[codex] Carry exec-server cwd as PathUri (#28032)

## Why

This is the second-to-last place in the exec-server protocol that needs
to migrate to URIs to support cross-OS operation.

## What

- Change `ExecParams.cwd` to `PathUri`.
- Keep the cwd URI-shaped through core and rmcp producers, converting it
to `AbsolutePathBuf` only in `LocalProcess::start_process`.
- Reject non-native cwd URIs before launch and update the affected
protocol documentation and call sites.

codex-rs/exec-server/src/environment.rs

@@ -498,6 +498,7 @@ mod tests {
     use crate::ProcessId;
     use crate::environment_provider::EnvironmentDefault;
     use crate::environment_provider::EnvironmentProviderSnapshot;
+    use codex_utils_path_uri::PathUri;
     use pretty_assertions::assert_eq;
 
     fn test_runtime_paths() -> ExecServerRuntimePaths {
@@ -862,7 +863,8 @@ mod tests {
             .start(crate::ExecParams {
                 process_id: ProcessId::from("default-env-proc"),
                 argv: vec!["true".to_string()],
-                cwd: std::env::current_dir().expect("read current dir"),
+                cwd: PathUri::from_path(std::env::current_dir().expect("read current dir"))
+                    .expect("cwd URI"),
                 env_policy: None,
                 env: Default::default(),
                 tty: false,

codex-rs/exec-server/src/local_process.rs

@@ -156,6 +156,12 @@ impl LocalProcess {
             .argv
             .split_first()
             .ok_or_else(|| invalid_params("argv must not be empty".to_string()))?;
+        let native_cwd = params.cwd.to_abs_path().map_err(|err| {
+            invalid_params(format!(
+                "cwd URI `{}` is not valid on this exec-server host: {err}",
+                params.cwd
+            ))
+        })?;
 
         {
             let mut process_map = self.inner.processes.lock().await;
@@ -172,7 +178,7 @@ impl LocalProcess {
             codex_utils_pty::spawn_pty_process(
                 program,
                 args,
-                params.cwd.as_path(),
+                native_cwd.as_path(),
                 &env,
                 &params.arg0,
                 TerminalSize::default(),
@@ -182,7 +188,7 @@ impl LocalProcess {
             codex_utils_pty::spawn_pipe_process(
                 program,
                 args,
-                params.cwd.as_path(),
+                native_cwd.as_path(),
                 &env,
                 &params.arg0,
             )
@@ -191,7 +197,7 @@ impl LocalProcess {
             codex_utils_pty::spawn_pipe_process_no_stdin(
                 program,
                 args,
-                params.cwd.as_path(),
+                native_cwd.as_path(),
                 &env,
                 &params.arg0,
             )
@@ -783,6 +789,7 @@ fn notification_sender(inner: &Inner) -> Option<RpcNotificationSender> {
 mod tests {
     use super::*;
     use codex_protocol::config_types::ShellEnvironmentPolicyInherit;
+    use codex_utils_path_uri::PathUri;
     use codex_utils_pty::ProcessDriver;
     use pretty_assertions::assert_eq;
     use tokio::sync::oneshot;
@@ -792,7 +799,7 @@ mod tests {
         ExecParams {
             process_id: ProcessId::from("env-test"),
             argv: vec!["true".to_string()],
-            cwd: std::path::PathBuf::from("/tmp"),
+            cwd: PathUri::from_path(std::env::current_dir().expect("cwd")).expect("cwd URI"),
             env_policy: None,
             env,
             tty: false,
@@ -801,6 +808,30 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn start_process_rejects_non_native_cwd_before_launch() {
+        #[cfg(unix)]
+        let uri = "file://server/share/checkout";
+        #[cfg(windows)]
+        let uri = "file:///usr/local/checkout";
+        let cwd = PathUri::parse(uri).expect("non-native cwd URI");
+        let source = cwd
+            .to_abs_path()
+            .expect_err("cwd should not be native to this host");
+        let expected = invalid_params(format!(
+            "cwd URI `{cwd}` is not valid on this exec-server host: {source}"
+        ));
+        let mut params = test_exec_params(HashMap::new());
+        params.cwd = cwd;
+
+        let result = LocalProcess::default().start_process(params).await;
+        let Err(error) = result else {
+            panic!("non-native cwd should be rejected");
+        };
+
+        assert_eq!(error, expected);
+    }
+
     #[test]
     fn child_env_defaults_to_exact_env() {
         let params = test_exec_params(HashMap::from([("ONLY_THIS".to_string(), "1".to_string())]));

codex-rs/exec-server/src/protocol.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::path::PathBuf;
 
 use crate::FileSystemSandboxContext;
 use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
@@ -77,7 +76,8 @@ pub struct EnvironmentInfo {
 pub struct ShellInfo {
     /// Stable shell name, for example `zsh`, `bash`, `powershell`, `sh`, or `cmd`.
     pub name: String,
-    /// Path the exec server would use for that shell.
+    /// Target-native shell executable path or command name. Fallbacks such as `cmd.exe` need not
+    /// be absolute, so this is not a [`PathUri`].
     pub path: String,
 }
 
@@ -88,7 +88,8 @@ pub struct ExecParams {
     /// This is a protocol key, not an OS pid.
     pub process_id: ProcessId,
     pub argv: Vec<String>,
-    pub cwd: PathBuf,
+    /// Working directory URI, interpreted using the exec-server host's path rules at launch time.
+    pub cwd: PathUri,
     #[serde(default)]
     pub env_policy: Option<ExecEnvPolicy>,
     pub env: HashMap<String, String>,
@@ -96,6 +97,8 @@ pub struct ExecParams {
     /// Keep non-tty stdin writable through `process/write`.
     #[serde(default)]
     pub pipe_stdin: bool,
+    /// Optional process-visible argv0 override. Values such as `codex-linux-sandbox` are command
+    /// names rather than paths, so this is not a [`PathUri`].
     pub arg0: Option<String>,
 }
 

codex-rs/exec-server/src/server/handler/tests.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 
+use codex_utils_path_uri::PathUri;
 use pretty_assertions::assert_eq;
 use tokio::sync::mpsc;
 use uuid::Uuid;
@@ -26,7 +27,7 @@ fn exec_params_with_argv(process_id: &str, argv: Vec<String>) -> ExecParams {
     ExecParams {
         process_id: ProcessId::from(process_id),
         argv,
-        cwd: std::env::current_dir().expect("cwd"),
+        cwd: PathUri::from_path(std::env::current_dir().expect("cwd")).expect("cwd URI"),
         env_policy: None,
         env: inherited_path_env(),
         tty: false,

codex-rs/exec-server/src/server/processor.rs

@@ -195,6 +195,7 @@ mod tests {
     use codex_app_server_protocol::JSONRPCRequest;
     use codex_app_server_protocol::JSONRPCResponse;
     use codex_app_server_protocol::RequestId;
+    use codex_utils_path_uri::PathUri;
     use serde::Serialize;
     use serde::de::DeserializeOwned;
     use tokio::io::AsyncBufReadExt;
@@ -396,7 +397,7 @@ mod tests {
         ExecParams {
             process_id,
             argv: sleep_then_print_argv(),
-            cwd: std::env::current_dir().expect("cwd"),
+            cwd: PathUri::from_path(std::env::current_dir().expect("cwd")).expect("cwd URI"),
             env_policy: None,
             env,
             tty: false,