From db263d4f5471f4fd2e91ae0955556ace66aeb1c5 Mon Sep 17 00:00:00 2001 From: rreichel3-oai Date: Thu, 19 Nov 2026 22:04:24 +0000 Subject: [PATCH] Refresh Guardian policy on config reload and account changes (#62614) ## Why Running threads need to pick up changes to approval requirements and Guardian policy when users reload configuration, sign in, or sign out. ## What changed Refresh Guardian policy after publishing local config layers so the first reload uses updated policy fallbacks. Attempt the refresh even if unrelated user configuration fails to load. Refresh policy after login while the account owner is still current, and after logout. If reading account details fails after login, report the error in the login completion notification and still send the account update. ## Testing Extend coverage for changing and removing Guardian policy requirements, applying requirements despite a config load error, and picking up local fallbacks on the first reload. Verify that a late low-risk score cannot release a pending adaptive approval while stricter requirements apply. GitOrigin-RevId: 95453807a06a0d3c39dcfd9a0f66fd63f41294b9 --- .../request_processors/account_processor.rs | 15 ++- .../request_processors/config_processor.rs | 10 +- .../request_processors/config_reload_tests.rs | 107 ++++++++++++++++-- .../src/async_scorer/extension_tests.rs | 94 ++++++++++++++- 4 files changed, 203 insertions(+), 23 deletions(-) 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),