Skip to content

armgit / codex

Public Imported from GitHub
0

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.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<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.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<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.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<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.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<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.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<_>>(),
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.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<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.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();
+ }
+}