Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Bound local exec-server output draining after process exit (#52652)

jif89c8759d8c49
diff --git a/codex-rs/core/src/unified_exec/mod_tests.rs b/codex-rs/core/src/unified_exec/mod_tests.rs
index 3bc0ad0189..20f2236668 100644
--- a/codex-rs/core/src/unified_exec/mod_tests.rs
+++ b/codex-rs/core/src/unified_exec/mod_tests.rs
@@ -1,3 +1,4 @@
+use super::process::OutputDrainPolicy;
use super::*;
use crate::codex_thread::BackgroundTerminalInfo;
use crate::exec::ExecCapturePolicy;
@@ -291,15 +292,18 @@ async fn blocking_terminate_unified_process(
) -> anyhow::Result<Arc<UnifiedExecProcess>> {
let (wake_tx, _wake_rx) = watch::channel(0);
Ok(Arc::new(
- UnifiedExecProcess::from_exec_server_started(StartedExecProcess {
- process: Arc::new(BlockingTerminateExecProcess {
- process_id: process_id.to_string().into(),
- terminate_started,
- allow_terminate,
- wake_tx,
- }),
- sandbox_type: Some(codex_sandboxing::SandboxType::None),
- })
+ UnifiedExecProcess::from_exec_server_started(
+ StartedExecProcess {
+ process: Arc::new(BlockingTerminateExecProcess {
+ process_id: process_id.to_string().into(),
+ terminate_started,
+ allow_terminate,
+ wake_tx,
+ }),
+ sandbox_type: Some(codex_sandboxing::SandboxType::None),
+ },
+ OutputDrainPolicy::WaitForOutputClosure,
+ )
.await?,
))
}
diff --git a/codex-rs/core/src/unified_exec/process.rs b/codex-rs/core/src/unified_exec/process.rs
index 51afaa36d0..09e0cd1824 100644
--- a/codex-rs/core/src/unified_exec/process.rs
+++ b/codex-rs/core/src/unified_exec/process.rs
@@ -74,6 +74,15 @@ impl Drop for OutputTaskGuard {
}
}
+/// Controls whether process exit can start the collectors' bounded output drain.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum OutputDrainPolicy {
+ /// Match direct local execution when descendants retain inherited output pipes.
+ BoundedAfterExit,
+ /// Remote foreground output may still be buffered or in transit after exit.
+ WaitForOutputClosure,
+}
+
/// Transport-specific process handle used by unified exec.
enum ProcessHandle {
Local(Box<ExecCommandSession>),
@@ -385,6 +394,7 @@ impl UnifiedExecProcess {
pub(super) async fn from_exec_server_started(
started: StartedExecProcess,
+ output_drain_policy: OutputDrainPolicy,
) -> Result<Self, UnifiedExecError> {
let process_handle = ProcessHandle::ExecServer(Arc::clone(&started.process));
// Older peers do not report this field. In that case, skip local
@@ -394,6 +404,7 @@ impl UnifiedExecProcess {
let output_handles = managed.output_handles().clone();
managed.output_task = Some(Self::spawn_exec_server_output_task(
started,
+ output_drain_policy,
output_handles,
managed.output_tx.clone(),
managed.state_tx.clone(),
@@ -422,6 +433,7 @@ impl UnifiedExecProcess {
fn spawn_exec_server_output_task(
started: StartedExecProcess,
+ output_drain_policy: OutputDrainPolicy,
output_handles: OutputHandles,
output_tx: broadcast::Sender<Vec<u8>>,
state_tx: watch::Sender<ProcessState>,
@@ -527,6 +539,9 @@ impl UnifiedExecProcess {
state
});
}
+ if exited && output_drain_policy == OutputDrainPolicy::BoundedAfterExit {
+ cancellation_token.cancel();
+ }
if closed {
output_closed.store(true, Ordering::Release);
output_closed_notify.notify_waiters();
@@ -564,6 +579,9 @@ impl UnifiedExecProcess {
let mut state = state_tx.borrow().clone();
state.sandbox_denied |= sandbox_denied.unwrap_or(false);
let _ = state_tx.send_replace(state.exited(Some(exit_code)));
+ if output_drain_policy == OutputDrainPolicy::BoundedAfterExit {
+ cancellation_token.cancel();
+ }
}
ExecProcessEvent::Closed { seq } => {
if seq <= last_seq {
diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rs
index 80a34ce6a1..a8c99cd2a4 100644
--- a/codex-rs/core/src/unified_exec/process_manager.rs
+++ b/codex-rs/core/src/unified_exec/process_manager.rs
@@ -13,6 +13,7 @@ use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use super::oneshot::Completion;
+use super::process::OutputDrainPolicy;
use crate::codex_thread::BackgroundTerminalInfo;
use crate::exec_env::CODEX_PERMISSION_PROFILE_ENV_VAR;
@@ -1343,7 +1344,13 @@ impl UnifiedExecProcessManager {
None => backend.start(params).await,
}
.map_err(|err| UnifiedExecError::create_process(err.to_string()))?;
- return UnifiedExecProcess::from_exec_server_started(started).await;
+ let output_drain_policy = if environment.is_remote() {
+ OutputDrainPolicy::WaitForOutputClosure
+ } else {
+ OutputDrainPolicy::BoundedAfterExit
+ };
+ return UnifiedExecProcess::from_exec_server_started(started, output_drain_policy)
+ .await;
}
// TODO(anp): Keep PathUri through the local PTY/process launch boundary.
diff --git a/codex-rs/core/src/unified_exec/process_tests.rs b/codex-rs/core/src/unified_exec/process_tests.rs
index ed59dfd486..29dabeee2d 100644
--- a/codex-rs/core/src/unified_exec/process_tests.rs
+++ b/codex-rs/core/src/unified_exec/process_tests.rs
@@ -1,3 +1,4 @@
+use super::process::OutputDrainPolicy;
use super::process::UnifiedExecProcess;
use crate::unified_exec::UnifiedExecError;
use codex_exec_server::ExecProcess;
@@ -104,7 +105,7 @@ pub(super) async fn remote_process(
sandbox_type: sandbox_type.into(),
};
- UnifiedExecProcess::from_exec_server_started(started)
+ UnifiedExecProcess::from_exec_server_started(started, OutputDrainPolicy::WaitForOutputClosure)
.await
.expect("remote process should start")
}
diff --git a/codex-rs/core/tests/suite/shell_snapshot.rs b/codex-rs/core/tests/suite/shell_snapshot.rs
index 5518bad8c0..8bfd272c10 100644
--- a/codex-rs/core/tests/suite/shell_snapshot.rs
+++ b/codex-rs/core/tests/suite/shell_snapshot.rs
@@ -381,6 +381,64 @@ async fn run_no_shell_turn(harness: &TestCodexHarness) -> Result<()> {
Ok(())
}
+#[cfg(unix)]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn shell_snapshot_v2_returns_before_inherited_output_closes() -> Result<()> {
+ use std::io::Write;
+
+ skip_if_remote!(Ok(()), "tests the local executor's inherited output pipes");
+ let profile_home = tempfile::tempdir()?;
+ let gate_path = profile_home.path().join("output-gate");
+ let status = std::process::Command::new("mkfifo")
+ .arg(&gate_path)
+ .status()?;
+ anyhow::ensure!(status.success(), "failed to create output gate");
+ let mut gate = std::fs::OpenOptions::new()
+ .read(true)
+ .write(true)
+ .open(&gate_path)?;
+ let harness = TestCodexHarness::with_auto_env_builder(shell_snapshot_v2_prewarm_builder(
+ profile_home.path(),
+ ))
+ .await?;
+
+ // The foreground shell exits, but its descendant retains stdout until we release the FIFO.
+ // Wait for the public command-end and turn-complete notifications, not polled process state.
+ let result = tokio::time::timeout(
+ Duration::from_secs(10),
+ run_tool_turn_on_harness(
+ &harness,
+ "run a command whose descendant retains stdout",
+ "inherited-output",
+ "exec_command",
+ json!({
+ "cmd": "(read -r release < \"$HOME/output-gate\") & printf 'foreground output'; exit 7",
+ "yield_time_ms": 30_000,
+ "tty": false,
+ }),
+ ),
+ )
+ .await;
+
+ // Release the descendant even when completion timed out on the broken path.
+ gate.write_all(b"release\n")?;
+ harness.test().codex.shutdown_and_wait().await?;
+ let end =
+ result.expect("tool response should complete before the inherited pipe is released")?;
+ assert_eq!(
+ (end.exit_code, end.aggregated_output),
+ (7, "foreground output".to_string()),
+ );
+ let output = harness.function_call_stdout("inherited-output").await;
+ assert!(output.contains("Process exited with code 7"), "{output}");
+ assert!(
+ !output.contains("Process running with session ID"),
+ "{output}"
+ );
+ assert!(output.ends_with("foreground output"), "{output}");
+ Ok(())
+}
+
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shell_snapshot_v2_warms_after_hooks_without_blocking_the_model() -> Result<()> {
diff --git a/codex-rs/core/tests/suite/unified_exec_process_events.rs b/codex-rs/core/tests/suite/unified_exec_process_events.rs
index 1abc857c61..2692825542 100644
--- a/codex-rs/core/tests/suite/unified_exec_process_events.rs
+++ b/codex-rs/core/tests/suite/unified_exec_process_events.rs
@@ -72,6 +72,8 @@ const REPLAY_RETAINED_OUTPUT_SEQ: u64 = 800;
#[cfg_attr(windows, allow(dead_code))]
enum PushedExecScenario {
Complete,
+ OutputAfterExit,
+ OutputAfterRecoveredExit,
CodexPath,
CodexPathDefaultFeature,
CodexPathDisabledFeature,
@@ -420,7 +422,79 @@ async fn serve_exec_with_pushed_events(
)
.await;
+ let mut process_read_requests = 0;
match scenario {
+ PushedExecScenario::OutputAfterExit | PushedExecScenario::OutputAfterRecoveredExit => {
+ send_exec_server_json(
+ &mut websocket,
+ json!({
+ "method": "process/output",
+ "params": {
+ "processId": &process_id,
+ "seq": 1,
+ "stream": "stdout",
+ "chunk": BASE64_STANDARD.encode("pushed "),
+ }
+ }),
+ )
+ .await;
+ let mut exit = json!({
+ "method": "process/exited",
+ "params": {
+ "processId": &process_id,
+ "seq": 2,
+ "exitCode": 0,
+ }
+ });
+ if matches!(scenario, PushedExecScenario::OutputAfterExit) {
+ exit["params"]["sandboxDenied"] = json!(false);
+ }
+ send_exec_server_json(&mut websocket, exit).await;
+ if matches!(scenario, PushedExecScenario::OutputAfterRecoveredExit) {
+ let read = read_exec_server_json(&mut websocket, STARTUP_TIMEOUT).await;
+ assert_eq!(read["method"], "process/read");
+ process_read_requests += 1;
+ send_exec_server_json(
+ &mut websocket,
+ json!({
+ "id": read["id"],
+ "result": {
+ "chunks": [],
+ "nextSeq": 3,
+ "exited": true,
+ "exitCode": 0,
+ "closed": false,
+ "failure": null,
+ "sandboxDenied": false,
+ }
+ }),
+ )
+ .await;
+ }
+ // Model foreground output delayed in transit beyond the local post-exit grace.
+ tokio::time::sleep(Duration::from_millis(250)).await;
+ send_exec_server_json(
+ &mut websocket,
+ json!({
+ "method": "process/output",
+ "params": {
+ "processId": &process_id,
+ "seq": 3,
+ "stream": "stdout",
+ "chunk": BASE64_STANDARD.encode("remote output\n"),
+ }
+ }),
+ )
+ .await;
+ send_exec_server_json(
+ &mut websocket,
+ json!({
+ "method": "process/closed",
+ "params": { "processId": &process_id, "seq": 4 }
+ }),
+ )
+ .await;
+ }
PushedExecScenario::Complete
| PushedExecScenario::DenyWin
| PushedExecScenario::DenyWinUnchanged
@@ -506,13 +580,16 @@ async fn serve_exec_with_pushed_events(
PushedExecScenario::ReplayGap => {}
}
- let mut process_read_requests = 0;
loop {
let request = read_exec_server_json(&mut websocket, Duration::from_secs(/*secs*/ 5)).await;
match request["method"].as_str() {
Some("process/read") => {
process_read_requests += 1;
let result = match scenario {
+ PushedExecScenario::OutputAfterExit
+ | PushedExecScenario::OutputAfterRecoveredExit => {
+ panic!("unexpected read after the delayed-output sequence")
+ }
PushedExecScenario::Complete
| PushedExecScenario::CodexPath
| PushedExecScenario::CodexPathDefaultFeature
@@ -633,6 +710,8 @@ async fn serve_exec_with_pushed_events(
}
#[test_case(PushedExecScenario::Complete, ManagedNetworkScenario::None, false ; "complete_event_stream")]
+#[test_case(PushedExecScenario::OutputAfterExit, ManagedNetworkScenario::None, false ; "output_after_exit")]
+#[test_case(PushedExecScenario::OutputAfterRecoveredExit, ManagedNetworkScenario::None, false ; "output_after_recovered_exit")]
#[test_case(PushedExecScenario::CodexPath, ManagedNetworkScenario::None, false ; "codex_path_is_exported_before_nested_command")]
#[test_case(PushedExecScenario::CodexPathDefaultFeature, ManagedNetworkScenario::None, false ; "codex_path_is_not_exported_by_default")]
#[test_case(PushedExecScenario::CodexPathDisabledFeature, ManagedNetworkScenario::None, false ; "disabled_codex_path_preserves_original_login_command")]
@@ -1368,6 +1447,22 @@ timeout = 900
let output = output.context("exec_command output should contain text")?;
let process_read_requests = exec_server_result.process_read_requests;
match scenario {
+ PushedExecScenario::OutputAfterExit | PushedExecScenario::OutputAfterRecoveredExit => {
+ assert_ne!(success, Some(false));
+ assert!(saw_exec_command_begin);
+ assert!(output.contains("Process exited with code 0"));
+ assert!(
+ output.contains(COMPLETE_OUTPUT),
+ "missing remote output tail: {output}"
+ );
+ assert_eq!(
+ process_read_requests,
+ usize::from(matches!(
+ scenario,
+ PushedExecScenario::OutputAfterRecoveredExit
+ ))
+ );
+ }
PushedExecScenario::Complete
| PushedExecScenario::DenyWin
| PushedExecScenario::DenyWinUnchanged