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 6980f786ba..928789fdf2 100644 --- a/codex-rs/rmcp-client/src/bin/test_stdio_server.rs +++ b/codex-rs/rmcp-client/src/bin/test_stdio_server.rs @@ -53,6 +53,8 @@ struct TestToolServer { invalidated_listing: Arc, } +const STATUSLINE_RECORD: &str = "MCP_TEST_STATUSLINE_RECORD"; +const STATUSLINE_URI: &str = "ui://fixture/footer"; const MEMO_URI: &str = "memo://codex/example-note"; const MEMO_CONTENT: &str = "This is a sample MCP resource served by the rmcp test server."; const SANDBOX_STATE_CAPABILITY: &str = "codex/sandbox-state"; @@ -158,6 +160,15 @@ impl TestToolServer { ); encrypted_output_tool.annotations = Some(ToolAnnotations::new().read_only(true)); + if std::env::var_os(STATUSLINE_RECORD).is_some() { + sandbox_meta_tool + .meta + .get_or_insert_with(MetaObject::new) + .insert( + "openai/ui".to_owned(), + json!({"entrypoints": [{"type": "statusline", "resourceUri": STATUSLINE_URI}]}), + ); + } let mut tools = vec![ Self::echo_tool(), Self::echo_dash_tool(), @@ -699,6 +710,34 @@ impl ServerHandler for TestToolServer { ReadResourceRequestParams { uri, .. }: ReadResourceRequestParams, context: rmcp::service::RequestContext, ) -> Result { + if uri == STATUSLINE_URI + && let Some(path) = std::env::var_os(STATUSLINE_RECORD) + { + use std::io::Write; + let state = context + .meta + .0 + .0 + .get("com.openai/codex-statusline-state") + .ok_or_else(|| McpError::invalid_params("missing statusline state", None))?; + std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(path) + .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(); + 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}")]}) + .to_string(), + meta: None, + }]) + .into(), + ); + } if uri == "test://codex/request-metadata" { let metadata = serde_json::Value::Object(context.meta.0.0); return Ok(ReadResourceResult::new(vec![ResourceContents::text( diff --git a/codex-rs/tui/BUILD.bazel b/codex-rs/tui/BUILD.bazel index 6dbf443b15..d061d83345 100644 --- a/codex-rs/tui/BUILD.bazel +++ b/codex-rs/tui/BUILD.bazel @@ -9,6 +9,7 @@ codex_rust_crate( crate_name = "codex_tui", extra_binaries = [ "//codex-rs/cli:codex", + "//codex-rs/rmcp-client:test_stdio_server", ], integration_compile_data_extra = ["src/test_backend.rs"], rustc_flags_extra = MACOS_WEBRTC_RUSTC_LINK_FLAGS, diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index 86052f49a2..64927a5e52 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -476,6 +476,9 @@ impl App { } } } + AppEvent::StatuslineRead(event) => { + self.chat_widget.handle_statusline_read(event, app_server); + } AppEvent::TaskToolsAvailable { thread_id } => { app_server.remember_task_tool_thread(thread_id); } diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index 9dda018b09..48014dae48 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -354,6 +354,7 @@ impl CapturedSideWork { #[allow(clippy::large_enum_variant)] #[derive(Debug, IntoStaticStr)] pub(crate) enum AppEvent { + StatuslineRead(crate::chatwidget::StatuslineReadEvent), AccountEmailLoaded { request_id: uuid::Uuid, email: Option, diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index 8368a7d839..91cbfc9e43 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -402,6 +402,9 @@ use self::status_state::TerminalTitleStatusKind; mod status_controls; mod status_surface_commands; mod status_surfaces; +mod statusline_reader; +pub(crate) use statusline_reader::StatuslineReadEvent; + pub(crate) mod statusline_state; use self::status_surface_commands::StatusSurfaceOverrides; mod streaming; @@ -574,6 +577,7 @@ pub(crate) struct ChatWidget { pub(crate) initial_user_message: Option, status_account_display: Option, pub(crate) remote_connection: Option, + statusline_read: Option, /// Remote app servers cannot read image paths on the TUI host. pub(crate) snapshot_local_images: bool, pub(crate) thread_params_mode: crate::app_server_session::ThreadParamsMode, diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rs index abd4ec7652..19c26ca9f4 100644 --- a/codex-rs/tui/src/chatwidget/constructor.rs +++ b/codex-rs/tui/src/chatwidget/constructor.rs @@ -148,6 +148,7 @@ impl ChatWidget { initial_user_message, status_account_display, remote_connection: None, + statusline_read: None, snapshot_local_images: false, thread_params_mode: crate::app_server_session::ThreadParamsMode::Embedded, pending_image_submission: None, diff --git a/codex-rs/tui/src/chatwidget/mcp_startup.rs b/codex-rs/tui/src/chatwidget/mcp_startup.rs index 69d1971ae5..f6ac519941 100644 --- a/codex-rs/tui/src/chatwidget/mcp_startup.rs +++ b/codex-rs/tui/src/chatwidget/mcp_startup.rs @@ -222,6 +222,11 @@ impl ChatWidget { &mut self, notification: McpServerStatusUpdatedNotification, ) { + if notification.status == McpServerStartupState::Ready + && let Some(footer) = &self.statusline_read + { + footer.server_ready(¬ification.name); + } let refresh_connector_mentions = notification.name == "codex_apps" && notification.environment_id.is_none() && notification.status == McpServerStartupState::Ready; diff --git a/codex-rs/tui/src/chatwidget/status_surfaces.rs b/codex-rs/tui/src/chatwidget/status_surfaces.rs index dc685a1364..9915161786 100644 --- a/codex-rs/tui/src/chatwidget/status_surfaces.rs +++ b/codex-rs/tui/src/chatwidget/status_surfaces.rs @@ -71,25 +71,6 @@ impl StatusSurfaceSelections { .status_line_items .contains(&StatusLineItem::BranchChanges) } - - fn uses_workspace_headline(&self) -> bool { - self.status_line_items - .contains(&StatusLineItem::WorkspaceHeadline) - } - - fn uses_thread_usage(&self) -> bool { - self.status_line_items.iter().any(|item| { - matches!( - item, - StatusLineItem::ThreadCredits | StatusLineItem::EstimatedThreadCost - ) - }) || self.terminal_title_items.iter().any(|item| { - matches!( - item, - TerminalTitleItem::ThreadCredits | TerminalTitleItem::EstimatedThreadCost - ) - }) - } } /// Cached project-root display name keyed by the cwd used for the last lookup. @@ -183,7 +164,7 @@ impl ChatWidget { } } - if !selections.uses_workspace_headline() { + if !self.uses_workspace_headline(&selections.status_line_items) { self.status_line_workspace_headline = None; self.status_line_workspace_headline_pending_request_id = None; self.status_line_workspace_headline_last_requested_at = None; @@ -192,7 +173,7 @@ impl ChatWidget { self.request_status_line_workspace_headline_if_due(Instant::now()); } - if selections.uses_thread_usage() { + if self.thread_usage_is_selected() { self.ensure_thread_usage_requested(); } else { self.cancel_thread_usage_polling(); @@ -200,6 +181,9 @@ impl ChatWidget { } fn refresh_status_line_from_selections(&mut self, selections: &StatusSurfaceSelections) { + if self.refresh_provider_footer() { + return; + } let enabled = !selections.status_line_items.is_empty(); self.bottom_pane.set_status_line_enabled(enabled); if !enabled { @@ -503,7 +487,7 @@ impl ChatWidget { }) } - fn status_line_cwd(&self) -> &Path { + pub(super) fn status_line_cwd(&self) -> &Path { self.current_cwd .as_deref() .unwrap_or(self.config.cwd.as_path()) @@ -662,6 +646,11 @@ impl ChatWidget { }); } + fn uses_workspace_headline(&self, status_line_items: &[StatusLineItem]) -> bool { + self.selected_statusline_provider().is_some() + || status_line_items.contains(&StatusLineItem::WorkspaceHeadline) + } + fn request_status_line_workspace_headline_if_due(&mut self, now: Instant) { if !self.status_line_workspace_headline_should_fetch(now) { return; @@ -693,10 +682,7 @@ impl ChatWidget { pub(super) fn refresh_status_line_if_workspace_headline_due(&mut self) { let now = Instant::now(); if self.status_line_workspace_headline_should_fetch(now) - && self - .status_line_items_with_invalids() - .0 - .contains(&StatusLineItem::WorkspaceHeadline) + && self.uses_workspace_headline(&self.status_line_items_with_invalids().0) { self.refresh_status_line(); } @@ -730,10 +716,7 @@ impl ChatWidget { } if !self.status_line_workspace_messages_disabled - && self - .status_line_items_with_invalids() - .0 - .contains(&StatusLineItem::WorkspaceHeadline) + && self.uses_workspace_headline(&self.status_line_items_with_invalids().0) { self.frame_requester .schedule_frame_in(crate::workspace_messages::WORKSPACE_HEADLINE_REFRESH_INTERVAL); diff --git a/codex-rs/tui/src/chatwidget/statusline_reader.rs b/codex-rs/tui/src/chatwidget/statusline_reader.rs new file mode 100644 index 0000000000..a94c1196a4 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/statusline_reader.rs @@ -0,0 +1,231 @@ +//! Read one statusline resource for the displayed thread and keep its footer through native refreshes. + +use super::ChatWidget; +use super::statusline_state::StatuslineState; +use crate::app_event::AppEvent; +use crate::app_event_sender::AppEventSender; +use crate::app_server_session::AppServerSession; +use crate::backend_id::BackendId; +use crate::statusline_provider::ProviderId; +use crate::statusline_provider::ProviderSelection; +use crate::statusline_provider::ResolvedStatuslineProvider; +use crate::ui_tree::UiNode; +use crate::ui_tree::UiTree; +use codex_app_server_protocol::McpResourceContent; +use codex_config::types::StatusLineProviderId; +use codex_config::types::StatusLineSelection; +use codex_features::Feature; +use codex_protocol::ThreadId; +use codex_utils_path_uri::LegacyAppPathString; +use color_eyre::eyre::Result; +use color_eyre::eyre::WrapErr; +use color_eyre::eyre::bail; +use color_eyre::eyre::eyre; +use std::path::PathBuf; +use std::time::Duration; +use tokio::sync::oneshot; +use tokio::sync::watch; +use uuid::Uuid; + +pub(super) struct ActiveStatuslineRead { + token: Uuid, + thread: Option, + selection: StatusLineProviderId, + host_cwd: PathBuf, + startup: watch::Sender<()>, +} + +#[derive(Debug)] +pub(crate) struct StatuslineReadEvent { + token: Uuid, + step: ReadStep, +} + +#[derive(derive_more::Debug)] +enum ReadStep { + Start(watch::Receiver<()>), + #[debug("Snapshot(..)")] + Snapshot(BackendId, oneshot::Sender), + #[debug("Finished(..)")] + Finished(BackendId, Result), +} + +impl StatuslineReadEvent { + fn send(sender: &AppEventSender, token: Uuid, step: ReadStep) { + sender.send(AppEvent::StatuslineRead(Self { token, step })); + } +} + +impl ChatWidget { + pub(super) fn selected_statusline_provider(&self) -> Option<&StatusLineProviderId> { + if self.read_only_history + || !self + .config + .features + .enabled(Feature::TuiExtensionsStatusLine) + { + return None; + } + match self.local_settings.tui.status_line_provider.as_deref()? { + StatusLineSelection::Builtin(_) => None, + StatusLineSelection::Mcp(id) => Some(id), + } + } + + pub(super) fn refresh_provider_footer(&mut self) -> bool { + let Some(selection) = self.selected_statusline_provider() else { + self.statusline_read = None; + return false; + }; + if self + .statusline_read + .as_ref() + .is_some_and(|read| read.is_current(self)) + { + return true; + } + let token = Uuid::new_v4(); + let (startup, ready) = watch::channel(()); + self.statusline_read = Some(ActiveStatuslineRead { + token, + thread: self.thread_id, + selection: selection.clone(), + host_cwd: self.status_line_cwd().to_owned(), + startup, + }); + self.bottom_pane.set_status_line_enabled(/*enabled*/ true); + self.set_status_line(Some( + UiTree(Some(UiNode::String("Initializing…".into()))).into(), + )); + if self.thread_id.is_some() { + StatuslineReadEvent::send(&self.app_event_tx, token, ReadStep::Start(ready)); + } + true + } + + pub(crate) fn handle_statusline_read( + &mut self, + event: StatuslineReadEvent, + owner: &AppServerSession, + ) { + let Some(footer) = self.statusline_read.as_ref() else { + return; + }; + if event.token != footer.token { + return; + } + if !footer.is_current(self) { + self.refresh_status_line(); + return; + } + match event.step { + ReadStep::Start(ready) => footer.start(owner, &self.app_event_tx, ready), + ReadStep::Snapshot(backend, reply) => { + if backend == owner.backend_id() + && let Some(state) = self.statusline_state() + { + let _ = reply.send(state); + } + } + ReadStep::Finished(backend, result) => { + if backend != owner.backend_id() { + return; + } + let tree = result.unwrap_or_else(|name| UiTree(Some(UiNode::String(format!( + "Error loading statusline contents from {name}. Use /statusline to (re)select your provider and try again." + ))))); + self.set_status_line(Some(tree.into())); + } + } + } +} + +impl ActiveStatuslineRead { + fn is_current(&self, chat: &ChatWidget) -> bool { + self.thread == chat.thread_id + && Some(&self.selection) == chat.selected_statusline_provider() + && self.host_cwd == chat.status_line_cwd() + } + + pub(super) fn server_ready(&self, server: &str) { + if self.selection.server == server { + self.startup.send_replace(()); + } + } + + fn start( + &self, + owner: &AppServerSession, + events: &AppEventSender, + mut ready: watch::Receiver<()>, + ) { + let Some(thread) = self.thread else { return }; + let id = ProviderId { + server: self.selection.server.as_str().into(), + tool: self.selection.tool.as_str().into(), + }; + let mut name = self.selection.tool.clone(); + let token = self.token; + let events = events.clone(); + let client = owner.request_handle(); + let backend = owner.backend_id(); + let cwd = LegacyAppPathString::from_path(&self.host_cwd).to_inferred_path_uri(); + 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); + } + // A cold catalog may arrive before the selected MCP server finishes starting. + ready.changed().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; + StatuslineReadEvent::send( + &events, + token, + ReadStep::Finished(backend, result.map_err(|_| name)), + ); + }); + } +} + +fn decode_tree(uri: &str, contents: &[McpResourceContent]) -> Result { + let [ + McpResourceContent::Text { + uri: returned_uri, + mime_type: Some(mime), + text, + .. + }, + ] = contents + else { + bail!("expected one text resource"); + }; + let media_type = mime.split(';').next().unwrap_or_default().trim(); + if uri != returned_uri || !media_type.eq_ignore_ascii_case("application/json") { + bail!("expected application/json at the advertised resource URI"); + } + text.parse().wrap_err("invalid UI tree") +} + +#[cfg(test)] +#[path = "statusline_reader_tests.rs"] +mod tests; diff --git a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs new file mode 100644 index 0000000000..db6680312e --- /dev/null +++ b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs @@ -0,0 +1,177 @@ +#![cfg(test)] +//! Exercise the MCP response envelope and the displayed footer's one-shot lifecycle. + +use super::*; +use crate::bottom_pane::StatusLineFocus; +use crate::chatwidget::tests::make_chatwidget_manual_with_sender; +use crate::chatwidget::tests::render_bottom_popup; +use codex_config::types::BuiltinStatusLine; +use pretty_assertions::assert_eq; +use ratatui::buffer::Buffer; +use ratatui::buffer::Cell; +use ratatui::layout::Rect; +use serde_json::json; +use tokio::sync::mpsc::UnboundedReceiver; + +#[test] +fn statusline_resource_requires_one_matching_json_text_item() { + let uri = "ui://provider/footer"; + let content = |value| serde_json::from_value::(value).unwrap(); + let text = |mime: &str, body: &str| content(json!({"uri":uri, "mimeType":mime, "text":body})); + let item = text("APPLICATION/JSON; charset=utf-8", "null"); + assert_eq!( + decode_tree(uri, std::slice::from_ref(&item)).unwrap(), + UiTree(None) + ); + for contents in [ + vec![], + vec![item.clone(), item], + vec![content( + json!({"uri":"ui://wrong","mimeType":"application/json","text":"null"}), + )], + vec![content(json!({"uri":uri,"text":"null"}))], + vec![content( + json!({"uri":uri,"mimeType":"application/json","blob":"bnVsbA=="}), + )], + vec![text("text/plain", "null")], + vec![text("application/json", "{")], + ] { + assert!(decode_tree(uri, &contents).is_err()); + } +} + +fn read_events(rx: &mut UnboundedReceiver) -> Vec { + std::iter::from_fn(|| rx.try_recv().ok()) + .filter_map(|event| match event { + AppEvent::StatuslineRead(read) => Some(read), + _ => None, + }) + .collect() +} + +fn footer(chat: &ChatWidget) -> Option { + let content = chat.bottom_pane.status_line_content()?; + let area = Rect::new( + /*x*/ 0, /*y*/ 0, /*width*/ 160, /*height*/ 1, + ); + let mut buffer = Buffer::empty(area); + content.render(area, &mut buffer, StatusLineFocus::Focused); + let row: String = buffer.content.iter().map(Cell::symbol).collect(); + Some(row.trim_end().to_owned()) +} + +#[tokio::test] +async fn custom_statusline_requests_headline_and_billing_with_no_native_items() { + let (mut chat, _, mut rx, _) = make_chatwidget_manual_with_sender().await; + let thread = ThreadId::new(); + chat.thread_id = Some(thread); + chat.has_codex_backend_auth = true; + chat.plan_type = Some(codex_protocol::account::PlanType::Business); + chat.local_settings.tui.status_line = Some(Vec::new()); + chat.local_settings.tui.terminal_title = Some(Vec::new()); + chat.local_settings.tui.status_line_provider = + Some(Box::new(StatusLineSelection::Mcp(StatusLineProviderId { + server: "fixture".into(), + tool: "line".into(), + }))); + chat.set_feature_enabled(Feature::TuiExtensionsStatusLine, /*enabled*/ true); + chat.refresh_status_line(); + + let events: Vec<_> = std::iter::from_fn(|| rx.try_recv().ok()).collect(); + assert!( + events + .iter() + .any(|event| matches!(event, AppEvent::RefreshStatusLineWorkspaceHeadline { .. })) + ); + assert!(events.iter().any(|event| matches!(event, AppEvent::RefreshThreadUsage { thread_id, .. } if *thread_id == thread))); +} + +#[tokio::test] +async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() { + let (mut chat, _, mut rx, _) = make_chatwidget_manual_with_sender().await; + let server = crate::start_embedded_app_server_for_picker(&chat.config) + .await + .unwrap(); + let selected = Box::new(StatusLineSelection::Mcp(StatusLineProviderId { + server: "fixture".into(), + tool: "line".into(), + })); + chat.local_settings.tui.status_line = Some(Vec::new()); + chat.thread_id = Some(ThreadId::new()); + chat.local_settings.tui.status_line_provider = Some(selected.clone()); + chat.set_feature_enabled(Feature::TuiExtensionsStatusLine, /*enabled*/ false); + chat.refresh_status_line(); + assert!(read_events(&mut rx).is_empty()); + + chat.local_settings.tui.status_line_provider = Some(Box::new(StatusLineSelection::Builtin( + BuiltinStatusLine::Default, + ))); + chat.set_feature_enabled(Feature::TuiExtensionsStatusLine, /*enabled*/ true); + chat.refresh_status_line(); + assert!(read_events(&mut rx).is_empty()); + chat.thread_id = None; + chat.local_settings.tui.status_line_provider = Some(selected); + chat.refresh_status_line(); + let initializing = footer(&chat).unwrap(); + assert!(read_events(&mut rx).is_empty()); + + chat.thread_id = Some(ThreadId::new()); + chat.refresh_status_line(); + chat.refresh_status_line(); + let [start] = read_events(&mut rx).try_into().unwrap(); + let token = start.token; + chat.set_active_agent_label(Some("native-agent-label".into())); + let finish = |token, root| StatuslineReadEvent { + token, + step: ReadStep::Finished(server.backend_id(), Ok(UiTree(root))), + }; + chat.handle_statusline_read(finish(token, Some(UiNode::String("Ready".into()))), &server); + chat.refresh_status_line(); + let ready = footer(&chat).unwrap(); + insta::assert_snapshot!(format!("{initializing}\n{ready}"), @" + Initializing… + Ready + "); + chat.handle_statusline_read(finish(token, /*root*/ None), &server); + chat.refresh_status_line(); + assert_eq!(footer(&chat).as_deref(), Some("")); + assert!(!render_bottom_popup(&chat, /*width*/ 80).contains("native-agent-label")); + assert!(read_events(&mut rx).is_empty()); + + chat.read_only_history = true; + chat.refresh_status_line(); + assert!(footer(&chat).is_none()); + assert!(read_events(&mut rx).is_empty()); + chat.read_only_history = false; + chat.refresh_status_line(); + let [resumed] = read_events(&mut rx).try_into().unwrap(); + chat.handle_statusline_read(finish(token, None), &server); + assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); + let token = resumed.token; + chat.primary_environment_cwd = Some(crate::session_state::EnvironmentCwd { + path: LegacyAppPathString::from_path(chat.config.cwd.join("executor-checkout").as_path()), + is_server_local: false, + }); + chat.refresh_status_line(); + assert!(read_events(&mut rx).is_empty()); + chat.current_cwd = Some(chat.config.cwd.join("another-project").to_path_buf()); + let (reply, snapshot) = oneshot::channel(); + chat.handle_statusline_read( + StatuslineReadEvent { + token, + step: ReadStep::Snapshot(server.backend_id(), reply), + }, + &server, + ); + assert!(snapshot.await.is_err()); + let [replacement] = read_events(&mut rx).try_into().unwrap(); + assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); + let token = replacement.token; + chat.thread_id = Some(ThreadId::new()); + chat.refresh_status_line(); + chat.handle_statusline_read( + finish(token, Some(UiNode::String("retired".into()))), + &server, + ); + assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); +} diff --git a/codex-rs/tui/src/chatwidget/statusline_state.rs b/codex-rs/tui/src/chatwidget/statusline_state.rs index 07eafd78c1..fb1a098fa5 100644 --- a/codex-rs/tui/src/chatwidget/statusline_state.rs +++ b/codex-rs/tui/src/chatwidget/statusline_state.rs @@ -176,7 +176,6 @@ impl ChatWidget { } } - #[cfg_attr(not(test), expect(dead_code, reason = "staged for provider reads"))] pub(crate) fn statusline_state(&self) -> Option { if self.read_only_history { return None; diff --git a/codex-rs/tui/src/chatwidget/thread_usage.rs b/codex-rs/tui/src/chatwidget/thread_usage.rs index 4a92e6fcdd..1aeba3cdff 100644 --- a/codex-rs/tui/src/chatwidget/thread_usage.rs +++ b/codex-rs/tui/src/chatwidget/thread_usage.rs @@ -396,18 +396,26 @@ impl ChatWidget { ) } - fn thread_usage_is_selected(&self) -> bool { + pub(super) fn thread_usage_is_selected(&self) -> bool { let selected = self.selected_thread_usage(); selected.credits || selected.estimated_cost } fn selected_thread_usage(&self) -> SelectedThreadUsage { + if self.selected_statusline_provider().is_some() { + return SelectedThreadUsage { + credits: self.plan_type != Some(PlanType::Ent26), + estimated_cost: true, + }; + } let mut selected = SelectedThreadUsage::default(); - for item in self.configured_status_line_items() { - match item.parse::() { - Ok(StatusLineItem::ThreadCredits) => selected.credits = true, - Ok(StatusLineItem::EstimatedThreadCost) => selected.estimated_cost = true, - Ok(_) | Err(_) => {} + if !self.read_only_history { + for item in self.configured_status_line_items() { + match item.parse::() { + Ok(StatusLineItem::ThreadCredits) => selected.credits = true, + Ok(StatusLineItem::EstimatedThreadCost) => selected.estimated_cost = true, + Ok(_) | Err(_) => {} + } } } for item in self.configured_terminal_title_items() { diff --git a/codex-rs/tui/src/statusline_provider.rs b/codex-rs/tui/src/statusline_provider.rs index 0175ed5fd2..4d3f95f6ee 100644 --- a/codex-rs/tui/src/statusline_provider.rs +++ b/codex-rs/tui/src/statusline_provider.rs @@ -65,10 +65,10 @@ pub(crate) struct ProviderId { pub(crate) tool: McpToolName, } -#[cfg_attr(not(test), expect(dead_code, reason = "staged provider choice"))] pub(crate) enum ProviderSelection<'a> { Saved(&'a ProviderId), /// A provider advertised during the current picker refresh. + #[cfg_attr(not(test), expect(dead_code, reason = "staged picker selection"))] Discovered(&'a StatuslineProvider), } @@ -78,7 +78,6 @@ pub(crate) struct ResolvedStatuslineProvider { provider: StatuslineProvider, } -#[cfg_attr(not(test), expect(dead_code, reason = "staged resource reader"))] impl ResolvedStatuslineProvider { pub(crate) async fn lookup( client: &AppServerRequestHandle, diff --git a/codex-rs/tui/tests/suite/mod.rs b/codex-rs/tui/tests/suite/mod.rs index b2992f4a2e..2a999f0817 100644 --- a/codex-rs/tui/tests/suite/mod.rs +++ b/codex-rs/tui/tests/suite/mod.rs @@ -14,7 +14,11 @@ mod resize_reflow; mod screen_reader; mod status_indicator; #[cfg(unix)] +mod statusline_provider; +#[cfg(unix)] mod thread_title; +#[cfg(unix)] +mod unix_daemon; mod vt100_history; mod vt100_live_commit; #[cfg(unix)] diff --git a/codex-rs/tui/tests/suite/provider_defaults.rs b/codex-rs/tui/tests/suite/provider_defaults.rs index f7b676f33e..2411ad3a92 100644 --- a/codex-rs/tui/tests/suite/provider_defaults.rs +++ b/codex-rs/tui/tests/suite/provider_defaults.rs @@ -6,12 +6,10 @@ use anyhow::Context; use anyhow::Result; use anyhow::ensure; use app_test_support::create_fake_rollout; -use std::process::Stdio; use std::time::Duration; #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn resume_lists_all_providers_and_fork_keeps_provider_filter() -> Result<()> { - let codex = codex_utils_cargo_bin::cargo_bin("codex")?; let cwd = codex_utils_cargo_bin::repo_root()?; for action in ["resume", "fork"] { for (embedded, last, explicit) in [ @@ -45,38 +43,11 @@ async fn resume_lists_all_providers_and_fork_keeps_provider_filter() -> Result<( /*git_info*/ None, )?; } - let mut daemon = tokio::process::Command::new(&codex) - .args([ - "app-server", - "--listen", - "unix://", - "-c", - "model_provider=\"server-provider\"", - ]) - .env("CODEX_HOME", home.path()) - .stdin(Stdio::null()) - .stdout(Stdio::null()) - .stderr(Stdio::inherit()) - .kill_on_drop(true) - .spawn()?; - let socket = codex_app_server_client::app_server_control_socket_path(home.path())?; - tokio::time::timeout(Duration::from_secs(/*secs*/ 30), async { - loop { - if tokio::net::UnixStream::connect(socket.as_path()) - .await - .is_ok() - { - return Ok::<(), anyhow::Error>(()); - } - ensure!( - daemon.try_wait()?.is_none(), - "app server exited before opening its socket" - ); - tokio::time::sleep(Duration::from_millis(/*millis*/ 20)).await; - } - }) - .await??; - let remote_endpoint = format!("unix://{}", socket.as_path().display()); + let (mut daemon, remote_endpoint) = super::unix_daemon::start( + home.path(), + &["-c", "model_provider=\"server-provider\""], + ) + .await?; let mut args = vec![action, "--all"]; if embedded { args.push("--no-daemon"); diff --git a/codex-rs/tui/tests/suite/statusline_provider.rs b/codex-rs/tui/tests/suite/statusline_provider.rs new file mode 100644 index 0000000000..e78de664f1 --- /dev/null +++ b/codex-rs/tui/tests/suite/statusline_provider.rs @@ -0,0 +1,142 @@ +#![cfg(test)] +//! A real CLI, app server and stdio MCP provider exercise the selected resource end to end. + +use super::focus_palette::PtyCodex; +use super::focus_palette::write_test_config; +use anyhow::Context; +use anyhow::Result; +use pretty_assertions::assert_eq; +use serde_json::Value; +use serde_json::json; +use std::fs; +use std::io::Write; +use std::path::Path; +use tempfile::TempDir; + +fn test_home(cwd: &Path) -> Result { + let home = tempfile::tempdir_in("/tmp")?; + write_test_config(home.path(), cwd)?; + let config = home.path().join("config.toml"); + let existing = fs::read_to_string(&config)?; + fs::write( + config, + format!("features.tui_extensions_statusline = true\n{existing}"), + )?; + Ok(home) +} + +fn register_provider(config: &Path, receipt: &Path, barrier: &Path) -> Result<()> { + let registration = json!({"mcp_servers":{"fixture":{ + "command":core_test_support::stdio_server_bin()?, + "env":{"MCP_TEST_STATUSLINE_RECORD":receipt, "MCP_TEST_INITIALIZE_BARRIER_FILE":barrier} + }}}); + writeln!( + fs::OpenOptions::new() + .create(true) + .append(true) + .open(config)?, + "\n{}", + toml::to_string(®istration)? + )?; + Ok(()) +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Setup { + Embedded, + Remote, + ProjectShadow, +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn statusline_reads_the_selected_stdio_resource_on_the_displayed_thread() -> Result<()> { + for mode in [Setup::Embedded, Setup::Remote, Setup::ProjectShadow] { + let work = tempfile::tempdir_in("/tmp")?; + let cwd = work.path().canonicalize()?; + fs::create_dir(cwd.join(".git"))?; + let client = test_home(&cwd)?; + let registration_home = test_home(&cwd)?; + let host = if mode == Setup::Remote { + registration_home.path() + } else { + client.path() + }; + let receipt = cwd.join("resource-read.jsonl"); + let shadow = cwd.join("project-read.jsonl"); + let barrier = cwd.join("provider-ready"); + register_provider(&host.join("config.toml"), &receipt, &barrier)?; + let preference = "[tui]\ndisable_paste_burst = true\nstatus_line = []\nstatus_line_provider = { server='fixture', tool='sandbox_meta' }"; + writeln!( + fs::OpenOptions::new() + .append(true) + .open(client.path().join("config.toml"))?, + "\n{preference}" + )?; + if mode == Setup::ProjectShadow { + let project = cwd.join(".codex"); + fs::create_dir(&project)?; + register_provider(&project.join("config.toml"), &shadow, &barrier)?; + } + let mut daemon = None; + let endpoint; + let args = if mode == Setup::Remote { + let (child, socket) = super::unix_daemon::start(host, &[]).await?; + daemon = Some(child); + endpoint = socket; + vec!["--remote", endpoint.as_str()] + } else { + vec!["--no-daemon"] + }; + let mut terminal = PtyCodex::start_cli(&cwd, client, &args)?; + terminal + .wait_for_screen("Initializing…") + .with_context(|| format!("{mode:?} initialization"))?; + assert!(!receipt.exists()); + if mode == Setup::Embedded { + terminal.write_input(b"/raw on\r")?; + terminal.wait_for_screen("Raw output mode on")?; + } + fs::write(&barrier, "")?; + if mode == Setup::ProjectShadow { + terminal.wait_for_screen("Error loading statusline contents from sandbox_meta")?; + assert!(!receipt.exists()); + assert!(!shadow.exists()); + } else { + terminal + .wait_for_screen("Provider thread ") + .with_context(|| format!("{mode:?} resource read"))?; + let receipts = fs::read_to_string(&receipt)?; + let [line]: [&str; 1] = receipts + .lines() + .collect::>() + .try_into() + .expect("one read"); + let state: Value = serde_json::from_str(line)?; + let thread = state["thread"]["id"] + .as_str() + .context("missing displayed thread ID")?; + terminal.wait_for_screen(&format!("Provider thread {thread}"))?; + terminal.write_input(b"/status\r")?; + terminal.wait_for_screen("Session:")?; + let status = terminal.screen_contents(); + let session = status + .lines() + .find(|line| line.contains("Session:")) + .context("missing Session row")?; + assert!( + session.contains(thread), + "{session} should identify {thread}" + ); + if mode == Setup::Embedded { + assert_eq!(state["app"]["display_mode"], "raw"); + } + assert_eq!(state["thread"]["workspace"], json!({"cwd": cwd})); + } + drop(terminal); + if let Some(mut child) = daemon { + child.kill().await?; + child.wait().await?; + } + } + Ok(()) +} diff --git a/codex-rs/tui/tests/suite/unix_daemon.rs b/codex-rs/tui/tests/suite/unix_daemon.rs new file mode 100644 index 0000000000..14bce09cb6 --- /dev/null +++ b/codex-rs/tui/tests/suite/unix_daemon.rs @@ -0,0 +1,36 @@ +//! Launch a real app server for CLI tests that connect over a Unix socket. + +use anyhow::Result; +use anyhow::ensure; +use std::path::Path; +use std::process::Stdio; +use std::time::Duration; +use tokio::process::Child; + +pub(super) async fn start(home: &Path, extra_args: &[&str]) -> Result<(Child, String)> { + let socket = codex_app_server_client::app_server_control_socket_path(home)?; + let mut daemon = tokio::process::Command::new(codex_utils_cargo_bin::cargo_bin("codex")?) + .args(["app-server", "--listen", "unix://"]) + .args(extra_args) + .env("CODEX_HOME", home) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::inherit()) + .kill_on_drop(true) + .spawn()?; + tokio::time::timeout(Duration::from_secs(30), async { + while tokio::net::UnixStream::connect(socket.as_path()) + .await + .is_err() + { + ensure!( + daemon.try_wait()?.is_none(), + "app server exited before opening its socket" + ); + tokio::time::sleep(Duration::from_millis(20)).await; + } + Ok::<_, anyhow::Error>(()) + }) + .await??; + Ok((daemon, format!("unix://{}", socket.as_path().display()))) +}