From 097f431a887f493afc598fcacc631a7dceca1935 Mon Sep 17 00:00:00 2001 From: Felipe Coury Date: Sun, 12 Apr 2026 21:57:21 -0300 Subject: [PATCH] feat(app-server): gate narrow permission requests by capability Gate the `request_permissions` tool and the app-server request delivery path on the surface capability handshake from `initialize`. The server now only emits narrow permission approval requests to subscribed connections that explicitly advertised support. Keep the preset flow out of this branch so the review stays focused on one transport path. Until the preset picker branch lands, app-server surfaces continue to hide `request_permission_preset` even if they advertise the future capability. --- .../app-server/src/bespoke_event_handling.rs | 13 +- .../app-server/src/codex_message_processor.rs | 71 +++- codex-rs/app-server/src/outgoing_message.rs | 12 + codex-rs/app-server/src/thread_state.rs | 54 +++- .../tests/suite/v2/request_permissions.rs | 306 +++++++++++++++--- 5 files changed, 406 insertions(+), 50 deletions(-) diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index 08a51108ae..6baf26bc8a 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -168,6 +168,7 @@ pub(crate) async fn apply_bespoke_event_handling( conversation: Arc, thread_manager: Arc, outgoing: ThreadScopedOutgoingMessageSender, + request_permissions_outgoing: ThreadScopedOutgoingMessageSender, thread_state: Arc>, thread_watch_manager: ThreadWatchManager, api_version: ApiVersion, @@ -854,7 +855,7 @@ pub(crate) async fn apply_bespoke_event_handling( } } EventMsg::RequestPermissions(request) => { - if matches!(api_version, ApiVersion::V2) { + if matches!(api_version, ApiVersion::V2) && !request_permissions_outgoing.is_empty() { let permission_guard = thread_watch_manager .note_permission_requested(&conversation_id.to_string()) .await; @@ -866,7 +867,7 @@ pub(crate) async fn apply_bespoke_event_handling( reason: request.reason, permissions: request.permissions.into(), }; - let (pending_request_id, rx) = outgoing + let (pending_request_id, rx) = request_permissions_outgoing .send_request(ServerRequestPayload::PermissionsRequestApproval(params)) .await; tokio::spawn(async move { @@ -882,8 +883,11 @@ pub(crate) async fn apply_bespoke_event_handling( .await; }); } else { - error!( - "request_permissions is only supported on api v2 (call_id: {})", + // App-server clients must advertise support before receiving + // permission confirmation requests. Fail closed instead of + // emitting a request that existing clients cannot answer. + warn!( + "request_permissions is not supported by this app-server client (call_id: {})", request.call_id ); let empty = CoreRequestPermissionsResponse { @@ -3058,6 +3062,7 @@ mod tests { self.conversation.clone(), self.thread_manager.clone(), self.outgoing.clone(), + self.outgoing.clone(), self.thread_state.clone(), self.thread_watch_manager.clone(), ApiVersion::V2, diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index a613539586..855e864250 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -2331,6 +2331,13 @@ impl CodexMessageProcessor { }; } + apply_surface_capability_feature_gates( + &mut config, + &listener_task_context.thread_state_manager, + &request_id, + ) + .await; + let instruction_sources = Self::instruction_sources_from_config(&config).await; let dynamic_tools = dynamic_tools.unwrap_or_default(); let core_dynamic_tools = if dynamic_tools.is_empty() { @@ -3886,7 +3893,7 @@ impl CodexMessageProcessor { let cloud_requirements = self.current_cloud_requirements(); let cli_overrides = self.current_cli_overrides(); let runtime_feature_enablement = self.current_runtime_feature_enablement(); - let config = match derive_config_for_cwd( + let mut config = match derive_config_for_cwd( &cli_overrides, request_overrides, typesafe_overrides, @@ -3904,6 +3911,12 @@ impl CodexMessageProcessor { return; } }; + apply_surface_capability_feature_gates( + &mut config, + &self.thread_state_manager, + &request_id, + ) + .await; let fallback_model_provider = config.model_provider_id.clone(); let instruction_sources = Self::instruction_sources_from_config(&config).await; @@ -4444,7 +4457,7 @@ impl CodexMessageProcessor { let cloud_requirements = self.current_cloud_requirements(); let cli_overrides = self.current_cli_overrides(); let runtime_feature_enablement = self.current_runtime_feature_enablement(); - let config = match derive_config_for_cwd( + let mut config = match derive_config_for_cwd( &cli_overrides, request_overrides, typesafe_overrides, @@ -4463,6 +4476,12 @@ impl CodexMessageProcessor { return; } }; + apply_surface_capability_feature_gates( + &mut config, + &self.thread_state_manager, + &request_id, + ) + .await; let fallback_model_provider = config.model_provider_id.clone(); let instruction_sources = Self::instruction_sources_from_config(&config).await; @@ -7539,11 +7558,19 @@ impl CodexMessageProcessor { let subscribed_connection_ids = thread_state_manager .subscribed_connection_ids(conversation_id) .await; + let request_permissions_connection_ids = thread_state_manager + .subscribed_connection_ids_supporting( + conversation_id, + SupportedServerRequestMethod::PermissionsRequestApproval, + ) + .await; let thread_outgoing = ThreadScopedOutgoingMessageSender::new( outgoing_for_task.clone(), subscribed_connection_ids, conversation_id, ); + let request_permissions_outgoing = thread_outgoing + .with_connection_ids(request_permissions_connection_ids); if let EventMsg::RawResponseItem(raw_response_item_event) = &event.msg && !raw_events_enabled @@ -7565,6 +7592,7 @@ impl CodexMessageProcessor { conversation.clone(), thread_manager.clone(), thread_outgoing, + request_permissions_outgoing, thread_state.clone(), thread_watch_manager.clone(), api_version, @@ -8686,6 +8714,45 @@ async fn derive_config_from_params( Ok(config) } +async fn apply_surface_capability_feature_gates( + config: &mut Config, + thread_state_manager: &ThreadStateManager, + request_id: &ConnectionRequestId, +) { + let supported_server_requests = thread_state_manager + .supported_server_requests_for_connection(request_id.connection_id) + .await; + gate_permission_tool_feature( + config, + Feature::RequestPermissionsTool, + supported_server_requests + .contains(&SupportedServerRequestMethod::PermissionsRequestApproval), + ); + gate_permission_tool_feature( + config, + Feature::RequestPermissionPresetTool, + /*surface_supports_tool*/ false, + ); +} + +fn gate_permission_tool_feature( + config: &mut Config, + feature: Feature, + surface_supports_tool: bool, +) { + if surface_supports_tool || !config.features.get().enabled(feature) { + return; + } + + if let Err(err) = config.features.disable(feature) { + warn!( + ?feature, + error = %err, + "failed to gate permission tool feature for unsupported app-server surface" + ); + } +} + async fn derive_config_for_cwd( cli_overrides: &[(String, TomlValue)], request_overrides: Option>, diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rs index d4e4bde063..2e8d7a2d89 100644 --- a/codex-rs/app-server/src/outgoing_message.rs +++ b/codex-rs/app-server/src/outgoing_message.rs @@ -145,6 +145,18 @@ impl ThreadScopedOutgoingMessageSender { } } + pub(crate) fn with_connection_ids(&self, connection_ids: Vec) -> Self { + Self { + outgoing: Arc::clone(&self.outgoing), + connection_ids: Arc::new(connection_ids), + thread_id: self.thread_id, + } + } + + pub(crate) fn is_empty(&self) -> bool { + self.connection_ids.is_empty() + } + pub(crate) async fn send_request( &self, payload: ServerRequestPayload, diff --git a/codex-rs/app-server/src/thread_state.rs b/codex-rs/app-server/src/thread_state.rs index 99983c5003..8a7f6e303c 100644 --- a/codex-rs/app-server/src/thread_state.rs +++ b/codex-rs/app-server/src/thread_state.rs @@ -202,13 +202,57 @@ impl ThreadStateManager { .insert(connection_id, supported_server_requests); } - pub(crate) async fn subscribed_connection_ids(&self, thread_id: ThreadId) -> Vec { + pub(crate) async fn supported_server_requests_for_connection( + &self, + connection_id: ConnectionId, + ) -> HashSet { let state = self.state.lock().await; state + .supported_server_requests_by_connection + .get(&connection_id) + .cloned() + .unwrap_or_default() + } + + pub(crate) async fn subscribed_connection_ids(&self, thread_id: ThreadId) -> Vec { + let state = self.state.lock().await; + let mut connection_ids = state .threads .get(&thread_id) - .map(|thread_entry| thread_entry.connection_ids.iter().copied().collect()) - .unwrap_or_default() + .map(|thread_entry| { + thread_entry + .connection_ids + .iter() + .copied() + .collect::>() + }) + .unwrap_or_default(); + sort_connection_ids(&mut connection_ids); + connection_ids + } + + pub(crate) async fn subscribed_connection_ids_supporting( + &self, + thread_id: ThreadId, + method: SupportedServerRequestMethod, + ) -> Vec { + let state = self.state.lock().await; + let Some(thread_entry) = state.threads.get(&thread_id) else { + return Vec::new(); + }; + let mut connection_ids = thread_entry + .connection_ids + .iter() + .filter(|connection_id| { + state + .supported_server_requests_by_connection + .get(connection_id) + .is_some_and(|supported| supported.contains(&method)) + }) + .copied() + .collect::>(); + sort_connection_ids(&mut connection_ids); + connection_ids } pub(crate) async fn thread_state(&self, thread_id: ThreadId) -> Arc> { @@ -388,3 +432,7 @@ impl ThreadStateManager { } } } + +fn sort_connection_ids(connection_ids: &mut [ConnectionId]) { + connection_ids.sort_by_key(|connection_id| connection_id.0); +} diff --git a/codex-rs/app-server/tests/suite/v2/request_permissions.rs b/codex-rs/app-server/tests/suite/v2/request_permissions.rs index 5a0679415d..1d53e9fff0 100644 --- a/codex-rs/app-server/tests/suite/v2/request_permissions.rs +++ b/codex-rs/app-server/tests/suite/v2/request_permissions.rs @@ -1,27 +1,124 @@ use anyhow::Result; +use anyhow::bail; use app_test_support::McpProcess; use app_test_support::create_final_assistant_message_sse_response; use app_test_support::create_mock_responses_server_sequence; use app_test_support::create_request_permissions_sse_response; use app_test_support::to_response; +use codex_app_server_protocol::ClientInfo; +use codex_app_server_protocol::InitializeCapabilities; use codex_app_server_protocol::JSONRPCMessage; use codex_app_server_protocol::JSONRPCResponse; -use codex_app_server_protocol::PermissionGrantScope; -use codex_app_server_protocol::PermissionsRequestApprovalResponse; use codex_app_server_protocol::RequestId; use codex_app_server_protocol::ServerRequest; use codex_app_server_protocol::ServerRequestResolvedNotification; +use codex_app_server_protocol::SupportedServerRequestMethod; use codex_app_server_protocol::ThreadStartParams; use codex_app_server_protocol::ThreadStartResponse; use codex_app_server_protocol::TurnStartParams; use codex_app_server_protocol::TurnStartResponse; use codex_app_server_protocol::UserInput as V2UserInput; +use serde_json::Value; +use serde_json::json; use tokio::time::timeout; +use wiremock::MockServer; const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10); #[tokio::test(flavor = "multi_thread", worker_threads = 4)] -async fn request_permissions_round_trip() -> Result<()> { +async fn permission_tools_are_hidden_without_supported_server_requests() -> Result<()> { + let body = first_responses_request_body_for_supported_server_requests(Vec::new()).await?; + assert_permission_tool_exposure( + &body, /*expect_permissions*/ false, /*expect_preset*/ false, + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn permission_tools_expose_only_narrow_permission_capability() -> Result<()> { + let body = first_responses_request_body_for_supported_server_requests(vec![ + SupportedServerRequestMethod::PermissionsRequestApproval, + ]) + .await?; + assert_permission_tool_exposure( + &body, /*expect_permissions*/ true, /*expect_preset*/ false, + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn permission_tools_keep_preset_hidden_without_delivery_support() -> Result<()> { + let body = first_responses_request_body_for_supported_server_requests(vec![ + SupportedServerRequestMethod::PermissionPresetRequestApproval, + ]) + .await?; + assert_permission_tool_exposure( + &body, /*expect_permissions*/ false, /*expect_preset*/ false, + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn permission_tools_expose_only_the_narrow_flow_for_now() -> Result<()> { + let body = first_responses_request_body_for_supported_server_requests(vec![ + SupportedServerRequestMethod::PermissionsRequestApproval, + SupportedServerRequestMethod::PermissionPresetRequestApproval, + ]) + .await?; + assert_permission_tool_exposure( + &body, /*expect_permissions*/ true, /*expect_preset*/ false, + ); + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn request_permissions_round_trips_when_client_supports_app_request() -> Result<()> { + let codex_home = tempfile::TempDir::new()?; + let responses = vec![ + create_request_permissions_sse_response("call1")?, + create_final_assistant_message_sse_response("done")?, + ]; + let server = create_mock_responses_server_sequence(responses).await; + create_config_toml(codex_home.path(), &server.uri())?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + initialize_with_supported_server_requests( + &mut mcp, + vec![SupportedServerRequestMethod::PermissionsRequestApproval], + ) + .await?; + + let thread_id = start_thread_and_turn(&mut mcp, "pick a directory").await?; + + let server_request = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_request_message(), + ) + .await??; + let ServerRequest::PermissionsRequestApproval { request_id, params } = server_request else { + bail!("expected PermissionsRequestApproval request"); + }; + assert_eq!(params.thread_id, thread_id); + assert_eq!(params.item_id, "call1"); + assert_eq!(params.reason.as_deref(), Some("Select a workspace root")); + let resolved_request_id = request_id.clone(); + + mcp.send_response( + request_id, + json!({ + "permissions": {}, + "scope": "turn", + }), + ) + .await?; + + wait_for_server_request_resolved_then_turn_completed(&mut mcp, &thread_id, resolved_request_id) + .await?; + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn request_permissions_auto_declines_without_app_request() -> Result<()> { let codex_home = tempfile::TempDir::new()?; let responses = vec![ create_request_permissions_sse_response("call1")?, @@ -62,44 +159,173 @@ async fn request_permissions_round_trip() -> Result<()> { mcp.read_stream_until_response_message(RequestId::Integer(turn_start_id)), ) .await??; - let TurnStartResponse { turn, .. } = to_response(turn_start_resp)?; + let TurnStartResponse { .. } = to_response(turn_start_resp)?; - let server_req = timeout( + loop { + let message = timeout(DEFAULT_READ_TIMEOUT, mcp.read_next_message()).await??; + match message { + JSONRPCMessage::Request(request) => { + let server_request: ServerRequest = request.try_into()?; + bail!("unexpected app-server request: {server_request:?}"); + } + JSONRPCMessage::Notification(notification) + if notification.method == "turn/completed" => + { + break; + } + _ => {} + } + } + + Ok(()) +} + +async fn initialize_with_supported_server_requests( + mcp: &mut McpProcess, + supported_server_requests: Vec, +) -> Result<()> { + let initialized = timeout( DEFAULT_READ_TIMEOUT, - mcp.read_stream_until_request_message(), + mcp.initialize_with_capabilities( + ClientInfo { + name: "codex_vscode".to_string(), + title: Some("Codex VS Code Extension".to_string()), + version: "0.1.0".to_string(), + }, + Some(InitializeCapabilities { + experimental_api: true, + supported_server_requests: Some(supported_server_requests), + opt_out_notification_methods: None, + }), + ), ) .await??; - let ServerRequest::PermissionsRequestApproval { request_id, params } = server_req else { - panic!("expected PermissionsRequestApproval request, got: {server_req:?}"); + let JSONRPCMessage::Response(_) = initialized else { + bail!("expected initialize response, got {initialized:?}"); }; + Ok(()) +} - assert_eq!(params.thread_id, thread.id); - assert_eq!(params.turn_id, turn.id); - assert_eq!(params.item_id, "call1"); - assert_eq!(params.reason, Some("Select a workspace root".to_string())); - let requested_writes = params - .permissions - .file_system - .and_then(|file_system| file_system.write) - .expect("request should include write permissions"); - assert_eq!(requested_writes.len(), 2); - let resolved_request_id = request_id.clone(); +async fn first_responses_request_body_for_supported_server_requests( + supported_server_requests: Vec, +) -> Result { + let codex_home = tempfile::TempDir::new()?; + let responses = vec![create_final_assistant_message_sse_response("done")?]; + let server = create_mock_responses_server_sequence(responses).await; + create_config_toml(codex_home.path(), &server.uri())?; - mcp.send_response( - request_id, - serde_json::to_value(PermissionsRequestApprovalResponse { - permissions: codex_app_server_protocol::GrantedPermissionProfile { - network: None, - file_system: Some(codex_app_server_protocol::AdditionalFileSystemPermissions { - read: None, - write: Some(vec![requested_writes[0].clone()]), - }), - }, - scope: PermissionGrantScope::Turn, - })?, + let mut mcp = McpProcess::new(codex_home.path()).await?; + if supported_server_requests.is_empty() { + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + } else { + initialize_with_supported_server_requests(&mut mcp, supported_server_requests).await?; + } + + start_thread_and_turn(&mut mcp, "Hello").await?; + wait_for_turn_completed_without_server_request(&mut mcp).await?; + + first_responses_request_body(&server).await +} + +async fn first_responses_request_body(server: &MockServer) -> Result { + let requests = server + .received_requests() + .await + .ok_or_else(|| anyhow::format_err!("failed to fetch received requests"))?; + requests + .into_iter() + .find(|request| request.url.path().ends_with("/responses")) + .ok_or_else(|| anyhow::format_err!("expected a /responses request"))? + .body_json() + .map_err(Into::into) +} + +fn assert_permission_tool_exposure(body: &Value, expect_permissions: bool, expect_preset: bool) { + let tool_names = body + .get("tools") + .and_then(Value::as_array) + .into_iter() + .flatten() + .filter_map(|tool| tool.get("name").and_then(Value::as_str)) + .collect::>(); + assert_eq!( + tool_names.contains(&"request_permissions"), + expect_permissions + ); + assert_eq!( + tool_names.contains(&"request_permission_preset"), + expect_preset + ); + + let body_text = body.to_string(); + assert_eq!( + body_text.contains("# request_permissions Tool"), + expect_permissions + ); + assert_eq!( + body_text.contains("# request_permission_preset Tool"), + expect_preset + ); +} + +async fn start_thread_and_turn(mcp: &mut McpProcess, input: &str) -> Result { + let thread_start_id = mcp + .send_thread_start_request(ThreadStartParams { + model: Some("mock-model".to_string()), + ..Default::default() + }) + .await?; + let thread_start_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(thread_start_id)), ) - .await?; + .await??; + let ThreadStartResponse { thread, .. } = to_response(thread_start_resp)?; + let turn_start_id = mcp + .send_turn_start_request(TurnStartParams { + thread_id: thread.id.clone(), + input: vec![V2UserInput::Text { + text: input.to_string(), + text_elements: Vec::new(), + }], + model: Some("mock-model".to_string()), + ..Default::default() + }) + .await?; + let turn_start_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(turn_start_id)), + ) + .await??; + let TurnStartResponse { .. } = to_response(turn_start_resp)?; + Ok(thread.id) +} + +async fn wait_for_turn_completed_without_server_request(mcp: &mut McpProcess) -> Result<()> { + loop { + let message = timeout(DEFAULT_READ_TIMEOUT, mcp.read_next_message()).await??; + match message { + JSONRPCMessage::Request(request) => { + let server_request: ServerRequest = request.try_into()?; + bail!("unexpected app-server request: {server_request:?}"); + } + JSONRPCMessage::Notification(notification) + if notification.method == "turn/completed" => + { + break; + } + _ => {} + } + } + Ok(()) +} + +async fn wait_for_server_request_resolved_then_turn_completed( + mcp: &mut McpProcess, + thread_id: &str, + request_id: RequestId, +) -> Result<()> { let mut saw_resolved = false; loop { let message = timeout(DEFAULT_READ_TIMEOUT, mcp.read_next_message()).await??; @@ -108,14 +334,12 @@ async fn request_permissions_round_trip() -> Result<()> { }; match notification.method.as_str() { "serverRequest/resolved" => { - let resolved: ServerRequestResolvedNotification = serde_json::from_value( - notification - .params - .clone() - .expect("serverRequest/resolved params"), - )?; - assert_eq!(resolved.thread_id, thread.id); - assert_eq!(resolved.request_id, resolved_request_id); + let Some(params) = notification.params.clone() else { + bail!("serverRequest/resolved notification missing params"); + }; + let resolved: ServerRequestResolvedNotification = serde_json::from_value(params)?; + assert_eq!(resolved.thread_id, thread_id); + assert_eq!(resolved.request_id, request_id); saw_resolved = true; } "turn/completed" => { @@ -125,7 +349,6 @@ async fn request_permissions_round_trip() -> Result<()> { _ => {} } } - Ok(()) } @@ -150,6 +373,7 @@ stream_max_retries = 0 [features] request_permissions_tool = true +request_permission_preset_tool = true "# ), )