Lightweight coding agent that runs in your terminal
Rust
Bound app-server stdio shutdown and handle Unix SIGTERM gracefully (#44523)
jif713caa89f389
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex d735f833ad..30a9c2f963 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2411,6 +2411,7 @@ dependencies = ["serde","serde_json","sha2 0.10.9",+ "signal-hook","tempfile","time","tokio",diff --git a/codex-rs/Cargo.toml b/codex-rs/Cargo.tomlindex e07725207c..788afe6e80 100644--- a/codex-rs/Cargo.toml+++ b/codex-rs/Cargo.toml@@ -451,6 +451,7 @@ sha1 = "0.10.6"scopeguard = "1.2.0"sha2 = "0.10"shlex = "1.3.0"+signal-hook = "0.3.18"similar = "2.7.0"symphonia = { version = "0.6.0", default-features = false, features = ["isomp4",diff --git a/codex-rs/app-server-transport/Cargo.toml b/codex-rs/app-server-transport/Cargo.tomlindex b6c3241307..aa8150de07 100644--- a/codex-rs/app-server-transport/Cargo.toml+++ b/codex-rs/app-server-transport/Cargo.toml@@ -55,6 +55,9 @@ tracing = { workspace = true, features = ["log"] }url = { workspace = true }uuid = { workspace = true, features = ["serde", "v7"] }+[target.'cfg(unix)'.dependencies]+signal-hook = { workspace = true }+[dev-dependencies]chrono = { workspace = true }codex-config = { workspace = true }diff --git a/codex-rs/app-server-transport/src/transport/stdio.rs b/codex-rs/app-server-transport/src/transport/stdio.rsindex c2efdaea71..12552800cf 100644--- a/codex-rs/app-server-transport/src/transport/stdio.rs+++ b/codex-rs/app-server-transport/src/transport/stdio.rs@@ -1,3 +1,8 @@+//! Stdio transport with EOF cleanup and Unix SIGTERM shutdown. Dedicated I/O+//! threads let SIGTERM abandon blocked pipes without holding the runtime open.+//! A dedicated signal thread arms the shared EOF/SIGTERM deadline even when+//! logging or the Tokio runtime is blocked.+use super::CHANNEL_CAPACITY;use super::ConnectionOrigin;use super::TransportEvent;@@ -8,24 +13,42 @@ use crate::outgoing_message::QueuedOutgoingMessage;use codex_app_server_protocol::InitializeParams;use codex_app_server_protocol::JSONRPCMessage;use codex_app_server_protocol::JSONRPCRequest;+use std::io::BufRead;use std::io::ErrorKind;use std::io::Result as IoResult;-use tokio::io;-use tokio::io::AsyncBufReadExt;-use tokio::io::AsyncWriteExt;-use tokio::io::BufReader;+use std::io::Write;use tokio::sync::mpsc;use tokio::sync::oneshot;use tokio::task::JoinHandle;+use tokio_util::sync::CancellationToken;use tracing::debug;use tracing::error;use tracing::info;pub async fn start_stdio_connection(transport_event_tx: mpsc::Sender<TransportEvent>,- stdio_handles: &mut Vec<JoinHandle<()>>,initialize_client_name_tx: oneshot::Sender<String>,-) -> IoResult<()> {+ install_shutdown_signal_handler: bool,+) -> IoResult<JoinHandle<()>> {+ let shutdown_signal = CancellationToken::new();+ #[cfg(unix)]+ if install_shutdown_signal_handler {+ use signal_hook::consts::SIGTERM;+ use signal_hook::iterator::Signals;++ // Register before accepting requests. Receiving SIGTERM and arming the+ // watchdog must not depend on Tokio or synchronous transport logging.+ let mut signals = Signals::new([SIGTERM])?;+ let shutdown_signal = shutdown_signal.clone();+ std::thread::Builder::new()+ .name("app-server-signal".to_string())+ .spawn(move || {+ if signals.forever().next().is_some() {+ start_shutdown_watchdog();+ shutdown_signal.cancel();+ }+ })?;+ }let connection_id = next_connection_id();let (writer_tx, mut writer_rx) = mpsc::channel::<QueuedOutgoingMessage>(CHANNEL_CAPACITY);let writer_tx_for_reader = writer_tx.clone();@@ -40,55 +63,84 @@ pub async fn start_stdio_connection(.await.map_err(|_| std::io::Error::new(ErrorKind::BrokenPipe, "processor unavailable"))?;- let transport_event_tx_for_reader = transport_event_tx.clone();- stdio_handles.push(tokio::spawn(async move {- let stdin = io::stdin();- let reader = BufReader::new(stdin);- let mut lines = reader.lines();- let mut initialize_client_name_tx = Some(initialize_client_name_tx);+ // Tokio's stdin uses an uncancellable blocking task, which keeps its runtime+ // alive while the client leaves stdin open. This process-owned thread may+ // remain blocked until process exit, but is not joined by the runtime.+ let (stdin_tx, mut stdin_rx) = mpsc::channel(/*buffer*/ 1);+ std::thread::Builder::new()+ .name("app-server-stdin".to_string())+ .spawn(move || {+ for line in std::io::stdin().lock().lines() {+ if stdin_tx.blocking_send(line).is_err() {+ break;+ }+ }+ })?;- loop {- match lines.next_line().await {- Ok(Some(line)) => {- if let Some(client_name) = stdio_initialize_client_name(&line)- && let Some(initialize_client_name_tx) = initialize_client_name_tx.take()- {- let _ = initialize_client_name_tx.send(client_name);- }- if !forward_incoming_message(- &transport_event_tx_for_reader,- &writer_tx_for_reader,- connection_id,- &line,- )- .await- {- break;- }+ // Keep stdout's blocking writes off Tokio's pool too. The forwarding future+ // owns writer_rx so cancelling it also releases producers stuck on a full queue.+ let (stdout_tx, mut stdout_rx) =+ mpsc::channel::<(String, oneshot::Sender<()>)>(/*buffer*/ 1);+ std::thread::Builder::new()+ .name("app-server-stdout".to_string())+ .spawn(move || {+ let mut stdout = std::io::stdout().lock();+ while let Some((json, written_tx)) = stdout_rx.blocking_recv() {+ if let Err(err) = stdout.write_all(json.as_bytes()) {+ error!("Failed to write to stdout: {err}");+ break;}- Ok(None) => break,+ let _ = written_tx.send(());+ }+ })?;++ let transport_event_tx_for_reader = transport_event_tx.clone();+ let read_messages = async move {+ let mut initialize_client_name_tx = Some(initialize_client_name_tx);+ while let Some(line) = stdin_rx.recv().await {+ let line = match line {+ Ok(line) => line,Err(err) => {error!("Failed reading stdin: {err}");break;}+ };+ if let Some(client_name) = stdio_initialize_client_name(&line)+ && let Some(initialize_client_name_tx) = initialize_client_name_tx.take()+ {+ let _ = initialize_client_name_tx.send(client_name);+ }+ if !forward_incoming_message(+ &transport_event_tx_for_reader,+ &writer_tx_for_reader,+ connection_id,+ &line,+ )+ .await+ {+ break;}}+ // EOF can finish the transport before RPC or runtime cleanup. Start+ // the same process deadline even if no SIGTERM arrives.+ if cfg!(unix) && install_shutdown_signal_handler {+ start_shutdown_watchdog();+ }let _ = transport_event_tx_for_reader.send(TransportEvent::ConnectionClosed { connection_id }).await;debug!("stdin reader finished (EOF)");- }));+ };- stdio_handles.push(tokio::spawn(async move {- let mut stdout = io::stdout();+ let write_messages = async move {while let Some(queued_message) = writer_rx.recv().await {let Some(mut json) = serialize_outgoing_message(queued_message.message) else {continue;};json.push('\n');- if let Err(err) = stdout.write_all(json.as_bytes()).await {- error!("Failed to write to stdout: {err}");+ let (written_tx, written_rx) = oneshot::channel();+ if stdout_tx.send((json, written_tx)).await.is_err() || written_rx.await.is_err() {break;}if let Some(write_complete_tx) = queued_message.write_complete_tx {@@ -96,9 +148,37 @@ pub async fn start_stdio_connection(}}info!("stdout writer exited (channel closed)");- }));+ };++ Ok(tokio::spawn(async move {+ tokio::select! {+ _ = shutdown_signal.cancelled() => {+ // Cancelling both forwarding futures drops their queues before+ // connection teardown, including when EOF already began draining.+ info!("SIGTERM received; closing stdio connection (45s shutdown deadline)");+ let _ = transport_event_tx+ .send(TransportEvent::ConnectionClosed { connection_id })+ .await;+ }+ _ = async move { tokio::join!(read_messages, write_messages); } => {}+ }+ }))+}- Ok(())+fn start_shutdown_watchdog() {+ // EOF and SIGTERM can both start cleanup; keep the first process deadline.+ static STARTED: std::sync::Once = std::sync::Once::new();+ STARTED.call_once(|| {+ std::thread::Builder::new()+ .name("app-server-shutdown".to_string())+ .spawn(|| {+ // Allow the processor's 30s RPC drain, then bound even Tokio's+ // runtime teardown. Do not log here: stderr may also be blocked.+ std::thread::sleep(std::time::Duration::from_secs(45));+ std::process::exit(/*code*/ 1);+ })+ .unwrap_or_else(|_| std::process::exit(/*code*/ 1));+ });}fn stdio_initialize_client_name(line: &str) -> Option<String> {diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rsindex b48813de2b..aa565b6b34 100644--- a/codex-rs/app-server/src/lib.rs+++ b/codex-rs/app-server/src/lib.rs@@ -762,12 +762,13 @@ pub async fn run_main_with_transport_options(AppServerTransport::Stdio => {let (stdio_client_name_tx, stdio_client_name_rx) = oneshot::channel::<String>();app_server_client_name_rx = Some(stdio_client_name_rx);- start_stdio_connection(+ let handle = start_stdio_connection(transport_event_tx.clone(),- &mut transport_accept_handles,stdio_client_name_tx,+ runtime_options.install_shutdown_signal_handler,).await?;+ transport_accept_handles.push(handle);}AppServerTransport::UnixSocket { socket_path } => {let accept_handle = start_control_socket_acceptor(diff --git a/codex-rs/app-server/tests/common/test_app_server.rs b/codex-rs/app-server/tests/common/test_app_server.rsindex 048f2eeb8e..568916e93b 100644--- a/codex-rs/app-server/tests/common/test_app_server.rs+++ b/codex-rs/app-server/tests/common/test_app_server.rs@@ -192,6 +192,21 @@ impl TestAppServer {self.process.wait().await}+ #[cfg(unix)]+ pub fn send_sigterm(&self) -> anyhow::Result<()> {+ let pid = self.process.id().context("app-server has no pid")?;+ let status = std::process::Command::new("kill")+ .args(["-TERM", &pid.to_string()])+ .status()?;+ ensure!(status.success(), "failed to signal app-server: {status}");+ Ok(())+ }++ /// Waits for output without consuming it, for transport backpressure tests.+ pub async fn peek_stdout(&mut self) -> std::io::Result<&[u8]> {+ self.stdout.fill_buf().await+ }+/// Closes stdio and waits for app-server's graceful thread teardown to finish.pub async fn shutdown_gracefully(&mut self) -> std::io::Result<ExitStatus> {drop(self.stdin.take());diff --git a/codex-rs/app-server/tests/suite/v2/connection_handling_stdio_tests.rs b/codex-rs/app-server/tests/suite/v2/connection_handling_stdio_tests.rsnew file mode 100644index 0000000000..434335f3e4--- /dev/null+++ b/codex-rs/app-server/tests/suite/v2/connection_handling_stdio_tests.rs@@ -0,0 +1,329 @@+//! Stdio shutdown cleans up owned commands and bounds teardown when I/O stalls.++use anyhow::Context;+use anyhow::Result;+use app_test_support::DISABLE_PLUGIN_STARTUP_TASKS_ARG;+use app_test_support::TestAppServer;+use base64::Engine;+use base64::engine::general_purpose::STANDARD;+use codex_app_server_protocol::CommandExecParams;+use codex_app_server_protocol::FsReadFileParams;+use codex_app_server_protocol::FsWriteFileParams;+use codex_app_server_protocol::JSONRPCMessage;+use codex_app_server_protocol::SandboxPolicy;+use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_cargo_bin::cargo_bin;+use core_test_support::skip_if_remote;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::io::ErrorKind;+use std::io::Read;+use std::process::Command;+use std::process::Stdio;+use std::time::Instant;+use tempfile::TempDir;+use test_case::test_case;+use tokio::io::AsyncBufReadExt;+use tokio::io::AsyncWriteExt;+use tokio::io::BufReader;+use tokio::net::unix::pipe;+use tokio::time::Duration;+use tokio::time::sleep;+use tokio::time::timeout;++#[tokio::test]+async fn stdio_sigterm_exits_with_open_pipes() -> Result<()> {+ let mut app = TestAppServer::builder().build_initialized().await?;++ app.send_sigterm()?;+ // wait_for_exit leaves both pipes open and does not drain stdout. Success catches an+ // unhandled SIGTERM, which exits before any cleanup can run.+ let status = timeout(Duration::from_secs(10), app.wait_for_exit())+ .await+ .context("app-server did not exit after SIGTERM")??;+ assert!(+ status.success(),+ "app-server did not exit cleanly: {status}"+ );+ Ok(())+}++#[tokio::test]+async fn stdio_sigterm_times_out_with_blocked_stderr() -> Result<()> {+ // TestAppServer drains stderr, so keep this subprocess's stderr pipe unread.+ let codex_home = TempDir::new()?;+ let mut process = tokio::process::Command::new(cargo_bin("codex-app-server")?)+ .arg(DISABLE_PLUGIN_STARTUP_TASKS_ARG)+ .env("CODEX_HOME", codex_home.path())+ .env(+ "CODEX_APP_SERVER_MANAGED_CONFIG_PATH",+ codex_home.path().join("managed_config.toml"),+ )+ .env("RUST_LOG", "codex_app_server_transport=error")+ .current_dir(codex_home.path())+ .stdin(Stdio::piped())+ .stdout(Stdio::piped())+ .stderr(Stdio::piped())+ .kill_on_drop(true)+ .spawn()?;+ let mut stdin = process.stdin.take().context("app-server has no stdin")?;+ let mut stdout =+ BufReader::new(process.stdout.take().context("app-server has no stdout")?).lines();+ let initialize = json!({+ "id": 1,+ "method": "initialize",+ "params": { "clientInfo": { "name": "stdio-stderr-test", "version": "1" } }+ });+ stdin+ .write_all(format!("{initialize}\n").as_bytes())+ .await?;+ let response = timeout(Duration::from_secs(10), stdout.next_line())+ .await??+ .context("app-server did not initialize")?;+ assert!(matches!(+ serde_json::from_str::<JSONRPCMessage>(&response)?,+ JSONRPCMessage::Response(_)+ ));++ // Invalid JSON logs synchronously in the reader. Fill stderr until the+ // transport stops consuming stdin, then keep all three pipes open.+ let invalid_input = b"{\n".repeat(1024 * 1024);+ assert!(+ timeout(Duration::from_secs(2), stdin.write_all(&invalid_input))+ .await+ .is_err(),+ "expected unread stderr to block the transport"+ );+ let signalled_at = Instant::now();+ let status = Command::new("kill")+ .arg("-TERM")+ .arg(process.id().context("app-server has no pid")?.to_string())+ .status()?;+ assert!(status.success(), "failed to signal app-server: {status}");+ let status = timeout(Duration::from_secs(55), process.wait())+ .await+ .context("blocked stderr prevented SIGTERM shutdown")??;+ assert_eq!(status.code(), Some(1));+ assert!(signalled_at.elapsed() >= Duration::from_secs(45));+ drop(stdin);+ Ok(())+}++#[test_case(Shutdown::Sigterm; "sigterm")]+#[test_case(Shutdown::Eof; "eof_then_sigterm")]+#[tokio::test]+async fn stdio_shutdown_times_out_with_blocked_file_write(shutdown: Shutdown) -> Result<()> {+ let codex_home = TempDir::new()?;+ let path = codex_home.path().join("blocked-write");+ let status = Command::new("mkfifo").arg(&path).status()?;+ assert!(status.success(), "failed to create FIFO: {status}");+ let mut reader = std::fs::File::from(+ pipe::OpenOptions::new()+ .open_receiver(&path)?+ .into_nonblocking_fd()?,+ );+ let mut app = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ // The FIFO belongs to the app-server's local filesystem, even in remote CI.+ .without_auto_env()+ .build_initialized()+ .await?;+ app.send_fs_write_file_request(FsWriteFileParams {+ path: AbsolutePathBuf::try_from(path)?,+ data_base64: STANDARD.encode(vec![b'x'; 1024 * 1024]),+ })+ .await?;++ // Confirm the write has started, then leave the FIFO unread. The blocking+ // filesystem write cannot finish, even if its async request is cancelled.+ let mut first_byte = [0];+ timeout(Duration::from_secs(10), async {+ loop {+ match reader.read(&mut first_byte) {+ Ok(0) => {}+ Ok(_) => break,+ Err(err) if err.kind() == ErrorKind::WouldBlock => {}+ Err(err) => return Err(err),+ }+ sleep(Duration::from_millis(20)).await;+ }+ Ok::<_, std::io::Error>(())+ })+ .await+ .context("filesystem write did not start")??;+ assert_eq!(first_byte, [b'x']);++ let shutdown_at = Instant::now();+ match shutdown {+ Shutdown::Sigterm => app.send_sigterm()?,+ Shutdown::Eof => {+ // Close stdin, then let the 30s RPC drain finish and enter runtime+ // teardown before SIGTERM. Keep the FIFO blocked throughout.+ assert!(+ timeout(Duration::from_secs(35), app.shutdown_gracefully())+ .await+ .is_err(),+ "app-server exited before allowing graceful cleanup"+ );+ app.send_sigterm()?;+ }+ }+ let remaining = Duration::from_secs(55).saturating_sub(shutdown_at.elapsed());+ let status = timeout(remaining, app.wait_for_exit())+ .await+ .context("app-server did not exit within the shutdown deadline")??;+ assert_eq!(status.code(), Some(1));+ assert!(+ shutdown_at.elapsed() >= Duration::from_secs(45),+ "app-server exited before allowing graceful cleanup"+ );+ drop(reader);+ Ok(())+}++#[derive(Clone, Copy)]+enum Shutdown {+ Eof,+ Sigterm,+}++#[test_case(Shutdown::Eof; "eof")]+#[test_case(Shutdown::Sigterm; "sigterm")]+#[tokio::test]+async fn stdio_shutdown_terminates_commands_and_children(shutdown: Shutdown) -> Result<()> {+ skip_if_remote!(+ Ok(()),+ "asserts that processes owned by the local app-server exit"+ );+ let workspace = TempDir::new()?;+ let mut app = TestAppServer::builder().build_initialized().await?;++ let script = r#"sleep 120 & child=$!; printf '%s %s\n' "$$" "$child" > pids; wait "$child""#;+ app.send_command_exec_request(CommandExecParams {+ command: vec!["/bin/sh".to_string(), "-c".to_string(), script.to_string()],+ process_id: Some("shutdown-test".to_string()),+ tty: false,+ stream_stdin: false,+ stream_stdout_stderr: true,+ output_bytes_cap: None,+ disable_output_cap: false,+ disable_timeout: true,+ timeout_ms: None,+ cwd: Some(workspace.path().to_path_buf()),+ env: None,+ size: None,+ sandbox_policy: Some(SandboxPolicy::DangerFullAccess),+ permission_profile: None,+ })+ .await?;++ let mut children = ProcessCleanup(Vec::new());+ timeout(Duration::from_secs(10), async {+ loop {+ if let Ok(pids) = tokio::fs::read_to_string(workspace.path().join("pids")).await {+ let pids = pids+ .split_whitespace()+ .map(str::parse::<u32>)+ .collect::<std::result::Result<Vec<_>, _>>()?;+ if pids.len() == 2 {+ children.0 = pids;+ break;+ }+ }+ sleep(Duration::from_millis(20)).await;+ }+ Ok::<_, anyhow::Error>(())+ })+ .await+ .context("command did not start")??;+ children.0.sort_unstable();+ assert_eq!(running_process_ids(&children.0)?, children.0);++ if matches!(shutdown, Shutdown::Sigterm) {+ let path = workspace.path().join("large-response");+ std::fs::write(&path, vec![b'x'; 1024 * 1024])?;+ app.send_fs_read_file_request(FsReadFileParams {+ path: AbsolutePathBuf::try_from(path)?,+ })+ .await?;+ timeout(Duration::from_secs(10), async {+ while !String::from_utf8_lossy(app.peek_stdout().await?).contains("dataBase64") {+ app.read_next_message().await?;+ }+ Ok::<_, anyhow::Error>(())+ })+ .await+ .context("large response did not start")??;+ // Leave the response unread so stdout remains blocked during shutdown.+ }++ let status = match shutdown {+ Shutdown::Eof => timeout(Duration::from_secs(10), app.shutdown_gracefully()).await??,+ Shutdown::Sigterm => {+ app.send_sigterm()?;+ timeout(Duration::from_secs(10), app.wait_for_exit())+ .await+ .context("app-server did not exit after SIGTERM")??+ }+ };+ assert!(+ status.success(),+ "app-server did not exit cleanly: {status}"+ );++ timeout(Duration::from_secs(5), async {+ loop {+ if running_process_ids(&children.0)?.is_empty() {+ children.0.clear();+ return Ok::<_, anyhow::Error>(());+ }+ sleep(Duration::from_millis(20)).await;+ }+ })+ .await+ .context("command or its child survived app-server shutdown")??;+ Ok(())+}++fn running_process_ids(pids: &[u32]) -> Result<Vec<u32>> {+ let output = Command::new("ps")+ .args(["-o", "pid=,stat=", "-p"])+ .arg(+ pids.iter()+ .map(u32::to_string)+ .collect::<Vec<_>>()+ .join(","),+ )+ .output()?;+ anyhow::ensure!(+ output.status.success() || output.status.code() == Some(1),+ "ps failed: {}",+ String::from_utf8_lossy(&output.stderr),+ );+ let mut running = Vec::new();+ for line in String::from_utf8(output.stdout)?.lines() {+ let mut fields = line.split_whitespace();+ let pid = fields.next().context("missing process id")?.parse()?;+ let state = fields.next().context("missing process state")?;+ // An orphaned zombie has exited but may not yet have been reaped+ // by init (notably in Linux test containers).+ if !state.starts_with('Z') {+ running.push(pid);+ }+ }+ running.sort_unstable();+ Ok(running)+}++struct ProcessCleanup(Vec<u32>);++impl Drop for ProcessCleanup {+ fn drop(&mut self) {+ for pid in &self.0 {+ let _ = Command::new("kill")+ .arg("-KILL")+ .arg(pid.to_string())+ .output();+ }+ }+}diff --git a/codex-rs/app-server/tests/suite/v2/mod.rs b/codex-rs/app-server/tests/suite/v2/mod.rsindex 4846897d71..67fe1b9541 100644--- a/codex-rs/app-server/tests/suite/v2/mod.rs+++ b/codex-rs/app-server/tests/suite/v2/mod.rs@@ -18,6 +18,9 @@ mod config_requirements_application;mod config_requirements_browser_use;mod config_requirements_in_app_browser;mod config_rpc;+#[cfg(unix)]+#[path = "connection_handling_stdio_tests.rs"]+mod connection_handling_stdio;mod connection_handling_websocket;#[cfg(unix)]mod connection_handling_websocket_unix;diff --git a/codex-rs/app-server/tests/suite/v2/session_end.rs b/codex-rs/app-server/tests/suite/v2/session_end.rsindex 93592f2967..2a478aacb1 100644--- a/codex-rs/app-server/tests/suite/v2/session_end.rs+++ b/codex-rs/app-server/tests/suite/v2/session_end.rs@@ -21,6 +21,7 @@ use pretty_assertions::assert_eq;use serde_json::Value;use serde_json::json;use tempfile::TempDir;+use test_case::test_case;use tokio::time::timeout;const READ_TIMEOUT: Duration = Duration::from_secs(20);@@ -94,8 +95,18 @@ async fn run_removal_session_end_test(operation: &str) -> Result<()> {Ok(())}+#[derive(Clone, Copy)]+enum Shutdown {+ Eof,+ Sigterm,+}++#[test_case(Shutdown::Eof; "eof")]+#[test_case(Shutdown::Sigterm; "sigterm")]#[tokio::test]-async fn app_server_shutdown_runs_session_end_for_all_loaded_threads() -> Result<()> {+async fn app_server_shutdown_runs_session_end_for_all_loaded_threads(+ shutdown: Shutdown,+) -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;let codex_home = TempDir::new()?;let log_path = write_config_and_hook(codex_home.path(), &server.uri())?;@@ -106,15 +117,27 @@ async fn app_server_shutdown_runs_session_end_for_all_loaded_threads() -> Resultlet first = start_thread(&mut app_server).await?;let second = start_thread(&mut app_server).await?;- let status = timeout(READ_TIMEOUT, app_server.shutdown_gracefully()).await??;+ let status = match shutdown {+ Shutdown::Eof => timeout(READ_TIMEOUT, app_server.shutdown_gracefully()).await??,+ Shutdown::Sigterm => {+ app_server.send_sigterm()?;+ timeout(READ_TIMEOUT, app_server.wait_for_exit()).await??+ }+ };assert!(status.success(), "app-server did not exit successfully");let mut actual = read_hook_log(&log_path)?.into_iter().map(|payload| {(- payload["session_id"].as_str().unwrap().to_string(),- payload["reason"].as_str().unwrap().to_string(),+ payload["session_id"]+ .as_str()+ .expect("session end session ID")+ .to_string(),+ payload["reason"]+ .as_str()+ .expect("session end reason")+ .to_string(),)}).collect::<Vec<_>>();