diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rs index 172eb1ac0d..d3899348d4 100644 --- a/codex-rs/cli/src/main.rs +++ b/codex-rs/cli/src/main.rs @@ -788,7 +788,11 @@ fn handle_app_exit( }; let update_action = exit_info.update_action; - if !matches!(update_action, Some(UpdateAction::Daemon(_))) { + if matches!(update_action, Some(UpdateAction::Daemon(_))) { + for warning in exit_info.archive_warnings { + eprintln!("{warning}"); + } + } else { let color_enabled = supports_color::on(Stream::Stdout).is_some(); for line in exit_info.format_exit_messages(color_enabled) { println!("{line}"); @@ -3880,6 +3884,7 @@ enabled = true thread_id, thread_name: thread_name.map(str::to_string), }), + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, @@ -3892,6 +3897,7 @@ enabled = true token_usage: TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, @@ -3952,6 +3958,7 @@ enabled = true token_usage: TokenUsage::default(), thread_id: Some(ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap()), resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::Fatal("boom".to_string()), diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index e058a20ba6..a269f4d654 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -487,6 +487,7 @@ pub struct AppExitInfo { pub thread_id: Option, pub resume_hint: Option, pub disconnect_info: Option, + pub archive_warnings: Vec, pub update_action: Option, pub exit_reason: ExitReason, } @@ -497,6 +498,7 @@ impl AppExitInfo { token_usage: TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::Fatal(message.into()), diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rs index 6f6896a1af..177f5070d5 100644 --- a/codex-rs/tui/src/app/agents_overview.rs +++ b/codex-rs/tui/src/app/agents_overview.rs @@ -47,6 +47,9 @@ pub(super) struct AgentsOverviewState { pub(super) removed_threads: HashSet, /// Local visibility only; activity and metadata refreshes never reveal hidden roots. pub(super) hidden_threads: HashSet, + /// Hide pending archives; retain their outcomes if shutdown beats event dispatch. + pub(super) pending_archives: + HashMap>>, pub(super) unread: HashSet, pub(super) last_messages: HashMap, pub(super) usage: HashMap, @@ -461,7 +464,9 @@ impl App { .map(|i| view.rows[i].thread_id) .collect(); matches.retain(|id, _| { - visible.contains(id) || self.agents_overview.hidden_threads.contains(id) + visible.contains(id) + || self.agents_overview.hidden_threads.contains(id) + || self.agents_overview.pending_archives.contains_key(id) }); } view.load_search_matches(/*additional*/ 0); @@ -530,7 +535,11 @@ impl App { threads.push(target.clone()); } } - threads.retain(is_visible_in_agents_overview); + threads.retain(|thread| { + is_visible_in_agents_overview(thread) + && !ThreadId::from_string(&thread.id) + .is_ok_and(|id| self.agents_overview.pending_archives.contains_key(&id)) + }); for thread in &mut threads { if thread.parent_thread_id.is_none() && let SessionSource::SubAgent(SubAgentSource::ThreadSpawn { diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rs index 3f6606caab..7f592f1eba 100644 --- a/codex-rs/tui/src/app/app_server_events.rs +++ b/codex-rs/tui/src/app/app_server_events.rs @@ -682,19 +682,25 @@ impl App { app_server_client.thread_tool_transport(), crate::dynamic_tools_mcp::ThreadToolTransport::Mcp(_) ); + let archiving = + thread_id.is_some_and(|id| self.agents_overview.pending_archives.contains_key(&id)); if !tui_tool || requires_mcp + || archiving || codex_protocol::ThreadId::from_string(¶ms.thread_id) .is_ok_and(|thread_id| self.abandoned_side_threads.contains(&thread_id)) { let response = crate::dynamic_tools::failure_response(if requires_mcp { "TUI task tools require the approval-gated MCP server" + } else if archiving { + "Source task is being archived" } else { "TUI dynamic tools require an active task in the TUI namespace" }); self.app_event_tx.send(AppEvent::DynamicToolCallCompleted { request_id: request_id.clone(), response, + reply: Some(buffered_request.reply), }); return; } @@ -713,6 +719,7 @@ impl App { .and_then(|thread_id| ThreadId::from_string(thread_id).ok()) .is_none_or(|thread_id| app_server_client.task_tools_available(thread_id)); let params = params.clone(); + let reply = buffered_request.reply; let mut thread_start_params = crate::app_server_session::thread_start_params_from_config( &self.config, @@ -751,6 +758,7 @@ impl App { app_event_tx.send(AppEvent::DynamicToolCallCompleted { request_id, response, + reply: Some(reply), }); }); self.dynamic_tool_tasks diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index 1b5ea88092..d07381e0d2 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -104,6 +104,7 @@ impl App { | AppEvent::ManagedWorktreeCreated(_) | AppEvent::AgentsOverviewWorktreeCreated(_) | AppEvent::AgentsOverviewPinToggled { .. } + | AppEvent::ArchiveFinished { .. } | AppEvent::OpenAgentsOverview | AppEvent::ShowMoreAgentsOverview | AppEvent::AgentsOverviewThreadsLoaded { .. } @@ -453,14 +454,16 @@ impl App { AppEvent::DynamicToolCallCompleted { request_id, response, + reply, } => { self.dynamic_tool_tasks.remove(&request_id); match serde_json::to_value(response) { Ok(result) => { - if let Err(error) = app_server - .resolve_server_request(request_id.clone(), result) - .await - { + let result = match reply { + Some(reply) => reply.resolve(result).await, + None => app_server.resolve_server_request(request_id.clone(), result).await, + }; + if let Err(error) = result { tracing::warn!(?request_id, %error, "failed to resolve dynamic tool call"); } } @@ -654,6 +657,37 @@ impl App { AppEvent::ArchiveCurrentThread => { return self.archive_current_thread(tui, app_server).await; } + AppEvent::ArchiveFinished { backend_id, thread_id, result } => { + if self.agents_overview.pending_archives.remove(&thread_id).is_some() { + match result { + Ok(()) => { + // The server already closed the archived task and canceled its requests. + let source = thread_id.to_string(); + for (_, (_, task)) in self.dynamic_tool_tasks.extract_if(|_, (thread, _)| *thread == source) { + task.abort(); + } + self.discard_thread_local_state(thread_id).await; + if backend_id == app_server.backend_id() { + self.agents_overview.input_states.remove(&thread_id); + } + self.agents_overview.dispatched_requests.remove(&thread_id); + self.track_agents_overview_notification(&ServerNotification::ThreadArchived( + codex_app_server_protocol::ThreadArchivedNotification { + thread_id: source, + }, + )); + } + Err(error) => { + self.agents_overview.refresh_thread_ids.insert(thread_id); + self.add_agents_overview_error(format!("Failed to archive thread {thread_id}: {error}")); + } + } + self.repaint_agents_overview(); + if backend_id == app_server.backend_id() && !self.reconnect.offline { + self.refresh_changed_agents_overview_threads(app_server); + } + } + } AppEvent::DeleteCurrentThread => { return self.delete_current_thread(tui, app_server).await; } @@ -729,7 +763,7 @@ impl App { } else { None }; - self.retain_subscriptions_for_fork(); + self.retain_thread_subscriptions(); match self .replace_chat_widget_with_app_server_thread( tui, @@ -3305,6 +3339,8 @@ impl App { AppEvent::AgentsOverviewThreadsLoaded { request_id, result } => { self.apply_agents_overview_thread_refresh(app_server, request_id, result); } + AppEvent::SelectAgentsOverviewThread { thread_id } + if self.agents_overview.pending_archives.contains_key(&thread_id) => {} AppEvent::SelectAgentsOverviewThread { thread_id } => { match self .select_agents_overview_thread(tui, app_server, thread_id) @@ -4236,7 +4272,12 @@ impl App { app_server: &mut AppServerSession, mode: ExitMode, ) -> AppRunControl { - for (request_id, (_, task)) in self.dynamic_tool_tasks.drain() { + for (request_id, (source, task)) in self.dynamic_tool_tasks.drain() { + if ThreadId::from_string(&source) + .is_ok_and(|id| self.agents_overview.pending_archives.contains_key(&id)) + { + continue; + } task.abort(); let response = crate::dynamic_tools::failure_response( "TUI disconnected while handling a dynamic tool call", @@ -4304,21 +4345,10 @@ impl App { } } - async fn return_to_agents_after_removal( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - thread_id: ThreadId, - ) -> Result<()> { - self.discard_thread_local_state(thread_id).await; - self.agents_overview.input_states.remove(&thread_id); - self.agents_overview.dispatched_requests.remove(&thread_id); - self.reset_for_thread_switch(tui)?; + async fn reset_after_leaving_thread(&mut self, tui: &mut tui::Tui) { self.pending_thread_switch_resets += 1; self.app_event_tx .send(AppEvent::ResetTranscriptForThreadSwitch); - self.detach_current_thread_for_navigation(app_server, /*destination*/ None) - .await; self.reset_thread_event_state().await; let init = self.chatwidget_init_for_forked_or_resumed_thread( tui, @@ -4326,8 +4356,6 @@ impl App { /*initial_user_message*/ None, ); self.replace_chat_widget(ChatWidget::new_with_app_event(init)); - self.open_agents_overview(app_server); - Ok(()) } pub(super) async fn archive_current_thread( @@ -4348,36 +4376,70 @@ impl App { return Ok(AppRunControl::Continue); } - if !self + let show_progress = !self.side_threads.is_empty() && { + let subtree = self.known_thread_subtree(thread_id); + self.side_threads + .values() + .any(|side| subtree.contains(&side.parent_thread_id)) + }; + if show_progress { + self.chat_widget + .set_footer_hint_override(Some(vec![("Archiving…".into(), String::new())])); + // Cleanup waits outside the event loop. Paint before sending its first request. + let screen_size = tui.terminal.last_known_screen_size; + if let Err(error) = self.render_chat_widget_frame(tui, screen_size) { + tracing::warn!(%error, "failed to render archive progress"); + } + } + let cleaned_up = self .shutdown_side_threads(app_server, Some(thread_id)) - .await - { + .await; + if show_progress { + self.chat_widget.set_footer_hint_override(/*items*/ None); + } + if !cleaned_up { return Ok(AppRunControl::Continue); } - let result = async { - self.stop_voice_for_removed_thread(app_server, thread_id) - .await?; - app_server.thread_archive(thread_id).await + if let Err(error) = self + .stop_voice_for_removed_thread(app_server, thread_id) + .await + { + self.chat_widget + .add_error_message(format!("Failed to archive current thread: {error}")); + return Ok(AppRunControl::Continue); } - .await; - Ok(match result { - Ok(()) => { - self.track_agents_overview_notification(&ServerNotification::ThreadArchived( - codex_app_server_protocol::ThreadArchivedNotification { - thread_id: thread_id.to_string(), - }, - )); - self.return_to_agents_after_removal(tui, app_server, thread_id) - .await?; - AppRunControl::Continue - } - Err(err) => { - self.chat_widget - .add_error_message(format!("Failed to archive current thread: {err}")); - AppRunControl::Continue - } - }) + + self.capture_session_inputs(app_server.backend_id()).await; + // Keep the target subscribed and retain its approvals until the archive resolves. + self.retain_thread_subscriptions(); + self.reset_for_thread_switch(tui)?; + self.reset_after_leaving_thread(tui).await; + let mut server = app_server.request_view(); + let backend_id = server.backend_id(); + let tx = self.saved_openings.tx.clone(); + let (outcome_tx, outcome_rx) = tokio::sync::oneshot::channel(); + let mut archive = Box::pin(async move { + let result = server + .thread_archive(thread_id) + .await + .map_err(|error| error.to_string()); + let _ = outcome_tx.send(result.clone()); + tx.send(AppEvent::ArchiveFinished { + backend_id, + thread_id, + result, + }); + }); + // Start queueing the archive before the overview starts its refresh. + if futures::poll!(archive.as_mut()).is_pending() { + tokio::spawn(archive); + } + self.agents_overview + .pending_archives + .insert(thread_id, outcome_rx); + self.open_agents_overview(app_server); + Ok(AppRunControl::Continue) } pub(super) async fn delete_current_thread( @@ -4420,8 +4482,14 @@ impl App { thread_id: thread_id.to_string(), }, )); - self.return_to_agents_after_removal(tui, app_server, thread_id) - .await?; + self.discard_thread_local_state(thread_id).await; + self.agents_overview.input_states.remove(&thread_id); + self.agents_overview.dispatched_requests.remove(&thread_id); + self.reset_for_thread_switch(tui)?; + self.detach_current_thread_for_navigation(app_server, /*destination*/ None) + .await; + self.reset_after_leaving_thread(tui).await; + self.open_agents_overview(app_server); AppRunControl::Continue } Err(err) => { diff --git a/codex-rs/tui/src/app/exit_summary.rs b/codex-rs/tui/src/app/exit_summary.rs index 3b3c8268ea..7d478b092e 100644 --- a/codex-rs/tui/src/app/exit_summary.rs +++ b/codex-rs/tui/src/app/exit_summary.rs @@ -22,6 +22,26 @@ pub struct DisconnectInfo { } impl App { + pub(super) async fn finish_pending_archives( + &mut self, + deadline: tokio::time::Instant, + ) -> Vec { + let mut warnings = Vec::new(); + for (thread_id, outcome) in self.agents_overview.pending_archives.drain() { + match tokio::time::timeout_at(deadline, outcome).await { + Ok(Ok(Ok(()))) => {} + Ok(Ok(Err(error))) => { + warnings.push(format!("Failed to archive thread {thread_id}: {error}")); + } + Ok(Err(_)) | Err(_) => { + warnings.push(format!("Archive of thread {thread_id} was not confirmed.")); + } + } + } + warnings.sort(); + warnings + } + pub(super) fn exit_info(&self, exit_reason: ExitReason) -> AppExitInfo { let thread_id = self.chat_widget.thread_id().or(self.primary_thread_id); let disconnect_info = thread_id.and_then(|_| { @@ -66,6 +86,7 @@ impl App { self.chat_widget.rollout_path().as_deref(), ), disconnect_info, + archive_warnings: Vec::new(), update_action: self.pending_update_action, exit_reason, } @@ -82,7 +103,7 @@ impl AppExitInfo { command } }; - let mut lines = Vec::new(); + let mut lines = self.archive_warnings; if let Some(disconnect) = self.disconnect_info && let Some(thread_id) = self.thread_id { diff --git a/codex-rs/tui/src/app/resume_preparation.rs b/codex-rs/tui/src/app/resume_preparation.rs index d54d57fc0a..7e8359f93f 100644 --- a/codex-rs/tui/src/app/resume_preparation.rs +++ b/codex-rs/tui/src/app/resume_preparation.rs @@ -103,6 +103,14 @@ impl App { target_session: &SessionTarget, source: ResumeSource<'_>, ) -> std::result::Result { + if self + .agents_overview + .pending_archives + .contains_key(&target_session.thread_id) + { + self.add_session_picker_error("This task is still being archived.".into()); + return Err(AppRunControl::Continue); + } if let Some(owner) = self.backend_registry.owner(target_session.thread_id) && let Err(error) = target_session.ensure_backend(owner) { diff --git a/codex-rs/tui/src/app/safety_recourse.rs b/codex-rs/tui/src/app/safety_recourse.rs index 796c089ebe..ed73227dc6 100644 --- a/codex-rs/tui/src/app/safety_recourse.rs +++ b/codex-rs/tui/src/app/safety_recourse.rs @@ -88,7 +88,7 @@ pub(super) async fn continue_with_rewrite( if let Some(input) = app.chat_widget.capture_thread_input_state() { app.agents_overview.input_states.insert(thread_id, input); } - app.retain_subscriptions_for_fork(); + app.retain_thread_subscriptions(); attached_fork = Some(fork_id); app.replace_chat_widget_with_app_server_thread( tui, diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs index 5d0d85dd32..711ae3608f 100644 --- a/codex-rs/tui/src/app/session_lifecycle.rs +++ b/codex-rs/tui/src/app/session_lifecycle.rs @@ -627,6 +627,13 @@ impl App { app_server: &mut AppServerSession, thread_id: ThreadId, ) -> Result<()> { + if self + .agents_overview + .pending_archives + .contains_key(&thread_id) + { + return Ok(()); + } if self .side_threads .get(&thread_id) diff --git a/codex-rs/tui/src/app/side.rs b/codex-rs/tui/src/app/side.rs index 1b47ccf682..de438142c0 100644 --- a/codex-rs/tui/src/app/side.rs +++ b/codex-rs/tui/src/app/side.rs @@ -584,6 +584,7 @@ impl App { response: crate::dynamic_tools::failure_response( "Source task was closed while handling a dynamic tool call", ), + reply: None, }); task.abort(); false diff --git a/codex-rs/tui/src/app/sidebar_loading.rs b/codex-rs/tui/src/app/sidebar_loading.rs index 65648819ba..9b170f1faa 100644 --- a/codex-rs/tui/src/app/sidebar_loading.rs +++ b/codex-rs/tui/src/app/sidebar_loading.rs @@ -24,8 +24,8 @@ struct Flight { pub(super) struct Openings { active: HashMap<(BackendId, ThreadId), Flight>, - // The app event channel rotates on reconnect. This pair has the lifetime of the flights. - tx: AppEventSender, + // Background completions survive app event channel rotation on reconnect. + pub(super) tx: AppEventSender, completions: mpsc::UnboundedReceiver, } diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs index 0e1b16d7cf..8cd29799ac 100644 --- a/codex-rs/tui/src/app/startup.rs +++ b/codex-rs/tui/src/app/startup.rs @@ -1376,7 +1376,9 @@ See the Codex keymap documentation for supported actions and examples." break Err(err.into()); } } - if app.pending_open_resume_picker { + // Process archive completions before the picker can list or mutate those threads. + if app.pending_open_resume_picker && app.agents_overview.pending_archives.is_empty() + { app.pending_open_resume_picker = false; match Box::pin(app.open_resume_picker_for_backends(tui, &mut backends)).await { Ok(AppRunControl::Continue) => {} @@ -1513,6 +1515,12 @@ See the Codex keymap documentation for supported actions and examples." AppRunControl::Continue } Some(event) = app.saved_openings.next_event(&mut app_event_rx) => { + if let AppEvent::ArchiveFinished { backend_id, thread_id, result: Ok(()) } = &event + && *backend_id != displayed_owner + && let Some(slot) = backends.slot(*backend_id) + { + backends.parked_inputs_mut(slot).remove(thread_id); + } let switch_backend = match &event { AppEvent::ChooseNewSessionCheckout { name } | AppEvent::NewSession { name } if multi_backend => app.other_new_session_backend(&backends).await @@ -1819,6 +1827,10 @@ See the Codex keymap documentation for supported actions and examples." cancellation.cancel(); } app.chat_widget.mention_usage_mut().flush().await; + // Closing a remote or embedded connection can abandon an outstanding archive. + let archive_warnings = app + .finish_pending_archives(tokio::time::Instant::now() + Duration::from_secs(/*secs*/ 5)) + .await; if let Err(err) = backends.shutdown().await { tracing::warn!(error = %err, "failed to shut down embedded app server"); } @@ -1844,9 +1856,14 @@ See the Codex keymap documentation for supported actions and examples." if let Err(clear_err) = clear_result { tracing::warn!(error = %clear_err, "failed to clear terminal UI"); } - return Err(err); + if archive_warnings.is_empty() { + return Err(err); + } + return Err(err.wrap_err(archive_warnings.join("\n"))); } }; - Ok(app.exit_info(exit_reason)) + let mut info = app.exit_info(exit_reason); + info.archive_warnings = archive_warnings; + Ok(info) } } diff --git a/codex-rs/tui/src/app/startup_prompts.rs b/codex-rs/tui/src/app/startup_prompts.rs index 1203f9eb43..71cc1a0bde 100644 --- a/codex-rs/tui/src/app/startup_prompts.rs +++ b/codex-rs/tui/src/app/startup_prompts.rs @@ -390,6 +390,7 @@ pub(super) async fn handle_model_migration_prompt_if_needed( token_usage: TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, diff --git a/codex-rs/tui/src/app/tests/background_exit_tests.rs b/codex-rs/tui/src/app/tests/background_exit_tests.rs index 5960485a77..736c42cedd 100644 --- a/codex-rs/tui/src/app/tests/background_exit_tests.rs +++ b/codex-rs/tui/src/app/tests/background_exit_tests.rs @@ -223,6 +223,19 @@ async fn daemon_disconnect_exit_summary_includes_reconnect_and_stop_instructions let thread_id = prepare_running_local_daemon(&mut app)?; app.keymap.agents.stop = vec![crate::key_hint::plain(KeyCode::F(10))]; let mut exit_info = app.exit_info(ExitReason::UserRequested); + let (rejected, outcome) = tokio::sync::oneshot::channel(); + app.agents_overview + .pending_archives + .insert(thread_id, outcome); + rejected.send(Err("permission denied".to_string())).unwrap(); + let pending_id = ThreadId::new(); + let (_pending, outcome) = tokio::sync::oneshot::channel(); + app.agents_overview + .pending_archives + .insert(pending_id, outcome); + exit_info.archive_warnings = app + .finish_pending_archives(tokio::time::Instant::now()) + .await; exit_info.token_usage = TokenUsage { input_tokens: 10, output_tokens: 2, @@ -232,7 +245,8 @@ async fn daemon_disconnect_exit_summary_includes_reconnect_and_stop_instructions let output = exit_info .format_exit_messages(/*color_enabled*/ false) .join("\n") - .replace(&thread_id.to_string(), "THREAD_ID"); + .replace(&thread_id.to_string(), "THREAD_ID") + .replace(&pending_id.to_string(), "PENDING_ID"); assert_snapshot!("daemon_disconnect_exit", output); Ok(()) } diff --git a/codex-rs/tui/src/app/tests/realtime_start.rs b/codex-rs/tui/src/app/tests/realtime_start.rs index df9178b683..f33b9bb0cd 100644 --- a/codex-rs/tui/src/app/tests/realtime_start.rs +++ b/codex-rs/tui/src/app/tests/realtime_start.rs @@ -208,6 +208,12 @@ async fn lifecycle_actions_stop_parked_voice_before_removing_owner() -> Result<( match action { AgentsOverviewAction::Archive => { Box::pin(app.archive_current_thread(&mut tui, &mut server)).await?; + app.agents_overview + .pending_archives + .remove(&root) + .expect("archive started") + .await? + .expect("archive succeeded"); } AgentsOverviewAction::Delete => { Box::pin(app.delete_current_thread(&mut tui, &mut server)).await?; diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs index ab81d8e989..df30710301 100644 --- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs +++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs @@ -2285,6 +2285,7 @@ fn spawn_approved_task_tool_call( app_event_tx.send(AppEvent::DynamicToolCallCompleted { request_id, response, + reply: None, }); }); } @@ -2402,38 +2403,232 @@ async fn external_transport_registers_dynamic_tools_and_finds_task_mentions() -> } #[tokio::test] -async fn archive_current_thread_reports_success_only_after_archiving() -> Result<()> { +async fn embedded_archive_completes_after_opening_command_center() -> Result<()> { let (mut app, _codex_home) = make_history_test_app().await?; - let thread_id = ThreadId::from_string( - &create_fake_rollout( - &app.config.codex_home, - "2026-08-25T01-00-00", - "2026-08-25T01:00:00Z", - "archive me", - Some(&app.config.model_provider_id), - /*git_info*/ None, - ) - .expect("create rollout"), - )?; - let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; - + let thread_id = create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "archive me")?; + let mut server = crate::start_embedded_app_server_for_picker(&app.config).await?; let mut tui = crate::tui::test_support::make_test_tui()?; - app.active_thread_id = Some(ThreadId::new()); - assert_matches!( - app.archive_current_thread(&mut tui, &mut app_server) - .await?, - AppRunControl::Continue - ); - + let (_tx, mut events) = tokio::sync::mpsc::unbounded_channel(); app.active_thread_id = Some(thread_id); - assert_matches!( - app.archive_current_thread(&mut tui, &mut app_server) - .await?, - AppRunControl::Continue - ); - + Box::pin(app.archive_current_thread(&mut tui, &mut server)).await?; assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID)); - app_server.shutdown().await?; + assert_matches!( + app.saved_openings.next_event(&mut events).await, + Some(AppEvent::ArchiveFinished { thread_id: id, result: Ok(()), .. }) if id == thread_id + ); + server.shutdown().await?; + Ok(()) +} + +#[tokio::test] +async fn archive_opens_command_center_before_the_server_replies() -> Result<()> { + use crate::app::agents_overview::tests::overview_thread; + use codex_app_server_client::AppServerClient; + use codex_app_server_client::CloudClient; + use codex_app_server_client::CloudOperation; + use futures::FutureExt; + + for (mode, succeeded) in [ + (crate::ThreadParamsMode::Cloud, true), + (crate::ThreadParamsMode::Remote, false), + ] { + let (mut app, old_events, _ops) = make_test_app_with_channels().await; + let (client, mut commands, _server_events) = CloudClient::channel(/*capacity*/ 1); + let mut server = AppServerSession::new( + crate::backend_id::BackendId::new(), + AppServerClient::Cloud(client), + mode, + ); + app.app_server_target = if mode == crate::ThreadParamsMode::Cloud { + AppServerTarget::Cloud + } else { + AppServerTarget::Remote { + endpoint: crate::resolve_remote_addr("ws://127.0.0.1:4500")?, + } + }; + let thread_id = ThreadId::from_string("11111111-1111-4111-8111-111111111111")?; + let other_id = ThreadId::new(); + for (id, name) in [(thread_id, "Archive me"), (other_id, "Keep me")] { + app.agents_overview.threads.insert( + id, + Some(overview_thread( + id, + /*parent_thread_id*/ None, + name, + ThreadStatus::Idle, + )), + ); + } + let session = test_thread_session(thread_id, app.config.cwd.to_path_buf()); + app.enqueue_primary_thread_session(session.clone(), Vec::new()) + .await?; + app.chat_widget.handle_thread_session(session); + app.ensure_thread_channel(other_id); + app.chat_widget.insert_str("Unsent draft"); + let input = app.chat_widget.capture_thread_input_state().expect("draft"); + let tool_id = AppServerRequestId::Integer(123); + app.dynamic_tool_tasks.insert( + tool_id.clone(), + (thread_id.to_string(), tokio::spawn(std::future::pending())), + ); + let mut tui = crate::tui::test_support::make_test_tui()?; + + assert_matches!( + Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::ArchiveCurrentThread)) + .now_or_never() + .expect("the confirmation must not wait for the archive RPC")?, + AppRunControl::Continue + ); + assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID)); + assert_eq!(app.current_displayed_thread_id(), None); + assert_eq!(app.agents_overview.visible_thread_ids, [other_id]); + assert_eq!( + app.agents_overview.input_states.get(&thread_id), + Some(&input) + ); + + let command = commands + .try_recv() + .expect("archive queued ahead of refresh"); + assert!(matches!( + command.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadArchive { params, .. } + if params.thread_id == thread_id.to_string()) + )); + let reply = if succeeded { + Ok(serde_json::json!({})) + } else { + Err(JSONRPCErrorError { + code: -32000, + message: "Archive rejected".into(), + data: None, + }) + }; + // Reconnect replaces the UI event channel without losing archive results. + let (tx, mut events) = tokio::sync::mpsc::unbounded_channel(); + app.app_event_tx = AppEventSender::new(tx); + drop(old_events); + command.response.send(Ok(reply)).expect("archive pending"); + let event = app + .saved_openings + .next_event(&mut events) + .await + .expect("archive completion"); + assert_matches!(&event, AppEvent::ArchiveFinished { .. }); + Box::pin(app.handle_event(&mut tui, &mut server, event)).await?; + + if succeeded { + assert_eq!(app.agents_overview.visible_thread_ids, [other_id]); + assert!(!app.agents_overview.input_states.contains_key(&thread_id)); + assert!(!app.dynamic_tool_tasks.contains_key(&tool_id)); + } else { + let (_, task) = app + .dynamic_tool_tasks + .remove(&tool_id) + .expect("tool still running"); + assert!(!task.is_finished()); + task.abort(); + let frame = render_bottom_popup(&app.chat_widget, /*width*/ 120); + let error = &frame[frame + .find(" Unable to complete action") + .expect("expected archive error dialog")..]; + insta::assert_snapshot!(error, @" + Unable to complete action + Failed to archive thread 11111111-1111-4111-8111-111111111111: failed to archive session + + + › 1. Return to command center + + enter select · esc back + "); + assert!(app.agents_overview.visible_thread_ids.contains(&thread_id)); + assert_eq!( + app.agents_overview.input_states.get(&thread_id), + Some(&input) + ); + } + } + Ok(()) +} + +#[tokio::test] +async fn archive_shows_progress_and_keeps_the_session_when_side_chat_cleanup_fails() -> Result<()> { + use codex_app_server_client::AppServerClient; + use codex_app_server_client::CloudClient; + use codex_app_server_client::CloudOperation; + + let (mut app, _events, _ops) = make_test_app_with_channels().await; + let (client, mut commands, _server_events) = CloudClient::channel(/*capacity*/ 1); + let mut server = AppServerSession::new( + crate::backend_id::BackendId::new(), + AppServerClient::Cloud(client), + crate::ThreadParamsMode::Remote, + ); + app.app_server_target = AppServerTarget::Remote { + endpoint: crate::resolve_remote_addr("ws://127.0.0.1:4500")?, + }; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, app.config.cwd.to_path_buf()); + app.enqueue_primary_thread_session(session.clone(), Vec::new()) + .await?; + app.chat_widget.handle_thread_session(session); + app.chat_widget.insert_str("Unsent draft"); + let side_id = ThreadId::new(); + app.side_threads + .insert(side_id, SideThreadState::new(thread_id)); + let mut tui = crate::tui::test_support::make_test_tui()?; + + let mut archive = + Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::ArchiveCurrentThread)); + assert!(futures::poll!(archive.as_mut()).is_pending()); + let interrupt = commands.try_recv().expect("side chat interrupt"); + assert!(matches!( + interrupt.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::TurnInterrupt { params, .. } + if params.thread_id == side_id.to_string()) + )); + interrupt + .response + .send(Ok(Ok(serde_json::json!({})))) + .expect("pending interrupt"); + assert!(futures::poll!(archive.as_mut()).is_pending()); + let unsubscribe = commands.try_recv().expect("side chat unsubscribe"); + assert!(matches!( + unsubscribe.operation, + CloudOperation::Request(request) + if matches!(request.as_ref(), ClientRequest::ThreadUnsubscribe { params, .. } + if params.thread_id == side_id.to_string()) + )); + unsubscribe + .response + .send(Ok(Err(JSONRPCErrorError { + code: -32000, + message: "Unsubscribe rejected".into(), + data: None, + }))) + .expect("pending unsubscribe"); + assert_matches!(archive.await?, AppRunControl::Continue); + assert!(commands.try_recv().is_err(), "archive must not be sent"); + + // The handler drew this frame before it waited for either cleanup reply. + let rendered = buffer_text(tui.terminal.previous_buffer()); + insta::assert_snapshot!( + rendered + .lines() + .find(|line| line.contains("Archiving")) + .expect("archive progress hint") + .trim(), + @"Archiving…" + ); + assert_eq!(app.current_displayed_thread_id(), Some(thread_id)); + assert!(app.side_threads.contains_key(&side_id)); + assert_eq!( + app.chat_widget.composer_draft_snapshot().text, + "Unsent draft" + ); + assert!(!render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("Archiving")); Ok(()) } @@ -2459,12 +2654,16 @@ async fn archive_current_thread_returns_to_agents() -> Result<()> { let (mut app, _codex_home) = make_history_test_app().await?; let thread_id = create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "archive me")?; - let (mut server, requests, proxy) = start_recording_app_server( - &app.config, - /*blocked_thread_list*/ None, - /*failed_thread_name*/ None, - ) - .await?; + let (mut server, requests, proxy) = if matches!(&target, AppServerTarget::Remote { .. }) { + start_recording_remote_app_server(&app.config).await? + } else { + start_recording_app_server( + &app.config, + /*blocked_thread_list*/ None, + /*failed_thread_name*/ None, + ) + .await? + }; let resumed = server .resume_thread( &app.local_settings, @@ -2510,15 +2709,24 @@ async fn archive_current_thread_returns_to_agents() -> Result<()> { .await?, AppRunControl::Continue ); - loop { - let event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv()) - .await? - .expect("expected command center refresh"); - let refreshed = matches!(&event, AppEvent::AgentsOverviewThreadsLoaded { .. }); - Box::pin(app.handle_event(&mut tui, &mut server, event)).await?; - if refreshed { - break; + let mut archived = false; + let mut refreshed = false; + while !archived || !refreshed { + let event = tokio::time::timeout( + Duration::from_secs(/*secs*/ 5), + app.saved_openings.next_event(&mut events), + ) + .await? + .expect("expected archive completion and command center refresh"); + match &event { + AppEvent::ArchiveFinished { result, .. } => { + assert_eq!(*result, Ok(())); + archived = true; + } + AppEvent::AgentsOverviewThreadsLoaded { .. } => refreshed = true, + _ => {} } + Box::pin(app.handle_event(&mut tui, &mut server, event)).await?; } assert!( app.agents_overview @@ -3187,6 +3395,7 @@ async fn check_dynamic_tool_requests( let AppEvent::DynamicToolCallCompleted { request_id, response, + reply, } = event else { panic!("expected a dynamic tool completion event") @@ -3206,6 +3415,7 @@ async fn check_dynamic_tool_requests( AppEvent::DynamicToolCallCompleted { request_id, response, + reply, }, )) .await?; diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__background_exit_tests__daemon_disconnect_exit.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__background_exit_tests__daemon_disconnect_exit.snap index e9685def66..416c9b45df 100644 --- a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__background_exit_tests__daemon_disconnect_exit.snap +++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__background_exit_tests__daemon_disconnect_exit.snap @@ -2,6 +2,8 @@ source: tui/src/app/tests/background_exit_tests.rs expression: output --- +Archive of thread PENDING_ID was not confirmed. +Failed to archive thread THREAD_ID: permission denied Disconnected from this task. Any running work continues. To reconnect, run: codex resume THREAD_ID diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rs index aaaef284a9..013c336d95 100644 --- a/codex-rs/tui/src/app/thread_routing.rs +++ b/codex-rs/tui/src/app/thread_routing.rs @@ -165,13 +165,14 @@ impl App { } } - pub(super) fn retain_subscriptions_for_fork(&mut self) { - // Tasks can start while the fork RPC is pending. + pub(super) fn retain_thread_subscriptions(&mut self) { + // Keep approvals routable while leaving the current task. for id in self .thread_event_channels .keys() .copied() .chain(self.agent_navigation.tracked_thread_ids()) + .chain(self.current_displayed_thread_id()) .filter(|id| { !self.side_threads.contains_key(id) && !self diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index 537282105b..e5cd2671e0 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -736,6 +736,7 @@ pub(crate) enum AppEvent { DynamicToolCallCompleted { request_id: AppServerRequestId, response: DynamicToolCallResponse, + reply: Option, }, /// Register task tools inherited by a dynamically created thread. @@ -801,6 +802,11 @@ pub(crate) enum AppEvent { /// Archive the current active main thread and return to the command center. ArchiveCurrentThread, + ArchiveFinished { + backend_id: crate::backend_id::BackendId, + thread_id: ThreadId, + result: Result<(), String>, + }, /// Permanently delete the current active main thread and return to the command center. DeleteCurrentThread, diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs index 98f472307b..e3db6b05ea 100644 --- a/codex-rs/tui/src/lib.rs +++ b/codex-rs/tui/src/lib.rs @@ -1217,6 +1217,7 @@ pub async fn run_main( token_usage: TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, @@ -1306,6 +1307,7 @@ async fn run_ratatui_app( token_usage: crate::token_usage::TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: Some(action), exit_reason: ExitReason::UserRequested, @@ -1494,6 +1496,7 @@ async fn run_ratatui_app( token_usage: crate::token_usage::TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, @@ -1627,6 +1630,7 @@ async fn run_ratatui_app( token_usage: crate::token_usage::TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::Fatal(format!( @@ -1744,6 +1748,7 @@ async fn run_ratatui_app( token_usage: crate::token_usage::TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, @@ -1848,6 +1853,7 @@ async fn run_ratatui_app( token_usage: crate::token_usage::TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, @@ -1899,6 +1905,7 @@ async fn run_ratatui_app( token_usage: crate::token_usage::TokenUsage::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested, diff --git a/codex-rs/tui/src/session_start.rs b/codex-rs/tui/src/session_start.rs index 5ea631357e..e9d79d8ba3 100644 --- a/codex-rs/tui/src/session_start.rs +++ b/codex-rs/tui/src/session_start.rs @@ -128,6 +128,7 @@ pub(crate) async fn cancel_session_start(app_server: AppServerSession) -> AppExi token_usage: Default::default(), thread_id: None, resume_hint: None, + archive_warnings: Vec::new(), disconnect_info: None, update_action: None, exit_reason: ExitReason::UserRequested,