Lightweight coding agent that runs in your terminal
Rust
Use native POSIX spawning for command hooks (#47610)
Charlie Marsh7aa65199098d
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex d9e4d8f039..825de0b06a 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -3589,6 +3589,7 @@ dependencies = ["codex-utils-path-uri","codex-utils-pty","futures",+ "libc","pretty_assertions","regex","schemars 0.8.22",diff --git a/codex-rs/hooks/Cargo.toml b/codex-rs/hooks/Cargo.tomlindex 0cdf84418a..cb234830aa 100644--- a/codex-rs/hooks/Cargo.toml+++ b/codex-rs/hooks/Cargo.toml@@ -32,6 +32,7 @@ tracing = { workspace = true }uuid = { workspace = true, features = ["v4"] }[dev-dependencies]+libc = { workspace = true }pretty_assertions = { workspace = true }tempfile = { workspace = true }tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }diff --git a/codex-rs/hooks/src/engine/command_runner.rs b/codex-rs/hooks/src/engine/command_runner.rsindex 36914c6287..d721500c17 100644--- a/codex-rs/hooks/src/engine/command_runner.rs+++ b/codex-rs/hooks/src/engine/command_runner.rs@@ -1,10 +1,10 @@use std::collections::HashMap;-#[cfg(not(windows))]use std::ffi::OsStr;use std::ffi::OsString;use std::future::Future;use std::io::ErrorKind;use std::path::Path;+#[cfg(not(unix))]use std::process::Stdio;use std::sync::Arc;use std::sync::Mutex;@@ -13,11 +13,14 @@ use std::time::Duration;use std::time::Instant;use async_channel::Sender;-use codex_protocol::shell_environment::scrub_non_inheritable_env_vars;+use codex_protocol::shell_environment::is_non_inheritable_env_var;+#[cfg(unix)]+use codex_utils_pty::Command;#[cfg(windows)]use codex_utils_pty::JobObject;use futures::future::try_join;use tokio::io::AsyncWriteExt;+#[cfg(not(unix))]use tokio::process::Command;use tokio::sync::Semaphore;use tokio::task::JoinSet;@@ -206,7 +209,7 @@ impl CommandHookRuntime {pub(crate) async fn run_command(runtime: &CommandHookRuntime,handler: &ConfiguredHandler,- command: &str,+ command_line: &str,env: &HashMap<String, String>,input_json: &str,cwd: &Path,@@ -214,21 +217,8 @@ pub(crate) async fn run_command(let started_at = chrono::Utc::now().timestamp();let started = Instant::now();- let mut command = build_command(&runtime.shell, command, &runtime.environment, env);- command- .current_dir(cwd)- .stdin(Stdio::piped())- .stdout(Stdio::piped())- .stderr(Stdio::piped())- .kill_on_drop(true);-- #[cfg(unix)]- // Keep process-group cleanup without inheriting the controlling terminal, where- // shell startup can otherwise stop the hook on background terminal I/O.- // SAFETY: detach_from_tty only performs async-signal-safe process setup.- unsafe {- command.pre_exec(codex_utils_pty::process_group::detach_from_tty);- }+ let mut command = build_command(&runtime.shell, command_line, &runtime.environment, env);+ command.current_dir(cwd);#[cfg(windows)]let mut process_tree_job = JobObject::create().ok();@@ -401,45 +391,60 @@ fn build_command(env: &HashMap<String, String>,) -> Command {let mut command = if shell.program.is_empty() {- default_shell_command(environment)+ Command::new(default_shell_program(environment))} else {Command::new(&shell.program)};if shell.program.is_empty() {#[cfg(windows)]- command.raw_arg(format!(r#""{command_line}""#));-+ command.arg("/C");#[cfg(not(windows))]- command.arg(command_line);+ command.arg("-lc");} else {command.args(&shell.args);-- #[cfg(windows)]- if shell.args.iter().any(|arg| arg.eq_ignore_ascii_case("/c")) {- command.raw_arg(format!(r#""{command_line}""#));- } else {- command.arg(command_line);- }-- #[cfg(not(windows))]+ }+ #[cfg(windows)]+ if shell.program.is_empty() || shell.args.iter().any(|arg| arg.eq_ignore_ascii_case("/c")) {+ command.raw_arg(format!(r#""{command_line}""#));+ } else {command.arg(command_line);}- // Replay the session snapshot instead of inheriting the live process environment.- command.env_clear();- command.envs(environment.iter().cloned());- command.envs(env);- scrub_non_inheritable_env_vars(command.as_std_mut());+ #[cfg(not(windows))]+ command.arg(command_line);++ #[cfg(unix)]+ command.process_mode(codex_utils_pty::ProcessMode::NewSession);+ #[cfg(not(unix))]+ command+ .env_clear()+ .stdin(Stdio::piped())+ .stdout(Stdio::piped())+ .stderr(Stdio::piped())+ .kill_on_drop(true);++ // Both launchers start with an empty environment. Replay the session snapshot+ // before hook overrides, filtering restricted names from both sources.+ command.envs(+ environment+ .iter()+ .map(|(key, value)| (key.as_os_str(), value.as_os_str()))+ .chain(+ env.iter()+ .map(|(key, value)| (OsStr::new(key), OsStr::new(value))),+ )+ .filter(|(key, _)| !key.to_str().is_some_and(is_non_inheritable_env_var)),+ );command}-fn default_shell_command(environment: &[(OsString, OsString)]) -> Command {+fn default_shell_program(environment: &[(OsString, OsString)]) -> OsString {#[cfg(windows)]- let (environment_variable, fallback_program, argument) = ("COMSPEC", "cmd.exe", "/C");+ let (environment_variable, fallback_program) = ("COMSPEC", "cmd.exe");#[cfg(not(windows))]- let (environment_variable, fallback_program, argument) = ("SHELL", "/bin/sh", "-lc");+ let (environment_variable, fallback_program) = ("SHELL", "/bin/sh");- let program = environment+ environment.iter().find(|(key, _)| {#[cfg(windows)]@@ -454,11 +459,7 @@ fn default_shell_command(environment: &[(OsString, OsString)]) -> Command {}}).map(|(_, value)| value.clone())- .unwrap_or_else(|| OsString::from(fallback_program));-- let mut command = Command::new(program);- command.arg(argument);- command+ .unwrap_or_else(|| OsString::from(fallback_program))}#[cfg(test)]diff --git a/codex-rs/hooks/src/engine/command_runner_tests.rs b/codex-rs/hooks/src/engine/command_runner_tests.rsindex d11da77656..1fb23b761c 100644--- a/codex-rs/hooks/src/engine/command_runner_tests.rs+++ b/codex-rs/hooks/src/engine/command_runner_tests.rs@@ -1,5 +1,4 @@use std::collections::HashMap;-use std::ffi::OsStr;use std::ffi::OsString;#[cfg(windows)]use std::fs;@@ -33,6 +32,7 @@ use super::CommandShell;use super::ConfiguredHandler;use super::MAX_CONCURRENT_ASYNC_HOOKS;use super::build_command;+use super::default_shell_program;use super::run_command;use crate::events::user_prompt_submit::UserPromptSubmitRequest;@@ -139,8 +139,60 @@ async fn hook_shell_startup_does_not_stop_on_controlling_terminal() {result_sender,);- let result = run_command(&runtime, &handler, command, &env, "{}", temp.path()).await;+ #[cfg(any(target_os = "linux", target_os = "macos"))]+ static FORKS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);+ #[cfg(any(target_os = "linux", target_os = "macos"))]+ {+ use std::sync::atomic::Ordering;+ extern "C" fn record_parent_fork() {+ FORKS.fetch_add(1, Ordering::SeqCst);+ }+ // Registration cannot be undone, so keep it in this isolated TTY child.+ // SAFETY: The callback only updates a lock-free atomic in the parent.+ assert_eq!(+ unsafe {+ libc::pthread_atfork(+ /*prepare*/ None,+ Some(record_parent_fork),+ /*child*/ None,+ )+ },+ 0+ );+ let mut baseline = tokio::process::Command::new("/bin/sh");+ baseline.args(["-c", "exit 0"]);+ // SAFETY: A no-op callback forces fork for the positive control.+ unsafe {+ baseline.pre_exec(|| Ok(()));+ }+ assert!(baseline.status().await.expect("fork control").success());+ assert_eq!(FORKS.load(Ordering::SeqCst), 1);+ }+ let result = run_command(&runtime, &handler, command, &env, "{}", temp.path()).await;+ #[cfg(any(target_os = "linux", target_os = "macos"))]+ {+ #[cfg(all(target_os = "linux", target_env = "gnu"))]+ let native_chdir_supported = {+ // SAFETY: Only inspect symbol availability, matching the launcher.+ !unsafe {+ libc::dlsym(+ libc::RTLD_DEFAULT,+ c"posix_spawn_file_actions_addchdir_np".as_ptr(),+ )+ }+ .is_null()+ };+ #[cfg(not(all(target_os = "linux", target_env = "gnu")))]+ let native_chdir_supported = true;+ if native_chdir_supported {+ assert_eq!(+ FORKS.load(std::sync::atomic::Ordering::SeqCst),+ 1,+ "hook must avoid forking its parent"+ );+ }+ }assert_eq!(result.exit_code, Some(0), "stderr: {}", result.stderr);assert_eq!(result.stdout, "hook-ran");assert_eq!(result.error, None);@@ -330,8 +382,8 @@ async fn command_hook_does_not_expose_configured_noise_auth_token() {assert_eq!(result.error, None);}-#[test]-fn build_command_replays_snapshot_before_hook_overrides_and_scrubbing() {+#[tokio::test]+async fn build_command_replays_snapshot_before_hook_overrides_and_scrubbing() {#[cfg(unix)]let non_unicode_value = OsString::from_vec(vec![b'v', 0xff]);let environment = vec![@@ -348,10 +400,7 @@ fn build_command_replays_snapshot_before_hook_overrides_and_scrubbing() {OsString::from("captured-noise-token"),),#[cfg(unix)]- (- OsString::from("CODEX_HOOK_NON_UNICODE"),- non_unicode_value.clone(),- ),+ (OsString::from("CODEX_HOOK_NON_UNICODE"), non_unicode_value),];let env = HashMap::from([("CODEX_HOOK_OVERRIDE".to_string(), "configured".to_string()),@@ -361,36 +410,45 @@ fn build_command_replays_snapshot_before_hook_overrides_and_scrubbing() {"configured-noise-token".to_string(),),]);+ #[cfg(not(windows))]+ let (program, args, command_line) = (+ "/bin/sh",+ vec!["-c".to_string()],+ "printf '%s\\n' \"$CODEX_HOOK_SNAPSHOT\" \"$CODEX_HOOK_OVERRIDE\" \"$CODEX_HOOK_SAFE_ENV\" \"${CODEX_EXEC_SERVER_NOISE_AUTH_TOKEN-absent}\" \"$CODEX_HOOK_NON_UNICODE\"",+ );+ #[cfg(windows)]+ let (program, args, command_line) = (+ "cmd.exe",+ vec!["/D".to_string(), "/C".to_string()],+ "echo %CODEX_HOOK_SNAPSHOT%&echo %CODEX_HOOK_OVERRIDE%&echo %CODEX_HOOK_SAFE_ENV%&if defined CODEX_EXEC_SERVER_NOISE_AUTH_TOKEN (echo leaked) else (echo absent)",+ );let command = build_command(&CommandShell {- program: "configured-shell".to_string(),- args: vec!["-c".to_string()],+ program: program.to_string(),+ args,},- "echo hook-ran",+ command_line,&environment,&env,);-- assert_eq!(- configured_environment_value(&command, "CODEX_HOOK_SNAPSHOT"),- Some(Some(OsString::from("captured")))- );- assert_eq!(- configured_environment_value(&command, "CODEX_HOOK_OVERRIDE"),- Some(Some(OsString::from("configured")))- );- assert_eq!(- configured_environment_value(&command, "CODEX_HOOK_SAFE_ENV"),- Some(Some(OsString::from("visible")))- );+ #[cfg(not(unix))]+ let mut command = command;+ let output = command+ .spawn()+ .expect("spawn hook")+ .wait_with_output()+ .await+ .expect("hook output");+ assert!(output.status.success(), "{output:?}");+ #[cfg(unix)]assert_eq!(- configured_environment_value(&command, CODEX_EXEC_SERVER_NOISE_AUTH_TOKEN_ENV_VAR),- None+ output.stdout,+ b"captured\nconfigured\nvisible\nabsent\nv\xff\n");- #[cfg(unix)]+ #[cfg(windows)]assert_eq!(- configured_environment_value(&command, "CODEX_HOOK_NON_UNICODE"),- Some(Some(non_unicode_value))+ output.stdout,+ b"captured\r\nconfigured\r\nvisible\r\nabsent\r\n");}@@ -400,25 +458,9 @@ fn fallback_shell_uses_snapshot() {let (name, program) = ("comspec", r"C:\captured\cmd.exe");#[cfg(not(windows))]let (name, program) = ("SHELL", "/captured/shell");- let command = build_command(- &CommandShell {- program: String::new(),- args: Vec::new(),- },- "echo hook-ran",- &[(OsString::from(name), OsString::from(program))],- &HashMap::new(),- );-- assert_eq!(command.as_std().get_program(), OsStr::new(program));- #[cfg(not(windows))]assert_eq!(- command- .as_std()- .get_args()- .map(OsStr::to_os_string)- .collect::<Vec<_>>(),- vec![OsString::from("-lc"), OsString::from("echo hook-ran")]+ default_shell_program(&[(OsString::from(name), OsString::from(program))]),+ OsString::from(program),);}@@ -445,17 +487,6 @@ fn runtime_with_environment((runtime, result_receiver)}-fn configured_environment_value(- command: &tokio::process::Command,- name: &str,-) -> Option<Option<OsString>> {- command- .as_std()- .get_envs()- .find(|(key, _)| *key == OsStr::new(name))- .map(|(_, value)| value.map(OsStr::to_os_string))-}-fn write_handler(temp: &TempDir, source: &str) -> ConfiguredHandler {let script_path = temp.path().join("async_hook.py");std::fs::write(&script_path, source).expect("write async test hook");@@ -693,3 +724,229 @@ print(json.dumps({{"shutdown must not deliver a late async result");}++#[cfg(unix)]+async fn process_is_running(pid: &str) -> bool {+ let output = tokio::process::Command::new("ps")+ .args(["-p", pid, "-o", "stat="])+ .output()+ .await+ .expect("inspect hook process state");+ assert!(output.stderr.is_empty(), "{output:?}");+ assert!(output.status.success() || output.status.code() == Some(1));+ String::from_utf8_lossy(&output.stdout)+ .split_whitespace()+ .any(|state| !state.starts_with('Z'))+}++#[cfg(unix)]+#[tokio::test]+async fn cancelled_and_timed_out_hooks_kill_their_process_group() {+ enum Termination {+ Cancellation,+ Timeout,+ }++ for termination in [Termination::Cancellation, Termination::Timeout] {+ let temp = tempdir().expect("create temp dir");+ let mut handler = write_handler(+ &temp,+ r#"import os+from pathlib import Path+import subprocess+import time++child = subprocess.Popen(['sleep', '60'])+Path('hook-pids.tmp').write_text(f'{os.getpid()} {child.pid}')+Path('hook-pids.tmp').rename('hook-pids')+time.sleep(60)+"#,+ );+ handler.timeout_sec = 2;+ let ConfiguredHandlerKind::Command { command, env, .. } = &handler.kind else {+ panic!("expected command hook");+ };+ let (mut runtime, _result_receiver) = runtime();+ runtime.shell.program = "/bin/sh".into();+ runtime.shell.args = vec!["-c".into()];+ let mut run = Box::pin(run_command(+ &runtime,+ &handler,+ command,+ env,+ "{}",+ temp.path(),+ ));+ let pids = timeout(Duration::from_secs(10), async {+ loop {+ if let Ok(pids) = std::fs::read_to_string(temp.path().join("hook-pids")) {+ break pids;+ }+ tokio::select! {+ result = &mut run => panic!("hook exited before cancellation: {result:?}"),+ _ = sleep(Duration::from_millis(10)) => {}+ }+ }+ })+ .await+ .expect("hook and descendant must start");+ match termination {+ Termination::Cancellation => drop(run),+ Termination::Timeout => {+ let result = timeout(Duration::from_secs(10), run)+ .await+ .expect("hook timeout completes");+ assert_eq!(result.error, Some("hook timed out after 2s".to_string()));+ }+ }+ timeout(Duration::from_secs(10), async {+ loop {+ let mut all_stopped = true;+ for pid in pids.split_whitespace() {+ all_stopped &= !process_is_running(pid).await;+ }+ if all_stopped {+ break;+ }+ sleep(Duration::from_millis(10)).await;+ }+ })+ .await+ .expect("cancellation and timeout must stop both hook and descendant");+ }+}++#[cfg(unix)]+#[tokio::test]+async fn completed_hook_preserves_background_descendant() {+ for exit_code in [0, 23] {+ let temp = tempdir().expect("create temp dir");+ let handler = write_handler(+ &temp,+ &format!(+ r#"import subprocess++subprocess.Popen(+ ['sh', '-c', 'i=0; while [ ! -f release-descendant ] && [ "$i" -lt 500 ]; do sleep 0.01; i=$((i + 1)); done; printf survived > descendant-result.tmp; mv descendant-result.tmp descendant-result'],+ stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)+raise SystemExit({exit_code})+"#+ ),+ );+ let ConfiguredHandlerKind::Command { command, env, .. } = &handler.kind else {+ panic!("expected command hook");+ };+ let (mut runtime, _result_receiver) = runtime();+ runtime.shell.program = "/bin/sh".into();+ runtime.shell.args = vec!["-c".into()];+ let result = run_command(&runtime, &handler, command, env, "{}", temp.path()).await;+ // Release even on a failed assertion so a failed test does not leak a waiter.+ std::fs::write(temp.path().join("release-descendant"), "").expect("release descendant");+ assert_eq!((result.exit_code, result.error), (Some(exit_code), None));+ let result_path = temp.path().join("descendant-result");+ timeout(Duration::from_secs(10), async {+ while !result_path.exists() {+ sleep(Duration::from_millis(10)).await;+ }+ })+ .await+ .expect("completed hook must leave its descendant running");+ assert_eq!(std::fs::read_to_string(result_path).unwrap(), "survived");+ }+}++#[cfg(unix)]+#[tokio::test]+async fn exited_hook_leader_with_open_descendant_output_still_times_out() {+ let temp = tempdir().expect("create temp dir");+ let mut handler = write_handler(+ &temp,+ r#"from pathlib import Path+import subprocess++child = subprocess.Popen(['sleep', '60'])+Path('descendant-pid').write_text(str(child.pid))+"#,+ );+ handler.timeout_sec = 2;+ let ConfiguredHandlerKind::Command { command, env, .. } = &handler.kind else {+ panic!("expected command hook");+ };+ let (mut runtime, _result_receiver) = runtime();+ runtime.shell.program = "/bin/sh".into();+ runtime.shell.args = vec!["-c".into()];+ let result = run_command(&runtime, &handler, command, env, "{}", temp.path()).await;+ assert_eq!(result.error, Some("hook timed out after 2s".to_string()));+ let pid = std::fs::read_to_string(temp.path().join("descendant-pid"))+ .expect("descendant started before its parent exited");+ timeout(Duration::from_secs(10), async {+ while process_is_running(pid.trim()).await {+ sleep(Duration::from_millis(10)).await;+ }+ })+ .await+ .expect("hook timeout must stop the descendant after the leader exits");+}++#[cfg(unix)]+#[tokio::test]+async fn hook_rejects_nul_arguments_before_execution() {+ for nul_in_shell_args in [false, true] {+ let root = tempdir().expect("tempdir");+ let (mut runtime, _receiver) = runtime();+ runtime.shell = CommandShell {+ program: "/usr/bin/touch".to_string(),+ args: if nul_in_shell_args {+ vec!["bad\0arg".to_string()]+ } else {+ Vec::new()+ },+ };+ let command = if nul_in_shell_args { "ran" } else { "bad\0arg" };+ let handler = write_handler(&root, "");+ let result = run_command(+ &runtime,+ &handler,+ command,+ &HashMap::new(),+ "",+ root.path(),+ )+ .await;+ assert!(result.error.is_some(), "invalid hook ran: {result:?}");+ assert_eq!(result.exit_code, None);+ assert!(!root.path().join("ran").exists());+ assert!(!root.path().join("<string-with-nul>").exists());+ }+}++#[cfg(unix)]+#[tokio::test]+async fn hook_rejects_nul_in_configured_and_default_shell_program() {+ for configured in [false, true] {+ let root = tempdir().expect("tempdir");+ let (mut runtime, _receiver) = runtime_with_environment(Arc::new(vec![(+ OsString::from("SHELL"),+ OsString::from("/bin/sh\0"),+ )]));+ if configured {+ runtime.shell.program = "/bin/sh\0".to_string();+ }+ let handler = write_handler(&root, "");+ let result = run_command(+ &runtime,+ &handler,+ "printf ran > ran",+ &HashMap::new(),+ "",+ root.path(),+ )+ .await;+ assert_eq!(+ result.error.as_deref(),+ Some("nul byte found in provided data")+ );+ assert_eq!(result.exit_code, None);+ assert!(!root.path().join("ran").exists());+ }+}diff --git a/codex-rs/utils/pty/src/child.rs b/codex-rs/utils/pty/src/child.rsindex d9a8365e9b..dfb6ff2bf4 100644--- a/codex-rs/utils/pty/src/child.rs+++ b/codex-rs/utils/pty/src/child.rs@@ -11,9 +11,9 @@ use tokio::process::ChildStderr;use tokio::process::ChildStdin;use tokio::process::ChildStdout;-#[cfg(target_os = "macos")]-#[path = "macos_child.rs"]-pub(super) mod macos;+#[cfg(any(target_os = "macos", target_os = "linux"))]+#[path = "posix_child.rs"]+pub(super) mod posix;#[cfg(unix)]#[path = "child_reaper.rs"]@@ -34,8 +34,8 @@ pub(super) enum ChildKind {child: Option<tokio::process::Child>,reaper: std::sync::mpsc::Sender<reaper::ChildToReap>,},- #[cfg(target_os = "macos")]- Native(macos::NativeChild),+ #[cfg(any(target_os = "macos", target_os = "linux"))]+ Native(posix::NativeChild),}impl Child {@@ -46,7 +46,7 @@ impl Child {ChildKind::TokioReapOnly { child, .. } => {child.as_ref().and_then(tokio::process::Child::id)}- #[cfg(target_os = "macos")]+ #[cfg(any(target_os = "macos", target_os = "linux"))]ChildKind::Native(child) => child.id(),}}@@ -64,7 +64,7 @@ impl Child {.wait().await}- #[cfg(target_os = "macos")]+ #[cfg(any(target_os = "macos", target_os = "linux"))]ChildKind::Native(child) => child.wait().await,}}@@ -114,7 +114,7 @@ impl Child {.kill().await}- #[cfg(target_os = "macos")]+ #[cfg(any(target_os = "macos", target_os = "linux"))]ChildKind::Native(child) => child.kill().await,}}diff --git a/codex-rs/utils/pty/src/child_command.rs b/codex-rs/utils/pty/src/child_command.rsindex 7207351314..ad5d6ee118 100644--- a/codex-rs/utils/pty/src/child_command.rs+++ b/codex-rs/utils/pty/src/child_command.rs@@ -234,7 +234,7 @@ impl Command {Ok(())}- /// Launch with native macOS path handling and the existing compatibility fallback.+ /// Launch with native platform settings and the existing compatibility fallback.pub fn spawn(mut self) -> io::Result<Child> {#[cfg(unix)]self.validate()?;@@ -242,17 +242,22 @@ impl Command {if let ProcessMode::NewGroup = self.process_mode {self.inner.process_group(/*pgroup*/ 0);}- #[cfg(target_os = "macos")]+ #[cfg(any(target_os = "macos", target_os = "linux"))]{let command = self.inner.as_std();let program = command.get_program();- if (Path::new(program).is_relative()+ #[cfg(target_os = "macos")]+ let use_native = Path::new(program).is_relative()|| self.descriptor_policy == DescriptorPolicy::Explicit|| self.fallback == SpawnFallback::ReturnError|| matches!(self.process_mode, ProcessMode::NewSession)- || !self.inherited_fds.is_empty())+ || !self.inherited_fds.is_empty();+ #[cfg(target_os = "linux")]+ let use_native =+ matches!(self.process_mode, ProcessMode::NewSession) && self.parent_pid.is_none();+ if use_native&& !program.is_empty()- && let Some(child) = crate::child::macos::NativeChild::spawn(&self)?+ && let Some(child) = crate::child::posix::NativeChild::spawn(&self)?{return Ok(child);}@@ -331,3 +336,7 @@ mod tests;#[cfg(all(test, target_os = "macos"))]#[path = "macos_descriptor_tests.rs"]mod descriptor_tests;++#[cfg(all(test, target_os = "linux"))]+#[path = "linux_child_tests.rs"]+mod linux_tests;diff --git a/codex-rs/utils/pty/src/child_reaper.rs b/codex-rs/utils/pty/src/child_reaper.rsindex 3fb871769a..46f25ade9a 100644--- a/codex-rs/utils/pty/src/child_reaper.rs+++ b/codex-rs/utils/pty/src/child_reaper.rs@@ -5,7 +5,7 @@//! ownership until reaped, so one live child cannot delay cleanup of another.use std::io;-#[cfg(target_os = "macos")]+#[cfg(any(target_os = "macos", target_os = "linux"))]use std::ptr;use std::sync::Mutex;use std::sync::PoisonError;@@ -14,7 +14,7 @@ use std::time::Duration;/// Exclusive ownership transferred by a child handle after its caller drops it.pub(crate) enum ChildToReap {- #[cfg(target_os = "macos")]+ #[cfg(any(target_os = "macos", target_os = "linux"))]Native(libc::pid_t),Tokio(tokio::process::Child),}@@ -47,7 +47,7 @@ pub(crate) fn sender() -> io::Result<mpsc::Sender<ChildToReap>> {// Amortize scans across bursts without starving reaping when drops continue.pending.extend(receiver.try_iter().take(REAP_BATCH_SIZE - 1));pending.retain_mut(|child| match child {- #[cfg(target_os = "macos")]+ #[cfg(any(target_os = "macos", target_os = "linux"))]ChildToReap::Native(pid) => {// SAFETY: Drop transferred exclusive ownership of this PID.let result = unsafe { libc::waitpid(*pid, ptr::null_mut(), libc::WNOHANG) };diff --git a/codex-rs/utils/pty/src/child_tests.rs b/codex-rs/utils/pty/src/child_tests.rsindex b3dedb376e..452e34374c 100644--- a/codex-rs/utils/pty/src/child_tests.rs+++ b/codex-rs/utils/pty/src/child_tests.rs@@ -12,6 +12,7 @@ use tokio::io::AsyncReadExt;use tokio::io::AsyncWriteExt;use crate::Command;+use crate::ProcessMode;#[tokio::test]async fn wait_with_output_keeps_eof_pipes_open_until_exit() -> anyhow::Result<()> {@@ -329,3 +330,76 @@ async fn preserving_descriptors_keeps_parent_record_locks() -> anyhow::Result<()assert!(output.status.success(), "{output:?}");Ok(())}++#[tokio::test]+async fn detached_spawn_preserves_child_path_cwd_environment_and_arg0() -> anyhow::Result<()> {+ let root = tempfile::tempdir()?;+ std::fs::create_dir(root.path().join("bin"))?;+ std::os::unix::fs::symlink("/bin/sh", root.path().join("bin/child-shell"))?;+ let mut command = Command::new("child-shell");+ command+ .current_dir(root.path())+ .env("PATH", "bin")+ .env("MARKER", "child-value")+ .arg0("custom-shell")+ .args(["-c", "printf '%s|%s|' \"$0\" \"$MARKER\"; pwd; read -r line; printf '%s' \"$line\"; printf diagnostic >&2"])+ .process_mode(ProcessMode::NewSession);+ let mut child = command.spawn()?;+ child+ .stdin+ .take()+ .expect("piped stdin")+ .write_all(b"input\n")+ .await?;+ assert_eq!(+ child.wait_with_output().await?,+ std::process::Output {+ status: std::process::ExitStatus::from_raw(0),+ stdout: format!(+ "custom-shell|child-value|{}\ninput",+ root.path().canonicalize()?.display()+ )+ .into_bytes(),+ stderr: b"diagnostic".to_vec(),+ }+ );+ Ok(())+}++#[tokio::test]+async fn detached_spawn_preserves_exec_errors_and_executable_text_handling() -> anyhow::Result<()> {+ use std::os::unix::fs::PermissionsExt;++ let root = tempfile::tempdir()?;+ let program = root.path().join("script");+ let mut missing = Command::new(&program);+ missing.process_mode(ProcessMode::NewSession);+ let error = missing.spawn().err().expect("missing executable must fail");+ assert_eq!(error.kind(), std::io::ErrorKind::NotFound);++ std::fs::write(&program, "printf '%s' \"$1\"")?;+ std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755))?;+ // Match the existing libc behavior: glibc/macOS retry executable text through+ // a shell, whereas musl returns ENOEXEC.+ let mut baseline = tokio::process::Command::new(&program);+ baseline.env_clear().arg("shell fallback");+ // SAFETY: The legacy route only performs async-signal-safe session setup.+ unsafe {+ baseline.pre_exec(crate::process_group::detach_from_tty);+ }+ let expected = baseline.output().await;+ let mut script = Command::new(&program);+ script+ .arg("shell fallback")+ .process_mode(ProcessMode::NewSession);+ let actual = match script.spawn() {+ Ok(child) => child.wait_with_output().await,+ Err(error) => Err(error),+ };+ let error_details = |error: std::io::Error| (error.kind(), error.raw_os_error());+ assert_eq!(+ actual.map_err(error_details),+ expected.map_err(error_details)+ );+ Ok(())+}diff --git a/codex-rs/utils/pty/src/linux_child_tests.rs b/codex-rs/utils/pty/src/linux_child_tests.rsnew file mode 100644index 0000000000..dd36e1772d--- /dev/null+++ b/codex-rs/utils/pty/src/linux_child_tests.rs@@ -0,0 +1,63 @@+//! Linux executable lookup must match the compatibility launcher's PATH semantics.++use std::os::unix::fs::PermissionsExt;++use pretty_assertions::assert_eq;++use crate::Command;+use crate::ProcessMode;++#[tokio::test]+async fn path_search_stops_at_invalid_candidates() -> anyhow::Result<()> {+ let root = tempfile::tempdir()?;+ std::fs::create_dir(root.path().join("bin"))?;+ std::os::unix::fs::symlink("loop", root.path().join("loop"))?;+ let script = root.path().join("bin/server");+ std::fs::write(&script, "#!/bin/sh\nprintf later\n")?;+ std::fs::set_permissions(script, std::fs::Permissions::from_mode(/*mode*/ 0o755))?;+ for candidate in ["loop".to_owned(), "x".repeat(256)] {+ let mut command = Command::new("server");+ command+ .current_dir(root.path())+ .env("PATH", format!("{candidate}:bin"));+ let expected = command+ .inner+ .spawn()+ .expect_err("invalid first candidate must stop lookup");+ command.process_mode(ProcessMode::NewSession);+ let actual = command.spawn().err().expect("native lookup must stop too");+ assert_eq!(actual.raw_os_error(), expected.raw_os_error());+ }+ Ok(())+}++#[tokio::test]+async fn empty_path_entries_preserve_script_argv0() -> anyhow::Result<()> {+ // A sibling test can fork while the script is open for writing, retaining+ // the writable descriptor and making exec fail with ETXTBSY.+ if std::env::var_os("CODEX_TEST_PATH_ARGV0").is_none() {+ let output = std::process::Command::new(std::env::current_exe()?)+ .args([+ "--exact",+ "child_command::linux_tests::empty_path_entries_preserve_script_argv0",+ "--nocapture",+ ])+ .env("CODEX_TEST_PATH_ARGV0", "1")+ .output()?;+ assert!(output.status.success(), "{output:?}");+ return Ok(());+ }+ let root = tempfile::tempdir()?;+ let script = root.path().join("server");+ std::fs::write(&script, "#!/bin/sh\nprintf '%s' \"$0\"\n")?;+ std::fs::set_permissions(script, std::fs::Permissions::from_mode(/*mode*/ 0o755))?;+ for path in ["", ":missing", "missing:", ".", "./"] {+ let mut command = Command::new("server");+ command.current_dir(root.path()).env("PATH", path);+ let expected = command.inner.output().await?;+ command.process_mode(ProcessMode::NewSession);+ let actual = command.spawn()?.wait_with_output().await?;+ assert_eq!(actual, expected);+ }+ Ok(())+}diff --git a/codex-rs/utils/pty/src/macos_child_tests.rs b/codex-rs/utils/pty/src/macos_child_tests.rsindex b2a29876ff..ad41af3880 100644--- a/codex-rs/utils/pty/src/macos_child_tests.rs+++ b/codex-rs/utils/pty/src/macos_child_tests.rs@@ -2,7 +2,7 @@use super::*;use crate::child::ChildKind;-use crate::child::macos::*;+use crate::child::posix::*;use pretty_assertions::assert_eq;use std::fs;use std::os::fd::AsRawFd;diff --git a/codex-rs/utils/pty/src/macos_child.rs b/codex-rs/utils/pty/src/posix_child.rssimilarity index 76%rename from codex-rs/utils/pty/src/macos_child.rsrename to codex-rs/utils/pty/src/posix_child.rsindex 7d3f5a34d0..5ef37588c7 100644--- a/codex-rs/utils/pty/src/macos_child.rs+++ b/codex-rs/utils/pty/src/posix_child.rs@@ -1,13 +1,15 @@-//! Native macOS spawning without rewriting executable paths or argv[0].+//! Native POSIX spawning without rewriting executable paths or argv[0].//!//! Spawn attributes and file actions implement the shared command's process-group//! and descriptor policies. Bare commands search the child's PATH. Callers choose//! whether incompatible executable formats and failed searches may retry through-//! Tokio. Each native child owns its PID until it has been reaped.+//! Tokio. Linux uses this for detached sessions with ambient descriptor inheritance.+//! Each native child owns its PID until it has been reaped.use std::ffi::CString;use std::ffi::OsStr;use std::io;+use std::mem::MaybeUninit;use std::os::fd::AsRawFd;use std::os::fd::FromRawFd;use std::os::fd::OwnedFd;@@ -27,12 +29,15 @@ use crate::child_command::ChildDropPolicy;use crate::child::reaper;-// Apple's spawn.h defines this extension on our minimum macOS 12, but libc-// does not expose it. A new session also creates a new process group.+#[cfg(target_os = "linux")]+use libc::POSIX_SPAWN_SETSID;+// Apple exposes this extension in spawn.h, but libc does not yet bind it.+#[cfg(target_os = "macos")]const POSIX_SPAWN_SETSID: libc::c_int = 0x0400;-// libc does not expose this Apple extension. It is available since macOS 10.15,-// before Codex's minimum supported macOS version (12).+// Available since macOS 10.15 and in Rust's bundled musl. Older glibc needs+// runtime detection so this optimization does not raise our minimum libc version.+#[cfg(any(target_os = "macos", target_env = "musl"))]unsafe extern "C" {fn posix_spawn_file_actions_addchdir_np(actions: *mut libc::posix_spawn_file_actions_t,@@ -51,10 +56,25 @@ pub(crate) struct NativeChild {impl NativeChild {/// Spawn the explicit command, retaining the caller's executable spelling and argv[0].+ /// Returns `Ok(None)` when native setup is unsupported or execution needs the+ /// caller's compatibility fallback.pub(crate) fn spawn(request: &crate::Command) -> io::Result<Option<crate::Child>> {+ #[cfg(target_os = "linux")]+ if request.descriptor_policy != crate::DescriptorPolicy::Inherit {+ return Ok(None);+ }let command = request.inner.as_std();let program = c_string(command.get_program())?;let search_path = !program.as_bytes().contains(&b'/');+ #[cfg(target_os = "linux")]+ if search_path+ && !command+ .get_envs()+ .any(|(key, value)| key == "PATH" && value.is_some())+ {+ // Preserve the libc-specific default search path in the fallback.+ return Ok(None);+ }let args = std::iter::once(request.arg0.as_deref().unwrap_or(command.get_program())).chain(command.get_args()).map(c_string)@@ -90,6 +110,31 @@ impl NativeChild {ChildDropPolicy::ReapOnly => Some(reaper::sender()?),};+ #[cfg(all(target_os = "linux", target_env = "gnu"))]+ let addchdir = {+ // SAFETY: dlsym returns the documented function signature when present.+ let symbol = unsafe {+ libc::dlsym(+ libc::RTLD_DEFAULT,+ c"posix_spawn_file_actions_addchdir_np".as_ptr(),+ )+ };+ if symbol.is_null() {+ return Ok(None);+ }+ unsafe {+ std::mem::transmute::<+ *mut libc::c_void,+ unsafe extern "C" fn(+ *mut libc::posix_spawn_file_actions_t,+ *const libc::c_char,+ ) -> libc::c_int,+ >(symbol)+ }+ };+ #[cfg(any(target_os = "macos", target_env = "musl"))]+ let addchdir = posix_spawn_file_actions_addchdir_np;+// Subscribe before spawning so a child that exits immediately cannot be missed.let sigchld = signal(SignalKind::child())?;let (stdin_read, stdin) = match &request.stdin {@@ -113,19 +158,20 @@ impl NativeChild {let stdout = ChildStdout::from_std(OwnedFd::from(stdout_read).into())?;let stderr = ChildStderr::from_std(OwnedFd::from(stderr_read).into())?;- let mut actions = FileActions(ptr::null_mut());- let mut attrs = Attributes(ptr::null_mut());+ let mut actions = MaybeUninit::uninit();+ // SAFETY: Successful initialization makes each object valid; RAII only+ // takes ownership after that success, including if the next init fails.+ cvt(unsafe { libc::posix_spawn_file_actions_init(actions.as_mut_ptr()) })?;+ let mut actions = FileActions(unsafe { actions.assume_init() });+ let mut attrs = MaybeUninit::uninit();+ cvt(unsafe { libc::posix_spawnattr_init(attrs.as_mut_ptr()) })?;+ let mut attrs = Attributes(unsafe { attrs.assume_init() });let mut pid = 0;// SAFETY: All C strings and pipe descriptors outlive this synchronous// spawn. The initialized action/attribute objects are destroyed by RAII.let result = unsafe {- cvt(libc::posix_spawn_file_actions_init(&mut actions.0))?;- cvt(libc::posix_spawnattr_init(&mut attrs.0))?;if let Some(cwd) = &cwd {- cvt(posix_spawn_file_actions_addchdir_np(- &mut actions.0,- cwd.as_ptr(),- ))?;+ cvt(addchdir(&mut actions.0, cwd.as_ptr()))?;}for (target, source) in child_fds.iter().enumerate() {cvt(libc::posix_spawn_file_actions_adddup2(@@ -146,7 +192,6 @@ impl NativeChild {}let group_flags = match request.process_mode {crate::ProcessMode::Inherit => 0,- crate::ProcessMode::NewSession => POSIX_SPAWN_SETSID,crate::ProcessMode::NewGroup => {cvt(libc::posix_spawnattr_setpgroup(&mut attrs.0,@@ -154,19 +199,28 @@ impl NativeChild {))?;libc::POSIX_SPAWN_SETPGROUP}+ crate::ProcessMode::NewSession => POSIX_SPAWN_SETSID,};- let mut defaults = 0;+ let mut defaults = std::mem::zeroed();cvt_errno(libc::sigemptyset(&mut defaults))?;cvt_errno(libc::sigaddset(&mut defaults, libc::SIGPIPE))?;cvt(libc::posix_spawnattr_setsigdefault(&mut attrs.0, &defaults))?;+ #[cfg(target_os = "macos")]let descriptor_flags = match request.descriptor_policy {crate::DescriptorPolicy::Inherit => 0,crate::DescriptorPolicy::Explicit => libc::POSIX_SPAWN_CLOEXEC_DEFAULT,};- cvt(libc::posix_spawnattr_setflags(+ #[cfg(target_os = "linux")]+ let descriptor_flags = 0;+ let result = libc::posix_spawnattr_setflags(&mut attrs.0,(group_flags | descriptor_flags | libc::POSIX_SPAWN_SETSIGDEF) as _,- ))?;+ );+ // Unsupported attributes fail before posix_spawn can select its fallback.+ if result == libc::EINVAL && request.fallback == crate::SpawnFallback::Compatible {+ return Ok(None);+ }+ cvt(result)?;let mut spawn = |executable: &CString| {libc::posix_spawn(&mut pid,@@ -190,12 +244,15 @@ impl NativeChild {let mut result = libc::ENOENT;for directory in std::env::split_paths(path) {let mut executable = directory.into_os_string();+ #[cfg(target_os = "macos")]if executable.is_empty() {executable.push(".");}// Preserve the spelling execvp would pass to a shebang// interpreter, including empty entries and trailing slashes.- executable.push("/");+ if !executable.is_empty() {+ executable.push("/");+ }executable.push(command.get_program());if executable.as_bytes().len() >= libc::PATH_MAX as usize {return if request.fallback == crate::SpawnFallback::Compatible {@@ -205,15 +262,13 @@ impl NativeChild {};}result = spawn(&c_string(&executable)?);- if !matches!(- result,- libc::ENOENT- | libc::ENOTDIR- | libc::EACCES- | libc::ELOOP- | libc::ENAMETOOLONG- ) {- break;+ match result {+ libc::ENOENT | libc::ENOTDIR | libc::EACCES => {}+ #[cfg(target_os = "macos")]+ libc::ELOOP | libc::ENAMETOOLONG => {}+ #[cfg(all(target_os = "linux", target_env = "gnu"))]+ libc::ESTALE | libc::ENODEV | libc::ETIMEDOUT => {}+ _ => break,}}result@@ -221,7 +276,10 @@ impl NativeChild {};// Retain Command's shell fallback and exact PATH search errors.if request.fallback == crate::SpawnFallback::Compatible- && (result == libc::ENOEXEC || (search_path && result != 0))+ && (result == libc::ENOEXEC+ || (search_path && result != 0)+ || (matches!(request.process_mode, crate::ProcessMode::NewSession)+ && matches!(result, libc::EINVAL | libc::EPERM))){return Ok(None);}@@ -380,22 +438,18 @@ struct Attributes(libc::posix_spawnattr_t);impl Drop for FileActions {fn drop(&mut self) {- if !self.0.is_null() {- // SAFETY: This object was initialized by posix_spawn_file_actions_init.- unsafe {- libc::posix_spawn_file_actions_destroy(&mut self.0);- }+ // SAFETY: This object was initialized by posix_spawn_file_actions_init.+ unsafe {+ libc::posix_spawn_file_actions_destroy(&mut self.0);}}}impl Drop for Attributes {fn drop(&mut self) {- if !self.0.is_null() {- // SAFETY: This object was initialized by posix_spawnattr_init.- unsafe {- libc::posix_spawnattr_destroy(&mut self.0);- }+ // SAFETY: This object was initialized by posix_spawnattr_init.+ unsafe {+ libc::posix_spawnattr_destroy(&mut self.0);}}}