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.