Lightweight coding agent that runs in your terminal
Rust
Persist server-advertised experimental features from the TUI (#42674)
Eric Traut048a936a23b8
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 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<tokio::sync::Mutex<()>>,model_catalog: Arc<ModelCatalog>,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.rsindex 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.rsnew file mode 100644index 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<Vec<codex_app_server_protocol::ExperimentalFeature>, 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<Result<FeatureWriteResult, String>>,+ ) {+ 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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<Result<FeatureWriteResult, String>>,+ },+/// 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.rsindex 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<Feature>,+ pub key: String,pub name: String,pub description: String,pub enabled: bool,+ pub writable: bool,}pub(crate) struct ExperimentalFeaturesView {features: Vec<ExperimentalFeatureItem>,initial_enabled: Vec<bool>,+ unconfirmed: Vec<String>,catalog_rx: Option<oneshot::Receiver<Result<Vec<ExperimentalFeature>, String>>>,- discovery_status: &'static str,+ discovery_status: String,+ thread_id: ThreadId,+ write_rx: Option<oneshot::Receiver<Result<FeatureWriteResult, String>>>,state: ScrollState,complete: bool,app_event_tx: AppEventSender,@@ -64,6 +69,7 @@ pub(crate) struct ExperimentalFeaturesView {impl ExperimentalFeaturesView {pub(crate) fn new(features: Vec<ExperimentalFeatureItem>,+ thread_id: ThreadId,catalog_rx: Option<oneshot::Receiver<Result<Vec<ExperimentalFeature>, 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<Duration> {- 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.rsindex 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<_>>(),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::<Vec<_>>().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.snapindex 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 effectonly 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 savediff --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.snapnew file mode 100644index 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.snapnew file mode 100644index 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.snapindex 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 orafter 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 savediff --git a/codex-rs/tui/src/chatwidget/settings_popups.rs b/codex-rs/tui/src/chatwidget/settings_popups.rsindex 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.rsindex 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.rsindex 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<Result<Vec<ExperimentalFeature>, 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<ExperimentalFeature>,+ pub warning: Option<String>,+}++pub(crate) async fn write(+ request_handle: AppServerRequestHandle,+ thread_id: ThreadId,+ updates: Vec<(String, bool)>,+) -> Result<FeatureWriteResult, String> {+ 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::<Result<Vec<_>, String>>()?;+ let response = tokio::time::timeout(Duration::from_secs(/*secs*/ 15), request_handle+ .request_typed::<ConfigWriteResponse>(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.rsindex 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_serverfetch(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_serverfetch(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();+ }+}