mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
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
This commit is contained in:
committed by
copyberry
parent
18352dc4e8
commit
2f7c5a8588
@@ -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),
|
||||
|
||||
@@ -72,7 +72,7 @@ pub(super) struct AgentsOverviewState {
|
||||
pub(super) active_refresh_thread_ids: HashSet<ThreadId>,
|
||||
pub(super) pins_by_backend: std::collections::BTreeMap<BackendId, Option<Vec<ThreadId>>>,
|
||||
pub(super) pending_pin_change: Option<(Uuid, BackendId)>,
|
||||
pub(super) refresh_task: Option<tokio::task::AbortHandle>,
|
||||
pub(super) refresh_task: Option<tokio::task::JoinHandle<()>>,
|
||||
pub(super) refresh_notifications: HashMap<ThreadId, Vec<ServerNotification>>,
|
||||
pub(super) rendered_full_screen: bool,
|
||||
pub(super) visible_thread_ids: Vec<ThreadId>,
|
||||
@@ -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<tokio::task::JoinHandle<()>> {
|
||||
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);
|
||||
|
||||
@@ -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 [
|
||||
|
||||
@@ -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<CloudCommand>| {
|
||||
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<AppEvent>,
|
||||
expected: ThreadId,
|
||||
) -> Result<SessionTarget> {
|
||||
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<CloudCommand>) {
|
||||
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<CloudCommand>,
|
||||
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?;
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<i64> =
|
||||
std::sync::LazyLock::new(|| chrono::Utc::now().timestamp() - 120);
|
||||
|
||||
fn overview_session_stub(
|
||||
owner: BackendId,
|
||||
mode: ThreadParamsMode,
|
||||
) -> (
|
||||
AppServerSession,
|
||||
tokio::sync::mpsc::Receiver<CloudCommand>,
|
||||
tokio::sync::mpsc::UnboundedSender<AppServerEvent>,
|
||||
) {
|
||||
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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -42,6 +42,17 @@ impl App {
|
||||
) -> Result<AppRunControl> {
|
||||
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(
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user