mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
config: add override config foundation
# Conflicts: # codex-rs/config/src/loader/mod.rs
This commit is contained in:
@@ -228,11 +228,20 @@ where
|
||||
|
||||
fn config_path_for_layer(layer: &ConfigLayerEntry, config_toml_file: &str) -> Option<PathBuf> {
|
||||
match &layer.name {
|
||||
ConfigLayerSource::System { file } => Some(file.to_path_buf()),
|
||||
ConfigLayerSource::User { file, .. } => Some(file.to_path_buf()),
|
||||
ConfigLayerSource::System { file } | ConfigLayerSource::SystemOverride { file } => {
|
||||
Some(file.to_path_buf())
|
||||
}
|
||||
ConfigLayerSource::User { file, .. } | ConfigLayerSource::UserOverride { file } => {
|
||||
Some(file.to_path_buf())
|
||||
}
|
||||
ConfigLayerSource::Project { dot_codex_folder } => {
|
||||
Some(dot_codex_folder.as_path().join(config_toml_file))
|
||||
}
|
||||
ConfigLayerSource::ProjectOverride { dot_codex_folder } => Some(
|
||||
dot_codex_folder
|
||||
.as_path()
|
||||
.join(crate::CONFIG_OVERRIDE_TOML_FILE),
|
||||
),
|
||||
ConfigLayerSource::LegacyManagedConfigTomlFromFile { file } => Some(file.to_path_buf()),
|
||||
ConfigLayerSource::Mdm { .. }
|
||||
| ConfigLayerSource::SessionFlags
|
||||
|
||||
@@ -27,6 +27,7 @@ mod tui_keymap;
|
||||
pub mod types;
|
||||
|
||||
pub const CONFIG_TOML_FILE: &str = "config.toml";
|
||||
pub const CONFIG_OVERRIDE_TOML_FILE: &str = "config.override.toml";
|
||||
|
||||
pub use cloud_requirements::CloudRequirementsLoadError;
|
||||
pub use cloud_requirements::CloudRequirementsLoadErrorCode;
|
||||
|
||||
@@ -5,6 +5,7 @@ mod macos;
|
||||
mod tests;
|
||||
|
||||
use self::layer_io::LoadedConfigLayers;
|
||||
use crate::CONFIG_OVERRIDE_TOML_FILE;
|
||||
use crate::CONFIG_TOML_FILE;
|
||||
use crate::ProfileV2Name;
|
||||
use crate::cloud_requirements::CloudRequirementsLoader;
|
||||
@@ -210,6 +211,23 @@ pub async fn load_config_layers_state(
|
||||
)
|
||||
.await?;
|
||||
layers.push(system_layer);
|
||||
if let Some(system_override_layer) = load_optional_override_layer(
|
||||
fs,
|
||||
&system_config_toml_file,
|
||||
strict_config,
|
||||
|override_file, config_toml| {
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::SystemOverride {
|
||||
file: override_file,
|
||||
},
|
||||
config_toml,
|
||||
)
|
||||
},
|
||||
)
|
||||
.await?
|
||||
{
|
||||
layers.push(system_override_layer);
|
||||
}
|
||||
|
||||
// Add the base user config layer. When profile-v2 is selected, add the
|
||||
// profile config as a second user layer on top so the profile only needs to
|
||||
@@ -242,6 +260,24 @@ pub async fn load_config_layers_state(
|
||||
));
|
||||
}
|
||||
layers.push(base_user_layer);
|
||||
if !ignore_user_config
|
||||
&& let Some(user_override_layer) = load_optional_override_layer(
|
||||
fs,
|
||||
&base_user_file,
|
||||
strict_config,
|
||||
|override_file, config_toml| {
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
config_toml,
|
||||
)
|
||||
},
|
||||
)
|
||||
.await?
|
||||
{
|
||||
layers.push(user_override_layer);
|
||||
}
|
||||
|
||||
if active_user_file != base_user_file {
|
||||
layers.push(
|
||||
@@ -480,6 +516,36 @@ async fn load_config_toml_for_required_layer(
|
||||
Ok(create_entry(toml_value))
|
||||
}
|
||||
|
||||
async fn load_optional_override_layer(
|
||||
fs: &dyn ExecutorFileSystem,
|
||||
config_toml_file: &AbsolutePathBuf,
|
||||
strict_config: bool,
|
||||
create_entry: impl FnOnce(AbsolutePathBuf, TomlValue) -> ConfigLayerEntry,
|
||||
) -> io::Result<Option<ConfigLayerEntry>> {
|
||||
let parent = config_toml_file.parent().ok_or_else(|| {
|
||||
io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
format!(
|
||||
"Config file {} has no parent directory",
|
||||
config_toml_file.as_path().display()
|
||||
),
|
||||
)
|
||||
})?;
|
||||
let override_file = parent.join(CONFIG_OVERRIDE_TOML_FILE);
|
||||
let Some(config_toml) = layer_io::read_config_from_path(
|
||||
fs,
|
||||
&override_file,
|
||||
/*log_missing_as_info*/ false,
|
||||
strict_config,
|
||||
)
|
||||
.await?
|
||||
else {
|
||||
return Ok(None);
|
||||
};
|
||||
let config_toml = resolve_relative_paths_in_config_toml(config_toml, parent.as_path())?;
|
||||
Ok(Some(create_entry(override_file, config_toml)))
|
||||
}
|
||||
|
||||
fn validate_config_toml_strictly(
|
||||
toml_file: &Path,
|
||||
contents: &str,
|
||||
@@ -862,10 +928,38 @@ fn project_layer_entry(
|
||||
disabled_reason: Option<String>,
|
||||
hooks_config_folder_override: Option<AbsolutePathBuf>,
|
||||
) -> ConfigLayerEntry {
|
||||
let source = ConfigLayerSource::Project {
|
||||
dot_codex_folder: dot_codex_folder.clone(),
|
||||
};
|
||||
project_config_layer_entry(
|
||||
ConfigLayerSource::Project {
|
||||
dot_codex_folder: dot_codex_folder.clone(),
|
||||
},
|
||||
config,
|
||||
disabled_reason,
|
||||
hooks_config_folder_override,
|
||||
)
|
||||
}
|
||||
|
||||
fn project_override_layer_entry(
|
||||
dot_codex_folder: &AbsolutePathBuf,
|
||||
config: TomlValue,
|
||||
disabled_reason: Option<String>,
|
||||
hooks_config_folder_override: Option<AbsolutePathBuf>,
|
||||
) -> ConfigLayerEntry {
|
||||
project_config_layer_entry(
|
||||
ConfigLayerSource::ProjectOverride {
|
||||
dot_codex_folder: dot_codex_folder.clone(),
|
||||
},
|
||||
config,
|
||||
disabled_reason,
|
||||
hooks_config_folder_override,
|
||||
)
|
||||
}
|
||||
|
||||
fn project_config_layer_entry(
|
||||
source: ConfigLayerSource,
|
||||
config: TomlValue,
|
||||
disabled_reason: Option<String>,
|
||||
hooks_config_folder_override: Option<AbsolutePathBuf>,
|
||||
) -> ConfigLayerEntry {
|
||||
let entry = if let Some(reason) = disabled_reason {
|
||||
ConfigLayerEntry::new_disabled(source, config, reason)
|
||||
} else {
|
||||
@@ -890,10 +984,9 @@ fn sanitize_project_config(config: &mut TomlValue) -> Vec<String> {
|
||||
}
|
||||
|
||||
fn project_ignored_config_keys_warning(
|
||||
dot_codex_folder: &AbsolutePathBuf,
|
||||
config_path: AbsolutePathBuf,
|
||||
ignored_keys: &[String],
|
||||
) -> String {
|
||||
let config_path = dot_codex_folder.join(CONFIG_TOML_FILE);
|
||||
let ignored_keys = ignored_keys.join(", ");
|
||||
format!(
|
||||
concat!(
|
||||
@@ -1191,31 +1284,20 @@ async fn load_project_layers(
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let mut config = config;
|
||||
if disabled_reason.is_none() && strict_config {
|
||||
validate_config_toml_strictly(
|
||||
config_file.as_path(),
|
||||
&contents,
|
||||
&config,
|
||||
dot_codex_abs.as_path(),
|
||||
)?;
|
||||
}
|
||||
let ignored_project_config_keys = sanitize_project_config(&mut config);
|
||||
let config =
|
||||
resolve_relative_paths_in_config_toml(config, dot_codex_abs.as_path())?;
|
||||
let config = merge_root_checkout_project_hooks(
|
||||
let config = prepare_project_layer_config(
|
||||
fs,
|
||||
&config_file,
|
||||
CONFIG_TOML_FILE,
|
||||
&contents,
|
||||
config,
|
||||
&dot_codex_abs,
|
||||
hooks_config_folder_override.as_ref(),
|
||||
decision.is_trusted(),
|
||||
strict_config,
|
||||
disabled_reason.is_none(),
|
||||
&mut startup_warnings,
|
||||
)
|
||||
.await?;
|
||||
if disabled_reason.is_none() && !ignored_project_config_keys.is_empty() {
|
||||
startup_warnings.push(project_ignored_config_keys_warning(
|
||||
&dot_codex_abs,
|
||||
&ignored_project_config_keys,
|
||||
));
|
||||
}
|
||||
let entry = project_layer_entry(
|
||||
&dot_codex_abs,
|
||||
config,
|
||||
@@ -1234,13 +1316,14 @@ async fn load_project_layers(
|
||||
TomlValue::Table(toml::map::Map::new()),
|
||||
hooks_config_folder_override.as_ref(),
|
||||
decision.is_trusted(),
|
||||
CONFIG_TOML_FILE,
|
||||
)
|
||||
.await?;
|
||||
layers.push(project_layer_entry(
|
||||
&dot_codex_abs,
|
||||
config,
|
||||
disabled_reason,
|
||||
hooks_config_folder_override,
|
||||
disabled_reason.clone(),
|
||||
hooks_config_folder_override.clone(),
|
||||
));
|
||||
} else {
|
||||
let config_file_display = config_file.as_path().display();
|
||||
@@ -1251,6 +1334,80 @@ async fn load_project_layers(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let override_file = dot_codex_abs.join(CONFIG_OVERRIDE_TOML_FILE);
|
||||
match fs.read_file_text(&override_file, /*sandbox*/ None).await {
|
||||
Ok(contents) => {
|
||||
let config: TomlValue = match toml::from_str(&contents) {
|
||||
Ok(config) => config,
|
||||
Err(err) => {
|
||||
if decision.is_trusted() {
|
||||
let override_file_display = override_file.as_path().display();
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
format!(
|
||||
"Error parsing project override config file {override_file_display}: {err}"
|
||||
),
|
||||
));
|
||||
}
|
||||
layers.push(project_override_layer_entry(
|
||||
&dot_codex_abs,
|
||||
TomlValue::Table(toml::map::Map::new()),
|
||||
disabled_reason.clone(),
|
||||
hooks_config_folder_override.clone(),
|
||||
));
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let config = prepare_project_layer_config(
|
||||
fs,
|
||||
&override_file,
|
||||
CONFIG_OVERRIDE_TOML_FILE,
|
||||
&contents,
|
||||
config,
|
||||
&dot_codex_abs,
|
||||
hooks_config_folder_override.as_ref(),
|
||||
decision.is_trusted(),
|
||||
strict_config,
|
||||
disabled_reason.is_none(),
|
||||
&mut startup_warnings,
|
||||
)
|
||||
.await?;
|
||||
layers.push(project_override_layer_entry(
|
||||
&dot_codex_abs,
|
||||
config,
|
||||
disabled_reason.clone(),
|
||||
hooks_config_folder_override.clone(),
|
||||
));
|
||||
}
|
||||
Err(err) if err.kind() == io::ErrorKind::NotFound => {
|
||||
if hooks_config_folder_override.is_some() {
|
||||
let config = merge_root_checkout_project_hooks(
|
||||
fs,
|
||||
TomlValue::Table(toml::map::Map::new()),
|
||||
hooks_config_folder_override.as_ref(),
|
||||
decision.is_trusted(),
|
||||
CONFIG_OVERRIDE_TOML_FILE,
|
||||
)
|
||||
.await?;
|
||||
layers.push(project_override_layer_entry(
|
||||
&dot_codex_abs,
|
||||
config,
|
||||
disabled_reason.clone(),
|
||||
hooks_config_folder_override.clone(),
|
||||
));
|
||||
}
|
||||
}
|
||||
Err(err) => {
|
||||
let override_file_display = override_file.as_path().display();
|
||||
return Err(io::Error::new(
|
||||
err.kind(),
|
||||
format!(
|
||||
"Failed to read project override config file {override_file_display}: {err}"
|
||||
),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(LoadedProjectLayers {
|
||||
@@ -1259,6 +1416,47 @@ async fn load_project_layers(
|
||||
})
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
async fn prepare_project_layer_config(
|
||||
fs: &dyn ExecutorFileSystem,
|
||||
config_file: &AbsolutePathBuf,
|
||||
config_file_name: &str,
|
||||
contents: &str,
|
||||
mut config: TomlValue,
|
||||
dot_codex_abs: &AbsolutePathBuf,
|
||||
hooks_config_folder_override: Option<&AbsolutePathBuf>,
|
||||
is_trusted: bool,
|
||||
strict_config: bool,
|
||||
is_enabled: bool,
|
||||
startup_warnings: &mut Vec<String>,
|
||||
) -> io::Result<TomlValue> {
|
||||
if is_enabled && strict_config {
|
||||
validate_config_toml_strictly(
|
||||
config_file.as_path(),
|
||||
contents,
|
||||
&config,
|
||||
dot_codex_abs.as_path(),
|
||||
)?;
|
||||
}
|
||||
let ignored_project_config_keys = sanitize_project_config(&mut config);
|
||||
let config = resolve_relative_paths_in_config_toml(config, dot_codex_abs.as_path())?;
|
||||
let config = merge_root_checkout_project_hooks(
|
||||
fs,
|
||||
config,
|
||||
hooks_config_folder_override,
|
||||
is_trusted,
|
||||
config_file_name,
|
||||
)
|
||||
.await?;
|
||||
if is_enabled && !ignored_project_config_keys.is_empty() {
|
||||
startup_warnings.push(project_ignored_config_keys_warning(
|
||||
config_file.clone(),
|
||||
&ignored_project_config_keys,
|
||||
));
|
||||
}
|
||||
Ok(config)
|
||||
}
|
||||
|
||||
/// For linked worktrees, preserve ordinary worktree-local project config while
|
||||
/// replacing only hook declarations with the matching root-checkout layer.
|
||||
async fn merge_root_checkout_project_hooks(
|
||||
@@ -1266,11 +1464,12 @@ async fn merge_root_checkout_project_hooks(
|
||||
mut config: TomlValue,
|
||||
hooks_config_folder_override: Option<&AbsolutePathBuf>,
|
||||
is_trusted: bool,
|
||||
config_toml_file: &str,
|
||||
) -> io::Result<TomlValue> {
|
||||
let Some(hooks_config_folder) = hooks_config_folder_override else {
|
||||
return Ok(config);
|
||||
};
|
||||
let hooks_config_file = hooks_config_folder.join(CONFIG_TOML_FILE);
|
||||
let hooks_config_file = hooks_config_folder.join(config_toml_file);
|
||||
let root_config = match fs
|
||||
.read_file_text(&hooks_config_file, /*sandbox*/ None)
|
||||
.await
|
||||
|
||||
+169
-76
@@ -180,9 +180,16 @@ impl ConfigLayerEntry {
|
||||
pub fn config_folder(&self) -> Option<AbsolutePathBuf> {
|
||||
match &self.name {
|
||||
ConfigLayerSource::Mdm { .. } => None,
|
||||
ConfigLayerSource::System { file } => file.parent(),
|
||||
ConfigLayerSource::User { file, .. } => file.parent(),
|
||||
ConfigLayerSource::Project { dot_codex_folder } => Some(dot_codex_folder.clone()),
|
||||
ConfigLayerSource::System { file } | ConfigLayerSource::SystemOverride { file } => {
|
||||
file.parent()
|
||||
}
|
||||
ConfigLayerSource::User { file, .. } | ConfigLayerSource::UserOverride { file } => {
|
||||
file.parent()
|
||||
}
|
||||
ConfigLayerSource::Project { dot_codex_folder }
|
||||
| ConfigLayerSource::ProjectOverride { dot_codex_folder } => {
|
||||
Some(dot_codex_folder.clone())
|
||||
}
|
||||
ConfigLayerSource::SessionFlags => None,
|
||||
ConfigLayerSource::LegacyManagedConfigTomlFromFile { .. } => None,
|
||||
ConfigLayerSource::LegacyManagedConfigTomlFromMdm => None,
|
||||
@@ -301,8 +308,8 @@ impl ConfigLayerStack {
|
||||
/// Returns all user config layers in the requested precedence order.
|
||||
///
|
||||
/// With profile-v2 enabled, `LowestPrecedenceFirst` returns the base user
|
||||
/// config before the profile overlay, while `HighestPrecedenceFirst` returns
|
||||
/// the profile overlay before the base user config.
|
||||
/// config, sibling user override, then profile overlay, while
|
||||
/// `HighestPrecedenceFirst` returns that order in reverse.
|
||||
pub fn get_user_layers(
|
||||
&self,
|
||||
ordering: ConfigLayerStackOrdering,
|
||||
@@ -310,14 +317,14 @@ impl ConfigLayerStack {
|
||||
) -> Vec<&ConfigLayerEntry> {
|
||||
self.get_layers(ordering, include_disabled)
|
||||
.into_iter()
|
||||
.filter(|layer| matches!(layer.name, ConfigLayerSource::User { .. }))
|
||||
.filter(|layer| is_user_config_layer(&layer.name))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Returns the merged config from enabled user layers only.
|
||||
///
|
||||
/// When profile config is active, this includes the base user config followed
|
||||
/// by the profile override config.
|
||||
/// When profile config is active, this includes the base user config, any
|
||||
/// sibling user override, then the profile override config.
|
||||
pub fn effective_user_config(&self) -> Option<TomlValue> {
|
||||
let user_layers = self.get_user_layers(
|
||||
ConfigLayerStackOrdering::LowestPrecedenceFirst,
|
||||
@@ -358,6 +365,25 @@ impl ConfigLayerStack {
|
||||
self.with_user_config_profile(config_toml, profile.as_ref(), user_config)
|
||||
}
|
||||
|
||||
pub fn with_user_override_config(
|
||||
&self,
|
||||
config_toml: &AbsolutePathBuf,
|
||||
user_config: TomlValue,
|
||||
) -> Self {
|
||||
let user_layer = ConfigLayerEntry::new(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: config_toml.clone(),
|
||||
},
|
||||
user_config,
|
||||
);
|
||||
self.with_user_layer(user_layer, |layer| {
|
||||
matches!(
|
||||
&layer.name,
|
||||
ConfigLayerSource::UserOverride { file } if file == config_toml
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn with_user_config_profile(
|
||||
&self,
|
||||
config_toml: &AbsolutePathBuf,
|
||||
@@ -372,38 +398,12 @@ impl ConfigLayerStack {
|
||||
user_config,
|
||||
);
|
||||
|
||||
let mut layers = self.layers.clone();
|
||||
if let Some(index) = layers.iter().position(|layer| {
|
||||
self.with_user_layer(user_layer, |layer| {
|
||||
matches!(
|
||||
&layer.name,
|
||||
ConfigLayerSource::User { file, .. } if file == config_toml
|
||||
)
|
||||
}) {
|
||||
layers.remove(index);
|
||||
}
|
||||
match layers
|
||||
.iter()
|
||||
.position(|layer| layer.name.precedence() > user_layer.name.precedence())
|
||||
{
|
||||
Some(index) => layers.insert(index, user_layer),
|
||||
None => layers.push(user_layer),
|
||||
}
|
||||
let user_layer_index = layers.iter().enumerate().rev().find_map(|(index, layer)| {
|
||||
if matches!(layer.name, ConfigLayerSource::User { .. }) {
|
||||
Some(index)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
});
|
||||
Self {
|
||||
layers,
|
||||
user_layer_index,
|
||||
requirements: self.requirements.clone(),
|
||||
requirements_toml: self.requirements_toml.clone(),
|
||||
ignore_user_and_project_exec_policy_rules: self
|
||||
.ignore_user_and_project_exec_policy_rules,
|
||||
startup_warnings: self.startup_warnings.clone(),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Returns a new stack with the user layer copied from `other`, preserving
|
||||
@@ -412,31 +412,37 @@ impl ConfigLayerStack {
|
||||
let user_layers = other
|
||||
.layers
|
||||
.iter()
|
||||
.filter(|layer| matches!(layer.name, ConfigLayerSource::User { .. }))
|
||||
.filter(|layer| is_user_config_layer(&layer.name))
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
let mut layers = self
|
||||
.layers
|
||||
.iter()
|
||||
.filter(|layer| !matches!(layer.name, ConfigLayerSource::User { .. }))
|
||||
.filter(|layer| !is_user_config_layer(&layer.name))
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
for user_layer in user_layers {
|
||||
match layers
|
||||
.iter()
|
||||
.position(|layer| layer.name.precedence() > user_layer.name.precedence())
|
||||
{
|
||||
Some(index) => layers.insert(index, user_layer),
|
||||
None => layers.push(user_layer),
|
||||
}
|
||||
insert_user_layer(&mut layers, user_layer);
|
||||
}
|
||||
let user_layer_index = layers.iter().enumerate().rev().find_map(|(index, layer)| {
|
||||
if matches!(layer.name, ConfigLayerSource::User { .. }) {
|
||||
Some(index)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
});
|
||||
self.with_layers(layers)
|
||||
}
|
||||
|
||||
fn with_user_layer(
|
||||
&self,
|
||||
user_layer: ConfigLayerEntry,
|
||||
matches_existing: impl Fn(&ConfigLayerEntry) -> bool,
|
||||
) -> Self {
|
||||
let mut layers = self.layers.clone();
|
||||
if let Some(index) = layers.iter().position(matches_existing) {
|
||||
layers[index] = user_layer;
|
||||
} else {
|
||||
insert_user_layer(&mut layers, user_layer);
|
||||
}
|
||||
self.with_layers(layers)
|
||||
}
|
||||
|
||||
fn with_layers(&self, layers: Vec<ConfigLayerEntry>) -> Self {
|
||||
let user_layer_index = active_user_layer_index(&layers);
|
||||
Self {
|
||||
layers,
|
||||
user_layer_index,
|
||||
@@ -511,6 +517,63 @@ impl ConfigLayerStack {
|
||||
}
|
||||
}
|
||||
|
||||
fn is_user_config_layer(layer: &ConfigLayerSource) -> bool {
|
||||
matches!(
|
||||
layer,
|
||||
ConfigLayerSource::User { .. } | ConfigLayerSource::UserOverride { .. }
|
||||
)
|
||||
}
|
||||
|
||||
fn insert_user_layer(layers: &mut Vec<ConfigLayerEntry>, user_layer: ConfigLayerEntry) {
|
||||
let index = layers.iter().position(|layer| {
|
||||
layer.name.precedence() > user_layer.name.precedence()
|
||||
|| matches!(
|
||||
(&user_layer.name, &layer.name),
|
||||
(
|
||||
ConfigLayerSource::User {
|
||||
file,
|
||||
profile: None,
|
||||
},
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
}
|
||||
) if user_base_file_has_sibling_override(file, override_file)
|
||||
)
|
||||
|| matches!(
|
||||
(&user_layer.name, &layer.name),
|
||||
(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
ConfigLayerSource::User {
|
||||
file,
|
||||
profile: None,
|
||||
}
|
||||
) if !user_base_file_has_sibling_override(file, override_file)
|
||||
)
|
||||
});
|
||||
match index {
|
||||
Some(index) => layers.insert(index, user_layer),
|
||||
None => layers.push(user_layer),
|
||||
}
|
||||
}
|
||||
|
||||
fn user_base_file_has_sibling_override(
|
||||
file: &AbsolutePathBuf,
|
||||
override_file: &AbsolutePathBuf,
|
||||
) -> bool {
|
||||
file.parent() == override_file.parent()
|
||||
&& file
|
||||
.file_name()
|
||||
.is_some_and(|name| name == crate::CONFIG_TOML_FILE)
|
||||
}
|
||||
|
||||
fn active_user_layer_index(layers: &[ConfigLayerEntry]) -> Option<usize> {
|
||||
layers.iter().enumerate().rev().find_map(|(index, layer)| {
|
||||
matches!(layer.name, ConfigLayerSource::User { .. }).then_some(index)
|
||||
})
|
||||
}
|
||||
|
||||
/// Ensures precedence ordering of config layers is correct. Returns the index
|
||||
/// of the active user config layer, if any.
|
||||
fn verify_layer_ordering(layers: &[ConfigLayerEntry]) -> std::io::Result<Option<usize>> {
|
||||
@@ -525,41 +588,71 @@ fn verify_layer_ordering(layers: &[ConfigLayerEntry]) -> std::io::Result<Option<
|
||||
// further verify that project layers are ordered from root to cwd. Multiple
|
||||
// user layers are allowed so a profile override can layer on top of the base
|
||||
// user config.
|
||||
let mut user_layer_index: Option<usize> = None;
|
||||
let mut previous_project_dot_codex_folder: Option<&AbsolutePathBuf> = None;
|
||||
for (index, layer) in layers.iter().enumerate() {
|
||||
if matches!(layer.name, ConfigLayerSource::User { .. }) {
|
||||
user_layer_index = Some(index);
|
||||
let mut previous_user_layer: Option<&ConfigLayerSource> = None;
|
||||
let mut previous_project_layer: Option<(&AbsolutePathBuf, bool)> = None;
|
||||
for layer in layers {
|
||||
if let Some(previous) = previous_user_layer
|
||||
&& let (
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
ConfigLayerSource::User {
|
||||
file,
|
||||
profile: None,
|
||||
},
|
||||
) = (previous, &layer.name)
|
||||
&& user_base_file_has_sibling_override(file, override_file)
|
||||
{
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::InvalidData,
|
||||
"user layers are not ordered from config.toml to config.override.toml",
|
||||
));
|
||||
}
|
||||
if is_user_config_layer(&layer.name) {
|
||||
previous_user_layer = Some(&layer.name);
|
||||
}
|
||||
|
||||
if let ConfigLayerSource::Project {
|
||||
dot_codex_folder: current_project_dot_codex_folder,
|
||||
} = &layer.name
|
||||
let current_project_layer = match &layer.name {
|
||||
ConfigLayerSource::Project { dot_codex_folder } => Some((dot_codex_folder, false)),
|
||||
ConfigLayerSource::ProjectOverride { dot_codex_folder } => {
|
||||
Some((dot_codex_folder, true))
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
if let Some((current_project_dot_codex_folder, current_is_override)) = current_project_layer
|
||||
{
|
||||
if let Some(previous) = previous_project_dot_codex_folder {
|
||||
let Some(parent) = previous.as_path().parent() else {
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::InvalidData,
|
||||
"project layer has no parent directory",
|
||||
));
|
||||
};
|
||||
if previous == current_project_dot_codex_folder
|
||||
|| !current_project_dot_codex_folder
|
||||
if let Some((previous, previous_is_override)) = previous_project_layer {
|
||||
if previous == current_project_dot_codex_folder {
|
||||
if previous_is_override || !current_is_override {
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::InvalidData,
|
||||
"project layers are not ordered from config.toml to config.override.toml",
|
||||
));
|
||||
}
|
||||
} else {
|
||||
let Some(parent) = previous.as_path().parent() else {
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::InvalidData,
|
||||
"project layer has no parent directory",
|
||||
));
|
||||
};
|
||||
if !current_project_dot_codex_folder
|
||||
.as_path()
|
||||
.ancestors()
|
||||
.any(|ancestor| ancestor == parent)
|
||||
{
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::InvalidData,
|
||||
"project layers are not ordered from root to cwd",
|
||||
));
|
||||
{
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::InvalidData,
|
||||
"project layers are not ordered from root to cwd",
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
previous_project_dot_codex_folder = Some(current_project_dot_codex_folder);
|
||||
previous_project_layer = Some((current_project_dot_codex_folder, current_is_override));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(user_layer_index)
|
||||
Ok(active_user_layer_index(layers))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -90,6 +90,237 @@ approval_policy = "on-failure"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn effective_user_config_merges_user_override_after_base_layer() {
|
||||
let temp_dir = TempDir::new().expect("tempdir");
|
||||
let base_file = test_user_config_path(&temp_dir, "config.toml");
|
||||
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
|
||||
let stack = ConfigLayerStack::new(
|
||||
vec![
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: base_file,
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "base""#).expect("base config"),
|
||||
),
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
toml::from_str(r#"model = "override""#).expect("override config"),
|
||||
),
|
||||
],
|
||||
ConfigRequirements::default(),
|
||||
ConfigRequirementsToml::default(),
|
||||
)
|
||||
.expect("user override stack should be valid");
|
||||
|
||||
assert_eq!(
|
||||
stack
|
||||
.effective_user_config()
|
||||
.expect("merged user config")
|
||||
.get("model")
|
||||
.and_then(toml::Value::as_str),
|
||||
Some("override")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_user_config_preserves_user_override_precedence() {
|
||||
let temp_dir = TempDir::new().expect("tempdir");
|
||||
let base_file = test_user_config_path(&temp_dir, "config.toml");
|
||||
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
|
||||
let stack = ConfigLayerStack::new(
|
||||
vec![
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: base_file.clone(),
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "base""#).expect("base config"),
|
||||
),
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
toml::from_str(r#"model = "override""#).expect("override config"),
|
||||
),
|
||||
],
|
||||
ConfigRequirements::default(),
|
||||
ConfigRequirementsToml::default(),
|
||||
)
|
||||
.expect("user override stack should be valid");
|
||||
|
||||
let updated = stack.with_user_config(
|
||||
&base_file,
|
||||
toml::from_str(r#"model = "updated-base""#).expect("updated base config"),
|
||||
);
|
||||
|
||||
let user_layers = updated
|
||||
.get_user_layers(
|
||||
ConfigLayerStackOrdering::LowestPrecedenceFirst,
|
||||
/*include_disabled*/ false,
|
||||
)
|
||||
.into_iter()
|
||||
.map(|layer| layer.name.clone())
|
||||
.collect::<Vec<_>>();
|
||||
assert!(matches!(
|
||||
user_layers.as_slice(),
|
||||
[
|
||||
ConfigLayerSource::User { .. },
|
||||
ConfigLayerSource::UserOverride { .. },
|
||||
]
|
||||
));
|
||||
assert_eq!(
|
||||
updated
|
||||
.effective_user_config()
|
||||
.expect("merged user config")
|
||||
.get("model")
|
||||
.and_then(toml::Value::as_str),
|
||||
Some("override")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_user_config_preserves_selected_non_profile_user_precedence() {
|
||||
let temp_dir = TempDir::new().expect("tempdir");
|
||||
let base_file = test_user_config_path(&temp_dir, "config.toml");
|
||||
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
|
||||
let selected_file = test_user_config_path(&temp_dir, "selected.toml");
|
||||
let stack = ConfigLayerStack::new(
|
||||
vec![
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: base_file,
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "base""#).expect("base config"),
|
||||
),
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
toml::from_str(r#"model = "override""#).expect("override config"),
|
||||
),
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: selected_file.clone(),
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "selected""#).expect("selected config"),
|
||||
),
|
||||
],
|
||||
ConfigRequirements::default(),
|
||||
ConfigRequirementsToml::default(),
|
||||
)
|
||||
.expect("selected user stack should be valid");
|
||||
|
||||
let updated = stack.with_user_config(
|
||||
&selected_file,
|
||||
toml::from_str(r#"model = "selected-updated""#).expect("updated selected config"),
|
||||
);
|
||||
assert_eq!(
|
||||
updated
|
||||
.effective_user_config()
|
||||
.expect("merged user config")
|
||||
.get("model")
|
||||
.and_then(toml::Value::as_str),
|
||||
Some("selected-updated")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_user_override_config_preserves_selected_non_profile_user_precedence() {
|
||||
let temp_dir = TempDir::new().expect("tempdir");
|
||||
let base_file = test_user_config_path(&temp_dir, "config.toml");
|
||||
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
|
||||
let selected_file = test_user_config_path(&temp_dir, "selected.toml");
|
||||
let stack = ConfigLayerStack::new(
|
||||
vec![
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: base_file,
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "base""#).expect("base config"),
|
||||
),
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: selected_file,
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "selected""#).expect("selected config"),
|
||||
),
|
||||
],
|
||||
ConfigRequirements::default(),
|
||||
ConfigRequirementsToml::default(),
|
||||
)
|
||||
.expect("selected user stack should be valid");
|
||||
|
||||
let updated = stack.with_user_override_config(
|
||||
&override_file,
|
||||
toml::from_str(r#"model = "override""#).expect("override config"),
|
||||
);
|
||||
|
||||
let user_layers = updated
|
||||
.get_user_layers(
|
||||
ConfigLayerStackOrdering::LowestPrecedenceFirst,
|
||||
/*include_disabled*/ false,
|
||||
)
|
||||
.into_iter()
|
||||
.map(|layer| layer.name.clone())
|
||||
.collect::<Vec<_>>();
|
||||
assert!(matches!(
|
||||
user_layers.as_slice(),
|
||||
[
|
||||
ConfigLayerSource::User { .. },
|
||||
ConfigLayerSource::UserOverride { .. },
|
||||
ConfigLayerSource::User { .. },
|
||||
]
|
||||
));
|
||||
assert_eq!(
|
||||
updated
|
||||
.effective_user_config()
|
||||
.expect("merged user config")
|
||||
.get("model")
|
||||
.and_then(toml::Value::as_str),
|
||||
Some("selected")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stack_rejects_base_user_config_after_sibling_override() {
|
||||
let temp_dir = TempDir::new().expect("tempdir");
|
||||
let base_file = test_user_config_path(&temp_dir, "config.toml");
|
||||
let override_file = test_user_config_path(&temp_dir, "config.override.toml");
|
||||
let err = ConfigLayerStack::new(
|
||||
vec![
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::UserOverride {
|
||||
file: override_file,
|
||||
},
|
||||
toml::from_str(r#"model = "override""#).expect("override config"),
|
||||
),
|
||||
ConfigLayerEntry::new(
|
||||
ConfigLayerSource::User {
|
||||
file: base_file,
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str(r#"model = "base""#).expect("base config"),
|
||||
),
|
||||
],
|
||||
ConfigRequirements::default(),
|
||||
ConfigRequirementsToml::default(),
|
||||
)
|
||||
.expect_err("base user config should not follow its sibling override");
|
||||
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"user layers are not ordered from config.toml to config.override.toml"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_user_config_updates_matching_user_layer_without_replacing_active_profile() {
|
||||
let temp_dir = TempDir::new().expect("tempdir");
|
||||
|
||||
Reference in New Issue
Block a user