config: add override config foundation

# Conflicts:
#	codex-rs/config/src/loader/mod.rs
This commit is contained in:
Brent Traut
2026-05-19 13:29:23 -07:00
parent 5c43a64e2b
commit ed68380a48
27 changed files with 1814 additions and 125 deletions
+1 -1
View File
@@ -218,7 +218,7 @@ Example with notification opt-out:
- `mcpServer/tool/call` — call a tool on a thread's configured MCP server by `threadId`, `server`, `tool`, optional `arguments`, and optional `_meta`, returning the MCP tool result.
- `windowsSandbox/setupStart` — start Windows sandbox setup for the selected mode (`elevated` or `unelevated`); accepts an optional absolute `cwd` to target setup for a specific workspace, returns `{ started: true }` immediately, and later emits `windowsSandbox/setupCompleted`.
- `feedback/upload` — submit a feedback report (classification + optional reason/logs, conversation_id, and optional `extraLogFiles` attachments array); returns the tracking thread id.
- `config/read` — fetch the effective config on disk after resolving config layering, including opaque `desktop` values stored in `config.toml`.
- `config/read` — fetch the effective config on disk after resolving config layering, including sibling `config.override.toml` layers and opaque `desktop` values stored in `config.toml`. Responses include `userConfigVersion`, the writable user-config version to pass back as `expectedVersion` for optimistic config writes.
- `externalAgentConfig/detect` — detect migratable external-agent artifacts with `includeHome` and optional `cwds`; each detected item includes `cwd` (`null` for home), and plugin/session migration items may additionally include structured `details` grouping plugin ids or session metadata.
- `externalAgentConfig/import` — apply selected external-agent migration items by passing explicit `migrationItems` with `cwd` (`null` for home) and any plugin/session `details` returned by detect. When a request includes migration items, the server emits `externalAgentConfig/import/completed` once after the full import finishes (immediately after the response when everything completed synchronously, or after background imports finish).
- `config/value/write` — write a single config key/value to the user's config.toml on disk; dotted paths such as `desktop.someKey` use the same generic write surface.
@@ -138,6 +138,9 @@ impl ConfigManager {
Ok(ConfigReadResponse {
config,
origins: layers.origins(),
user_config_version: layers
.get_active_user_layer()
.map(|layer| layer.version.clone()),
layers: params.include_layers.then(|| {
layers
.get_layers(
@@ -608,14 +611,25 @@ fn override_message(layer: &ConfigLayerSource) -> String {
ConfigLayerSource::System { file } => {
format!("Overridden by managed config (system): {}", file.display())
}
ConfigLayerSource::SystemOverride { file } => {
format!("Overridden by managed config override: {}", file.display())
}
ConfigLayerSource::Project { dot_codex_folder } => format!(
"Overridden by project config: {}/{CONFIG_TOML_FILE}",
dot_codex_folder.display(),
),
ConfigLayerSource::ProjectOverride { dot_codex_folder } => format!(
"Overridden by project config override: {}/{}",
dot_codex_folder.display(),
codex_config::CONFIG_OVERRIDE_TOML_FILE,
),
ConfigLayerSource::SessionFlags => "Overridden by session flags".to_string(),
ConfigLayerSource::User { file, .. } => {
format!("Overridden by user config: {}", file.display())
}
ConfigLayerSource::UserOverride { file } => {
format!("Overridden by user config override: {}", file.display())
}
ConfigLayerSource::LegacyManagedConfigTomlFromFile { file } => {
format!(
"Overridden by legacy managed_config.toml: {}",
@@ -431,6 +431,73 @@ async fn version_conflict_rejected() {
);
}
#[tokio::test]
async fn read_reports_writable_user_config_version_when_override_wins() {
let tmp = tempdir().expect("tempdir");
std::fs::write(tmp.path().join(CONFIG_TOML_FILE), "model = \"base\"").unwrap();
std::fs::write(
tmp.path().join(codex_config::CONFIG_OVERRIDE_TOML_FILE),
"model = \"override\"",
)
.unwrap();
let service = ConfigManager::without_managed_config_for_tests(tmp.path().to_path_buf());
let read = service
.read(ConfigReadParams {
include_layers: true,
cwd: None,
})
.await
.expect("read succeeds");
let user_layer = read
.layers
.as_ref()
.expect("layers")
.iter()
.find(|layer| matches!(layer.name, ConfigLayerSource::User { .. }))
.expect("active user layer");
assert_eq!(read.config.model.as_deref(), Some("override"));
assert_eq!(read.user_config_version, Some(user_layer.version.clone()));
}
#[tokio::test]
async fn write_value_rejects_stale_user_config_version_when_override_wins() {
let tmp = tempdir().expect("tempdir");
std::fs::write(tmp.path().join(CONFIG_TOML_FILE), "model = \"base\"").unwrap();
std::fs::write(
tmp.path().join(codex_config::CONFIG_OVERRIDE_TOML_FILE),
"model = \"override\"",
)
.unwrap();
let service = ConfigManager::without_managed_config_for_tests(tmp.path().to_path_buf());
let read = service
.read(ConfigReadParams {
include_layers: false,
cwd: None,
})
.await
.expect("read succeeds");
std::fs::write(tmp.path().join(CONFIG_TOML_FILE), "model = \"changed\"").unwrap();
let err = service
.write_value(ConfigValueWriteParams {
file_path: None,
key_path: "model".to_string(),
value: serde_json::json!("new"),
merge_strategy: MergeStrategy::Replace,
expected_version: read.user_config_version,
})
.await
.expect_err("stale user config version should conflict");
assert_eq!(
err.write_error_code(),
Some(ConfigWriteErrorCode::ConfigVersionConflict)
);
}
#[tokio::test]
async fn write_value_defaults_to_user_config_path() {
let tmp = tempdir().expect("tempdir");
@@ -75,10 +75,12 @@ sandbox_mode = "workspace-write"
let ConfigReadResponse {
config,
origins,
user_config_version,
layers,
} = to_response(resp)?;
assert_eq!(config.model.as_deref(), Some("gpt-user"));
assert!(user_config_version.is_some());
assert_eq!(
origins.get("model").expect("origin").name,
ConfigLayerSource::User {
@@ -126,6 +128,7 @@ allowed_domains = ["example.com"]
config,
origins,
layers,
..
} = to_response(resp)?;
let tools = config.tools.expect("tools present");
@@ -358,6 +361,7 @@ default_tools_approval_mode = "prompt"
config,
origins,
layers,
..
} = to_response(resp)?;
assert_eq!(
@@ -503,6 +507,81 @@ model_reasoning_effort = "high"
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_read_reports_project_override_layers_and_origins() -> Result<()> {
let codex_home = TempDir::new()?;
write_config(&codex_home, r#"model = "gpt-user""#)?;
let workspace = TempDir::new()?;
let project_config_dir = workspace.path().join(".codex");
std::fs::create_dir_all(&project_config_dir)?;
std::fs::write(
project_config_dir.join("config.toml"),
r#"
model_reasoning_effort = "high"
"#,
)?;
std::fs::write(
project_config_dir.join("config.override.toml"),
r#"
model_reasoning_effort = "xhigh"
"#,
)?;
set_project_trust_level(codex_home.path(), workspace.path(), TrustLevel::Trusted)?;
let project_config = AbsolutePathBuf::try_from(project_config_dir)?;
let mut mcp = McpProcess::new(codex_home.path()).await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let request_id = mcp
.send_config_read_request(ConfigReadParams {
include_layers: true,
cwd: Some(workspace.path().to_string_lossy().into_owned()),
})
.await?;
let resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
)
.await??;
let ConfigReadResponse {
config,
origins,
layers,
..
} = to_response(resp)?;
assert_eq!(config.model_reasoning_effort, Some(ReasoningEffort::XHigh));
assert_eq!(
origins.get("model_reasoning_effort").expect("origin").name,
ConfigLayerSource::ProjectOverride {
dot_codex_folder: project_config.clone()
}
);
let project_layers = layers
.expect("layers")
.into_iter()
.filter_map(|layer| match layer.name {
source @ ConfigLayerSource::Project { .. }
| source @ ConfigLayerSource::ProjectOverride { .. } => Some(source),
_ => None,
})
.collect::<Vec<_>>();
assert_eq!(
project_layers,
vec![
ConfigLayerSource::ProjectOverride {
dot_codex_folder: project_config.clone(),
},
ConfigLayerSource::Project {
dot_codex_folder: project_config,
},
]
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_read_includes_system_layer_and_overrides() -> Result<()> {
let codex_home = TempDir::new()?;
@@ -569,6 +648,7 @@ writable_roots = [{}]
config,
origins,
layers,
..
} = to_response(resp)?;
assert_eq!(config.model.as_deref(), Some("gpt-system"));
@@ -655,7 +735,7 @@ model = "gpt-old"
)
.await??;
let read: ConfigReadResponse = to_response(read_resp)?;
let expected_version = read.origins.get("model").map(|m| m.version.clone());
let expected_version = read.user_config_version.clone();
let write_id = mcp
.send_config_value_write_request(ConfigValueWriteParams {
@@ -695,6 +775,60 @@ model = "gpt-old"
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_value_write_uses_user_config_version_when_override_is_effective() -> Result<()> {
let temp_dir = TempDir::new()?;
let codex_home = temp_dir.path().canonicalize()?;
write_config(
&temp_dir,
r#"
model = "gpt-base"
"#,
)?;
std::fs::write(
temp_dir.path().join("config.override.toml"),
"model = \"gpt-override\"\n",
)?;
let mut mcp = McpProcess::new(&codex_home).await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let read_id = mcp
.send_config_read_request(ConfigReadParams {
include_layers: false,
cwd: None,
})
.await?;
let read_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(read_id)),
)
.await??;
let read: ConfigReadResponse = to_response(read_resp)?;
let expected_version = read.user_config_version.clone();
let write_id = mcp
.send_config_value_write_request(ConfigValueWriteParams {
file_path: None,
key_path: "model".to_string(),
value: json!("gpt-new-base"),
merge_strategy: MergeStrategy::Replace,
expected_version,
})
.await?;
let write_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(write_id)),
)
.await??;
let write: ConfigWriteResponse = to_response(write_resp)?;
assert_eq!(write.status, WriteStatus::OkOverridden);
assert!(write.overridden_metadata.is_some());
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_value_write_updates_desktop_settings() -> Result<()> {
let temp_dir = TempDir::new()?;