Lightweight coding agent that runs in your terminal
Rust
Persist loaded threads before managed daemon shutdown (#44283)
Eric Trautc1840dc55e3c
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 93c66e97c6..c0fa80e7f0 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2226,6 +2226,7 @@ dependencies = ["codex-state","codex-thread-store","codex-tools",+ "codex-uds","codex-user-verification","codex-utils-absolute-path","codex-utils-cargo-bin",diff --git a/codex-rs/app-server/Cargo.toml b/codex-rs/app-server/Cargo.tomlindex 6965b0c452..0643950835 100644--- a/codex-rs/app-server/Cargo.toml+++ b/codex-rs/app-server/Cargo.toml@@ -123,6 +123,7 @@ tikv-jemallocator = { workspace = true }codex-windows-sandbox = { workspace = true }[dev-dependencies]+codex-uds = { workspace = true }app_test_support = { workspace = true }axum = { workspace = true, default-features = false, features = ["http1",diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rsindex 06269bfd5c..8c4a346b89 100644--- a/codex-rs/app-server/src/lib.rs+++ b/codex-rs/app-server/src/lib.rs@@ -445,6 +445,15 @@ pub async fn run_main(AppServerRuntimeOptions::default(),).await+ .map(|_| ())+}++/// Reports whether shutdown finished or the managed daemon must exit without waiting for I/O.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum AppServerExit {+ Graceful,+ /// Executables should exit before dropping their runtime; libraries must not exit their host.+ Forced,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -459,6 +468,7 @@ pub struct AppServerRuntimeOptions {pub plugin_startup_tasks: PluginStartupTasks,pub remote_control_startup_mode: RemoteControlStartupMode,pub install_shutdown_signal_handler: bool,+ pub managed_daemon: bool,}impl Default for AppServerRuntimeOptions {@@ -468,6 +478,7 @@ impl Default for AppServerRuntimeOptions {plugin_startup_tasks: PluginStartupTasks::Start,remote_control_startup_mode: RemoteControlStartupMode::ResolvePersisted,install_shutdown_signal_handler: true,+ managed_daemon: false,}}}@@ -483,7 +494,7 @@ pub async fn run_main_with_transport_options(session_source: SessionSource,auth: AppServerWebsocketAuthSettings,runtime_options: AppServerRuntimeOptions,-) -> IoResult<()> {+) -> IoResult<AppServerExit> {let loader_overrides = loader_overrides_with_test_user_config_file(loader_overrides,test_user_config_file_from_env(),@@ -741,6 +752,8 @@ pub async fn run_main_with_transport_options(let single_client_mode = matches!(&transport, AppServerTransport::Stdio);let graceful_signal_restart_enabled =runtime_options.install_shutdown_signal_handler && !single_client_mode;+ let managed_daemon = matches!(&transport, AppServerTransport::UnixSocket { .. })+ && runtime_options.managed_daemon;let mut app_server_client_name_rx = None;match &transport {@@ -970,24 +983,43 @@ pub async fn run_main_with_transport_options(let transport_shutdown_token = transport_shutdown_token.clone();async move {let mut listen_for_threads = true;+ // Keep force signals and daemon control events responsive while saving.+ let mut snapshot = Box::pin(processor.persist_daemon_threads());+ let mut snapshot_finished = !managed_daemon;+ let mut clients_disconnected = false;let mut shutdown_state = ShutdownState::default();let exit_reason = loop {// Sample submissions first: one can publish a running turn before// releasing its permit, and shutdown must observe that new turn.let active_admissions = *active_admissions_rx.borrow_and_update();let running_turn_count = *running_turn_count_rx.borrow_and_update();- if matches!(+ let ready_to_exit = matches!(shutdown_state.update(running_turn_count, active_admissions, connections.len()),ShutdownAction::Finish- ) {- transport_shutdown_token.cancel();- let _ = outbound_control_tx- .send(OutboundControlEvent::DisconnectAll)- .await;- break "shutdown_requested";+ );+ if ready_to_exit {+ let finished = snapshot_finished || shutdown_state.forced();+ if finished {+ transport_shutdown_token.cancel();+ }+ if managed_daemon && shutdown_state.forced() {+ break "forced_shutdown_requested";+ }+ if !clients_disconnected {+ let _ = outbound_control_tx+ .send(OutboundControlEvent::DisconnectAll)+ .await;+ clients_disconnected = true;+ }+ if finished {+ break "shutdown_requested";+ }}tokio::select! {+ _ = &mut snapshot, if ready_to_exit && !snapshot_finished => {+ snapshot_finished = true;+ }shutdown_signal_result = shutdown_signal(), if graceful_signal_restart_enabled && !shutdown_state.forced() => {let signal = match shutdown_signal_result {Ok(signal) => signal,@@ -1013,6 +1045,12 @@ pub async fn run_main_with_transport_options(let Some(event) = event else {break "transport_channel_closed";};+ if ready_to_exit && !matches!(event, TransportEvent::DaemonShutdown) {+ if let TransportEvent::ConnectionOpened { disconnect_sender: Some(token), .. } = event {+ token.cancel();+ }+ continue;+ }match event {TransportEvent::DaemonShutdown => {shutdown_state.on_signal(ShutdownSignal::Forceable, connections.len(), *running_turn_count_rx.borrow(), &processor.turn_admission);@@ -1188,7 +1226,7 @@ pub async fn run_main_with_transport_options(.send_server_notification(notification).await;}- created = thread_created_rx.recv(), if listen_for_threads => {+ created = thread_created_rx.recv(), if listen_for_threads && !ready_to_exit => {match created {Ok(thread_id) => {let mut initialized_connection_ids = Vec::new();@@ -1219,6 +1257,7 @@ pub async fn run_main_with_transport_options(}};+ drop(snapshot);if !shutdown_state.forced() {futures::future::join_all(connections.iter().map(|(&connection_id, connection_state)| {@@ -1238,12 +1277,19 @@ pub async fn run_main_with_transport_options(shutdown_forced = shutdown_state.forced(),"processor task exited");+ if managed_daemon && shutdown_state.forced() {+ AppServerExit::Forced+ } else {+ AppServerExit::Graceful+ }}});drop(transport_event_tx);- let _ = processor_handle.await;+ if matches!(processor_handle.await, Ok(AppServerExit::Forced)) {+ return Ok(AppServerExit::Forced);+ }let _ = outbound_handle.await;transport_shutdown_token.cancel();@@ -1252,7 +1298,7 @@ pub async fn run_main_with_transport_options(let _ = handle.await;}- Ok(())+ Ok(AppServerExit::Graceful)}struct SqliteRecoveryNotice {diff --git a/codex-rs/app-server/src/main.rs b/codex-rs/app-server/src/main.rsindex c29d9b95e1..4f36d3ae6c 100644--- a/codex-rs/app-server/src/main.rs+++ b/codex-rs/app-server/src/main.rs@@ -70,6 +70,10 @@ struct AppServerArgs {/// Enable remote control for this app-server process without changing persistence.#[arg(long = "remote-control", hide = true)]remote_control: bool,++ /// Save loaded threads during managed daemon shutdown.+ #[arg(long, hide = true)]+ managed_daemon: bool,}fn main() -> anyhow::Result<()> {@@ -85,6 +89,7 @@ fn main() -> anyhow::Result<()> {#[cfg(debug_assertions)]disable_plugin_startup_tasks_for_tests,remote_control,+ managed_daemon,} = AppServerArgs::parse();let loader_overrides = if disable_managed_config_from_debug_env() {LoaderOverrides::without_managed_config_for_tests()@@ -97,6 +102,7 @@ fn main() -> anyhow::Result<()> {let auth = auth.try_into_settings()?;let mut runtime_options = AppServerRuntimeOptions {code_mode_host_transport: code_mode_host.into(),+ managed_daemon,..Default::default()};#[cfg(debug_assertions)]@@ -110,7 +116,7 @@ fn main() -> anyhow::Result<()> {(false, false) => codex_app_server::RemoteControlStartupMode::ResolvePersisted,};- run_main_with_transport_options(+ let exit = run_main_with_transport_options(arg0_paths,config_overrides,loader_overrides,@@ -122,6 +128,10 @@ fn main() -> anyhow::Result<()> {runtime_options,).await?;+ if exit == codex_app_server::AppServerExit::Forced {+ // Runtime teardown can wait forever for blocked rollout I/O.+ std::process::exit(0);+ }Ok(())})}diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rsindex 0721f00be9..106d1a2027 100644--- a/codex-rs/app-server/src/message_processor.rs+++ b/codex-rs/app-server/src/message_processor.rs@@ -759,6 +759,10 @@ impl MessageProcessor {self.thread_processor.thread_created_receiver()}+ pub(crate) async fn persist_daemon_threads(&self) {+ self.thread_processor.persist_daemon_threads().await+ }+pub(crate) async fn send_initialize_notifications_to_connection(&self,connection_id: ConnectionId,@@ -951,7 +955,11 @@ impl MessageProcessor {| ClientRequest::ThreadFork { .. }| ClientRequest::ThreadResume { .. }| ClientRequest::ThreadRollback { .. }- | ClientRequest::ThreadRevert { .. } => (Some(self.turn_admission.admit()?), false),+ | ClientRequest::ThreadRevert { .. }+ | ClientRequest::ThreadSettingsUpdate { .. }+ | ClientRequest::TurnSettingsUpdate { .. }+ | ClientRequest::ThreadDelete { .. }+ | ClientRequest::ThreadArchive { .. } => (Some(self.turn_admission.admit()?), false),ClientRequest::TurnStart { .. }| ClientRequest::TurnSteer { .. }| ClientRequest::ReviewStart { .. }diff --git a/codex-rs/app-server/src/request_processors/daemon_snapshot.rs b/codex-rs/app-server/src/request_processors/daemon_snapshot.rsnew file mode 100644index 0000000000..8295e3dafb--- /dev/null+++ b/codex-rs/app-server/src/request_processors/daemon_snapshot.rs@@ -0,0 +1,35 @@+//! Persists loaded persistent root threads before managed daemon shutdown.+//! Failures are logged so other threads can still be saved.++use super::ThreadRequestProcessor;+use codex_thread_store::PersistContext;+use tracing::warn;++impl ThreadRequestProcessor {+ #[expect(+ clippy::await_holding_invalid_type,+ reason = "snapshot selection must be serialized against pending unloads"+ )]+ pub(crate) async fn persist_daemon_threads(&self) {+ for thread_id in self.thread_manager.list_thread_ids().await {+ let pending_unloads = self.pending_thread_unloads.lock().await;+ if pending_unloads.contains(&thread_id) {+ continue;+ }+ let Ok(thread) = self.thread_manager.get_thread(thread_id).await else {+ continue;+ };+ let config = thread.config_snapshot().await;+ if !config.ephemeral+ && config.parent_thread_id.is_none()+ && !config.session_source.is_non_root_agent()+ && let Err(err) = self+ .thread_store+ .persist_thread(thread_id, PersistContext::Standard)+ .await+ {+ warn!(%thread_id, %err, "failed to persist thread during daemon shutdown");+ }+ }+ }+}diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex cea25713f1..e17e0e38d7 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -1,3 +1,6 @@+#[path = "daemon_snapshot.rs"]+mod daemon_snapshot;+use super::persisted_resume_settings::PersistedResumeSettings;use super::persisted_resume_settings::latest_persisted_resume_settings;use super::thread_enrichment::enrich_loaded_threads;diff --git a/codex-rs/app-server/tests/suite/v2/connection_handling_websocket_unix.rs b/codex-rs/app-server/tests/suite/v2/connection_handling_websocket_unix.rsindex 095d3e3514..0575a4e1f2 100644--- a/codex-rs/app-server/tests/suite/v2/connection_handling_websocket_unix.rs+++ b/codex-rs/app-server/tests/suite/v2/connection_handling_websocket_unix.rs@@ -88,6 +88,15 @@ async fn websocket_transport_ctrl_c_waits_for_running_turn_before_exit() -> Resu("thread/start", json!({})),("thread/fork", json!({"threadId": thread_id})),("thread/resume", json!({"threadId": thread_id})),+ ("thread/delete", json!({"threadId": thread_id})),+ (+ "thread/settings/update",+ json!({"threadId": thread_id, "model": "other"}),+ ),+ (+ "turn/settings/update",+ json!({"threadId": thread_id, "turnId": "unused", "model": "other"}),+ ),("thread/rollback",json!({"threadId": thread_id, "numTurns": 1}),diff --git a/codex-rs/app-server/tests/suite/v2/daemon_update_recovery.rs b/codex-rs/app-server/tests/suite/v2/daemon_update_recovery.rsnew file mode 100644index 0000000000..0c4b3a8b41--- /dev/null+++ b/codex-rs/app-server/tests/suite/v2/daemon_update_recovery.rs@@ -0,0 +1,324 @@+//! Best-effort thread persistence during managed app-server shutdown.++use super::connection_handling_websocket::DEFAULT_READ_TIMEOUT;+use super::connection_handling_websocket::create_config_toml;+use anyhow::Context;+use anyhow::Result;+use app_test_support::DISABLE_PLUGIN_STARTUP_TASKS_ARG;+use app_test_support::create_final_assistant_message_sse_response;+use codex_app_server_protocol::InitializeCapabilities;+use codex_app_server_protocol::JSONRPCMessage;+use codex_app_server_protocol::RequestId;+use codex_app_server_protocol::ThreadStartResponse;+use codex_uds::UnixStream;+use core_test_support::streaming_sse::StreamingSseChunk;+use core_test_support::streaming_sse::start_streaming_sse_server;+use futures::SinkExt;+use futures::StreamExt;+use pretty_assertions::assert_eq;+use serde_json::json;+use std::path::Path;+#[cfg(unix)]+use std::process::Command as StdCommand;+use std::process::Stdio;+use tempfile::TempDir;+use tokio::process::Child;+use tokio::process::Command;+use tokio::sync::oneshot;+use tokio::time::Duration;+use tokio::time::sleep;+use tokio::time::timeout;+use tokio_tungstenite::WebSocketStream;+use tokio_tungstenite::client_async;+use tokio_tungstenite::tungstenite::Message;++#[tokio::test]+async fn managed_shutdown_persists_loaded_threads_after_active_turn() -> Result<()> {+ let home = TempDir::new()?;+ let (release_response, response_gate) = oneshot::channel();+ let (mock, _completions) =+ start_streaming_sse_server(vec![vec![stream_chunk(Some(response_gate), "Done")?]]).await;+ create_config_toml(home.path(), mock.uri(), "never")?;+ let socket_path = home.path().join("control/server.sock");+ let mut server = spawn_server(home.path(), &socket_path)?;+ let mut client = connect_default_daemon_client(&socket_path).await?;+ let active = start_thread(&mut client, /*id*/ 2, json!({})).await?;+ let idle = start_thread(&mut client, /*id*/ 3, json!({})).await?;+ start_turn(&mut client, /*id*/ 4, &active.thread.id).await?;+ wait_for_requests(&mock, /*count*/ 1).await?;+ request_shutdown(&server, &socket_path).await?;+ assert_still_running(&mut server, "active turn must finish first").await;+ release_response.send(()).expect("response is waiting");+ wait_success(&mut server).await?;++ let mut successor = spawn_server(home.path(), &socket_path)?;+ let mut reconnected = connect_default_daemon_client(&socket_path).await?;+ for (id, thread) in [(2, &active.thread), (3, &idle.thread)] {+ let resumed = request(+ &mut reconnected,+ id,+ "thread/resume",+ json!({"threadId":thread.id}),+ )+ .await?;+ assert_eq!(resumed["thread"]["id"], thread.id);+ if thread.id == active.thread.id {+ assert!(+ resumed["thread"]["turns"][0]["items"]+ .as_array()+ .context("recovered turn items")?+ .iter()+ .any(|item| item["type"] == "agentMessage" && item["text"] == "Done")+ );+ }+ }+ request_shutdown(&successor, &socket_path).await?;+ wait_success(&mut successor).await?;+ Ok(())+}++#[tokio::test]+async fn managed_force_shutdown_exits_with_active_work() -> Result<()> {+ let home = TempDir::new()?;+ let (_release_response, response_gate) = oneshot::channel();+ let (mock, _completions) =+ start_streaming_sse_server(vec![vec![stream_chunk(Some(response_gate), "Done")?]]).await;+ create_config_toml(home.path(), mock.uri(), "never")?;+ let socket_path = home.path().join("control/server.sock");+ let mut server = spawn_server(home.path(), &socket_path)?;+ let mut client = connect_default_daemon_client(&socket_path).await?;+ let thread = start_thread(&mut client, /*id*/ 2, json!({})).await?;+ start_turn(&mut client, /*id*/ 3, &thread.thread.id).await?;+ wait_for_requests(&mock, /*count*/ 1).await?;+ request_shutdown(&server, &socket_path).await?;+ assert_still_running(&mut server, "graceful shutdown must wait").await;+ request_shutdown(&server, &socket_path).await?;+ wait_success(&mut server).await?;+ Ok(())+}++#[cfg(unix)]+#[tokio::test]+async fn managed_force_shutdown_exits_with_blocked_rollout_writer() -> Result<()> {+ let home = TempDir::new()?;+ let mock = wiremock::MockServer::start().await;+ create_config_toml(home.path(), &mock.uri(), "never")?;+ let socket_path = home.path().join("control/server.sock");+ let mut server = spawn_server(home.path(), &socket_path)?;+ let mut client = connect_default_daemon_client(&socket_path).await?;+ let thread = start_thread(&mut client, /*id*/ 2, json!({})).await?;+ let rollout = thread+ .thread+ .path+ .context("persistent thread rollout path")?;+ assert!(!rollout.exists(), "idle rollout should still be deferred");+ let compressed = rollout.with_extension("jsonl.zst");+ std::fs::create_dir_all(compressed.parent().context("rollout directory")?)?;+ assert!(+ StdCommand::new("mkfifo")+ .arg(&compressed)+ .status()?+ .success()+ );++ request_shutdown(&server, &socket_path).await?;+ // Opening the write end succeeds only once the real rollout writer opens+ // the compressed input. Keep it empty and open to block that writer's read.+ let _blocked_input = timeout(Duration::from_secs(10), async {+ loop {+ if let Ok(sender) = tokio::net::unix::pipe::OpenOptions::new().open_sender(&compressed)+ {+ return sender;+ }+ sleep(Duration::from_millis(25)).await;+ }+ })+ .await+ .context("rollout writer did not open the blocked input")?;+ assert_still_running(&mut server, "graceful shutdown must wait for the writer").await;+ request_shutdown(&server, &socket_path).await?;+ wait_success(&mut server).await?;+ Ok(())+}++async fn wait_success(server: &mut Child) -> Result<()> {+ anyhow::ensure!(+ timeout(Duration::from_secs(10), server.wait())+ .await??+ .success(),+ "server did not exit successfully"+ );+ Ok(())+}++async fn assert_still_running(server: &mut Child, message: &str) {+ assert!(+ timeout(Duration::from_millis(300), server.wait())+ .await+ .is_err(),+ "{message}"+ );+}++fn stream_chunk(gate: Option<oneshot::Receiver<()>>, body: &str) -> Result<StreamingSseChunk> {+ Ok(StreamingSseChunk {+ gate,+ body: create_final_assistant_message_sse_response(body)?,+ })+}++async fn wait_for_requests(+ mock: &core_test_support::streaming_sse::StreamingSseServer,+ count: usize,+) -> Result<()> {+ timeout(Duration::from_secs(5), mock.wait_for_request_count(count)).await?;+ Ok(())+}++async fn start_turn(+ websocket: &mut WebSocketStream<UnixStream>,+ id: i64,+ thread_id: impl serde::Serialize,+) -> Result<()> {+ request(+ websocket,+ id,+ "turn/start",+ json!({"threadId":thread_id,"input":[{"type":"text","text":"Hello"}]}),+ )+ .await?;+ Ok(())+}++async fn start_thread(+ websocket: &mut WebSocketStream<UnixStream>,+ id: i64,+ params: serde_json::Value,+) -> Result<ThreadStartResponse> {+ Ok(serde_json::from_value(+ request(websocket, id, "thread/start", params).await?,+ )?)+}++async fn connect_default_daemon_client(socket_path: &Path) -> Result<WebSocketStream<UnixStream>> {+ connect_daemon_client(socket_path, InitializeCapabilities::default()).await+}++async fn connect_daemon_client(+ socket_path: &Path,+ capabilities: InitializeCapabilities,+) -> Result<WebSocketStream<UnixStream>> {+ connect_initialized(socket_path, capabilities, "daemon_recovery_test", "0.1.0").await+}++fn spawn_server(home: &Path, socket_path: &Path) -> Result<Child> {+ let binary = codex_utils_cargo_bin::cargo_bin("codex-app-server")?;+ Ok(Command::new(binary)+ .args(["--listen", &format!("unix://{}", socket_path.display())])+ .arg(DISABLE_PLUGIN_STARTUP_TASKS_ARG)+ .env("CODEX_HOME", home)+ .arg("--managed-daemon")+ .env(+ codex_app_server_transport::DAEMON_SHUTDOWN_SOCKET_ENV,+ socket_path,+ )+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .kill_on_drop(true)+ .spawn()?)+}++#[cfg(unix)]+async fn request_shutdown(server: &Child, _socket_path: &Path) -> Result<()> {+ let pid = server.id().context("server pid")?;+ let status = StdCommand::new("kill")+ .arg("-TERM")+ .arg(pid.to_string())+ .status()?;+ anyhow::ensure!(status.success(), "failed to signal server {pid}: {status}");+ Ok(())+}++#[cfg(windows)]+async fn request_shutdown(server: &Child, socket_path: &Path) -> Result<()> {+ let pid = server.id().context("server pid")?.to_string();+ timeout(DEFAULT_READ_TIMEOUT, async {+ let stream = UnixStream::connect(socket_path).await?;+ let (mut websocket, _) = client_async("ws://localhost/daemon/shutdown", stream).await?;+ websocket.send(Message::Text(pid.clone().into())).await?;+ let reply = websocket+ .next()+ .await+ .context("missing shutdown acknowledgment")??;+ assert_eq!(reply, Message::Text(pid.into()));+ websocket.close(None).await?;+ Ok(())+ })+ .await?+}++async fn connect_initialized(+ socket_path: &Path,+ capabilities: InitializeCapabilities,+ client_name: &str,+ client_version: &str,+) -> Result<WebSocketStream<UnixStream>> {+ let mut websocket = timeout(DEFAULT_READ_TIMEOUT, async {+ loop {+ if let Ok(stream) = UnixStream::connect(socket_path).await+ && let Ok((websocket, _)) = client_async("ws://localhost/", stream).await+ {+ return websocket;+ }+ sleep(Duration::from_millis(25)).await;+ }+ })+ .await+ .context("server did not open its control socket")?;+ request(+ &mut websocket,+ /*id*/ 1,+ "initialize",+ json!({"clientInfo":{"name":client_name,"version":client_version},"capabilities":capabilities}),+ )+ .await?;+ websocket+ .send(Message::Text(+ json!({"method":"initialized"}).to_string().into(),+ ))+ .await?;+ Ok(websocket)+}++async fn request(+ websocket: &mut WebSocketStream<UnixStream>,+ id: i64,+ method: &str,+ params: serde_json::Value,+) -> Result<serde_json::Value> {+ websocket+ .send(Message::Text(+ json!({"id":id,"method":method,"params":params})+ .to_string()+ .into(),+ ))+ .await?;+ timeout(DEFAULT_READ_TIMEOUT, async {+ loop {+ let frame = websocket.next().await.context("socket closed")??;+ let Message::Text(text) = frame else { continue };+ match serde_json::from_str::<JSONRPCMessage>(&text)? {+ JSONRPCMessage::Response(response) if response.id == RequestId::Integer(id) => {+ return Ok(response.result);+ }+ JSONRPCMessage::Error(error) if error.id == RequestId::Integer(id) => {+ anyhow::bail!("{}: {}", method, error.error.message);+ }+ _ => {}+ }+ }+ })+ .await+ .context("timed out waiting for app-server response")?+}diff --git a/codex-rs/app-server/tests/suite/v2/mod.rs b/codex-rs/app-server/tests/suite/v2/mod.rsindex c7bc32d01f..654f9e78df 100644--- a/codex-rs/app-server/tests/suite/v2/mod.rs+++ b/codex-rs/app-server/tests/suite/v2/mod.rs@@ -25,6 +25,7 @@ mod connection_handling_websocket_unix;mod curated_mcp_sync;mod current_time;mod cyber_access_program;+mod daemon_update_recovery;mod daybreak_access;mod dynamic_tools;mod environment_add;diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex d234575b79..ee42ceb1e5 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -577,6 +577,10 @@ struct AppServerCommand {#[arg(long = "remote-control", hide = true)]remote_control: bool,+ /// Save loaded threads during managed daemon shutdown.+ #[arg(long, hide = true)]+ managed_daemon: bool,+/// Controls whether analytics are enabled by default.////// Analytics are disabled by default for app-server. Users have to explicitly opt in@@ -1319,6 +1323,7 @@ async fn cli_main(listen,stdio,remote_control,+ managed_daemon,analytics_default_enabled,auth,} = app_server_cli;@@ -1339,6 +1344,7 @@ async fn cli_main(let auth = auth.try_into_settings()?;let runtime_options = codex_app_server::AppServerRuntimeOptions {code_mode_host_transport: code_mode_host.into(),+ managed_daemon,remote_control_startup_mode: match (remote_control, remote_control_disabled){(true, _) => {@@ -1353,7 +1359,7 @@ async fn cli_main(},..Default::default()};- codex_app_server::run_main_with_transport_options(+ let exit = codex_app_server::run_main_with_transport_options(arg0_paths.clone(),root_config_overrides,LoaderOverrides::default(),@@ -1365,6 +1371,10 @@ async fn cli_main(runtime_options,).await?;+ if exit == codex_app_server::AppServerExit::Forced {+ // Runtime teardown can wait forever for blocked rollout I/O.+ std::process::exit(0);+ }}Some(AppServerSubcommand::Daemon(daemon_cli)) => match daemon_cli.subcommand {AppServerDaemonSubcommand::Start => {diff --git a/codex-rs/cli/src/remote_control_cmd.rs b/codex-rs/cli/src/remote_control_cmd.rsindex bd0f16b82f..f70125c7d8 100644--- a/codex-rs/cli/src/remote_control_cmd.rs+++ b/codex-rs/cli/src/remote_control_cmd.rs@@ -129,7 +129,7 @@ async fn run_foreground_remote_control(..Default::default()};let (stop_rx, stop_signal_task) = foreground_stop_signal();- let mut app_server_task = tokio::spawn(codex_app_server::run_main_with_transport_options(+ let app_server = codex_app_server::run_main_with_transport_options(arg0_paths,root_config_overrides,LoaderOverrides::default(),@@ -139,7 +139,8 @@ async fn run_foreground_remote_control(SessionSource::VSCode,AppServerWebsocketAuthSettings::default(),runtime_options,- ));+ );+ let mut app_server_task = tokio::spawn(async move { app_server.await.map(|_| ()) });let summary = match wait_for_foreground_remote_control_start(&mut app_server_task,