Lightweight coding agent that runs in your terminal
Rust
Honor attachment-owned permissions for MCP servers (#40728)
sayan-oai4213b38f3c55
diff --git a/codex-rs/app-server/src/request_processors/apps_processor/installed.rs b/codex-rs/app-server/src/request_processors/apps_processor/installed.rsindex a7ce8dd66a..37c650448b 100644--- a/codex-rs/app-server/src/request_processors/apps_processor/installed.rs+++ b/codex-rs/app-server/src/request_processors/apps_processor/installed.rs@@ -14,7 +14,6 @@ use codex_mcp::effective_mcp_servers;use codex_mcp::host_owned_codex_apps_enabled;use codex_mcp::tool_is_model_visible;use codex_protocol::mcp::ClientMcpExtensions;-use codex_protocol::models::PermissionProfile;#[cfg(test)]#[path = "installed_tests.rs"]@@ -57,12 +56,10 @@ impl AppsRequestProcessor {.apps_enabled_for_auth(auth.as_ref().is_some_and(CodexAuth::uses_codex_backend));let mcp_manager = self.thread_manager.mcp_manager();- let mut mcp_config = mcp_manager.runtime_config(&config).await;- // Installed-app discovery has no active turn or reviewer.- mcp_config.permission_profile = PermissionProfile::default();- let mcp_config = Arc::new(mcp_config);+ let mcp_config = mcp_manager.runtime_config(&config).await;let mut mcp_servers = effective_mcp_servers(&mcp_config, auth.as_ref());mcp_servers.retain(|name, _| name == CODEX_APPS_MCP_SERVER_NAME);+ let mcp_config = Arc::new(mcp_config.for_threadless_operations(&mcp_servers));let cache_key = connector_runtime_context_key(auth.as_ref());let previous_snapshot = mcp_manager.codex_apps_tools_cache()diff --git a/codex-rs/app-server/tests/suite/v2/mcp_resource.rs b/codex-rs/app-server/tests/suite/v2/mcp_resource.rsindex 2ccc6ddbee..f4427207b5 100644--- a/codex-rs/app-server/tests/suite/v2/mcp_resource.rs+++ b/codex-rs/app-server/tests/suite/v2/mcp_resource.rs@@ -36,7 +36,6 @@ use codex_protocol::protocol::SessionSource;use core_test_support::responses;use pretty_assertions::assert_eq;use rmcp::handler::server::ServerHandler;-use rmcp::model::BooleanSchema;use rmcp::model::CallToolRequestParams;use rmcp::model::CallToolResult;use rmcp::model::ElicitRequestParams;@@ -47,7 +46,6 @@ use rmcp::model::ListResourcesResult;use rmcp::model::ListToolsResult;use rmcp::model::MetaObject;use rmcp::model::PaginatedRequestParams;-use rmcp::model::PrimitiveSchemaDefinition;use rmcp::model::ProtocolVersion;use rmcp::model::ReadResourceRequestParams;use rmcp::model::ReadResourceResult;@@ -569,7 +567,8 @@ async fn mcp_resource_read_returns_contents_and_declines_elicitation_without_thrr#"chatgpt_base_url = "{apps_server_url}"mcp_oauth_credentials_store = "file"-approval_policy = "on-request"+approval_policy = "never"+sandbox_mode = "danger-full-access"[features]apps = true@@ -979,10 +978,6 @@ impl ServerHandler for ResourceAppsMcpServer {}if uri == TEST_ELICITATION_RESOURCE_URI {let requested_schema = ElicitationSchema::builder()- .required_property(- "confirmed",- PrimitiveSchemaDefinition::Boolean(BooleanSchema::new()),- ).build().map_err(|err| rmcp::ErrorData::internal_error(err.to_string(), None))?;let result = contextdiff --git a/codex-rs/codex-mcp/src/binding.rs b/codex-rs/codex-mcp/src/binding.rsindex 862558de5b..79e1451c08 100644--- a/codex-rs/codex-mcp/src/binding.rs+++ b/codex-rs/codex-mcp/src/binding.rs@@ -10,6 +10,7 @@ use anyhow::Context;use anyhow::Result;use codex_config::AppToolApproval;use codex_protocol::mcp::CallToolResult;+use codex_protocol::models::PermissionProfile;use rmcp::model::ListResourceTemplatesResult;use rmcp::model::ListResourcesResult;use rmcp::model::PaginatedRequestParams;@@ -196,9 +197,10 @@ impl PreparedMcpCall {server_metadata: McpServerMetadata,plugin_id: Option<String>,selected_plugin_server: bool,- ) -> Self {+ ) -> Option<Self> {let server_name = tool_info.server_name.clone();- Self {+ config.permission_profile_for_server(&server_name)?;+ Some(Self {_connections: connections,client,config,@@ -209,7 +211,7 @@ impl PreparedMcpCall {server_metadata,plugin_id,selected_plugin_server,- }+ })}pub fn tool_info(&self) -> &ToolInfo {@@ -221,6 +223,15 @@ impl PreparedMcpCall {&self.config}+ /// Returns the owner permissions validated when this immutable call was prepared.+ pub fn permission_profile(&self) -> &PermissionProfile {+ let Some(permission_profile) = self.config.permission_profile_for_server(&self.server_name)+ else {+ unreachable!("prepared MCP calls retain their immutable permission authority");+ };+ permission_profile+ }+pub fn server_name(&self) -> &str {&self.server_name}diff --git a/codex-rs/codex-mcp/src/binding_tests.rs b/codex-rs/codex-mcp/src/binding_tests.rsindex 2d04479492..b42f75c53a 100644--- a/codex-rs/codex-mcp/src/binding_tests.rs+++ b/codex-rs/codex-mcp/src/binding_tests.rs@@ -105,6 +105,9 @@ async fn test_step(} else {config.approvals_reviewer = ApprovalsReviewer::AutoReview;}+ config+ .server_permission_profiles+ .insert(SERVER_NAME.to_string(), config.permission_profile.clone());let config = Arc::new(config);let prepared = PreparedMcpCall::new(Arc::clone(&connections),@@ -125,7 +128,8 @@ async fn test_step(},Some(format!("{label}-plugin")),label == "old",- );+ )+ .expect("test call should retain its thread-owned permission profile");let calls = HashMap::from([((SERVER_NAME.to_string(), TOOL_NAME.to_string()), prepared)]);TestStep {@@ -213,7 +217,7 @@ async fn prepared_call_keeps_captured_connection_and_authority_after_refresh() -assert_eq!((old_call.config().approval_policy.value(),- &old_call.config().permission_profile,+ old_call.permission_profile(),old_call.config().approvals_reviewer,),(diff --git a/codex-rs/codex-mcp/src/connection_manager.rs b/codex-rs/codex-mcp/src/connection_manager.rsindex 0128c3dac4..d0c50bfa56 100644--- a/codex-rs/codex-mcp/src/connection_manager.rs+++ b/codex-rs/codex-mcp/src/connection_manager.rs@@ -61,8 +61,6 @@ use codex_diagnostics::Gauge;use codex_diagnostics::GaugeGuard;use codex_protocol::mcp::CallToolResult;use codex_protocol::mcp::McpServerInfo;-use codex_protocol::models::PermissionProfile;-use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::Event;use codex_protocol::protocol::EventMsg;use codex_protocol::protocol::McpStartupCompleteEvent;@@ -226,8 +224,6 @@ impl McpConnectionSet {} = input;let store_mode = config.mcp_oauth_credentials_store_mode;let keyring_backend_kind = config.auth_keyring_backend_kind;- let approval_policy = &config.approval_policy;- let initial_permission_profile = config.permission_profile.clone();let codex_home = config.codex_home.clone();let prefix_mcp_tool_names = config.prefix_mcp_tool_names;let non_prefixed_mcp_tool_servers = config.non_prefixed_mcp_tool_servers.clone();@@ -255,8 +251,7 @@ impl McpConnectionSet {let reusable_previous = previous.filter(|previous| {!previous.servers.is_empty()&& previous.elicitation_requests.update(- approval_policy.value(),- initial_permission_profile.clone(),+ Arc::clone(&config),elicitation_reviewer.clone(),elicitation_lifecycle.clone(),)@@ -265,8 +260,7 @@ impl McpConnectionSet {previous.elicitation_requests.clone()} else {ElicitationRequestManager::new(- approval_policy.value(),- initial_permission_profile,+ Arc::clone(&config),elicitation_reviewer,elicitation_lifecycle,elicitation_router,@@ -747,13 +741,7 @@ impl McpConnectionSet {tool_plugin_provenance: Arc::new(ToolPluginProvenance::default()),prefix_mcp_tool_names,non_prefixed_mcp_tool_servers: Vec::new(),- elicitation_requests: ElicitationRequestManager::new(- AskForApproval::Never,- PermissionProfile::default(),- /*reviewer*/ None,- /*lifecycle*/ None,- ElicitationRequestRouter::default(),- ),+ elicitation_requests: ElicitationRequestManager::default(),}}diff --git a/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs b/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rsindex 4075bd616a..ca92e0eeda 100644--- a/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs+++ b/codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs@@ -334,7 +334,7 @@ impl McpConnectionSet {) -> Option<PreparedMcpCall> {let server_name = &tool_info.server_name;let view = self.servers.get(server_name)?;- Some(PreparedMcpCall::new(+ PreparedMcpCall::new(Arc::clone(self),client,config,@@ -345,7 +345,7 @@ impl McpConnectionSet {self.plugin_id_for_mcp_server_name(server_name).map(str::to_string),self.is_selected_plugin_mcp_server(server_name),- ))+ )}/// Force-refresh Codex Apps tools and publish one new exact catalog revision.diff --git a/codex-rs/codex-mcp/src/connection_manager_tests.rs b/codex-rs/codex-mcp/src/connection_manager_tests.rsindex 2347c9120e..e168840c15 100644--- a/codex-rs/codex-mcp/src/connection_manager_tests.rs+++ b/codex-rs/codex-mcp/src/connection_manager_tests.rs@@ -6,6 +6,7 @@ use crate::elicitation::ElicitationRequestRouter;use crate::elicitation::ElicitationReviewRequest;use crate::elicitation::ElicitationReviewer;use crate::elicitation::elicitation_is_rejected_by_policy;+use crate::mcp::tests::test_elicitation_config;use crate::rmcp_client::AsyncManagedClient;use crate::rmcp_client::CODEX_APPS_RECONNECT_INITIAL_BACKOFF;use crate::rmcp_client::CodexAppsStartupReconnect;@@ -43,6 +44,7 @@ use codex_protocol::approvals::ElicitationRequest;use codex_protocol::mcp::ClientMcpExtensions;use codex_protocol::mcp::McpServerInfo;use codex_protocol::models::PermissionProfile;+use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::GranularApprovalConfig;use codex_protocol::protocol::McpStartupFailureReason;use codex_rmcp_client::ElicitationResponse;@@ -104,8 +106,11 @@ impl McpConnectionSet {prefix_mcp_tool_names,non_prefixed_mcp_tool_servers: Vec::new(),elicitation_requests: ElicitationRequestManager::new(- approval_policy.value(),- permission_profile.get().clone(),+ test_elicitation_config(+ "server",+ approval_policy.value(),+ permission_profile.get().clone(),+ ),/*reviewer*/ None,/*lifecycle*/ None,ElicitationRequestRouter::default(),@@ -205,9 +210,15 @@ fn store_current_tools(cache_context: &ConnectorRuntimeContext<ToolInfo>, tools:}async fn capture_binding(manager: &Arc<McpConnectionSet>) -> McpBinding {+ let mut config = crate::mcp::tests::test_mcp_config(std::env::temp_dir());+ config.server_permission_profiles = manager+ .servers+ .keys()+ .map(|name| (name.clone(), PermissionProfile::default()))+ .collect();manager.capture_binding_with_metadata(- Arc::new(crate::mcp::tests::test_mcp_config(std::env::temp_dir())),+ Arc::new(config),/*plugins_available*/ false,/*required_servers*/ &[],)@@ -787,8 +798,7 @@ fn elicitation_granular_policy_respects_never_and_config() {#[tokio::test]async fn disabled_permissions_auto_accept_elicitation_with_empty_form_schema() {let manager = ElicitationRequestManager::new(- AskForApproval::Never,- PermissionProfile::Disabled,+ test_elicitation_config("server", AskForApproval::Never, PermissionProfile::Disabled),/*reviewer*/ None,/*lifecycle*/ None,ElicitationRequestRouter::default(),@@ -822,8 +832,7 @@ async fn disabled_permissions_auto_accept_elicitation_with_empty_form_schema() {#[tokio::test]async fn disabled_permissions_do_not_auto_accept_elicitation_with_requested_fields() {let manager = ElicitationRequestManager::new(- AskForApproval::Never,- PermissionProfile::Disabled,+ test_elicitation_config("server", AskForApproval::Never, PermissionProfile::Disabled),/*reviewer*/ None,/*lifecycle*/ None,ElicitationRequestRouter::default(),@@ -914,8 +923,7 @@ async fn assert_elicitation_declined_with_reviewer_calls() {let reviewer = Arc::new(DecliningElicitationReviewer::default());let manager = ElicitationRequestManager::new(- approval_policy,- PermissionProfile::Disabled,+ test_elicitation_config(server_name, approval_policy, PermissionProfile::Disabled),Some(reviewer.clone()),/*lifecycle*/ None,full_access_form_input_enabled_router(),@@ -955,8 +963,7 @@ async fn assert_requested_user_input_is_declined(router: ElicitationRequestRouter,) {let manager = ElicitationRequestManager::new(- approval_policy,- permission_profile,+ test_elicitation_config("server", approval_policy, permission_profile),/*reviewer*/ None,/*lifecycle*/ None,router,@@ -1043,8 +1050,7 @@ async fn assert_disabled_permissions_surface_requested_user_input(let router = full_access_form_input_enabled_router();let reviewer = Arc::new(DecliningElicitationReviewer::default());let manager = ElicitationRequestManager::new(- AskForApproval::Never,- PermissionProfile::Disabled,+ test_elicitation_config("server", AskForApproval::Never, PermissionProfile::Disabled),Some(reviewer.clone()),/*lifecycle*/ None,router.clone(),@@ -1190,8 +1196,7 @@ async fn on_request_approval_forms_remain_with_the_reviewer() {#[tokio::test]async fn disabled_permissions_decline_user_input_without_an_event_channel() {let manager = ElicitationRequestManager::new(- AskForApproval::Never,- PermissionProfile::Disabled,+ test_elicitation_config("server", AskForApproval::Never, PermissionProfile::Disabled),/*reviewer*/ None,/*lifecycle*/ None,full_access_form_input_enabled_router(),@@ -1222,8 +1227,11 @@ async fn disabled_permissions_decline_user_input_without_an_event_channel() {#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn concurrent_authority_updates_never_auto_approve_mixed_policy() {let manager = ElicitationRequestManager::new(- AskForApproval::Never,- PermissionProfile::default(),+ test_elicitation_config(+ "server",+ AskForApproval::Never,+ PermissionProfile::default(),+ ),/*reviewer*/ None,/*lifecycle*/ None,ElicitationRequestRouter::default(),@@ -1232,14 +1240,20 @@ async fn concurrent_authority_updates_never_auto_approve_mixed_policy() {let updater = tokio::spawn(async move {for _ in 0..1_000 {assert!(updating_manager.update(- AskForApproval::OnRequest,- PermissionProfile::Disabled,+ test_elicitation_config(+ "server",+ AskForApproval::OnRequest,+ PermissionProfile::Disabled+ ),/*reviewer*/ None,/*lifecycle*/ None,));assert!(updating_manager.update(- AskForApproval::Never,- PermissionProfile::default(),+ test_elicitation_config(+ "server",+ AskForApproval::Never,+ PermissionProfile::default()+ ),/*reviewer*/ None,/*lifecycle*/ None,));@@ -1292,15 +1306,21 @@ async fn shared_elicitation_router_targets_the_exact_pending_request() {}});let manager_a = ElicitationRequestManager::new(- AskForApproval::OnRequest,- PermissionProfile::default(),+ test_elicitation_config(+ "server",+ AskForApproval::OnRequest,+ PermissionProfile::default(),+ ),/*reviewer*/ None,Some(lifecycle.clone()),router.clone(),);let manager_b = ElicitationRequestManager::new(- AskForApproval::OnRequest,- PermissionProfile::default(),+ test_elicitation_config(+ "server",+ AskForApproval::OnRequest,+ PermissionProfile::default(),+ ),/*reviewer*/ None,Some(lifecycle),router.clone(),@@ -1392,8 +1412,11 @@ async fn shared_elicitation_router_targets_the_exact_pending_request() {async fn cancelled_elicitation_is_removed_without_affecting_other_pending_requests() {let router = ElicitationRequestRouter::default();let manager = ElicitationRequestManager::new(- AskForApproval::OnRequest,- PermissionProfile::default(),+ test_elicitation_config(+ "server",+ AskForApproval::OnRequest,+ PermissionProfile::default(),+ ),/*reviewer*/ None,/*lifecycle*/ None,router.clone(),@@ -4849,8 +4872,14 @@ async fn reconciliation_updates_elicitation_policy_without_restarting_ready_serv.authority.lock().expect("elicitation authority lock");- authority.approval_policy = AskForApproval::Never;- authority.permission_profile = PermissionProfile::Disabled;+ let config = Arc::make_mut(+ &mut authority+ .as_mut()+ .expect("test manager should have permission authority")+ .config,+ );+ config.approval_policy = Constrained::allow_any(AskForApproval::Never);+ config.permission_profile = PermissionProfile::Disabled;}let reconciled = reconcile_reusable_server(&previous, config, runtime_context).await;@@ -4861,8 +4890,12 @@ async fn reconciliation_updates_elicitation_policy_without_restarting_ready_serv.authority.lock().expect("elicitation authority lock");- assert_eq!(authority.approval_policy, AskForApproval::OnRequest);- assert_eq!(authority.permission_profile, PermissionProfile::default());+ let config = &authority+ .as_ref()+ .expect("reconciled manager should have permission authority")+ .config;+ assert_eq!(config.approval_policy.value(), AskForApproval::OnRequest);+ assert_eq!(config.permission_profile, PermissionProfile::default());}#[tokio::test]diff --git a/codex-rs/codex-mcp/src/elicitation.rs b/codex-rs/codex-mcp/src/elicitation.rsindex 6218419449..7b934e5d63 100644--- a/codex-rs/codex-mcp/src/elicitation.rs+++ b/codex-rs/codex-mcp/src/elicitation.rs@@ -12,6 +12,7 @@ use std::sync::atomic::AtomicBool;use std::sync::atomic::AtomicU64;use std::sync::atomic::Ordering;+use crate::McpConfig;use crate::mcp::McpPermissionPromptAutoApproveContext;use crate::mcp::mcp_permission_prompt_is_auto_approved;use anyhow::Context;@@ -25,7 +26,6 @@ use codex_protocol::mcp_approval_meta::APPROVAL_KIND_KEY;use codex_protocol::mcp_approval_meta::APPROVAL_KIND_TOOL_SUGGESTION;use codex_protocol::mcp_approval_meta::APPROVALS_REVIEWER_KEY;use codex_protocol::mcp_approval_meta::STRICT_AUTO_REVIEW_KEY;-use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::Event;use codex_protocol::protocol::EventMsg;@@ -153,53 +153,48 @@ impl ElicitationRequestRouter {#[derive(Clone)]pub(crate) struct ElicitationAuthority {- pub(crate) approval_policy: AskForApproval,- pub(crate) permission_profile: PermissionProfile,+ pub(crate) config: Arc<McpConfig>,reviewer: Option<ElicitationReviewerHandle>,lifecycle: Option<ElicitationLifecycle>,}-#[derive(Clone)]+#[derive(Clone, Default)]pub(crate) struct ElicitationRequestManager {router: ElicitationRequestRouter,- pub(crate) authority: Arc<StdMutex<ElicitationAuthority>>,+ pub(crate) authority: Arc<StdMutex<Option<ElicitationAuthority>>>,}impl ElicitationRequestManager {pub(crate) fn new(- approval_policy: AskForApproval,- permission_profile: PermissionProfile,+ config: Arc<McpConfig>,reviewer: Option<ElicitationReviewerHandle>,lifecycle: Option<ElicitationLifecycle>,router: ElicitationRequestRouter,) -> Self {Self {router,- authority: Arc::new(StdMutex::new(ElicitationAuthority {- approval_policy,- permission_profile,+ authority: Arc::new(StdMutex::new(Some(ElicitationAuthority {+ config,reviewer,lifecycle,- })),+ }))),}}pub(crate) fn update(&self,- approval_policy: AskForApproval,- permission_profile: PermissionProfile,+ config: Arc<McpConfig>,reviewer: Option<ElicitationReviewerHandle>,lifecycle: Option<ElicitationLifecycle>,) -> bool {let Ok(mut authority) = self.authority.lock() else {return false;};- *authority = ElicitationAuthority {- approval_policy,- permission_profile,+ *authority = Some(ElicitationAuthority {+ config,reviewer,lifecycle,- };+ });true}@@ -237,7 +232,8 @@ impl ElicitationRequestManager {});}- let Ok(authority) = authority.lock().map(|authority| authority.clone()) else {+ let Ok(Some(authority)) = authority.lock().map(|authority| authority.clone())+ else {return Ok(ElicitationResponse {action: ElicitationAction::Decline,content: None,@@ -245,11 +241,19 @@ impl ElicitationRequestManager {});};let ElicitationAuthority {- approval_policy,- permission_profile,+ config,reviewer,lifecycle,} = authority;+ let approval_policy = config.approval_policy.value();+ let Some(permission_profile) = config.permission_profile_for_server(&server_name)+ else {+ return Ok(ElicitationResponse {+ action: ElicitationAction::Decline,+ content: None,+ meta: None,+ });+ };match elicitation.meta()@@ -303,7 +307,7 @@ impl ElicitationRequestManager {let permission_prompt_is_auto_approved = mcp_permission_prompt_is_auto_approved(approval_policy,- &permission_profile,+ permission_profile,McpPermissionPromptAutoApproveContext::default(),);if permission_prompt_is_auto_approved && can_auto_accept_elicitation(&elicitation) {diff --git a/codex-rs/codex-mcp/src/elicitation_tests.rs b/codex-rs/codex-mcp/src/elicitation_tests.rsindex 1c206a0a4e..9bd780ccaf 100644--- a/codex-rs/codex-mcp/src/elicitation_tests.rs+++ b/codex-rs/codex-mcp/src/elicitation_tests.rs@@ -1,5 +1,7 @@use super::*;+use crate::mcp::tests::test_elicitation_config;use async_channel::Receiver;+use codex_protocol::models::PermissionProfile;use codex_protocol::protocol::GranularApprovalConfig;use pretty_assertions::assert_eq;use rmcp::model::ElicitRequestParams;@@ -75,9 +77,16 @@ fn elicitation_fixture(LifecycleRegistration(active_elicitations.clone())})});- let manager = ElicitationRequestManager::new(+ let mut config = test_elicitation_config(+ "independent-mcp",approval_policy,- permission_profile,+ permission_profile.clone(),+ );+ Arc::make_mut(&mut config)+ .server_permission_profiles+ .insert("another-independent-mcp".to_string(), permission_profile);+ let manager = ElicitationRequestManager::new(+ config,reviewer.map(|reviewer| reviewer as Arc<dyn ElicitationReviewer>),lifecycle,ElicitationRequestRouter::default(),@@ -132,8 +141,11 @@ fn closed_event_channel_immediately_cleans_up_pending_elicitation() {/*reviewer*/ None,);assert!(manager.update(- AskForApproval::OnRequest,- PermissionProfile::Disabled,+ test_elicitation_config(+ "independent-mcp",+ AskForApproval::OnRequest,+ PermissionProfile::Disabled+ ),/*reviewer*/ None,Some(lifecycle),));@@ -283,3 +295,106 @@ async fn strict_auto_review_fails_closed_without_a_canonical_decision() {}assert_declined(json!(true), /*response*/ None).await;}++#[tokio::test]+async fn reused_elicitation_senders_follow_each_servers_latest_permission_authority() {+ let mut config = crate::mcp::tests::test_mcp_config(std::env::temp_dir());+ config.approval_policy = codex_config::Constrained::allow_any(AskForApproval::Never);+ config.permission_profile = PermissionProfile::Disabled;+ config.apps_enabled = true;+ let auth = codex_login::CodexAuth::create_dummy_chatgpt_auth_for_testing();++ let hosted_server = crate::codex_apps_mcp_server_config(+ "https://example.com",+ /*apps_mcp_product_sku*/ None,+ /*originator*/ None,+ );+ let mut attached_server = hosted_server.clone();+ attached_server.environment_id = "attached".to_string();+ let mut catalog = crate::ResolvedMcpCatalog::builder();+ catalog.register(crate::McpServerRegistration::from_config(+ "attached".to_string(),+ attached_server,+ ));+ catalog.register(crate::McpServerRegistration::from_hosted_apps(+ "host",+ /*contribution_order*/ 0,+ hosted_server,+ ));+ config.mcp_server_catalog = catalog.build();+ let servers = crate::effective_mcp_servers(&config, Some(&auth));+ config.set_server_permission_profiles(+ &servers,+ [("attached".to_string(), PermissionProfile::read_only())],+ );++ let manager = ElicitationRequestManager::new(+ Arc::new(config.clone()),+ /*reviewer*/ None,+ /*lifecycle*/ None,+ ElicitationRequestRouter::default(),+ );+ let attached = manager.make_sender("attached".to_string(), /*tx_event*/ None);+ let hosted = manager.make_sender(+ crate::CODEX_APPS_MCP_SERVER_NAME.to_string(),+ /*tx_event*/ None,+ );++ assert_eq!(+ send_elicitation(&attached, /*marker*/ None).await.action,+ ElicitationAction::Decline+ );+ assert_eq!(+ send_elicitation(&hosted, /*marker*/ None).await.action,+ ElicitationAction::Accept+ );++ config.set_server_permission_profiles(+ &servers,+ [("attached".to_string(), PermissionProfile::Disabled)],+ );+ assert!(manager.update(+ Arc::new(config.clone()),+ /*reviewer*/ None,+ /*lifecycle*/ None,+ ));+ assert_eq!(+ send_elicitation(&attached, /*marker*/ None).await.action,+ ElicitationAction::Accept+ );++ let mut configured_servers = config.mcp_server_catalog.configured_servers();+ configured_servers+ .get_mut("attached")+ .expect("attached server should be registered")+ .enabled = false;+ config.mcp_server_catalog = config+ .mcp_server_catalog+ .with_materialized_servers(configured_servers);+ let servers = crate::effective_mcp_servers(&config, Some(&auth));+ config.set_server_permission_profiles(+ &servers,+ [("attached".to_string(), PermissionProfile::Disabled)],+ );+ assert!(manager.update(+ Arc::new(config.clone()),+ /*reviewer*/ None,+ /*lifecycle*/ None,+ ));+ assert_eq!(+ send_elicitation(&attached, /*marker*/ None).await.action,+ ElicitationAction::Decline+ );++ let servers = crate::effective_mcp_servers(&config, /*auth*/ None);+ config.set_server_permission_profiles(&servers, std::iter::empty());+ assert!(manager.update(+ Arc::new(config.clone()),+ /*reviewer*/ None,+ /*lifecycle*/ None,+ ));+ assert_eq!(+ send_elicitation(&hosted, /*marker*/ None).await.action,+ ElicitationAction::Decline+ );+}diff --git a/codex-rs/codex-mcp/src/mcp/mod.rs b/codex-rs/codex-mcp/src/mcp/mod.rsindex 3f3e0195ef..05d8a8de68 100644--- a/codex-rs/codex-mcp/src/mcp/mod.rs+++ b/codex-rs/codex-mcp/src/mcp/mod.rs@@ -49,6 +49,7 @@ use serde_json::Value;use tokio_util::sync::CancellationToken;use crate::McpProtocolMode;+use crate::McpServerSource;use crate::ResolvedMcpCatalog;use crate::connection_manager::McpConnectionSet;use crate::runtime::McpPublicationGate;@@ -145,6 +146,8 @@ pub struct McpConfig {pub approvals_reviewer: ApprovalsReviewer,/// Working directories for the exact environment handles used by this runtime.pub environment_cwds: HashMap<String, PathUri>,+ /// Explicit server permissions; unresolved or unavailable servers have no entry.+ pub server_permission_profiles: HashMap<String, PermissionProfile>,/// Optional path to `codex-linux-sandbox` for sandboxed MCP tool execution.pub codex_linux_sandbox_exe: Option<PathBuf>,/// Whether to use legacy Landlock behavior in the MCP sandbox state.@@ -172,6 +175,58 @@ pub struct McpConfig {pub connector_snapshot: ConnectorSnapshot,}+impl McpConfig {+ /// Resolves enabled runtime servers against the exact attachment permissions being published.+ pub fn set_server_permission_profiles(+ &mut self,+ servers: &HashMap<String, EffectiveMcpServer>,+ environment_profiles: impl IntoIterator<Item = (String, PermissionProfile)>,+ ) {+ let environment_profiles = environment_profiles.into_iter().collect::<HashMap<_, _>>();+ self.server_permission_profiles = servers+ .iter()+ .filter(|(_, server)| server.enabled())+ .filter_map(|(server_name, _)| {+ let server = self.mcp_server_catalog.server(server_name)?;+ let permission_profile = if server+ .source()+ .is_host_owned_apps(server_name, server.config())+ {+ &self.permission_profile+ } else if let Some(permission_profile) =+ environment_profiles.get(&server.config().environment_id)+ {+ permission_profile+ } else if server.config().is_local_environment()+ || matches!(server.source(), McpServerSource::SelectedPlugin(_))+ {+ &self.permission_profile+ } else {+ return None;+ };+ Some((server_name.clone(), permission_profile.clone()))+ })+ .collect();+ }++ /// Returns this server's published permission authority.+ pub fn permission_profile_for_server(&self, server_name: &str) -> Option<&PermissionProfile> {+ self.server_permission_profiles.get(server_name)+ }++ /// Standalone discovery and resource reads must not inherit thread execution authority.+ pub fn for_threadless_operations(&self, servers: &HashMap<String, EffectiveMcpServer>) -> Self {+ let mut config = self.clone();+ config.permission_profile = PermissionProfile::default();+ config.server_permission_profiles = servers+ .iter()+ .filter(|(_, server)| server.enabled())+ .map(|(name, _)| (name.clone(), PermissionProfile::default()))+ .collect();+ config+ }+}+#[derive(Debug, Clone, Default, PartialEq, Eq)]pub struct ToolPluginProvenance {plugin_display_names_by_connector_id: HashMap<String, Vec<String>>,@@ -357,8 +412,7 @@ pub async fn read_mcp_resource(let mut mcp_servers = effective_mcp_servers(config, auth);mcp_servers.retain(|name, _| name == server);let cancel_token = CancellationToken::new();- let mut runtime_config = config.clone();- runtime_config.permission_profile = PermissionProfile::default();+ let runtime_config = config.for_threadless_operations(&mcp_servers);let manager = McpConnectionSet::new(/*previous*/ None,McpPublicationGate::already_published(),@@ -433,8 +487,7 @@ pub async fn collect_mcp_server_status_snapshot_with_detail(let server_names = mcp_servers.keys().cloned().collect();let cancel_token = CancellationToken::new();- let mut runtime_config = config.clone();- runtime_config.permission_profile = PermissionProfile::default();+ let runtime_config = config.for_threadless_operations(&mcp_servers);let mcp_connection_manager = McpConnectionSet::new(/*previous*/ None,McpPublicationGate::already_published(),diff --git a/codex-rs/codex-mcp/src/mcp/mod_tests.rs b/codex-rs/codex-mcp/src/mcp/mod_tests.rsindex 79193c6086..350e8f8878 100644--- a/codex-rs/codex-mcp/src/mcp/mod_tests.rs+++ b/codex-rs/codex-mcp/src/mcp/mod_tests.rs@@ -16,6 +16,7 @@ use pretty_assertions::assert_eq;use std::collections::HashMap;use std::collections::HashSet;use std::path::PathBuf;+use std::sync::Arc;pub(crate) fn test_mcp_config(codex_home: PathBuf) -> McpConfig {McpConfig {@@ -32,6 +33,7 @@ pub(crate) fn test_mcp_config(codex_home: PathBuf) -> McpConfig {config_layer_stack: codex_config::ConfigLayerStack::default(),approvals_reviewer: codex_config::types::ApprovalsReviewer::default(),environment_cwds: HashMap::new(),+ server_permission_profiles: HashMap::new(),codex_linux_sandbox_exe: None,use_legacy_landlock: false,apps_enabled: false,@@ -44,6 +46,20 @@ pub(crate) fn test_mcp_config(codex_home: PathBuf) -> McpConfig {}}+pub(crate) fn test_elicitation_config(+ server_name: &str,+ approval_policy: AskForApproval,+ permission_profile: PermissionProfile,+) -> Arc<McpConfig> {+ let mut config = test_mcp_config(PathBuf::new());+ config.approval_policy = Constrained::allow_any(approval_policy);+ config.permission_profile = permission_profile.clone();+ config+ .server_permission_profiles+ .insert(server_name.to_string(), permission_profile);+ Arc::new(config)+}+#[test]fn qualified_mcp_tool_name_prefix_sanitizes_server_names_without_lowercasing() {assert_eq!(@@ -52,6 +68,47 @@ fn qualified_mcp_tool_name_prefix_sanitizes_server_names_without_lowercasing() {);}+#[test]+fn mcp_server_permissions_handle_unattached_and_threadless_servers() {+ let mut config = test_mcp_config(PathBuf::new());+ config.permission_profile = PermissionProfile::Disabled;+ let mut missing_server = codex_apps_mcp_server_config(+ "https://example.com",+ /*apps_mcp_product_sku*/ None,+ /*originator*/ None,+ );+ missing_server.environment_id = "missing".to_string();+ let mut selected_server = missing_server.clone();+ selected_server.environment_id = "unattached".to_string();+ let mut catalog = ResolvedMcpCatalog::builder();+ catalog.register(McpServerRegistration::from_config(+ "missing".to_string(),+ missing_server,+ ));+ catalog.register(McpServerRegistration::from_selected_plugin(+ "selected".to_string(),+ McpPluginAttribution::new("selected@test".to_string(), "Selected".to_string()),+ /*selection_order*/ 0,+ selected_server,+ ));+ config.mcp_server_catalog = catalog.build();+ let servers = effective_mcp_servers(&config, /*auth*/ None);+ assert_eq!(config.permission_profile_for_server("selected"), None);+ config.set_server_permission_profiles(&servers, std::iter::empty());++ assert_eq!(+ config.permission_profile_for_server("selected"),+ Some(&PermissionProfile::Disabled)+ );+ assert_eq!(config.permission_profile_for_server("missing"), None);++ let config = config.for_threadless_operations(&servers);+ assert_eq!(+ config.permission_profile_for_server("selected"),+ Some(&PermissionProfile::default())+ );+}+#[test]fn mcp_prompt_auto_approval_honors_unrestricted_managed_profiles() {assert!(mcp_permission_prompt_is_auto_approved(diff --git a/codex-rs/codex-mcp/src/runtime.rs b/codex-rs/codex-mcp/src/runtime.rsindex af97ffd5dd..57d5299177 100644--- a/codex-rs/codex-mcp/src/runtime.rs+++ b/codex-rs/codex-mcp/src/runtime.rs@@ -104,6 +104,7 @@ struct PublishedMcpRuntime {auth_token: Option<String>,plugins_available: bool,ready_selected_capability_roots: Vec<SelectedCapabilityRoot>,+ selected_environments: HashMap<String, Arc<Environment>>,cached_binding: Mutex<Option<CachedMcpBinding>>,}@@ -174,6 +175,7 @@ impl McpRuntime {auth_token: None,plugins_available: false,ready_selected_capability_roots: Vec::new(),+ selected_environments: HashMap::new(),cached_binding: Mutex::new(None),}),hosted_event_server_removals: watch::channel(()).0,@@ -270,6 +272,7 @@ impl McpRuntime {let auth_token = auth.as_ref().and_then(|auth| auth.get_token().ok());let plugins_available = input.plugins_available;let ready_selected_capability_roots = input.ready_selected_capability_roots.clone();+ let selected_environments = input.runtime_context.selected_environments.clone();let connections = Arc::new(McpConnectionSet::new(previous,@@ -295,6 +298,7 @@ impl McpRuntime {auth_token,plugins_available,ready_selected_capability_roots,+ selected_environments,cached_binding: Mutex::new(None),}));let _ = publish.send(true);@@ -432,6 +436,22 @@ impl McpRuntime {self.current.load().ready_selected_capability_roots.clone()}+ /// Whether this publication uses the currently ready environment handles.+ pub fn current_environments_match(+ &self,+ environments: &HashMap<String, Arc<Environment>>,+ ) -> bool {+ let current = self.current.load();+ current.config.is_some()+ && current.selected_environments.len() == environments.len()+ && environments.iter().all(|(id, environment)| {+ current+ .selected_environments+ .get(id)+ .is_some_and(|published| Arc::ptr_eq(published, environment))+ })+ }+pub fn elicitations_auto_deny(&self) -> bool {self.elicitation_router.auto_deny()}@@ -789,6 +809,7 @@ mod tests {auth_token: None,plugins_available: false,ready_selected_capability_roots: Vec::new(),+ selected_environments: HashMap::new(),cached_binding: Mutex::new(None),});let first = McpRuntime::binding_from_published_runtime(diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex dffcfd3f40..252e9ffa22 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -1725,6 +1725,7 @@ impl Config {config_layer_stack: self.config_layer_stack.clone(),approvals_reviewer: self.approvals_reviewer,environment_cwds: HashMap::new(),+ server_permission_profiles: HashMap::new(),codex_linux_sandbox_exe: self.codex_linux_sandbox_exe.clone(),use_legacy_landlock: self.features.use_legacy_landlock(),apps_enabled: self.features.enabled(Feature::Apps),diff --git a/codex-rs/core/src/connectors.rs b/codex-rs/core/src/connectors.rsindex cea1a81719..ef3b7839fe 100644--- a/codex-rs/core/src/connectors.rs+++ b/codex-rs/core/src/connectors.rs@@ -41,7 +41,6 @@ use codex_mcp::ToolPluginProvenance;use codex_mcp::effective_mcp_servers;use codex_mcp::tool_plugin_provenance;use codex_protocol::mcp::ClientMcpExtensions;-use codex_protocol::models::PermissionProfile;const CONNECTORS_READY_TIMEOUT_ON_EMPTY_TOOLS: Duration = Duration::from_secs(30);@@ -224,10 +223,7 @@ pub async fn list_accessible_connectors_from_mcp_tools_with_mcp_manager(});}let cache_key = accessible_connectors_cache_key(config, auth.as_ref());- let mut mcp_config = mcp_manager.runtime_config(config).await;- // Discovery has no active turn or reviewer and must never inherit execution authority.- mcp_config.permission_profile = PermissionProfile::default();- let mcp_config = Arc::new(mcp_config);+ let mcp_config = mcp_manager.runtime_config(config).await;let tool_plugin_provenance = tool_plugin_provenance(&mcp_config);if !force_refetch && let Some(cached_connectors) = read_cached_accessible_connectors(&cache_key){@@ -240,6 +236,7 @@ pub async fn list_accessible_connectors_from_mcp_tools_with_mcp_manager(let mut mcp_servers = effective_mcp_servers(&mcp_config, auth.as_ref());mcp_servers.retain(|name, _| name == CODEX_APPS_MCP_SERVER_NAME);+ let mcp_config = Arc::new(mcp_config.for_threadless_operations(&mcp_servers));if mcp_servers.is_empty() {return Ok(AccessibleConnectorsStatus {connectors: Vec::new(),diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rsindex 1b9057478c..038a9a24c4 100644--- a/codex-rs/core/src/mcp_tool_call.rs+++ b/codex-rs/core/src/mcp_tool_call.rs@@ -59,6 +59,7 @@ use codex_protocol::mcp_approval_meta::TOOL_DESCRIPTION_KEY as MCP_TOOL_APPROVALuse codex_protocol::mcp_approval_meta::TOOL_PARAMS_DISPLAY_KEY as MCP_TOOL_APPROVAL_TOOL_PARAMS_DISPLAY_KEY;use codex_protocol::mcp_approval_meta::TOOL_PARAMS_KEY as MCP_TOOL_APPROVAL_TOOL_PARAMS_KEY;use codex_protocol::mcp_approval_meta::TOOL_TITLE_KEY as MCP_TOOL_APPROVAL_TOOL_TITLE_KEY;+use codex_protocol::models::PermissionProfile;use codex_protocol::openai_models::InputModality;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::McpInvocation;@@ -243,6 +244,7 @@ pub(crate) async fn handle_mcp_tool_call(&hook_tool_name,&metadata,prepared_call.config(),+ prepared_call.permission_profile(),approval_policy,).await@@ -775,9 +777,8 @@ async fn augment_mcp_tool_request_meta_with_sandbox_state(};// TODO(anp): Build this metadata from the server's captured// TurnEnvironment::sandbox_context instead of the runtime-wide Landlock value.- let permission_profile = prepared_call.config().permission_profile.clone();let sandbox_state = serde_json::to_value(SandboxState {- permission_profile,+ permission_profile: prepared_call.permission_profile().clone(),codex_linux_sandbox_exe: prepared_call.config().codex_linux_sandbox_exe.clone(),sandbox_cwd,use_legacy_landlock: prepared_call.config().use_legacy_landlock,@@ -1301,6 +1302,7 @@ async fn maybe_request_mcp_tool_approval(hook_tool_name: &HookToolName,metadata: &McpToolApprovalMetadata,config: &codex_mcp::McpConfig,+ permission_profile: &PermissionProfile,policy: McpToolApprovalPolicy,) -> Option<ReviewDecision> {let turn_context = &step_context.turn;@@ -1324,7 +1326,7 @@ async fn maybe_request_mcp_tool_approval(if !strict_auto_review&& mcp_permission_prompt_is_auto_approved(config.approval_policy.value(),- &config.permission_profile,+ permission_profile,McpPermissionPromptAutoApproveContext {tool_approval_mode: Some(policy.mode),},diff --git a/codex-rs/core/src/mcp_tool_call_tests.rs b/codex-rs/core/src/mcp_tool_call_tests.rsindex e8fd9f9f46..51b983339f 100644--- a/codex-rs/core/src/mcp_tool_call_tests.rs+++ b/codex-rs/core/src/mcp_tool_call_tests.rs@@ -2335,6 +2335,7 @@ async fn approve_mode_skips_when_annotations_do_not_require_approval() {&HookToolName::new("mcp__test__tool"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Approve),).await;@@ -2415,6 +2416,7 @@ async fn guardian_mode_skips_auto_when_annotations_do_not_require_approval() {&HookToolName::new("mcp__test__tool"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Auto),).await;@@ -2477,6 +2479,7 @@ async fn permission_request_hook_allows_mcp_tool_call() {&HookToolName::new("mcp__memory__create_entities"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Auto),).await;@@ -2547,6 +2550,7 @@ async fn permission_request_hook_uses_hook_tool_name_without_metadata() {&HookToolName::new("mcp__memory__create_entities"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Auto),).await;@@ -2632,6 +2636,7 @@ async fn permission_request_hook_runs_after_remembered_mcp_approval() {&HookToolName::new("mcp__memory__create_entities"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Auto),).await;@@ -2731,6 +2736,7 @@ async fn strict_auto_review_forces_guardian_for_mcp_policy_skip() {&HookToolName::new("mcp__test__tool"),&metadata,&captured_mcp_config,+ &captured_mcp_config.permission_profile,McpToolApprovalPolicy::for_server(AppToolApproval::Approve),).await;@@ -2808,6 +2814,7 @@ async fn assert_mcp_user_approval_persistence(&HookToolName::new("mcp__memory__create_entities"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Auto),).await@@ -2893,6 +2900,7 @@ async fn prompt_mode_waits_for_approval_when_annotations_do_not_require_approval&HookToolName::new("mcp__test__tool"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Prompt),).await@@ -2958,6 +2966,7 @@ async fn full_access_mode_skips_mcp_tool_approval_for_all_approval_modes() {&HookToolName::new("mcp__test__tool"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(approval_mode),).await;@@ -3051,6 +3060,7 @@ async fn approve_mode_skips_guardian_in_every_permission_mode() {&HookToolName::new("mcp__test__tool"),&metadata,&approval_config(&turn_context),+ turn_context.config.permissions.permission_profile(),McpToolApprovalPolicy::for_server(AppToolApproval::Approve),).await;diff --git a/codex-rs/core/src/session/mcp.rs b/codex-rs/core/src/session/mcp.rsindex 847f6e21da..026330b541 100644--- a/codex-rs/core/src/session/mcp.rs+++ b/codex-rs/core/src/session/mcp.rs@@ -178,6 +178,24 @@ impl Session {return;};loop {+ let environments = self.services.turn_environments.snapshot().await;+ let ready_environments = environments+ .turn_environments()+ .map(|environment| {+ (+ environment.selection.environment_id.clone(),+ Arc::clone(&environment.environment),+ )+ })+ .collect();+ // Attachment resolution can finish after the owner's configuration callback.+ if !self+ .services+ .mcp_runtime+ .current_environments_match(&ready_environments)+ {+ self.mark_mcp_runtime_dirty();+ }let auth = self.services.auth_manager.auth_cached();if !self.services@@ -232,9 +250,6 @@ impl Session {).await;refresh_invalidation.published = true;- if !self.mcp_refresh.is_pending() {- return;- }}}@@ -813,9 +828,14 @@ async fn review_guardian_mcp_elicitation(let approval_policy = mcp_config.approval_policy.value();match approval_policy {AskForApproval::Never => {+ let Some(permission_profile) =+ mcp_config.permission_profile_for_server(&request.server_name)+ else {+ return Ok(Some(mcp_elicitation_decline_without_message()));+ };if codex_mcp::mcp_permission_prompt_is_auto_approved(approval_policy,- &mcp_config.permission_profile,+ permission_profile,codex_mcp::McpPermissionPromptAutoApproveContext::default(),) && matches!(&request.elicitation,diff --git a/codex-rs/core/src/session/mcp_refresh.rs b/codex-rs/core/src/session/mcp_refresh.rsindex 19cf2f8b9b..9afd414bf6 100644--- a/codex-rs/core/src/session/mcp_refresh.rs+++ b/codex-rs/core/src/session/mcp_refresh.rs@@ -22,6 +22,7 @@ impl McpRefresh {self.pending.store(true, Ordering::Release);}+ #[cfg(test)]pub(super) fn is_pending(&self) -> bool {self.pending.load(Ordering::Acquire)}diff --git a/codex-rs/core/src/session/mcp_runtime.rs b/codex-rs/core/src/session/mcp_runtime.rsindex 10029b8a8f..010769ca22 100644--- a/codex-rs/core/src/session/mcp_runtime.rs+++ b/codex-rs/core/src/session/mcp_runtime.rs@@ -333,8 +333,17 @@ impl Session {.environment_cwds.entry(codex_config::DEFAULT_MCP_SERVER_ENVIRONMENT_ID.to_string()).or_insert_with(|| PathUri::from_abs_path(&desired.config.cwd));+ let mcp_servers = effective_mcp_servers(&config, auth.as_ref());+ config.set_server_permission_profiles(+ &mcp_servers,+ desired.environments.turn_environments().map(|environment| {+ (+ environment.selection.environment_id.clone(),+ environment.permission_profile_with_workspace_roots(),+ )+ }),+ );let mcp_config = Arc::new(config);- let mcp_servers = effective_mcp_servers(&mcp_config, auth.as_ref());let runtime_context = McpRuntimeContext::new(self.services.turn_environments.environment_manager(),desired.local_process_cwd.clone(),diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 211cd48c90..77709e494b 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -169,6 +169,7 @@ use core_test_support::PathExt;use core_test_support::context_snapshot;use core_test_support::context_snapshot::ContextSnapshotOptions;use core_test_support::context_snapshot::ContextSnapshotRenderMode;+use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;use core_test_support::responses::ev_response_created;use core_test_support::responses::mount_sse_once;@@ -8777,7 +8778,33 @@ async fn refreshed_mcp_binding_captures_current_approval_authority() {#[tokio::test]async fn mcp_elicitation_reviewer_uses_latest_runtime_authority() {- let (session, old_turn, rx) = make_session_and_context_with_rx().await;+ let guardian_server = start_mock_server().await;+ mount_sse_once(+ &guardian_server,+ sse(vec![+ ev_response_created("guardian-review"),+ ev_assistant_message("guardian-review", r#"{"outcome":"allow"}"#),+ ev_completed("guardian-review"),+ ]),+ )+ .await;+ let (session, old_turn, rx) = make_session_and_context_with_auth_and_config_and_rx(+ CodexAuth::from_api_key("Test API Key"),+ Vec::new(),+ |config| {+ config.model_provider.base_url = Some(format!("{}/v1", guardian_server.uri()));+ config+ .mcp_servers+ .set(+ serde_json::from_value(json!({+ "browser-use": { "command": "missing-test-mcp-server" }+ }))+ .expect("test MCP server configuration should deserialize"),+ )+ .expect("test MCP server should be configurable");+ },+ )+ .await;assert_eq!(old_turn.config.approvals_reviewer, ApprovalsReviewer::User);session.spawn_task(@@ -8870,7 +8897,7 @@ async fn mcp_elicitation_reviewer_uses_latest_runtime_authority() {assert_eq!(session.mcp_elicitation_reviewer()- .review(request)+ .review(request.clone()).await.expect("elicitation review should succeed"),Some(ElicitationResponse {@@ -8880,6 +8907,39 @@ async fn mcp_elicitation_reviewer_uses_latest_runtime_authority() {}));+ let selection = session+ .services+ .turn_environments+ .selections()+ .into_iter()+ .next()+ .expect("session should select its executor environment");+ let mut owner_config = old_turn+ .environments+ .primary()+ .expect("ready environment")+ .config()+ .clone();+ owner_config.permission_profile =+ PermissionProfileSnapshot::legacy(PermissionProfile::read_only());+ session+ .environment_ready(&selection, owner_config)+ .await+ .expect("attachment owner should install its restricted permissions");+ session.refresh_mcp_if_dirty().await;+ assert_eq!(+ session+ .mcp_elicitation_reviewer()+ .review(request)+ .await+ .expect("elicitation review should succeed"),+ Some(ElicitationResponse {+ action: ElicitationAction::Decline,+ content: None,+ meta: Some(json!({ "approvals_reviewer": "auto_review" })),+ })+ );+session.abort_all_tasks(TurnAbortReason::Interrupted).await;}diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex bab8d92c51..c1f667f1d9 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -143,14 +143,9 @@ impl TurnEnvironment {}pub(crate) fn permission_profile_with_workspace_roots(&self) -> PermissionProfile {- let workspace_roots = self- .workspace_roots()- .iter()- .filter_map(|workspace_root| workspace_root.to_abs_path().ok())- .collect::<Vec<_>>();self.permission_profile().clone()- .materialize_project_roots_with_workspace_roots(&workspace_roots)+ .materialize_project_roots_with_path_uris(self.workspace_roots())}pub(crate) fn selection(&self) -> TurnEnvironmentSelection {diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex 73d243b631..d4f011254a 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -871,6 +871,8 @@ async fn settings_update_does_not_retarget_active_turn_environment() -> Result<(async fn deferred_executor_promotes_primary_environment_when_startup_completes() -> Result<()> {let listener = TcpListener::bind("127.0.0.1:0").await?;let server = start_mock_server().await;+ let apps = core_test_support::apps_test_server::AppsTestServer::mount(&server).await?;+ let mcp_url = format!("{}/api/codex/ps/mcp", apps.chatgpt_base_url);let response_mock = mount_sse_sequence(&server,vec![@@ -912,7 +914,20 @@ async fn deferred_executor_promotes_primary_environment_when_startup_completes().await;let mut builder = test_codex().with_exec_server_url(format!("ws://{}", listener.local_addr()?))- .with_config(|config| {+ .with_model_info_override("gpt-5.4", |model| model.supports_search_tool = false)+ .with_config(move |config| {+ config+ .mcp_servers+ .set(HashMap::from([(+ "deferred".to_string(),+ serde_json::from_value(json!({+ "url": mcp_url,+ "environment_id": REMOTE_ENVIRONMENT_ID,+ "startup_timeout_sec": 60,+ }))+ .expect("MCP server config"),+ )]))+ .expect("set MCP server");config.project_doc_max_bytes = 0;assert!(config.features.enable(Feature::DeferredExecutor).is_ok());assert!(@@ -966,8 +981,56 @@ async fn deferred_executor_promotes_primary_environment_when_startup_completes()assert!(initial_context.contains("<environment id=\"local\" primary=\"true\">"));assert!(initial_context.contains("<environment id=\"remote\" primary=\"false\">"));assert!(initial_context.contains("<status>starting</status>"));+ assert!(+ requests[1]+ .tool_by_name("mcp__deferred", "calendar_list_events")+ .is_none()+ );- serve_environment_info(listener).await;+ let mut websocket = accept_initialized_exec_server(listener).await;+ // Forward MCP HTTP through the fake executor while keeping startup under test control.+ let http_client =+ codex_exec_server::Environment::create_for_tests(/*exec_server_url*/ None)?+ .get_http_client();+ let executor = tokio::spawn(async move {+ loop {+ let request = read_exec_server_json(&mut websocket).await;+ let Some(id) = request.get("id") else {+ continue;+ };+ let mut messages = Vec::new();+ if request["method"] == "http/request" {+ let params = serde_json::from_value(request["params"].clone()).unwrap();+ let mut response =+ serde_json::to_value(http_client.http_request(params).await.unwrap()).unwrap();+ if request["params"]["streamResponse"] == true {+ let body = response["bodyBase64"].take();+ response["bodyBase64"] = json!("");+ messages.push(json!({+ "method": "http/request/bodyDelta",+ "params": { "requestId": request["params"]["requestId"], "seq": 1,+ "deltaBase64": body, "done": true }+ }));+ }+ messages.insert(0, json!({ "id": id, "result": response }));+ } else if request["method"] == "environment/info" {+ messages.push(json!({ "id": id,+ "result": { "shell": { "name": "zsh", "path": "/bin/zsh" } }+ }));+ } else {+ messages.push(+ json!({ "id": id, "error": { "code": -32601, "message": "unsupported" } }),+ );+ }+ for message in messages {+ websocket+ .send(Message::Text(message.to_string().into()))+ .await+ .unwrap();+ }+ }+ });+ core_test_support::wait_for_mcp_server(&test.codex, "deferred").await?;test.codex.submit(Op::UserInputAnswer {id: request.turn_id,@@ -987,6 +1050,11 @@ async fn deferred_executor_promotes_primary_environment_when_startup_completes().await;let requests = response_mock.requests();+ assert!(+ requests[2]+ .tool_by_name("mcp__deferred", "calendar_list_events")+ .is_some()+ );let updated_context = requests[2].message_input_texts("user").into_iter()@@ -1017,6 +1085,8 @@ async fn deferred_executor_promotes_primary_environment_when_startup_completes()Some(&Value::Null));+ executor.abort();+ let _ = executor.await;Ok(())}diff --git a/codex-rs/core/tests/suite/rmcp_client.rs b/codex-rs/core/tests/suite/rmcp_client.rsindex a9def0d0fc..ec6be70b83 100644--- a/codex-rs/core/tests/suite/rmcp_client.rs+++ b/codex-rs/core/tests/suite/rmcp_client.rs@@ -61,6 +61,12 @@ use codex_protocol::openai_models::ModelVisibility;use codex_protocol::openai_models::ModelsResponse;use codex_protocol::openai_models::ReasoningEffortPreset;use codex_protocol::openai_models::TruncationPolicyConfig;+use codex_protocol::permissions::FileSystemAccessMode;+use codex_protocol::permissions::FileSystemPath;+use codex_protocol::permissions::FileSystemSandboxEntry;+use codex_protocol::permissions::FileSystemSandboxPolicy;+use codex_protocol::permissions::FileSystemSpecialPath;+use codex_protocol::permissions::NetworkSandboxPolicy;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::EnvironmentConfigState;use codex_protocol::protocol::EventMsg;@@ -1541,14 +1547,16 @@ async fn local_stdio_server_uses_runtime_fallback_cwd_when_config_omits_cwd() ->Ok(())}-#[test_case(false, false; "both disabled")]-#[test_case(true, false; "auto review required")]-#[test_case(false, true; "disabled")]-#[test_case(true, true; "both enabled")]+#[test_case(false, false, false; "both disabled")]+#[test_case(true, false, false; "auto review required")]+#[test_case(false, true, false; "disabled")]+#[test_case(true, true, false; "both enabled")]+#[test_case(false, false, true; "attachment-owned permissions preserve foreign workspace roots")]#[tokio::test(flavor = "multi_thread", worker_threads = 1)]async fn stdio_mcp_tool_call_includes_sandbox_state_meta(node_repl_auto_review_required: bool,node_repl_disabled: bool,+ attachment_owned_permissions: bool,) -> anyhow::Result<()> {// TODO(anp): Remove after packaging a Windows stdio test server for Wine exec.skip_if_wine_exec!(@@ -1560,6 +1568,7 @@ async fn stdio_mcp_tool_call_includes_sandbox_state_meta(let server = responses::start_mock_server().await;let call_id = "sandbox-meta-call";+ let restricted_call_id = "owner-restricted-call";let server_name = "rmcp";let namespace = format!("mcp__{server_name}");let mut models = codex_models_manager::bundled_models_response()?;@@ -1572,15 +1581,20 @@ async fn stdio_mcp_tool_call_includes_sandbox_state_meta(model.node_repl_disabled = node_repl_disabled;let models_mock = mount_models_once(&server, models).await;- let initial_mock = mount_sse_once(- &server,- responses::sse(vec![- responses::ev_response_created("resp-1"),- responses::ev_function_call_with_namespace(call_id, &namespace, "sandbox_meta", "{}"),- responses::ev_completed("resp-1"),- ]),- )- .await;+ let mut response_events = vec![+ responses::ev_response_created("resp-1"),+ responses::ev_function_call_with_namespace(call_id, &namespace, "sandbox_meta", "{}"),+ ];+ if attachment_owned_permissions {+ response_events.push(responses::ev_function_call_with_namespace(+ restricted_call_id,+ &namespace,+ "sync",+ "{}",+ ));+ }+ response_events.push(responses::ev_completed("resp-1"));+ let initial_mock = mount_sse_once(&server, responses::sse(response_events)).await;let final_mock = mount_sse_once(&server,responses::sse(vec![@@ -1609,6 +1623,91 @@ async fn stdio_mcp_tool_call_includes_sandbox_state_meta(.await?;wait_for_mcp_server(&fixture.codex, server_name).await?;+ let owner_permission_profile = if attachment_owned_permissions {+ PermissionProfile::from_runtime_permissions(+ &FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Write,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::project_roots(/*subpath*/ None),+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::project_roots(Some(".git".to_string())),+ },+ FileSystemAccessMode::Read,+ ),+ ]),+ NetworkSandboxPolicy::Restricted,+ )+ } else {+ PermissionProfile::read_only()+ };+ let owner_workspace_roots = if attachment_owned_permissions {+ let selection = fixture+ .codex+ .environment_selections()+ .await+ .into_iter()+ .find(|selection| selection.environment_id == remote_aware_environment_id())+ .context("thread should select the MCP server's executor environment")?;+ let selection = TurnEnvironmentSelection {+ workspace_roots: vec![PathUri::parse(if cfg!(windows) {+ "file:///foreign/workspace"+ } else {+ "file:///C:/workspace"+ })?],+ ..selection+ };+ submit_thread_settings(+ &fixture.codex,+ ThreadSettingsOverrides {+ environments: Some(TurnEnvironmentSelections::new(+ fixture.config.cwd.clone(),+ vec![TurnEnvironmentSelection {+ config: EnvironmentConfigState::Pending,+ ..selection.clone()+ }],+ )),+ ..Default::default()+ },+ )+ .await?;+ let workspace_roots = selection.workspace_roots.clone();+ fixture+ .codex+ .environment_ready(+ &selection,+ EnvironmentConfig {+ allow_login_shell: fixture.config.permissions.allow_login_shell,+ permission_profile: PermissionProfileSnapshot::legacy(+ owner_permission_profile.clone(),+ ),+ shell_environment_policy: Default::default(),+ windows_sandbox_level: WindowsSandboxLevel::from_config(&fixture.config),+ windows_sandbox_private_desktop: fixture+ .config+ .permissions+ .windows_sandbox_private_desktop,+ use_legacy_landlock: fixture.config.features.use_legacy_landlock(),+ exec_policy: None,+ mcp_policy: None,+ network_policy: None,+ selected_capability_roots: Vec::new(),+ },+ )+ .await?;+ workspace_roots+ } else {+ Vec::new()+ };fixture.thread_manager.get_models_manager()@@ -1622,7 +1721,11 @@ async fn stdio_mcp_tool_call_includes_sandbox_state_meta(fixture.submit_turn_with_permission_profile("call the rmcp sandbox_meta tool",- PermissionProfile::read_only(),+ if attachment_owned_permissions {+ PermissionProfile::Disabled+ } else {+ PermissionProfile::read_only()+ },).await?;@@ -1641,7 +1744,19 @@ async fn stdio_mcp_tool_call_includes_sandbox_state_meta(json!(node_repl_disabled));- let output_item = final_mock.single_request().function_call_output(call_id);+ let final_request = final_mock.single_request();+ if attachment_owned_permissions {+ let restricted_output = final_request+ .function_call_output_text(restricted_call_id)+ .expect("restricted MCP tool should produce a denied call output");+ assert!(+ restricted_output+ .contains("MCP tool call requires approval, but approval policy is never"),+ "attachment-owned permissions should deny the mutable MCP tool: {restricted_output}"+ );+ }++ let output_item = final_request.function_call_output(call_id);let output_text = output_item.get("output").and_then(Value::as_str)@@ -1665,10 +1780,26 @@ async fn stdio_mcp_tool_call_includes_sandbox_state_meta(.get(MCP_SANDBOX_STATE_META_CAPABILITY).expect("sandbox state metadata should be present");let sandbox_state: SandboxState = serde_json::from_value(sandbox_meta.clone())?;+ if attachment_owned_permissions {+ let workspace_root = &owner_workspace_roots[0];+ for path in [workspace_root.clone(), workspace_root.join(".git")?] {+ let expected_entry =+ FileSystemSandboxEntry::new(path.into(), FileSystemAccessMode::Read);+ assert!(+ sandbox_state+ .permission_profile+ .file_system_sandbox_policy()+ .entries+ .contains(&expected_entry),+ "foreign workspace root should retain its owner restriction: {expected_entry:?}"+ );+ }+ }assert_eq!(sandbox_state,SandboxState {- permission_profile: PermissionProfile::read_only(),+ permission_profile: owner_permission_profile+ .materialize_project_roots_with_path_uris(&owner_workspace_roots),codex_linux_sandbox_exe: fixture.config.codex_linux_sandbox_exe.clone(),sandbox_cwd: PathUri::from_abs_path(&fixture.config.cwd),use_legacy_landlock: false,diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rsindex e8bcab9c98..4d02ef8d2b 100644--- a/codex-rs/protocol/src/models.rs+++ b/codex-rs/protocol/src/models.rs@@ -548,15 +548,28 @@ impl PermissionProfile {pub fn materialize_project_roots_with_workspace_roots(self,workspace_roots: &[AbsolutePathBuf],+ ) -> Self {+ self.materialize_project_roots_with(|policy| {+ policy.materialize_project_roots_with_workspace_roots(workspace_roots)+ })+ }++ pub fn materialize_project_roots_with_path_uris(self, workspace_roots: &[PathUri]) -> Self {+ self.materialize_project_roots_with(|policy| {+ policy.materialize_project_roots_with_path_uris(workspace_roots)+ })+ }++ fn materialize_project_roots_with(+ self,+ materialize: impl FnOnce(FileSystemSandboxPolicy) -> FileSystemSandboxPolicy,) -> Self {match self {Self::Managed {file_system,network,} => {- let file_system = file_system- .to_sandbox_policy()- .materialize_project_roots_with_workspace_roots(workspace_roots);+ let file_system = materialize(file_system.to_sandbox_policy());Self::Managed {file_system: ManagedFileSystemPermissions::from_sandbox_policy(&file_system),network,diff --git a/codex-rs/protocol/src/permissions.rs b/codex-rs/protocol/src/permissions.rsindex e94ed5c60b..38d9c4b78f 100644--- a/codex-rs/protocol/src/permissions.rs+++ b/codex-rs/protocol/src/permissions.rs@@ -7,6 +7,7 @@ use std::path::PathBuf;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_absolute_path::canonicalize_preserving_symlinks;use codex_utils_path_uri::LegacyAppPathString;+use codex_utils_path_uri::PathConvention;use codex_utils_path_uri::PathUri;use globset::GlobBuilder;use globset::GlobMatcher;@@ -1030,6 +1031,65 @@ impl FileSystemSandboxPolicy {self}+ /// Materializes workspace-root entries without projecting executor paths onto the host.+ pub fn materialize_project_roots_with_path_uris(mut self, workspace_roots: &[PathUri]) -> Self {+ if let Ok(native_workspace_roots) = workspace_roots+ .iter()+ .map(PathUri::to_abs_path)+ .collect::<Result<Vec<_>, _>>()+ {+ return self.materialize_project_roots_with_workspace_roots(&native_workspace_roots);+ }++ let mut entries = Vec::with_capacity(self.entries.len());+ for entry in self.entries {+ let (subpath, is_glob) = match &entry.path {+ FileSystemPath::Special {+ value: FileSystemSpecialPath::ProjectRoots { subpath },+ } => (subpath.as_deref(), false),+ FileSystemPath::GlobPattern { pattern }+ if pattern.starts_with(PROJECT_ROOTS_GLOB_PATTERN_PREFIX) =>+ {+ (+ Some(&pattern[PROJECT_ROOTS_GLOB_PATTERN_PREFIX.len()..]),+ true,+ )+ }+ _ => {+ entries.push(entry);+ continue;+ }+ };+ entries.extend(workspace_roots.iter().filter_map(|root| {+ let path = subpath.map_or_else(+ || Some(root.clone()),+ |subpath| resolve_scoped_workspace_path(root, subpath),+ );+ let (path, access) = match path {+ Some(path) if is_glob => (+ FileSystemPath::GlobPattern {+ pattern: path.inferred_native_path_string(),+ },+ entry.access,+ ),+ Some(path) => (FileSystemPath::Path { path }, entry.access),+ None if !entry.access.can_write() => (+ FileSystemPath::Path { path: root.clone() },+ FileSystemAccessMode::Deny,+ ),+ None => return None,+ };+ Some(FileSystemSandboxEntry {+ path,+ access,+ missing_path_behavior: entry.missing_path_behavior,+ })+ }));+ }+ self.entries = entries;+ self+ }+/// Preserves symbolic `:workspace_roots` entries while also adding concrete/// entries for each provided workspace root.pub fn with_materialized_project_roots_for_workspace_roots(@@ -1600,6 +1660,28 @@ fn resolve_candidate_path(path: &Path, cwd: &Path) -> Option<AbsolutePathBuf> {}}+/// Resolves a workspace-relative path using the root's own path convention.+///+/// Rejects absolute paths, traversal, Windows drive changes, and any result+/// outside the root so foreign-platform permission rules cannot escape scope.+fn resolve_scoped_workspace_path(root: &PathUri, subpath: &str) -> Option<PathUri> {+ let convention = root.infer_path_convention()?;+ if subpath.starts_with('/')+ || convention == PathConvention::Windows && subpath.starts_with('\\')+ || convention+ .path_segments(subpath)+ .any(|segment| segment == "." || segment == "..")+ || convention == PathConvention::Windows+ && convention+ .path_segments(subpath)+ .any(|segment| segment.contains(':'))+ {+ return None;+ }+ let path = root.join(subpath).ok()?;+ path.starts_with(root).then_some(path)+}+/// Returns true when two config paths refer to the same exact target before/// any prefix matching is applied.///