diff --git a/codex-rs/app-server/src/request_processors/account_processor.rs b/codex-rs/app-server/src/request_processors/account_processor.rs index ca98e7e1ab..792b24bdb7 100644 --- a/codex-rs/app-server/src/request_processors/account_processor.rs +++ b/codex-rs/app-server/src/request_processors/account_processor.rs @@ -2,6 +2,7 @@ use super::bedrock_auth::BedrockProviderConfig; use super::bedrock_auth::clear_user_model_provider_if_bedrock; use super::bedrock_auth::prepare_bedrock_provider; use super::config_processor::map_error as map_config_error; +use super::config_processor::refresh_guardian_policy; use super::*; use crate::auth_mode::auth_mode_to_api; use crate::external_auth::ExternalAuthBridge; @@ -991,13 +992,15 @@ impl AccountRequestProcessor { ) { let auth_changes = self.auth_manager.auth_change_state_receiver(); let owner_generation = auth_changes.borrow().owner_generation; - if payload.success - && let Err(error) = self.read_account(/*request*/ None).await - { + let logged_in = payload.success; + if logged_in && let Err(error) = self.read_account(/*request*/ None).await { payload.success = false; payload.error = Some(error.to_string()); } - if payload.success && auth_changes.borrow().owner_generation == owner_generation { + if logged_in && auth_changes.borrow().owner_generation == owner_generation { + refresh_guardian_policy(&self.thread_manager).await; + } + if logged_in && auth_changes.borrow().owner_generation == owner_generation { Self::maybe_refresh_plugin_caches_for_current_config( &self.config_manager, &self.thread_manager, @@ -1006,7 +1009,6 @@ impl AccountRequestProcessor { .await; } - let success = payload.success; self.outgoing .send_account_notification( /*connection_id*/ None, @@ -1016,7 +1018,7 @@ impl AccountRequestProcessor { ) .await; - if success { + if logged_in { let notification = self.current_account_updated_notification(); self.outgoing .send_account_notification( @@ -1073,6 +1075,7 @@ impl AccountRequestProcessor { self.model_catalog.invalidate().await; *self.workspace_routing.lock().await = None; + refresh_guardian_policy(&self.thread_manager).await; Self::maybe_refresh_plugin_caches_for_current_config( &self.config_manager, &self.thread_manager, diff --git a/codex-rs/app-server/src/request_processors/config_processor.rs b/codex-rs/app-server/src/request_processors/config_processor.rs index 1d80bfedb4..722c796453 100644 --- a/codex-rs/app-server/src/request_processors/config_processor.rs +++ b/codex-rs/app-server/src/request_processors/config_processor.rs @@ -427,8 +427,16 @@ pub(super) async fn reload_user_config( config_manager: &ConfigManager, thread_manager: &ThreadManager, ) { - // Reload owns several config snapshots; do not inline that future into dispatch. + // Publish local layers first so Guardian resolves their new policy fallbacks. Box::pin(reload_user_config_inner(config_manager, thread_manager)).await; + // Guardian still refreshes when unrelated configuration could not load. + refresh_guardian_policy(thread_manager).await; +} + +pub(super) async fn refresh_guardian_policy(thread_manager: &ThreadManager) { + if let Err(error) = Box::pin(thread_manager.refresh_guardian_policy()).await { + tracing::warn!(kind = ?error.kind(), "failed to refresh Guardian policy"); + } } async fn reload_user_config_inner(config_manager: &ConfigManager, thread_manager: &ThreadManager) { diff --git a/codex-rs/app-server/src/request_processors/config_reload_tests.rs b/codex-rs/app-server/src/request_processors/config_reload_tests.rs index ecf13891ec..d5ba823703 100644 --- a/codex-rs/app-server/src/request_processors/config_reload_tests.rs +++ b/codex-rs/app-server/src/request_processors/config_reload_tests.rs @@ -7,6 +7,8 @@ use codex_config::types::AuthKeyringBackendKind; use codex_core::config::ConfigOverrides; use codex_exec_server::EnvironmentManager; use codex_login::CodexAuth; +use codex_protocol::config_types::ApprovalsReviewer::AutoReview; +use codex_protocol::config_types::ApprovalsReviewer::User; use pretty_assertions::assert_eq; use serde_json::json; use std::collections::HashMap; @@ -69,14 +71,17 @@ async fn reloads_accept_a_provider_supplied_by_thread_overrides() -> anyhow::Res } #[tokio::test] -async fn user_reload_promotes_plugin_and_feature_requirements_without_server_changes() +async fn user_reload_refreshes_independent_requirements_without_server_changes() -> anyhow::Result<()> { let home = tempfile::tempdir()?; let requirements_path = home.path().join("requirements.toml"); - std::fs::write(&requirements_path, "")?; + std::fs::write( + &requirements_path, + "allowed_approvals_reviewers = ['auto_review']\nguardian_policy_config = 'first policy'\nguardian_extra_policy = 'first extra'\n", + )?; std::fs::write( home.path().join(codex_config::CONFIG_TOML_FILE), - "[features]\nenable_mcp_apps = true\n", + "approvals_reviewer = 'user'\n[features]\nenable_mcp_apps = true\n", )?; let mut overrides = codex_config::LoaderOverrides::without_managed_config_for_tests(); overrides.ignore_managed_requirements = false; @@ -99,7 +104,8 @@ async fn user_reload_promotes_plugin_and_feature_requirements_without_server_cha initial.model_provider.clone(), initial.codex_home.to_path_buf(), Arc::new(EnvironmentManager::default_for_tests()), - ), + ) + .with_guardian_policy_loader(Arc::new(manager.clone())), ); assert!( initial @@ -111,17 +117,17 @@ async fn user_reload_promotes_plugin_and_feature_requirements_without_server_cha .start_thread(codex_core::StartThreadOptions::new(initial)) .await? .thread; + assert_eq!( + thread.config_snapshot().await.approvals_reviewer, + AutoReview + ); std::fs::write( &requirements_path, - "[features]\nenable_mcp_apps = false\n[plugins.example.mcp_servers]\n", + "guardian_policy_config = 'first policy'\nguardian_extra_policy = 'first extra'\n[features]\nenable_mcp_apps = false\n[plugins.example.mcp_servers]\n", )?; - tokio::time::timeout( - std::time::Duration::from_secs(10), - reload_user_config(&manager, &threads), - ) - .await - .expect("policy promotion must terminate"); + reload_user_config(&manager, &threads).await; let config = thread.config().await; + assert_eq!(config.approvals_reviewer, User); assert_eq!(config.mcp_servers.get(), &original_servers); assert!( !config @@ -150,6 +156,85 @@ async fn user_reload_promotes_plugin_and_feature_requirements_without_server_cha .feature_requirements .is_some() ); + for requirements in [ + "guardian_policy_config = 'replacement policy'\nguardian_extra_policy = 'first extra'", + "guardian_policy_config = 'replacement policy'\nguardian_extra_policy = 'replacement extra'", + "", + ] { + let requirements = format!( + "{requirements}\n[features]\nenable_mcp_apps = false\n[plugins.example.mcp_servers]\n" + ); + std::fs::write(&requirements_path, &requirements)?; + let expected: codex_config::ConfigRequirementsToml = toml::from_str(&requirements)?; + reload_user_config(&manager, &threads).await; + let config = thread.config().await; + assert_eq!(config.mcp_servers.get(), &original_servers); + assert_eq!( + ( + config.guardian_policy_config.as_deref(), + config.guardian_extra_policy.as_deref() + ), + ( + expected.guardian_policy_config.as_deref(), + expected.guardian_extra_policy.as_deref() + ) + ); + } + // Guardian still applies changed requirements when user config cannot load. + let model = thread.config_snapshot().await.model; + std::fs::write( + &requirements_path, + format!( + "allowed_approvals_reviewers = ['auto_review']\n[auto_review]\nrequired_on_models = ['{model}']" + ), + )?; + std::fs::write( + home.path().join(codex_config::CONFIG_TOML_FILE), + "model_provider = 'missing-provider'", + )?; + reload_user_config(&manager, &threads).await; + assert_eq!( + thread.config_snapshot().await.approvals_reviewer, + AutoReview + ); + let config = thread.config().await; + assert!( + config + .config_layer_stack + .requirements() + .approvals_reviewer + .can_set(&AutoReview) + .is_ok() + ); + let restored = thread.restorable_thread_settings().await; + thread.restore_thread_settings(restored).await?; + // An explicit user reload resolves new local fallbacks on its first invocation. + std::fs::write(&requirements_path, "")?; + std::fs::write( + home.path().join(codex_config::CONFIG_TOML_FILE), + "[auto_review]\npolicy = 'new user fallback'", + )?; + reload_user_config(&manager, &threads).await; + let config = thread.config().await; + assert_eq!( + ( + config.guardian_policy_config.as_deref(), + config.guardian_extra_policy.as_deref(), + config.approvals_reviewer + ), + (Some("new user fallback"), None, User) + ); + thread + .restore_thread_settings(codex_core::CodexThreadSettingsOverrides { + approvals_reviewer: Some(AutoReview), + ..Default::default() + }) + .await?; + reload_user_config(&manager, &threads).await; + assert_eq!( + thread.config_snapshot().await.approvals_reviewer, + AutoReview + ); Ok(()) } diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs index 47635c8ce9..c7cf0068e5 100644 --- a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs +++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs @@ -2,9 +2,14 @@ use crate::async_scorer::conversation::ConversationBackend; use std::collections::BTreeMap; use std::sync::Arc; use std::sync::Mutex; +use std::task::Poll; use std::time::Duration; use anyhow::Result; +use codex_config::CloudConfigBundleLoader; +use codex_config::GuardianPolicySnapshot; +use codex_config::loader::load_guardian_policy_snapshot; +use codex_config::test_support::CloudConfigBundleFixture; use codex_core::config::Config; use codex_core::config::ConfigBuilder; use codex_core::config::LoaderOverrides; @@ -67,6 +72,7 @@ use core_test_support::responses::ev_assistant_message; use core_test_support::responses::ev_completed; use core_test_support::skip_if_no_network; use core_test_support::test_codex::TestCodex; +use core_test_support::test_codex::TestEnv; use core_test_support::test_codex::test_codex; use core_test_support::wait_for_event; use pretty_assertions::assert_eq; @@ -1771,6 +1777,49 @@ classifier_instructions = "Predict future violations.\n# Security Policy\n{{ ten .await, Some(ReviewDecision::Approved) ); + // Tightening while a review is pending must prevent a late low-risk score from releasing it. + const TIGHTENED_REVISION: u64 = 1; + const RELAXED_REVISION: u64 = TIGHTENED_REVISION + 1; + let fs = TestEnv::local().await?.environment().get_filesystem(); + let overrides = LoaderOverrides::without_managed_config_for_tests(); + let load = |loader, revision| { + load_guardian_policy_snapshot( + fs.as_ref(), + test.codex_home_path(), + &overrides, + loader, + revision, + ) + }; + let tightened = CloudConfigBundleFixture::loader_with_enterprise_requirement( + "allowed_approvals_reviewers = ['auto_review']", + ); + store.insert(vec![ + load(&tightened, TIGHTENED_REVISION).await?, + load(&CloudConfigBundleLoader::default(), RELAXED_REVISION).await?, + ]); + store.insert_arc(Arc::clone(&test.codex)); + let mut score = cached_score(&turn_store).unwrap(); + score.scores.insert("action_risk".to_owned(), 1.0); + set_cached_score(&turn_store, score); + let scored_action = r#"{"id":"call-1","tool":"read_file"}"#; + assert_eq!( + cached_approval( + ®istry, + store, + &turn_store, + scored_action, + /*metrics*/ None, + ) + .await, + None + ); + assert_eq!( + test.codex.config().await.guardian_policy_revision, + RELAXED_REVISION + ); + store.remove::>(); + store.remove::(); Ok(()) } @@ -3975,14 +4024,46 @@ async fn assert_parent_compaction_reuse(parent_context_for_review: bool) -> Resu Ok(()) } -struct CacheMiss; -impl codex_extension_api::SynchronousApprovalReviewer for CacheMiss { +struct CacheMiss<'a> { + thread_store: &'a ExtensionData, + turn_store: &'a ExtensionData, +} +impl codex_extension_api::SynchronousApprovalReviewer for CacheMiss<'_> { fn review<'a>( &'a self, _reason: codex_protocol::approvals::GuardianReviewReason, - _async_approval: Option>, + async_approval: Option>, ) -> codex_extension_api::ExtensionFuture<'a, Option> { - Box::pin(async { Some(ReviewDecision::denied("cache miss")) }) + Box::pin(async move { + if let Some(snapshots) = self.thread_store.get::>() { + let mut pending = async_approval.expect("adaptive review should be pending"); + assert!( + std::future::poll_fn(|context| Poll::Ready(pending.as_mut().poll(context))) + .await + .is_pending() + ); + let thread = self.thread_store.get::().unwrap(); + let cache = + ConversationBackend::for_turn(self.thread_store, self.turn_store).unwrap(); + let progress = &cache.progress; + for (snapshot, expected) in snapshots.iter().zip([Poll::Pending, Poll::Ready(())]) { + assert_eq!( + thread.refresh_guardian_policy(snapshot).await, + codex_core::ConfigRefreshOutcome::Published + ); + let mut score = cached_score(self.turn_store).unwrap(); + score.scores.insert("action_risk".to_owned(), 0.0); + set_cached_score(self.turn_store, score); + progress.updates.send_replace(()); + assert_eq!( + std::future::poll_fn(|context| Poll::Ready(pending.as_mut().poll(context))) + .await, + expected + ); + } + } + Some(ReviewDecision::denied("cache miss")) + }) } } @@ -4189,7 +4270,10 @@ async fn cached_approval( require_fresh_review: false, full_access: false, metrics, - synchronous_reviewer: &CacheMiss, + synchronous_reviewer: &CacheMiss { + thread_store, + turn_store, + }, }; match registry.decide_approval(&input).await { Some(codex_extension_api::ApprovalDecision::Allow) => Some(ReviewDecision::Approved),