From 2f7c5a858865b413f5b56ebe1af70fbeb349b218 Mon Sep 17 00:00:00 2001 From: Benjamin Carlsson Date: Wed, 18 Nov 2026 00:52:34 +0000 Subject: [PATCH] Cancel Cloud overview refreshes that block TUI navigation (#62150) ## Why An in-flight Cloud task list from the agents overview can keep the Cloud worker busy while the TUI waits for a session request, such as listing tasks in the resume picker or unsubscribing from a discarded blank task. ## What changed Cancel the affected backend's Cloud overview refresh when dismissing the overview or before session operations that need the same worker. Wait for the aborted task to drop its request before proceeding. When opening the resume picker, clear queued Cloud refreshes first so canceling the active refresh cannot start another page ahead of the picker's requests. ## Testing Add regression tests that hold Cloud list requests open while returning to the current chat, opening the resume picker, or switching backends. Cover canceling a refresh before starting a fresh plan implementation session and preserving another backend's in-flight page during archive. GitOrigin-RevId: 94993aa0014ac895a30f454e3ff5f4cbc45bb429 --- codex-rs/tui/src/app.rs | 13 + codex-rs/tui/src/app/agents_overview.rs | 13 +- .../src/app/agents_overview_actions_tests.rs | 76 +++ .../app/agents_overview_discovery_tests.rs | 473 ++++++++++++++++++ codex-rs/tui/src/app/agents_overview_new.rs | 1 + codex-rs/tui/src/app/agents_overview_tests.rs | 25 +- .../tui/src/app/agents_overview_threads.rs | 2 +- codex-rs/tui/src/app/backend_selection.rs | 39 +- codex-rs/tui/src/app/session_lifecycle.rs | 2 + codex-rs/tui/src/app/session_picker.rs | 11 + .../app/tests/navigation_reconnect_tests.rs | 9 +- .../tui/src/app/tests/new_session_tests.rs | 70 +++ codex-rs/tui/src/app/voice_owner.rs | 1 + 13 files changed, 711 insertions(+), 24 deletions(-) diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index bb13706ec6..5bc667d1b7 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -1345,7 +1345,20 @@ impl App { } else { match event { TuiEvent::Key(key_event) => { + let overview_id = agents_overview::AGENTS_OVERVIEW_VIEW_ID; + let overview_was_open = self + .chat_widget + .selected_index_for_present_view(overview_id) + .is_some(); self.handle_key_event(tui, app_server, key_event).await; + if overview_was_open + && self + .chat_widget + .selected_index_for_present_view(overview_id) + .is_none() + { + self.cancel_cloud_inventory_refresh(app_server).await; + } } TuiEvent::Paste(pasted) => { // Pasted text may contain CRLF pairs or bare CRs (e.g., from iTerm2), diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rs index 869273050b..0db25eff23 100644 --- a/codex-rs/tui/src/app/agents_overview.rs +++ b/codex-rs/tui/src/app/agents_overview.rs @@ -72,7 +72,7 @@ pub(super) struct AgentsOverviewState { pub(super) active_refresh_thread_ids: HashSet, pub(super) pins_by_backend: std::collections::BTreeMap>>, pub(super) pending_pin_change: Option<(Uuid, BackendId)>, - pub(super) refresh_task: Option, + pub(super) refresh_task: Option>, pub(super) refresh_notifications: HashMap>, pub(super) rendered_full_screen: bool, pub(super) visible_thread_ids: Vec, @@ -383,13 +383,18 @@ impl App { .is_some_and(|owner| overview.has_more_for(&self.backend_registry, owner)); } - pub(super) fn cancel_agents_overview_refresh(&mut self, backend_id: BackendId) { + pub(super) fn cancel_agents_overview_refresh( + &mut self, + backend_id: BackendId, + ) -> Option> { let overview = &mut self.agents_overview; + let mut canceled = None; if overview .active_refresh .is_some_and(|(_, owner)| owner == backend_id) { - if let Some(task) = overview.refresh_task.take() { + canceled = overview.refresh_task.take(); + if let Some(task) = &canceled { task.abort(); } overview.active_refresh = None; @@ -434,6 +439,7 @@ impl App { }); } self.repaint_agents_overview(); + canceled } pub(super) fn repaint_agents_overview(&mut self) { @@ -711,6 +717,7 @@ impl App { if self.current_displayed_thread_id() == Some(root_thread_id) && (!self.thread_unavailable(root_thread_id) || self.chat_widget.is_read_only_view()) { + self.cancel_cloud_inventory_refresh(app_server).await; // Keep the displayed read-only snapshot frozen; R explicitly retries attachment. if let Ok(mut state) = self.agents_overview.view_state.lock() { state.completion = Some(crate::bottom_pane::ViewCompletion::Accepted); diff --git a/codex-rs/tui/src/app/agents_overview_actions_tests.rs b/codex-rs/tui/src/app/agents_overview_actions_tests.rs index 97c762786d..df833a27b2 100644 --- a/codex-rs/tui/src/app/agents_overview_actions_tests.rs +++ b/codex-rs/tui/src/app/agents_overview_actions_tests.rs @@ -514,6 +514,82 @@ async fn archiving_selects_the_next_displayed_task() -> Result<()> { Ok(()) } +#[tokio::test] +async fn archiving_keeps_another_backends_page_in_flight() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; + app.backend_registry.connect(&app_server); + let rollout_id = app_test_support::create_fake_rollout( + &app.config.codex_home, + "2025-01-01T12-00-00", + "2025-01-01T12:00:00Z", + "Local task", + Some(&app.config.model_provider_id), + /*git_info*/ None, + ) + .map_err(color_eyre::eyre::Report::msg)?; + let thread_id = ThreadId::from_string(&rollout_id)?; + app.backend_registry + .observe(app_server.backend_id(), thread_id); + let foreign = crate::backend_id::BackendId::new(); + let foreign_thread = ThreadId::new(); + app.backend_registry.observe(foreign, foreign_thread); + let foreign_request = Uuid::new_v4(); + app.agents_overview.active_refresh = Some((foreign_request, foreign)); + app.agents_overview.refresh_show_more = true; + for id in [thread_id, foreign_thread] { + app.track_agents_overview_notification(&ServerNotification::ThreadStarted( + codex_app_server_protocol::ThreadStartedNotification { + thread: overview_thread( + id, + /*parent_thread_id*/ None, + "Task", + ThreadStatus::Idle, + ), + }, + )); + } + let mut tui = crate::tui::test_support::make_test_tui()?; + tui.pause_events(); + + Box::pin(app.run_agents_overview_action( + &mut tui, + &mut app_server, + thread_id, + AgentsOverviewAction::Archive, + )) + .await?; + + let overview = &app.agents_overview; + assert!(overview.removed_threads.contains(&thread_id)); + assert_eq!(overview.active_refresh, Some((foreign_request, foreign))); + assert!(overview.refresh_show_more); + assert!(!overview.refresh_notifications.contains_key(&thread_id)); + assert!(overview.refresh_notifications.contains_key(&foreign_thread)); + assert!( + overview + .pending_refresh_backends + .contains(&app_server.backend_id()) + ); + app.apply_agents_overview_thread_refresh( + &app_server, + foreign_request, + Ok(crate::app_event::AgentsOverviewThreadRefresh { + cleared_unread: Vec::new(), + threads: HashMap::new(), + last_messages: HashMap::new(), + recent_seed_complete: true, + discovery: None, + pinned_thread_ids: None, + }), + ); + assert!(app.agents_overview.removed_threads.contains(&thread_id)); + assert!(!app.agents_overview.threads.contains_key(&thread_id)); + assert!(app.agents_overview.threads.contains_key(&foreign_thread)); + app_server.shutdown().await?; + Ok(()) +} + #[tokio::test] async fn external_removals_preserve_adjacent_selection() { for grouping in [ diff --git a/codex-rs/tui/src/app/agents_overview_discovery_tests.rs b/codex-rs/tui/src/app/agents_overview_discovery_tests.rs index 1576237ef6..f1c41fdcb7 100644 --- a/codex-rs/tui/src/app/agents_overview_discovery_tests.rs +++ b/codex-rs/tui/src/app/agents_overview_discovery_tests.rs @@ -2,12 +2,17 @@ use super::*; use crate::app::agents_overview_discovery::AgentsOverviewDiscovery; +use crate::app::backend_sessions::BackendSessions; +use crate::app::tests::test_thread_session; use crate::app_event::AgentsOverviewAction; use crate::app_server_session::ThreadParamsMode; +use codex_app_server_client::CloudCommand; use codex_app_server_client::CloudOperation; use codex_app_server_protocol::ClientRequest; +use codex_app_server_protocol::JSONRPCErrorError; use codex_app_server_protocol::JSONRPCMessage; use codex_app_server_protocol::ThreadHistoryMode; +use codex_app_server_protocol::ThreadSortKey; use futures::SinkExt; use futures::StreamExt; use pretty_assertions::assert_eq; @@ -16,6 +21,7 @@ use std::sync::Arc; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; use tokio::net::TcpListener; +use tokio::sync::mpsc; use tokio_tungstenite::tungstenite::Message; #[tokio::test] @@ -62,6 +68,473 @@ async fn overview_cloud_discovery_uses_only_interactive_pages() { tokio::join!(serve_pages, discover); } +#[tokio::test] +async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reopen() -> Result<()> { + let (mut app, mut events, _) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + attach_thread(&mut app, thread_id); + let owner = BackendId::new(); + let (mut cloud, mut commands, _events) = overview_session_stub(owner, ThreadParamsMode::Cloud); + app.app_server_target = AppServerTarget::Cloud; + app.app_server_backend_id = Some(owner); + app.backend_registry.connect(&cloud); + assert!(app.backend_registry.observe(owner, thread_id)); + let mut current = overview_thread( + thread_id, + /*parent_thread_id*/ None, + "Current Cloud chat", + ThreadStatus::Idle, + ); + current.history_mode = ThreadHistoryMode::Paginated; + app.agents_overview + .threads + .insert(thread_id, Some(current.clone())); + + let timeout = Duration::from_secs(/*secs*/ 10); + let next_list = async |commands: &mut mpsc::Receiver| { + reject_cloud_pinned_list(commands).await; + let loaded = commands.recv().await.expect("Cloud loaded threads"); + assert!(matches!( + loaded.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadLoadedList { .. }) + )); + loaded + .response + .send(Ok(Ok(json!({"data": [], "nextCursor": null})))) + .unwrap(); + next_cloud_page(commands, /*cursor*/ None).await + }; + let mut tui = crate::tui::test_support::make_test_tui()?; + for key in [KeyCode::Esc, KeyCode::Enter] { + app.open_agents_overview(&cloud); + let held_list = tokio::time::timeout(timeout, next_list(&mut commands)).await?; + Box::pin(app.handle_tui_event(&mut tui, &mut cloud, TuiEvent::Key(key.into()))).await?; + if key == KeyCode::Enter { + tokio::time::timeout(timeout, async { + loop { + if let AppEvent::SelectAgentsOverviewThread { + thread_id: selected, + } = events.recv().await.expect("overview selection event") + { + assert_eq!(selected, thread_id); + break; + } + } + app.select_agents_overview_thread(&mut tui, &mut cloud, thread_id) + .await + }) + .await??; + } + assert!(held_list.response.is_closed()); + assert!(!app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID)); + } + + app.open_agents_overview(&cloud); + let reopened = tokio::time::timeout(timeout, next_list(&mut commands)).await?; + reopened + .response + .send(Ok(Ok(json!({"data": [], "nextCursor": null})))) + .unwrap(); + let read = tokio::time::timeout(timeout, commands.recv()) + .await? + .expect("Cloud task details after reopen"); + assert!(matches!( + read.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadRead { params, .. } + if params.thread_id == thread_id.to_string() && !params.include_turns) + )); + read.response + .send(Ok(Ok(json!({"thread": current, "readState": null})))) + .unwrap(); + let turns = tokio::time::timeout(timeout, commands.recv()) + .await? + .expect("Cloud task preview after reopen"); + assert!(matches!( + turns.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadTurnsList { params, .. } + if params.thread_id == thread_id.to_string() && params.limit == Some(1)) + )); + turns + .response + .send(Ok(Ok( + json!({"data": [], "nextCursor": null, "backwardsCursor": null}), + ))) + .unwrap(); + finish_overview_refresh(&mut app, &cloud, &mut events).await; + assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID)); + assert!(!app.agents_overview.refresh_failed_backends.contains(&owner)); + Ok(()) +} + +#[tokio::test] +async fn resume_picker_cancels_a_held_cloud_show_more_page() -> Result<()> { + let (mut app, _events, _) = make_test_app_with_channels().await; + let owner = BackendId::new(); + let (cloud, mut commands, _server_events) = + overview_session_stub(owner, ThreadParamsMode::Cloud); + app.app_server_target = AppServerTarget::Cloud; + app.app_server_backend_id = Some(owner); + app.backend_registry.connect(&cloud); + let row = overview_thread( + ThreadId::new(), + /*parent_thread_id*/ None, + "Cloud task", + ThreadStatus::Idle, + ); + let mut discovery = AgentsOverviewDiscovery::default(); + let handle = cloud.request_handle(); + let (page, ()) = tokio::join!(discovery.next_batch(&handle, /*limit*/ 10), async { + let command = next_cloud_page(&mut commands, /*cursor*/ None).await; + command + .response + .send(Ok(Ok(json!({"data": [&row], "nextCursor": "next"})))) + .unwrap(); + }); + assert_eq!(page, (vec![(row.clone(), false)], true)); + app.agents_overview.initialized.insert(owner); + let view = app.agents_overview_view(vec![row], /*selected_thread_id*/ None); + app.chat_widget.show_bottom_pane_view(Box::new(view)); + app.agents_overview.discovery.insert(owner, discovery); + app.show_more_agents_overview(&cloud); + reject_cloud_pinned_list(&mut commands).await; + let held_page = next_cloud_page(&mut commands, Some("next")).await; + let mut backends = BackendSessions::new(cloud); + let mut tui = crate::tui::test_support::make_test_tui()?; + tui.set_alt_screen_enabled(/*enabled*/ false); + tui.pause_events(); + let mut picker = Box::pin(app.open_resume_picker_for_backends(&mut tui, &mut backends)); + let list = tokio::time::timeout(Duration::from_secs(/*secs*/ 10), async { + tokio::select! { + result = &mut picker => panic!("picker exited before listing Cloud tasks: {result:?}"), + command = commands.recv() => command.expect("picker Cloud list"), + } + }) + .await?; + assert!(held_page.response.is_closed()); + assert!( + matches!(list.operation, CloudOperation::Request(request) if matches!(request.as_ref(), ClientRequest::ThreadList { .. })) + ); + drop(picker); + Ok(()) +} + +#[tokio::test] +async fn navigation_without_an_unsubscribe_keeps_the_cloud_page() -> Result<()> { + let mut app = make_test_app().await; + let owner = BackendId::new(); + let (mut cloud, _commands, _events) = overview_session_stub(owner, ThreadParamsMode::Cloud); + app.backend_registry.connect(&cloud); + let request = Uuid::new_v4(); + app.agents_overview.active_refresh = Some((request, owner)); + let (guard, mut dropped) = tokio::sync::oneshot::channel::<()>(); + app.agents_overview.refresh_task = Some(tokio::spawn(async move { + let _guard = guard; + std::future::pending::<()>().await; + })); + + app.detach_current_thread_for_navigation(&mut cloud, Some(ThreadId::new())) + .await; + + assert_eq!(app.agents_overview.active_refresh, Some((request, owner))); + assert!(matches!( + dropped.try_recv(), + Err(tokio::sync::oneshot::error::TryRecvError::Empty) + )); + app.agents_overview.refresh_task.take().unwrap().abort(); + Ok(()) +} + +#[tokio::test] +async fn cycling_from_a_blank_cloud_task_releases_its_page_before_unsubscribe() -> Result<()> { + let (mut app, _events, _) = make_test_app_with_channels().await; + let local_settings = app.backend_settings(); + let local = crate::start_embedded_app_server_for_picker(&app.config).await?; + let local_owner = local.backend_id(); + let owner = BackendId::new(); + let id = ThreadId::new(); + let (cloud, mut commands, _server_events) = + overview_session_stub(owner, ThreadParamsMode::Cloud); + app.app_server_target = AppServerTarget::Cloud; + app.app_server_backend_id = Some(owner); + app.backend_registry.connect(&cloud); + assert!(app.backend_registry.observe(owner, id)); + let session = test_thread_session(id, app.config.cwd.to_path_buf()); + app.enqueue_primary_thread_session(session.clone(), Vec::new()) + .await?; + app.agents_overview.blank_sessions.insert( + id, + AppServerStartedThread { + session, + turns: Vec::new(), + blocks_direct_input: false, + task_tools_available: false, + }, + ); + app.refresh_agents_overview_threads(&cloud); + reject_cloud_pinned_list(&mut commands).await; + let loaded = commands.recv().await.expect("Cloud loaded threads"); + assert!(matches!(loaded.operation, CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadLoadedList { .. }))); + loaded + .response + .send(Ok(Ok(json!({"data": [], "nextCursor": null})))) + .unwrap(); + let mut held_page = next_cloud_page(&mut commands, /*cursor*/ None).await; + let mut backends = BackendSessions::from_initial(cloud, vec![local]); + backends.settings.insert(local_owner, local_settings); + let mut tui = crate::tui::test_support::make_test_tui()?; + let (switched, ()) = tokio::time::timeout(Duration::from_secs(/*secs*/ 10), async { + tokio::join!( + Box::pin(app.start_new_session_on_other_backend( + &mut tui, + &mut backends, + local_owner, + crate::app::backend_selection::NewBackendSession::CarryDraft, + )), + async { + held_page.response.closed().await; + let command = commands.recv().await.expect("blank Cloud unsubscribe"); + assert!(matches!(command.operation, CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadUnsubscribe { params, .. } + if params.thread_id == id.to_string()))); + command + .response + .send(Ok(Ok(json!({"status": "unsubscribed"})))) + .unwrap(); + } + ) + }) + .await?; + switched.expect("switch backend"); + assert_eq!(backends.displayed_owner(), local_owner); + let (shutdown, ()) = tokio::join!(backends.shutdown(), async { + let command = commands.recv().await.expect("Cloud shutdown"); + assert!(matches!(command.operation, CloudOperation::Shutdown)); + command + .response + .send(Ok(Ok(serde_json::Value::Null))) + .unwrap(); + }); + shutdown?; + Ok(()) +} + +#[tokio::test] +async fn overview_local_enter_drops_the_displayed_cloud_list_before_detach() -> Result<()> { + let (mut app, mut events, _) = make_test_app_with_channels().await; + let mut local = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + let local_owner = local.backend_id(); + let local_session = local.start_thread(&app.config).await?.session; + let local_id = local_session.thread_id; + let saved_item = serde_json::from_str( + r#"{"type":"message","role":"assistant","content":[{"type":"output_text","text":"saved locally"}]}"#, + )?; + local + .thread_inject_items(local_id, vec![saved_item]) + .await?; + let local_settings = app.backend_settings(); + let mut local_row = overview_thread( + local_id, + /*parent_thread_id*/ None, + "Local saved chat", + ThreadStatus::Idle, + ); + local_row.cwd = local_session.cwd; + + let cloud_owner = BackendId::new(); + let cloud_id = ThreadId::new(); + let (cloud, mut commands, _events) = + overview_session_stub(cloud_owner, ThreadParamsMode::Cloud); + let cloud_row = overview_thread( + cloud_id, + /*parent_thread_id*/ None, + "Current Cloud chat", + ThreadStatus::Idle, + ); + app.backend_registry.connect(&cloud); + for (owner, id, row) in [ + (local_owner, local_id, local_row.clone()), + (cloud_owner, cloud_id, cloud_row.clone()), + ] { + assert!(app.backend_registry.observe(owner, id)); + app.agents_overview.threads.insert(id, Some(row)); + app.agents_overview.initialized.insert(owner); + } + app.app_server_target = AppServerTarget::Cloud; + app.app_server_backend_id = Some(cloud_owner); + app.enqueue_primary_thread_session( + test_thread_session(cloud_id, app.config.cwd.to_path_buf()), + Vec::new(), + ) + .await?; + + let timeout = Duration::from_secs(/*secs*/ 10); + let mut discovery = AgentsOverviewDiscovery::default(); + let handle = cloud.request_handle(); + let (first_page, ()) = tokio::time::timeout(timeout, async { + tokio::join!(discovery.next_batch(&handle, /*limit*/ 10), async { + let command = next_cloud_page(&mut commands, /*cursor*/ None).await; + command + .response + .send(Ok(Ok( + json!({"data": [&cloud_row], "nextCursor": "cloud-next"}), + ))) + .unwrap(); + }) + }) + .await?; + assert_eq!(first_page, (vec![(cloud_row.clone(), false)], true)); + app.agents_overview.discovery.insert(cloud_owner, discovery); + let view = app.agents_overview_view(vec![cloud_row.clone(), local_row.clone()], Some(local_id)); + app.agents_overview.visible_thread_ids = view.thread_ids(); + app.chat_widget.show_bottom_pane_view(Box::new(view)); + app.show_more_agents_overview(&cloud); + let mut held_list = tokio::time::timeout(timeout, async { + reject_cloud_pinned_list(&mut commands).await; + next_cloud_page(&mut commands, Some("cloud-next")).await + }) + .await?; + + let mut backends = BackendSessions::from_initial(cloud, vec![local]); + backends.settings.insert(local_owner, local_settings); + let mut tui = crate::tui::test_support::make_test_tui()?; + let target = + enter_overview_thread(&mut app, &mut tui, &mut backends, &mut events, local_id).await?; + assert_eq!( + (target.backend_id, target.thread_id), + (local_owner, local_id) + ); + + let detach = async { + // Model the native worker's serial dispatch while the page caller is alive. + held_list.response.closed().await; + let command = commands.recv().await.expect("outgoing Cloud detach"); + assert!(matches!( + command.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadUnsubscribe { params, .. } + if params.thread_id == cloud_id.to_string()) + )); + command + .response + .send(Ok(Ok(json!({"status": "unsubscribed"})))) + .unwrap(); + }; + let (resumed, ()) = tokio::time::timeout(timeout, async { + tokio::join!( + app.resume_backend_session(&mut tui, &mut backends, target), + detach + ) + }) + .await?; + assert!(matches!(resumed?, AppRunControl::Continue)); + assert_eq!(backends.displayed_owner(), local_owner); + assert_eq!(app.current_displayed_thread_id(), Some(local_id)); + assert!( + app.agents_overview + .show_more_backends + .contains(&cloud_owner) + ); + + let (shutdown, ()) = tokio::time::timeout(timeout, async { + tokio::join!(backends.shutdown(), async { + let command = commands.recv().await.expect("Cloud shutdown"); + assert!(matches!(command.operation, CloudOperation::Shutdown)); + command + .response + .send(Ok(Ok(serde_json::Value::Null))) + .unwrap(); + }) + }) + .await?; + shutdown?; + Ok(()) +} + +async fn enter_overview_thread( + app: &mut App, + tui: &mut crate::tui::Tui, + backends: &mut BackendSessions, + events: &mut mpsc::UnboundedReceiver, + expected: ThreadId, +) -> Result { + let index = app + .agents_overview + .visible_thread_ids + .iter() + .position(|id| *id == expected) + .unwrap(); + for _ in 0..app.agents_overview.visible_thread_ids.len() { + if app + .chat_widget + .selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID) + == Some(index) + { + break; + } + app.chat_widget.handle_key_event(KeyCode::Down.into()); + } + app.chat_widget.handle_key_event(KeyCode::Enter.into()); + tokio::time::timeout(Duration::from_secs(/*secs*/ 10), async { + loop { + if let AppEvent::SelectAgentsOverviewThread { thread_id } = + events.recv().await.expect("overview selection event") + { + assert_eq!(thread_id, expected); + break; + } + } + let displayed = backends.displayed; + app.select_agents_overview_thread(tui, backends.session_at_mut(displayed), expected) + .await?; + loop { + if let AppEvent::ResumeBackendSession(target) = + events.recv().await.expect("owner-routed resume event") + { + return Ok(target); + } + } + }) + .await? +} + +async fn reject_cloud_pinned_list(commands: &mut mpsc::Receiver) { + let command = commands.recv().await.expect("Cloud pinned threads"); + assert!(matches!( + command.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadList { params, .. } + if params.sort_key == Some(ThreadSortKey::SectionPosition)) + )); + command + .response + .send(Ok(Err(JSONRPCErrorError { + code: -32000, + message: "These cloud conversation filters are not supported yet.".to_string(), + data: None, + }))) + .unwrap(); +} + +async fn next_cloud_page( + commands: &mut mpsc::Receiver, + cursor: Option<&str>, +) -> CloudCommand { + let command = commands.recv().await.expect("Cloud inventory page"); + let CloudOperation::Request(request) = &command.operation else { + panic!("expected a Cloud request"); + }; + let ClientRequest::ThreadList { params, .. } = request.as_ref() else { + panic!("expected thread/list"); + }; + assert_eq!(params.cursor.as_deref(), cursor); + assert_eq!(params.source_kinds, Some(Vec::new())); + command +} + #[tokio::test] async fn overview_show_more_refills_archived_rows_and_retries_without_losing_rows() -> Result<()> { check_discovery(/*mixed_sources*/ false).await?; diff --git a/codex-rs/tui/src/app/agents_overview_new.rs b/codex-rs/tui/src/app/agents_overview_new.rs index a07eafd7e3..fef1206945 100644 --- a/codex-rs/tui/src/app/agents_overview_new.rs +++ b/codex-rs/tui/src/app/agents_overview_new.rs @@ -114,6 +114,7 @@ impl App { } return Ok(AppRunControl::Continue); } + self.cancel_cloud_inventory_refresh(app_server).await; // Keep folder consent and config loading off the session-start stack frame. let Some((config, remote_cwd)) = Box::pin(self.agents_overview_session_config( tui, diff --git a/codex-rs/tui/src/app/agents_overview_tests.rs b/codex-rs/tui/src/app/agents_overview_tests.rs index 074de7c3a5..98e0445bdb 100644 --- a/codex-rs/tui/src/app/agents_overview_tests.rs +++ b/codex-rs/tui/src/app/agents_overview_tests.rs @@ -146,6 +146,7 @@ use crate::test_support::test_path_display; use codex_app_server_client::AppServerClient; use codex_app_server_client::AppServerEvent; use codex_app_server_client::CloudClient; +use codex_app_server_client::CloudCommand; use codex_app_server_protocol::DynamicToolCallParams; use codex_app_server_protocol::ReasoningSummaryTextDeltaNotification; use codex_app_server_protocol::RequestId; @@ -177,6 +178,19 @@ use ratatui::layout::Rect; static OVERVIEW_TIMESTAMP: std::sync::LazyLock = std::sync::LazyLock::new(|| chrono::Utc::now().timestamp() - 120); +fn overview_session_stub( + owner: BackendId, + mode: ThreadParamsMode, +) -> ( + AppServerSession, + tokio::sync::mpsc::Receiver, + tokio::sync::mpsc::UnboundedSender, +) { + let (client, commands, events) = CloudClient::channel(/*capacity*/ 1); + let session = AppServerSession::new(owner, AppServerClient::Cloud(client), mode); + (session, commands, events) +} + #[tokio::test] async fn refreshing_one_backends_pins_preserves_cross_backend_rank() { let mut app = make_test_app().await; @@ -392,12 +406,8 @@ async fn queued_overview_page_survives_a_focus_change() { #[tokio::test] async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> { let mut app = make_test_app().await; - let stub = |owner, mode| { - let (client, commands, events) = CloudClient::channel(/*capacity*/ 1); - let session = AppServerSession::new(owner, AppServerClient::Cloud(client), mode); - (session, (commands, events)) - }; - let (mut displayed, (mut commands, _events)) = stub(BackendId::new(), ThreadParamsMode::Cloud); + let (mut displayed, mut commands, _events) = + overview_session_stub(BackendId::new(), ThreadParamsMode::Cloud); let remote_owner = BackendId::new(); let [local_id, remote_id, colliding_id] = std::array::from_fn(|_| ThreadId::new()); let [local, remote, colliding] = [ @@ -535,7 +545,8 @@ async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> { // Reverse the foreground so the backend that supports pinning is displayed. app.chat_widget.handle_key_event(KeyCode::Enter.into()); - let (mut foreground, _foreground_transport) = stub(remote_owner, ThreadParamsMode::Embedded); + let (mut foreground, _foreground_commands, _foreground_events) = + overview_session_stub(remote_owner, ThreadParamsMode::Embedded); app.app_server_backend_id = Some(remote_owner); app.repaint_agents_overview(); let selected = app diff --git a/codex-rs/tui/src/app/agents_overview_threads.rs b/codex-rs/tui/src/app/agents_overview_threads.rs index b3902d3c97..019b01589c 100644 --- a/codex-rs/tui/src/app/agents_overview_threads.rs +++ b/codex-rs/tui/src/app/agents_overview_threads.rs @@ -593,6 +593,6 @@ impl App { .await; app_event_tx.send(AppEvent::AgentsOverviewThreadsLoaded { request_id, result }); }); - self.agents_overview.refresh_task = Some(refresh_task.abort_handle()); + self.agents_overview.refresh_task = Some(refresh_task); } } diff --git a/codex-rs/tui/src/app/backend_selection.rs b/codex-rs/tui/src/app/backend_selection.rs index 16710cb6ff..61135ace9d 100644 --- a/codex-rs/tui/src/app/backend_selection.rs +++ b/codex-rs/tui/src/app/backend_selection.rs @@ -226,6 +226,8 @@ impl App { environment.map(|env| (owner, env)), ), }; + self.cancel_cloud_inventory_refresh(backends.session_at(slot)) + .await; let destination = backends.session_at_mut(slot); let clipboard_after_bootstrap = if destination.remote_cwd_override().is_some() { // An explicit remote directory can open the trust prompt after bootstrap. @@ -443,11 +445,9 @@ impl App { }; input_states.remove(&thread_id); self.remove_agents_overview_thread(thread_id); - if let Err(error) = backends - .session_at_mut(outgoing_slot) - .thread_unsubscribe(thread_id) - .await - { + let outgoing = backends.session_at_mut(outgoing_slot); + self.cancel_cloud_inventory_refresh(outgoing).await; + if let Err(error) = outgoing.thread_unsubscribe(thread_id).await { tracing::warn!(%error, "failed to unsubscribe replaced blank thread {thread_id}"); } self.discard_thread_local_state(thread_id).await; @@ -510,11 +510,9 @@ impl App { channel.backend_id.get_or_insert(outgoing); } backends.settings.insert(outgoing, self.backend_settings()); - self.detach_current_thread_for_navigation( - backends.session_at_mut(backends.displayed), - Some(thread_id), - ) - .await; + let outgoing_session = backends.session_at_mut(backends.displayed); + self.detach_current_thread_for_navigation(outgoing_session, Some(thread_id)) + .await; let destination = backends.session_at_mut(destination_slot); self.store_active_thread_receiver().await; self.clear_active_thread().await; @@ -560,6 +558,24 @@ impl App { ); } + pub(super) async fn cancel_cloud_inventory_refresh(&mut self, session: &AppServerSession) { + let owner = session.backend_id(); + if (self + .agents_overview + .active_refresh + .is_some_and(|(_, backend)| backend == owner) + || self + .agents_overview + .pending_refresh_backends + .contains(&owner)) + && matches!(session.request_handle(), AppServerRequestHandle::Cloud(_)) + && let Some(task) = self.cancel_agents_overview_refresh(owner) + { + // The native worker can release a held list once its caller is dropped. + let _ = task.await; + } + } + pub(super) fn resume_backend_session<'a>( &'a mut self, tui: &'a mut tui::Tui, @@ -577,6 +593,8 @@ impl App { return Ok(AppRunControl::Continue); } if owner == outgoing { + self.cancel_cloud_inventory_refresh(backends.session_at(displayed_session)) + .await; return self .apply_resume_picker_selection( tui, @@ -611,6 +629,7 @@ impl App { return Ok(AppRunControl::Continue); }; let destination = backends.session_at_mut(destination_slot); + self.cancel_cloud_inventory_refresh(destination).await; let bootstrap = match destination.bootstrap(&settings.config).await { Ok(bootstrap) => bootstrap, Err(error) => { diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs index 9b7151c2e4..9f09713a70 100644 --- a/codex-rs/tui/src/app/session_lifecycle.rs +++ b/codex-rs/tui/src/app/session_lifecycle.rs @@ -1298,6 +1298,7 @@ impl App { } return; } + self.cancel_cloud_inventory_refresh(app_server).await; // Resolve trust before loading defaults and applying explicit permission choices. if self.current_displayed_thread_id().is_none() { let mut config = self.chat_widget.config_ref().clone(); @@ -1472,6 +1473,7 @@ impl App { if self.reject_pending_permission_root_switch() { return Ok(()); } + self.cancel_cloud_inventory_refresh(app_server).await; let prepared = match self .prepare_fresh_session(app_server, Some(ThreadStartSource::Clear)) .await diff --git a/codex-rs/tui/src/app/session_picker.rs b/codex-rs/tui/src/app/session_picker.rs index 3c26b5aeb4..8e20a6fc32 100644 --- a/codex-rs/tui/src/app/session_picker.rs +++ b/codex-rs/tui/src/app/session_picker.rs @@ -42,6 +42,17 @@ impl App { ) -> Result { let displayed_session = backends.displayed; let displayed_owner = backends.displayed_owner(); + // Remove queued refreshes before aborting the active one, so cancellation + // cannot start another Cloud page ahead of the picker's list requests. + let active_owner = self.agents_overview.active_refresh.map(|(_, owner)| owner); + for session in backends.picker_views() { + if Some(session.backend_id()) != active_owner { + self.cancel_cloud_inventory_refresh(&session).await; + } + } + if let Some(session) = active_owner.and_then(|owner| backends.session(owner)) { + self.cancel_cloud_inventory_refresh(session).await; + } let selection = crate::resume_picker::run_resume_picker_from_existing_session_with_app_servers( crate::uses_remote_workspace_or_environment( diff --git a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs index ba7ce83286..b624cd3b0e 100644 --- a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs +++ b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs @@ -159,8 +159,11 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv let stale_request = Uuid::new_v4(); let refresh_owner = crate::backend_id::BackendId::new(); app.agents_overview.active_refresh = Some((stale_request, refresh_owner)); - let refresh = tokio::spawn(std::future::pending::<()>()); - app.agents_overview.refresh_task = Some(refresh.abort_handle()); + let (refresh_guard, refresh_dropped) = tokio::sync::oneshot::channel::<()>(); + app.agents_overview.refresh_task = Some(tokio::spawn(async move { + let _guard = refresh_guard; + std::future::pending::<()>().await; + })); let directory = tempfile::tempdir()?; let socket_path = directory.path().join("daemon.sock"); let listener = UnixListener::bind(&socket_path)?; @@ -299,7 +302,7 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv ); assert!(app.backend_registry.request_handle(parked_owner).is_some()); assert!(app.agents_overview.last_messages.is_empty()); - assert!(refresh.await.unwrap_err().is_cancelled()); + assert!(refresh_dropped.await.is_err()); assert_eq!(app.agents_overview.active_refresh, None); assert!(app.agents_overview.pending_refresh_backends.is_empty()); app.apply_agents_overview_thread_refresh( diff --git a/codex-rs/tui/src/app/tests/new_session_tests.rs b/codex-rs/tui/src/app/tests/new_session_tests.rs index 4ad08e8c2a..44eede8383 100644 --- a/codex-rs/tui/src/app/tests/new_session_tests.rs +++ b/codex-rs/tui/src/app/tests/new_session_tests.rs @@ -897,6 +897,76 @@ async fn plan_implementation_handles_unavailable_attachment() -> Result<()> { Ok(()) } +#[tokio::test] +async fn plan_implementation_cancels_only_its_cloud_inventory_refresh() -> Result<()> { + for (owned, queued) in [(true, false), (false, false), (false, true)] { + let (mut app, _events, _ops) = make_test_app_with_channels().await; + let (client, mut commands, _server_events) = + codex_app_server_client::CloudClient::channel(/*capacity*/ 1); + let backend_id = crate::backend_id::BackendId::new(); + let mut server = AppServerSession::new( + backend_id, + codex_app_server_client::AppServerClient::Cloud(client), + crate::app_server_session::ThreadParamsMode::Embedded, + ); + let refresh_owner = if owned { + backend_id + } else { + crate::backend_id::BackendId::new() + }; + app.backend_registry.connect(&server); + if queued { + app.agents_overview + .pending_refresh_backends + .push_back(backend_id); + } + let request_id = uuid::Uuid::new_v4(); + app.agents_overview.active_refresh = Some((request_id, refresh_owner)); + let (guard, mut dropped) = tokio::sync::oneshot::channel::<()>(); + app.agents_overview.refresh_task = Some(tokio::spawn(async move { + let _guard = guard; + std::future::pending::<()>().await; + })); + let mut tui = crate::tui::test_support::make_test_tui()?; + let (result, ()) = tokio::join!( + app.implement_plan_in_fresh_session(&mut tui, &mut server, "# Plan".into()), + async { + let request = commands.recv().await.expect("fresh session config request"); + assert!(matches!( + request.operation, + codex_app_server_client::CloudOperation::Request(request) + if matches!(*request, codex_app_server_protocol::ClientRequest::ConfigRead { .. }) + )); + if owned { + assert!(matches!( + dropped.try_recv(), + Err(tokio::sync::oneshot::error::TryRecvError::Closed) + )); + } else { + assert!(matches!( + dropped.try_recv(), + Err(tokio::sync::oneshot::error::TryRecvError::Empty) + )); + } + request + .response + .send(Err(std::io::Error::other("config unavailable"))) + .unwrap(); + } + ); + result?; + assert_eq!( + app.agents_overview.active_refresh, + (!owned).then_some((request_id, refresh_owner)) + ); + assert!(app.agents_overview.pending_refresh_backends.is_empty()); + if let Some(task) = app.agents_overview.refresh_task.take() { + task.abort(); + } + } + Ok(()) +} + async fn assert_plan_implementation_with_unavailable_attachment( write_fails: bool, oversized: bool, diff --git a/codex-rs/tui/src/app/voice_owner.rs b/codex-rs/tui/src/app/voice_owner.rs index 9c614ff9ee..e72cd69ca0 100644 --- a/codex-rs/tui/src/app/voice_owner.rs +++ b/codex-rs/tui/src/app/voice_owner.rs @@ -148,6 +148,7 @@ impl App { { continue; } + self.cancel_cloud_inventory_refresh(app_server).await; if let Err(err) = app_server.thread_unsubscribe(thread_id).await { tracing::warn!("failed to unsubscribe thread {thread_id}: {err}"); }