Persist server-advertised experimental features from the TUI (#42674)

## What changed

- Save writable `/experimental` selections through `config/batchWrite`, including features that are not known to the local client.
- Refresh configured values after writes and surface timeouts, failures, and higher-priority overrides without changing the active task's settings.
- Serialize saves and discovery, let accepted writes finish after the popup closes, and retain uncertain selections for explicit retry.

## Testing

- Cover new server feature keys, server defaults, overrides, write and readback failures, timeouts, selected config profiles, and popup retry behavior.

GitOrigin-RevId: acee4e10cbb8c2fce9211e8fadd3cd67fa0eb1a5
This commit is contained in:
Eric Traut authored and copyberry committed 2026-09-04 04:55:40 +00:00
1 parent b995d06050
commit 048a936a23
18 files changed
+647 -81

No files matched your search

+2
View File
@@ -219,6 +219,7 @@ mod config_persistence;
mod connector_mentions; mod connector_mentions;
mod event_dispatch; mod event_dispatch;
mod exit_summary; mod exit_summary;
mod experimental_features;
mod file_change_approvals; mod file_change_approvals;
mod history_pagination; mod history_pagination;
mod history_ui; mod history_ui;
@@ -537,6 +538,7 @@ struct InitialHistoryReplayBuffer {
} }
pub(crate) struct App { pub(crate) struct App {
feature_write_lock: Arc<tokio::sync::Mutex<()>>,
model_catalog: Arc<ModelCatalog>, model_catalog: Arc<ModelCatalog>,
pub(crate) session_telemetry: SessionTelemetry, pub(crate) session_telemetry: SessionTelemetry,
pub(crate) app_event_tx: AppEventSender, pub(crate) app_event_tx: AppEventSender,
+4 -5
View File
@@ -2402,11 +2402,10 @@ impl App {
} }
} }
AppEvent::FetchExperimentalFeatures { thread_id, response_tx } => { AppEvent::FetchExperimentalFeatures { thread_id, response_tx } => {
crate::experimental_features::fetch( self.fetch_experimental_features(app_server, thread_id, response_tx);
app_server.request_handle(), }
thread_id, AppEvent::SaveExperimentalFeatures { thread_id, updates, response_tx } => {
response_tx, self.save_experimental_features(app_server, thread_id, updates, response_tx);
);
} }
AppEvent::UpdateFeatureFlags { updates } => { AppEvent::UpdateFeatureFlags { updates } => {
self.update_feature_flags(app_server, updates).await; self.update_feature_flags(app_server, updates).await;
@@ -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;
@@ -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(())
}
+1
View File
@@ -505,6 +505,7 @@ See the Codex keymap documentation for supported actions and examples."
let upgrade_version = crate::updates::get_upgrade_version(&config); let upgrade_version = crate::updates::get_upgrade_version(&config);
let mut app = Self { let mut app = Self {
feature_write_lock: Arc::default(),
model_catalog, model_catalog,
session_telemetry: session_telemetry.clone(), session_telemetry: session_telemetry.clone(),
app_event_tx, app_event_tx,
+1
View File
@@ -17,6 +17,7 @@ pub(super) async fn make_test_app() -> App {
let session_telemetry = test_session_telemetry(&config, model.as_str()); let session_telemetry = test_session_telemetry(&config, model.as_str());
App { App {
feature_write_lock: Arc::default(),
model_catalog: chat_widget.model_catalog(), model_catalog: chat_widget.model_catalog(),
session_telemetry, session_telemetry,
app_event_tx, app_event_tx,
+2
View File
@@ -5466,6 +5466,7 @@ async fn make_test_app() -> App {
let session_telemetry = test_session_telemetry(&config, model.as_str()); let session_telemetry = test_session_telemetry(&config, model.as_str());
App { App {
feature_write_lock: Arc::default(),
model_catalog: chat_widget.model_catalog(), model_catalog: chat_widget.model_catalog(),
session_telemetry, session_telemetry,
app_event_tx, app_event_tx,
@@ -5550,6 +5551,7 @@ pub(super) async fn make_test_app_with_channels() -> (
( (
App { App {
feature_write_lock: Arc::default(),
model_catalog: chat_widget.model_catalog(), model_catalog: chat_widget.model_catalog(),
session_telemetry, session_telemetry,
app_event_tx, app_event_tx,
+8
View File
@@ -54,6 +54,7 @@ use crate::bottom_pane::TerminalTitleItem;
use crate::chatwidget::ConnectorScopeGeneration; use crate::chatwidget::ConnectorScopeGeneration;
use crate::chatwidget::ThreadUsageOutcome; use crate::chatwidget::ThreadUsageOutcome;
use crate::chatwidget::UserMessage; use crate::chatwidget::UserMessage;
use crate::experimental_features::FeatureWriteResult;
use crate::goal_files::GoalDraft; use crate::goal_files::GoalDraft;
use codex_app_server_protocol::AskForApproval; use codex_app_server_protocol::AskForApproval;
use codex_config::types::ApprovalsReviewer; use codex_config::types::ApprovalsReviewer;
@@ -1171,6 +1172,13 @@ pub(crate) enum AppEvent {
updates: Vec<(Feature, bool)>, 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. /// Update memory settings and persist them to config.toml.
UpdateMemorySettings { UpdateMemorySettings {
use_memories: bool, use_memories: bool,
@@ -1,9 +1,12 @@
//! Experimental controls with popup-owned discovery and configured enablement. //! 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::ExperimentalFeature;
use codex_app_server_protocol::ExperimentalFeatureStage; use codex_app_server_protocol::ExperimentalFeatureStage;
use codex_features::FEATURES; use codex_features::FEATURES;
use codex_features::Feature;
use codex_protocol::ThreadId;
use std::time::Duration; use std::time::Duration;
use std::time::Instant; use std::time::Instant;
use tokio::sync::oneshot; use tokio::sync::oneshot;
@@ -32,8 +35,6 @@ use crate::render::renderable::ColumnRenderable;
use crate::render::renderable::Renderable; use crate::render::renderable::Renderable;
use crate::style::user_message_style; use crate::style::user_message_style;
use codex_features::Feature;
use super::CancellationEvent; use super::CancellationEvent;
use super::bottom_pane_view::BottomPaneView; use super::bottom_pane_view::BottomPaneView;
use super::popup_consts::MAX_POPUP_ROWS; 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; use super::selection_popup_common::render_rows;
pub(crate) struct ExperimentalFeatureItem { pub(crate) struct ExperimentalFeatureItem {
pub feature: Option<Feature>, pub key: String,
pub name: String, pub name: String,
pub description: String, pub description: String,
pub enabled: bool, pub enabled: bool,
pub writable: bool,
} }
pub(crate) struct ExperimentalFeaturesView { pub(crate) struct ExperimentalFeaturesView {
features: Vec<ExperimentalFeatureItem>, features: Vec<ExperimentalFeatureItem>,
initial_enabled: Vec<bool>, initial_enabled: Vec<bool>,
unconfirmed: Vec<String>,
catalog_rx: Option<oneshot::Receiver<Result<Vec<ExperimentalFeature>, 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, state: ScrollState,
complete: bool, complete: bool,
app_event_tx: AppEventSender, app_event_tx: AppEventSender,
@@ -64,6 +69,7 @@ pub(crate) struct ExperimentalFeaturesView {
impl ExperimentalFeaturesView { impl ExperimentalFeaturesView {
pub(crate) fn new( pub(crate) fn new(
features: Vec<ExperimentalFeatureItem>, features: Vec<ExperimentalFeatureItem>,
thread_id: ThreadId,
catalog_rx: Option<oneshot::Receiver<Result<Vec<ExperimentalFeature>, String>>>, catalog_rx: Option<oneshot::Receiver<Result<Vec<ExperimentalFeature>, String>>>,
app_event_tx: AppEventSender, app_event_tx: AppEventSender,
keymap: ListKeymap, keymap: ListKeymap,
@@ -73,8 +79,12 @@ impl ExperimentalFeaturesView {
"Loading server experiments…" "Loading server experiments…"
} else { } else {
"" ""
}, }
.to_string(),
thread_id,
write_rx: None,
catalog_rx, catalog_rx,
unconfirmed: Vec::new(),
initial_enabled: features.iter().map(|item| item.enabled).collect(), initial_enabled: features.iter().map(|item| item.enabled).collect(),
features, features,
state: ScrollState::new(), state: ScrollState::new(),
@@ -92,7 +102,7 @@ impl ExperimentalFeaturesView {
header.push(Line::from("Experimental features".bold())); header.push(Line::from("Experimental features".bold()));
for text in [ for text in [
"Checked features are configured on. Some experimental features take effect only in new tasks or after restarting the Codex server.", "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()) { ].into_iter().filter(|text| !text.is_empty()) {
for line in textwrap::wrap(text, usize::from(width.max(1))) { for line in textwrap::wrap(text, usize::from(width.max(1))) {
header.push(Line::from(line.into_owned().dim())); header.push(Line::from(line.into_owned().dim()));
@@ -123,16 +133,12 @@ impl ExperimentalFeaturesView {
' ' ' '
}; };
let marker = if item.enabled { 'x' } else { ' ' }; let marker = if item.enabled { 'x' } else { ' ' };
let read_only = if item.feature.is_none() { let read_only = if item.writable { "" } else { " (read-only)" };
" (read-only)"
} else {
""
};
let name = format!("{prefix} [{marker}] {}{read_only}", item.name); let name = format!("{prefix} [{marker}] {}{read_only}", item.name);
rows.push(GenericDisplayRow { rows.push(GenericDisplayRow {
name, name,
description: Some(item.description.clone()), description: Some(item.description.clone()),
is_disabled: item.feature.is_none(), is_disabled: !item.writable || self.write_rx.is_some(),
..Default::default() ..Default::default()
}); });
} }
@@ -187,13 +193,67 @@ impl ExperimentalFeaturesView {
return; return;
}; };
if let Some(item) = self.features.get_mut(selected_idx) if self.write_rx.is_none()
&& item.feature.is_some() && let Some(item) = self.features.get_mut(selected_idx)
&& item.writable
{ {
item.enabled = !item.enabled; 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 { fn rows_width(total_width: u16) -> u16 {
total_width.saturating_sub(2) total_width.saturating_sub(2)
} }
@@ -201,6 +261,42 @@ impl ExperimentalFeaturesView {
impl BottomPaneView for ExperimentalFeaturesView { impl BottomPaneView for ExperimentalFeaturesView {
fn pre_draw_tick(&mut self, _now: Instant) -> bool { 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 { let Some(receiver) = self.catalog_rx.as_mut() else {
return false; return false;
}; };
@@ -219,19 +315,18 @@ impl BottomPaneView for ExperimentalFeaturesView {
if feature.stage != ExperimentalFeatureStage::Beta { if feature.stage != ExperimentalFeatureStage::Beta {
continue; continue;
} }
// The existing writer uses local defaults and Feature IDs. A new self.initial_enabled.push(feature.enabled);
// server control or a changed default must wait for config-write migration. self.features.push(ExperimentalFeatureItem {
let writable = FEATURES // Preserve the existing metadata gate for unmigrated controls.
.iter() writable: !matches!(
.find(|spec| { feature.name.as_str(),
"prevent_idle_sleep" | "guardian_approval"
) || FEATURES.iter().any(|spec| {
spec.key == feature.name spec.key == feature.name
&& spec.stage.experimental_menu_name().is_some() && spec.stage.experimental_menu_name().is_some()
&& spec.default_enabled == feature.default_enabled && spec.default_enabled == feature.default_enabled
}) }),
.map(|spec| spec.id); key: feature.name.clone(),
self.initial_enabled.push(feature.enabled);
self.features.push(ExperimentalFeatureItem {
feature: writable,
name: feature.display_name.unwrap_or(feature.name), name: feature.display_name.unwrap_or(feature.name),
description: feature.description.unwrap_or_default(), description: feature.description.unwrap_or_default(),
enabled: feature.enabled, enabled: feature.enabled,
@@ -242,21 +337,21 @@ impl BottomPaneView for ExperimentalFeaturesView {
"No server experiments available." "No server experiments available."
} else { } else {
"" ""
}; }
.to_string();
self.initialize_selection(); self.initialize_selection();
} }
Err(error) => { Err(error) => {
tracing::warn!(%error, "experimental feature discovery failed"); 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 true
} }
fn next_frame_delay(&self) -> Option<Duration> { fn next_frame_delay(&self) -> Option<Duration> {
self.catalog_rx (self.catalog_rx.is_some() || self.write_rx.is_some())
.as_ref() .then(|| Duration::from_millis(/*millis*/ 100))
.map(|_| Duration::from_millis(/*millis*/ 100))
} }
fn keymap_contexts(&self) -> crate::keymap::KeymapContextSet { fn keymap_contexts(&self) -> crate::keymap::KeymapContextSet {
@@ -276,9 +371,10 @@ impl BottomPaneView for ExperimentalFeaturesView {
modifiers: KeyModifiers::NONE, modifiers: KeyModifiers::NONE,
.. ..
} => self.toggle_selected(), } => self.toggle_selected(),
_ if self.keymap.accept.is_pressed(key_event) _ if self.keymap.accept.is_pressed(key_event) => {
|| self.keymap.cancel.is_pressed(key_event) => self.save_changes();
{ }
_ if self.keymap.cancel.is_pressed(key_event) => {
self.on_ctrl_c(); self.on_ctrl_c();
} }
_ => {} _ => {}
@@ -290,18 +386,13 @@ impl BottomPaneView for ExperimentalFeaturesView {
} }
fn on_ctrl_c(&mut self) -> CancellationEvent { fn on_ctrl_c(&mut self) -> CancellationEvent {
let updates: Vec<_> = self // After an attempted save, cancellation must remain possible even if the
.features // server rejects retries immediately. Explicit accept retries dirty keys.
.iter() if !self.unconfirmed.is_empty() {
.zip(&self.initial_enabled) self.save_special_controls();
.filter(|(item, initial)| item.enabled != **initial) } else {
.filter_map(|(item, _)| item.feature.map(|feature| (feature, item.enabled))) self.save_changes();
.collect();
if !updates.is_empty() {
self.app_event_tx
.send(AppEvent::UpdateFeatureFlags { updates });
} }
self.complete = true; self.complete = true;
CancellationEvent::Handled CancellationEvent::Handled
} }
@@ -362,7 +453,14 @@ impl Renderable for ExperimentalFeaturesView {
width: footer_area.width.saturating_sub(2), width: footer_area.width.saturating_sub(2),
height: footer_area.height, 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 { fn desired_height(&self, width: u16) -> u16 {
@@ -14,11 +14,12 @@ fn server_feature(name: &str) -> ExperimentalFeature {
} }
#[test] #[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 (app_tx, mut app_rx) = tokio::sync::mpsc::unbounded_channel();
let (catalog_tx, catalog_rx) = oneshot::channel(); let (catalog_tx, catalog_rx) = oneshot::channel();
let mut view = ExperimentalFeaturesView::new( let mut view = ExperimentalFeaturesView::new(
Vec::new(), Vec::new(),
ThreadId::new(),
Some(catalog_rx), Some(catalog_rx),
AppEventSender::new(app_tx), AppEventSender::new(app_tx),
crate::keymap::RuntimeKeymap::defaults().list, crate::keymap::RuntimeKeymap::defaults().list,
@@ -38,12 +39,12 @@ fn experimental_features_discovery_preserves_server_order_and_limits_writes() {
assert_eq!( assert_eq!(
view.features view.features
.iter() .iter()
.map(|item| (item.feature, item.enabled)) .map(|item| (item.key.as_str(), item.enabled))
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
vec![ vec![
(Some(Feature::NetworkProxy), true), ("network_proxy", true),
(None, true), ("future_feature", true),
(Some(Feature::PreventIdleSleep), true), ("prevent_idle_sleep", true)
] ]
); );
let area = Rect::new( let area = Rect::new(
@@ -58,25 +59,72 @@ fn experimental_features_discovery_preserves_server_order_and_limits_writes() {
"experimental_features_server_discovery", "experimental_features_server_discovery",
buffer_text(&buffer) 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.state.selected_idx = Some(1);
view.toggle_selected(); view.toggle_selected();
assert!(view.features[1].enabled); assert!(!view.features[1].enabled);
view.state.selected_idx = Some(0); view.state.selected_idx = Some(0);
view.toggle_selected(); view.toggle_selected();
view.state.selected_idx = Some(2); view.features[2].enabled = false;
view.toggle_selected(); view.handle_key_event(KeyEvent::from(KeyCode::Enter));
view.on_ctrl_c(); assert!(
let AppEvent::UpdateFeatureFlags { updates } = app_rx.try_recv().unwrap() else { 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"); panic!("expected feature edits");
}; };
assert_eq!( assert_eq!(
updates, updates,
vec![ vec![
(Feature::NetworkProxy, false), ("network_proxy".to_string(), false),
(Feature::PreventIdleSleep, 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] #[test]
@@ -98,6 +146,7 @@ fn experimental_features_empty_error_and_cancel_remain_usable() {
let (catalog_tx, catalog_rx) = oneshot::channel(); let (catalog_tx, catalog_rx) = oneshot::channel();
let mut view = ExperimentalFeaturesView::new( let mut view = ExperimentalFeaturesView::new(
Vec::new(), Vec::new(),
ThreadId::new(),
Some(catalog_rx), Some(catalog_rx),
AppEventSender::new(app_tx), AppEventSender::new(app_tx),
crate::keymap::RuntimeKeymap::defaults().list, crate::keymap::RuntimeKeymap::defaults().list,
@@ -115,7 +164,6 @@ fn experimental_features_empty_error_and_cancel_remain_usable() {
let mut buffer = Buffer::empty(area); let mut buffer = Buffer::empty(area);
view.render(area, &mut buffer); view.render(area, &mut buffer);
insta::assert_snapshot!(snapshot, buffer_text(&buffer)); insta::assert_snapshot!(snapshot, buffer_text(&buffer));
view.toggle_selected();
view.on_ctrl_c(); view.on_ctrl_c();
assert!(view.is_complete()); assert!(view.is_complete());
assert!(app_rx.try_recv().is_err()); 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 (catalog_tx, catalog_rx) = oneshot::channel();
let view = ExperimentalFeaturesView::new( let view = ExperimentalFeaturesView::new(
Vec::new(), Vec::new(),
ThreadId::new(),
Some(catalog_rx), Some(catalog_rx),
AppEventSender::new(app_tx), AppEventSender::new(app_tx),
crate::keymap::RuntimeKeymap::defaults().list, crate::keymap::RuntimeKeymap::defaults().list,
@@ -146,3 +195,15 @@ fn buffer_text(buffer: &Buffer) -> String {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .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));
}
@@ -7,6 +7,6 @@ expression: buffer_text(&buffer)
Checked features are configured on. Some experimental features take effect Checked features are configured on. Some experimental features take effect
only in new tasks or after restarting the Codex server. 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 Press space to select or enter to save
@@ -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.
@@ -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.
@@ -7,8 +7,8 @@ expression: buffer_text(&buffer)
Checked features are configured on. Some experimental features take effect only in new tasks or Checked features are configured on. Some experimental features take effect only in new tasks or
after restarting the Codex server. after restarting the Codex server.
› [x] Server network_proxy Description supplied by the server. › [x] Server network_proxy Description supplied by the server.
[x] Server future_feature (read-only) Description supplied by the server. [x] Server future_feature Description supplied by the server.
[x] Server prevent_idle_sleep Description supplied by the server. [x] Server prevent_idle_sleep Description supplied by the server.
Press space to select or enter to save Press space to select or enter to save
@@ -101,6 +101,7 @@ impl ChatWidget {
}); });
let view = ExperimentalFeaturesView::new( let view = ExperimentalFeaturesView::new(
Vec::new(), Vec::new(),
thread_id,
Some(response_rx), Some(response_rx),
self.app_event_tx.clone(), self.app_event_tx.clone(),
self.bottom_pane.list_keymap(), self.bottom_pane.list_keymap(),
@@ -3001,13 +3001,15 @@ async fn experimental_features_popup_snapshot() {
let worktrees = Feature::Worktrees.stage(); let worktrees = Feature::Worktrees.stage();
let features = vec![ let features = vec![
ExperimentalFeatureItem { ExperimentalFeatureItem {
feature: Some(Feature::JsRepl), key: Feature::JsRepl.key().to_string(),
writable: true,
name: "JavaScript REPL".to_string(), 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(), description: "Enable a persistent Node-backed JavaScript REPL for interactive website debugging and other inline JavaScript execution capabilities.".to_string(),
enabled: false, enabled: false,
}, },
ExperimentalFeatureItem { ExperimentalFeatureItem {
feature: Some(Feature::ShellTool), key: Feature::ShellTool.key().to_string(),
writable: true,
name: "Shell tool".to_string(), name: "Shell tool".to_string(),
description: "Allow the model to run shell commands.".to_string(), description: "Allow the model to run shell commands.".to_string(),
enabled: true, enabled: true,
@@ -3021,6 +3023,7 @@ async fn experimental_features_popup_snapshot() {
]; ];
let view = ExperimentalFeaturesView::new( let view = ExperimentalFeaturesView::new(
features, features,
ThreadId::new(),
/*catalog_rx*/ None, /*catalog_rx*/ None,
chat.app_event_tx.clone(), chat.app_event_tx.clone(),
crate::keymap::RuntimeKeymap::defaults().list, crate::keymap::RuntimeKeymap::defaults().list,
@@ -3038,11 +3041,13 @@ async fn experimental_features_popup_snapshot() {
.expect("valid experimental-feature chord"); .expect("valid experimental-feature chord");
let view = ExperimentalFeaturesView::new( let view = ExperimentalFeaturesView::new(
vec![ExperimentalFeatureItem { vec![ExperimentalFeatureItem {
feature: Some(Feature::ShellTool), key: Feature::ShellTool.key().to_string(),
writable: true,
name: "Shell tool".to_string(), name: "Shell tool".to_string(),
description: "Allow the model to run shell commands.".to_string(), description: "Allow the model to run shell commands.".to_string(),
enabled: true, enabled: true,
}], }],
ThreadId::new(),
/*catalog_rx*/ None, /*catalog_rx*/ None,
chat.app_event_tx.clone(), chat.app_event_tx.clone(),
keymap.list, keymap.list,
@@ -3056,17 +3061,21 @@ async fn experimental_features_popup_snapshot() {
async fn experimental_features_toggle_saves_on_exit() { async fn experimental_features_toggle_saves_on_exit() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; 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 expected_feature = Feature::JsRepl;
let view = ExperimentalFeaturesView::new( let view = ExperimentalFeaturesView::new(
vec![ExperimentalFeatureItem { vec![ExperimentalFeatureItem {
feature: Some(expected_feature), key: expected_feature.key().to_string(),
writable: true,
name: "JavaScript REPL".to_string(), 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(), description: "Enable a persistent Node-backed JavaScript REPL for interactive website debugging and other inline JavaScript execution capabilities.".to_string(),
enabled: false, enabled: false,
}], }],
ThreadId::new(),
/*catalog_rx*/ None, /*catalog_rx*/ None,
chat.app_event_tx.clone(), chat.app_event_tx.clone(),
crate::keymap::RuntimeKeymap::defaults().list, keymap,
); );
chat.bottom_pane.show_view(Box::new(view)); 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" "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; let mut updates = None;
while let Ok(event) = rx.try_recv() { while let Ok(event) = rx.try_recv() {
if let AppEvent::UpdateFeatureFlags { if let AppEvent::SaveExperimentalFeatures {
updates: event_updates, updates: event_updates,
..
} = event } = event
{ {
updates = Some(event_updates); updates = Some(event_updates);
@@ -3090,8 +3104,8 @@ async fn experimental_features_toggle_saves_on_exit() {
} }
} }
let updates = updates.expect("expected UpdateFeatureFlags event"); let updates = updates.expect("expected SaveExperimentalFeatures event");
assert_eq!(updates, vec![(expected_feature, true)]); assert_eq!(updates, vec![(expected_feature.key().to_string(), true)]);
} }
#[tokio::test] #[tokio::test]
+89 -4
View File
@@ -1,13 +1,16 @@
//! Bounded, popup-scoped experimental-feature discovery through the existing RPC. //! Bounded experimental-feature discovery and persistence through existing RPCs.
//! Dropping a popup stops pagination. One reserved request ID bounds abandoned //! Dropping a popup stops discovery, but submitted writes finish independently.
//! requests until the server replies or the connection closes. //! Readback describes configured enablement; reserved IDs bound unanswered requests.
use codex_app_server_client::AppServerRequestHandle; use codex_app_server_client::AppServerRequestHandle;
use codex_app_server_protocol::ClientRequest; 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::ExperimentalFeature;
use codex_app_server_protocol::ExperimentalFeatureListParams; use codex_app_server_protocol::ExperimentalFeatureListParams;
use codex_app_server_protocol::ExperimentalFeatureListResponse; use codex_app_server_protocol::ExperimentalFeatureListResponse;
use codex_app_server_protocol::RequestId; use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::WriteStatus;
use codex_protocol::ThreadId; use codex_protocol::ThreadId;
use std::collections::HashSet; use std::collections::HashSet;
use std::time::Duration; use std::time::Duration;
@@ -16,6 +19,7 @@ use tokio::sync::oneshot;
pub(crate) fn fetch( pub(crate) fn fetch(
request_handle: AppServerRequestHandle, request_handle: AppServerRequestHandle,
thread_id: ThreadId, thread_id: ThreadId,
request_id: &'static str,
mut response_tx: oneshot::Sender<Result<Vec<ExperimentalFeature>, String>>, mut response_tx: oneshot::Sender<Result<Vec<ExperimentalFeature>, String>>,
) { ) {
tokio::spawn(async move { tokio::spawn(async move {
@@ -30,7 +34,7 @@ pub(crate) fn fetch(
ClientRequest::ExperimentalFeatureList { ClientRequest::ExperimentalFeatureList {
// The client rejects duplicate pending IDs, bounding unanswered // The client rejects duplicate pending IDs, bounding unanswered
// requests across popup cancellation and timeout/retry cycles. // 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 { params: ExperimentalFeatureListParams {
cursor, cursor,
limit: Some(100), 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)] #[cfg(test)]
#[path = "experimental_features_tests.rs"] #[path = "experimental_features_tests.rs"]
mod tests; mod tests;
@@ -82,6 +82,7 @@ async fn experimental_features_rpc_paginates_thread_config_and_bounds_bad_server
fetch( fetch(
AppServerRequestHandle::Remote(client.request_handle()), AppServerRequestHandle::Remote(client.request_handle()),
thread_id, thread_id,
"tui-experimental-features",
tx, tx,
); );
let result = tokio::time::timeout(Duration::from_secs(/*secs*/ 10), rx) 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( fetch(
AppServerRequestHandle::Remote(client.request_handle()), AppServerRequestHandle::Remote(client.request_handle()),
thread_id, thread_id,
"tui-experimental-features",
tx, tx,
); );
assert_eq!( 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();
}
}