Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Ignore stale thread-close notifications after resuming a thread (#47155)

Eric Trautbf7c87a7b7bd
diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rs
index 80b9595f60..fbea229338 100644
--- a/codex-rs/tui/src/app/app_server_events.rs
+++ b/codex-rs/tui/src/app/app_server_events.rs
@@ -14,6 +14,7 @@ use crate::app_info::app_info_from_api;
use crate::app_server_session::AppServerSession;
use crate::app_server_session::status_account_display_from_auth_mode;
use codex_app_server_client::AppServerEvent;
+use codex_app_server_client::TypedRequestError;
use codex_app_server_protocol::AuthMode;
use codex_app_server_protocol::ClientRequest;
use codex_app_server_protocol::RateLimitReachedType;
@@ -25,8 +26,10 @@ use codex_app_server_protocol::ThreadItem;
use codex_app_server_protocol::ThreadReadParams;
use codex_app_server_protocol::ThreadReadResponse;
use codex_app_server_protocol::ThreadSource;
+use codex_app_server_protocol::ThreadStatus;
use codex_protocol::ThreadId;
use codex_protocol::protocol::SubAgentSource;
+use std::time::Duration;
impl App {
pub(super) fn refresh_mcp_startup_expected_servers_from_config(&mut self) {
@@ -116,6 +119,62 @@ impl App {
app_server_client: &AppServerSession,
notification: ServerNotification,
) {
+ // A picker can leave an old runtime's close notification queued while the same thread
+ // is resumed. Thread IDs survive reloads, so confirm that the displayed thread is still
+ // unloaded before routing a close that would exit the TUI or switch away from it.
+ if let ServerNotification::ThreadClosed(closed) = &notification
+ && let Ok(thread_id) = ThreadId::from_string(&closed.thread_id)
+ && self.current_displayed_thread_id() == Some(thread_id)
+ {
+ let deadline = tokio::time::Instant::now() + Duration::from_secs(/*secs*/ 5);
+ for attempt in 0..2 {
+ let result = tokio::time::timeout_at(
+ deadline,
+ app_server_client
+ .request_handle()
+ .request_typed::<ThreadReadResponse>(ClientRequest::ThreadRead {
+ request_id: RequestId::String(format!(
+ "thread-closed-{thread_id}-{attempt}"
+ )),
+ params: ThreadReadParams {
+ thread_id: closed.thread_id.clone(),
+ include_turns: false,
+ },
+ }),
+ )
+ .await;
+ match result {
+ Ok(Ok(response))
+ if !matches!(response.thread.status, ThreadStatus::NotLoaded) =>
+ {
+ return;
+ }
+ Ok(Ok(_)) => break,
+ // Unpersisted closed threads can no longer be read. Preserve that close
+ // and compatibility with servers that do not support this request.
+ Ok(Err(TypedRequestError::Server { source, .. }))
+ if matches!(source.code, -32602..=-32600) =>
+ {
+ break;
+ }
+ Ok(Err(TypedRequestError::Server { source, .. }))
+ if source.code == -32603 && attempt == 0 =>
+ {
+ continue;
+ }
+ Ok(Err(_)) | Err(_) => {
+ // A failed read does not confirm closure. Remote connections recover
+ // through the normal reconnect path, rather than exiting the TUI.
+ tracing::warn!("could not confirm displayed thread closure");
+ if self.begin_reconnect() {
+ return;
+ }
+ break;
+ }
+ }
+ }
+ }
+
if let ServerNotification::ThreadStatusChanged(status) = &notification {
let _ = self.dynamic_tool_status_updates.send(status.clone());
}
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 769afb0a1b..b111d7e068 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -71,6 +71,8 @@ mod realtime_start;
mod reasoning_resume_tests;
#[path = "tests/recap_generation_tests.rs"]
mod recap_generation;
+#[path = "tests/resume_shutdown_tests.rs"]
+mod resume_shutdown_tests;
mod safety_buffering;
#[path = "tests/session_lifecycle_requests.rs"]
mod session_lifecycle_requests;
diff --git a/codex-rs/tui/src/app/tests/resume_shutdown_tests.rs b/codex-rs/tui/src/app/tests/resume_shutdown_tests.rs
new file mode 100644
index 0000000000..654cc03742
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/resume_shutdown_tests.rs
@@ -0,0 +1,149 @@
+//! A delayed close must not shut down a thread that has already been reloaded.
+
+use super::disconnect::serve_reconnect_requests;
+use super::*;
+use crate::app_server_session::ThreadParamsMode;
+use codex_app_server_client::AppServerEvent;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+use tokio::net::TcpListener;
+
+#[tokio::test]
+async fn thread_close_exits_only_when_displayed_thread_is_unloaded() -> Result<()> {
+ let (mut app, mut events, _commands) = make_test_app_with_channels().await;
+ app.config.thread_unload_delay = Duration::ZERO;
+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
+ let started = server.start_thread(&app.config).await?;
+ let thread_id = started.session.thread_id;
+ app.enqueue_primary_thread_session(started.session, started.turns)
+ .await?;
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ app.drain_active_thread_events(&mut tui).await?;
+
+ // The old runtime's notification can arrive after this thread ID is loaded again.
+ app.handle_app_server_event(
+ &server,
+ AppServerEvent::ServerNotification(Box::new(thread_closed_notification(thread_id))),
+ )
+ .await;
+ app.drain_active_thread_events(&mut tui).await?;
+ assert!(
+ !std::iter::from_fn(|| events.try_recv().ok())
+ .any(|event| matches!(event, AppEvent::Exit(_)))
+ );
+
+ // A genuine close must still exit.
+ server.thread_unsubscribe(thread_id).await?;
+ let closed = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {
+ while let Some(event) = server.next_event().await {
+ if matches!(&event,
+ AppServerEvent::ServerNotification(notification)
+ if matches!(notification.as_ref(), ServerNotification::ThreadClosed(closed)
+ if closed.thread_id == thread_id.to_string()))
+ {
+ return event;
+ }
+ }
+ panic!("server event stream ended before the thread closed");
+ })
+ .await?;
+ app.handle_app_server_event(&server, closed).await;
+ app.drain_active_thread_events(&mut tui).await?;
+ assert!(
+ std::iter::from_fn(|| events.try_recv().ok())
+ .any(|event| matches!(event, AppEvent::Exit(ExitMode::Immediate)))
+ );
+ server.shutdown().await?;
+ Ok(())
+}
+
+#[tokio::test]
+async fn failed_close_status_read_reconnects_remote_or_closes_embedded() -> Result<()> {
+ for (failure, expected_reads, offline) in [
+ ("disconnect", 1, true),
+ ("timeout", 1, true),
+ ("transient", 2, false),
+ ("persistent", 2, true),
+ ("embedded", 2, false),
+ ("unsupported", 1, false),
+ ] {
+ let (mut app, mut events, _commands) = make_test_app_with_channels().await;
+ let id = ThreadId::new();
+ app.enqueue_primary_thread_session(
+ test_thread_session(id, app.config.cwd.to_path_buf()),
+ Vec::new(),
+ )
+ .await?;
+ let listener = TcpListener::bind("127.0.0.1:0").await?;
+ let endpoint = crate::resolve_remote_addr(&format!("ws://{}", listener.local_addr()?))?;
+ if failure != "embedded" {
+ app.app_server_target = AppServerTarget::Remote {
+ endpoint: endpoint.clone(),
+ };
+ }
+ let reads = Arc::new(AtomicUsize::new(/*v*/ 0));
+ let server_reads = reads.clone();
+ let cwd = app.config.cwd.clone();
+ let server = tokio::spawn(async move {
+ let (stream, _) = listener.accept().await?;
+ serve_reconnect_requests(
+ tokio_tungstenite::accept_async(stream).await?,
+ move |request| {
+ assert_eq!(request.method, "thread/read");
+ let attempt = server_reads.fetch_add(/*val*/ 1, Ordering::SeqCst);
+ let response = match failure {
+ "disconnect" | "timeout" => None,
+ "unsupported" => {
+ Some(json!({"error": {"code": -32601, "message": "method not found"}}))
+ }
+ "transient" if attempt == 1 => Some(json!({"result": {"thread": {
+ "id": id, "sessionId": id, "preview": "", "ephemeral": false,
+ "modelProvider": "test-provider", "createdAt": 1, "updatedAt": 2,
+ "status": {"type": "idle"}, "cwd": cwd, "cliVersion": "0.0.0",
+ "source": "cli", "turns": []
+ }}})),
+ _ => {
+ Some(json!({"error": {"code": -32603, "message": "temporary failure"}}))
+ }
+ };
+ async move {
+ if failure == "timeout" {
+ std::future::pending::<()>().await;
+ }
+ response
+ }
+ },
+ )
+ .await
+ });
+ let session = AppServerSession::new(
+ crate::connect_remote_app_server(endpoint).await?,
+ ThreadParamsMode::Remote,
+ );
+ tokio::time::timeout(
+ Duration::from_secs(/*secs*/ 10),
+ app.handle_app_server_event(
+ &session,
+ AppServerEvent::ServerNotification(Box::new(thread_closed_notification(id))),
+ ),
+ )
+ .await?;
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ app.drain_active_thread_events(&mut tui).await?;
+ assert_eq!(
+ (reads.load(Ordering::SeqCst), app.reconnect.offline),
+ (expected_reads, offline),
+ "{failure}"
+ );
+ assert_eq!(
+ std::iter::from_fn(|| events.try_recv().ok())
+ .any(|event| matches!(event, AppEvent::Exit(_) | AppEvent::FatalExitRequest(_))),
+ matches!(failure, "embedded" | "unsupported"),
+ "{failure}"
+ );
+ server.abort();
+ let _ = server.await;
+ session.shutdown().await?;
+ }
+ Ok(())
+}