diff --git a/.github/workflows/pwragent-ci.yml b/.github/workflows/pwragent-ci.yml index 14a0897af960..e82f162dab63 100644 --- a/.github/workflows/pwragent-ci.yml +++ b/.github/workflows/pwragent-ci.yml @@ -54,6 +54,10 @@ jobs: command: >- cargo build --locked --bin codex-code-mode-host && cargo nextest run --locked -p codex-core --lib --no-fail-fast + - name: app-server-config + command: >- + cargo nextest run --locked -p codex-app-server --lib --no-fail-fast + -E 'test(config_manager::)' - name: clippy command: cargo clippy --locked -p codex-core --all-targets # The jobs above do not build the CLI or app-server executables, so diff --git a/codex-rs/app-server/src/config_manager.rs b/codex-rs/app-server/src/config_manager.rs index dc75d18c0735..9648e36e8dce 100644 --- a/codex-rs/app-server/src/config_manager.rs +++ b/codex-rs/app-server/src/config_manager.rs @@ -6,8 +6,10 @@ use codex_config::ConfigLayerStack; use codex_config::LoaderOverrides; use codex_config::ThreadConfigLoader; use codex_config::apply_default_gcp_auth; +use codex_config::build_cli_overrides_layer; use codex_config::loader::load_config_layers_state; use codex_config::loader::load_managed_requirements_state; +use codex_config::merge_toml_values; use codex_core::config::Config; use codex_core::config::ConfigBuilder; use codex_core::config::ConfigOverrides; @@ -684,15 +686,22 @@ impl ConfigManager { ) })?); } - let merged_cli_overrides = cli_overrides - .iter() - .cloned() - .chain( - request_overrides - .into_iter() - .map(|(key, value)| (key, json_to_toml(value))), - ) + let request_overrides = request_overrides + .into_iter() + .map(|(key, value)| (key, json_to_toml(value))) .collect::>(); + // Process flags and request config are separate layers. Applying a + // request table as another CLI assignment would replace sibling flags. + let mut merged_cli_overrides = build_cli_overrides_layer(cli_overrides); + merge_toml_values( + &mut merged_cli_overrides, + &build_cli_overrides_layer(&request_overrides), + ); + let TomlValue::Table(merged_cli_overrides) = merged_cli_overrides else { + unreachable!("CLI override layers are tables"); + }; + // Keep nested keys literal, including MCP server names containing dots. + let merged_cli_overrides = merged_cli_overrides.into_iter().collect::>(); let result = codex_core::config::ConfigBuilder::default() .codex_home(self.codex_home.clone()) .cli_overrides(merged_cli_overrides) @@ -811,6 +820,10 @@ impl ConfigManager { #[path = "application_network_tests.rs"] mod application_network_tests; +#[cfg(test)] +#[path = "config_manager_override_tests.rs"] +mod override_tests; + #[cfg(test)] #[path = "config_manager_provider_tests.rs"] mod provider_tests; diff --git a/codex-rs/app-server/src/config_manager_override_tests.rs b/codex-rs/app-server/src/config_manager_override_tests.rs new file mode 100644 index 000000000000..2a5c1e3ef919 --- /dev/null +++ b/codex-rs/app-server/src/config_manager_override_tests.rs @@ -0,0 +1,164 @@ +//! Request overrides are a higher-priority layer, not additional process CLI assignments. + +use super::*; +use anyhow::Result; +use pretty_assertions::assert_eq; +use serde_json::json; +use tempfile::tempdir; + +#[tokio::test] +async fn request_tables_preserve_unrelated_process_settings() -> Result<()> { + let home = tempdir()?; + let file_config = "[features]\napps = true\nplugins = true\nmulti_agent = true\ngoals = true\nimage_generation = true\n[mcp_servers.inherited]\ncommand = 'inherited-command'\nenabled = true\n"; + let config_path = home.path().join("config.toml"); + std::fs::write(&config_path, file_config)?; + let manager = ConfigManager::without_managed_config_for_tests(home.path().to_path_buf()); + let features = [ + "apps", + "plugins", + "multi_agent", + "goals", + "image_generation", + ]; + + // Exhaust every combination: an unrelated request table must preserve each + // process flag's value, irrespective of the file's lower-priority defaults. + for mask in 0..(1 << features.len()) { + for dotted_request in [false, true] { + let mut process = features + .iter() + .enumerate() + .map(|(index, feature)| { + ( + format!("features.{feature}"), + TomlValue::Boolean(mask & (1 << index) != 0), + ) + }) + .collect::>(); + process.push(("features.code_mode".into(), TomlValue::Boolean(false))); + process.push(( + "mcp_servers.inherited.enabled".into(), + TomlValue::Boolean(false), + )); + let code_mode = json!({ "max_output_tokens_ceiling": 1234 }); + let selected = json!({ "command": "selected-command" }); + let request = if dotted_request { + HashMap::from([ + ("features.code_mode".into(), code_mode), + ("mcp_servers.selected".into(), selected), + ]) + } else { + HashMap::from([ + ("features".into(), json!({ "code_mode": code_mode })), + ("mcp_servers".into(), json!({ "selected": selected })), + ]) + }; + let config = manager + .load_with_cli_overrides( + &process, + Some(request), + ConfigOverrides::default(), + Some(home.path().to_path_buf()), + ) + .await?; + let effective = config.config_layer_stack.effective_config(); + for (index, feature) in features.iter().enumerate() { + assert_eq!( + effective["features"][feature], + TomlValue::Boolean(mask & (1 << index) != 0), + "mask={mask}, dotted_request={dotted_request}, feature={feature}" + ); + } + assert_eq!( + effective["features"]["code_mode"]["enabled"], + TomlValue::Boolean(false) + ); + assert_eq!( + effective["features"]["code_mode"]["max_output_tokens_ceiling"], + TomlValue::Integer(1234) + ); + assert!(!config.mcp_servers.get()["inherited"].enabled); + assert!(config.mcp_servers.get()["selected"].enabled); + } + } + assert_eq!(std::fs::read_to_string(config_path)?, file_config); + Ok(()) +} + +#[tokio::test] +async fn explicit_request_values_win_without_splitting_server_names() -> Result<()> { + let home = tempdir()?; + let manager = ConfigManager::without_managed_config_for_tests(home.path().to_path_buf()); + for server_name in [ + "inherited", + "inherited.server", + "inherited.server.with.dots", + ] { + for enabled in [false, true] { + let process = vec![ + ("features.apps".into(), TomlValue::Boolean(!enabled)), + ( + "features.code_mode.max_output_tokens_ceiling".into(), + TomlValue::Integer(1234), + ), + ( + "features.code_mode.enabled".into(), + TomlValue::Boolean(!enabled), + ), + ( + "mcp_servers".into(), + json_to_toml(json!({ + server_name: { + "command": "inherited-command", "enabled": !enabled, + "args": ["old"], "env": { "KEPT": "process", "REPLACED": "process" }, + }, + })), + ), + ]; + let request = HashMap::from([ + ( + "features".into(), + json!({ "apps": enabled, "code_mode": enabled }), + ), + ( + "mcp_servers".into(), + json!({ + server_name: { "enabled": enabled, "args": ["new"], "env": { "REPLACED": "request" } }, + "selected.server": { "command": "selected-command" }, + }), + ), + ]); + let config = manager + .load_with_cli_overrides( + &process, + Some(request), + ConfigOverrides::default(), + Some(home.path().to_path_buf()), + ) + .await?; + let effective = config.config_layer_stack.effective_config(); + assert_eq!(effective["features"]["apps"], TomlValue::Boolean(enabled)); + assert_eq!( + effective["features"]["code_mode"]["enabled"], + TomlValue::Boolean(enabled) + ); + assert_eq!( + effective["features"]["code_mode"]["max_output_tokens_ceiling"], + TomlValue::Integer(1234) + ); + assert_eq!( + effective["mcp_servers"], + json_to_toml(json!({ + server_name: { + "command": "inherited-command", "enabled": enabled, + "args": ["new"], "env": { "KEPT": "process", "REPLACED": "request" }, + }, + "selected.server": { "command": "selected-command" }, + })) + ); + assert_eq!(config.mcp_servers.get()[server_name].enabled, enabled); + assert!(config.mcp_servers.get().contains_key("selected.server")); + } + } + Ok(()) +}