diff --git a/codex-rs/rmcp-client/src/bin/test_stdio_server.rs b/codex-rs/rmcp-client/src/bin/test_stdio_server.rs index 928789fdf2..f2b78505b1 100644 --- a/codex-rs/rmcp-client/src/bin/test_stdio_server.rs +++ b/codex-rs/rmcp-client/src/bin/test_stdio_server.rs @@ -727,11 +727,12 @@ impl ServerHandler for TestToolServer { .and_then(|mut file| writeln!(file, "{state}")) .map_err(|error| McpError::internal_error(error.to_string(), None))?; let thread = state["thread"]["id"].as_str().unwrap_or_default(); + let mode = state["app"]["display_mode"].as_str().unwrap_or_default(); return Ok( ReadResourceResult::new(vec![ResourceContents::TextResourceContents { uri, mime_type: Some("APPLICATION/JSON; charset=utf-8".into()), - text: json!({"type":"text", "children":[format!("Provider thread {thread}")]}) + text: json!({"type":"text", "children":[format!("Provider thread {thread} ({mode})")]}) .to_string(), meta: None, }]) diff --git a/codex-rs/tui/src/chatwidget/realtime_navigation.rs b/codex-rs/tui/src/chatwidget/realtime_navigation.rs index 6dbaaa137b..922b934613 100644 --- a/codex-rs/tui/src/chatwidget/realtime_navigation.rs +++ b/codex-rs/tui/src/chatwidget/realtime_navigation.rs @@ -18,6 +18,7 @@ impl ChatWidget { pub(crate) fn park_voice(&mut self) { self.app_event_tx.voice_only.store(true, Ordering::Relaxed); + self.statusline_read = None; self.set_queue_autosend_suppressed(/*suppressed*/ true); self.stop_rate_limit_poller(); } diff --git a/codex-rs/tui/src/chatwidget/statusline_reader.rs b/codex-rs/tui/src/chatwidget/statusline_reader.rs index a94c1196a4..f03bfe386c 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader.rs @@ -1,4 +1,4 @@ -//! Read one statusline resource for the displayed thread and keep its footer through native refreshes. +//! Poll the displayed thread’s statusline resource until a read fails or the reader is retired. use super::ChatWidget; use super::statusline_state::StatuslineState; @@ -25,6 +25,11 @@ use std::path::PathBuf; use std::time::Duration; use tokio::sync::oneshot; use tokio::sync::watch; +use tokio::time::Instant; +use tokio::time::sleep; +use tokio::time::timeout; +use tokio::time::timeout_at; +use tokio_util::sync::CancellationToken; use uuid::Uuid; pub(super) struct ActiveStatuslineRead { @@ -33,6 +38,13 @@ pub(super) struct ActiveStatuslineRead { selection: StatusLineProviderId, host_cwd: PathBuf, startup: watch::Sender<()>, + cancel: CancellationToken, +} + +impl Drop for ActiveStatuslineRead { + fn drop(&mut self) { + self.cancel.cancel(); + } } #[derive(Debug)] @@ -59,6 +71,10 @@ impl StatuslineReadEvent { impl ChatWidget { pub(super) fn selected_statusline_provider(&self) -> Option<&StatusLineProviderId> { if self.read_only_history + || self + .app_event_tx + .voice_only + .load(std::sync::atomic::Ordering::Relaxed) || !self .config .features @@ -92,6 +108,7 @@ impl ChatWidget { selection: selection.clone(), host_cwd: self.status_line_cwd().to_owned(), startup, + cancel: CancellationToken::new(), }); self.bottom_pane.set_status_line_enabled(/*enabled*/ true); self.set_status_line(Some( @@ -170,39 +187,58 @@ impl ActiveStatuslineRead { let client = owner.request_handle(); let backend = owner.backend_id(); let cwd = LegacyAppPathString::from_path(&self.host_cwd).to_inferred_path_uri(); + let cancel = self.cancel.clone(); tokio::spawn(async move { - let result: Result = async { - let cwd = cwd.ok_or_else(|| eyre!("invalid app-server working directory"))?; - let provider = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async { - loop { - if let Ok(Some(provider)) = ResolvedStatuslineProvider::lookup( - &client, - thread, - &cwd, - ProviderSelection::Saved(&id), - ) - .await - { - return Ok::<_, watch::error::RecvError>(provider); + let result: Option> = cancel + .run_until_cancelled(async { + let cwd = cwd.ok_or_else(|| eyre!("invalid app-server working directory"))?; + let provider = timeout(Duration::from_secs(/*secs*/ 5), async { + loop { + if let Ok(Some(provider)) = ResolvedStatuslineProvider::lookup( + &client, + thread, + &cwd, + ProviderSelection::Saved(&id), + ) + .await + { + return Ok::<_, watch::error::RecvError>(provider); + } + // A cold catalog may arrive before the selected MCP server finishes starting. + ready.changed().await?; } - // A cold catalog may arrive before the selected MCP server finishes starting. - ready.changed().await?; + }) + .await??; + name.clone_from(&provider.provider().title); + loop { + let (reply, snapshot) = oneshot::channel(); + StatuslineReadEvent::send( + &events, + token, + ReadStep::Snapshot(backend, reply), + ); + let snapshot = serde_json::to_value(snapshot.await?)?; + let deadline = Instant::now() + Duration::from_secs(1); + // A ready reply can win the final poll of timeout_at after the deadline. + let response = match timeout_at(deadline, provider.read(snapshot)).await { + Ok(response) if Instant::now() < deadline => response?, + Ok(_) | Err(_) => { + bail!("resource read timed out"); + } + }; + let tree = decode_tree(&provider.provider().uri, &response.contents)?; + StatuslineReadEvent::send( + &events, + token, + ReadStep::Finished(backend, Ok(tree)), + ); + sleep(Duration::from_secs(/*secs*/ 1)).await; } }) - .await??; - name.clone_from(&provider.provider().title); - // Lookup can outlive the displayed thread or its current usage measurements. - let (reply, current) = oneshot::channel(); - StatuslineReadEvent::send(&events, token, ReadStep::Snapshot(backend, reply)); - let response = provider.read(serde_json::to_value(current.await?)?).await?; - decode_tree(&provider.provider().uri, &response.contents) + .await; + if let Some(Err(_)) = result { + StatuslineReadEvent::send(&events, token, ReadStep::Finished(backend, Err(name))); } - .await; - StatuslineReadEvent::send( - &events, - token, - ReadStep::Finished(backend, result.map_err(|_| name)), - ); }); } } diff --git a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs index db6680312e..b346e3dec5 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs @@ -1,10 +1,17 @@ #![cfg(test)] -//! Exercise the MCP response envelope and the displayed footer's one-shot lifecycle. +//! Exercise the MCP response envelope and the displayed footer’s polling lifecycle. use super::*; +use crate::app_server_session::ThreadParamsMode; use crate::bottom_pane::StatusLineFocus; use crate::chatwidget::tests::make_chatwidget_manual_with_sender; use crate::chatwidget::tests::render_bottom_popup; +use codex_app_server_client::AppServerClient; +use codex_app_server_client::CloudClient; +use codex_app_server_client::CloudCommand; +use codex_app_server_client::CloudOperation; +use codex_app_server_client::RequestResult; +use codex_app_server_protocol::ClientRequest; use codex_config::types::BuiltinStatusLine; use pretty_assertions::assert_eq; use ratatui::buffer::Buffer; @@ -12,6 +19,7 @@ use ratatui::buffer::Cell; use ratatui::layout::Rect; use serde_json::json; use tokio::sync::mpsc::UnboundedReceiver; +use tokio::time::Instant; #[test] fn statusline_resource_requires_one_matching_json_text_item() { @@ -175,3 +183,298 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() ); assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); } + +type Reply = oneshot::Sender>; +const URI: &str = "ui://fixture/status"; + +struct Reader { + chat: ChatWidget, + owner: AppServerSession, + events: UnboundedReceiver, + requests: tokio::sync::mpsc::Receiver, +} + +impl Reader { + async fn new() -> Self { + let (mut chat, _, events, _) = make_chatwidget_manual_with_sender().await; + let (client, requests, _) = CloudClient::channel(/*capacity*/ 8); + let owner = AppServerSession::new( + BackendId::new(), + AppServerClient::Cloud(client), + ThreadParamsMode::Cloud, + ); + chat.thread_id = Some(ThreadId::new()); + chat.set_feature_enabled(Feature::TuiExtensionsStatusLine, /*enabled*/ true); + chat.local_settings.tui.status_line_provider = + Some(Box::new(StatusLineSelection::Mcp(StatusLineProviderId { + server: "fixture".into(), + tool: "line".into(), + }))); + chat.refresh_status_line(); + let mut reader = Self { + chat, + owner, + events, + requests, + }; + reader.dispatch().await; + reader + } + + async fn dispatch(&mut self) { + while let Some(event) = self.events.recv().await { + if let AppEvent::StatuslineRead(event) = event { + self.chat.handle_statusline_read(event, &self.owner); + return; + } + } + panic!("reader event channel closed"); + } + + async fn request(&mut self) -> (ClientRequest, Reply) { + let command = self.requests.recv().await.unwrap(); + let CloudOperation::Request(request) = command.operation else { + panic!("expected an app-server request"); + }; + (*request, command.response) + } + + async fn resolve(&mut self) { + let (ClientRequest::ConfigRead { .. }, config) = self.request().await else { + panic!("expected the selected thread's config"); + }; + let layer = json!({"mcp_servers":{"fixture":{"command":"fixture"}}}); + config + .send(Ok(Ok( + json!({"config":layer, "layers":[{"name":{"type":"user"}, "config":layer}]}), + ))) + .unwrap(); + for thread in [None, self.chat.thread_id.map(|id| id.to_string())] { + let (ClientRequest::McpServerStatusList { params, .. }, reply) = self.request().await + else { + panic!("expected a selected-server lookup"); + }; + assert_eq!( + (params.server_name.as_deref(), params.thread_id), + (Some("fixture"), thread) + ); + let tool = json!({"name":"line","title":"Calendar","inputSchema":{},"_meta":{ + "openai/ui":{"entrypoints":[{"type":"statusline","resourceUri":URI}]} + }}); + reply.send(Ok(Ok(json!({"data":[{"name":"fixture","httpOrigin":null,"runtimeStatus":"connected", + "tools":{"line":tool},"resources":[],"resourceTemplates":[],"authStatus":"unsupported"}],"nextCursor":null})))).unwrap(); + } + } + + async fn read(&mut self, uri: &str) -> Reply { + self.dispatch().await; + let (ClientRequest::McpResourceRead { params, .. }, reply) = self.request().await else { + panic!("expected the selected resource read"); + }; + assert_eq!(params.uri, uri); + reply + } + + fn assert_idle(&mut self) { + assert!( + read_events(&mut self.events).is_empty(), + "unexpected reader event" + ); + assert!( + self.requests.try_recv().is_err(), + "unexpected app-server request" + ); + } +} + +fn respond(reply: Reply, text: &str) { + reply + .send(Ok(Ok( + json!({"contents":[{"uri":URI,"mimeType":"application/json","text":text}]}), + ))) + .unwrap(); +} + +async fn advance(millis: u64) { + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_millis(millis)).await; + tokio::task::yield_now().await; +} + +#[tokio::test(start_paused = true)] +async fn statusline_polls_one_second_after_completion_including_empty_content() { + let mut reader = Reader::new().await; + reader.resolve().await; + // A busy TUI can delay the first snapshot without consuming the provider’s read budget. + advance(/*millis*/ 6000).await; + let first = reader.read(URI).await; + advance(/*millis*/ 800).await; + reader.assert_idle(); + let completed = Instant::now(); + respond(first, r#""ready""#); + reader.dispatch().await; + assert_eq!(footer(&reader.chat).as_deref(), Some("ready")); + + advance(/*millis*/ 999).await; + reader.assert_idle(); + advance(/*millis*/ 1).await; + reader.chat.set_model("updated-model"); + reader.dispatch().await; + let (ClientRequest::McpResourceRead { params, .. }, second) = reader.request().await else { + panic!("expected second resource read"); + }; + let meta = params.meta.unwrap(); + assert_eq!( + meta["com.openai/codex-statusline-state"]["thread"]["model"]["display_name"], + "updated-model" + ); + assert_eq!(completed.elapsed(), Duration::from_secs(1)); + let completed = Instant::now(); + respond(second, "null"); + reader.dispatch().await; + assert_eq!(footer(&reader.chat).as_deref(), Some("")); + advance(/*millis*/ 999).await; + reader.assert_idle(); + advance(/*millis*/ 1).await; + let _third = reader.read(URI).await; + assert_eq!(completed.elapsed(), Duration::from_secs(1)); +} + +#[tokio::test(start_paused = true)] +async fn statusline_invalid_content_stops_polling_immediately() { + let mut reader = Reader::new().await; + reader.resolve().await; + respond(reader.read(URI).await, r#""last good""#); + reader.dispatch().await; + advance(/*millis*/ 1000).await; + + let invalid = reader.read(URI).await; + assert_eq!(footer(&reader.chat).as_deref(), Some("last good")); + let failed = Instant::now(); + respond(invalid, "{"); + reader.dispatch().await; + assert_eq!(failed.elapsed(), Duration::ZERO); + insta::assert_snapshot!(footer(&reader.chat).unwrap(), @"Error loading statusline contents from Calendar. Use /statusline to (re)select your provider and try again."); + reader.chat.refresh_status_line(); + advance(/*millis*/ 60_000).await; + reader.assert_idle(); +} + +#[tokio::test(start_paused = true)] +async fn statusline_rpc_error_stops_polling_immediately() { + let mut reader = Reader::new().await; + reader.resolve().await; + let resolved = Instant::now(); + let reply = reader.read(URI).await; + assert_eq!(resolved.elapsed(), Duration::ZERO); + let failed = Instant::now(); + reply + .send(Err(std::io::Error::other("provider disconnected"))) + .unwrap(); + reader.dispatch().await; + assert_eq!(failed.elapsed(), Duration::ZERO); + assert!( + footer(&reader.chat) + .unwrap() + .contains("Error loading statusline contents from Calendar") + ); + advance(/*millis*/ 60_000).await; + reader.assert_idle(); +} + +#[tokio::test(start_paused = true)] +async fn statusline_returning_to_a_thread_fetches_fresh_state_and_discards_its_old_reply() { + let mut reader = Reader::new().await; + let original = reader.chat.thread_id.unwrap(); + reader.resolve().await; + let old = reader.read(URI).await; + + reader.chat.thread_id = Some(ThreadId::new()); + reader.chat.refresh_status_line(); + reader.dispatch().await; + reader.resolve().await; + let other = reader.read(URI).await; + + reader.chat.thread_id = Some(original); + reader.chat.refresh_status_line(); + reader.dispatch().await; + let returned = Instant::now(); + reader.resolve().await; + let current = reader.read(URI).await; + assert_eq!(returned.elapsed(), Duration::ZERO); + respond(current, r#""fresh footer""#); + reader.dispatch().await; + assert_eq!(footer(&reader.chat).as_deref(), Some("fresh footer")); + + let late = + json!({"contents":[{"uri":URI,"mimeType":"application/json","text":"\"old footer\""}]}); + assert!(old.send(Ok(Ok(late.clone()))).is_err()); + assert!(other.send(Ok(Ok(late))).is_err()); + advance(/*millis*/ 1000).await; + let mut parked = reader.read(URI).await; + reader.chat.park_voice(); + reader.chat.refresh_status_line(); + parked.closed().await; + reader.assert_idle(); +} + +#[tokio::test(start_paused = true)] +async fn statusline_deadline_wins_when_a_late_reply_is_already_queued() { + let mut reader = Reader::new().await; + reader.resolve().await; + let reply = reader.read(URI).await; + // Queue the reply beyond the deadline before letting the reader poll either future. + let mut advance = std::pin::pin!(tokio::time::advance(Duration::from_millis(1_001))); + assert!(futures::poll!(&mut advance).is_pending()); + respond(reply, r#""too late""#); + reader.dispatch().await; + assert!( + footer(&reader.chat) + .unwrap() + .contains("Error loading statusline contents from Calendar") + ); +} + +#[tokio::test(start_paused = true)] +async fn statusline_hung_read_stops_polling_after_one_second() { + let mut reader = Reader::new().await; + reader.resolve().await; + let held = reader.read(URI).await; + let started = Instant::now(); + advance(/*millis*/ 999).await; + reader.assert_idle(); + advance(/*millis*/ 1).await; + reader.dispatch().await; + assert_eq!(started.elapsed(), Duration::from_secs(1)); + assert!( + footer(&reader.chat) + .unwrap() + .contains("Error loading statusline contents from Calendar") + ); + assert!(held.is_closed()); + advance(/*millis*/ 60_000).await; + reader.assert_idle(); +} + +#[tokio::test(start_paused = true)] +async fn statusline_startup_timeout_stops_before_the_first_read() { + let mut reader = Reader::new().await; + let (ClientRequest::ConfigRead { .. }, held) = reader.request().await else { + panic!("expected startup lookup"); + }; + let started = Instant::now(); + advance(/*millis*/ 4999).await; + reader.assert_idle(); + advance(/*millis*/ 1).await; + reader.dispatch().await; + assert_eq!(started.elapsed(), Duration::from_secs(5)); + assert!( + footer(&reader.chat) + .unwrap() + .contains("Error loading statusline contents from line") + ); + assert!(held.is_closed()); + reader.chat.refresh_status_line(); + advance(/*millis*/ 60_000).await; + reader.assert_idle(); +} diff --git a/codex-rs/tui/tests/suite/statusline_provider.rs b/codex-rs/tui/tests/suite/statusline_provider.rs index e78de664f1..53a0c198f8 100644 --- a/codex-rs/tui/tests/suite/statusline_provider.rs +++ b/codex-rs/tui/tests/suite/statusline_provider.rs @@ -106,11 +106,10 @@ async fn statusline_reads_the_selected_stdio_resource_on_the_displayed_thread() .wait_for_screen("Provider thread ") .with_context(|| format!("{mode:?} resource read"))?; let receipts = fs::read_to_string(&receipt)?; - let [line]: [&str; 1] = receipts + let line = receipts .lines() - .collect::>() - .try_into() - .expect("one read"); + .next() + .context("missing first resource read")?; let state: Value = serde_json::from_str(line)?; let thread = state["thread"]["id"] .as_str() @@ -129,6 +128,9 @@ async fn statusline_reads_the_selected_stdio_resource_on_the_displayed_thread() ); if mode == Setup::Embedded { assert_eq!(state["app"]["display_mode"], "raw"); + terminal.write_input(b"/raw off\r")?; + terminal.wait_for_screen("Raw output mode off")?; + terminal.wait_for_screen(&format!("Provider thread {thread} (standard)"))?; } assert_eq!(state["thread"]["workspace"], json!({"cwd": cwd})); }