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}"); }