diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index f777550c2b..3274af22f9 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -219,6 +219,7 @@ mod config_persistence; mod connector_mentions; mod event_dispatch; mod exit_summary; +mod experimental_features; mod file_change_approvals; mod history_pagination; mod history_ui; @@ -537,6 +538,7 @@ struct InitialHistoryReplayBuffer { } pub(crate) struct App { + feature_write_lock: Arc>, model_catalog: Arc, pub(crate) session_telemetry: SessionTelemetry, pub(crate) app_event_tx: AppEventSender, diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index 7bfc312b4a..46b7b400cb 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -2402,11 +2402,10 @@ impl App { } } AppEvent::FetchExperimentalFeatures { thread_id, response_tx } => { - crate::experimental_features::fetch( - app_server.request_handle(), - thread_id, - response_tx, - ); + self.fetch_experimental_features(app_server, thread_id, response_tx); + } + AppEvent::SaveExperimentalFeatures { thread_id, updates, response_tx } => { + self.save_experimental_features(app_server, thread_id, updates, response_tx); } AppEvent::UpdateFeatureFlags { updates } => { self.update_feature_flags(app_server, updates).await; diff --git a/codex-rs/tui/src/app/experimental_features.rs b/codex-rs/tui/src/app/experimental_features.rs new file mode 100644 index 0000000000..19d9d3eec6 --- /dev/null +++ b/codex-rs/tui/src/app/experimental_features.rs @@ -0,0 +1,67 @@ +//! Menu-only feature persistence. Configured readback never replaces task state, +//! and an accepted save finishes even if its popup closes or the user navigates. + +use super::*; +use crate::experimental_features::FeatureWriteResult; +use tokio::sync::oneshot; + +impl App { + pub(super) fn fetch_experimental_features( + &self, + app_server: &AppServerSession, + thread_id: ThreadId, + mut response_tx: oneshot::Sender< + Result, String>, + >, + ) { + let lock = self.feature_write_lock.clone(); + let handle = app_server.request_handle(); + tokio::spawn(async move { + // A reopened popup must discover values after the outstanding save. + tokio::select! { + _ = response_tx.closed() => {}, + _guard = lock.lock() => crate::experimental_features::fetch( + handle, thread_id, "tui-experimental-features", response_tx, + ), + } + }); + } + + pub(super) fn save_experimental_features( + &mut self, + app_server: &AppServerSession, + thread_id: ThreadId, + updates: Vec<(String, bool)>, + response_tx: oneshot::Sender>, + ) { + let Ok(guard) = self.feature_write_lock.clone().try_lock_owned() else { + let error = + "An experimental feature save is still in progress. Retry after it finishes."; + self.chat_widget.add_warning_message(error.to_string()); + let _ = response_tx.send(Err(error.to_string())); + return; + }; + let request_handle = app_server.request_handle(); + let tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let result = + crate::experimental_features::write(request_handle, thread_id, updates).await; + drop(guard); + // Report unresolved outcomes even if the popup closes before its next draw. + let warning = match &result { + Ok(result) => result.warning.as_ref(), + Err(error) => Some(error), + }; + if let Some(warning) = warning { + tx.send(AppEvent::InsertHistoryCell(Box::new( + history_cell::new_warning_event(warning.clone()), + ))); + } + let _ = response_tx.send(result); + }); + } +} + +#[cfg(test)] +#[path = "experimental_features_tests.rs"] +mod tests; diff --git a/codex-rs/tui/src/app/experimental_features_tests.rs b/codex-rs/tui/src/app/experimental_features_tests.rs new file mode 100644 index 0000000000..bec78ba8ff --- /dev/null +++ b/codex-rs/tui/src/app/experimental_features_tests.rs @@ -0,0 +1,92 @@ +use super::*; +use crate::app::tests::make_test_app_with_channels; +use codex_app_server_client::AppServerClient; +use pretty_assertions::assert_eq; + +#[tokio::test] +async fn experimental_features_use_selected_server_profile_and_preserve_task_settings() -> Result<()> +{ + let home = tempfile::tempdir()?; + let selected = AbsolutePathBuf::from_absolute_path(home.path().join("work.config.toml"))?; + std::fs::write(home.path().join("config.toml"), "# unselected\n")?; + std::fs::write(&selected, "[features]\nnetwork_proxy = true\n")?; + let loader = LoaderOverrides { + user_config_path: Some(selected.clone()), + user_config_profile: Some("work".parse()?), + ignore_project_config: true, + ..LoaderOverrides::without_managed_config_for_tests() + }; + let config = ConfigBuilder::default() + .codex_home(home.path().to_path_buf()) + .loader_overrides(loader.clone()) + .build() + .await?; + let client = Box::pin(crate::start_embedded_app_server( + Default::default(), + config.clone(), + Vec::new(), + loader, + /*strict_config*/ false, + Default::default(), + codex_feedback::CodexFeedback::new(), + /*log_db*/ None, + /*state_db*/ None, + Arc::new(EnvironmentManager::default_for_tests()), + )) + .await?; + let mut server = AppServerSession::new( + AppServerClient::InProcess(client), + crate::app_server_session::ThreadParamsMode::Remote, + ); + let thread = server.start_thread(&config).await?.session.thread_id; + let (mut app, mut events, _ops) = make_test_app_with_channels().await; + let before = (app.config.clone(), app.chat_widget.config_ref().clone()); + let updates = vec![ + ("network_proxy".to_string(), false), + ("multi_agent".to_string(), false), + ("memories".to_string(), true), + ]; + let (response_tx, response_rx) = oneshot::channel(); + app.save_experimental_features(&server, thread, updates.clone(), response_tx); + let (retry_tx, retry_rx) = oneshot::channel(); + app.save_experimental_features(&server, thread, updates.clone(), retry_tx); + assert!(retry_rx.await?.unwrap_err().contains("still in progress")); + assert!(matches!(events.try_recv()?, AppEvent::InsertHistoryCell(_))); + let (catalog_tx, catalog_rx) = oneshot::channel(); + app.fetch_experimental_features(&server, thread, catalog_tx); + // Navigation while the write is pending must not change the new task's settings. + app.active_thread_id = Some(ThreadId::new()); + let result = tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 15), response_rx) + .await?? + .map_err(|error| color_eyre::eyre::eyre!(error))?; + assert_eq!(result.warning, None); + assert_eq!( + catalog_rx + .await? + .map_err(|error| color_eyre::eyre::eyre!(error))?, + result.features + ); + let saved: toml::Value = toml::from_str(&std::fs::read_to_string(&selected)?)?; + assert_eq!( + serde_json::to_value(saved)?, + serde_json::json!({"features": {"multi_agent": false, "memories": true}}) + ); + assert_eq!( + (app.config.clone(), app.chat_widget.config_ref().clone()), + before + ); + assert_eq!( + std::fs::read_to_string(home.path().join("config.toml"))?, + "# unselected\n" + ); + // A failed save still reports to history after its popup has closed. + let (tx, rx) = oneshot::channel(); + drop(rx); + app.save_experimental_features(&server, thread, vec![("missing_feature".into(), true)], tx); + assert!(matches!( + events.recv().await, + Some(AppEvent::InsertHistoryCell(_)) + )); + server.shutdown().await?; + Ok(()) +} diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs index 8c179a3d45..0dacd3b588 100644 --- a/codex-rs/tui/src/app/startup.rs +++ b/codex-rs/tui/src/app/startup.rs @@ -505,6 +505,7 @@ See the Codex keymap documentation for supported actions and examples." let upgrade_version = crate::updates::get_upgrade_version(&config); let mut app = Self { + feature_write_lock: Arc::default(), model_catalog, session_telemetry: session_telemetry.clone(), app_event_tx, diff --git a/codex-rs/tui/src/app/test_support.rs b/codex-rs/tui/src/app/test_support.rs index ece72fa1dd..ec93917e4f 100644 --- a/codex-rs/tui/src/app/test_support.rs +++ b/codex-rs/tui/src/app/test_support.rs @@ -17,6 +17,7 @@ pub(super) async fn make_test_app() -> App { let session_telemetry = test_session_telemetry(&config, model.as_str()); App { + feature_write_lock: Arc::default(), model_catalog: chat_widget.model_catalog(), session_telemetry, app_event_tx, diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs index 0f08385a37..e4225417a4 100644 --- a/codex-rs/tui/src/app/tests.rs +++ b/codex-rs/tui/src/app/tests.rs @@ -5466,6 +5466,7 @@ async fn make_test_app() -> App { let session_telemetry = test_session_telemetry(&config, model.as_str()); App { + feature_write_lock: Arc::default(), model_catalog: chat_widget.model_catalog(), session_telemetry, app_event_tx, @@ -5550,6 +5551,7 @@ pub(super) async fn make_test_app_with_channels() -> ( ( App { + feature_write_lock: Arc::default(), model_catalog: chat_widget.model_catalog(), session_telemetry, app_event_tx, diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index 07ecf99923..66d8f934fc 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -54,6 +54,7 @@ use crate::bottom_pane::TerminalTitleItem; use crate::chatwidget::ConnectorScopeGeneration; use crate::chatwidget::ThreadUsageOutcome; use crate::chatwidget::UserMessage; +use crate::experimental_features::FeatureWriteResult; use crate::goal_files::GoalDraft; use codex_app_server_protocol::AskForApproval; use codex_config::types::ApprovalsReviewer; @@ -1171,6 +1172,13 @@ pub(crate) enum AppEvent { updates: Vec<(Feature, bool)>, }, + /// Save generic menu controls without changing running-task settings. + SaveExperimentalFeatures { + thread_id: ThreadId, + updates: Vec<(String, bool)>, + response_tx: tokio::sync::oneshot::Sender>, + }, + /// Update memory settings and persist them to config.toml. UpdateMemorySettings { use_memories: bool, diff --git a/codex-rs/tui/src/bottom_pane/experimental_features_view.rs b/codex-rs/tui/src/bottom_pane/experimental_features_view.rs index 59224c8750..9ea74c2ba8 100644 --- a/codex-rs/tui/src/bottom_pane/experimental_features_view.rs +++ b/codex-rs/tui/src/bottom_pane/experimental_features_view.rs @@ -1,9 +1,12 @@ //! Experimental controls with popup-owned discovery and configured enablement. -//! Only changed, supported controls are submitted to the existing writer. +//! Failed saves retain intent for explicit retry; cancellation remains available. +use crate::experimental_features::FeatureWriteResult; use codex_app_server_protocol::ExperimentalFeature; use codex_app_server_protocol::ExperimentalFeatureStage; use codex_features::FEATURES; +use codex_features::Feature; +use codex_protocol::ThreadId; use std::time::Duration; use std::time::Instant; use tokio::sync::oneshot; @@ -32,8 +35,6 @@ use crate::render::renderable::ColumnRenderable; use crate::render::renderable::Renderable; use crate::style::user_message_style; -use codex_features::Feature; - use super::CancellationEvent; use super::bottom_pane_view::BottomPaneView; use super::popup_consts::MAX_POPUP_ROWS; @@ -43,17 +44,21 @@ use super::selection_popup_common::measure_rows_height; use super::selection_popup_common::render_rows; pub(crate) struct ExperimentalFeatureItem { - pub feature: Option, + pub key: String, pub name: String, pub description: String, pub enabled: bool, + pub writable: bool, } pub(crate) struct ExperimentalFeaturesView { features: Vec, initial_enabled: Vec, + unconfirmed: Vec, catalog_rx: Option, String>>>, - discovery_status: &'static str, + discovery_status: String, + thread_id: ThreadId, + write_rx: Option>>, state: ScrollState, complete: bool, app_event_tx: AppEventSender, @@ -64,6 +69,7 @@ pub(crate) struct ExperimentalFeaturesView { impl ExperimentalFeaturesView { pub(crate) fn new( features: Vec, + thread_id: ThreadId, catalog_rx: Option, String>>>, app_event_tx: AppEventSender, keymap: ListKeymap, @@ -73,8 +79,12 @@ impl ExperimentalFeaturesView { "Loading server experiments…" } else { "" - }, + } + .to_string(), + thread_id, + write_rx: None, catalog_rx, + unconfirmed: Vec::new(), initial_enabled: features.iter().map(|item| item.enabled).collect(), features, state: ScrollState::new(), @@ -92,7 +102,7 @@ impl ExperimentalFeaturesView { header.push(Line::from("Experimental features".bold())); for text in [ "Checked features are configured on. Some experimental features take effect only in new tasks or after restarting the Codex server.", - self.discovery_status, + self.discovery_status.as_str(), ].into_iter().filter(|text| !text.is_empty()) { for line in textwrap::wrap(text, usize::from(width.max(1))) { header.push(Line::from(line.into_owned().dim())); @@ -123,16 +133,12 @@ impl ExperimentalFeaturesView { ' ' }; let marker = if item.enabled { 'x' } else { ' ' }; - let read_only = if item.feature.is_none() { - " (read-only)" - } else { - "" - }; + let read_only = if item.writable { "" } else { " (read-only)" }; let name = format!("{prefix} [{marker}] {}{read_only}", item.name); rows.push(GenericDisplayRow { name, description: Some(item.description.clone()), - is_disabled: item.feature.is_none(), + is_disabled: !item.writable || self.write_rx.is_some(), ..Default::default() }); } @@ -187,13 +193,67 @@ impl ExperimentalFeaturesView { return; }; - if let Some(item) = self.features.get_mut(selected_idx) - && item.feature.is_some() + if self.write_rx.is_none() + && let Some(item) = self.features.get_mut(selected_idx) + && item.writable { item.enabled = !item.enabled; } } + fn save_special_controls(&mut self) { + // Keep the two unmigrated controls on their existing writer, including + // its runtime and permission side effects. Never retry them generically. + let mut updates = Vec::new(); + for (item, initial) in self.features.iter().zip(&mut self.initial_enabled) { + if item.writable + && item.enabled != *initial + && let Some(feature) = [Feature::PreventIdleSleep, Feature::GuardianApproval] + .into_iter() + .find(|feature| feature.key() == item.key) + { + updates.push((feature, item.enabled)); + *initial = item.enabled; + } + } + if !updates.is_empty() { + self.app_event_tx + .send(AppEvent::UpdateFeatureFlags { updates }); + } + } + + fn save_changes(&mut self) { + if self.write_rx.is_some() { + self.complete = true; + return; + } + self.save_special_controls(); + let updates: Vec<_> = self + .features + .iter() + .zip(&self.initial_enabled) + .filter(|(item, initial)| { + item.writable && (item.enabled != **initial || self.unconfirmed.contains(&item.key)) + }) + .map(|(item, _)| (item.key.clone(), item.enabled)) + .collect(); + if !updates.is_empty() { + let (tx, rx) = oneshot::channel(); + self.write_rx = Some(rx); + // A failed response can follow a committed write. Keep these keys dirty + // so reverting to the old baseline still sends a corrective write. + self.unconfirmed = updates.iter().map(|(key, _)| key.clone()).collect(); + self.discovery_status = "Saving experimental features…".to_string(); + self.app_event_tx.send(AppEvent::SaveExperimentalFeatures { + thread_id: self.thread_id, + updates, + response_tx: tx, + }); + } else { + self.complete = true; + } + } + fn rows_width(total_width: u16) -> u16 { total_width.saturating_sub(2) } @@ -201,6 +261,42 @@ impl ExperimentalFeaturesView { impl BottomPaneView for ExperimentalFeaturesView { fn pre_draw_tick(&mut self, _now: Instant) -> bool { + if let Some(receiver) = self.write_rx.as_mut() { + let result = match receiver.try_recv() { + Ok(result) => result, + Err(oneshot::error::TryRecvError::Empty) => return false, + Err(oneshot::error::TryRecvError::Closed) => Err( + "Saving was interrupted. Reopen /experimental to check configured values." + .to_string(), + ), + }; + self.write_rx = None; + match result { + Ok(result) => { + for item in &mut self.features { + if matches!( + item.key.as_str(), + "prevent_idle_sleep" | "guardian_approval" + ) { + continue; + } + if let Some(feature) = result + .features + .iter() + .find(|feature| feature.name == item.key) + { + item.enabled = feature.enabled; + } + } + self.unconfirmed.clear(); + self.initial_enabled = self.features.iter().map(|item| item.enabled).collect(); + self.complete = result.warning.is_none(); + self.discovery_status = result.warning.unwrap_or_default(); + } + Err(error) => self.discovery_status = error, + } + return true; + } let Some(receiver) = self.catalog_rx.as_mut() else { return false; }; @@ -219,19 +315,18 @@ impl BottomPaneView for ExperimentalFeaturesView { if feature.stage != ExperimentalFeatureStage::Beta { continue; } - // The existing writer uses local defaults and Feature IDs. A new - // server control or a changed default must wait for config-write migration. - let writable = FEATURES - .iter() - .find(|spec| { + self.initial_enabled.push(feature.enabled); + self.features.push(ExperimentalFeatureItem { + // Preserve the existing metadata gate for unmigrated controls. + writable: !matches!( + feature.name.as_str(), + "prevent_idle_sleep" | "guardian_approval" + ) || FEATURES.iter().any(|spec| { spec.key == feature.name && spec.stage.experimental_menu_name().is_some() && spec.default_enabled == feature.default_enabled - }) - .map(|spec| spec.id); - self.initial_enabled.push(feature.enabled); - self.features.push(ExperimentalFeatureItem { - feature: writable, + }), + key: feature.name.clone(), name: feature.display_name.unwrap_or(feature.name), description: feature.description.unwrap_or_default(), enabled: feature.enabled, @@ -242,21 +337,21 @@ impl BottomPaneView for ExperimentalFeaturesView { "No server experiments available." } else { "" - }; + } + .to_string(); self.initialize_selection(); } Err(error) => { tracing::warn!(%error, "experimental feature discovery failed"); - self.discovery_status = "Server experiments unavailable. Reopen /experimental to retry; restart this Codex client if requests remain unanswered."; + self.discovery_status = "Server experiments unavailable. Reopen /experimental to retry; restart this Codex client if requests remain unanswered.".to_string(); } } true } fn next_frame_delay(&self) -> Option { - self.catalog_rx - .as_ref() - .map(|_| Duration::from_millis(/*millis*/ 100)) + (self.catalog_rx.is_some() || self.write_rx.is_some()) + .then(|| Duration::from_millis(/*millis*/ 100)) } fn keymap_contexts(&self) -> crate::keymap::KeymapContextSet { @@ -276,9 +371,10 @@ impl BottomPaneView for ExperimentalFeaturesView { modifiers: KeyModifiers::NONE, .. } => self.toggle_selected(), - _ if self.keymap.accept.is_pressed(key_event) - || self.keymap.cancel.is_pressed(key_event) => - { + _ if self.keymap.accept.is_pressed(key_event) => { + self.save_changes(); + } + _ if self.keymap.cancel.is_pressed(key_event) => { self.on_ctrl_c(); } _ => {} @@ -290,18 +386,13 @@ impl BottomPaneView for ExperimentalFeaturesView { } fn on_ctrl_c(&mut self) -> CancellationEvent { - let updates: Vec<_> = self - .features - .iter() - .zip(&self.initial_enabled) - .filter(|(item, initial)| item.enabled != **initial) - .filter_map(|(item, _)| item.feature.map(|feature| (feature, item.enabled))) - .collect(); - if !updates.is_empty() { - self.app_event_tx - .send(AppEvent::UpdateFeatureFlags { updates }); + // After an attempted save, cancellation must remain possible even if the + // server rejects retries immediately. Explicit accept retries dirty keys. + if !self.unconfirmed.is_empty() { + self.save_special_controls(); + } else { + self.save_changes(); } - self.complete = true; CancellationEvent::Handled } @@ -362,7 +453,14 @@ impl Renderable for ExperimentalFeaturesView { width: footer_area.width.saturating_sub(2), height: footer_area.height, }; - self.footer_hint.clone().dim().render(hint_area, buf); + let hint = if self.write_rx.is_some() { + Line::from("Saving… Closing this popup will not cancel the write.") + } else if !self.unconfirmed.is_empty() { + Line::from("Selections retained. Save to retry, or cancel to close.") + } else { + self.footer_hint.clone() + }; + hint.dim().render(hint_area, buf); } fn desired_height(&self, width: u16) -> u16 { diff --git a/codex-rs/tui/src/bottom_pane/experimental_features_view_tests.rs b/codex-rs/tui/src/bottom_pane/experimental_features_view_tests.rs index d6f0edd9bb..3ae7173d60 100644 --- a/codex-rs/tui/src/bottom_pane/experimental_features_view_tests.rs +++ b/codex-rs/tui/src/bottom_pane/experimental_features_view_tests.rs @@ -14,11 +14,12 @@ fn server_feature(name: &str) -> ExperimentalFeature { } #[test] -fn experimental_features_discovery_preserves_server_order_and_limits_writes() { +fn experimental_features_discovery_preserves_server_order_and_accepts_new_keys() { let (app_tx, mut app_rx) = tokio::sync::mpsc::unbounded_channel(); let (catalog_tx, catalog_rx) = oneshot::channel(); let mut view = ExperimentalFeaturesView::new( Vec::new(), + ThreadId::new(), Some(catalog_rx), AppEventSender::new(app_tx), crate::keymap::RuntimeKeymap::defaults().list, @@ -38,12 +39,12 @@ fn experimental_features_discovery_preserves_server_order_and_limits_writes() { assert_eq!( view.features .iter() - .map(|item| (item.feature, item.enabled)) + .map(|item| (item.key.as_str(), item.enabled)) .collect::>(), vec![ - (Some(Feature::NetworkProxy), true), - (None, true), - (Some(Feature::PreventIdleSleep), true), + ("network_proxy", true), + ("future_feature", true), + ("prevent_idle_sleep", true) ] ); let area = Rect::new( @@ -58,25 +59,72 @@ fn experimental_features_discovery_preserves_server_order_and_limits_writes() { "experimental_features_server_discovery", buffer_text(&buffer) ); - // Read-only entries retain their configured checkmark when Space is pressed. + // New server features are writable without a local Feature enum variant. view.state.selected_idx = Some(1); view.toggle_selected(); - assert!(view.features[1].enabled); + assert!(!view.features[1].enabled); view.state.selected_idx = Some(0); view.toggle_selected(); - view.state.selected_idx = Some(2); - view.toggle_selected(); - view.on_ctrl_c(); - let AppEvent::UpdateFeatureFlags { updates } = app_rx.try_recv().unwrap() else { + view.features[2].enabled = false; + view.handle_key_event(KeyEvent::from(KeyCode::Enter)); + assert!( + matches!(app_rx.try_recv().unwrap(), AppEvent::UpdateFeatureFlags { updates } + if updates == vec![(Feature::PreventIdleSleep, false)]) + ); + let AppEvent::SaveExperimentalFeatures { + updates, + response_tx, + .. + } = app_rx.try_recv().unwrap() + else { panic!("expected feature edits"); }; assert_eq!( updates, vec![ - (Feature::NetworkProxy, false), - (Feature::PreventIdleSleep, false) + ("network_proxy".to_string(), false), + ("future_feature".to_string(), false) ] ); + snapshot_view("experimental_features_saving", &view); + response_tx + .send(Err("Saved but readback failed".to_string())) + .unwrap(); + view.pre_draw_tick(Instant::now()); + snapshot_view("experimental_features_save_failed", &view); + + // Reverting uncertain saves to their original values must still write them. + view.features[0].enabled = true; + view.features[1].enabled = true; + view.handle_key_event(KeyEvent::from(KeyCode::Enter)); + let AppEvent::SaveExperimentalFeatures { + updates, + response_tx, + .. + } = app_rx.try_recv().unwrap() + else { + panic!("expected corrective save without repeating special controls"); + }; + assert_eq!( + updates, + vec![ + ("network_proxy".to_string(), true), + ("future_feature".to_string(), true) + ] + ); + response_tx + .send(Err("Persistent write rejection".to_string())) + .unwrap(); + view.pre_draw_tick(Instant::now()); + // Cancel saves new special edits without retrying the failed generic write. + view.features[2].enabled = true; + view.handle_key_event(KeyEvent::from(KeyCode::Esc)); + assert!(view.is_complete()); + assert!( + matches!(app_rx.try_recv().unwrap(), AppEvent::UpdateFeatureFlags { updates } + if updates == vec![(Feature::PreventIdleSleep, true)]) + ); + assert!(app_rx.try_recv().is_err()); } #[test] @@ -98,6 +146,7 @@ fn experimental_features_empty_error_and_cancel_remain_usable() { let (catalog_tx, catalog_rx) = oneshot::channel(); let mut view = ExperimentalFeaturesView::new( Vec::new(), + ThreadId::new(), Some(catalog_rx), AppEventSender::new(app_tx), crate::keymap::RuntimeKeymap::defaults().list, @@ -115,7 +164,6 @@ fn experimental_features_empty_error_and_cancel_remain_usable() { let mut buffer = Buffer::empty(area); view.render(area, &mut buffer); insta::assert_snapshot!(snapshot, buffer_text(&buffer)); - view.toggle_selected(); view.on_ctrl_c(); assert!(view.is_complete()); assert!(app_rx.try_recv().is_err()); @@ -124,6 +172,7 @@ fn experimental_features_empty_error_and_cancel_remain_usable() { let (catalog_tx, catalog_rx) = oneshot::channel(); let view = ExperimentalFeaturesView::new( Vec::new(), + ThreadId::new(), Some(catalog_rx), AppEventSender::new(app_tx), crate::keymap::RuntimeKeymap::defaults().list, @@ -146,3 +195,15 @@ fn buffer_text(buffer: &Buffer) -> String { .collect::>() .join("\n") } + +fn snapshot_view(name: &str, view: &ExperimentalFeaturesView) { + let area = Rect::new( + /*x*/ 0, + /*y*/ 0, + /*width*/ 80, + view.desired_height(/*width*/ 80), + ); + let mut buffer = Buffer::empty(area); + view.render(area, &mut buffer); + insta::assert_snapshot!(name, buffer_text(&buffer)); +} diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_changed_default.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_changed_default.snap index 9519153a8c..905d975203 100644 --- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_changed_default.snap +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_changed_default.snap @@ -7,6 +7,6 @@ expression: buffer_text(&buffer) Checked features are configured on. Some experimental features take effect only in new tasks or after restarting the Codex server. -› [x] Server network_proxy (read-only) Description supplied by the server. +› [x] Server network_proxy Description supplied by the server. Press space to select or enter to save diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_save_failed.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_save_failed.snap new file mode 100644 index 0000000000..f529b54d80 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_save_failed.snap @@ -0,0 +1,15 @@ +--- +source: tui/src/bottom_pane/experimental_features_view_tests.rs +expression: buffer_text(&buffer) +--- + + Experimental features + Checked features are configured on. Some experimental features take effect + only in new tasks or after restarting the Codex server. + Saved but readback failed + +› [ ] Server network_proxy Description supplied by the server. + [ ] Server future_feature Description supplied by the server. + [ ] Server prevent_idle_sleep Description supplied by the server. + + Selections retained. Save to retry, or cancel to close. diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_saving.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_saving.snap new file mode 100644 index 0000000000..3b24a44fa5 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_saving.snap @@ -0,0 +1,15 @@ +--- +source: tui/src/bottom_pane/experimental_features_view_tests.rs +expression: buffer_text(&buffer) +--- + + Experimental features + Checked features are configured on. Some experimental features take effect + only in new tasks or after restarting the Codex server. + Saving experimental features… + +› [ ] Server network_proxy Description supplied by the server. + [ ] Server future_feature Description supplied by the server. + [ ] Server prevent_idle_sleep Description supplied by the server. + + Saving… Closing this popup will not cancel the write. diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_server_discovery.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_server_discovery.snap index 0c200d1d5e..0b35d3e6de 100644 --- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_server_discovery.snap +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__experimental_features_view__tests__experimental_features_server_discovery.snap @@ -7,8 +7,8 @@ expression: buffer_text(&buffer) Checked features are configured on. Some experimental features take effect only in new tasks or after restarting the Codex server. -› [x] Server network_proxy Description supplied by the server. - [x] Server future_feature (read-only) Description supplied by the server. - [x] Server prevent_idle_sleep Description supplied by the server. +› [x] Server network_proxy Description supplied by the server. + [x] Server future_feature Description supplied by the server. + [x] Server prevent_idle_sleep Description supplied by the server. Press space to select or enter to save diff --git a/codex-rs/tui/src/chatwidget/settings_popups.rs b/codex-rs/tui/src/chatwidget/settings_popups.rs index 293e4bac9a..1c8cefdd16 100644 --- a/codex-rs/tui/src/chatwidget/settings_popups.rs +++ b/codex-rs/tui/src/chatwidget/settings_popups.rs @@ -101,6 +101,7 @@ impl ChatWidget { }); let view = ExperimentalFeaturesView::new( Vec::new(), + thread_id, Some(response_rx), self.app_event_tx.clone(), self.bottom_pane.list_keymap(), diff --git a/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs b/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs index 36f6db5f54..10b4a43d9a 100644 --- a/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs +++ b/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs @@ -3001,13 +3001,15 @@ async fn experimental_features_popup_snapshot() { let worktrees = Feature::Worktrees.stage(); let features = vec![ ExperimentalFeatureItem { - feature: Some(Feature::JsRepl), + key: Feature::JsRepl.key().to_string(), + writable: true, name: "JavaScript REPL".to_string(), description: "Enable a persistent Node-backed JavaScript REPL for interactive website debugging and other inline JavaScript execution capabilities.".to_string(), enabled: false, }, ExperimentalFeatureItem { - feature: Some(Feature::ShellTool), + key: Feature::ShellTool.key().to_string(), + writable: true, name: "Shell tool".to_string(), description: "Allow the model to run shell commands.".to_string(), enabled: true, @@ -3021,6 +3023,7 @@ async fn experimental_features_popup_snapshot() { ]; let view = ExperimentalFeaturesView::new( features, + ThreadId::new(), /*catalog_rx*/ None, chat.app_event_tx.clone(), crate::keymap::RuntimeKeymap::defaults().list, @@ -3038,11 +3041,13 @@ async fn experimental_features_popup_snapshot() { .expect("valid experimental-feature chord"); let view = ExperimentalFeaturesView::new( vec![ExperimentalFeatureItem { - feature: Some(Feature::ShellTool), + key: Feature::ShellTool.key().to_string(), + writable: true, name: "Shell tool".to_string(), description: "Allow the model to run shell commands.".to_string(), enabled: true, }], + ThreadId::new(), /*catalog_rx*/ None, chat.app_event_tx.clone(), keymap.list, @@ -3056,17 +3061,21 @@ async fn experimental_features_popup_snapshot() { async fn experimental_features_toggle_saves_on_exit() { let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let mut keymap = crate::keymap::RuntimeKeymap::defaults().list; + keymap.cancel = vec![crate::key_hint::plain(KeyCode::F(2))]; let expected_feature = Feature::JsRepl; let view = ExperimentalFeaturesView::new( vec![ExperimentalFeatureItem { - feature: Some(expected_feature), + key: expected_feature.key().to_string(), + writable: true, name: "JavaScript REPL".to_string(), description: "Enable a persistent Node-backed JavaScript REPL for interactive website debugging and other inline JavaScript execution capabilities.".to_string(), enabled: false, }], + ThreadId::new(), /*catalog_rx*/ None, chat.app_event_tx.clone(), - crate::keymap::RuntimeKeymap::defaults().list, + keymap, ); chat.bottom_pane.show_view(Box::new(view)); @@ -3077,12 +3086,17 @@ async fn experimental_features_toggle_saves_on_exit() { "expected no updates until saving the popup" ); - chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + chat.handle_key_event(KeyEvent::new(KeyCode::F(2), KeyModifiers::NONE)); + assert!( + !chat.has_active_view(), + "remapped cancel must save and close" + ); let mut updates = None; while let Ok(event) = rx.try_recv() { - if let AppEvent::UpdateFeatureFlags { + if let AppEvent::SaveExperimentalFeatures { updates: event_updates, + .. } = event { updates = Some(event_updates); @@ -3090,8 +3104,8 @@ async fn experimental_features_toggle_saves_on_exit() { } } - let updates = updates.expect("expected UpdateFeatureFlags event"); - assert_eq!(updates, vec![(expected_feature, true)]); + let updates = updates.expect("expected SaveExperimentalFeatures event"); + assert_eq!(updates, vec![(expected_feature.key().to_string(), true)]); } #[tokio::test] diff --git a/codex-rs/tui/src/experimental_features.rs b/codex-rs/tui/src/experimental_features.rs index 28a92b58c0..dee31a7713 100644 --- a/codex-rs/tui/src/experimental_features.rs +++ b/codex-rs/tui/src/experimental_features.rs @@ -1,13 +1,16 @@ -//! Bounded, popup-scoped experimental-feature discovery through the existing RPC. -//! Dropping a popup stops pagination. One reserved request ID bounds abandoned -//! requests until the server replies or the connection closes. +//! Bounded experimental-feature discovery and persistence through existing RPCs. +//! Dropping a popup stops discovery, but submitted writes finish independently. +//! Readback describes configured enablement; reserved IDs bound unanswered requests. use codex_app_server_client::AppServerRequestHandle; use codex_app_server_protocol::ClientRequest; +use codex_app_server_protocol::ConfigBatchWriteParams; +use codex_app_server_protocol::ConfigWriteResponse; use codex_app_server_protocol::ExperimentalFeature; use codex_app_server_protocol::ExperimentalFeatureListParams; use codex_app_server_protocol::ExperimentalFeatureListResponse; use codex_app_server_protocol::RequestId; +use codex_app_server_protocol::WriteStatus; use codex_protocol::ThreadId; use std::collections::HashSet; use std::time::Duration; @@ -16,6 +19,7 @@ use tokio::sync::oneshot; pub(crate) fn fetch( request_handle: AppServerRequestHandle, thread_id: ThreadId, + request_id: &'static str, mut response_tx: oneshot::Sender, String>>, ) { tokio::spawn(async move { @@ -30,7 +34,7 @@ pub(crate) fn fetch( ClientRequest::ExperimentalFeatureList { // The client rejects duplicate pending IDs, bounding unanswered // requests across popup cancellation and timeout/retry cycles. - request_id: RequestId::String("tui-experimental-features".to_string()), + request_id: RequestId::String(request_id.to_string()), params: ExperimentalFeatureListParams { cursor, limit: Some(100), @@ -69,6 +73,87 @@ pub(crate) fn fetch( }); } +/// Configured readback, deliberately separate from running-task feature state. +#[derive(Debug)] +pub(crate) struct FeatureWriteResult { + pub features: Vec, + pub warning: Option, +} + +pub(crate) async fn write( + request_handle: AppServerRequestHandle, + thread_id: ThreadId, + updates: Vec<(String, bool)>, +) -> Result { + let (tx, rx) = oneshot::channel(); + fetch( + request_handle.clone(), + thread_id, + "tui-experimental-save-readback", + tx, + ); + let features = rx + .await + .map_err(|_| "Feature discovery was interrupted")??; + let edits = updates + .iter() + .map(|(name, enabled)| { + let feature = features + .iter() + .find(|feature| feature.name == *name) + .ok_or_else(|| { + format!("The server did not advertise experimental feature `{name}`") + })?; + // Quote the server's key as a single TOML path segment. + let key = format!("features.{}", serde_json::json!(name)); + Ok(crate::config_update::replace_config_value( + key, + if *enabled || feature.default_enabled { + serde_json::json!(enabled) + } else { + serde_json::Value::Null + }, + )) + }) + .collect::, String>>()?; + let response = tokio::time::timeout(Duration::from_secs(/*secs*/ 15), request_handle + .request_typed::(ClientRequest::ConfigBatchWrite { + // A timed-out write may still finish. Bound unanswered retries too. + request_id: RequestId::String("tui-experimental-feature-write".to_string()), + params: ConfigBatchWriteParams { + edits, + file_path: None, + expected_version: None, + reload_user_config: true, + }, + })).await + .map_err(|_| "Saving experimental features timed out; the write may still finish. Reopen /experimental to check.")? + .map_err(|_| "Failed to save experimental features. Reopen /experimental to check configured values before retrying.")?; + let (tx, rx) = oneshot::channel(); + fetch( + request_handle, + thread_id, + "tui-experimental-save-readback", + tx, + ); + let features = rx + .await + .map_err(|_| "Features were saved, but readback was interrupted")? + .map_err(|error| { + format!("Features were saved, but configured values could not be refreshed: {error}") + })?; + let overridden = response.status == WriteStatus::OkOverridden + || updates.iter().any(|(name, enabled)| { + !features + .iter() + .any(|feature| feature.name == *name && feature.enabled == *enabled) + }); + Ok(FeatureWriteResult { + features, + warning: overridden.then(|| "Changes were saved, but the configured values differ from your selections. A higher-priority setting may override them.".to_string()), + }) +} + #[cfg(test)] #[path = "experimental_features_tests.rs"] mod tests; diff --git a/codex-rs/tui/src/experimental_features_tests.rs b/codex-rs/tui/src/experimental_features_tests.rs index 3eb1e5f4cd..a5f6797f72 100644 --- a/codex-rs/tui/src/experimental_features_tests.rs +++ b/codex-rs/tui/src/experimental_features_tests.rs @@ -82,6 +82,7 @@ async fn experimental_features_rpc_paginates_thread_config_and_bounds_bad_server fetch( AppServerRequestHandle::Remote(client.request_handle()), thread_id, + "tui-experimental-features", tx, ); let result = tokio::time::timeout(Duration::from_secs(/*secs*/ 10), rx) @@ -126,6 +127,7 @@ async fn experimental_features_rpc_paginates_thread_config_and_bounds_bad_server fetch( AppServerRequestHandle::Remote(client.request_handle()), thread_id, + "tui-experimental-features", tx, ); assert_eq!( @@ -145,3 +147,106 @@ async fn experimental_features_rpc_paginates_thread_config_and_bounds_bad_server ); } } + +#[tokio::test] +async fn experimental_feature_writes_use_server_defaults_and_refresh_configured_values() { + for scenario in [ + "overridden", + "write_error", + "write_timeout", + "readback_error", + ] { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + let thread_id = ThreadId::new(); + let selected_file = std::env::temp_dir().join("selected.config.toml"); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = tokio_tungstenite::accept_async(stream).await.unwrap(); + let mut wrote = false; + while let Some(Ok(Message::Text(text))) = socket.next().await { + let JSONRPCMessage::Request(request) = serde_json::from_str(&text).unwrap() else { + continue; + }; + let fail = (request.method == "config/batchWrite" && scenario == "write_error") + || (request.method == "experimentalFeature/list" + && wrote + && scenario == "readback_error"); + if fail { + socket.send(Message::Text(json!({"id": request.id, "error": {"code": -32600, "message": "rejected", "data": "private diagnostic"}}).to_string().into())).await.unwrap(); + continue; + } + let result = match request.method.as_str() { + "initialize" => json!({"userAgent": "experimental-test"}), + "experimentalFeature/list" => { + json!({"data": [ + {"name": "default_off", "stage": "beta", "displayName": null, "description": null, "announcement": null, "enabled": !wrote || scenario == "overridden", "defaultEnabled": false}, + {"name": "default_on", "stage": "beta", "displayName": null, "description": null, "announcement": null, "enabled": !wrote, "defaultEnabled": true}, + {"name": "new_server_feature", "stage": "beta", "displayName": null, "description": null, "announcement": null, "enabled": wrote, "defaultEnabled": false} + ], "nextCursor": null}) + } + "config/batchWrite" => { + assert_eq!( + request.params, + Some(json!({ + "edits": [ + {"keyPath": "features.\"default_off\"", "value": null, "mergeStrategy": "replace"}, + {"keyPath": "features.\"default_on\"", "value": false, "mergeStrategy": "replace"}, + {"keyPath": "features.\"new_server_feature\"", "value": true, "mergeStrategy": "replace"} + ], "filePath": null, "expectedVersion": null, "reloadUserConfig": true + })) + ); + wrote = true; + if scenario == "write_timeout" { + tokio::time::pause(); + continue; + } + json!({"status": "ok", "version": "v2", "filePath": selected_file, "overriddenMetadata": null}) + } + other => panic!("unexpected RPC: {other}"), + }; + socket + .send(Message::Text( + json!({"id": request.id, "result": result}) + .to_string() + .into(), + )) + .await + .unwrap(); + } + }); + let client = crate::connect_remote_app_server(RemoteAppServerEndpoint::WebSocket { + websocket_url: url, + auth_token: None, + }) + .await + .unwrap(); + let handle = client.request_handle(); + let result = write( + handle, + thread_id, + vec![ + ("default_off".to_string(), false), + ("default_on".to_string(), false), + ("new_server_feature".to_string(), true), + ], + ) + .await; + if scenario == "write_timeout" { + tokio::time::resume(); + } + match scenario { + "overridden" => assert!(result.unwrap().warning.is_some()), + scenario => { + let error = result.unwrap_err(); + assert!(error.contains(match scenario { + "readback_error" => "saved, but configured values could not be refreshed", + "write_timeout" => "write may still finish", + _ => "Failed to save experimental features.", + })); + } + } + let _ = client.shutdown().await; + server.await.unwrap(); + } +}