Skip to content

armgit / codex

Public Imported from GitHub
0

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.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::<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.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<_>>(),
+ 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::<Vec<_>>();
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<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.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<ToolInvocation> 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<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.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::<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.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<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.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<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.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<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.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::<SelectedPluginSnapshot>(),
- step_store.get::<HashMap<String, FileSystemSandboxContext>>(),
)
}
}
@@ -480,6 +476,7 @@ where
host_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,
},
)
.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<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.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<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.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<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.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<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.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<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.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<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.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<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.