From da2e174a66a6572204a91373321b7d22d87fb12e Mon Sep 17 00:00:00 2001 From: "Adam Perry @ OpenAI" Date: Thu, 1 Oct 2026 06:19:01 +0000 Subject: [PATCH] Scope extension filesystem access to callback permissions (#49898) ## Why Executor skill reads need to use the environments and permissions captured for the current step, including newly approved grants. Cached continuation pages must remain bound to the filesystem and permissions that produced them. ## What changed - Supply borrowed `EnvironmentAccess` to turn-input contributors and extension tools, with session and originating-turn grants already applied. - Require executor skill reads to use filesystem access from an environment available to the callback, and replace separate optional read contexts with `SkillReadContext`. - Bind skill pagination snapshots to `EnvironmentAccessKey`, which identifies the source filesystem and callback permissions. - Route image-generation filesystem operations through the same accessor. ## Testing Extend skill-read integration coverage to verify that a denied reference becomes readable after a turn-scoped grant is captured by the next model step. Update Windows coverage to verify that restricted reads fail when the executor cannot enforce a sandbox, and add a test requiring turn environment selection before exposing capability roots. GitOrigin-RevId: 825b49302319965835d61c77fc5bcdb951e10543 --- codex-rs/core/src/session/mod.rs | 18 -- codex-rs/core/src/session/step_context.rs | 15 ++ codex-rs/core/src/session/tests.rs | 34 +++ codex-rs/core/src/session/turn.rs | 11 +- codex-rs/core/src/session/turn_context.rs | 13 ++ .../src/tools/handlers/extension_tools.rs | 46 ++-- codex-rs/core/tests/suite/skills_extension.rs | 214 +++++++++++++++--- .../src/contributors/turn_input.rs | 31 ++- codex-rs/ext/image-generation/src/tool.rs | 42 ++-- codex-rs/ext/skills/src/cloud_cache_tests.rs | 9 +- codex-rs/ext/skills/src/extension.rs | 37 ++- codex-rs/ext/skills/src/provider.rs | 30 ++- codex-rs/ext/skills/src/provider/executor.rs | 47 +--- codex-rs/ext/skills/src/provider/host.rs | 6 +- codex-rs/ext/skills/src/state.rs | 17 +- codex-rs/ext/skills/src/tools/mod.rs | 5 - codex-rs/ext/skills/src/tools/read.rs | 68 +++--- .../tests/executor_file_system_authority.rs | 99 ++++---- codex-rs/ext/skills/tests/skills_extension.rs | 53 +++-- .../presentation_dedup_tests.rs | 13 +- .../shadow_task_context_tests.rs | 10 +- codex-rs/tools/src/tool_call.rs | 35 ++- 22 files changed, 559 insertions(+), 294 deletions(-) diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs index f24e68ab7f..9caf797d45 100644 --- a/codex-rs/core/src/session/mod.rs +++ b/codex-rs/core/src/session/mod.rs @@ -3774,24 +3774,6 @@ impl Session { extension_data.insert(selected_capability_roots.clone()); if let Some(discovery) = &executor_capability_discovery { extension_data.insert(discovery.as_ref().clone()); - if !discovery.sandbox_contexts().is_empty() { - extension_data.insert(discovery.sandbox_contexts().clone()); - } - } else if !turn_context - .permission_profile_for_environments(&environments) - .file_system_sandbox_policy() - .has_full_disk_read_access() - { - let sandbox_contexts = environments - .turn_environments() - .map(|environment| { - ( - environment.selection.environment_id.clone(), - environment.sandbox_context(/*additional_permissions*/ None), - ) - }) - .collect::>(); - extension_data.insert(sandbox_contexts); } let (mcp, prepared_recommendations) = tokio::join!( // MCP refresh can be large; keep it off the sampling request's stack. diff --git a/codex-rs/core/src/session/step_context.rs b/codex-rs/core/src/session/step_context.rs index 5c1006c900..9f574254b0 100644 --- a/codex-rs/core/src/session/step_context.rs +++ b/codex-rs/core/src/session/step_context.rs @@ -8,9 +8,11 @@ use crate::environment_selection::TurnEnvironmentSnapshot; use crate::realtime_conversation::RealtimeConversationSnapshot; use crate::session::step_settings::ResolvedStepSettings; use crate::session::turn_context::TurnContext; +use crate::session::turn_context::TurnEnvironment; use crate::tools::router::ToolRouter; use codex_exec_server::ExecutorCapabilityDiscoverySnapshot; use codex_exec_server::ResolvedSelectedCapabilityRoot; +use codex_file_system::EnvironmentAccess; use codex_mcp::McpBinding; use codex_otel::SessionTelemetry; use codex_protocol::items::ModelInvocationContext; @@ -44,6 +46,19 @@ pub(crate) struct StepContext { } impl StepContext { + /// Pairs the step's environments with access using current session and originating-turn grants. + pub(crate) fn environments(&self) -> Vec<(&TurnEnvironment, impl EnvironmentAccess + '_)> { + self.environments + .turn_environments() + .map(|environment| { + let grants = self + .turn + .granted_permissions(&environment.selection.environment_id); + (environment, environment.fs_accessor(grants)) + }) + .collect() + } + /// Persist the context captured for this request, even after a live update. pub(crate) fn to_turn_context_item(&self) -> TurnContextItem { let mut item = self.turn.to_turn_context_item(); diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index f7a3cc26cc..4496c9b940 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -9935,6 +9935,40 @@ async fn mcp_refresh_detects_shared_auth_manager_changes() { ); } +/// A ready registry entry alone must not expose roots outside the turn's environment selection. +#[tokio::test] +async fn capability_roots_require_turn_environment_selection() { + let (mut session, turn_context) = make_session_and_context().await; + let environment = turn_context + .initial_environments + .primary() + .expect("ready local environment"); + let root = codex_protocol::capabilities::SelectedCapabilityRoot { + id: "selected-root".to_string(), + location: codex_protocol::capabilities::CapabilityRootLocation::Environment { + environment_id: environment.selection.environment_id.clone(), + path: environment.cwd().clone(), + }, + }; + session.services.selected_capability_roots = vec![root.clone()]; + + let unselected_roots = session + .resolve_selected_capability_roots_for_step(&TurnEnvironmentSnapshot::default()) + .await; + assert!(unselected_roots.is_empty()); + + let selected_roots = session + .resolve_selected_capability_roots_for_step(&turn_context.initial_environments) + .await; + assert_eq!( + selected_roots + .iter() + .map(|root| root.selected_root().clone()) + .collect::>(), + vec![root] + ); +} + #[tokio::test] #[tracing_test::traced_test] async fn conflicting_ready_environment_root_ids_keep_first_location() { diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index 32f16fe4c5..106e2c4dd4 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -1,6 +1,5 @@ use std::collections::HashMap; use std::collections::HashSet; -use std::marker::PhantomData; use std::sync::Arc; use std::sync::atomic::Ordering; @@ -1186,15 +1185,15 @@ async fn build_extension_turn_input_items( return Some(Vec::new()); } - let environments = step_context - .environments - .turn_environments() + let environment_accessors = step_context.environments(); + let environments = environment_accessors + .iter() .enumerate() - .map(|(index, environment)| TurnInputEnvironment { - _lifetime: PhantomData, + .map(|(index, (environment, fs))| TurnInputEnvironment { environment_id: environment.selection.environment_id.clone(), cwd: environment.cwd().clone(), is_primary: index == 0, + fs, }) .collect::>(); diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rs index 5fd52bb823..8f94f0b81b 100644 --- a/codex-rs/core/src/session/turn_context.rs +++ b/codex-rs/core/src/session/turn_context.rs @@ -17,6 +17,8 @@ use codex_core_plugins::ResolvedPluginMetricsOperation; use codex_core_plugins::TrustedPluginRoots; use codex_exec_server::ExecutorFileSystem; use codex_extension_api::SelectedPluginSnapshot; +use codex_file_system::EnvironmentAccess; +use codex_file_system::FileSystemEnvironmentAccessor; use codex_file_system::FileSystemSandboxContext; use codex_model_provider::SharedModelProvider; use codex_protocol::SessionId; @@ -215,6 +217,17 @@ impl TurnEnvironment { self.config().permission_profile.permission_profile() } + /// Borrows this snapshot's filesystem using its permissions and any additional grants. + pub(crate) fn fs_accessor( + &self, + additional_permissions: Option, + ) -> impl EnvironmentAccess + '_ { + FileSystemEnvironmentAccessor::new( + self.environment.filesystem_ref(), + self.sandbox_context(additional_permissions), + ) + } + /// Sandbox context for this environment, including any additional permission grants. pub(crate) fn sandbox_context( &self, diff --git a/codex-rs/core/src/tools/handlers/extension_tools.rs b/codex-rs/core/src/tools/handlers/extension_tools.rs index 58434b2ee1..ea483528d0 100644 --- a/codex-rs/core/src/tools/handlers/extension_tools.rs +++ b/codex-rs/core/src/tools/handlers/extension_tools.rs @@ -1,4 +1,3 @@ -use std::marker::PhantomData; use std::sync::Arc; use std::sync::Weak; @@ -18,12 +17,10 @@ use codex_tools::TurnItemEmissionFuture; use codex_tools::TurnItemEmitter; use codex_utils_string::to_ascii_json_string; -use crate::sandboxing::SandboxPermissions; use crate::session::session::Session; use crate::session::turn_context::TurnContext; use crate::tools::context::ToolInvocation; use crate::tools::context::ToolPayload; -use crate::tools::handlers::apply_granted_turn_permissions; use crate::tools::lifecycle::extension_tool_call_source; use crate::tools::registry::CoreToolRuntime; use crate::tools::registry::ToolExecutor; @@ -66,7 +63,22 @@ impl ToolExecutor for ExtensionToolAdapter { where ToolInvocation: 'a, { - Box::pin(async move { self.0.handle(to_extension_call(&invocation).await).await }) + Box::pin(async move { + let environment_accessors = invocation.step_context.environments(); + let environments = environment_accessors + .iter() + .map(|(environment, fs)| { + ToolEnvironment::new( + environment.selection.environment_id.clone(), + environment.cwd().clone(), + fs, + ) + }) + .collect(); + self.0 + .handle(to_extension_call(&invocation, environments).await) + .await + }) } } @@ -164,7 +176,10 @@ impl TurnItemEmitter for CoreTurnItemEmitter { } } -async fn to_extension_call(invocation: &ToolInvocation) -> ExtensionToolCall<'_> { +async fn to_extension_call<'a>( + invocation: &ToolInvocation, + environments: Vec>, +) -> ExtensionToolCall<'a> { let history = invocation .session .clone_history() @@ -184,25 +199,6 @@ async fn to_extension_call(invocation: &ToolInvocation) -> ExtensionToolCall<'_> &invocation.step_context.settings, )) .and_then(|metadata| to_ascii_json_string(&metadata).ok()); - let mut environments = Vec::new(); - for environment in invocation.step_context.environments.turn_environments() { - let additional_permissions = apply_granted_turn_permissions( - &invocation.step_context, - environment, - environment.cwd(), - SandboxPermissions::UseDefault, - /*additional_permissions*/ None, - ) - .additional_permissions; - let file_system_sandbox_context = environment.sandbox_context(additional_permissions); - environments.push(ToolEnvironment { - _lifetime: PhantomData, - environment_id: environment.selection.environment_id.clone(), - cwd: environment.cwd().clone(), - file_system: environment.environment.get_filesystem(), - file_system_sandbox_context, - }); - } ExtensionToolCall { turn_id: invocation.turn.sub_id.clone(), call_id: invocation.call_id.clone(), @@ -355,7 +351,7 @@ mod tests { *self.captured_sandbox_cwds.lock().await = call .environments .iter() - .map(|environment| environment.file_system_sandbox_context.cwd.clone()) + .map(|environment| environment.cwd.clone()) .collect(); let call = codex_tools::ToolCall { environments: Vec::new(), diff --git a/codex-rs/core/tests/suite/skills_extension.rs b/codex-rs/core/tests/suite/skills_extension.rs index 72462e1e62..a56b0a8c6d 100644 --- a/codex-rs/core/tests/suite/skills_extension.rs +++ b/codex-rs/core/tests/suite/skills_extension.rs @@ -13,9 +13,13 @@ use codex_core::StartThreadOptions; use codex_core::TurnInputRequest; use codex_core::WaitForEnvironmentToolConfig; use codex_core::config::Config; +use codex_core::config::Constrained; use codex_exec_server::CreateDirectoryOptions; use codex_exec_server::EnvironmentManager; +use codex_exec_server::ExecParams; +use codex_exec_server::ExecProcessEvent; use codex_exec_server::LOCAL_ENVIRONMENT_ID; +use codex_exec_server::ProcessId; use codex_exec_server::RemoveOptions; use codex_extension_api::ExtensionDataInit; use codex_extension_api::ExtensionEventSink; @@ -38,6 +42,7 @@ use codex_otel::OtelSettings; use codex_otel::THREAD_SKILLS_KEPT_TOTAL_METRIC; use codex_protocol::capabilities::CapabilityRootLocation; use codex_protocol::capabilities::SelectedCapabilityRoot; +use codex_protocol::models::FileSystemPermissions; use codex_protocol::models::PermissionProfile; use codex_protocol::openai_models::ModelsResponse; use codex_protocol::openai_models::TruncationPolicyConfig; @@ -47,6 +52,7 @@ 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::Event; use codex_protocol::protocol::EventMsg; @@ -55,6 +61,9 @@ use codex_protocol::protocol::ThreadSettingsOverrides; use codex_protocol::protocol::TurnEnvironmentSelection; use codex_protocol::protocol::TurnSettingsUpdate; use codex_protocol::protocol::TurnSettingsUpdateOutcome; +use codex_protocol::request_permissions::PermissionGrantScope; +use codex_protocol::request_permissions::RequestPermissionProfile; +use codex_protocol::request_permissions::RequestPermissionsResponse; use codex_protocol::user_input::UserInput; use codex_skills_extension::ExecutorSkillProvider; use codex_skills_extension::HostSkillProvider; @@ -1359,15 +1368,17 @@ async fn executor_only_provider_preserves_structured_repo_skill_without_discover enum ExecutorReferenceRead { Allowed, Denied, + Granted, Continuation, EditedContinuation, DeniedContinuation, } -/// Live references and continuation pages use current permissions, including after discovery +/// Live references and continuation pages use the step's captured permissions after discovery /// materialized the main prompt. Continuations preserve the cached snapshot across file edits. #[test_case(ExecutorReferenceRead::Allowed; "full disk read")] #[test_case(ExecutorReferenceRead::Denied; "denied reference")] +#[test_case(ExecutorReferenceRead::Granted; "grant captured by the next model step")] #[test_case(ExecutorReferenceRead::Continuation; "unchanged continuation")] #[test_case(ExecutorReferenceRead::EditedContinuation; "edited continuation")] #[test_case(ExecutorReferenceRead::DeniedContinuation; "denied continuation")] @@ -1378,7 +1389,9 @@ async fn executor_skill_tool_reads_references_under_current_permissions( skip_if_no_network!(Ok(())); if matches!( read, - ExecutorReferenceRead::Denied | ExecutorReferenceRead::DeniedContinuation + ExecutorReferenceRead::Denied + | ExecutorReferenceRead::Granted + | ExecutorReferenceRead::DeniedContinuation ) { skip_if_target_windows!( Ok(()), @@ -1388,16 +1401,17 @@ async fn executor_skill_tool_reads_references_under_current_permissions( const REFERENCE_CONTENTS: &str = "Live executor reference instructions."; let contents = match read { - ExecutorReferenceRead::Allowed | ExecutorReferenceRead::Denied => { - REFERENCE_CONTENTS.to_string() - } + ExecutorReferenceRead::Allowed + | ExecutorReferenceRead::Denied + | ExecutorReferenceRead::Granted => REFERENCE_CONTENTS.to_string(), ExecutorReferenceRead::Continuation | ExecutorReferenceRead::EditedContinuation | ExecutorReferenceRead::DeniedContinuation => "reference line\n".repeat(800), }; - let reference_access = match read { + let restricted_path_access = match read { ExecutorReferenceRead::Denied => FileSystemAccessMode::Deny, ExecutorReferenceRead::Allowed + | ExecutorReferenceRead::Granted | ExecutorReferenceRead::Continuation | ExecutorReferenceRead::EditedContinuation | ExecutorReferenceRead::DeniedContinuation => FileSystemAccessMode::Read, @@ -1458,15 +1472,62 @@ async fn executor_skill_tool_reads_references_under_current_permissions( ), ("reference.md", contents.as_str()), ] { + let directory = if name == "reference.md" && matches!(read, ExecutorReferenceRead::Granted) + { + &selection.cwd + } else { + &skill_dir + }; file_system .write_file( - &skill_dir.join(name)?, + &directory.join(name)?, contents.as_bytes().to_vec(), Default::default(), /*sandbox*/ None, ) .await?; } + if matches!(read, ExecutorReferenceRead::Granted) { + // The package directory must be listable for discovery. Put the reference outside it so + // it still requires a separate grant; create the link on the executor, including remotely. + let process = test + .executor_environment() + .environment() + .get_exec_backend() + .start(ExecParams { + process_id: ProcessId::from("link-grant-reference"), + metadata: None, + argv: ["/bin/ln", "-s", "../reference.md", "skill/reference.md"] + .map(str::to_string) + .to_vec(), + cwd: selection.cwd.clone(), + env_policy: None, + shell_snapshot: None, + env: Default::default(), + tty: false, + pipe_stdin: false, + arg0: None, + sandbox: None, + enforce_managed_network: false, + managed_network: None, + network_proxy: None, + }) + .await? + .process; + let mut events = process.subscribe_events(); + loop { + match events.recv().await? { + ExecProcessEvent::Exited { exit_code, .. } => { + assert_eq!(exit_code, 0, "link the reference on the executor"); + break; + } + ExecProcessEvent::Output(_) => {} + event @ (ExecProcessEvent::Closed { .. } | ExecProcessEvent::Failed(_)) => { + panic!("reference symlink process did not exit: {event:?}") + } + } + } + } let package = format!( "skill://reference-root/{}", skill_dir @@ -1480,10 +1541,26 @@ async fn executor_skill_tool_reads_references_under_current_permissions( id: "reference-root".to_string(), location: CapabilityRootLocation::Environment { environment_id: selection.environment_id.clone(), - path: selection.cwd.clone(), + path: if matches!(read, ExecutorReferenceRead::Granted) { + skill_dir.clone() + } else { + selection.cwd.clone() + }, }, }]); let mut config = test.config.clone(); + if matches!(read, ExecutorReferenceRead::Granted) { + config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest); + config.features.enable(Feature::RequestPermissionsTool)?; + } + let (root_access, restricted_path) = if matches!(read, ExecutorReferenceRead::Granted) { + (FileSystemAccessMode::Deny, policy_skill_dir.clone()) + } else { + ( + FileSystemAccessMode::Read, + policy_skill_dir.join("reference.md")?, + ) + }; config .permissions .set_permission_profile(PermissionProfile::from_runtime_permissions( @@ -1492,13 +1569,13 @@ async fn executor_skill_tool_reads_references_under_current_permissions( FileSystemPath::Special { value: FileSystemSpecialPath::Root, }, - FileSystemAccessMode::Read, + root_access, ), FileSystemSandboxEntry::new( FileSystemPath::Path { - path: policy_skill_dir.join("reference.md")?, + path: restricted_path, }, - reference_access, + restricted_path_access, ), ]), NetworkSandboxPolicy::Restricted, @@ -1511,23 +1588,59 @@ async fn executor_skill_tool_reads_references_under_current_permissions( ..StartThreadOptions::new(config) }) .await?; - let response = responses::mount_sse_sequence( - &server, - vec![ - sse(vec![ - ev_response_created("resp-1"), - responses::ev_function_call_with_namespace( - "read-reference", - "skills", - "read", - &json!({ "package": package, "resource": resource }).to_string(), - ), - ev_completed("resp-1"), - ]), - sse(vec![ev_response_created("resp-2"), ev_completed("resp-2")]), - ], - ) - .await; + let requested_permissions = RequestPermissionProfile { + file_system: Some(FileSystemPermissions::from_read_write_path_uris( + Some(vec![if matches!(read, ExecutorReferenceRead::Granted) { + policy_skill_dir + .parent() + .expect("skill directory has a parent") + .join("reference.md")? + } else { + policy_skill_dir.join("reference.md")? + }]), + /*write*/ None, + )), + ..Default::default() + }; + let mut response_sequence = Vec::new(); + if matches!(read, ExecutorReferenceRead::Granted) { + // Separate responses ensure the denied read finishes before approval can be requested. + response_sequence.push(sse(vec![ + ev_response_created("resp-before-grant"), + responses::ev_function_call_with_namespace( + "read-before-grant", + "skills", + "read", + &json!({"package": package, "resource": resource}).to_string(), + ), + ev_completed("resp-before-grant"), + ])); + response_sequence.push(sse(vec![ + ev_response_created("resp-grant"), + responses::ev_function_call( + "grant-reference", + "request_permissions", + &json!({"reason": "Read", "permissions": requested_permissions}).to_string(), + ), + ev_completed("resp-grant"), + ])); + } + // The next model step captures any newly approved permissions. + response_sequence.push(sse(vec![ + ev_response_created("resp-read"), + responses::ev_function_call_with_namespace( + "read-reference", + "skills", + "read", + &json!({ "package": package, "resource": resource }).to_string(), + ), + ev_completed("resp-read"), + ])); + response_sequence.push(sse(vec![ + ev_response_created("resp-2"), + ev_completed("resp-2"), + ])); + let response = responses::mount_sse_sequence(&server, response_sequence).await; thread .thread .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text { @@ -1535,16 +1648,53 @@ async fn executor_skill_tool_reads_references_under_current_permissions( text_elements: Vec::new(), }])) .await?; + if matches!(read, ExecutorReferenceRead::Granted) { + let event = wait_for_event(&thread.thread, |event| { + matches!( + event, + EventMsg::RequestPermissions(_) | EventMsg::TurnComplete(_) + ) + }) + .await; + let EventMsg::RequestPermissions(request) = event else { + panic!("expected request_permissions before completion: {event:?}"); + }; + thread + .thread + .submit(Op::RequestPermissionsResponse { + id: request.call_id, + response: RequestPermissionsResponse { + permissions: requested_permissions, + scope: PermissionGrantScope::Turn, + strict_auto_review: false, + }, + }) + .await?; + } wait_for_event(&thread.thread, |event| { matches!(event, EventMsg::TurnComplete(_)) }) .await; - let output = response.requests()[1] + let output = response + .requests() + .last() + .expect("final model request includes the reference read") .function_call_output_text("read-reference") .expect("skills.read should return a tool result"); + if matches!(read, ExecutorReferenceRead::Granted) { + assert_eq!( + response.requests()[1] + .function_call_output_text("read-before-grant") + .expect("the earlier skills.read should return a tool result"), + "failed to read skill resource", + ); + } if matches!(read, ExecutorReferenceRead::Denied) { assert_eq!(output, "failed to read skill resource"); - } else if matches!(read, ExecutorReferenceRead::Allowed) { + } else if matches!( + read, + ExecutorReferenceRead::Allowed | ExecutorReferenceRead::Granted + ) { assert_eq!( serde_json::from_str::(&output)?, json!({ @@ -1650,7 +1800,9 @@ async fn executor_skill_tool_reads_references_under_current_permissions( ExecutorReferenceRead::DeniedContinuation => { assert_eq!(output, "failed to read skill resource") } - ExecutorReferenceRead::Allowed | ExecutorReferenceRead::Denied => { + ExecutorReferenceRead::Allowed + | ExecutorReferenceRead::Denied + | ExecutorReferenceRead::Granted => { unreachable!("single-page cases handled above") } } diff --git a/codex-rs/ext/extension-api/src/contributors/turn_input.rs b/codex-rs/ext/extension-api/src/contributors/turn_input.rs index 61437279cd..6375242ac9 100644 --- a/codex-rs/ext/extension-api/src/contributors/turn_input.rs +++ b/codex-rs/ext/extension-api/src/contributors/turn_input.rs @@ -1,9 +1,10 @@ +use codex_file_system::EnvironmentAccess; use codex_protocol::user_input::UserInput; use codex_utils_path_uri::PathUri; -use std::marker::PhantomData; +use std::fmt; /// Host-owned turn environment summary visible to turn-input contributors. -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct TurnInputEnvironment<'a> { /// Stable host environment id used to route executor-scoped capabilities. pub environment_id: String, @@ -11,12 +12,12 @@ pub struct TurnInputEnvironment<'a> { pub cwd: PathUri, /// Whether this is the primary environment for the turn. pub is_primary: bool, - // TODO(anp): Replace the marker with callback-scoped environment access. - pub _lifetime: PhantomData<&'a ()>, + /// Filesystem access with the permissions captured for this model turn. + pub fs: &'a dyn EnvironmentAccess, } /// Turn facts supplied before the host records turn-local model input items. -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct TurnInputContext<'a> { /// Stable host-owned turn identifier. pub turn_id: String, @@ -25,3 +26,23 @@ pub struct TurnInputContext<'a> { /// Resolved turn environments, in host priority order. pub environments: Vec>, } + +impl fmt::Debug for TurnInputEnvironment<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("TurnInputEnvironment") + .field("environment_id", &self.environment_id) + .field("cwd", &self.cwd) + .field("is_primary", &self.is_primary) + .finish_non_exhaustive() + } +} + +impl fmt::Debug for TurnInputContext<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("TurnInputContext") + .field("turn_id", &self.turn_id) + .field("user_input", &self.user_input) + .field("environments", &self.environments) + .finish_non_exhaustive() + } +} diff --git a/codex-rs/ext/image-generation/src/tool.rs b/codex-rs/ext/image-generation/src/tool.rs index f31a130ce3..d2777fb202 100644 --- a/codex-rs/ext/image-generation/src/tool.rs +++ b/codex-rs/ext/image-generation/src/tool.rs @@ -328,6 +328,7 @@ async fn save_image_generation_result( None => { let environment = environment?; let cwd = environment.cwd.to_abs_path().ok()?; + let fs = environment.fs(); let output_dir = cwd.join("generated_images"); let save_result: io::Result = async { let result = result.trim(); @@ -349,26 +350,19 @@ async fn save_image_generation_result( let artifact_path = image_generation_artifact_path(&cwd, session_id, call_id); let path = output_dir.join(artifact_path.as_path().file_name().unwrap_or_default()); - let sandbox = Some(&environment.file_system_sandbox_context); if let Some(parent) = path.parent() { let parent_uri = PathUri::from_abs_path(&parent); - environment - .file_system - .create_directory( - &parent_uri, - CreateDirectoryOptions { - recursive: true, - follow_symlinks: true, - }, - sandbox, - ) - .await?; + fs.create_directory( + &parent_uri, + CreateDirectoryOptions { + recursive: true, + follow_symlinks: true, + }, + ) + .await?; // Full-access executor contexts do not prevent symlinked output directories. - let metadata = environment - .file_system - .get_metadata(&parent_uri, Default::default(), sandbox) - .await?; + let metadata = fs.get_metadata(&parent_uri, Default::default()).await?; if metadata.is_symlink || !metadata.is_directory { return Err(io::Error::new( io::ErrorKind::PermissionDenied, @@ -379,11 +373,7 @@ async fn save_image_generation_result( // Existing destination hardlinks could otherwise overwrite files outside the workspace. let path_uri = PathUri::from_abs_path(&path); - match environment - .file_system - .get_metadata(&path_uri, Default::default(), sandbox) - .await - { + match fs.get_metadata(&path_uri, Default::default()).await { Ok(_) => { return Err(io::Error::new( io::ErrorKind::AlreadyExists, @@ -394,10 +384,7 @@ async fn save_image_generation_result( Err(error) => return Err(error), } - environment - .file_system - .write_file(&path_uri, bytes, Default::default(), sandbox) - .await?; + fs.write_file(&path_uri, bytes, Default::default()).await?; Ok(path) } .await; @@ -574,10 +561,9 @@ async fn image_url( environment: &ToolEnvironment<'_>, ) -> Result { let path_uri = PathUri::from_abs_path(path); - let sandbox = environment.file_system_sandbox_context.clone(); let bytes = environment - .file_system - .read_file(&path_uri, Default::default(), Some(&sandbox)) + .fs() + .read_file(&path_uri, Default::default()) .await .map_err(|error| { FunctionCallError::RespondToModel(format!( diff --git a/codex-rs/ext/skills/src/cloud_cache_tests.rs b/codex-rs/ext/skills/src/cloud_cache_tests.rs index 7a001ca1c5..5844dc4c4b 100644 --- a/codex-rs/ext/skills/src/cloud_cache_tests.rs +++ b/codex-rs/ext/skills/src/cloud_cache_tests.rs @@ -5,6 +5,7 @@ use crate::catalog::SkillResourceId; use crate::catalog::SkillSearchResult; use crate::provider::SkillProvider; use crate::provider::SkillProviderFuture; +use crate::provider::SkillReadContext; use crate::provider::SkillSearchRequest; use codex_mcp::McpRuntime; use pretty_assertions::assert_eq; @@ -93,14 +94,12 @@ fn query(client: Option>) -> SkillListQuery { fn request(client: Option>) -> SkillReadRequest<'static> { SkillReadRequest { - _lifetime: Default::default(), authority: SkillAuthority::new(SkillSourceKind::Cloud, "codex_apps"), package: SkillPackageId("skill://demo".into()), resource: SkillResourceId::new("skill://demo/SKILL.md"), - resolved_executor_roots: Vec::new(), - sandbox: None, - host_snapshot: None, - mcp_resources: client, + context: SkillReadContext::Cloud { + mcp_resources: client, + }, } } diff --git a/codex-rs/ext/skills/src/extension.rs b/codex-rs/ext/skills/src/extension.rs index 979d2c65c7..4b6568045d 100644 --- a/codex-rs/ext/skills/src/extension.rs +++ b/codex-rs/ext/skills/src/extension.rs @@ -1,12 +1,9 @@ -use std::collections::HashMap; -use std::marker::PhantomData; use std::sync::Arc; use crate::HostSkillsSnapshot; use crate::InjectedHostSkillPrompts; use codex_analytics::InvocationType; use codex_exec_server::ExecutorCapabilityDiscoverySnapshot; -use codex_exec_server::FileSystemSandboxContext; use codex_exec_server::LOCAL_ENVIRONMENT_ID; use codex_exec_server::ResolvedSelectedCapabilityRoot; use codex_extension_api::ConfigContributor; @@ -46,6 +43,7 @@ use crate::fragments::SkillInstructions; use crate::fragments::SkillResourceAccess; use crate::provider::HostSkillProvider; use crate::provider::SkillListQuery; +use crate::provider::SkillReadContext; use crate::provider::SkillReadRequest; use crate::render::AvailableSkillsRender; use crate::render::MAX_SKILL_NAME_BYTES; @@ -302,7 +300,6 @@ where thread_store, /*executor_query*/ None, /*selected_plugins*/ None, - /*sandbox_contexts*/ None, ) } @@ -337,7 +334,6 @@ where thread_store, executor_query, step_store.get::(), - step_store.get::>(), ) } } @@ -480,6 +476,7 @@ where host_snapshot.clone(), mcp_resources.clone(), &thread_state, + &input, ) .await { @@ -581,7 +578,6 @@ impl SkillsExtension { thread_store: &ExtensionData, executor_query: Option, selected_plugins: Option>, - sandbox_contexts: Option>>, ) -> Vec ToolExecutor>>> { skill_tools( self.providers.clone(), @@ -589,7 +585,6 @@ impl SkillsExtension { thread_store, executor_query, selected_plugins, - sandbox_contexts, ) } @@ -617,19 +612,37 @@ impl SkillsExtension { host_snapshot: Option>, mcp_resources: Option>, thread_state: &SkillsThreadState, + input: &TurnInputContext<'_>, ) -> Result { + let context = match entry.authority.kind { + SkillSourceKind::Cloud => SkillReadContext::Cloud { mcp_resources }, + SkillSourceKind::Custom(_) => SkillReadContext::Custom { mcp_resources }, + SkillSourceKind::Host => SkillReadContext::Host { host_snapshot }, + SkillSourceKind::Executor => { + let fs = entry + .main_prompt + .environment_path() + .and_then(|(id, _)| { + input + .environments + .iter() + .find(|env| env.environment_id == id) + .map(|env| env.fs) + }) + .ok_or_else(|| { + "skill environment is not available for this callback".to_string() + })?; + SkillReadContext::Executor { fs } + } + }; thread_state .read_skill( &self.providers, SkillReadRequest { - _lifetime: PhantomData, authority: entry.authority.clone(), package: entry.id.clone(), resource: entry.main_prompt.clone(), - resolved_executor_roots: Vec::new(), - sandbox: None, - host_snapshot, - mcp_resources, + context, }, ) .await diff --git a/codex-rs/ext/skills/src/provider.rs b/codex-rs/ext/skills/src/provider.rs index 0802cb43cf..c2a1210cdb 100644 --- a/codex-rs/ext/skills/src/provider.rs +++ b/codex-rs/ext/skills/src/provider.rs @@ -1,5 +1,4 @@ use std::future::Future; -use std::marker::PhantomData; use std::pin::Pin; use std::sync::Arc; @@ -7,8 +6,8 @@ mod executor; mod host; use crate::HostSkillsSnapshot; +use codex_exec_server::EnvironmentAccess; use codex_exec_server::ExecutorCapabilityDiscoverySnapshot; -use codex_exec_server::FileSystemSandboxContext; use codex_exec_server::ResolvedSelectedCapabilityRoot; use codex_mcp::McpResourceClient; use codex_protocol::capabilities::SelectedCapabilityRoot; @@ -41,17 +40,30 @@ pub struct SkillListQuery { pub executor_capability_discovery: Option, } -#[derive(Clone, Debug)] +/// A skill read with the source access supplied by its callback. +#[derive(Clone)] pub struct SkillReadRequest<'a> { - // TODO(anp): Replace the marker with callback-scoped environment access. - pub _lifetime: PhantomData<&'a ()>, pub authority: SkillAuthority, pub package: SkillPackageId, pub resource: SkillResourceId, - pub resolved_executor_roots: Vec, - pub sandbox: Option, - pub host_snapshot: Option>, - pub mcp_resources: Option>, + pub context: SkillReadContext<'a>, +} + +/// Executor reads require callback access; other providers carry their own source context. +#[derive(Clone)] +pub enum SkillReadContext<'a> { + Host { + host_snapshot: Option>, + }, + Executor { + fs: &'a dyn EnvironmentAccess, + }, + Cloud { + mcp_resources: Option>, + }, + Custom { + mcp_resources: Option>, + }, } #[derive(Clone, Debug, PartialEq, Eq)] diff --git a/codex-rs/ext/skills/src/provider/executor.rs b/codex-rs/ext/skills/src/provider/executor.rs index ede044539b..d2bab6dc63 100644 --- a/codex-rs/ext/skills/src/provider/executor.rs +++ b/codex-rs/ext/skills/src/provider/executor.rs @@ -2,9 +2,9 @@ use std::collections::HashMap; use std::collections::HashSet; use std::sync::Arc; +use codex_exec_server::EnvironmentAccess; use codex_exec_server::EnvironmentManager; use codex_exec_server::FileSystemEnvironmentAccessor; -use codex_exec_server::FileSystemSandboxContext; use codex_extension_api::SelectedPluginSnapshot; use codex_protocol::capabilities::CapabilityRootLocation; use codex_protocol::protocol::Product; @@ -29,6 +29,7 @@ use crate::provider::MAX_SKILL_RESOURCE_CONTENT_BYTES; use crate::provider::SkillListQuery; use crate::provider::SkillProvider; use crate::provider::SkillProviderFuture; +use crate::provider::SkillReadContext; use crate::provider::SkillReadRequest; use crate::provider::SkillSearchRequest; @@ -162,39 +163,23 @@ impl SkillProvider for ExecutorSkillProvider { "executor skill resource does not match its package", )); } + let SkillReadContext::Executor { fs } = request.context else { + return Err(SkillProviderError::new( + "executor skill reads require filesystem access", + )); + }; if let Some(contents) = request.resource.environment_contents() { return Ok(SkillReadResult { resource: request.resource.clone(), contents: contents.to_string(), }); } - let Some((environment_id, resource_path)) = request.resource.environment_path() else { + let Some((_, resource_path)) = request.resource.environment_path() else { return Err(SkillProviderError::new( "executor skill resource is not bound to an environment", )); }; - let file_system = request - .resolved_executor_roots - .iter() - .find(|root| root.selected_root().id == request.authority.id) - .map(|root| root.environment().get_filesystem()) - .or_else(|| { - self.environment_manager - .get_environment(environment_id) - .map(|environment| environment.get_filesystem()) - }); - let Some(file_system) = file_system else { - return Err(SkillProviderError::new(format!( - "executor skill resource references unavailable environment `{environment_id}`" - ))); - }; - let contents = read_bounded_text( - file_system.as_ref(), - resource_path, - request.resource.as_str(), - request.sandbox.as_ref(), - ) - .await?; + let contents = read_bounded_text(fs, resource_path, request.resource.as_str()).await?; Ok(SkillReadResult { resource: request.resource, @@ -326,27 +311,17 @@ fn normalized_environment_path(path: &PathUri) -> String { } async fn read_bounded_text( - file_system: &dyn codex_exec_server::ExecutorFileSystem, + file_system: &dyn EnvironmentAccess, path: &PathUri, resource: &str, - sandbox: Option<&FileSystemSandboxContext>, ) -> Result { let read_error = |err| { SkillProviderError::new(format!( "failed to read executor skill resource {resource}: {err}" )) }; - if sandbox.is_some_and(FileSystemSandboxContext::should_read_from_sandbox) - && path.infer_path_convention() == Some(PathConvention::Windows) - && sandbox.is_some_and(|context| !context.windows_sandbox_is_requested()) - { - return Err(SkillProviderError::new( - "executor skill resource requires an unavailable filesystem sandbox", - )); - } - let mut stream = file_system - .read_file_stream(path, sandbox) + .read_file_stream(path) .await .map_err(&read_error)?; let mut contents = Vec::new(); diff --git a/codex-rs/ext/skills/src/provider/host.rs b/codex-rs/ext/skills/src/provider/host.rs index 9aed89618c..8e5da1032a 100644 --- a/codex-rs/ext/skills/src/provider/host.rs +++ b/codex-rs/ext/skills/src/provider/host.rs @@ -15,6 +15,7 @@ use crate::catalog::SkillSourceKind; use crate::provider::SkillListQuery; use crate::provider::SkillProvider; use crate::provider::SkillProviderFuture; +use crate::provider::SkillReadContext; use crate::provider::SkillReadRequest; use crate::provider::SkillSearchRequest; @@ -51,7 +52,10 @@ impl SkillProvider for HostSkillProvider { request: SkillReadRequest<'a>, ) -> SkillProviderFuture<'a, SkillReadResult> { Box::pin(async move { - let Some(host_snapshot) = request.host_snapshot else { + let SkillReadContext::Host { + host_snapshot: Some(host_snapshot), + } = request.context + else { return Err(SkillProviderError::new( "host skill provider requires a host skills snapshot", )); diff --git a/codex-rs/ext/skills/src/state.rs b/codex-rs/ext/skills/src/state.rs index e1997da589..d7d0ac56c0 100644 --- a/codex-rs/ext/skills/src/state.rs +++ b/codex-rs/ext/skills/src/state.rs @@ -1,10 +1,8 @@ use std::collections::HashSet; use std::sync::Arc; use std::sync::Mutex; -use std::sync::Weak; -use codex_exec_server::Environment; -use codex_exec_server::FileSystemSandboxContext; +use codex_exec_server::EnvironmentAccessKey; use codex_extension_api::ExtensionMetrics; use codex_mcp::McpResourceClient; use codex_protocol::capabilities::SelectedCapabilityRoot; @@ -20,6 +18,7 @@ use crate::catalog::SkillProviderResult; use crate::catalog::SkillReadResult; use crate::catalog::SkillSourceKind; use crate::provider::SkillListQuery; +use crate::provider::SkillReadContext; use crate::provider::SkillReadRequest; use crate::shadow_selection_experiment::RecentSkillInvocations; use crate::shadow_selection_experiment::ShadowSelectionTurnState; @@ -370,7 +369,12 @@ impl SkillsThreadState { return providers.read(request).await; } - let cache = self.cloud_cache(request.mcp_resources.as_deref()); + let SkillReadContext::Cloud { mcp_resources } = &request.context else { + return Err(SkillProviderError::new( + "cloud skill reads require a cloud context", + )); + }; + let cache = self.cloud_cache(mcp_resources.as_deref()); let cache_key = SkillReadCacheKey::from(&request); { let config = self @@ -435,9 +439,8 @@ impl SkillsThreadState { pub(crate) struct ExecutorReadSnapshot { pub(crate) authority: SkillAuthority, pub(crate) package: SkillPackageId, - // Named environments can be replaced; do not reuse their old resource or keep them alive. - pub(crate) environment: Weak, - pub(crate) sandbox: Option, + // The key binds cached contents to their source filesystem and callback permissions. + pub(crate) access: EnvironmentAccessKey, pub(crate) result: Arc, } diff --git a/codex-rs/ext/skills/src/tools/mod.rs b/codex-rs/ext/skills/src/tools/mod.rs index 8ca6c2a283..64d2eaddde 100644 --- a/codex-rs/ext/skills/src/tools/mod.rs +++ b/codex-rs/ext/skills/src/tools/mod.rs @@ -1,4 +1,3 @@ -use std::collections::HashMap; use std::collections::hash_map::DefaultHasher; use std::hash::Hash; use std::hash::Hasher; @@ -9,7 +8,6 @@ use codex_analytics::InvocationType; use codex_analytics::SkillInvocation; use codex_analytics::SkillInvocationLocation; use codex_analytics::build_track_events_context; -use codex_exec_server::FileSystemSandboxContext; use codex_extension_api::ExtensionData; use codex_extension_api::ExtensionMetrics; use codex_extension_api::FunctionCallError; @@ -64,7 +62,6 @@ pub(crate) fn skill_tools( thread_store: &ExtensionData, executor_query: Option, selected_plugins: Option>, - sandbox_contexts: Option>>, ) -> Vec ToolExecutor>>> { let Some(thread_state) = thread_store.get::() else { return Vec::new(); @@ -85,7 +82,6 @@ pub(crate) fn skill_tools( cloud_available, executor_query, selected_plugins, - sandbox_contexts, executor_catalog: Arc::new(OnceCell::new()), }; vec![ @@ -220,7 +216,6 @@ struct SkillToolContext { cloud_available: bool, executor_query: Option, selected_plugins: Option>, - sandbox_contexts: Option>>, executor_catalog: Arc>, } diff --git a/codex-rs/ext/skills/src/tools/read.rs b/codex-rs/ext/skills/src/tools/read.rs index eb06993abc..012cc8e8a7 100644 --- a/codex-rs/ext/skills/src/tools/read.rs +++ b/codex-rs/ext/skills/src/tools/read.rs @@ -1,4 +1,3 @@ -use std::marker::PhantomData; use std::sync::Arc; use codex_analytics::InvocationType; @@ -14,6 +13,7 @@ use serde::Serialize; use crate::catalog::SkillResourceId; use crate::provider::MAX_SKILL_RESOURCE_CONTENT_BYTES; +use crate::provider::SkillReadContext; use crate::provider::SkillReadRequest; use crate::render::build_alias_plan; use crate::state::ExecutorReadSnapshot; @@ -21,6 +21,7 @@ use crate::state::ExecutorReadSnapshot; use super::MAX_HANDLE_BYTES; use super::MAX_SKILL_RESPONSE_BYTES; use super::SkillToolAuthority; +use super::SkillToolAuthoritySelector; use super::SkillToolContext; use super::pagination_cursor; use super::parse_args; @@ -121,42 +122,35 @@ impl<'call> ToolExecutor> for ReadTool { .bind_environment_package_resource(&package, resource.clone()) .unwrap_or_else(|| SkillResourceId::new(resource)), }; - let resolved_executor_roots = self - .context - .executor_query - .as_ref() - .map(|query| query.resolved_executor_roots.clone()) - .unwrap_or_default(); - let executor_environment = resolved_executor_roots - .iter() - .find(|root| root.selected_root().id == authority.id) - .map(|root| Arc::downgrade(root.environment())); - let sandbox = requested_resource - .environment_path() - .and_then(|(environment_id, _)| { - self.context.sandbox_contexts.as_ref().and_then(|contexts| { - contexts.get(environment_id).map(|captured| { + let (context, access_key) = match output_authority { + SkillToolAuthoritySelector::Cloud => ( + SkillReadContext::Cloud { + mcp_resources: self.context.mcp_resources.clone(), + }, + None, + ), + SkillToolAuthoritySelector::Executor => { + let fs = requested_resource + .environment_path() + .and_then(|(id, _)| { call.environments .iter() - .find(|environment| environment.environment_id == environment_id) - .map(|environment| environment.file_system_sandbox_context.clone()) - .unwrap_or_else(|| captured.clone()) + .find(|env| env.environment_id == id) }) - }) - }); - if self.context.sandbox_contexts.is_some() - && requested_resource.environment_path().is_some() - && sandbox.is_none() - { - return Err(FunctionCallError::RespondToModel( - "failed to read skill resource".to_string(), - )); - } + .map(codex_extension_api::ToolEnvironment::fs) + .ok_or_else(|| { + FunctionCallError::RespondToModel( + "skill environment is not available for this callback".to_string(), + ) + })?; + (SkillReadContext::Executor { fs }, Some(fs.cache_key())) + } + }; // Reuse the snapshot to avoid reading the whole file for each page. File edits // are not detected on cache hits, so a continuation can return old contents. // Snapshots have no expiry and are not cleared after the final page. let cached = args.cursor.as_deref().and_then(|cursor| { - let environment = executor_environment.as_ref()?; + let access = access_key.as_ref()?; let snapshot = self .context .thread_state @@ -167,8 +161,7 @@ impl<'call> ToolExecutor> for ReadTool { snapshot.authority == authority && snapshot.package == package && snapshot.result.resource == requested_resource - && snapshot.environment.ptr_eq(environment) - && snapshot.sandbox == sandbox + && snapshot.access == *access })?; let start = parse_pagination_cursor( Some(cursor), @@ -187,14 +180,10 @@ impl<'call> ToolExecutor> for ReadTool { .read_skill( &self.context.providers, SkillReadRequest { - _lifetime: PhantomData, authority: authority.clone(), package: package.clone(), resource: requested_resource.clone(), - resolved_executor_roots, - sandbox: sandbox.clone(), - host_snapshot: None, - mcp_resources: self.context.mcp_resources.clone(), + context, }, ) .await @@ -255,7 +244,7 @@ impl<'call> ToolExecutor> for ReadTool { if output_authority == super::SkillToolAuthoritySelector::Executor && response.next_cursor.is_some() && result.contents.len() <= MAX_SKILL_RESOURCE_CONTENT_BYTES - && let Some(environment) = executor_environment + && let Some(access) = access_key { *self .context @@ -266,8 +255,7 @@ impl<'call> ToolExecutor> for ReadTool { Some(ExecutorReadSnapshot { authority, package, - environment, - sandbox, + access, result, }); } diff --git a/codex-rs/ext/skills/tests/executor_file_system_authority.rs b/codex-rs/ext/skills/tests/executor_file_system_authority.rs index ef7f6535a3..957123ea87 100644 --- a/codex-rs/ext/skills/tests/executor_file_system_authority.rs +++ b/codex-rs/ext/skills/tests/executor_file_system_authority.rs @@ -1,6 +1,5 @@ use std::collections::HashMap; use std::io; -use std::marker::PhantomData; use std::sync::Arc; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; @@ -15,14 +14,20 @@ use codex_exec_server::CopyOptions; use codex_exec_server::CreateDirectoryOptions; use codex_exec_server::DiscoveredSkillFiles; use codex_exec_server::EnvironmentManager; +#[cfg(windows)] +use codex_exec_server::ExecServerRuntimeOptions; use codex_exec_server::ExecutorCapabilityDiscoveryCache; use codex_exec_server::ExecutorCapabilityDiscoverySnapshot; use codex_exec_server::ExecutorFileSystem; use codex_exec_server::ExecutorFileSystemFuture; use codex_exec_server::FileMetadata; +use codex_exec_server::FileSystemEnvironmentAccessor; use codex_exec_server::FileSystemReadStream; use codex_exec_server::FileSystemSandboxContext; use codex_exec_server::GetMetadataOptions; +use codex_exec_server::LOCAL_FS; +#[cfg(windows)] +use codex_exec_server::LocalFileSystem; use codex_exec_server::ReadDirectoryEntry; use codex_exec_server::ReadFileOptions; use codex_exec_server::RemoveOptions; @@ -30,12 +35,15 @@ use codex_exec_server::WalkEntry; use codex_exec_server::WalkEntryKind; use codex_exec_server::WalkOptions; use codex_exec_server::WalkOutcome; +#[cfg(windows)] use codex_exec_server::WindowsSandboxSelection; use codex_exec_server::WriteFileOptions; use codex_protocol::capabilities::CapabilityRootLocation; use codex_protocol::capabilities::SelectedCapabilityRoot; use codex_protocol::models::PermissionProfile; +#[cfg(windows)] use codex_protocol::permissions::FileSystemSandboxPolicy; +#[cfg(windows)] use codex_protocol::permissions::NetworkSandboxPolicy; use codex_protocol::protocol::Product; use codex_skills_extension::ExecutorSkillProvider; @@ -45,10 +53,13 @@ use codex_skills_extension::catalog::SkillAuthority; use codex_skills_extension::catalog::SkillCatalog; use codex_skills_extension::catalog::SkillCatalogEntry; use codex_skills_extension::catalog::SkillPackageId; +#[cfg(windows)] +use codex_skills_extension::catalog::SkillReadResult; use codex_skills_extension::catalog::SkillResourceId; use codex_skills_extension::catalog::SkillSourceKind; use codex_skills_extension::provider::SkillListQuery; use codex_skills_extension::provider::SkillProvider; +use codex_skills_extension::provider::SkillReadContext; use codex_skills_extension::provider::SkillReadRequest; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_path_uri::PathUri; @@ -301,62 +312,71 @@ async fn skill_loading_and_reads_use_the_supplied_executor_file_system() { ); } +/// Restricted skill reads must fail closed when the Windows executor has no sandbox selected. +#[cfg(windows)] #[tokio::test] -async fn windows_executor_skill_read_requires_a_requested_sandbox() { +async fn windows_executor_skill_read_requires_a_requested_sandbox() -> io::Result<()> { + let test_root = create_local_skill_root("windows-sandbox")?; + // Disabled sandbox selection must fail before launching any helper. + let runtime_paths = ExecServerRuntimeOptions::new( + std::env::current_exe()?, + /*codex_linux_sandbox_exe*/ None, + )?; + let file_system: Arc = + Arc::new(LocalFileSystem::with_runtime_paths(runtime_paths)); let provider = ExecutorSkillProvider::new_with_restriction_product( Arc::new(EnvironmentManager::default_for_tests()), /*restriction_product*/ None, ); + let resource = SkillResourceId::environment( + "skill://windows-root/skill/SKILL.md", + "local", + PathUri::from_host_native_path(test_root.join("skill/SKILL.md"))?, + ); + let access = FileSystemEnvironmentAccessor::unrestricted(&file_system); + let read = provider + .read(SkillReadRequest { + authority: SkillAuthority::new(SkillSourceKind::Executor, "windows-root"), + package: SkillPackageId("skill://windows-root/skill".into()), + resource: resource.clone(), + context: SkillReadContext::Executor { fs: &access }, + }) + .await + .expect("read the existing skill without sandbox restrictions"); + assert_eq!( + read, + SkillReadResult { + resource: resource.clone(), + contents: SKILL_CONTENTS.to_string(), + } + ); + let mut sandbox = FileSystemSandboxContext::from_permission_profile( PermissionProfile::from_runtime_permissions( &FileSystemSandboxPolicy::restricted(Vec::new()), NetworkSandboxPolicy::Restricted, ), - PathUri::parse("file:///C:/skill").expect("Windows resource cwd"), - ); - let resource = SkillResourceId::environment( - "skill://windows-root/C:/skill/SKILL.md", - "local", - PathUri::parse("file:///C:/skill/SKILL.md").expect("Windows resource URI"), + PathUri::from_host_native_path(&test_root)?, ); + sandbox.windows_sandbox_selection = WindowsSandboxSelection::Disabled; + let access = FileSystemEnvironmentAccessor::new(&file_system, sandbox); let error = provider .read(SkillReadRequest { - _lifetime: PhantomData, authority: SkillAuthority::new(SkillSourceKind::Executor, "windows-root"), - package: SkillPackageId("skill://windows-root/C:/skill".into()), + package: SkillPackageId("skill://windows-root/skill".into()), resource: resource.clone(), - resolved_executor_roots: Vec::new(), - sandbox: Some(sandbox.clone()), - host_snapshot: None, - mcp_resources: None, + context: SkillReadContext::Executor { fs: &access }, }) .await .expect_err("disabled Windows sandbox must fail closed"); assert_eq!( error.message, - "executor skill resource requires an unavailable filesystem sandbox" - ); - - sandbox.windows_sandbox_selection = WindowsSandboxSelection::Mxc; - let error = provider - .read(SkillReadRequest { - _lifetime: PhantomData, - authority: SkillAuthority::new(SkillSourceKind::Executor, "windows-root"), - package: SkillPackageId("skill://windows-root/C:/skill".into()), - resource, - resolved_executor_roots: Vec::new(), - sandbox: Some(sandbox), - host_snapshot: None, - mcp_resources: None, - }) - .await - .expect_err("synthetic Windows resource should not be readable"); - assert!( - error - .message - .starts_with("failed to read executor skill resource"), - "{error:?}" + format!( + "failed to read executor skill resource {}: filesystem sandbox cannot be enforced on this executor", + resource.as_str() + ) ); + std::fs::remove_dir_all(test_root) } #[tokio::test] @@ -939,15 +959,12 @@ async fn high_level_discovery_reuses_materialized_skill_contents_for_reads() { let [entry] = catalog.entries.as_slice() else { panic!("expected exactly one skill"); }; + let access = FileSystemEnvironmentAccessor::unrestricted(&LOCAL_FS); let request = SkillReadRequest { - _lifetime: PhantomData, authority: entry.authority.clone(), package: entry.id.clone(), resource: entry.main_prompt.clone(), - resolved_executor_roots: Vec::new(), - sandbox: None, - host_snapshot: None, - mcp_resources: None, + context: SkillReadContext::Executor { fs: &access }, }; std::fs::remove_dir_all(&test_root).expect("remove skill directory after discovery"); diff --git a/codex-rs/ext/skills/tests/skills_extension.rs b/codex-rs/ext/skills/tests/skills_extension.rs index db0718cbde..d4a5be14e6 100644 --- a/codex-rs/ext/skills/tests/skills_extension.rs +++ b/codex-rs/ext/skills/tests/skills_extension.rs @@ -11,6 +11,7 @@ use codex_config::ConfigLayerStack; use codex_config::ConfigRequirementsToml; use codex_exec_server::CapabilityRootDiscovery; use codex_exec_server::ExecutorCapabilityDiscoverySnapshot; +use codex_exec_server::FileSystemEnvironmentAccessor; use codex_exec_server::LOCAL_FS; use codex_extension_api::ConversationHistory; use codex_extension_api::ExtensionData; @@ -987,7 +988,15 @@ async fn shadow_lru_selector_recovers_a_skill_invoked_on_an_earlier_turn() -> Te text: text.to_string(), text_elements: Vec::new(), }], - environments: Vec::new(), + environments: vec![codex_extension_api::TurnInputEnvironment { + environment_id: "test".to_string(), + cwd: PathUri::from_host_native_path( + std::env::current_dir().expect("test cwd"), + ) + .expect("absolute cwd"), + is_primary: true, + fs: &FileSystemEnvironmentAccessor::unrestricted(&LOCAL_FS), + }], }, /*extension_metrics*/ None, &session_store, @@ -1082,14 +1091,21 @@ async fn shadow_lru_selector_recovers_a_skill_invoked_on_an_earlier_turn() -> Te async fn selected_executor_catalog_follows_step_availability_and_reuses_its_cache() -> TestResult { let read_requests = Arc::new(Mutex::new(Vec::new())); let list_calls = Arc::new(AtomicUsize::new(0)); + let resource = SkillResourceId::environment( + "lint-fix/SKILL.md", + "env-1", + PathUri::parse("file:///skills/lint-fix/SKILL.md")?, + ); + let mut entry = test_entry( + SkillSourceKind::Executor, + "env-1", + "executor/lint-fix", + "lint-fix/SKILL.md", + ); + entry.main_prompt = resource.clone(); let executor_provider = Arc::new(StaticSkillProvider { catalog: SkillCatalog { - entries: vec![test_entry( - SkillSourceKind::Executor, - "env-1", - "executor/lint-fix", - "lint-fix/SKILL.md", - )], + entries: vec![entry], warnings: Vec::new(), }, read_requests: Arc::clone(&read_requests), @@ -1132,7 +1148,7 @@ async fn selected_executor_catalog_follows_step_availability_and_reuses_its_cach let turn_store = ExtensionData::new("turn-1"); let turn_environment = TurnEnvironmentSelection { - environment_id: "turn-env".to_string(), + environment_id: "env-1".to_string(), cwd: PathUri::parse("file:///workspace").expect("cwd URI"), workspace_roots: Vec::new(), config: EnvironmentConfigState::FromThread, @@ -1172,7 +1188,12 @@ async fn selected_executor_catalog_follows_step_availability_and_reuses_its_cach text: "$lint-fix please".to_string(), text_elements: Vec::new(), }], - environments: Vec::new(), + environments: vec![codex_extension_api::TurnInputEnvironment { + environment_id: turn_environment.environment_id.clone(), + cwd: turn_environment.cwd.clone(), + is_primary: true, + fs: &FileSystemEnvironmentAccessor::unrestricted(&LOCAL_FS), + }], }, /*extension_metrics*/ None, &session_store, @@ -1189,7 +1210,7 @@ async fn selected_executor_catalog_follows_step_availability_and_reuses_its_cach vec![( SkillAuthority::new(SkillSourceKind::Executor, "env-1"), SkillPackageId("executor/lint-fix".to_string()), - SkillResourceId::new("lint-fix/SKILL.md"), + resource, )], read_request_keys(&read_requests) ); @@ -2155,6 +2176,7 @@ async fn root_qualified_locator_selects_only_the_matching_executor_skill() -> Te let read_requests = Arc::new(Mutex::new(Vec::new())); let root_a_locator = "skill://root-a/shared/lint-fix/SKILL.md"; let root_b_locator = "skill://root-b/shared/lint-fix/SKILL.md"; + let skill_path = PathUri::parse("file:///shared/lint-fix/SKILL.md")?; let executor_provider = Arc::new(StaticSkillProvider { catalog: SkillCatalog { entries: [("root-a", root_a_locator), ("root-b", root_b_locator)] @@ -2165,7 +2187,7 @@ async fn root_qualified_locator_selects_only_the_matching_executor_skill() -> Te SkillAuthority::new(SkillSourceKind::Executor, root_id), "lint-fix", "Fix lint errors.", - SkillResourceId::new(locator), + SkillResourceId::environment(locator, "env-1", skill_path.clone()), ) .with_display_path(locator) }) @@ -2236,7 +2258,12 @@ async fn root_qualified_locator_selects_only_the_matching_executor_skill() -> Te name: "lint-fix".to_string(), path: root_b_locator.to_string(), }], - environments: Vec::new(), + environments: vec![codex_extension_api::TurnInputEnvironment { + environment_id: "env-1".to_string(), + cwd: PathUri::parse("file:///workspace")?, + is_primary: true, + fs: &FileSystemEnvironmentAccessor::unrestricted(&LOCAL_FS), + }], }, /*extension_metrics*/ None, &session_store, @@ -2251,7 +2278,7 @@ async fn root_qualified_locator_selects_only_the_matching_executor_skill() -> Te vec![( SkillAuthority::new(SkillSourceKind::Executor, "root-b"), SkillPackageId(root_b_locator.to_string()), - SkillResourceId::new(root_b_locator), + SkillResourceId::environment(root_b_locator, "env-1", skill_path), )], read_request_keys(&read_requests) ); diff --git a/codex-rs/ext/skills/tests/skills_extension/presentation_dedup_tests.rs b/codex-rs/ext/skills/tests/skills_extension/presentation_dedup_tests.rs index 3ab7d57630..9d1747538b 100644 --- a/codex-rs/ext/skills/tests/skills_extension/presentation_dedup_tests.rs +++ b/codex-rs/ext/skills/tests/skills_extension/presentation_dedup_tests.rs @@ -2,6 +2,7 @@ use super::*; use codex_exec_server::EnvironmentManager; +use codex_extension_api::ToolEnvironment; use pretty_assertions::assert_eq; #[tokio::test] @@ -24,6 +25,11 @@ async fn cloud_preference_preserves_aliases_reads_and_executor_fallback() -> Tes ); entry.name = format!("{plugin}:s{index}"); entry.description = description.clone(); + entry.main_prompt = SkillResourceId::environment( + format!("{package}/SKILL.md"), + "local", + PathUri::parse(&format!("file:///skills/{plugin}/s{index}/SKILL.md"))?, + ); executor_entries.push(entry.with_alias_root(root)); } } @@ -90,6 +96,7 @@ async fn cloud_preference_preserves_aliases_reads_and_executor_fallback() -> Tes .resolve_selected_capability_roots(&roots, &Default::default()) .await; assert_eq!(resolved_roots.len(), 1); + let access = FileSystemEnvironmentAccessor::unrestricted(&LOCAL_FS); let mut previous = serde_json::Map::new(); let mut initial_cloud_body = None; let model_info = ModelInfo { @@ -217,7 +224,11 @@ async fn cloud_preference_preserves_aliases_reads_and_executor_fallback() -> Tes source: ToolCallSource::Direct, conversation_history: ConversationHistory::default(), turn_item_emitter: Arc::new(NoopTurnItemEmitter), - environments: Vec::new(), + environments: vec![ToolEnvironment::new( + "local".to_string(), + PathUri::parse("file:///skills")?, + &access, + )], payload: payload.clone(), }) .await?; diff --git a/codex-rs/ext/skills/tests/skills_extension/shadow_task_context_tests.rs b/codex-rs/ext/skills/tests/skills_extension/shadow_task_context_tests.rs index b288a880e7..a756156aee 100644 --- a/codex-rs/ext/skills/tests/skills_extension/shadow_task_context_tests.rs +++ b/codex-rs/ext/skills/tests/skills_extension/shadow_task_context_tests.rs @@ -169,7 +169,15 @@ async fn task_context_recovers_prior_requests_and_explicit_intent_without_changi TurnInputContext { turn_id: turn_id.to_string(), user_input, - environments: Vec::new(), + environments: vec![codex_extension_api::TurnInputEnvironment { + environment_id: "test".to_string(), + cwd: PathUri::from_host_native_path( + std::env::current_dir().expect("test cwd"), + ) + .expect("absolute cwd"), + is_primary: true, + fs: &FileSystemEnvironmentAccessor::unrestricted(&LOCAL_FS), + }], }, /*extension_metrics*/ None, &session_store, diff --git a/codex-rs/tools/src/tool_call.rs b/codex-rs/tools/src/tool_call.rs index a2c57a5015..95b3360e8e 100644 --- a/codex-rs/tools/src/tool_call.rs +++ b/codex-rs/tools/src/tool_call.rs @@ -2,8 +2,7 @@ use crate::FunctionCallError; use crate::ToolName; use crate::ToolPayload; use codex_extension_items::ExtensionItem; -use codex_file_system::ExecutorFileSystem; -use codex_file_system::FileSystemSandboxContext; +use codex_file_system::EnvironmentAccess; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::EventMsg; use codex_utils_output_truncation::TruncationPolicy; @@ -11,7 +10,6 @@ use codex_utils_output_truncation::with_serialization_allowance; use codex_utils_path_uri::PathUri; use std::fmt; use std::future::Future; -use std::marker::PhantomData; use std::pin::Pin; use std::sync::Arc; use std::sync::LazyLock; @@ -85,19 +83,36 @@ pub trait TurnItemEmitter: Send + Sync { fn emit_completed<'a>(&'a self, item: ExtensionTurnItem) -> TurnItemEmissionFuture<'a>; } -/// Host-owned turn environment summary visible to extension tools. +/// Callback-scoped view of a turn environment for extension tools. +/// +/// The host retains its runtime and configuration, and supplies access with this callback's +/// grants already applied. Borrowing the accessor prevents retaining it for a later callback. #[derive(Clone)] pub struct ToolEnvironment<'call> { /// Stable host environment id used to route executor-scoped capabilities. pub environment_id: String, /// Effective working directory for this turn in the environment. pub cwd: PathUri, - /// Filesystem implementation for this environment. - pub file_system: Arc, - /// Sandbox context to use for filesystem operations. - pub file_system_sandbox_context: FileSystemSandboxContext, - // TODO(anp): Replace the marker with callback-scoped environment access. - pub _lifetime: PhantomData<&'call ()>, + file_system: &'call dyn EnvironmentAccess, +} + +impl<'call> ToolEnvironment<'call> { + pub fn new( + environment_id: String, + cwd: PathUri, + file_system: &'call dyn EnvironmentAccess, + ) -> Self { + Self { + environment_id, + cwd, + file_system, + } + } + + /// Borrows filesystem access with the permissions captured for this callback. + pub fn fs(&self) -> &dyn EnvironmentAccess { + self.file_system + } } /// Turn-item emitter used when a caller does not expose visible item emission.