Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Exit the stdio app-server when its connection closes (#36035)

Gabriel Peal9cf6b3905c10
diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rs
index e355bfe02a..200df63399 100644
--- a/codex-rs/app-server/src/lib.rs
+++ b/codex-rs/app-server/src/lib.rs
@@ -34,6 +34,7 @@ use crate::outgoing_message::OutgoingEnvelope;
use crate::outgoing_message::OutgoingMessageSender;
use crate::outgoing_message::QueuedOutgoingMessage;
use crate::transport::CHANNEL_CAPACITY;
+use crate::transport::ConnectionOrigin;
use crate::transport::ConnectionState;
use crate::transport::OutboundConnectionState;
use crate::transport::RemoteControlPolicy;
@@ -709,7 +710,6 @@ pub async fn run_main_with_transport_options(
let mut transport_accept_handles = Vec::<JoinHandle<()>>::new();
let single_client_mode = matches!(&transport, AppServerTransport::Stdio);
- let shutdown_when_no_connections = single_client_mode;
let graceful_signal_restart_enabled =
runtime_options.install_shutdown_signal_handler && !single_client_mode;
let mut app_server_client_name_rx = None;
@@ -991,6 +991,7 @@ pub async fn run_main_with_transport_options(
let Some(connection_state) = connections.remove(&connection_id) else {
continue;
};
+ let stdio_closed = connection_state.origin == ConnectionOrigin::Stdio;
connection_state.session.rpc_gate.close().await;
let outbound_closed = outbound_control_tx
.send(OutboundControlEvent::Closed { connection_id })
@@ -1005,8 +1006,8 @@ pub async fn run_main_with_transport_options(
if !outbound_closed {
break "outbound_router_closed";
}
- if shutdown_when_no_connections && connections.is_empty() {
- break "last_connection_closed";
+ if single_client_mode && stdio_closed {
+ break "stdio_connection_closed";
}
}
TransportEvent::IncomingMessage { connection_id, message } => {
diff --git a/codex-rs/app-server/src/transport.rs b/codex-rs/app-server/src/transport.rs
index 89b2d1e814..62b3da44cd 100644
--- a/codex-rs/app-server/src/transport.rs
+++ b/codex-rs/app-server/src/transport.rs
@@ -37,6 +37,7 @@ pub(crate) use codex_app_server_transport::start_websocket_acceptor;
pub use codex_app_server_transport::take_remote_control_disabled_env;
pub(crate) struct ConnectionState {
+ pub(crate) origin: ConnectionOrigin,
pub(crate) outbound_initialized: Arc<AtomicBool>,
pub(crate) outbound_experimental_api_enabled: Arc<AtomicBool>,
pub(crate) outbound_opted_out_notification_methods: Arc<RwLock<HashSet<String>>>,
@@ -45,12 +46,13 @@ pub(crate) struct ConnectionState {
impl ConnectionState {
pub(crate) fn new(
- _origin: ConnectionOrigin,
+ origin: ConnectionOrigin,
outbound_initialized: Arc<AtomicBool>,
outbound_experimental_api_enabled: Arc<AtomicBool>,
outbound_opted_out_notification_methods: Arc<RwLock<HashSet<String>>>,
) -> Self {
Self {
+ origin,
outbound_initialized,
outbound_experimental_api_enabled,
outbound_opted_out_notification_methods,
diff --git a/codex-rs/app-server/tests/suite/logging.rs b/codex-rs/app-server/tests/suite/logging.rs
index 04486a70ce..fbd79218d2 100644
--- a/codex-rs/app-server/tests/suite/logging.rs
+++ b/codex-rs/app-server/tests/suite/logging.rs
@@ -33,7 +33,7 @@ fn standalone_app_server_emits_json_info_events() -> Result<()> {
"level": "INFO",
"fields": {
"message": "processor task exited",
- "exit_reason": "last_connection_closed",
+ "exit_reason": "stdio_connection_closed",
"remaining_connection_count": 0,
"shutdown_forced": false,
},
diff --git a/codex-rs/app-server/tests/suite/v2/remote_control.rs b/codex-rs/app-server/tests/suite/v2/remote_control.rs
index c8805062b8..a8a843e3d0 100644
--- a/codex-rs/app-server/tests/suite/v2/remote_control.rs
+++ b/codex-rs/app-server/tests/suite/v2/remote_control.rs
@@ -44,6 +44,8 @@ use codex_protocol::protocol::SessionSource;
use codex_state::RemoteControlEnrollmentRecord;
use codex_state::StateRuntime;
use codex_utils_cli::CliConfigOverrides;
+use futures::SinkExt;
+use futures::StreamExt;
use pretty_assertions::assert_eq;
use serial_test::serial;
use tempfile::TempDir;
@@ -56,6 +58,8 @@ use tokio::net::TcpStream;
use tokio::sync::oneshot;
use tokio::task::JoinHandle;
use tokio::time::timeout;
+use tokio_tungstenite::accept_async;
+use tokio_tungstenite::tungstenite::Message;
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
const STARTUP_TIMEOUT: Duration = Duration::from_secs(30);
@@ -465,6 +469,27 @@ async fn remote_control_enable_returns_connecting_status() -> Result<()> {
Ok(())
}
+#[tokio::test]
+async fn stdio_eof_exits_with_remote_control_connection() -> Result<()> {
+ let codex_home = TempDir::new()?;
+ let mut backend = ConnectedRemoteControlBackend::start(codex_home.path()).await?;
+ let mut app_server = TestAppServer::builder()
+ .with_codex_home(codex_home.path())
+ .without_auto_env()
+ .build_initialized()
+ .await?;
+
+ let request_id = app_server.send_remote_control_enable_request().await?;
+ let _: RemoteControlEnableResponse =
+ timeout(DEFAULT_TIMEOUT, app_server.read_response(request_id)).await??;
+ timeout(DEFAULT_TIMEOUT, backend.wait_until_initialized()).await??;
+
+ let status = timeout(DEFAULT_TIMEOUT, app_server.shutdown_gracefully()).await??;
+ assert!(status.success());
+ timeout(DEFAULT_TIMEOUT, backend.wait_for_disconnect()).await??;
+ Ok(())
+}
+
#[tokio::test]
async fn disable_waits_for_in_flight_durable_enable() -> Result<()> {
let codex_home = TempDir::new()?;
@@ -806,11 +831,131 @@ struct BlockingRemoteControlBackend {
server_task: JoinHandle<()>,
}
+struct ConnectedRemoteControlBackend {
+ initialized_rx: Option<oneshot::Receiver<std::result::Result<(), String>>>,
+ server_task: JoinHandle<Result<()>>,
+}
+
struct ClientManagementRemoteControlBackend {
requests_rx: Option<oneshot::Receiver<Result<Vec<String>>>>,
server_task: JoinHandle<()>,
}
+impl ConnectedRemoteControlBackend {
+ async fn start(codex_home: &std::path::Path) -> Result<Self> {
+ let listener = configured_remote_control_listener(codex_home).await?;
+ let (initialized_tx, initialized_rx) = oneshot::channel();
+ let server_task = tokio::spawn(async move {
+ let mut initialized_tx = Some(initialized_tx);
+ let result: Result<()> = async {
+ let (_request_line, reader) = read_enroll_request(&listener).await?;
+ respond_with_json(
+ reader.into_inner(),
+ serde_json::json!({
+ "server_id": "server-id",
+ "environment_id": "environment-id",
+ "remote_control_token": "remote-control-token",
+ "expires_at": "3026-05-22T12:34:56Z",
+ }),
+ )
+ .await?;
+
+ let (stream, _) = listener.accept().await?;
+ let mut websocket = accept_async(stream).await?;
+ websocket
+ .send(Message::Text(
+ serde_json::json!({
+ "type": "client_message",
+ "client_id": "client-id",
+ "stream_id": "stream-id",
+ "seq_id": 0,
+ "message": {
+ "id": 1,
+ "method": "initialize",
+ "params": {
+ "clientInfo": {
+ "name": "remote-test-client",
+ "version": "0.1.0",
+ },
+ },
+ },
+ })
+ .to_string()
+ .into(),
+ ))
+ .await?;
+
+ loop {
+ let message = websocket
+ .next()
+ .await
+ .context("remote control disconnected before initialize response")??;
+ let Message::Text(message) = message else {
+ continue;
+ };
+ let message: serde_json::Value = serde_json::from_str(&message)?;
+ if message["type"] == "server_message" && message["message"]["id"] == 1 {
+ break;
+ }
+ }
+
+ websocket
+ .send(Message::Text(
+ serde_json::json!({
+ "type": "client_message",
+ "client_id": "client-id",
+ "stream_id": "stream-id",
+ "seq_id": 1,
+ "message": {
+ "method": "initialized",
+ },
+ })
+ .to_string()
+ .into(),
+ ))
+ .await?;
+ if let Some(initialized_tx) = initialized_tx.take() {
+ let _ = initialized_tx.send(Ok(()));
+ }
+
+ while let Some(message) = websocket.next().await {
+ match message {
+ Ok(Message::Close(_)) | Err(_) => break,
+ Ok(_) => {}
+ }
+ }
+ Ok(())
+ }
+ .await;
+
+ if let Err(err) = &result
+ && let Some(initialized_tx) = initialized_tx.take()
+ {
+ let _ = initialized_tx.send(Err(err.to_string()));
+ }
+ result
+ });
+
+ Ok(Self {
+ initialized_rx: Some(initialized_rx),
+ server_task,
+ })
+ }
+
+ async fn wait_until_initialized(&mut self) -> Result<()> {
+ self.initialized_rx
+ .take()
+ .context("remote control initialization should only be awaited once")?
+ .await?
+ .map_err(anyhow::Error::msg)
+ }
+
+ async fn wait_for_disconnect(&mut self) -> Result<()> {
+ (&mut self.server_task).await??;
+ Ok(())
+ }
+}
+
impl ClientManagementRemoteControlBackend {
async fn start(codex_home: &std::path::Path) -> Result<Self> {
let listener = configured_remote_control_listener(codex_home).await?;
@@ -1043,6 +1188,12 @@ impl Drop for BlockingRemoteControlBackend {
}
}
+impl Drop for ConnectedRemoteControlBackend {
+ fn drop(&mut self) {
+ self.server_task.abort();
+ }
+}
+
impl Drop for ClientManagementRemoteControlBackend {
fn drop(&mut self) {
self.server_task.abort();
diff --git a/codex-rs/cli/tests/app_server.rs b/codex-rs/cli/tests/app_server.rs
index 6815c2be99..455c9f668b 100644
--- a/codex-rs/cli/tests/app_server.rs
+++ b/codex-rs/cli/tests/app_server.rs
@@ -43,7 +43,7 @@ fn app_server_emits_json_info_events() -> Result<()> {
"level": "INFO",
"fields": {
"message": "processor task exited",
- "exit_reason": "last_connection_closed",
+ "exit_reason": "stdio_connection_closed",
"remaining_connection_count": 0,
"shutdown_forced": false,
},