Add a loader for executor-local config layers (#37406)

## What changed

- Add `load_local_config_layers` to return raw configuration and requirements layers with their sources, base directories, precedence order, and cloud insertion positions.
- Support projecting layer stacks to selected TOML paths while preserving non-table override blockers and adjusting cloud insertion positions when empty layers are removed.
- Reuse project discovery and trust handling for local reads, including linked-worktree hooks, without resolving relative paths or including profiles, session flags, thread layers, or cloud-provided values.

## Testing

- Cover layer ordering, raw relative paths, legacy requirements, trust filtering, projection semantics, and untrusted linked-worktree hook handling.

GitOrigin-RevId: a1098af5650ac44e5a230ba9a5fe918927986d05
This commit is contained in:
sayan-oai authored and copyberry committed 2026-08-07 08:28:10 +00:00
1 parent c87a218bd3
commit 957f8eedee
5 files changed
+831 -90

No files matched your search

+214 -2
View File
@@ -70,10 +70,21 @@ impl ExecutorFileSystem for TestFileSystem {
fn get_metadata<'a>(
&'a self,
_path: &'a PathUri,
path: &'a PathUri,
_sandbox: Option<&'a FileSystemSandboxContext>,
) -> ExecutorFileSystemFuture<'a, FileMetadata> {
Box::pin(async move { unimplemented!("test filesystem only supports reads") })
Box::pin(async move {
let path = path.to_abs_path()?;
let metadata = tokio::fs::symlink_metadata(path.as_path()).await?;
Ok(FileMetadata {
is_directory: metadata.is_dir(),
is_file: metadata.is_file(),
is_symlink: metadata.file_type().is_symlink(),
size: metadata.len(),
created_at_ms: 0,
modified_at_ms: 0,
})
})
}
fn read_directory<'a>(
@@ -254,3 +265,204 @@ model = "gpt-dev"
.await
.expect("profile-v2 should allow unrelated legacy profiles in base user config");
}
#[test]
fn local_layer_projection_preserves_override_blockers_and_cloud_position() {
let tmp = tempdir().expect("tempdir");
let base_dir = AbsolutePathBuf::from_absolute_path(tmp.path()).expect("absolute base");
let layer = |source, contents| LocalTomlLayer {
source,
base_dir: base_dir.clone(),
toml: toml::from_str(contents).expect("valid TOML"),
};
let layers = LocalConfigLayers {
config: LocalTomlLayerStack {
layers: vec![
layer(
ConfigLayerSource::System {
file: base_dir.join("system.toml"),
},
r#"ignored=true
"literal.key"="literal"
array=[1,2]
[a]
b=1
c=2
"#,
),
layer(
ConfigLayerSource::SessionFlags,
"a=2\nignored=false\nonly_user=true",
),
layer(
ConfigLayerSource::LegacyManagedConfigTomlFromMdm,
"[a]\nunrequested=true",
),
],
cloud_insertion_index: 1,
},
requirements: LocalTomlLayerStack {
layers: Vec::<LocalTomlLayer<RequirementSource>>::new(),
cloud_insertion_index: 0,
},
};
let only_user = layers.clone().project(&[vec!["only_user".into()]], &[]);
assert_eq!(only_user.config.layers.len(), 1);
assert_eq!(only_user.config.cloud_insertion_index, 0);
let projected = layers.project(
&[
vec!["a".into(), "b".into()],
vec!["array".into(), "unused".into()],
vec!["literal.key".into()],
],
&[],
);
assert_eq!(
projected.config,
LocalTomlLayerStack {
layers: vec![
layer(
ConfigLayerSource::System {
file: base_dir.join("system.toml"),
},
r#""literal.key"="literal"
array=[1,2]
[a]
b=1"#,
),
layer(ConfigLayerSource::SessionFlags, "a=2"),
layer(ConfigLayerSource::LegacyManagedConfigTomlFromMdm, "[a]"),
],
cloud_insertion_index: 1,
}
);
let mut merged = TomlValue::Table(toml::map::Map::new());
for layer in projected.config.layers {
merge_toml_values(&mut merged, &layer.toml);
}
assert_eq!(
merged.get("a"),
Some(&TomlValue::Table(toml::map::Map::new()))
);
}
#[tokio::test]
async fn local_layers_keep_raw_paths_order_and_legacy_requirements() {
let tmp = tempdir().expect("tempdir");
let codex_home = tmp.path().join("codex-home");
let project = tmp.path().join("project");
let dot_codex = project.join(".codex");
let system_dir = tmp.path().join("system");
let managed_dir = tmp.path().join("managed");
for dir in [&codex_home, &dot_codex, &system_dir, &managed_dir] {
std::fs::create_dir_all(dir).expect("create fixture directory");
}
std::fs::write(project.join(".project-root"), "").expect("write project marker");
let project_key = project_trust_key(&project);
let project_key = TomlValue::String(project_key).to_string();
let user_config = |trust_level| {
format!(
"project_root_markers=[\".project-root\"]\nmodel_instructions_file=\"./user.md\"\n[projects.{project_key}]\ntrust_level=\"{trust_level}\""
)
};
let user_file = codex_home.join(CONFIG_TOML_FILE);
std::fs::write(&user_file, user_config("trusted")).expect("write user config");
let system_file = system_dir.join(CONFIG_TOML_FILE);
std::fs::write(&system_file, "model_instructions_file = \"./system.md\"")
.expect("write system config");
std::fs::write(
dot_codex.join(CONFIG_TOML_FILE),
"model_instructions_file = \"./project.md\"\nopenai_base_url = \"https://ignored\"",
)
.expect("write project config");
let managed_file = managed_dir.join("managed_config.toml");
std::fs::write(
&managed_file,
"approval_policy = \"never\"\nsandbox_mode = \"workspace-write\"\nmodel_instructions_file = \"./managed.md\"",
)
.expect("write legacy managed config");
let requirements_file = managed_dir.join("requirements.toml");
std::fs::write(
&requirements_file,
"allowed_sandbox_modes = [\"read-only\"]\nlog_dir = \"./logs\"",
)
.expect("write system requirements");
let mut overrides = LoaderOverrides::with_managed_config_path_for_tests(managed_file.clone());
overrides.system_config_path = Some(system_file.clone());
overrides.system_requirements_path = Some(requirements_file.clone());
let cwd = AbsolutePathBuf::from_absolute_path(&project).expect("absolute cwd");
let layers = local::load_local_config_layers_with_overrides(
&TestFileSystem,
&codex_home,
&cwd,
&overrides,
)
.await
.expect("load local layers");
assert_eq!(
layers
.config
.layers
.iter()
.map(|layer| layer.base_dir.to_path_buf())
.collect::<Vec<_>>(),
vec![
system_dir.clone(),
codex_home.clone(),
dot_codex.clone(),
managed_dir.clone(),
]
);
assert_eq!(layers.config.cloud_insertion_index, 1);
assert_eq!(layers.requirements.cloud_insertion_index, 1);
assert_eq!(
(
layers.config.layers[2].toml.clone(),
layers.config.layers[3]
.toml
.get("model_instructions_file")
.cloned(),
layers.requirements.layers[0]
.toml
.get("log_dir")
.cloned(),
layers.requirements.layers[1].toml.clone(),
),
(
toml::from_str("model_instructions_file = \"./project.md\"")
.expect("project TOML"),
Some(TomlValue::String("./managed.md".into())),
Some(TomlValue::String("./logs".into())),
toml::from_str(
"allowed_approval_policies=[\"never\"]\nallowed_sandbox_modes=[\"read-only\",\"workspace-write\"]"
)
.expect("legacy requirements TOML"),
)
);
std::fs::write(&user_file, user_config("untrusted")).expect("write user config");
let layers = local::load_local_config_layers_with_overrides(
&TestFileSystem,
&codex_home,
&cwd,
&overrides,
)
.await
.expect("load local layers");
assert_eq!(
layers
.config
.layers
.iter()
.filter(|layer| matches!(layer.source, ConfigLayerSource::Project { .. }))
.count(),
0
);
}