Lightweight coding agent that runs in your terminal
Rust
Scope extension filesystem access to callback permissions (#49898)
Adam Perry @ OpenAIda2e174a66a6
diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex 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::<HashMap<_, _>>();- 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.rsindex 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.rsindex 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<_>>(),+ 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.rsindex 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::<Vec<_>>();diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex 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<AdditionalPermissionProfile>,+ ) -> 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.rsindex 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<ToolInvocation> for ExtensionToolAdapter {whereToolInvocation: '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<ToolEnvironment<'a>>,+) -> 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.rsindex 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_discoverenum 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::<Value>(&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.rsindex 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<TurnInputEnvironment<'a>>,}++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.rsindex 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<AbsolutePathBuf> = 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<ImageReference, FunctionCallError> {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.rsindex 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<Arc<McpResourceClient>>) -> SkillListQuery {fn request(client: Option<Arc<McpResourceClient>>) -> 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.rsindex 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 @@ wherethread_store,/*executor_query*/ None,/*selected_plugins*/ None,- /*sandbox_contexts*/ None,)}@@ -337,7 +334,6 @@ wherethread_store,executor_query,step_store.get::<SelectedPluginSnapshot>(),- step_store.get::<HashMap<String, FileSystemSandboxContext>>(),)}}@@ -480,6 +476,7 @@ wherehost_snapshot.clone(),mcp_resources.clone(),&thread_state,+ &input,).await{@@ -581,7 +578,6 @@ impl<C> SkillsExtension<C> {thread_store: &ExtensionData,executor_query: Option<SkillListQuery>,selected_plugins: Option<Arc<SelectedPluginSnapshot>>,- sandbox_contexts: Option<Arc<HashMap<String, FileSystemSandboxContext>>>,) -> Vec<Arc<dyn for<'call> ToolExecutor<ToolCall<'call>>>> {skill_tools(self.providers.clone(),@@ -589,7 +585,6 @@ impl<C> SkillsExtension<C> {thread_store,executor_query,selected_plugins,- sandbox_contexts,)}@@ -617,19 +612,37 @@ impl<C> SkillsExtension<C> {host_snapshot: Option<Arc<HostSkillsSnapshot>>,mcp_resources: Option<Arc<McpResourceClient>>,thread_state: &SkillsThreadState,+ input: &TurnInputContext<'_>,) -> Result<SkillReadResult, String> {+ 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,},).awaitdiff --git a/codex-rs/ext/skills/src/provider.rs b/codex-rs/ext/skills/src/provider.rsindex 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<ExecutorCapabilityDiscoverySnapshot>,}-#[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<ResolvedSelectedCapabilityRoot>,- pub sandbox: Option<FileSystemSandboxContext>,- pub host_snapshot: Option<Arc<HostSkillsSnapshot>>,- pub mcp_resources: Option<Arc<McpResourceClient>>,+ 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<Arc<HostSkillsSnapshot>>,+ },+ Executor {+ fs: &'a dyn EnvironmentAccess,+ },+ Cloud {+ mcp_resources: Option<Arc<McpResourceClient>>,+ },+ Custom {+ mcp_resources: Option<Arc<McpResourceClient>>,+ },}#[derive(Clone, Debug, PartialEq, Eq)]diff --git a/codex-rs/ext/skills/src/provider/executor.rs b/codex-rs/ext/skills/src/provider/executor.rsindex 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<String, SkillProviderError> {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.rsindex 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.rsindex 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<Environment>,- pub(crate) sandbox: Option<FileSystemSandboxContext>,+ // The key binds cached contents to their source filesystem and callback permissions.+ pub(crate) access: EnvironmentAccessKey,pub(crate) result: Arc<SkillReadResult>,}diff --git a/codex-rs/ext/skills/src/tools/mod.rs b/codex-rs/ext/skills/src/tools/mod.rsindex 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<SkillListQuery>,selected_plugins: Option<Arc<SelectedPluginSnapshot>>,- sandbox_contexts: Option<Arc<HashMap<String, FileSystemSandboxContext>>>,) -> Vec<Arc<dyn for<'call> ToolExecutor<ToolCall<'call>>>> {let Some(thread_state) = thread_store.get::<SkillsThreadState>() 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<SkillListQuery>,selected_plugins: Option<Arc<SelectedPluginSnapshot>>,- sandbox_contexts: Option<Arc<HashMap<String, FileSystemSandboxContext>>>,executor_catalog: Arc<OnceCell<SkillCatalog>>,}diff --git a/codex-rs/ext/skills/src/tools/read.rs b/codex-rs/ext/skills/src/tools/read.rsindex 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<ToolCall<'call>> 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<ToolCall<'call>> 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<ToolCall<'call>> 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<ToolCall<'call>> 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<ToolCall<'call>> 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.rsindex 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<dyn ExecutorFileSystem> =+ 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 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",+ "skill://windows-root/skill/SKILL.md","local",- PathUri::parse("file:///C:/skill/SKILL.md").expect("Windows resource URI"),+ PathUri::from_host_native_path(test_root.join("skill/SKILL.md"))?,);- let error = provider+ let access = FileSystemEnvironmentAccessor::unrestricted(&file_system);+ let read = 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");+ .expect("read the existing skill without sandbox restrictions");assert_eq!(- error.message,- "executor skill resource requires an unavailable filesystem sandbox"+ read,+ SkillReadResult {+ resource: resource.clone(),+ contents: SKILL_CONTENTS.to_string(),+ });- sandbox.windows_sandbox_selection = WindowsSandboxSelection::Mxc;+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(+ &FileSystemSandboxPolicy::restricted(Vec::new()),+ NetworkSandboxPolicy::Restricted,+ ),+ 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()),- resource,- resolved_executor_roots: Vec::new(),- sandbox: Some(sandbox),- host_snapshot: None,- mcp_resources: None,+ package: SkillPackageId("skill://windows-root/skill".into()),+ resource: resource.clone(),+ context: SkillReadContext::Executor { fs: &access },}).await- .expect_err("synthetic Windows resource should not be readable");- assert!(- error- .message- .starts_with("failed to read executor skill resource"),- "{error:?}"+ .expect_err("disabled Windows sandbox must fail closed");+ assert_eq!(+ error.message,+ 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.rsindex 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() -> Tetext: 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() -> Teasync 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_cachlet 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_cachtext: "$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_cachvec![(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() -> Telet 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() -> TeSkillAuthority::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() -> Tename: "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() -> Tevec![(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.rsindex 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() -> Tessource: 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.rsindex 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_changiTurnInputContext {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.rsindex 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<dyn ExecutorFileSystem>,- /// 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.