mirror of
https://github.com/openai/codex.git
synced 2026-11-16 22:00:36 +00:00
Restrict enterprise MCP auth and fail closed on config refresh (#49260)
## Why Configuration reloads must honor current managed restrictions without granting new enterprise MCP authority to existing sessions or overwriting newer configuration with stale snapshots. ## What changed - Allow enterprise managed authentication only for configured MCP servers. Remove plugin `ema_auth` overlays from the schema and disable servers that still use them. - Refresh ordinary MCP settings while preserving session settings and initially admitted enterprise registrations. Disable enterprise MCP when its registration changes, policy revokes access, or configuration loading or resolution fails; require a new session to restore enterprise authority. - Publish refreshes only when their captured configuration is still current, with bounded retries in app-server reloads. Preserve updated managed restrictions even when a refresh is rejected. - Finish processing other thread refreshes before `config/mcpServer/reload` reports a rejection, and document that an error can accompany partially applied changes. ## Testing Add regression coverage for stale refreshes, bounded retries, managed-policy revocation, persistent enterprise disablement, ordinary MCP transport changes, and rejection of plugin enterprise authentication. Verify that denied enterprise servers receive no requests. GitOrigin-RevId: 34429cd339c1ec152a2ee8697cb29f0cff5d9e5f
This commit is contained in:
@@ -161,6 +161,18 @@ pub struct CodexThreadSettingsOverrides {
|
||||
pub disabled_plugin_ids: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
/// Result of publishing a loaded configuration snapshot for a thread.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
#[must_use]
|
||||
pub enum ConfigRefreshOutcome {
|
||||
/// The resolved configuration was published.
|
||||
Published,
|
||||
/// The captured owner changed; the caller must reload before retrying.
|
||||
Stale,
|
||||
/// Resolution failed and a configuration disabling enterprise MCP was published.
|
||||
Rejected,
|
||||
}
|
||||
|
||||
pub use codex_guardian_context::GuardianRootMessage;
|
||||
|
||||
/// Authorization state that changes on genuine user input or history resets.
|
||||
@@ -985,14 +997,36 @@ impl CodexThread {
|
||||
|
||||
/// Refresh the thread's layer-backed user config state from a caller-supplied
|
||||
/// config snapshot. Thread-scoped layers and session-static settings remain
|
||||
/// unchanged.
|
||||
pub async fn refresh_runtime_config(&self, next_config: crate::config::Config) {
|
||||
self.session.refresh_runtime_config(next_config).await;
|
||||
/// unchanged. A stale owner requires reloading from the current config before retrying.
|
||||
pub async fn refresh_runtime_config(
|
||||
&self,
|
||||
expected_config: Arc<crate::config::Config>,
|
||||
next_config: crate::config::Config,
|
||||
) -> ConfigRefreshOutcome {
|
||||
Box::pin(
|
||||
self.session
|
||||
.refresh_runtime_config(expected_config, next_config),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
/// Revokes enterprise MCP authority from the current owner after a failed reload.
|
||||
pub async fn disable_mcp_enterprise_auth(&self) {
|
||||
self.session.disable_mcp_enterprise_auth().await;
|
||||
}
|
||||
|
||||
/// Refresh MCP configuration and managed requirements without reloading unrelated settings.
|
||||
pub async fn refresh_mcp_config(&self, next_config: crate::config::Config) {
|
||||
self.session.refresh_mcp_config(next_config).await;
|
||||
/// A stale owner requires reloading from the current config before retrying.
|
||||
pub async fn refresh_mcp_config(
|
||||
&self,
|
||||
expected_config: Arc<crate::config::Config>,
|
||||
next_config: crate::config::Config,
|
||||
) -> ConfigRefreshOutcome {
|
||||
Box::pin(
|
||||
self.session
|
||||
.refresh_mcp_config(expected_config, next_config),
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
/// Refreshes this thread's Apps tools before returning their runtime state.
|
||||
|
||||
@@ -143,9 +143,10 @@ async fn local_compaction_respects_tool_metadata_state(
|
||||
assert!(metadata_bytes > 2 * 1024 * 1024);
|
||||
|
||||
if !metadata_enabled {
|
||||
let mut config = (*session.get_config().await).clone();
|
||||
let current_config = session.get_config().await;
|
||||
let mut config = current_config.as_ref().clone();
|
||||
config.features.disable(Feature::ExecutedToolCallMetadata)?;
|
||||
session.refresh_runtime_config(config).await;
|
||||
let _ = session.refresh_runtime_config(current_config, config).await;
|
||||
}
|
||||
|
||||
let mock = responses::mount_sse_once(
|
||||
|
||||
@@ -118,6 +118,28 @@ impl ManagedFeatures {
|
||||
self.set(next)
|
||||
}
|
||||
|
||||
/// Refresh ordinary MCP feature values and pins without changing session-static features.
|
||||
pub(crate) fn refresh_mcp_features(&mut self, next: &Self) -> ConstraintResult<()> {
|
||||
let mut refreshed = self.clone();
|
||||
let mut values = self.get().clone();
|
||||
for feature in [
|
||||
Feature::EnableMcpApps,
|
||||
Feature::SecretAuthStorage,
|
||||
Feature::McpOAuthRefreshCoordination,
|
||||
] {
|
||||
values.set_enabled(feature, next.enabled(feature));
|
||||
if let Some(enabled) = next.pinned_features.get(&feature) {
|
||||
refreshed.pinned_features.insert(feature, *enabled);
|
||||
} else {
|
||||
refreshed.pinned_features.remove(&feature);
|
||||
}
|
||||
}
|
||||
refreshed.value.source = next.value.source.clone().or(refreshed.value.source);
|
||||
refreshed.set(values)?;
|
||||
*self = refreshed;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn enable(&mut self, feature: Feature) -> ConstraintResult<()> {
|
||||
self.set_enabled(feature, /*enabled*/ true)
|
||||
}
|
||||
|
||||
@@ -176,6 +176,8 @@ mod permission_profile_selection;
|
||||
mod permissions;
|
||||
mod requirements;
|
||||
mod resolved_permission_profile;
|
||||
mod runtime_refresh;
|
||||
pub(crate) use runtime_refresh::RuntimeConfigRefresh;
|
||||
#[cfg(test)]
|
||||
mod schema;
|
||||
mod token_budget_startup;
|
||||
|
||||
@@ -0,0 +1,171 @@
|
||||
//! Resolves refreshable MCP inputs without rebuilding unrelated session configuration.
|
||||
//! Existing sessions refresh ordinary MCP state without gaining enterprise authority.
|
||||
|
||||
use crate::config::Config;
|
||||
use crate::config::ManagedFeatures;
|
||||
use crate::config::constrain_mcp_servers;
|
||||
use crate::config::resolve_tool_suggest_config_from_layer_stack;
|
||||
use codex_config::McpServerAuth;
|
||||
use codex_config::McpServerConfig;
|
||||
use codex_features::Feature;
|
||||
use codex_features::FeatureConfigSource;
|
||||
use codex_features::FeatureOverrides;
|
||||
use codex_features::Features;
|
||||
use codex_features::FeaturesToml;
|
||||
use serde::Deserialize;
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "runtime_refresh_tests.rs"]
|
||||
mod tests;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub(crate) enum RuntimeConfigRefresh {
|
||||
User,
|
||||
Mcp,
|
||||
}
|
||||
|
||||
#[derive(Default, Deserialize)]
|
||||
#[serde(default)]
|
||||
struct McpRefreshToml {
|
||||
features: Option<FeaturesToml>,
|
||||
}
|
||||
|
||||
impl Config {
|
||||
pub(crate) fn resolve_runtime_refresh(
|
||||
&self,
|
||||
incoming: &Self,
|
||||
scope: RuntimeConfigRefresh,
|
||||
) -> std::io::Result<Self> {
|
||||
let layers = match scope {
|
||||
RuntimeConfigRefresh::User => self
|
||||
.config_layer_stack
|
||||
.with_user_layer_from(&incoming.config_layer_stack),
|
||||
RuntimeConfigRefresh::Mcp => Self::layer_stack_preserving_session(
|
||||
&self.config_layer_stack,
|
||||
&incoming.config_layer_stack,
|
||||
)?
|
||||
.with_user_layer_from(&self.config_layer_stack),
|
||||
};
|
||||
let cfg: McpRefreshToml = layers
|
||||
.effective_config()
|
||||
.try_into()
|
||||
.map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err))?;
|
||||
let mut configured_features = Features::from_sources(
|
||||
FeatureConfigSource {
|
||||
features: cfg.features.as_ref(),
|
||||
..Default::default()
|
||||
},
|
||||
FeatureConfigSource::default(),
|
||||
FeatureOverrides::default(),
|
||||
);
|
||||
// These existing operational controls also accept host runtime overrides.
|
||||
// Enterprise opt-in always comes from trusted layers instead.
|
||||
for feature in [
|
||||
Feature::SecretAuthStorage,
|
||||
Feature::McpOAuthRefreshCoordination,
|
||||
] {
|
||||
// A publication wait may have allowed a newer host/user override.
|
||||
configured_features.set_enabled(feature, incoming.features.enabled(feature));
|
||||
}
|
||||
let features = ManagedFeatures::from_configured(
|
||||
configured_features,
|
||||
layers.requirements().feature_requirements.clone(),
|
||||
)?;
|
||||
let is_enterprise = |server: &McpServerConfig| {
|
||||
matches!(server.auth, McpServerAuth::EmaAuth) || server.ema_registration().is_some()
|
||||
};
|
||||
// Refresh ordinary servers from the complete host-owned set. Keep the
|
||||
// initially admitted EMA configuration until a fresh session is constructed.
|
||||
let mut servers: HashMap<_, _> = incoming
|
||||
.mcp_servers
|
||||
.get()
|
||||
.iter()
|
||||
.filter(|(name, server)| {
|
||||
!is_enterprise(server)
|
||||
&& !self.mcp_servers.get().get(*name).is_some_and(is_enterprise)
|
||||
})
|
||||
.map(|(name, server)| (name.clone(), server.clone()))
|
||||
.collect();
|
||||
servers.extend(
|
||||
self.mcp_servers
|
||||
.get()
|
||||
.iter()
|
||||
.filter(|(_, server)| is_enterprise(server))
|
||||
.map(|(name, server)| (name.clone(), server.clone())),
|
||||
);
|
||||
let mut config = self.clone();
|
||||
config
|
||||
.features
|
||||
.refresh_mcp_features(&features)
|
||||
.map_err(std::io::Error::other)?;
|
||||
config.mcp_servers =
|
||||
constrain_mcp_servers(servers, layers.requirements().mcp_servers.as_ref())
|
||||
.map_err(std::io::Error::other)?;
|
||||
// A missing profile also carries the host's fail-closed load result.
|
||||
let enterprise_retired = incoming.mcp_enterprise_managed_auth.is_none()
|
||||
|| !incoming.features.enabled(Feature::UseXaa)
|
||||
|| (self
|
||||
.mcp_servers
|
||||
.get()
|
||||
.values()
|
||||
.any(|server| is_enterprise(server) && server.enabled)
|
||||
&& incoming.mcp_enterprise_managed_auth != self.mcp_enterprise_managed_auth)
|
||||
|| self.mcp_servers.get().iter().any(|(name, server)| {
|
||||
is_enterprise(server)
|
||||
&& server.enabled
|
||||
&& !incoming
|
||||
.mcp_servers
|
||||
.get()
|
||||
.get(name)
|
||||
.is_some_and(|incoming| {
|
||||
incoming.enabled
|
||||
&& incoming.auth == server.auth
|
||||
&& incoming.transport == server.transport
|
||||
&& incoming.oauth_resource == server.oauth_resource
|
||||
&& incoming.oauth == server.oauth
|
||||
&& incoming.scopes == server.scopes
|
||||
&& incoming.environment_id == server.environment_id
|
||||
&& incoming.ema_registration() == server.ema_registration()
|
||||
})
|
||||
})
|
||||
|| self.mcp_servers.get().iter().any(|(name, server)| {
|
||||
is_enterprise(server)
|
||||
&& server.enabled
|
||||
&& !config
|
||||
.mcp_servers
|
||||
.get()
|
||||
.get(name)
|
||||
.is_some_and(|server| server.enabled)
|
||||
});
|
||||
config.mcp_optional_startup_grace = incoming.mcp_optional_startup_grace;
|
||||
config.mcp_oauth_credentials_store_mode = incoming.mcp_oauth_credentials_store_mode;
|
||||
if !matches!(scope, RuntimeConfigRefresh::Mcp) {
|
||||
config.active_project = incoming.active_project.clone();
|
||||
config.tool_suggest = resolve_tool_suggest_config_from_layer_stack(&layers);
|
||||
}
|
||||
config.config_layer_stack = layers;
|
||||
if enterprise_retired {
|
||||
config.disable_mcp_enterprise_auth();
|
||||
}
|
||||
Ok(config)
|
||||
}
|
||||
|
||||
/// Disables enterprise MCP authorization while preserving unrelated MCP servers.
|
||||
pub fn disable_mcp_enterprise_auth(&mut self) {
|
||||
self.mcp_enterprise_managed_auth = None;
|
||||
let mut servers = self.mcp_servers.get().clone();
|
||||
for server in servers.values_mut() {
|
||||
if matches!(server.auth, McpServerAuth::EmaAuth) || server.ema_registration().is_some()
|
||||
{
|
||||
server.enabled = false;
|
||||
if let Some(oauth) = &mut server.oauth {
|
||||
oauth.ema_registration = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
if self.mcp_servers.set(servers).is_err() {
|
||||
tracing::warn!("failed to clear disabled enterprise registrations");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
//! Ordinary refresh resolution and enterprise revocation without Session construction.
|
||||
|
||||
use super::*;
|
||||
use crate::config::ConfigBuilder;
|
||||
use codex_config::CONFIG_TOML_FILE;
|
||||
use codex_config::ConfigLayerSource;
|
||||
use codex_config::test_support::CloudConfigBundleFixture;
|
||||
use codex_core_plugins::PluginLoadOutcome;
|
||||
use pretty_assertions::assert_eq;
|
||||
|
||||
async fn base_config() -> (tempfile::TempDir, Config) {
|
||||
let home = tempfile::tempdir().unwrap();
|
||||
let config = ConfigBuilder::without_managed_config_for_tests()
|
||||
.codex_home(home.path().to_path_buf())
|
||||
.fallback_cwd(Some(home.path().to_path_buf()))
|
||||
.build()
|
||||
.await
|
||||
.unwrap();
|
||||
(home, config)
|
||||
}
|
||||
|
||||
async fn layered_config(
|
||||
base: &Config,
|
||||
user: &str,
|
||||
managed: &str,
|
||||
requirements: &str,
|
||||
session: &str,
|
||||
) -> Config {
|
||||
std::fs::write(base.codex_home.join(CONFIG_TOML_FILE), user).unwrap();
|
||||
let overrides: toml::Table = toml::from_str(session).unwrap();
|
||||
ConfigBuilder::without_managed_config_for_tests()
|
||||
.codex_home(base.codex_home.to_path_buf())
|
||||
.fallback_cwd(Some(base.cwd.to_path_buf()))
|
||||
.cli_overrides(overrides.into_iter().collect())
|
||||
.cloud_config_bundle(
|
||||
CloudConfigBundleFixture::enterprise_config(managed)
|
||||
.add_enterprise_requirement(format!("[features]\n{requirements}"))
|
||||
.into_loader(),
|
||||
)
|
||||
.build()
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn enterprise_config(issuer: &str, resource: &str) -> String {
|
||||
format!(
|
||||
"[features]\nuse_xaa = true\napps = false\nsecret_auth_storage = false\n\
|
||||
[mcp_servers.enterprise]\nurl = 'https://resource.example/mcp'\nauth = 'ema_auth'\n\
|
||||
oauth_resource = '{resource}'\n\
|
||||
[mcp_enterprise_managed_auth.idp]\nissuer = '{issuer}'\nclient_id = '{issuer}-client'\n"
|
||||
)
|
||||
}
|
||||
|
||||
fn runtime_servers(config: &Config) -> HashMap<String, McpServerConfig> {
|
||||
codex_mcp::configured_mcp_servers(
|
||||
&config.to_mcp_config_with_loaded_plugins(&PluginLoadOutcome::default(), []),
|
||||
)
|
||||
}
|
||||
|
||||
#[test_case::test_case(RuntimeConfigRefresh::User; "user refresh")]
|
||||
#[test_case::test_case(RuntimeConfigRefresh::Mcp; "MCP refresh")]
|
||||
#[tokio::test]
|
||||
async fn refresh_honors_fresh_managed_denial(scope: RuntimeConfigRefresh) {
|
||||
let (_home, base) = base_config().await;
|
||||
let enterprise = enterprise_config("https://idp.example", "resource");
|
||||
let current = layered_config(&base, &enterprise, "", "use_xaa = true", "").await;
|
||||
let next = layered_config(&base, &enterprise, "", "use_xaa = false", "").await;
|
||||
let refreshed = current.resolve_runtime_refresh(&next, scope).unwrap();
|
||||
assert!(!runtime_servers(&refreshed)["enterprise"].enabled);
|
||||
assert!(refreshed.mcp_enterprise_managed_auth.is_none());
|
||||
assert_eq!(refreshed.model, current.model);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn refresh_honors_disabled_enterprise_host_load_result() {
|
||||
let (_home, base) = base_config().await;
|
||||
let current = layered_config(
|
||||
&base,
|
||||
&enterprise_config("https://idp.example", "resource"),
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
)
|
||||
.await;
|
||||
let mut failed = current.clone();
|
||||
failed.disable_mcp_enterprise_auth();
|
||||
let refreshed = current
|
||||
.resolve_runtime_refresh(&failed, RuntimeConfigRefresh::Mcp)
|
||||
.unwrap();
|
||||
assert!(refreshed.mcp_enterprise_managed_auth.is_none());
|
||||
assert!(!runtime_servers(&refreshed)["enterprise"].enabled);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ordinary_transport_transitions_use_the_resolved_incoming_map() {
|
||||
let (_home, base) = base_config().await;
|
||||
let command = "[mcp_servers.ordinary]\ncommand = 'ordinary-server'";
|
||||
let url = "[mcp_servers.ordinary]\nurl = 'https://ordinary.example/mcp'";
|
||||
for scope in [RuntimeConfigRefresh::User, RuntimeConfigRefresh::Mcp] {
|
||||
let (current, incoming) = match scope {
|
||||
RuntimeConfigRefresh::User => (
|
||||
layered_config(&base, "", "", "", url).await,
|
||||
layered_config(&base, command, "", "", "").await,
|
||||
),
|
||||
RuntimeConfigRefresh::Mcp => (
|
||||
layered_config(&base, command, "", "", "").await,
|
||||
layered_config(&base, "", url, "", "").await,
|
||||
),
|
||||
};
|
||||
let refreshed = current.resolve_runtime_refresh(&incoming, scope).unwrap();
|
||||
assert_eq!(refreshed.mcp_servers.get(), incoming.mcp_servers.get());
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_refresh_preserves_current_user_and_session_layers_without_reopening_ema() {
|
||||
let (_home, base) = base_config().await;
|
||||
let current = layered_config(
|
||||
&base,
|
||||
&enterprise_config("https://current-idp.example", "current-resource"),
|
||||
"",
|
||||
"",
|
||||
"[mcp_servers.enterprise]\nenabled = false",
|
||||
)
|
||||
.await;
|
||||
let next = layered_config(
|
||||
&base,
|
||||
&enterprise_config("https://old-idp.example", "old-resource"),
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
)
|
||||
.await;
|
||||
let refreshed = current
|
||||
.resolve_runtime_refresh(&next, RuntimeConfigRefresh::Mcp)
|
||||
.unwrap();
|
||||
let preserved_layers = |config: &Config| {
|
||||
config
|
||||
.config_layer_stack
|
||||
.all_layers_low_to_high()
|
||||
.filter(|layer| {
|
||||
matches!(
|
||||
layer.name,
|
||||
ConfigLayerSource::User { .. } | ConfigLayerSource::SessionFlags
|
||||
)
|
||||
})
|
||||
.cloned()
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
assert_eq!(preserved_layers(&refreshed), preserved_layers(¤t));
|
||||
let server = &runtime_servers(&refreshed)["enterprise"];
|
||||
assert!(!server.enabled);
|
||||
assert_eq!(
|
||||
server.ema_registration(),
|
||||
runtime_servers(¤t)["enterprise"].ema_registration()
|
||||
);
|
||||
}
|
||||
|
||||
#[test_case::test_case("removed"; "removed")]
|
||||
#[test_case::test_case("disabled"; "disabled")]
|
||||
#[test_case::test_case("resource"; "resource changed")]
|
||||
#[test_case::test_case("transport"; "transport changed")]
|
||||
#[test_case::test_case("scopes"; "scopes changed")]
|
||||
#[test_case::test_case("oauth"; "OAuth client changed")]
|
||||
#[test_case::test_case("idp"; "IdP changed")]
|
||||
#[tokio::test]
|
||||
async fn refresh_revokes_changed_enterprise_admission(change: &str) {
|
||||
let (_home, base) = base_config().await;
|
||||
let current = layered_config(
|
||||
&base,
|
||||
&enterprise_config("https://idp.example", "resource"),
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
)
|
||||
.await;
|
||||
let mut incoming = current.clone();
|
||||
let mut servers = incoming.mcp_servers.get().clone();
|
||||
match change {
|
||||
"removed" => {
|
||||
servers.remove("enterprise");
|
||||
}
|
||||
"disabled" => servers.get_mut("enterprise").unwrap().enabled = false,
|
||||
"resource" => servers.get_mut("enterprise").unwrap().oauth_resource = Some("other".into()),
|
||||
"scopes" => servers.get_mut("enterprise").unwrap().scopes = Some(vec!["other".into()]),
|
||||
"oauth" => {
|
||||
servers
|
||||
.get_mut("enterprise")
|
||||
.unwrap()
|
||||
.oauth
|
||||
.get_or_insert_default()
|
||||
.client_id = Some("other-client".into())
|
||||
}
|
||||
"idp" => {
|
||||
incoming
|
||||
.mcp_enterprise_managed_auth
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.idp
|
||||
.client_id = "other-client".into()
|
||||
}
|
||||
"transport" => {
|
||||
let codex_config::McpServerTransportConfig::StreamableHttp { url, .. } =
|
||||
&mut servers.get_mut("enterprise").unwrap().transport
|
||||
else {
|
||||
unreachable!()
|
||||
};
|
||||
*url = "https://other.example/mcp".into();
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
incoming.mcp_servers.set(servers).unwrap();
|
||||
for scope in [RuntimeConfigRefresh::User, RuntimeConfigRefresh::Mcp] {
|
||||
let revoked = current.resolve_runtime_refresh(&incoming, scope).unwrap();
|
||||
assert!(revoked.mcp_enterprise_managed_auth.is_none());
|
||||
assert!(!runtime_servers(&revoked)["enterprise"].enabled);
|
||||
let restored = revoked.resolve_runtime_refresh(¤t, scope).unwrap();
|
||||
assert!(restored.mcp_enterprise_managed_auth.is_none());
|
||||
assert!(!runtime_servers(&restored)["enterprise"].enabled);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn mcp_refresh_preserves_apps_until_new_session() {
|
||||
let (_home, base) = base_config().await;
|
||||
let current = layered_config(&base, "[features]\napps = true", "", "", "").await;
|
||||
let next = layered_config(&base, "[features]\napps = true", "", "apps = false", "").await;
|
||||
let refreshed = current
|
||||
.resolve_runtime_refresh(&next, RuntimeConfigRefresh::Mcp)
|
||||
.unwrap();
|
||||
assert!(refreshed.features.enabled(Feature::Apps));
|
||||
let reloaded = refreshed
|
||||
.resolve_runtime_refresh(&next, RuntimeConfigRefresh::User)
|
||||
.unwrap();
|
||||
assert!(reloaded.features.enabled(Feature::Apps));
|
||||
assert!(!next.features.enabled(Feature::Apps));
|
||||
}
|
||||
@@ -3449,7 +3449,8 @@ async fn guardian_review_routes_required_actions(
|
||||
| RequiredGuardianReview::LiveManagedModelWithGuardianV2 => {
|
||||
Arc::make_mut(&mut context.model_info).slug = "required-action-model".to_string();
|
||||
// The admitted turn has neither this model nor the new requirement.
|
||||
let mut config = session.get_config().await.as_ref().clone();
|
||||
let current_config = session.get_config().await;
|
||||
let mut config = current_config.as_ref().clone();
|
||||
let requirements = codex_config::ConfigRequirements {
|
||||
auto_review_required_models: Some(Sourced::new(
|
||||
std::collections::BTreeSet::from([context.model_info.slug.clone()]),
|
||||
@@ -3466,7 +3467,7 @@ async fn guardian_review_routes_required_actions(
|
||||
requirements,
|
||||
config.config_layer_stack.requirements_toml().clone(),
|
||||
)?;
|
||||
session.refresh_mcp_config(config).await;
|
||||
let _ = session.refresh_mcp_config(current_config, config).await;
|
||||
(
|
||||
guardian_exec_command_request("shell-live-managed-model"),
|
||||
ApprovalRequestReasons::default(),
|
||||
|
||||
@@ -47,6 +47,7 @@ pub use codex_protocol::protocol::EnvironmentConfig;
|
||||
pub use codex_thread::BackgroundTerminalInfo;
|
||||
pub use codex_thread::CodexThread;
|
||||
pub use codex_thread::CodexThreadSettingsOverrides;
|
||||
pub use codex_thread::ConfigRefreshOutcome;
|
||||
pub use codex_thread::GuardianAuthorizationVersion;
|
||||
pub use codex_thread::GuardianRootMessage;
|
||||
pub use codex_thread::GuardianRootSnapshot;
|
||||
|
||||
@@ -0,0 +1,147 @@
|
||||
//! Publishes resolved MCP configuration while preserving session-static settings.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use crate::ConfigRefreshOutcome;
|
||||
use crate::config::Config;
|
||||
use crate::config::Constrained;
|
||||
use crate::config::RuntimeConfigRefresh;
|
||||
use crate::session::Session;
|
||||
use codex_config::McpServerAuth;
|
||||
use codex_features::Feature;
|
||||
use tracing::warn;
|
||||
|
||||
impl Session {
|
||||
pub(crate) async fn disable_mcp_enterprise_auth(&self) {
|
||||
let mut state = self.state.lock().await;
|
||||
let mut config = state
|
||||
.session_configuration
|
||||
.original_config_do_not_use
|
||||
.as_ref()
|
||||
.clone();
|
||||
config.disable_mcp_enterprise_auth();
|
||||
state.session_configuration.original_config_do_not_use = Arc::new(config);
|
||||
self.services.mcp_runtime.invalidate_resource_caches();
|
||||
self.mark_mcp_runtime_dirty();
|
||||
drop(state);
|
||||
self.schedule_mcp_prewarm();
|
||||
}
|
||||
|
||||
pub(crate) async fn refresh_runtime_config(
|
||||
&self,
|
||||
expected_config: Arc<Config>,
|
||||
next_config: Config,
|
||||
) -> ConfigRefreshOutcome {
|
||||
self.refresh_config(expected_config, next_config, RuntimeConfigRefresh::User)
|
||||
.await
|
||||
}
|
||||
|
||||
pub(crate) async fn refresh_mcp_config(
|
||||
&self,
|
||||
expected_config: Arc<Config>,
|
||||
next_config: Config,
|
||||
) -> ConfigRefreshOutcome {
|
||||
self.refresh_config(expected_config, next_config, RuntimeConfigRefresh::Mcp)
|
||||
.await
|
||||
}
|
||||
|
||||
pub(super) async fn refresh_config(
|
||||
&self,
|
||||
expected_config: Arc<Config>,
|
||||
next_config: Config,
|
||||
scope: RuntimeConfigRefresh,
|
||||
) -> ConfigRefreshOutcome {
|
||||
let (mut config, outcome, rejection_kind) =
|
||||
match expected_config.resolve_runtime_refresh(&next_config, scope) {
|
||||
Ok(config) => (config, ConfigRefreshOutcome::Published, None),
|
||||
Err(error) => {
|
||||
let mut config = expected_config.as_ref().clone();
|
||||
if matches!(scope, RuntimeConfigRefresh::Mcp) {
|
||||
// The host-resolved map already carries fresh requirements and
|
||||
// preserved session overrides. Keep ordinary-server revocations even
|
||||
// when retained layers make the enterprise merge invalid.
|
||||
let mut refreshed_servers = next_config.mcp_servers.clone();
|
||||
let mut servers = refreshed_servers.get().clone();
|
||||
// Retain enterprise identities so a later corrected refresh cannot
|
||||
// admit an ordinary-auth replacement under a retired server's name.
|
||||
for (name, server) in expected_config.mcp_servers.get() {
|
||||
if matches!(server.auth, McpServerAuth::EmaAuth)
|
||||
|| server.ema_registration().is_some()
|
||||
{
|
||||
let mut retired = server.clone();
|
||||
retired.enabled = false;
|
||||
servers.insert(name.clone(), retired);
|
||||
}
|
||||
}
|
||||
config.mcp_servers = if refreshed_servers.set(servers).is_ok() {
|
||||
refreshed_servers
|
||||
} else {
|
||||
Constrained::allow_any(Default::default())
|
||||
};
|
||||
}
|
||||
config.config_layer_stack = config
|
||||
.config_layer_stack
|
||||
.with_mcp_requirements_from(&next_config.config_layer_stack);
|
||||
if let Err(err) = config.features.refresh_mcp_features(&next_config.features) {
|
||||
warn!(%err, "failed to apply managed MCP feature restrictions");
|
||||
config.mcp_servers = Constrained::allow_any(Default::default());
|
||||
}
|
||||
config.disable_mcp_enterprise_auth();
|
||||
(config, ConfigRefreshOutcome::Rejected, Some(error.kind()))
|
||||
}
|
||||
};
|
||||
for (feature, description) in [
|
||||
(Feature::Mcp20260728, "MCP protocol"),
|
||||
(Feature::CodexAppsMcp20260728, "Codex Apps MCP protocol"),
|
||||
] {
|
||||
if let Err(err) = config
|
||||
.features
|
||||
.set_enabled(feature, next_config.features.enabled(feature))
|
||||
{
|
||||
warn!("failed to refresh {description} config: {err}");
|
||||
}
|
||||
}
|
||||
let config = Arc::new(config);
|
||||
let notify_contributors = !matches!(scope, RuntimeConfigRefresh::Mcp)
|
||||
&& !self.services.extensions.config_contributors().is_empty();
|
||||
let (previous_config, new_config) = {
|
||||
let mut state = self.state.lock().await;
|
||||
// Loaded snapshots can publish only while their captured owner is current.
|
||||
if !Arc::ptr_eq(
|
||||
&state.session_configuration.original_config_do_not_use,
|
||||
&expected_config,
|
||||
) {
|
||||
return ConfigRefreshOutcome::Stale;
|
||||
}
|
||||
if let Some(rejection_kind) = rejection_kind {
|
||||
warn!(
|
||||
?rejection_kind,
|
||||
"disabling enterprise MCP after rejected configuration refresh"
|
||||
);
|
||||
}
|
||||
// A host refresh carries current rollout settings for recording. A
|
||||
// legacy file reload uses its original snapshot and bypasses this path.
|
||||
if matches!(scope, RuntimeConfigRefresh::User) {
|
||||
self.services
|
||||
.executed_tool_calls
|
||||
.refresh(&next_config.features);
|
||||
}
|
||||
let previous_config = notify_contributors
|
||||
.then(|| self.build_effective_session_config(&state.session_configuration));
|
||||
state.session_configuration.original_config_do_not_use = Arc::clone(&config);
|
||||
if matches!(scope, RuntimeConfigRefresh::Mcp) {
|
||||
self.services.mcp_runtime.invalidate_resource_caches();
|
||||
}
|
||||
self.mark_mcp_runtime_dirty();
|
||||
let new_config = notify_contributors
|
||||
.then(|| self.build_effective_session_config(&state.session_configuration));
|
||||
(previous_config, new_config)
|
||||
};
|
||||
self.emit_config_changed_contributors(previous_config.as_ref(), new_config.as_ref());
|
||||
self.schedule_mcp_prewarm();
|
||||
if !matches!(scope, RuntimeConfigRefresh::Mcp) {
|
||||
self.refresh_hooks(config).await;
|
||||
}
|
||||
outcome
|
||||
}
|
||||
}
|
||||
@@ -238,7 +238,7 @@ pub fn refresh_mcp_servers(sess: &Session) {
|
||||
}
|
||||
|
||||
pub async fn reload_user_config(sess: &Arc<Session>) {
|
||||
sess.reload_user_config_layer().await;
|
||||
Box::pin(sess.reload_user_config_layer()).await;
|
||||
}
|
||||
|
||||
pub async fn compact(sess: &Arc<Session>, sub_id: String) {
|
||||
|
||||
@@ -228,6 +228,7 @@ use codex_protocol::error::Result as CodexResult;
|
||||
use codex_protocol::exec_output::StreamOutput;
|
||||
|
||||
mod code_mode_warning;
|
||||
mod config_refresh;
|
||||
pub(crate) mod context_window;
|
||||
mod daemon_recovery;
|
||||
mod environment;
|
||||
@@ -2046,18 +2047,25 @@ impl Session {
|
||||
state.session_configuration.provider.info().clone()
|
||||
}
|
||||
|
||||
pub(crate) async fn refresh_runtime_config(&self, next_config: Config) {
|
||||
self.refresh_runtime_config_inner(next_config, /*refresh_recording*/ true)
|
||||
.await;
|
||||
}
|
||||
|
||||
async fn refresh_runtime_config_inner(&self, next_config: Config, refresh_recording: bool) {
|
||||
async fn refresh_file_config(
|
||||
&self,
|
||||
expected_config: Arc<Config>,
|
||||
next_config: Config,
|
||||
) -> crate::ConfigRefreshOutcome {
|
||||
// Refresh only the user layer from the incoming snapshot. Preserve thread-local
|
||||
// layers such as request/session overrides that were present when this session
|
||||
// was created.
|
||||
let notify_config_contributors = !self.services.extensions.config_contributors().is_empty();
|
||||
let (previous_config, new_config, config) = {
|
||||
let mut state = self.state.lock().await;
|
||||
if !Arc::ptr_eq(
|
||||
&state.session_configuration.original_config_do_not_use,
|
||||
&expected_config,
|
||||
) {
|
||||
return crate::ConfigRefreshOutcome::Stale;
|
||||
}
|
||||
self.services.skills_service.clear_cache();
|
||||
self.services.plugins_manager.clear_cache();
|
||||
let previous_config = notify_config_contributors
|
||||
.then(|| self.build_effective_session_config(&state.session_configuration));
|
||||
let mut config = (*state.session_configuration.original_config_do_not_use).clone();
|
||||
@@ -2070,13 +2078,6 @@ impl Session {
|
||||
config.mcp_servers = next_config.mcp_servers.clone();
|
||||
config.mcp_optional_startup_grace = next_config.mcp_optional_startup_grace;
|
||||
config.mcp_oauth_credentials_store_mode = next_config.mcp_oauth_credentials_store_mode;
|
||||
// Recording can follow rollout changes without changing the session's
|
||||
// execution features (including Code Mode's dispatch gate).
|
||||
if refresh_recording {
|
||||
self.services
|
||||
.executed_tool_calls
|
||||
.refresh(&next_config.features);
|
||||
}
|
||||
if let Err(err) = config.features.set_enabled(
|
||||
Feature::Mcp20260728,
|
||||
next_config.features.enabled(Feature::Mcp20260728),
|
||||
@@ -2113,6 +2114,7 @@ impl Session {
|
||||
self.emit_config_changed_contributors(previous_config.as_ref(), new_config.as_ref());
|
||||
self.schedule_mcp_prewarm();
|
||||
self.refresh_hooks(config).await;
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
}
|
||||
|
||||
pub(crate) async fn refresh_hooks(&self, config: Arc<Config>) {
|
||||
@@ -2139,48 +2141,6 @@ impl Session {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn refresh_mcp_config(&self, next_config: Config) {
|
||||
let mut state = self.state.lock().await;
|
||||
let mut config = (*state.session_configuration.original_config_do_not_use).clone();
|
||||
config.config_layer_stack = next_config
|
||||
.config_layer_stack
|
||||
.with_user_layer_from(&config.config_layer_stack);
|
||||
config.mcp_servers = next_config.mcp_servers;
|
||||
config.mcp_optional_startup_grace = next_config.mcp_optional_startup_grace;
|
||||
config.mcp_oauth_credentials_store_mode = next_config.mcp_oauth_credentials_store_mode;
|
||||
if let Err(err) = config.features.set_enabled(
|
||||
Feature::Mcp20260728,
|
||||
next_config.features.enabled(Feature::Mcp20260728),
|
||||
) {
|
||||
warn!("failed to refresh MCP protocol config: {err}");
|
||||
}
|
||||
if let Err(err) = config.features.set_enabled(
|
||||
Feature::CodexAppsMcp20260728,
|
||||
next_config.features.enabled(Feature::CodexAppsMcp20260728),
|
||||
) {
|
||||
warn!("failed to refresh Codex Apps MCP protocol config: {err}");
|
||||
}
|
||||
if let Err(err) = config.features.set_enabled(
|
||||
Feature::SecretAuthStorage,
|
||||
next_config.features.enabled(Feature::SecretAuthStorage),
|
||||
) {
|
||||
warn!("failed to refresh MCP auth storage config: {err}");
|
||||
}
|
||||
if let Err(err) = config.features.set_enabled(
|
||||
Feature::McpOAuthRefreshCoordination,
|
||||
next_config
|
||||
.features
|
||||
.enabled(Feature::McpOAuthRefreshCoordination),
|
||||
) {
|
||||
warn!("failed to refresh MCP OAuth coordination config: {err}");
|
||||
}
|
||||
state.session_configuration.original_config_do_not_use = Arc::new(config);
|
||||
self.services.mcp_runtime.invalidate_resource_caches();
|
||||
self.mark_mcp_runtime_dirty();
|
||||
drop(state);
|
||||
self.schedule_mcp_prewarm();
|
||||
}
|
||||
|
||||
fn emit_config_changed_contributors(
|
||||
&self,
|
||||
previous_config: Option<&Config>,
|
||||
@@ -2209,55 +2169,55 @@ impl Session {
|
||||
//
|
||||
// Prefer `refresh_runtime_config()` when the host can already provide a materialized
|
||||
// config snapshot. This file-based path exists for legacy local reload flows.
|
||||
let config_toml_paths = {
|
||||
let state = self.state.lock().await;
|
||||
let config = &state.session_configuration.original_config_do_not_use;
|
||||
let user_config_paths = config
|
||||
.config_layer_stack
|
||||
.all_layers_low_to_high()
|
||||
.filter_map(|layer| match &layer.name {
|
||||
ConfigLayerSource::User { file, .. } => Some(file.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
if user_config_paths.is_empty() {
|
||||
vec![
|
||||
state
|
||||
.session_configuration
|
||||
.codex_home
|
||||
.join(CONFIG_TOML_FILE),
|
||||
]
|
||||
} else {
|
||||
user_config_paths
|
||||
}
|
||||
};
|
||||
loop {
|
||||
let (expected_config, config_toml_paths) = {
|
||||
let state = self.state.lock().await;
|
||||
let config = Arc::clone(&state.session_configuration.original_config_do_not_use);
|
||||
let user_config_paths = config
|
||||
.config_layer_stack
|
||||
.all_layers_low_to_high()
|
||||
.filter_map(|layer| match &layer.name {
|
||||
ConfigLayerSource::User { file, .. } => Some(file.clone()),
|
||||
_ => None,
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let paths = if user_config_paths.is_empty() {
|
||||
vec![
|
||||
state
|
||||
.session_configuration
|
||||
.codex_home
|
||||
.join(CONFIG_TOML_FILE),
|
||||
]
|
||||
} else {
|
||||
user_config_paths
|
||||
};
|
||||
(config, paths)
|
||||
};
|
||||
|
||||
let mut reloaded_user_configs = Vec::with_capacity(config_toml_paths.len());
|
||||
for config_toml_path in config_toml_paths {
|
||||
let user_config = match std::fs::read_to_string(&config_toml_path) {
|
||||
Ok(contents) => match toml::from_str::<toml::Value>(&contents) {
|
||||
Ok(config) => config,
|
||||
let mut reloaded_user_configs = Vec::with_capacity(config_toml_paths.len());
|
||||
for config_toml_path in config_toml_paths {
|
||||
let user_config = match std::fs::read_to_string(&config_toml_path) {
|
||||
Ok(contents) => match toml::from_str::<toml::Value>(&contents) {
|
||||
Ok(config) => config,
|
||||
Err(err) => {
|
||||
warn!("failed to parse user config while reloading layer: {err}");
|
||||
return;
|
||||
}
|
||||
},
|
||||
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
|
||||
toml::Value::Table(Default::default())
|
||||
}
|
||||
Err(err) => {
|
||||
warn!("failed to parse user config while reloading layer: {err}");
|
||||
warn!("failed to read user config while reloading layer: {err}");
|
||||
return;
|
||||
}
|
||||
},
|
||||
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
|
||||
toml::Value::Table(Default::default())
|
||||
}
|
||||
Err(err) => {
|
||||
warn!("failed to read user config while reloading layer: {err}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
reloaded_user_configs.push((config_toml_path, user_config));
|
||||
}
|
||||
};
|
||||
reloaded_user_configs.push((config_toml_path, user_config));
|
||||
}
|
||||
|
||||
let next_config = {
|
||||
let state = self.state.lock().await;
|
||||
let mut config = (*state.session_configuration.original_config_do_not_use).clone();
|
||||
let mut next_config = expected_config.as_ref().clone();
|
||||
for (config_toml_path, user_config) in reloaded_user_configs {
|
||||
let config_layer_stack = match config
|
||||
let config_layer_stack = match next_config
|
||||
.config_layer_stack
|
||||
.with_user_config(&config_toml_path, user_config)
|
||||
{
|
||||
@@ -2267,18 +2227,16 @@ impl Session {
|
||||
return;
|
||||
}
|
||||
};
|
||||
config.config_layer_stack = config_layer_stack;
|
||||
next_config.config_layer_stack = config_layer_stack;
|
||||
}
|
||||
config.tool_suggest =
|
||||
resolve_tool_suggest_config_from_layer_stack(&config.config_layer_stack);
|
||||
config
|
||||
};
|
||||
self.services.skills_service.clear_cache();
|
||||
self.services.plugins_manager.clear_cache();
|
||||
// This legacy snapshot still has the original execution features, not
|
||||
// the host's latest rollout settings. Leave the live recorder alone.
|
||||
self.refresh_runtime_config_inner(next_config, /*refresh_recording*/ false)
|
||||
.await;
|
||||
next_config.tool_suggest =
|
||||
resolve_tool_suggest_config_from_layer_stack(&next_config.config_layer_stack);
|
||||
if self.refresh_file_config(expected_config, next_config).await
|
||||
!= crate::ConfigRefreshOutcome::Stale
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Record a terminal CodexErr before the app-server completion notification is reduced.
|
||||
|
||||
@@ -16,6 +16,7 @@ use crate::agents_md_manager::SessionInstructions;
|
||||
use crate::compact::InitialContextInjection;
|
||||
use crate::config::ConfigBuilder;
|
||||
use crate::config::ConfigOverrides;
|
||||
use crate::config::RuntimeConfigRefresh;
|
||||
use crate::context::ContextualUserFragment;
|
||||
use crate::context::DeveloperInstructions;
|
||||
use crate::context::TurnAborted;
|
||||
@@ -2028,8 +2029,11 @@ async fn refresh_runtime_config_refreshes_hooks() -> anyhow::Result<()> {
|
||||
};
|
||||
assert!(session.hooks().preview_session_start(&request).is_empty());
|
||||
|
||||
let current_config = session.get_config().await;
|
||||
let next_config = load_latest_config_for_session(&session).await;
|
||||
session.refresh_runtime_config(next_config).await;
|
||||
let _ = session
|
||||
.refresh_runtime_config(current_config, next_config)
|
||||
.await;
|
||||
|
||||
assert_eq!(session.hooks().preview_session_start(&request).len(), 1);
|
||||
Ok(())
|
||||
@@ -2089,8 +2093,20 @@ disabled_tools = [
|
||||
let mut next_config = load_latest_config_for_session(&session).await;
|
||||
next_config.model = Some("gpt-5.4".to_string());
|
||||
next_config.notify = Some(vec!["echo".to_string()]);
|
||||
let mcp_protocol_enabled = !original.features.enabled(Feature::Mcp20260728);
|
||||
let apps_protocol_enabled = !original.features.enabled(Feature::CodexAppsMcp20260728);
|
||||
next_config
|
||||
.features
|
||||
.set_enabled(Feature::Mcp20260728, mcp_protocol_enabled)
|
||||
.expect("set MCP protocol rollout");
|
||||
next_config
|
||||
.features
|
||||
.set_enabled(Feature::CodexAppsMcp20260728, apps_protocol_enabled)
|
||||
.expect("set Codex Apps MCP protocol rollout");
|
||||
|
||||
session.refresh_runtime_config(next_config).await;
|
||||
let _ = session
|
||||
.refresh_runtime_config(Arc::clone(&original), next_config)
|
||||
.await;
|
||||
|
||||
let config = session.get_config().await;
|
||||
let apps_toml = config
|
||||
@@ -2111,6 +2127,14 @@ disabled_tools = [
|
||||
assert_eq!(app.destructive_enabled, Some(false));
|
||||
assert_eq!(config.model, original.model);
|
||||
assert_eq!(config.notify, original.notify);
|
||||
assert_eq!(
|
||||
config.features.enabled(Feature::Mcp20260728),
|
||||
mcp_protocol_enabled
|
||||
);
|
||||
assert_eq!(
|
||||
config.features.enabled(Feature::CodexAppsMcp20260728),
|
||||
apps_protocol_enabled
|
||||
);
|
||||
assert_eq!(
|
||||
config.tool_suggest.disabled_tools,
|
||||
vec![
|
||||
@@ -2120,9 +2144,38 @@ disabled_tools = [
|
||||
);
|
||||
}
|
||||
|
||||
#[test_case::test_case(false; "published")]
|
||||
#[test_case::test_case(true; "rejected")]
|
||||
#[tokio::test]
|
||||
async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
|
||||
async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements(reject: bool) {
|
||||
let (session, _turn_context) = make_session_and_context().await;
|
||||
let original = session.get_config().await;
|
||||
if reject {
|
||||
let mut config = original.as_ref().clone();
|
||||
let mut layers: Vec<_> = config
|
||||
.config_layer_stack
|
||||
.all_layers_low_to_high()
|
||||
.filter(|layer| !matches!(layer.name, codex_config::ConfigLayerSource::SessionFlags))
|
||||
.cloned()
|
||||
.collect();
|
||||
layers.push(codex_config::ConfigLayerEntry::new(
|
||||
codex_config::ConfigLayerSource::SessionFlags,
|
||||
toml::from_str("features = 'invalid retained features'").unwrap(),
|
||||
));
|
||||
config.config_layer_stack = ConfigLayerStack::new(
|
||||
layers,
|
||||
config.config_layer_stack.requirements().clone(),
|
||||
config.config_layer_stack.requirements_toml().clone(),
|
||||
)
|
||||
.unwrap();
|
||||
session
|
||||
.state
|
||||
.lock()
|
||||
.await
|
||||
.session_configuration
|
||||
.original_config_do_not_use = Arc::new(config);
|
||||
}
|
||||
let original = session.get_config().await;
|
||||
let server = serde_json::from_value::<McpServerConfig>(json!({
|
||||
"url": "https://example.com/mcp",
|
||||
"enabled": true
|
||||
@@ -2137,12 +2190,22 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
|
||||
codex_config::PluginRequirementsToml {
|
||||
mcp_servers: Some(std::collections::BTreeMap::from([(
|
||||
"beta".to_string(),
|
||||
requirement,
|
||||
requirement.clone(),
|
||||
)])),
|
||||
},
|
||||
)]);
|
||||
|
||||
let mut next_config = session.get_config().await.as_ref().clone();
|
||||
let mut next_config = original.as_ref().clone();
|
||||
let mcp_protocol_enabled = !original.features.enabled(Feature::Mcp20260728);
|
||||
let apps_protocol_enabled = !original.features.enabled(Feature::CodexAppsMcp20260728);
|
||||
next_config
|
||||
.features
|
||||
.set_enabled(Feature::Mcp20260728, mcp_protocol_enabled)
|
||||
.expect("set MCP protocol rollout");
|
||||
next_config
|
||||
.features
|
||||
.set_enabled(Feature::CodexAppsMcp20260728, apps_protocol_enabled)
|
||||
.expect("set Codex Apps MCP protocol rollout");
|
||||
next_config.mcp_servers = codex_config::Constrained::normalized(
|
||||
HashMap::from([("beta".to_string(), server.clone())]),
|
||||
|mut servers: HashMap<String, McpServerConfig>| {
|
||||
@@ -2152,11 +2215,29 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
|
||||
)
|
||||
.expect("valid refreshed MCP constraints");
|
||||
let mut requirements = next_config.config_layer_stack.requirements().clone();
|
||||
let mcp_requirements = BTreeMap::from([("beta".to_string(), requirement)]);
|
||||
requirements.mcp_servers = Some(Sourced::new(
|
||||
mcp_requirements.clone(),
|
||||
RequirementSource::LegacyManagedConfigTomlFromMdm,
|
||||
));
|
||||
requirements.plugins = Some(Sourced::new(
|
||||
plugin_requirements.clone(),
|
||||
RequirementSource::LegacyManagedConfigTomlFromMdm,
|
||||
));
|
||||
let feature_requirements: codex_config::FeatureRequirementsToml =
|
||||
serde_json::from_value(json!({"secret_auth_storage": false})).unwrap();
|
||||
requirements.feature_requirements = Some(Sourced::new(
|
||||
feature_requirements.clone(),
|
||||
RequirementSource::LegacyManagedConfigTomlFromMdm,
|
||||
));
|
||||
next_config.features = crate::config::ManagedFeatures::from_configured(
|
||||
next_config.features.get().clone(),
|
||||
requirements.feature_requirements.clone(),
|
||||
)
|
||||
.unwrap();
|
||||
let mut requirements_toml = next_config.config_layer_stack.requirements_toml().clone();
|
||||
requirements_toml.feature_requirements = Some(feature_requirements);
|
||||
requirements_toml.mcp_servers = Some(mcp_requirements);
|
||||
requirements_toml.plugins = Some(plugin_requirements.clone());
|
||||
let layers = next_config
|
||||
.config_layer_stack
|
||||
@@ -2166,9 +2247,35 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
|
||||
next_config.config_layer_stack = ConfigLayerStack::new(layers, requirements, requirements_toml)
|
||||
.expect("managed MCP and plugin requirements");
|
||||
|
||||
session.refresh_mcp_config(next_config).await;
|
||||
let outcome = session
|
||||
.refresh_mcp_config(Arc::clone(&original), next_config)
|
||||
.await;
|
||||
assert_eq!(
|
||||
outcome,
|
||||
if reject {
|
||||
crate::ConfigRefreshOutcome::Rejected
|
||||
} else {
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
}
|
||||
);
|
||||
|
||||
let config = session.get_config().await;
|
||||
assert!(!config.features.enabled(Feature::SecretAuthStorage));
|
||||
assert!(
|
||||
config
|
||||
.config_layer_stack
|
||||
.requirements()
|
||||
.feature_requirements
|
||||
.is_some()
|
||||
);
|
||||
assert_eq!(
|
||||
config.features.enabled(Feature::Mcp20260728),
|
||||
mcp_protocol_enabled
|
||||
);
|
||||
assert_eq!(
|
||||
config.features.enabled(Feature::CodexAppsMcp20260728),
|
||||
apps_protocol_enabled
|
||||
);
|
||||
let mut managed_servers = config.mcp_servers.clone();
|
||||
managed_servers
|
||||
.set(HashMap::from([
|
||||
@@ -2176,10 +2283,13 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
|
||||
("beta".to_string(), server.clone()),
|
||||
]))
|
||||
.expect("apply refreshed managed MCP constraints");
|
||||
assert_eq!(
|
||||
managed_servers.get(),
|
||||
&HashMap::from([("beta".to_string(), server.clone())])
|
||||
assert!(
|
||||
!managed_servers
|
||||
.get()
|
||||
.get("alpha")
|
||||
.is_some_and(|server| server.enabled)
|
||||
);
|
||||
assert_eq!(managed_servers.get()["beta"], server);
|
||||
assert_eq!(
|
||||
config
|
||||
.config_layer_stack
|
||||
@@ -2197,6 +2307,73 @@ async fn refresh_mcp_config_replaces_managed_server_and_plugin_requirements() {
|
||||
config.apply_plugin_mcp_server_requirements("example-plugin", &mut plugin_servers);
|
||||
assert!(!plugin_servers["alpha"].enabled);
|
||||
assert!(plugin_servers["beta"].enabled);
|
||||
let reloaded = config.resolve_runtime_refresh(&config, RuntimeConfigRefresh::User);
|
||||
if let Ok(reloaded) = reloaded {
|
||||
assert_eq!(
|
||||
reloaded.config_layer_stack.requirements().plugins,
|
||||
config.config_layer_stack.requirements().plugins
|
||||
);
|
||||
} else {
|
||||
assert!(reject);
|
||||
}
|
||||
}
|
||||
|
||||
#[test_case::test_case(RuntimeConfigRefresh::User; "user refresh")]
|
||||
#[test_case::test_case(RuntimeConfigRefresh::Mcp; "MCP refresh")]
|
||||
#[tokio::test]
|
||||
async fn refresh_config_rejects_stale_owner_without_effects(scope: RuntimeConfigRefresh) {
|
||||
let (session, _turn_context) = make_session_and_context().await;
|
||||
let stale_owner = session.get_config().await;
|
||||
let mut stale_config = stale_owner.as_ref().clone();
|
||||
stale_config
|
||||
.features
|
||||
.set_enabled(
|
||||
Feature::Mcp20260728,
|
||||
!stale_owner.features.enabled(Feature::Mcp20260728),
|
||||
)
|
||||
.expect("set MCP protocol rollout");
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_runtime_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
let current_owner = session.get_config().await;
|
||||
assert!(session.mcp_refresh.claim());
|
||||
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_config(stale_owner, stale_config, scope)
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Stale
|
||||
);
|
||||
|
||||
assert!(Arc::ptr_eq(¤t_owner, &session.get_config().await));
|
||||
assert!(!session.mcp_refresh.is_pending());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn refresh_file_config_rejects_stale_owner_without_effects() {
|
||||
let (session, _turn_context) = make_session_and_context().await;
|
||||
let stale_owner = session.get_config().await;
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_runtime_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
let current_owner = session.get_config().await;
|
||||
assert!(session.mcp_refresh.claim());
|
||||
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_file_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Stale
|
||||
);
|
||||
|
||||
assert!(Arc::ptr_eq(¤t_owner, &session.get_config().await));
|
||||
assert!(!session.mcp_refresh.is_pending());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -3771,8 +3948,11 @@ disabled_tools = [
|
||||
"#,
|
||||
)
|
||||
.expect("write user config");
|
||||
let current_config = session.get_config().await;
|
||||
let next_config = load_latest_config_for_session(&session).await;
|
||||
session.refresh_runtime_config(next_config).await;
|
||||
let _ = session
|
||||
.refresh_runtime_config(current_config, next_config)
|
||||
.await;
|
||||
|
||||
let expected_disabled_tools = vec![
|
||||
ToolSuggestDisabledTool::connector("calendar"),
|
||||
@@ -13096,3 +13276,65 @@ async fn session_start_hooks_require_project_trust_without_config_toml() -> std:
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejected_mcp_refresh_then_corrected_user_config_blocks_ordinary_replacement() {
|
||||
let (session, _turn_context) = make_session_and_context().await;
|
||||
let base = session.get_config().await;
|
||||
let enterprise: McpServerConfig = serde_json::from_value(json!({
|
||||
"url": "https://enterprise.example/mcp", "auth": "ema_auth", "enabled": true
|
||||
}))
|
||||
.unwrap();
|
||||
let ordinary: McpServerConfig = serde_json::from_value(json!({
|
||||
"url": "https://ordinary.example/mcp", "enabled": true
|
||||
}))
|
||||
.unwrap();
|
||||
let mut initial = base.as_ref().clone();
|
||||
initial.mcp_servers = crate::config::Constrained::allow_any(HashMap::from([(
|
||||
"enterprise".to_string(),
|
||||
enterprise,
|
||||
)]));
|
||||
initial.config_layer_stack = ConfigLayerStack::new(
|
||||
vec![codex_config::ConfigLayerEntry::new(
|
||||
codex_config::ConfigLayerSource::User {
|
||||
file: initial.codex_home.join(CONFIG_TOML_FILE),
|
||||
profile: None,
|
||||
},
|
||||
toml::from_str("features = 'invalid retained features'").unwrap(),
|
||||
)],
|
||||
base.config_layer_stack.requirements().clone(),
|
||||
base.config_layer_stack.requirements_toml().clone(),
|
||||
)
|
||||
.unwrap();
|
||||
session
|
||||
.state
|
||||
.lock()
|
||||
.await
|
||||
.session_configuration
|
||||
.original_config_do_not_use = Arc::new(initial);
|
||||
let current = session.get_config().await;
|
||||
let mut corrected = base.as_ref().clone();
|
||||
corrected.mcp_servers = crate::config::Constrained::allow_any(HashMap::from([(
|
||||
"enterprise".to_string(),
|
||||
ordinary,
|
||||
)]));
|
||||
assert_eq!(
|
||||
session.refresh_mcp_config(current, corrected.clone()).await,
|
||||
crate::ConfigRefreshOutcome::Rejected
|
||||
);
|
||||
let rejected = session.get_config().await;
|
||||
assert!(rejected.mcp_enterprise_managed_auth.is_none());
|
||||
assert_eq!(
|
||||
session.refresh_runtime_config(rejected, corrected).await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
let final_config = session.get_config().await;
|
||||
assert!(
|
||||
!final_config
|
||||
.mcp_servers
|
||||
.get()
|
||||
.get("enterprise")
|
||||
.is_some_and(|server| server.enabled),
|
||||
"rejection must not permit same-name ordinary-auth replacement in this session"
|
||||
);
|
||||
}
|
||||
|
||||
@@ -361,9 +361,12 @@ async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
|
||||
}
|
||||
|
||||
// Reapplying an enabled config keeps the same recording lifetime.
|
||||
session
|
||||
.refresh_runtime_config((*session.get_config().await).clone())
|
||||
.await;
|
||||
let current_config = session.get_config().await;
|
||||
let config = current_config.as_ref().clone();
|
||||
assert_eq!(
|
||||
session.refresh_runtime_config(current_config, config).await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
// Await in reverse order: each result must already own its record before history attachment.
|
||||
let mut outputs = Vec::new();
|
||||
for (arguments, future) in pending.into_iter().rev() {
|
||||
@@ -413,12 +416,15 @@ async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
|
||||
.expect("dispatched direct call"),
|
||||
);
|
||||
}
|
||||
let mut config = (*session.get_config().await).clone();
|
||||
let current_config = session.get_config().await;
|
||||
let mut config = current_config.as_ref().clone();
|
||||
config
|
||||
.features
|
||||
.disable(Feature::ExecutedToolCallMetadata)
|
||||
.expect("disable metadata");
|
||||
session.refresh_runtime_config(config.clone()).await;
|
||||
let _ = session
|
||||
.refresh_runtime_config(current_config, config.clone())
|
||||
.await;
|
||||
let result = pending
|
||||
.remove(0)
|
||||
.await
|
||||
@@ -438,7 +444,8 @@ async fn direct_results_keep_their_own_records_when_call_ids_repeat() {
|
||||
.features
|
||||
.enable(Feature::ExecutedToolCallMetadata)
|
||||
.expect("re-enable metadata");
|
||||
session.refresh_runtime_config(config).await;
|
||||
let current_config = session.get_config().await;
|
||||
let _ = session.refresh_runtime_config(current_config, config).await;
|
||||
let result = pending
|
||||
.pop()
|
||||
.expect("call prepared before disable")
|
||||
|
||||
@@ -426,6 +426,33 @@ fn direct_retained_metadata_budget_sheds_results_then_calls_across_refresh() {
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stale_runtime_refresh_preserves_recording_state() {
|
||||
let (session, _turn) = crate::session::tests::make_session_and_context().await;
|
||||
let calls = session.services.executed_tool_calls.clone();
|
||||
assert!(calls.lock_state().is_none());
|
||||
let stale_owner = session.get_config().await;
|
||||
let mut stale_config = stale_owner.as_ref().clone();
|
||||
stale_config
|
||||
.features
|
||||
.enable(Feature::ExecutedToolCallMetadata)
|
||||
.expect("enable executed tool call metadata");
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_mcp_config(Arc::clone(&stale_owner), stale_owner.as_ref().clone())
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_runtime_config(stale_owner, stale_config)
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Stale
|
||||
);
|
||||
assert!(calls.lock_state().is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn recorder_refreshes_without_changing_execution_features_or_claiming_missing_history() {
|
||||
struct MetadataLookup<'a>(std::cell::Cell<usize>, JsonValue, &'a ExecutedToolCalls);
|
||||
@@ -462,11 +489,14 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
|
||||
let mut retry_cache = HashMap::new();
|
||||
let mut prior_generation = None;
|
||||
for (index, enabled) in [false, true, false, true].into_iter().enumerate() {
|
||||
let current_config = session.get_config().await;
|
||||
next_config
|
||||
.features
|
||||
.set_enabled(Feature::ExecutedToolCallMetadata, enabled)
|
||||
.expect("test feature must be configurable");
|
||||
session.refresh_runtime_config(next_config.clone()).await;
|
||||
let _ = session
|
||||
.refresh_runtime_config(current_config, next_config.clone())
|
||||
.await;
|
||||
assert_eq!(calls.lock_state().is_some(), enabled);
|
||||
// A legacy file reload has no new rollout snapshot and must keep this setting.
|
||||
session.reload_user_config_layer().await;
|
||||
@@ -509,6 +539,21 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
|
||||
);
|
||||
assert_eq!(tool_calls_complete(&direct_output), enabled.then_some(true));
|
||||
|
||||
if enabled {
|
||||
// Reapplying an enabled config must preserve already-recorded calls.
|
||||
let prepared = calls.prepare_direct_call(&call, &ToolCallSource::Direct, &step);
|
||||
let current_config = session.get_config().await;
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_runtime_config(current_config, next_config.clone())
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
let mut replay = output(&call.call_id);
|
||||
calls.attach_direct_call_to_output(&mut replay, prepared);
|
||||
assert_eq!(replay, direct_output);
|
||||
}
|
||||
|
||||
let cell = CellId::new(format!("cell-{index}"));
|
||||
let origin = format!("exec-{index}");
|
||||
calls.start_cell(&cell, &origin);
|
||||
@@ -523,7 +568,13 @@ async fn recorder_refreshes_without_changing_execution_features_or_claiming_miss
|
||||
nested.set_tool_result_metadata(ToolResultMetadata::new(&json!({})));
|
||||
if enabled {
|
||||
// Reapplying an enabled config must preserve pending calls and their metadata.
|
||||
session.refresh_runtime_config(next_config.clone()).await;
|
||||
let current_config = session.get_config().await;
|
||||
assert_eq!(
|
||||
session
|
||||
.refresh_runtime_config(current_config, next_config.clone())
|
||||
.await,
|
||||
crate::ConfigRefreshOutcome::Published
|
||||
);
|
||||
}
|
||||
calls.finish_cell_recording(&cell);
|
||||
let mut prompt = vec![exec_input(&origin), exec_output(&origin)];
|
||||
|
||||
Reference in New Issue
Block a user