Lightweight coding agent that runs in your terminal
Rust
Preserve filesystem sandbox policy context when the cwd disappears (#46112)
Adam Perry @ OpenAI841b5490b251
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 77470f0ae1..86413b6d60 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -3263,6 +3263,7 @@ dependencies = ["codex-shell-command","codex-test-binary-support","codex-utils-absolute-path",+ "codex-utils-cargo-bin","codex-utils-home-dir","codex-utils-path-uri","codex-utils-pty",diff --git a/codex-rs/core/src/apply_patch_tests.rs b/codex-rs/core/src/apply_patch_tests.rsindex 275b2a2da7..45e33822f2 100644--- a/codex-rs/core/src/apply_patch_tests.rs+++ b/codex-rs/core/src/apply_patch_tests.rs@@ -59,7 +59,7 @@ async fn prepare_apply_patch_uses_action_policy_before_turn_policy() {environment.config_mut().permission_profile =PermissionProfileSnapshot::legacy(permission_profile);let sandbox = environment.sandbox_context(/*additional_permissions*/ None);- let context = sandbox.policy_context().expect("local sandbox context");+ let context = sandbox.policy_context();let prepared = prepare_apply_patch(&step,diff --git a/codex-rs/core/src/environment_selection.rs b/codex-rs/core/src/environment_selection.rsindex c1993ab5fc..62761030bf 100644--- a/codex-rs/core/src/environment_selection.rs+++ b/codex-rs/core/src/environment_selection.rs@@ -1333,8 +1333,7 @@ url = "ws://127.0.0.1:8765"assert_eq!(environment.sandbox_context(/*additional_permissions*/ None)- .policy_context()- .expect("selected environment sandbox context has cwd"),+ .policy_context(),FileSystemSandboxPolicyContext {cwd: environment.cwd(),workspace_roots: &[],@@ -1686,8 +1685,7 @@ url = "ws://127.0.0.1:8765"assert_eq!(environment.sandbox_context(/*additional_permissions*/ None)- .policy_context()- .expect("selected environment sandbox context has cwd"),+ .policy_context(),FileSystemSandboxPolicyContext {cwd: environment.cwd(),workspace_roots: &[],diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex c242c83cd4..c5df08eee1 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -3055,13 +3055,7 @@ impl Session {let requested_permissions = args.permissions;let sandbox_context = environment.sandbox_context(/*additional_permissions*/ None);- let Some(context) = sandbox_context.policy_context() else {- return Some(RequestPermissionsResponse {- permissions: RequestPermissionProfile::default(),- scope: PermissionGrantScope::Turn,- strict_auto_review: false,- });- };+ let context = sandbox_context.policy_context();{let originating_turn_state = {let active = self.active_turn.lock().await;@@ -3292,19 +3286,11 @@ impl Session {let sandbox_context = entry.environment.sandbox_context(/*additional_permissions*/ None);- let response = if let Some(context) = sandbox_context.policy_context() {- Self::normalize_request_permissions_response(- entry.requested_permissions,- response,- &context,- )- } else {- RequestPermissionsResponse {- permissions: RequestPermissionProfile::default(),- scope: PermissionGrantScope::Turn,- strict_auto_review: false,- }- };+ let response = Self::normalize_request_permissions_response(+ entry.requested_permissions,+ response,+ &sandbox_context.policy_context(),+ );self.record_granted_request_permissions_for_turn(&response,&entry.environment.selection.environment_id,diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 723f85a882..0bea18376c 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -9062,8 +9062,8 @@ async fn capability_discovery_uses_environment_permission_profile() {environment_config.windows_sandbox_private_desktop = false;environment_config.use_legacy_landlock = true;let expected_sandbox = FileSystemSandboxContext {- permissions: environment.permission_profile().clone().into(),- cwd: Some(environment.cwd().clone()),+ permissions: environment.permission_profile().clone(),+ cwd: environment.cwd().clone(),workspace_roots: environment.workspace_roots().to_vec(),user_home_dir: environment.user_home_dir.clone(),temporary_directories: environment.temporary_directories.clone(),diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex ae88a809ae..13a68466f3 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -222,8 +222,8 @@ impl TurnEnvironment {additional_permissions.as_ref(),);FileSystemSandboxContext {- permissions: permissions.into(),- cwd: Some(self.cwd().clone()),+ permissions,+ cwd: self.cwd().clone(),workspace_roots: self.workspace_roots().to_vec(),user_home_dir: self.user_home_dir.clone(),temporary_directories: self.temporary_directories.clone(),diff --git a/codex-rs/core/src/tools/handlers/apply_patch.rs b/codex-rs/core/src/tools/handlers/apply_patch.rsindex 5ab6666283..527c8770fc 100644--- a/codex-rs/core/src/tools/handlers/apply_patch.rs+++ b/codex-rs/core/src/tools/handlers/apply_patch.rs@@ -552,12 +552,7 @@ async fn execute_verified_patch() -> Result<String, FunctionCallError> {let cwd = action.cwd.clone();let sandbox_context = turn_environment.sandbox_context(/*additional_permissions*/ None);- let Some(policy_context) = file_system_sandbox_policy_context_for_cwd(&sandbox_context, &cwd)- else {- return Err(FunctionCallError::RespondToModel(- "apply_patch requires an executor cwd".to_string(),- ));- };+ let policy_context = file_system_sandbox_policy_context_for_cwd(&sandbox_context, &cwd);let sandbox_route = if turn_environment.environment.is_remote() {PatchSandboxRoute::ExecutorManaged} else {diff --git a/codex-rs/core/src/tools/handlers/extension_tools.rs b/codex-rs/core/src/tools/handlers/extension_tools.rsindex 92ac4bdb81..0fcb6165c2 100644--- a/codex-rs/core/src/tools/handlers/extension_tools.rs+++ b/codex-rs/core/src/tools/handlers/extension_tools.rs@@ -299,7 +299,7 @@ mod tests {struct CapturingExtensionExecutor {captured_call: Arc<Mutex<Option<codex_tools::ToolCall<'static>>>>,- captured_sandbox_cwds: Arc<Mutex<Vec<Option<PathUri>>>>,+ captured_sandbox_cwds: Arc<Mutex<Vec<PathUri>>>,}impl<'call> codex_extension_api::ToolExecutor<codex_tools::ToolCall<'call>>@@ -432,7 +432,7 @@ mod tests {let expected_sandbox_cwds = turn.environments.turn_environments()- .map(|environment| Some(environment.cwd().clone()))+ .map(|environment| environment.cwd().clone()).collect::<Vec<_>>();let history_item = ResponseItem::Message {id: None,diff --git a/codex-rs/core/src/tools/handlers/mod.rs b/codex-rs/core/src/tools/handlers/mod.rsindex ce09df5b33..38cc41c748 100644--- a/codex-rs/core/src/tools/handlers/mod.rs+++ b/codex-rs/core/src/tools/handlers/mod.rs@@ -243,10 +243,10 @@ pub(super) struct EffectiveAdditionalPermissions {pub(super) fn file_system_sandbox_policy_context_for_cwd<'a>(sandbox_context: &'a FileSystemSandboxContext,cwd: &'a PathUri,-) -> Option<codex_protocol::permissions::FileSystemSandboxPolicyContext<'a>> {- let mut context = sandbox_context.policy_context()?;+) -> codex_protocol::permissions::FileSystemSandboxPolicyContext<'a> {+ let mut context = sandbox_context.policy_context();context.cwd = cwd;- Some(context)+ context}pub(super) fn implicit_granted_permissions(@@ -298,9 +298,9 @@ pub(super) async fn apply_granted_turn_permissions(if additional_permissions.is_none() {Some(granted.clone())} else {- effective_permissions.as_ref().and_then(|effective| {- preapproved_permission_profile(effective, granted, context.as_ref()?)- })+ effective_permissions+ .as_ref()+ .and_then(|effective| preapproved_permission_profile(effective, granted, &context))}});let permissions_preapproved = preapproved_permissions.is_some();diff --git a/codex-rs/core/src/tools/handlers/request_permissions.rs b/codex-rs/core/src/tools/handlers/request_permissions.rsindex bb3a7de75d..ececd52c6d 100644--- a/codex-rs/core/src/tools/handlers/request_permissions.rs+++ b/codex-rs/core/src/tools/handlers/request_permissions.rs@@ -79,11 +79,7 @@ impl RequestPermissionsHandler {};let sandbox_context =turn_environment.sandbox_context(/*additional_permissions*/ None);- let context = sandbox_context.policy_context().ok_or_else(|| {- FunctionCallError::RespondToModel(- "request_permissions requires an executor cwd".to_string(),- )- })?;+ let context = sandbox_context.policy_context();let mut arguments: Value = parse_arguments(&arguments)?;resolve_permission_path_strings(&mut arguments, &context)?;let mut args: RequestPermissionsArgs =diff --git a/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs b/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rsindex 0a026fbb6d..0e43be8318 100644--- a/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs+++ b/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs@@ -322,14 +322,7 @@ impl ExecCommandHandler {let requested_additional_permissions = additional_permissions.clone();let sandbox_context =turn_environment.sandbox_context(/*additional_permissions*/ None);- let Some(permission_context) =- file_system_sandbox_policy_context_for_cwd(&sandbox_context, &cwd)- else {- manager.release_process_id(process_id).await;- return Err(FunctionCallError::RespondToModel(- "selected environment sandbox context is missing cwd".to_string(),- ));- };+ let permission_context = file_system_sandbox_policy_context_for_cwd(&sandbox_context, &cwd);let effective_additional_permissions = apply_granted_turn_permissions(context.session.as_ref(),turn_environment,diff --git a/codex-rs/core/src/tools/runtimes/apply_patch.rs b/codex-rs/core/src/tools/runtimes/apply_patch.rsindex 435883b4b1..776c0fffe8 100644--- a/codex-rs/core/src/tools/runtimes/apply_patch.rs+++ b/codex-rs/core/src/tools/runtimes/apply_patch.rs@@ -97,8 +97,8 @@ impl ApplyPatchRuntime {req.additional_permissions.as_ref(),);Some(FileSystemSandboxContext {- permissions: permissions.into(),- cwd: Some(attempt.sandbox_cwd.clone()),+ permissions,+ cwd: attempt.sandbox_cwd.clone(),workspace_roots: attempt.workspace_roots.to_vec(),user_home_dir: req.turn_environment.user_home_dir.clone(),temporary_directories: None,diff --git a/codex-rs/core/src/tools/runtimes/apply_patch_tests.rs b/codex-rs/core/src/tools/runtimes/apply_patch_tests.rsindex 85a76226d5..be3080d105 100644--- a/codex-rs/core/src/tools/runtimes/apply_patch_tests.rs+++ b/codex-rs/core/src/tools/runtimes/apply_patch_tests.rs@@ -265,15 +265,10 @@ async fn file_system_sandbox_context_preserves_executor_workspace_permissions());let expected_permissions =PermissionProfile::from_runtime_permissions(&file_system_policy, network_policy);- let native_permissions: PermissionProfile = sandbox- .permissions- .clone()- .try_into()- .expect("native sandbox permissions");- assert_eq!(native_permissions, expected_permissions);+ assert_eq!(sandbox.permissions, expected_permissions);assert_eq!(sandbox.cwd,- Some(codex_utils_path_uri::PathUri::from_abs_path(&path))+ codex_utils_path_uri::PathUri::from_abs_path(&path));assert_eq!(sandbox.windows_sandbox_selection,@@ -348,8 +343,8 @@ async fn file_system_sandbox_context_respects_sandbox_request() {assert_eq!(ApplyPatchRuntime::file_system_sandbox_context_for_attempt(&req, &attempt),Some(FileSystemSandboxContext {- permissions: permissions.into(),- cwd: Some(cwd.clone()),+ permissions,+ cwd: cwd.clone(),workspace_roots: vec![cwd],user_home_dir: Some(user_home_dir),temporary_directories: None,diff --git a/codex-rs/core/src/tools/sandboxing.rs b/codex-rs/core/src/tools/sandboxing.rsindex 1bcce42afd..1c8201dde2 100644--- a/codex-rs/core/src/tools/sandboxing.rs+++ b/codex-rs/core/src/tools/sandboxing.rs@@ -520,8 +520,8 @@ impl<'a> SandboxAttempt<'a> {exec_request.exec_server_managed_network = managed_network;if self.sandbox_requested {exec_request.exec_server_sandbox = Some(FileSystemSandboxContext {- permissions: exec_server_permissions.into(),- cwd: Some(exec_request.windows_sandbox_policy_cwd.clone()),+ permissions: exec_server_permissions,+ cwd: exec_request.windows_sandbox_policy_cwd.clone(),workspace_roots: self.workspace_roots.to_vec(),user_home_dir: None,temporary_directories: None,diff --git a/codex-rs/core/src/tools/sandboxing_tests.rs b/codex-rs/core/src/tools/sandboxing_tests.rsindex ee146a1ebb..392d62e7e7 100644--- a/codex-rs/core/src/tools/sandboxing_tests.rs+++ b/codex-rs/core/src/tools/sandboxing_tests.rs@@ -368,8 +368,8 @@ fn exec_server_env_keeps_command_native_and_carries_sandbox_context() {assert_eq!(request.exec_server_sandbox,Some(codex_exec_server::FileSystemSandboxContext {- permissions: exec_server_permissions.clone().into(),- cwd: Some(cwd_uri.clone()),+ permissions: exec_server_permissions.clone(),+ cwd: cwd_uri.clone(),workspace_roots: vec![cwd_uri.clone()],user_home_dir: None,temporary_directories: None,diff --git a/codex-rs/core/src/unified_exec/process_manager_tests.rs b/codex-rs/core/src/unified_exec/process_manager_tests.rsindex 8be6eda337..bb928ad8f9 100644--- a/codex-rs/core/src/unified_exec/process_manager_tests.rs+++ b/codex-rs/core/src/unified_exec/process_manager_tests.rs@@ -271,7 +271,10 @@ fn exec_server_params_use_path_uri_and_env_policy_overlay_contract() {request.exec_server_shell_snapshot = None;request.exec_server_sandbox = Some(- codex_exec_server::FileSystemSandboxContext::from_permission_profile(permission_profile),+ codex_exec_server::FileSystemSandboxContext::from_permission_profile(+ permission_profile,+ request.cwd.clone(),+ ),);let first = params_for_request(&request);let second = params_for_request(&request);diff --git a/codex-rs/core/src/unified_exec/shell_snapshot.rs b/codex-rs/core/src/unified_exec/shell_snapshot.rsindex 941266f5d2..343c89df03 100644--- a/codex-rs/core/src/unified_exec/shell_snapshot.rs+++ b/codex-rs/core/src/unified_exec/shell_snapshot.rs@@ -92,8 +92,8 @@ impl Session {/*has_managed_network_requirements*/ false,).then(|| FileSystemSandboxContext {- permissions: environment.permission_profile().clone().into(),- cwd: Some(environment.cwd().clone()),+ permissions: environment.permission_profile().clone(),+ cwd: environment.cwd().clone(),workspace_roots: environment.workspace_roots().to_vec(),user_home_dir: None,temporary_directories: None,diff --git a/codex-rs/core/src/unified_exec/stdin_approval.rs b/codex-rs/core/src/unified_exec/stdin_approval.rsindex 750fd3f954..75172d173e 100644--- a/codex-rs/core/src/unified_exec/stdin_approval.rs+++ b/codex-rs/core/src/unified_exec/stdin_approval.rs@@ -12,7 +12,6 @@ use crate::session::turn_context::TurnEnvironment;use crate::tools::sandboxing::ApprovalAction;use crate::tools::sandboxing::ToolError;use codex_features::Feature;-use codex_file_system::ExecPermissionProfile;use codex_file_system::FileSystemSandboxContext;use codex_network_proxy::EnvironmentNetworkPolicy;use codex_protocol::models::AdditionalPermissionProfile;@@ -69,7 +68,7 @@ impl TerminalPolicy {fn file_system_context(&self) -> FileSystemSandboxContext {let mut context = self.sandbox.clone();// Network changes require review, not rejection for denied-read drift.- if let ExecPermissionProfile::Managed { network, .. } = &mut context.permissions {+ if let PermissionProfile::Managed { network, .. } = &mut context.permissions {*network = NetworkSandboxPolicy::Restricted;}context@@ -131,7 +130,7 @@ impl TerminalPermissions {Ok(if bypassed || &self.policy != current {SandboxPermissions::RequireEscalated} else if self.policy.sandbox.permissions- == effective_permission_profile(baseline, /*additional_permissions*/ None).into()+ == effective_permission_profile(baseline, /*additional_permissions*/ None){SandboxPermissions::UseDefault} else {@@ -145,7 +144,7 @@ impl TerminalPermissions {) -> Result<String, serde_json::Error> {let authority = if self.launch_permissions.requires_escalated_permissions() {"This terminal was launched outside the sandbox, bypassing any managed network proxy."- } else if self.policy.sandbox.permissions == ExecPermissionProfile::Disabled {+ } else if self.policy.sandbox.permissions == PermissionProfile::Disabled {"This terminal runs without a filesystem sandbox."} else {match sandbox_permissions {diff --git a/codex-rs/core/src/unified_exec/stdin_approval_tests.rs b/codex-rs/core/src/unified_exec/stdin_approval_tests.rsindex 8f0a2b38c2..5d06ebcf99 100644--- a/codex-rs/core/src/unified_exec/stdin_approval_tests.rs+++ b/codex-rs/core/src/unified_exec/stdin_approval_tests.rs@@ -20,6 +20,7 @@ fn terminal_permissions(profile: &PermissionProfile) -> TerminalPermissions {policy: TerminalPolicy {sandbox: FileSystemSandboxContext::from_permission_profile(effective_permission_profile(profile, /*additional_permissions*/ None),+ PathUri::from_host_native_path(std::env::temp_dir()).expect("local temporary cwd"),),environment_network: None,controller_network: None,diff --git a/codex-rs/core/tests/suite/apply_patch_cli.rs b/codex-rs/core/tests/suite/apply_patch_cli.rsindex b5dda68de7..75de4ed1da 100644--- a/codex-rs/core/tests/suite/apply_patch_cli.rs+++ b/codex-rs/core/tests/suite/apply_patch_cli.rs@@ -43,6 +43,7 @@ use codex_protocol::protocol::ReviewDecision;use codex_protocol::protocol::SandboxPolicy;use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::protocol::TurnEnvironmentSelection;+use codex_protocol::protocol::TurnEnvironmentSelections;use codex_protocol::user_input::UserInput;#[cfg(target_os = "linux")]use codex_sandboxing::landlock::CODEX_LINUX_SANDBOX_ARG0;@@ -939,6 +940,151 @@ async fn intercepted_apply_patch_verification_uses_local_sandbox() -> Result<()>Ok(())}+/// An intercepted update can verify allowed absolute paths after the turn cwd disappears,+/// while the same turn still cannot read or update an explicitly denied target.+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn intercepted_apply_patch_updates_absolute_target_after_turn_cwd_is_removed() -> Result<()> {+ skip_if_no_network!(Ok(()));+ skip_if_target_windows!(+ Ok(()),+ "the default Windows restricted-token test backend cannot enforce denied reads"+ );++ let harness = apply_patch_harness_with(|builder| builder.with_model("gpt-5.4")).await?;+ let test = harness.test();+ let workspace = test.workspace_path_uri("")?;+ let original_cwd = test.workspace_path_uri("policy-cwd")?;+ let allowed_target = test.workspace_path_uri("allowed.txt")?;+ let denied_target = test.workspace_path_uri("denied.txt")?;+ harness.create_dir_all("policy-cwd").await?;+ harness.write_file("allowed.txt", "original\n").await?;+ harness.write_file("denied.txt", "private\n").await?;++ let file_system_policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry {+ path: FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ access: FileSystemAccessMode::Read,+ missing_path_behavior: None,+ },+ FileSystemSandboxEntry {+ path: FileSystemPath::Path {+ path: workspace.clone(),+ },+ access: FileSystemAccessMode::Write,+ missing_path_behavior: None,+ },+ FileSystemSandboxEntry {+ path: FileSystemPath::Path {+ path: denied_target.clone(),+ },+ access: FileSystemAccessMode::Deny,+ missing_path_behavior: None,+ },+ ]);+ let permissions = PermissionProfile::from_runtime_permissions(+ &file_system_policy,+ NetworkSandboxPolicy::Restricted,+ );+ let (sandbox_policy, permission_profile) =+ turn_permission_fields(permissions, test.config.cwd.as_path());+ let selection = TurnEnvironmentSelection {+ cwd: original_cwd,+ workspace_roots: vec![workspace.clone()],+ ..test.executor_environment().selection().clone()+ };++ let workdir = workspace.inferred_native_path_string();+ let allowed_patch = format!(+ "apply_patch <<'EOF'\n*** Begin Patch\n*** Update File: {}\n@@\n-original\n+changed\n*** End Patch\nEOF\n",+ allowed_target.inferred_native_path_string(),+ );+ let denied_patch = format!(+ "apply_patch <<'EOF'\n*** Begin Patch\n*** Update File: {}\n@@\n-private\n+changed\n*** End Patch\nEOF\n",+ denied_target.inferred_native_path_string(),+ );+ let responses = mount_sse_sequence(+ harness.server(),+ vec![+ sse(vec![+ ev_response_created("resp-remove"),+ ev_exec_command_call_with_args(+ "remove-cwd",+ &json!({"cmd": "rmdir policy-cwd", "workdir": workdir, "login": false}),+ ),+ ev_completed("resp-remove"),+ ]),+ sse(vec![+ ev_response_created("resp-allowed"),+ ev_exec_command_call_with_args(+ "patch-allowed",+ &json!({"cmd": allowed_patch, "workdir": workdir, "login": false}),+ ),+ ev_completed("resp-allowed"),+ ]),+ sse(vec![+ ev_response_created("resp-denied"),+ ev_exec_command_call_with_args(+ "patch-denied",+ &json!({"cmd": denied_patch, "workdir": workdir, "login": false}),+ ),+ ev_completed("resp-denied"),+ ]),+ sse(vec![+ ev_assistant_message("msg-done", "done"),+ ev_completed("resp-done"),+ ]),+ ],+ )+ .await;++ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "remove the turn cwd, then update the allowed and denied files".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ environments: Some(TurnEnvironmentSelections::new(+ test.config.cwd.clone(),+ vec![selection],+ )),+ approval_policy: Some(AskForApproval::Never),+ sandbox_policy: Some(sandbox_policy),+ permission_profile,+ ..Default::default()+ }),+ )+ .await?;+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;++ assert!(!harness.path_exists("policy-cwd").await?);+ let allowed_output = responses+ .function_call_output_text("patch-allowed")+ .expect("the model should receive the allowed patch output");+ assert!(allowed_output.contains("Success."), "{allowed_output}");+ let denied_output = responses+ .function_call_output_text("patch-denied")+ .expect("the model should receive the denied patch output");+ assert!(+ denied_output.contains("apply_patch verification failed")+ && denied_output.contains("Failed to read"),+ "{denied_output}",+ );+ assert_eq!(+ (+ harness.read_file_text("allowed.txt").await?,+ harness.read_file_text("denied.txt").await?,+ ),+ ("changed\n".to_string(), "private\n".to_string()),+ );+ Ok(())+}+#[cfg(unix)]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn escalated_patch_rejects_symlink_swapped_after_approval_request() -> Result<()> {diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex f305233450..e5295233de 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -2940,7 +2940,8 @@ fn absolute_path(path: PathBuf) -> AbsolutePathBuf {fn read_only_sandbox(readable_root: PathBuf) -> FileSystemSandboxContext {let readable_root = absolute_path(readable_root);- FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(+ let cwd = PathUri::from_abs_path(&readable_root);+ let permissions = PermissionProfile::from_runtime_permissions(&FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {path: FileSystemPath::Path {path: readable_root.into(),@@ -2949,12 +2950,14 @@ fn read_only_sandbox(readable_root: PathBuf) -> FileSystemSandboxContext {missing_path_behavior: None,}]),NetworkSandboxPolicy::Restricted,- ))+ );+ FileSystemSandboxContext::from_permission_profile(permissions, cwd)}fn workspace_write_sandbox(writable_root: PathBuf) -> FileSystemSandboxContext {let writable_root = absolute_path(writable_root);- FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(+ let cwd = PathUri::from_abs_path(&writable_root);+ let permissions = PermissionProfile::from_runtime_permissions(&FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {path: FileSystemPath::Path {path: writable_root.into(),@@ -2963,7 +2966,8 @@ fn workspace_write_sandbox(writable_root: PathBuf) -> FileSystemSandboxContext {missing_path_behavior: None,}]),NetworkSandboxPolicy::Restricted,- ))+ );+ FileSystemSandboxContext::from_permission_profile(permissions, cwd)}fn assert_normalized_path_rejected(error: &std::io::Error) {diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rsindex 67125ab0c2..fc9060f564 100644--- a/codex-rs/exec-server-protocol/src/protocol.rs+++ b/codex-rs/exec-server-protocol/src/protocol.rs@@ -5,6 +5,7 @@ use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;use codex_file_system::FileSystemSandboxContext;pub use codex_file_system::WalkOptions;pub use codex_file_system::WalkOutcome;+use codex_file_system::WireFileSystemSandboxContext;use codex_network_proxy::ManagedNetworkSandboxContext;use codex_network_proxy::RemoteNetworkProxyLaunchConfig;use codex_protocol::ThreadId;@@ -15,6 +16,7 @@ use codex_utils_path_uri::PathUri;use serde::Deserialize;use serde::Serialize;+use crate::JSONRPCErrorError;use crate::ProcessId;pub const INITIALIZE_METHOD: &str = "initialize";@@ -328,6 +330,70 @@ pub struct ExecParams {pub network_proxy: Option<RemoteNetworkProxyLaunchConfig>,}+/// Executor ingress for process requests from clients that may omit the sandbox policy cwd.+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireExecParams {+ process_id: ProcessId,+ metadata: Option<ExecMetadata>,+ argv: Vec<String>,+ cwd: PathUri,+ env_policy: Option<ExecEnvPolicy>,+ shell_snapshot: Option<ShellSnapshotRequest>,+ env: HashMap<String, String>,+ tty: bool,+ #[serde(default)]+ pipe_stdin: bool,+ arg0: Option<String>,+ sandbox: Option<WireFileSystemSandboxContext>,+ #[serde(default)]+ enforce_managed_network: bool,+ managed_network: Option<ManagedNetworkSandboxContext>,+ network_proxy: Option<RemoteNetworkProxyLaunchConfig>,+}++impl From<WireExecParams> for ExecParams {+ fn from(wire: WireExecParams) -> Self {+ let WireExecParams {+ process_id,+ metadata,+ argv,+ cwd,+ env_policy,+ shell_snapshot,+ env,+ tty,+ pipe_stdin,+ arg0,+ sandbox,+ enforce_managed_network,+ managed_network,+ network_proxy,+ } = wire;+ let sandbox = sandbox.map(|sandbox| {+ // Legacy processes used the required process cwd as their sandbox policy cwd.+ let policy_cwd = sandbox.cwd().unwrap_or(&cwd).clone();+ sandbox.into_context(policy_cwd)+ });+ Self {+ process_id,+ metadata,+ argv,+ cwd,+ env_policy,+ shell_snapshot,+ env,+ tty,+ pipe_stdin,+ arg0,+ sandbox,+ enforce_managed_network,+ managed_network,+ network_proxy,+ }+ }+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct ExecEnvPolicy {@@ -461,6 +527,16 @@ pub struct FsReadFileParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsReadFileParams {+ path: PathUri,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ follow_symlinks: Option<bool>,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsReadFileResponse {@@ -475,6 +551,15 @@ pub struct FsOpenParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsOpenParams {+ handle_id: String,+ path: PathUri,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsOpenResponse {@@ -516,6 +601,17 @@ pub struct FsWriteFileParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsWriteFileParams {+ path: PathUri,+ data_base64: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ follow_symlinks: Option<bool>,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsWriteFileResponse {}@@ -530,6 +626,17 @@ pub struct FsCreateDirectoryParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsCreateDirectoryParams {+ path: PathUri,+ recursive: Option<bool>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ follow_symlinks: Option<bool>,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsCreateDirectoryResponse {}@@ -543,6 +650,16 @@ pub struct FsGetMetadataParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsGetMetadataParams {+ path: PathUri,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ follow_symlinks: Option<bool>,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsGetMetadataResponse {@@ -561,6 +678,14 @@ pub struct FsCanonicalizeParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsCanonicalizeParams {+ path: PathUri,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsCanonicalizeResponse {@@ -574,6 +699,14 @@ pub struct FsReadDirectoryParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsReadDirectoryParams {+ path: PathUri,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsReadDirectoryEntry {@@ -596,6 +729,15 @@ pub struct FsWalkParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsWalkParams {+ path: PathUri,+ options: WalkOptions,+ sandbox: Option<WireFileSystemSandboxContext>,+}+pub type FsWalkResponse = WalkOutcome;#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]@@ -609,6 +751,18 @@ pub struct FsRemoveParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsRemoveParams {+ path: PathUri,+ recursive: Option<bool>,+ force: Option<bool>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ follow_symlinks: Option<bool>,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsRemoveResponse {}@@ -622,6 +776,16 @@ pub struct FsCopyParams {pub sandbox: Option<FileSystemSandboxContext>,}+/// Filesystem RPC wire request with legacy optional sandbox policy cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFsCopyParams {+ source_path: PathUri,+ destination_path: PathUri,+ recursive: bool,+ sandbox: Option<WireFileSystemSandboxContext>,+}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FsCopyResponse {}@@ -633,6 +797,13 @@ pub struct CapabilityRootsDiscoverParams {pub roots: Vec<CapabilityRootDiscoverRequest>,}+/// Executor ingress for capability roots whose sandbox policy cwd may be absent.+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireCapabilityRootsDiscoverParams {+ roots: Vec<WireCapabilityRootDiscoverRequest>,+}+/// One caller-selected capability root.#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]@@ -646,6 +817,84 @@ pub struct CapabilityRootDiscoverRequest {pub sandbox: Option<FileSystemSandboxContext>,}+/// One executor-ingress capability root with legacy optional sandbox policy cwd.+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireCapabilityRootDiscoverRequest {+ id: String,+ path: PathUri,+ sandbox: Option<WireFileSystemSandboxContext>,+}++// Destructuring both types makes adding a request field require updating the wire conversion.+macro_rules! impl_wire_filesystem_request {+ ($($wire:ident => $request:ident { $($field:ident),+ $(,)? }),+ $(,)?) => {$(+ impl From<$request> for $wire {+ fn from(request: $request) -> Self {+ let $request { $($field,)+ sandbox } = request;+ Self { $($field,)+ sandbox: sandbox.map(Into::into) }+ }+ }++ impl $wire {+ /// Resolves optional wire sandbox intent before it reaches an executor handler.+ pub fn try_into_request(+ self,+ resolve: fn(WireFileSystemSandboxContext) -> Result<FileSystemSandboxContext, JSONRPCErrorError>,+ ) -> Result<$request, JSONRPCErrorError> {+ let Self { $($field,)+ sandbox } = self;+ Ok($request { $($field,)+ sandbox: sandbox.map(resolve).transpose()? })+ }+ }+ )+};+}++impl_wire_filesystem_request! {+ WireFsReadFileParams => FsReadFileParams { path, follow_symlinks },+ WireFsOpenParams => FsOpenParams { handle_id, path },+ WireFsWriteFileParams => FsWriteFileParams { path, data_base64, follow_symlinks },+ WireFsCreateDirectoryParams => FsCreateDirectoryParams { path, recursive, follow_symlinks },+ WireFsGetMetadataParams => FsGetMetadataParams { path, follow_symlinks },+ WireFsCanonicalizeParams => FsCanonicalizeParams { path },+ WireFsReadDirectoryParams => FsReadDirectoryParams { path },+ WireFsWalkParams => FsWalkParams { path, options },+ WireFsRemoveParams => FsRemoveParams { path, recursive, force, follow_symlinks },+ WireFsCopyParams => FsCopyParams { source_path, destination_path, recursive },+}++impl WireCapabilityRootDiscoverRequest {+ /// Resolves optional wire sandbox intent before it reaches an executor handler.+ pub fn try_into_request(+ self,+ resolve: fn(+ WireFileSystemSandboxContext,+ ) -> Result<FileSystemSandboxContext, JSONRPCErrorError>,+ ) -> Result<CapabilityRootDiscoverRequest, JSONRPCErrorError> {+ let Self { id, path, sandbox } = self;+ Ok(CapabilityRootDiscoverRequest {+ id,+ path,+ sandbox: sandbox.map(resolve).transpose()?,+ })+ }+}++impl WireCapabilityRootsDiscoverParams {+ /// Resolves each root's optional wire sandbox before it reaches an executor handler.+ pub fn try_into_request(+ self,+ resolve: fn(+ WireFileSystemSandboxContext,+ ) -> Result<FileSystemSandboxContext, JSONRPCErrorError>,+ ) -> Result<CapabilityRootsDiscoverParams, JSONRPCErrorError> {+ let mut roots = Vec::with_capacity(self.roots.len());+ for root in self.roots {+ roots.push(root.try_into_request(resolve)?);+ }+ Ok(CapabilityRootsDiscoverParams { roots })+ }+}+/// Executor-local discovery results in request order.#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]@@ -908,17 +1157,21 @@ mod base64_bytes {#[cfg(test)]mod tests {+ use super::CapabilityRootDiscoverRequest;use super::EnvironmentCapabilities;use super::EnvironmentInfo;use super::ExecExitedNotification;use super::ExecMetadata;use super::ExecParams;use super::ExecResponse;+ use super::FsOpenParams;use super::FsReadFileParams;use super::HttpRequestParams;use super::ProcessId;use super::ProcessSandboxType;use super::ShellInfo;+ use super::WireFsOpenParams;+ use super::WireFsReadFileParams;use codex_file_system::FileSystemSandboxContext;use codex_file_system::WindowsSandboxSelection;use codex_network_proxy::ManagedNetworkSandboxContext;@@ -1222,7 +1475,7 @@ mod tests {})).expect_err("native absolute path should not deserialize as a URI");- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::default(),PathUri::from_host_native_path(&native_cwd).expect("cwd URI"),);@@ -1273,13 +1526,14 @@ mod tests {network: NetworkSandboxPolicy::Restricted,};let mut sandbox =- FileSystemSandboxContext::from_permission_profile_with_cwd(permissions, cwd.clone());+ FileSystemSandboxContext::from_permission_profile(permissions, cwd.clone());sandbox.user_home_dir = Some(cwd.clone());sandbox.windows_sandbox_selection = WindowsSandboxSelection::Mxc;let serialized = serde_json::to_value(&sandbox).expect("serialize sandbox");assert_eq!(serialized["windowsSandboxLevel"], "mxc");+ assert_eq!(serialized["cwd"], serde_json::json!(cwd.to_string()));assert_eq!(serialized["userHomeDir"],serde_json::json!(cwd.to_string())@@ -1324,6 +1578,150 @@ mod tests {);}+ /// The filesystem RPC preserves Windows drive and UNC permission URIs on any host.+ #[test]+ fn filesystem_protocol_preserves_foreign_permission_path_json() {+ let cwd = PathUri::parse("file:///C:/a%20b").expect("drive cwd URI");+ let unc = PathUri::parse("file://host/s/a%20b").expect("UNC path URI");+ let permissions = PermissionProfile::Managed {+ file_system: ManagedFileSystemPermissions::Restricted {+ entries: [cwd.clone(), unc.clone()]+ .into_iter()+ .map(|path| {+ FileSystemSandboxEntry::new(path.into(), FileSystemAccessMode::Read)+ })+ .collect(),+ glob_scan_max_depth: None,+ },+ network: NetworkSandboxPolicy::Restricted,+ };+ let params = FsReadFileParams {+ path: unc,+ follow_symlinks: None,+ sandbox: Some(FileSystemSandboxContext::from_permission_profile(+ permissions,+ cwd,+ )),+ };+ let serialized = serde_json::to_value(WireFsReadFileParams::from(params.clone()))+ .expect("serialize filesystem wire request");+ assert_eq!(+ serialized["sandbox"]["permissions"],+ serde_json::json!({+ "type": "managed",+ "file_system": {+ "type": "restricted",+ "entries": [+ {"path": {"type": "path", "path": "file:///C:/a%20b"}, "access": "read"},+ {"path": {"type": "path", "path": "file://host/s/a%20b"}, "access": "read"}+ ]+ },+ "network": "restricted"+ }),+ );+ assert_eq!(+ serde_json::from_value::<WireFsReadFileParams>(serialized)+ .expect("deserialize filesystem wire request")+ .try_into_request(|wire| {+ let cwd = wire.cwd().expect("explicit client policy cwd").clone();+ Ok(wire.into_context(cwd))+ })+ .expect("resolve filesystem request"),+ params,+ );+ }++ /// Executor ingress must use the full policy context instead of interpreting legacy helper fields.+ #[test]+ fn filesystem_protocol_prefers_explicit_policy_paths_over_legacy_fields() {+ let cwd = PathUri::parse("file:///workspace/selected").expect("selected policy cwd");+ let workspace = PathUri::parse("file:///workspace/other").expect("selected workspace");+ let path = cwd.join("note.txt").expect("read path");+ let sandbox = FileSystemSandboxContext {+ workspace_roots: vec![workspace],+ ..FileSystemSandboxContext::from_permission_profile(PermissionProfile::Disabled, cwd)+ };+ let params = FsReadFileParams {+ path,+ follow_symlinks: None,+ sandbox: Some(sandbox),+ };+ let mut json = serde_json::to_value(WireFsReadFileParams::from(params.clone()))+ .expect("serialize wire read");+ json["sandbox"]["cwd"] = serde_json::json!("file:///legacy");+ json["sandbox"]["workspaceRoots"] = serde_json::json!(["file:///legacy"]);+ let wire: WireFsReadFileParams = serde_json::from_value(json).expect("wire read");+ let request = wire+ .try_into_request(|wire| {+ let cwd = wire.cwd().expect("explicit policy cwd").clone();+ Ok(wire.into_context(cwd))+ })+ .expect("strict executor read");+ assert_eq!(request, params);+ }++ /// Only filesystem RPCs need the additive policy field; capability discovery keeps its original wire cwd.+ #[test]+ fn filesystem_open_and_capability_discovery_keep_their_existing_cwd_contracts() {+ let cwd = PathUri::parse("file:///D:/selected").expect("Windows policy cwd");+ let path = cwd.join("note.txt").expect("read path");+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::Disabled,+ cwd.clone(),+ );+ sandbox.windows_sandbox_selection = WindowsSandboxSelection::Mxc;+ let open = FsOpenParams {+ handle_id: "handle".to_owned(),+ path: path.clone(),+ sandbox: Some(sandbox.clone()),+ };+ let capability = CapabilityRootDiscoverRequest {+ id: "root".to_owned(),+ path,+ sandbox: Some(sandbox),+ };+ let open_wire =+ serde_json::to_value(WireFsOpenParams::from(open.clone())).expect("serialize open");+ let capability_wire = serde_json::to_value(&capability).expect("serialize capability");+ assert_eq!(+ (+ open_wire["sandbox"].get("cwd"),+ open_wire["sandbox"].get("workspaceRoots"),+ open_wire["sandbox"].get("policyContext"),+ open_wire["sandbox"].get("windowsSandboxLevel"),+ capability_wire["sandbox"].get("cwd"),+ capability_wire["sandbox"].get("workspaceRoots"),+ capability_wire["sandbox"].get("policyContext"),+ capability_wire["sandbox"].get("windowsSandboxLevel"),+ ),+ (+ None,+ None,+ Some(&serde_json::json!({"cwd": cwd, "workspaceRoots": [cwd]})),+ Some(&serde_json::json!("mxc")),+ Some(&serde_json::json!(cwd)),+ Some(&serde_json::json!([cwd])),+ None,+ Some(&serde_json::json!("mxc")),+ )+ );+ assert_eq!(+ serde_json::from_value::<WireFsOpenParams>(open_wire)+ .expect("deserialize wire open")+ .try_into_request(|wire| {+ let cwd = wire.cwd().expect("explicit client policy cwd").clone();+ Ok(wire.into_context(cwd))+ })+ .expect("resolve open"),+ open+ );+ assert_eq!(+ serde_json::from_value::<CapabilityRootDiscoverRequest>(capability_wire)+ .expect("deserialize capability"),+ capability+ );+ }+#[test]fn filesystem_protocol_round_trips_legacy_policy_paths_as_uris() {let native_cwd = std::env::current_dir().expect("current directory");@@ -1339,8 +1737,7 @@ mod tests {&file_system_policy,NetworkSandboxPolicy::Restricted,);- let sandbox =- FileSystemSandboxContext::from_permission_profile_with_cwd(permissions, cwd.clone());+ let sandbox = FileSystemSandboxContext::from_permission_profile(permissions, cwd.clone());let serialized = serde_json::to_value(&sandbox).expect("serialize sandbox");diff --git a/codex-rs/exec-server/BUILD.bazel b/codex-rs/exec-server/BUILD.bazelindex 4fba596f48..cf8c72ae79 100644--- a/codex-rs/exec-server/BUILD.bazel+++ b/codex-rs/exec-server/BUILD.bazel@@ -20,6 +20,8 @@ codex_rust_crate(],extra_binaries = ["//codex-rs/bwrap:bwrap",+ "//codex-rs/windows-sandbox-rs:codex-command-runner",+ "//codex-rs/windows-sandbox-rs:codex-windows-sandbox-setup",],integration_compile_data_extra = ["src/proto/codex.exec_server.relay.v1.rs",diff --git a/codex-rs/exec-server/Cargo.toml b/codex-rs/exec-server/Cargo.tomlindex bc441d9fe4..50c728b04a 100644--- a/codex-rs/exec-server/Cargo.toml+++ b/codex-rs/exec-server/Cargo.toml@@ -83,6 +83,7 @@ windows-sys = { version = "0.52", features = [anyhow = { workspace = true }codex-exec-server-test-support = { workspace = true }codex-test-binary-support = { workspace = true }+codex-utils-cargo-bin = { workspace = true }ctor = { workspace = true }http = { workspace = true }opentelemetry_sdk = { workspace = true }diff --git a/codex-rs/exec-server/src/capability_discovery.rs b/codex-rs/exec-server/src/capability_discovery.rsindex c1c5f44883..4799db98d2 100644--- a/codex-rs/exec-server/src/capability_discovery.rs+++ b/codex-rs/exec-server/src/capability_discovery.rs@@ -76,6 +76,13 @@ async fn discover_root(error: None,};+ if let Some(sandbox) = sandbox+ && let Err(error) = sandbox.validate_file_system_paths_for_current_host()+ {+ discovery.error = Some(format!("failed to inspect capability root {path}: {error}"));+ return discovery;+ }+#[cfg(target_os = "windows")]if sandbox.is_some_and(|context| {context.should_run_in_sandbox() && !context.windows_sandbox_is_requested()diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rsindex a8baa33fde..99d0255493 100644--- a/codex-rs/exec-server/src/client.rs+++ b/codex-rs/exec-server/src/client.rs@@ -120,6 +120,16 @@ use crate::protocol::SignalParams;use crate::protocol::SignalResponse;use crate::protocol::TerminateParams;use crate::protocol::TerminateResponse;+use crate::protocol::WireFsCanonicalizeParams;+use crate::protocol::WireFsCopyParams;+use crate::protocol::WireFsCreateDirectoryParams;+use crate::protocol::WireFsGetMetadataParams;+use crate::protocol::WireFsOpenParams;+use crate::protocol::WireFsReadDirectoryParams;+use crate::protocol::WireFsReadFileParams;+use crate::protocol::WireFsRemoveParams;+use crate::protocol::WireFsWalkParams;+use crate::protocol::WireFsWriteFileParams;use crate::protocol::WriteParams;use crate::protocol::WriteResponse;use crate::rpc::RpcCallError;@@ -900,11 +910,13 @@ impl ExecServerClient {&self,params: FsReadFileParams,) -> Result<FsReadFileResponse, ExecServerError> {- self.call(FS_READ_FILE_METHOD, ¶ms).await+ self.call(FS_READ_FILE_METHOD, &WireFsReadFileParams::from(params))+ .await}pub async fn fs_open(&self, params: FsOpenParams) -> Result<FsOpenResponse, ExecServerError> {- self.call(FS_OPEN_METHOD, ¶ms).await+ self.call(FS_OPEN_METHOD, &WireFsOpenParams::from(params))+ .await}pub async fn fs_read_block(@@ -925,50 +937,70 @@ impl ExecServerClient {&self,params: FsWriteFileParams,) -> Result<FsWriteFileResponse, ExecServerError> {- self.call(FS_WRITE_FILE_METHOD, ¶ms).await+ self.call(FS_WRITE_FILE_METHOD, &WireFsWriteFileParams::from(params))+ .await}pub async fn fs_create_directory(&self,params: FsCreateDirectoryParams,) -> Result<FsCreateDirectoryResponse, ExecServerError> {- self.call(FS_CREATE_DIRECTORY_METHOD, ¶ms).await+ self.call(+ FS_CREATE_DIRECTORY_METHOD,+ &WireFsCreateDirectoryParams::from(params),+ )+ .await}pub async fn fs_get_metadata(&self,params: FsGetMetadataParams,) -> Result<FsGetMetadataResponse, ExecServerError> {- self.call(FS_GET_METADATA_METHOD, ¶ms).await+ self.call(+ FS_GET_METADATA_METHOD,+ &WireFsGetMetadataParams::from(params),+ )+ .await}pub async fn fs_canonicalize(&self,params: FsCanonicalizeParams,) -> Result<FsCanonicalizeResponse, ExecServerError> {- self.call(FS_CANONICALIZE_METHOD, ¶ms).await+ self.call(+ FS_CANONICALIZE_METHOD,+ &WireFsCanonicalizeParams::from(params),+ )+ .await}pub async fn fs_read_directory(&self,params: FsReadDirectoryParams,) -> Result<FsReadDirectoryResponse, ExecServerError> {- self.call(FS_READ_DIRECTORY_METHOD, ¶ms).await+ self.call(+ FS_READ_DIRECTORY_METHOD,+ &WireFsReadDirectoryParams::from(params),+ )+ .await}pub async fn fs_walk(&self, params: FsWalkParams) -> Result<FsWalkResponse, ExecServerError> {- self.call(FS_WALK_METHOD, ¶ms).await+ self.call(FS_WALK_METHOD, &WireFsWalkParams::from(params))+ .await}pub async fn fs_remove(&self,params: FsRemoveParams,) -> Result<FsRemoveResponse, ExecServerError> {- self.call(FS_REMOVE_METHOD, ¶ms).await+ self.call(FS_REMOVE_METHOD, &WireFsRemoveParams::from(params))+ .await}pub async fn fs_copy(&self, params: FsCopyParams) -> Result<FsCopyResponse, ExecServerError> {- self.call(FS_COPY_METHOD, ¶ms).await+ self.call(FS_COPY_METHOD, &WireFsCopyParams::from(params))+ .await}pub(crate) async fn start_process(diff --git a/codex-rs/exec-server/src/environment.rs b/codex-rs/exec-server/src/environment.rsindex 26b8825d72..bc1e68491f 100644--- a/codex-rs/exec-server/src/environment.rs+++ b/codex-rs/exec-server/src/environment.rs@@ -1838,7 +1838,7 @@ mod tests {let source = sandbox_cwd.to_abs_path().expect_err("sandbox cwd should not be native to this host");- let sandbox = crate::FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = crate::FileSystemSandboxContext::from_permission_profile(codex_protocol::models::PermissionProfile::workspace_write(),sandbox_cwd.clone(),);@@ -1890,6 +1890,8 @@ mod tests {&codex_protocol::permissions::FileSystemSandboxPolicy::restricted(Vec::new()),codex_protocol::permissions::NetworkSandboxPolicy::Restricted,),+ PathUri::from_host_native_path(std::env::current_dir().expect("read current dir"))+ .expect("cwd URI"),);let err = environmentdiff --git a/codex-rs/exec-server/src/fs_sandbox.rs b/codex-rs/exec-server/src/fs_sandbox.rsindex 74a20d1a5c..945b43901b 100644--- a/codex-rs/exec-server/src/fs_sandbox.rs+++ b/codex-rs/exec-server/src/fs_sandbox.rs@@ -20,6 +20,10 @@ use codex_sandboxing::SandboxType;use codex_utils_absolute_path::AbsolutePathBuf;#[cfg(not(target_os = "linux"))]use codex_utils_absolute_path::canonicalize_preserving_symlinks;+#[cfg(any(windows, test))]+use codex_utils_path_uri::LegacyAppPathString;+#[cfg(any(windows, test))]+use codex_utils_path_uri::PathConvention;use codex_utils_path_uri::PathUri;#[cfg(any(windows, test))]use tokio::io::AsyncBufReadExt;@@ -34,7 +38,6 @@ use crate::fs_helper::CODEX_FS_HELPER_ARG1;use crate::fs_helper::FsHelperPayload;use crate::fs_helper::FsHelperRequest;use crate::fs_helper::FsHelperResponse;-use crate::local_file_system::current_sandbox_cwd;use crate::rpc::internal_error;use crate::rpc::invalid_request;@@ -100,12 +103,13 @@ impl FileSystemSandboxRunner {.map(native_workspace_root).collect::<Result<Vec<_>, _>>()?;let workspace_roots = native_workspace_roots.as_slice();- let native_permissions: PermissionProfile =- sandbox.permissions.clone().try_into().map_err(|err| {- invalid_request(format!("invalid sandbox permission path URI: {err}"))- })?;- let native_permissions =- native_permissions.materialize_project_roots_with_workspace_roots(workspace_roots);+ sandbox+ .validate_file_system_paths_for_current_host()+ .map_err(|err| invalid_request(err.to_string()))?;+ let native_permissions = sandbox+ .permissions+ .clone()+ .materialize_project_roots_with_workspace_roots(workspace_roots);let mut file_system_policy = native_permissions.file_system_sandbox_policy();tracing::Span::current().record("permission_entries", file_system_policy.entries.len());let helper_read_roots = if sandbox.use_legacy_landlock {@@ -122,6 +126,8 @@ impl FileSystemSandboxRunner {// unrelated permission roots synchronously on the executor's runtime thread.#[cfg(not(target_os = "linux"))]normalize_file_system_policy_root_aliases(&mut file_system_policy);+ #[cfg(windows)]+ bind_windows_cwd_relative_deny_read_globs(&mut file_system_policy, &cwd.uri)?;let network_policy = NetworkSandboxPolicy::Restricted;let permission_profile = PermissionProfile::from_runtime_permissions_with_enforcement(native_permissions.enforcement(),@@ -155,10 +161,17 @@ impl FileSystemSandboxRunner {"filesystem sandbox cannot be enforced on this executor".to_string(),));}+ // Requests use absolute paths; the helper can start at the filesystem root even if+ // the policy cwd was removed. Keep its drive or share for Windows `:root` rules.+ let helper_cwd = cwd+ .native+ .ancestors()+ .last()+ .ok_or_else(|| invalid_request("filesystem sandbox cwd has no root".to_string()))?;let command = SandboxCommand {program: helper.as_path().as_os_str().to_owned(),args: vec![CODEX_FS_HELPER_ARG1.to_string()],- cwd: cwd.uri.clone(),+ cwd: PathUri::from_abs_path(&helper_cwd),env: self.helper_env.clone(),managed_network: None,additional_permissions: None,@@ -193,23 +206,10 @@ impl FileSystemSandboxRunner {}fn sandbox_cwd(sandbox: &FileSystemSandboxContext) -> Result<SandboxCwd, JSONRPCErrorError> {- if let Some(uri) = &sandbox.cwd {- return Ok(SandboxCwd {- native: native_sandbox_cwd(uri)?,- uri: uri.clone(),- });- }-- if sandbox.has_cwd_dependent_permissions() {- return Err(invalid_request(- "file system sandbox context with dynamic permissions requires cwd".to_string(),- ));- }-- let native = AbsolutePathBuf::from_absolute_path(current_sandbox_cwd().map_err(io_error)?)- .map_err(|err| invalid_request(format!("current directory is not absolute: {err}")))?;- let uri = PathUri::from_abs_path(&native);- Ok(SandboxCwd { uri, native })+ Ok(SandboxCwd {+ native: native_sandbox_cwd(&sandbox.cwd)?,+ uri: sandbox.cwd.clone(),+ })}fn native_sandbox_cwd(cwd: &PathUri) -> Result<AbsolutePathBuf, JSONRPCErrorError> {@@ -264,6 +264,34 @@ fn add_helper_runtime_permissions(}}+#[cfg(any(windows, test))]+fn bind_windows_cwd_relative_deny_read_globs(+ file_system_policy: &mut FileSystemSandboxPolicy,+ cwd: &PathUri,+) -> Result<(), JSONRPCErrorError> {+ // The Windows direct-spawn wrapper reevaluates the profile using the helper cwd.+ // Bind cwd-relative denials before moving the helper to the filesystem root.+ for entry in &mut file_system_policy.entries {+ if let FileSystemPath::GlobPattern { pattern } = &mut entry.path+ && entry.access == FileSystemAccessMode::Deny+ && PathConvention::Windows+ .home_relative_suffix(pattern)+ .is_none()+ && LegacyAppPathString::from_string(pattern.as_str())+ .to_path_uri(PathConvention::Windows)+ .is_err()+ {+ cwd.validate_glob_directory(PathConvention::Windows)+ .map_err(|err| invalid_request(err.to_string()))?;+ *pattern = cwd+ .join(pattern.as_str())+ .map_err(|err| invalid_request(err.to_string()))?+ .inferred_native_path_string();+ }+ }+ Ok(())+}+#[cfg(not(target_os = "linux"))]fn normalize_file_system_policy_root_aliases(file_system_policy: &mut FileSystemSandboxPolicy) {for entry in &mut file_system_policy.entries {@@ -542,6 +570,7 @@ mod tests {use super::FileSystemSandboxRunner;use super::SandboxCwd;use super::add_helper_runtime_permissions;+ use super::bind_windows_cwd_relative_deny_read_globs;use super::helper_env;use super::helper_env_from_vars;use super::helper_env_key_is_allowed;@@ -740,6 +769,147 @@ mod tests {assert_eq!(request.env.get(&path_key), Some(&path));}+ /// Removing the selected directory must not change permission anchoring or prevent launch.+ #[test]+ fn sandbox_exec_request_uses_filesystem_root_and_preserves_policy_cwd() {+ let codex_self_exe = std::env::current_exe().expect("current exe");+ let runtime_paths =+ ExecServerRuntimePaths::new(codex_self_exe.clone(), Some(codex_self_exe))+ .expect("runtime paths");+ let runner = FileSystemSandboxRunner::new(runtime_paths);+ let selected = tempfile::tempdir().expect("selected directory");+ let selected_cwd = AbsolutePathBuf::from_absolute_path(selected.path()).expect("cwd");+ let root = selected_cwd.ancestors().last().expect("filesystem root");+ let policy = restricted_policy(vec![special_entry(+ FileSystemSpecialPath::Root,+ FileSystemAccessMode::Read,+ )]);+ let sandbox_context =+ sandbox_context_with_cwd(&policy, PathUri::from_abs_path(&selected_cwd));+ #[cfg(windows)]+ let sandbox_context = crate::FileSystemSandboxContext {+ windows_sandbox_selection: codex_file_system::WindowsSandboxSelection::RestrictedToken,+ ..sandbox_context+ };+ selected.close().expect("remove selected directory");++ let request = runner+ .sandbox_command(&sandbox_context)+ .expect("sandbox command");++ assert_eq!(+ (request.cwd, request.sandbox_policy_cwd),+ (+ PathUri::from_abs_path(&root),+ PathUri::from_abs_path(&selected_cwd)+ )+ );+ }++ /// Tilde patterns stay home-relative when Windows sandbox commands start at another cwd.+ #[test]+ fn windows_cwd_relative_denial_binding_keeps_tilde_patterns_home_relative() {+ let cwd = PathUri::parse("file:///C:/policy/checkout").expect("Windows policy cwd");+ let mut policy = restricted_policy(+ [+ "~",+ "~/",+ r"~\",+ "~/private/*.env",+ r"~\private\*.env",+ "hidden/*.env",+ "~someone/private",+ "D:/absolute/*.env",+ ]+ .into_iter()+ .map(|pattern| {+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: pattern.to_string(),+ },+ FileSystemAccessMode::Deny,+ )+ })+ .collect(),+ );++ bind_windows_cwd_relative_deny_read_globs(&mut policy, &cwd).expect("bind Windows policy");++ let patterns = policy+ .entries+ .into_iter()+ .filter_map(|entry| match entry.path {+ FileSystemPath::GlobPattern { pattern } => Some(pattern),+ FileSystemPath::Path { .. } | FileSystemPath::Special { .. } => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(+ patterns,+ [+ "~",+ "~/",+ r"~\",+ "~/private/*.env",+ r"~\private\*.env",+ r"C:\policy\checkout\hidden\*.env",+ r"C:\policy\checkout\~someone\private",+ "D:/absolute/*.env",+ ]+ );+ }++ /// Windows wrapper policy checks must keep cwd-relative denials anchored to the selection.+ #[cfg(windows)]+ #[test]+ fn sandbox_exec_request_binds_windows_relative_globs_to_policy_cwd() {+ let codex_self_exe = std::env::current_exe().expect("current exe");+ let runtime_paths =+ ExecServerRuntimePaths::new(codex_self_exe, /*codex_linux_sandbox_exe*/ None)+ .expect("runtime paths");+ let runner = FileSystemSandboxRunner::new(runtime_paths);+ let selected = tempfile::tempdir().expect("selected directory");+ let selected_cwd = AbsolutePathBuf::from_absolute_path(selected.path()).expect("cwd");+ let cwd_uri = PathUri::from_abs_path(&selected_cwd);+ let pattern = "hidden/*.env";+ let absolute_pattern = cwd_uri+ .join(pattern)+ .expect("absolute glob")+ .inferred_native_path_string();+ let policy = restricted_policy(vec![+ special_entry(FileSystemSpecialPath::Root, FileSystemAccessMode::Read),+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: pattern.to_string(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let sandbox_context = crate::FileSystemSandboxContext {+ windows_sandbox_selection: codex_file_system::WindowsSandboxSelection::Elevated,+ ..sandbox_context_with_cwd(&policy, cwd_uri)+ };+ selected.close().expect("remove selected directory");++ let request = runner+ .sandbox_command(&sandbox_context)+ .expect("sandbox command");++ assert_eq!(+ request+ .permission_profile+ .file_system_sandbox_policy()+ .entries+ .into_iter()+ .find(|entry| { matches!(entry.path, FileSystemPath::GlobPattern { .. }) }),+ Some(FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: absolute_pattern+ },+ FileSystemAccessMode::Deny,+ ))+ );+ }+#[test]fn sandbox_cwd_uses_context_cwd() {let native_cwd = AbsolutePathBuf::from_absolute_path(std::env::temp_dir().as_path())@@ -780,27 +950,6 @@ mod tests {);}- #[test]- fn sandbox_cwd_rejects_cwd_dependent_profile_without_context_cwd() {- let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {- path: FileSystemPath::Special {- value: FileSystemSpecialPath::project_roots(/*subpath*/ None),- },- access: FileSystemAccessMode::Write,- missing_path_behavior: None,- }]);- let sandbox_context = codex_file_system::FileSystemSandboxContext::from_permission_profile(- PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),- );-- let err = sandbox_cwd(&sandbox_context).expect_err("missing cwd should be rejected");-- assert_eq!(- err.message,- "file system sandbox context with dynamic permissions requires cwd"- );- }-#[test]fn helper_permissions_include_only_the_helper_executable() {let codex_self_exe = std::env::current_exe().expect("current exe");@@ -875,7 +1024,7 @@ mod tests {policy: &FileSystemSandboxPolicy,cwd: PathUri,) -> crate::FileSystemSandboxContext {- codex_file_system::FileSystemSandboxContext::from_permission_profile_with_cwd(+ codex_file_system::FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(policy, NetworkSandboxPolicy::Restricted),cwd,)diff --git a/codex-rs/exec-server/src/local_file_system.rs b/codex-rs/exec-server/src/local_file_system.rsindex 63048da72a..f4b29363f2 100644--- a/codex-rs/exec-server/src/local_file_system.rs+++ b/codex-rs/exec-server/src/local_file_system.rs@@ -99,6 +99,9 @@ impl LocalFileSystem {&'a dyn ExecutorFileSystem,Option<&'a FileSystemSandboxContext>,)> {+ if let Some(sandbox) = sandbox {+ sandbox.validate_file_system_paths_for_current_host()?;+ }if sandbox.is_some_and(FileSystemSandboxContext::should_run_in_sandbox) {Ok((self.sandboxed()?, sandbox))} else {@@ -113,6 +116,9 @@ impl LocalFileSystem {path: &PathUri,sandbox: Option<&FileSystemSandboxContext>,) -> FileSystemResult<tokio::fs::File> {+ if let Some(sandbox) = sandbox {+ sandbox.validate_file_system_paths_for_current_host()?;+ }if sandbox.is_some_and(FileSystemSandboxContext::should_run_in_sandbox) {return self.sandboxed()?.open_file_for_read(path, sandbox).await;}@@ -1225,12 +1231,6 @@ pub(crate) fn resolve_existing_path(path: &Path) -> io::Result<PathBuf> {Ok(resolved)}-pub(crate) fn current_sandbox_cwd() -> io::Result<PathBuf> {- let cwd = std::env::current_dir()- .map_err(|err| io::Error::other(format!("failed to read current dir: {err}")))?;- resolve_existing_path(cwd.as_path())-}-fn copy_symlink(source: &Path, target: &Path) -> io::Result<()> {let link_target = std::fs::read_link(source)?;#[cfg(unix)]@@ -1349,6 +1349,7 @@ mod walk_tests {&FileSystemSandboxPolicy::restricted(Vec::new()),NetworkSandboxPolicy::Restricted,),+ root.clone(),);let options = WalkOptions {max_depth: 1,diff --git a/codex-rs/exec-server/src/process_sandbox.rs b/codex-rs/exec-server/src/process_sandbox.rsindex 035bfa8831..5bc2b5d9fc 100644--- a/codex-rs/exec-server/src/process_sandbox.rs+++ b/codex-rs/exec-server/src/process_sandbox.rs@@ -145,19 +145,18 @@ pub(crate) async fn prepare_exec_request_with_telemetry(windows_sandbox: None,});};+ let runtime_paths = runtime_paths+ .ok_or_else(|| invalid_params("sandbox runtime paths are not configured".to_string()))?;+ sandbox_context+ .validate_file_system_paths_for_current_host()+ .map_err(|err| invalid_params(err.to_string()))?;let windows_sandbox_proxy_settings_mode = sandbox_context.windows_sandbox_proxy_settings_mode.unwrap_or_default();- let runtime_paths = runtime_paths- .ok_or_else(|| invalid_params("sandbox runtime paths are not configured".to_string()))?;// TODO(jif): Transport permissions before orchestrator-local paths are materialized,// then resolve executor-local helper and workspace paths here.- let permissions: PermissionProfile = sandbox_context- .permissions- .clone()- .try_into()- .map_err(|err| invalid_params(format!("invalid sandbox permission path URI: {err}")))?;- let sandbox_policy_cwd = sandbox_context.cwd.as_ref().unwrap_or(¶ms.cwd);+ let permissions = sandbox_context.permissions.clone();+ let sandbox_policy_cwd = &sandbox_context.cwd;let native_sandbox_policy_cwd = native_path(sandbox_policy_cwd, "sandbox cwd")?;let native_workspace_roots = sandbox_context.workspace_rootsdiff --git a/codex-rs/exec-server/src/process_sandbox_tests.rs b/codex-rs/exec-server/src/process_sandbox_tests.rsindex 7e66b2e419..7f415f4dde 100644--- a/codex-rs/exec-server/src/process_sandbox_tests.rs+++ b/codex-rs/exec-server/src/process_sandbox_tests.rs@@ -27,6 +27,8 @@ use codex_sandboxing::landlock::CODEX_LINUX_SANDBOX_ARG0;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;+#[cfg(unix)]+use tempfile::tempdir;#[cfg(windows)]use test_case::test_case;use tokio::io::AsyncReadExt;@@ -65,15 +67,13 @@ async fn prepare_exec_request(#[cfg(unix)]#[tokio::test]async fn sandbox_request_wraps_native_argv_on_executor() {- let cwd: AbsolutePathBuf = std::env::current_dir()- .expect("current directory")- .try_into()- .expect("absolute cwd");+ let command_directory = tempdir().expect("command directory");+ let cwd = AbsolutePathBuf::from_absolute_path(command_directory.path()).expect("absolute cwd");let cwd_uri = PathUri::from_abs_path(&cwd);let self_exe = std::env::current_exe().expect("current executable");let runtime_paths =ExecServerRuntimePaths::new(self_exe.clone(), Some(self_exe)).expect("runtime paths");- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::workspace_write(),cwd_uri.clone(),);@@ -129,6 +129,37 @@ async fn sandbox_request_wraps_native_argv_on_executor() {PermissionProfile::workspace_write().materialize_project_roots_with_workspace_roots(std::slice::from_ref(&cwd)));++ let policy_directory = tempdir().expect("policy directory");+ let explicit_cwd =+ AbsolutePathBuf::from_absolute_path(policy_directory.path()).expect("policy cwd");+ let mut params = params.clone();+ for policy_cwd in [&cwd, &explicit_cwd] {+ params.sandbox.as_mut().expect("sandbox").cwd = PathUri::from_abs_path(policy_cwd);+ let prepared = prepare_exec_request(+ ¶ms,+ HashMap::new(),+ Some(&runtime_paths),+ /*network_policy_decider*/ None,+ /*network_policy_audit_observer*/ None,+ )+ .await+ .expect("prepare sandboxed request");+ let actual_cwds = prepared+ .command+ .windows(4)+ .find(|args| args[0] == "--sandbox-policy-cwd")+ .expect("sandbox wrapper cwd arguments");+ assert_eq!(+ actual_cwds,+ [+ "--sandbox-policy-cwd",+ policy_cwd.to_string_lossy().as_ref(),+ "--command-cwd",+ cwd.to_string_lossy().as_ref(),+ ]+ );+ }}#[cfg(target_os = "macos")]assert_eq!(@@ -162,7 +193,7 @@ async fn sandbox_request_routes_custom_arg0_to_inner_helper() {let self_exe = std::env::current_exe().expect("current executable");let runtime_paths =ExecServerRuntimePaths::new(self_exe.clone(), Some(self_exe)).expect("runtime paths");- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::workspace_write(),cwd_uri.clone(),);@@ -224,7 +255,7 @@ fn managed_network_sandbox_request() -> (ExecParams, ExecServerRuntimePaths) {let self_exe = std::env::current_exe().expect("current executable");let runtime_paths =ExecServerRuntimePaths::new(self_exe.clone(), Some(self_exe)).expect("runtime paths");- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::workspace_write(),cwd_uri.clone(),);@@ -617,10 +648,8 @@ async fn managed_network_honors_windows_sandbox_level(windows_sandbox_level: Winlet self_exe = std::env::current_exe().expect("current executable");let runtime_paths = ExecServerRuntimePaths::new(self_exe, None).expect("runtime paths");let permissions = PermissionProfile::read_only();- let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(- permissions.clone(),- cwd_uri.clone(),- );+ let mut sandbox =+ FileSystemSandboxContext::from_permission_profile(permissions.clone(), cwd_uri.clone());sandbox.windows_sandbox_selection = windows_sandbox_level.into();sandbox.windows_sandbox_proxy_settings_mode =Some(codex_sandboxing::WindowsSandboxProxySettingsMode::Preserve);diff --git a/codex-rs/exec-server/src/remote_file_stream.rs b/codex-rs/exec-server/src/remote_file_stream.rsindex 107dea51d7..f71e5fd1ee 100644--- a/codex-rs/exec-server/src/remote_file_stream.rs+++ b/codex-rs/exec-server/src/remote_file_stream.rs@@ -24,7 +24,7 @@ struct FileReadRegistration {pub(super) async fn open(client: ExecServerClient,path: PathUri,- sandbox: Option<FileSystemSandboxContext>,+ sandbox: Option<&FileSystemSandboxContext>,) -> FileSystemResult<FileSystemReadStream> {let registration = FileReadRegistration {client,@@ -37,7 +37,7 @@ pub(super) async fn open(.fs_open(FsOpenParams {handle_id: registration.handle_id.clone(),path,- sandbox,+ sandbox: sandbox.cloned(),}).await.map_err(map_remote_error)?;diff --git a/codex-rs/exec-server/src/remote_file_system.rs b/codex-rs/exec-server/src/remote_file_system.rsindex d574cece8c..33d3b0be69 100644--- a/codex-rs/exec-server/src/remote_file_system.rs+++ b/codex-rs/exec-server/src/remote_file_system.rs@@ -106,7 +106,7 @@ impl RemoteFileSystem {) -> FileSystemResult<FileSystemReadStream> {trace!("remote fs read_file_stream");let client = self.client.get().await.map_err(map_remote_error)?;- file_stream::open(client, path.clone(), remote_sandbox_context(sandbox)).await+ file_stream::open(client, path.clone(), sandbox).await}async fn write_file(@@ -410,9 +410,7 @@ impl ExecutorFileSystem for RemoteFileSystem {fn remote_sandbox_context(sandbox: Option<&FileSystemSandboxContext>,) -> Option<FileSystemSandboxContext> {- sandbox- .cloned()- .map(FileSystemSandboxContext::drop_cwd_if_unused)+ sandbox.cloned()}fn map_remote_error(error: ExecServerError) -> io::Error {@@ -451,7 +449,7 @@ mod tests {use super::*;#[test]- fn remote_sandbox_context_drops_unused_cwd() {+ fn remote_sandbox_context_preserves_cwd_for_absolute_permissions() {let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {path: FileSystemPath::Path {path: absolute_test_path("remote-root").into(),@@ -461,15 +459,14 @@ mod tests {}]);let permissions =PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted);- let sandbox_context = FileSystemSandboxContext::from_permission_profile_with_cwd(- permissions,- path_uri("host-checkout"),- );+ let cwd = path_uri("executor-checkout");+ let sandbox_context =+ FileSystemSandboxContext::from_permission_profile(permissions, cwd.clone());let remote_context =remote_sandbox_context(Some(&sandbox_context)).expect("remote sandbox context");- assert_eq!(remote_context.cwd, None);+ assert_eq!(remote_context.cwd, cwd);}#[test]@@ -485,12 +482,12 @@ mod tests {PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted);let cwd = path_uri("host-checkout");let sandbox_context =- FileSystemSandboxContext::from_permission_profile_with_cwd(permissions, cwd.clone());+ FileSystemSandboxContext::from_permission_profile(permissions, cwd.clone());let remote_context =remote_sandbox_context(Some(&sandbox_context)).expect("remote sandbox context");- assert_eq!(remote_context.cwd, Some(cwd));+ assert_eq!(remote_context.cwd, cwd);}#[test]diff --git a/codex-rs/exec-server/src/remote_file_system_path_uri_tests.rs b/codex-rs/exec-server/src/remote_file_system_path_uri_tests.rsindex 4956f4bfdb..813574d1b1 100644--- a/codex-rs/exec-server/src/remote_file_system_path_uri_tests.rs+++ b/codex-rs/exec-server/src/remote_file_system_path_uri_tests.rs@@ -42,7 +42,10 @@ use crate::protocol::FsReadFileResponse;use crate::protocol::INITIALIZE_METHOD;use crate::protocol::INITIALIZED_METHOD;use crate::protocol::InitializeResponse;+use crate::protocol::WireFsGetMetadataParams;+use crate::protocol::WireFsReadFileParams;+/// Absolute policies preserve foreign selection paths without adding legacy policy directories.#[tokio::test]async fn remote_file_system_sends_path_and_sandbox_cwd_uris_without_native_conversion() {let (websocket_url, captured_params, server) =@@ -59,17 +62,20 @@ async fn remote_file_system_sends_path_and_sandbox_cwd_uris_without_native_convePathUri::parse("file://server/share/src/main.rs").expect("valid UNC URI"),];let sandbox_cwd = non_native_cwd();- let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {- path: FileSystemPath::Special {- value: FileSystemSpecialPath::project_roots(/*subpath*/ None),- },- access: FileSystemAccessMode::Write,- missing_path_behavior: None,- }]);- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let workspace_root = paths[0].parent().expect("workspace root URI");+ let policy = FileSystemSandboxPolicy::restricted(+ paths+ .iter()+ .map(|path| {+ FileSystemSandboxEntry::new(path.clone().into(), FileSystemAccessMode::Read)+ })+ .collect(),+ );+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),sandbox_cwd,);+ sandbox.workspace_roots = vec![workspace_root];for path in &paths {assert_eq!(@@ -81,6 +87,7 @@ async fn remote_file_system_sends_path_and_sandbox_cwd_uris_without_native_conve);}+ let captured_params = captured_params.await.expect("captured params");let expected_params = paths.into_iter().map(|path| FsReadFileParams {@@ -90,12 +97,279 @@ async fn remote_file_system_sends_path_and_sandbox_cwd_uris_without_native_conve}).collect::<Vec<_>>();assert_eq!(- captured_params.await.expect("captured params"),+ captured_params+ .iter()+ .map(|(params, _)| params.clone())+ .collect::<Vec<_>>(),+ expected_params+ );+ let policy_context = serde_json::json!({+ "cwd": sandbox.cwd,+ "workspaceRoots": sandbox.workspace_roots,+ });+ for (_, raw_sandbox) in captured_params {+ assert_eq!(+ (+ raw_sandbox.get("cwd"),+ raw_sandbox.get("workspaceRoots"),+ raw_sandbox.get("policyContext"),+ ),+ (None, None, Some(&policy_context)),+ );+ }+ server.await.expect("recording server should succeed");+}++/// Only dynamic policies retain legacy selection fields; all policies preserve the new context.+#[tokio::test]+async fn remote_file_system_preserves_only_cwd_dependent_policy_directories() {+ let cases = [+ (+ "file:///workspace/checkout",+ Some("/elsewhere/*.secret"),+ None,+ Some("selected-root"),+ ),+ (+ "file:///D:/checkout",+ Some(r"D:\elsewhere\*.secret"),+ None,+ Some("selected-root"),+ ),+ (+ "file://server/share/checkout",+ Some(r"\\server\share\elsewhere\*.secret"),+ None,+ Some("selected-root"),+ ),+ (+ "file:///workspace/checkout",+ Some("*.secret"),+ Some("file:///workspace/checkout"),+ Some("selected-root"),+ ),+ (+ "file:///D:/checkout",+ Some(r"private\*.secret"),+ Some("file:///D:/checkout"),+ Some("selected-root"),+ ),+ (+ "file:///workspace/checkout",+ None,+ Some("file:///workspace/checkout"),+ Some("selected-root"),+ ),+ (+ "file:///D:/checkout",+ None,+ Some("file:///D:/checkout"),+ None,+ ),+ ];+ let (websocket_url, captured_params, server) = record_read_file_params(cases.len()).await;+ let file_system = RemoteFileSystem::new(LazyRemoteExecServerClient::new(+ ExecServerTransportParams::websocket_url(+ websocket_url,+ DEFAULT_REMOTE_EXEC_SERVER_CONNECT_TIMEOUT,+ ),+ HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ ));+ let mut expected_params = Vec::new();+ let mut expected_contexts = Vec::new();+ for (cwd, pattern, legacy_cwd, selected_root) in cases {+ let cwd = PathUri::parse(cwd).expect("policy cwd");+ let path = cwd.join("public.txt").expect("operation path");+ let permission_path = match pattern {+ Some(pattern) => FileSystemPath::GlobPattern {+ pattern: pattern.to_string(),+ },+ None => FileSystemPath::Special {+ value: FileSystemSpecialPath::project_roots(/*subpath*/ None),+ },+ };+ let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry::new(+ permission_path,+ FileSystemAccessMode::Deny,+ )]);+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );+ sandbox.workspace_roots = selected_root+ .map(|root| cwd.join(root).expect("selected workspace root"))+ .into_iter()+ .collect();+ file_system+ .read_file(&path, Default::default(), Some(&sandbox))+ .await+ .expect("remote read");+ let legacy_cwd = legacy_cwd+ .map(|cwd| serde_json::json!(PathUri::parse(cwd).expect("legacy policy cwd")));+ let legacy_roots = if legacy_cwd.is_some() && !sandbox.workspace_roots.is_empty() {+ Some(serde_json::json!(sandbox.workspace_roots))+ } else {+ None+ };+ expected_contexts.push((+ legacy_cwd,+ legacy_roots,+ Some(serde_json::json!({+ "cwd": cwd,+ "workspaceRoots": sandbox.workspace_roots,+ })),+ ));+ expected_params.push(FsReadFileParams {+ path,+ follow_symlinks: None,+ sandbox: Some(sandbox),+ });+ }+ let captured_params = captured_params.await.expect("captured params");+ assert_eq!(+ captured_params+ .iter()+ .map(|(params, _)| params.clone())+ .collect::<Vec<_>>(),expected_params);+ assert_eq!(+ captured_params+ .iter()+ .map(|(_, sandbox)| {+ (+ sandbox.get("cwd").cloned(),+ sandbox.get("workspaceRoots").cloned(),+ sandbox.get("policyContext").cloned(),+ )+ })+ .collect::<Vec<_>>(),+ expected_contexts,+ );server.await.expect("recording server should succeed");}+/// Older executors can launch with their own cwd while newer executors retain the removed cwd.+#[tokio::test]+async fn remote_file_system_can_read_after_checkout_removal_with_legacy_helper_launch() {+ let temp = tempfile::TempDir::new().expect("test directory");+ let checkout = temp.path().join("checkout");+ std::fs::create_dir(&checkout).expect("checkout should exist");+ let path = temp.path().join("allowed.txt");+ std::fs::write(&path, "allowed").expect("fixture should be writable");+ let path = PathUri::from_host_native_path(path).expect("absolute file path");+ let cwd = PathUri::from_host_native_path(&checkout).expect("absolute checkout");+ std::fs::remove_dir(checkout).expect("checkout should be removed");+ let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry::new(+ path.clone().into(),+ FileSystemAccessMode::Read,+ )]);+ let sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );++ let listener = TcpListener::bind("127.0.0.1:0")+ .await+ .expect("listener should bind");+ let websocket_url = format!("ws://{}", listener.local_addr().expect("listener address"));+ let server = tokio::spawn(async move {+ let (stream, _) = listener.accept().await.expect("listener should accept");+ let mut websocket = accept_async(stream)+ .await+ .expect("websocket handshake should succeed");+ complete_websocket_initialize(&mut websocket).await;+ let JSONRPCMessage::Request(request) = read_jsonrpc_websocket(&mut websocket).await else {+ panic!("expected fs/readFile request");+ };+ assert_eq!(request.method, FS_READ_FILE_METHOD);+ let raw_params = request.params.expect("read params");+ let raw_sandbox = raw_params+ .get("sandbox")+ .expect("raw sandbox should be sent");+ let policy_context = serde_json::json!({+ "cwd": cwd,+ "workspaceRoots": [cwd],+ });+ assert_eq!(+ (+ raw_sandbox.get("cwd"),+ raw_sandbox.get("workspaceRoots"),+ raw_sandbox.get("policyContext"),+ ),+ (None, None, Some(&policy_context)),+ );+ let legacy_cwd = raw_sandbox+ .get("cwd")+ .cloned()+ .map(serde_json::from_value::<PathUri>)+ .transpose()+ .expect("legacy sandbox cwd");+ let params = serde_json::from_value::<WireFsReadFileParams>(raw_params)+ .expect("wire read params")+ .try_into_request(|wire| {+ let cwd = wire.cwd().expect("explicit client policy cwd").clone();+ Ok(wire.into_context(cwd))+ })+ .expect("typed read params");+ let selected_sandbox = params.sandbox.expect("sandbox should be sent");+ assert_eq!(+ (selected_sandbox.cwd, selected_sandbox.workspace_roots),+ (cwd.clone(), vec![cwd]),+ );+ // An old executor falls back to its own cwd when it spawns the helper for this policy.+ let helper_cwd = match legacy_cwd {+ Some(cwd) => cwd.to_abs_path().expect("native legacy cwd").to_path_buf(),+ None => std::env::current_dir().expect("legacy executor cwd"),+ };+ #[cfg(unix)]+ let mut command = tokio::process::Command::new("cat");+ #[cfg(windows)]+ let mut command = {+ let mut command = tokio::process::Command::new("cmd.exe");+ command.args(["/C", "type"]);+ command+ };+ let output = command+ .current_dir(helper_cwd)+ .arg(params.path.to_abs_path().expect("native file").as_path())+ .output()+ .await+ .expect("legacy helper should launch");+ assert!(+ output.status.success(),+ "{}",+ String::from_utf8_lossy(&output.stderr)+ );+ write_jsonrpc_websocket(+ &mut websocket,+ JSONRPCMessage::Response(JSONRPCResponse {+ id: request.id,+ result: serde_json::to_value(FsReadFileResponse {+ data_base64: STANDARD.encode(output.stdout),+ })+ .expect("read response"),+ }),+ )+ .await;+ });+ let file_system = RemoteFileSystem::new(LazyRemoteExecServerClient::new(+ ExecServerTransportParams::websocket_url(+ websocket_url,+ DEFAULT_REMOTE_EXEC_SERVER_CONNECT_TIMEOUT,+ ),+ HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ ));+ assert_eq!(+ file_system+ .read_file(&path, Default::default(), Some(&sandbox))+ .await+ .expect("remote read"),+ b"allowed"+ );+ server.await.expect("legacy server should succeed");+}+#[tokio::test]async fn concurrent_remote_metadata_requests_share_only_in_flight_results() {let (abandoned_request_tx, abandoned_request_rx) = oneshot::channel();@@ -390,7 +664,7 @@ async fn remote_metadata_requests_do_not_cross_path_or_sandbox_boundaries() {));let first_path = PathUri::parse("file:///workspace/project/AGENTS.md").expect("valid path URI");let second_path = PathUri::parse("file:///workspace/project/SKILL.md").expect("valid path URI");- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {path: FileSystemPath::Special {@@ -447,7 +721,7 @@ async fn record_read_file_params(expected_requests: usize,) -> (String,- oneshot::Receiver<Vec<FsReadFileParams>>,+ oneshot::Receiver<Vec<(FsReadFileParams, serde_json::Value)>>,tokio::task::JoinHandle<()>,) {let listener = TcpListener::bind("127.0.0.1:0")@@ -470,10 +744,19 @@ async fn record_read_file_params(}other => panic!("expected fs/readFile request, got {other:?}"),};- let params: FsReadFileParams =- serde_json::from_value(request.params.expect("fs/readFile params should exist"))- .expect("fs/readFile params should deserialize");- captured_params.push(params);+ let raw_params = request.params.expect("fs/readFile params should exist");+ let raw_sandbox = raw_params+ .get("sandbox")+ .expect("fs/readFile sandbox should exist")+ .clone();+ let params = serde_json::from_value::<WireFsReadFileParams>(raw_params)+ .expect("fs/readFile wire params should deserialize")+ .try_into_request(|wire| {+ let cwd = wire.cwd().expect("explicit client policy cwd").clone();+ Ok(wire.into_context(cwd))+ })+ .expect("fs/readFile params should convert");+ captured_params.push((params, raw_sandbox));write_jsonrpc_websocket(&mut websocket,JSONRPCMessage::Response(JSONRPCResponse {@@ -554,10 +837,15 @@ async fn record_metadata_params());} else {assert_eq!(request.method, FS_GET_METADATA_METHOD);- let params: FsGetMetadataParams = serde_json::from_value(+ let params = serde_json::from_value::<WireFsGetMetadataParams>(request.params.expect("fs/getMetadata params should exist"),)- .expect("fs/getMetadata params should deserialize");+ .expect("fs/getMetadata wire params should deserialize")+ .try_into_request(|wire| {+ let cwd = wire.cwd().expect("explicit client policy cwd").clone();+ Ok(wire.into_context(cwd))+ })+ .expect("fs/getMetadata params should convert");captured_params.push(params);}let response = match response {diff --git a/codex-rs/exec-server/src/sandboxed_file_system_path_uri_tests.rs b/codex-rs/exec-server/src/sandboxed_file_system_path_uri_tests.rsindex 031d89080f..f39f01e0e4 100644--- a/codex-rs/exec-server/src/sandboxed_file_system_path_uri_tests.rs+++ b/codex-rs/exec-server/src/sandboxed_file_system_path_uri_tests.rs@@ -1,5 +1,9 @@use codex_protocol::models::PermissionProfile;+use codex_protocol::permissions::FileSystemAccessMode;+use codex_protocol::permissions::FileSystemPath;+use codex_protocol::permissions::FileSystemSandboxEntry;use codex_protocol::permissions::FileSystemSandboxPolicy;+use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;@@ -14,12 +18,14 @@ async fn sandboxed_file_system_rejects_non_native_uri_as_invalid_input() {/*codex_linux_sandbox_exe*/ None,).expect("runtime paths");- let file_system = SandboxedFileSystem::new(runtime_paths);+ let file_system = SandboxedFileSystem::new(runtime_paths.clone());+ let cwd = PathUri::from_host_native_path(std::env::temp_dir()).expect("native temporary cwd");let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&FileSystemSandboxPolicy::restricted(Vec::new()),NetworkSandboxPolicy::Restricted,),+ cwd.clone(),);let error = file_system@@ -28,6 +34,34 @@ async fn sandboxed_file_system_rejects_non_native_uri_as_invalid_input() {.expect_err("non-native URI should be rejected");assert_eq!(error.kind(), io::ErrorKind::InvalidInput);++ // A foreign permission path must not select the unsandboxed filesystem, even with a root grant.+ let file_system = crate::LocalFileSystem::with_runtime_paths(runtime_paths);+ let foreign = non_native_uri();+ let policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Write,+ ),+ FileSystemSandboxEntry::new(foreign.clone().into(), FileSystemAccessMode::Write),+ ]);+ let sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd,+ );+ let readable = tempfile::NamedTempFile::new().expect("readable file");+ let error = file_system+ .read_file(+ &PathUri::from_host_native_path(readable.path()).expect("readable file URI"),+ Default::default(),+ Some(&sandbox),+ )+ .await+ .expect_err("foreign permission path must not allow unsandboxed access");+ assert_eq!(error.kind(), io::ErrorKind::InvalidInput);+ assert!(error.to_string().contains(&foreign.to_string()));}fn non_native_uri() -> PathUri {diff --git a/codex-rs/exec-server/src/server/file_system_handler.rs b/codex-rs/exec-server/src/server/file_system_handler.rsindex 8acc2a39c6..cdddddf689 100644--- a/codex-rs/exec-server/src/server/file_system_handler.rs+++ b/codex-rs/exec-server/src/server/file_system_handler.rs@@ -79,7 +79,10 @@ impl FileSystemHandler {.first().and_then(|root| root.sandbox.as_ref()).filter(|sandbox| {- sandbox.should_run_in_sandbox()+ sandbox+ .validate_file_system_paths_for_current_host()+ .is_ok()+ && sandbox.should_run_in_sandbox()&& (!cfg!(target_os = "windows") || sandbox.windows_sandbox_is_requested())&& params.rootsdiff --git a/codex-rs/exec-server/src/server/registry.rs b/codex-rs/exec-server/src/server/registry.rsindex 4cd21ad85e..9eeba5bfa1 100644--- a/codex-rs/exec-server/src/server/registry.rs+++ b/codex-rs/exec-server/src/server/registry.rs@@ -1,8 +1,11 @@+use codex_file_system::FileSystemSandboxContext;+use codex_file_system::WireFileSystemSandboxContext;+use codex_utils_path_uri::PathUri;use opentelemetry::trace::TraceContextExt;use std::sync::Arc;+use crate::local_file_system::resolve_existing_path;use crate::protocol::CAPABILITY_ROOTS_DISCOVER_METHOD;-use crate::protocol::CapabilityRootsDiscoverParams;use crate::protocol::ENVIRONMENT_CONFIG_READ_METHOD;use crate::protocol::ENVIRONMENT_INFO_METHOD;use crate::protocol::ENVIRONMENT_STATUS_METHOD;@@ -12,7 +15,6 @@ use crate::protocol::EXEC_SIGNAL_METHOD;use crate::protocol::EXEC_TERMINATE_METHOD;use crate::protocol::EXEC_WRITE_METHOD;use crate::protocol::EnvironmentConfigReadParams;-use crate::protocol::ExecParams;use crate::protocol::FS_CANONICALIZE_METHOD;use crate::protocol::FS_CLOSE_METHOD;use crate::protocol::FS_COPY_METHOD;@@ -25,28 +27,33 @@ use crate::protocol::FS_READ_FILE_METHOD;use crate::protocol::FS_REMOVE_METHOD;use crate::protocol::FS_WALK_METHOD;use crate::protocol::FS_WRITE_FILE_METHOD;-use crate::protocol::FsCanonicalizeParams;use crate::protocol::FsCloseParams;-use crate::protocol::FsCopyParams;-use crate::protocol::FsCreateDirectoryParams;-use crate::protocol::FsGetMetadataParams;-use crate::protocol::FsOpenParams;use crate::protocol::FsReadBlockParams;-use crate::protocol::FsReadDirectoryParams;-use crate::protocol::FsReadFileParams;-use crate::protocol::FsRemoveParams;-use crate::protocol::FsWalkParams;-use crate::protocol::FsWriteFileParams;use crate::protocol::HTTP_REQUEST_METHOD;use crate::protocol::HttpRequestParams;use crate::protocol::INITIALIZE_METHOD;use crate::protocol::INITIALIZED_METHOD;use crate::protocol::InitializeParams;+use crate::protocol::JSONRPCErrorError;use crate::protocol::ReadParams;use crate::protocol::SignalParams;use crate::protocol::TerminateParams;+use crate::protocol::WireCapabilityRootsDiscoverParams;+use crate::protocol::WireExecParams;+use crate::protocol::WireFsCanonicalizeParams;+use crate::protocol::WireFsCopyParams;+use crate::protocol::WireFsCreateDirectoryParams;+use crate::protocol::WireFsGetMetadataParams;+use crate::protocol::WireFsOpenParams;+use crate::protocol::WireFsReadDirectoryParams;+use crate::protocol::WireFsReadFileParams;+use crate::protocol::WireFsRemoveParams;+use crate::protocol::WireFsWalkParams;+use crate::protocol::WireFsWriteFileParams;use crate::protocol::WriteParams;use crate::rpc::RpcRouter;+use crate::rpc::internal_error;+use crate::rpc::invalid_params;use crate::server::ExecServerHandler;pub(crate) fn build_router() -> RpcRouter<ExecServerHandler> {@@ -71,12 +78,12 @@ pub(crate) fn build_router() -> RpcRouter<ExecServerHandler> {);router.request_with_trace(EXEC_METHOD,- |handler: Arc<ExecServerHandler>, params: ExecParams, trace| async move {+ |handler: Arc<ExecServerHandler>, params: WireExecParams, trace| async move {let launch_context = trace.as_ref().and_then(codex_otel::context_from_w3c_trace_context).map(|context| context.span().span_context().clone());- handler.exec(params, launch_context).await+ handler.exec(params.into(), launch_context).await},);router.request(@@ -95,7 +102,8 @@ pub(crate) fn build_router() -> RpcRouter<ExecServerHandler> {);router.request(CAPABILITY_ROOTS_DISCOVER_METHOD,- |handler: Arc<ExecServerHandler>, params: CapabilityRootsDiscoverParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireCapabilityRootsDiscoverParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.discover_capability_roots(params).await},);@@ -125,13 +133,15 @@ pub(crate) fn build_router() -> RpcRouter<ExecServerHandler> {);router.request(FS_READ_FILE_METHOD,- |handler: Arc<ExecServerHandler>, params: FsReadFileParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsReadFileParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_read_file(params).await},);router.request(FS_OPEN_METHOD,- |handler: Arc<ExecServerHandler>, params: FsOpenParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsOpenParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_open(params).await},);@@ -149,51 +159,80 @@ pub(crate) fn build_router() -> RpcRouter<ExecServerHandler> {);router.request(FS_WRITE_FILE_METHOD,- |handler: Arc<ExecServerHandler>, params: FsWriteFileParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsWriteFileParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_write_file(params).await},);router.request(FS_CREATE_DIRECTORY_METHOD,- |handler: Arc<ExecServerHandler>, params: FsCreateDirectoryParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsCreateDirectoryParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_create_directory(params).await},);router.request(FS_GET_METADATA_METHOD,- |handler: Arc<ExecServerHandler>, params: FsGetMetadataParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsGetMetadataParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_get_metadata(params).await},);router.request(FS_CANONICALIZE_METHOD,- |handler: Arc<ExecServerHandler>, params: FsCanonicalizeParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsCanonicalizeParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_canonicalize(params).await},);router.request(FS_READ_DIRECTORY_METHOD,- |handler: Arc<ExecServerHandler>, params: FsReadDirectoryParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsReadDirectoryParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_read_directory(params).await},);router.request(FS_WALK_METHOD,- |handler: Arc<ExecServerHandler>, params: FsWalkParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsWalkParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_walk(params).await},);router.request(FS_REMOVE_METHOD,- |handler: Arc<ExecServerHandler>, params: FsRemoveParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsRemoveParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_remove(params).await},);router.request(FS_COPY_METHOD,- |handler: Arc<ExecServerHandler>, params: FsCopyParams| async move {+ |handler: Arc<ExecServerHandler>, params: WireFsCopyParams| async move {+ let params = params.try_into_request(resolve_filesystem_sandbox)?;handler.fs_copy(params).await},);router}++fn resolve_filesystem_sandbox(+ sandbox: WireFileSystemSandboxContext,+) -> Result<FileSystemSandboxContext, JSONRPCErrorError> {+ let cwd = if let Some(cwd) = sandbox.cwd() {+ cwd.clone()+ } else {+ if sandbox.requires_cwd() {+ return Err(invalid_params(+ "file system sandbox context with dynamic permissions requires cwd".to_string(),+ ));+ }+ // Legacy filesystem clients omitted cwd only for these policies. Preserve the executor's+ // own default (and Windows drive/share), rather than using the requested path.+ std::env::current_dir()+ .and_then(|cwd| resolve_existing_path(&cwd))+ .and_then(PathUri::from_host_native_path)+ .map_err(|err| internal_error(err.to_string()))?+ };+ Ok(sandbox.into_context(cwd))+}diff --git a/codex-rs/exec-server/tests/capability_discovery.rs b/codex-rs/exec-server/tests/capability_discovery.rsindex 0be51f9fbb..e811bfbbe5 100644--- a/codex-rs/exec-server/tests/capability_discovery.rs+++ b/codex-rs/exec-server/tests/capability_discovery.rs@@ -5,6 +5,8 @@ mod fake_bwrap;#[cfg(target_os = "linux")]use anyhow::Context as _;+use base64::Engine as _;+use base64::engine::general_purpose::STANDARD;use codex_exec_server::CAPABILITY_ROOTS_DISCOVER_METHOD;use codex_exec_server::CapabilityRootDiscovery;use codex_exec_server::CapabilityRootsDiscoverParams;@@ -14,12 +16,26 @@ use codex_exec_server::InitializeParams;use codex_exec_server::InitializeResponse;use codex_exec_server::WindowsSandboxSelection;use codex_exec_server_protocol::CapabilityRootDiscoverRequest;+use codex_exec_server_protocol::EXEC_METHOD;+#[cfg(unix)]+use codex_exec_server_protocol::EXEC_READ_METHOD;+use codex_exec_server_protocol::FS_OPEN_METHOD;+#[cfg(unix)]+use codex_exec_server_protocol::FS_READ_BLOCK_METHOD;+use codex_exec_server_protocol::FS_READ_FILE_METHOD;+#[cfg(unix)]+use codex_exec_server_protocol::FsReadBlockResponse;+use codex_exec_server_protocol::FsReadFileResponse;use codex_exec_server_protocol::JSONRPCMessage;use codex_exec_server_protocol::JSONRPCResponse;+#[cfg(unix)]+use codex_exec_server_protocol::ReadResponse;use codex_protocol::models::PermissionProfile;use codex_protocol::permissions::FileSystemAccessMode;+use codex_protocol::permissions::FileSystemPath;use codex_protocol::permissions::FileSystemSandboxEntry;use codex_protocol::permissions::FileSystemSandboxPolicy;+use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;@@ -183,6 +199,715 @@ async fn discovers_cursor_plugin_without_reading_default_mcp_for_inline_servers(Ok(())}+#[tokio::test]+async fn executor_legacy_missing_or_null_sandbox_cwd_keeps_absolute_requests_working()+-> anyhow::Result<()> {+ let workspace = tempfile::tempdir()?;+ std::fs::write(workspace.path().join("note.txt"), b"contents")?;+ write_file(+ &workspace.path().join("skills/demo/SKILL.md"),+ "---\nname: demo\ndescription: Demo.\n---\n",+ )?;+ let cwd = PathUri::from_host_native_path(workspace.path())?;+ let path = cwd.join("note.txt")?;+ let program = std::env::current_exe()?.to_string_lossy().into_owned();+ // A process with sandbox intent needs an enforceable profile and an enabled Windows backend.+ let process_policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Path { path: cwd.clone() },+ FileSystemAccessMode::Write,+ ),+ ]);+ let mut process_sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&process_policy, NetworkSandboxPolicy::Enabled),+ cwd.clone(),+ );+ process_sandbox.windows_sandbox_selection = WindowsSandboxSelection::RestrictedToken;+ let sandbox =+ FileSystemSandboxContext::from_permission_profile(PermissionProfile::Disabled, cwd.clone());+ let requests = [+ (+ EXEC_METHOD,+ serde_json::json!({+ "processId": "sandbox-cwd", "argv": [program, "--help"], "cwd": cwd,+ "env": {}, "tty": false, "sandbox": process_sandbox,+ }),+ "/sandbox",+ ),+ (+ FS_READ_FILE_METHOD,+ serde_json::json!({ "path": path, "sandbox": sandbox }),+ "/sandbox",+ ),+ (+ CAPABILITY_ROOTS_DISCOVER_METHOD,+ serde_json::json!({ "roots": [{ "id": "root", "path": cwd, "sandbox": sandbox }] }),+ "/roots/0/sandbox",+ ),+ ];+ let mut server = exec_server().await?;+ initialize(&mut server).await?;++ for (method, request, sandbox_pointer) in requests {+ for (index, legacy_cwd) in [None, Some(serde_json::Value::Null)]+ .into_iter()+ .enumerate()+ {+ let mut request = request.clone();+ if method == EXEC_METHOD {+ request["processId"] = serde_json::json!(format!("sandbox-cwd-{index}"));+ }+ let sandbox = request+ .pointer_mut(sandbox_pointer)+ .and_then(serde_json::Value::as_object_mut)+ .expect("sandbox request");+ if let Some(legacy_cwd) = legacy_cwd {+ sandbox.insert("cwd".to_string(), legacy_cwd);+ } else {+ sandbox.remove("cwd");+ }+ sandbox.remove("workspaceRoots");+ let request_id = server.send_request(method, request).await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Response(response) = response else {+ anyhow::bail!("expected legacy {method} to succeed, got {response:?}");+ };+ if method == FS_READ_FILE_METHOD {+ let read: FsReadFileResponse = serde_json::from_value(response.result)?;+ assert_eq!(STANDARD.decode(read.data_base64)?, b"contents");+ } else if method == CAPABILITY_ROOTS_DISCOVER_METHOD {+ let discovery: CapabilityRootsDiscoverResponse =+ serde_json::from_value(response.result)?;+ assert_eq!(+ discovery.roots[0]+ .skills+ .iter()+ .map(|skill| &skill.instructions.path)+ .collect::<Vec<_>>(),+ vec![&cwd.join("skills/demo/SKILL.md")?],+ );+ }+ }+ }++ server.shutdown().await?;+ Ok(())+}++/// Old filesystem clients cannot replace the original cwd for rules whose meaning depends on it.+#[tokio::test]+async fn executor_legacy_filesystem_rejects_missing_cwd_for_dynamic_permissions()+-> anyhow::Result<()> {+ let workspace = tempfile::tempdir()?;+ let cwd = PathUri::from_host_native_path(workspace.path())?;+ let mut server = exec_server().await?;+ initialize(&mut server).await?;++ for path in [+ FileSystemPath::Special {+ value: FileSystemSpecialPath::ProjectRoots { subpath: None },+ },+ FileSystemPath::GlobPattern {+ pattern: "secrets/**".to_string(),+ },+ ] {+ let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry::new(+ path,+ FileSystemAccessMode::Deny,+ )]);+ let sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );+ for legacy_cwd in [None, Some(serde_json::Value::Null)] {+ let mut sandbox = serde_json::to_value(&sandbox)?;+ let fields = sandbox.as_object_mut().expect("sandbox object");+ if let Some(legacy_cwd) = legacy_cwd {+ fields.insert("cwd".to_string(), legacy_cwd);+ } else {+ fields.remove("cwd");+ }+ fields.remove("workspaceRoots");+ for (method, request) in [+ (+ FS_READ_FILE_METHOD,+ serde_json::json!({ "path": cwd, "sandbox": sandbox }),+ ),+ (+ FS_OPEN_METHOD,+ serde_json::json!({ "handleId": "denied", "path": cwd, "sandbox": sandbox }),+ ),+ (+ CAPABILITY_ROOTS_DISCOVER_METHOD,+ serde_json::json!({ "roots": [{ "id": "root", "path": cwd, "sandbox": sandbox }] }),+ ),+ ] {+ let request_id = server.send_request(method, request).await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Error(error) = response else {+ anyhow::bail!(+ "expected legacy {method} to reject dynamic permissions, got {response:?}"+ );+ };+ assert_eq!(+ (error.error.code, error.error.message.as_str()),+ (+ -32602,+ "file system sandbox context with dynamic permissions requires cwd"+ ),+ "{method}",+ );+ }+ }+ }++ server.shutdown().await?;+ Ok(())+}++/// Providing cwd lets project roots and relative rules be enforced against the original directory.+#[cfg(unix)]+#[tokio::test]+async fn executor_legacy_filesystem_accepts_cwd_for_dynamic_permissions() -> anyhow::Result<()> {+ let workspace = tempfile::tempdir()?;+ write_file(&workspace.path().join("allowed.txt"), "allowed")?;+ write_file(&workspace.path().join("secret.txt"), "secret")?;+ let cwd = PathUri::from_host_native_path(workspace.path())?;+ let policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::ProjectRoots { subpath: None },+ },+ FileSystemAccessMode::Write,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: "secret*".to_string(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );+ let mut server = exec_server().await?;+ initialize(&mut server).await?;+ let request_id = server+ .send_request(+ FS_READ_FILE_METHOD,+ serde_json::json!({"path": cwd.join("secret.txt")?}),+ )+ .await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Response(response) = response else {+ anyhow::bail!(+ "expected the denied path to be readable without a sandbox, got {response:?}"+ );+ };+ let read: FsReadFileResponse = serde_json::from_value(response.result)?;+ assert_eq!(STANDARD.decode(read.data_base64)?, b"secret");++ for (name, permitted) in [("allowed.txt", true), ("secret.txt", false)] {+ let request_id = server+ .send_request(+ FS_READ_FILE_METHOD,+ serde_json::json!({+ "path": cwd.join(name)?, "sandbox": sandbox,+ }),+ )+ .await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ match response {+ JSONRPCMessage::Response(response) if permitted => {+ let read: FsReadFileResponse = serde_json::from_value(response.result)?;+ assert_eq!(STANDARD.decode(read.data_base64)?, b"allowed");+ }+ JSONRPCMessage::Error(error) if !permitted => {+ assert_eq!(error.error.code, -32600, "{error:?}");+ assert!(+ matches!(+ error.error.message.as_str(),+ "Permission denied (os error 13)" | "Operation not permitted (os error 1)"+ ),+ "expected a filesystem permission denial: {error:?}"+ );+ }+ response => anyhow::bail!("unexpected filesystem result for {name}: {response:?}"),+ }+ }+ server.shutdown().await?;+ Ok(())+}++/// A present policy context can omit cwd: legacy cwd still anchors denials, and only static+/// filesystem policies can use the executor default when both cwd fields are absent.+#[tokio::test]+async fn executor_legacy_nested_policy_context_cwd_uses_available_fallbacks() -> anyhow::Result<()>+{+ let workspace = tempfile::tempdir()?;+ write_file(&workspace.path().join("allowed.txt"), "allowed")?;+ write_file(&workspace.path().join("secret.txt"), "secret")?;+ let cwd = PathUri::from_host_native_path(workspace.path())?;+ let static_permissions = if cfg!(unix) {+ PermissionProfile::read_only()+ } else {+ // The direct Windows test fixture has no enabled platform sandbox.+ PermissionProfile::Disabled+ };+ let static_sandbox =+ FileSystemSandboxContext::from_permission_profile(static_permissions, cwd.clone());+ let policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: "secret*".to_string(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let dynamic_sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );+ let mut server = exec_server().await?;+ initialize(&mut server).await?;++ for (shape, policy_context) in [+ ("missing", serde_json::json!({"workspaceRoots": [cwd]})),+ (+ "null",+ serde_json::json!({"cwd": null, "workspaceRoots": [cwd]}),+ ),+ ] {+ for (case, sandbox, legacy_cwd, name, expected) in [+ (+ "static allowed without legacy cwd",+ &static_sandbox,+ None::<&PathUri>,+ "allowed.txt",+ Ok(b"allowed".as_slice()),+ ),+ (+ "static secret without legacy cwd",+ &static_sandbox,+ None,+ "secret.txt",+ Ok(b"secret".as_slice()),+ ),+ (+ "dynamic without legacy cwd",+ &dynamic_sandbox,+ None,+ "allowed.txt",+ Err(-32602),+ ),+ // The default Windows test backend cannot enforce read denials at runtime.+ #[cfg(unix)]+ (+ "dynamic allowed with legacy cwd",+ &dynamic_sandbox,+ Some(&cwd),+ "allowed.txt",+ Ok(b"allowed".as_slice()),+ ),+ #[cfg(unix)]+ (+ "dynamic secret with legacy cwd",+ &dynamic_sandbox,+ Some(&cwd),+ "secret.txt",+ Err(-32600),+ ),+ ] {+ let mut sandbox = serde_json::to_value(sandbox)?;+ let fields = sandbox.as_object_mut().expect("sandbox object");+ fields.insert("policyContext".to_string(), policy_context.clone());+ if let Some(legacy_cwd) = legacy_cwd {+ fields.insert("cwd".to_string(), serde_json::to_value(legacy_cwd)?);+ } else {+ fields.remove("cwd");+ }+ fields.remove("workspaceRoots");+ let request_id = server+ .send_request(+ FS_READ_FILE_METHOD,+ serde_json::json!({"path": cwd.join(name)?, "sandbox": sandbox}),+ )+ .await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ match (response, expected) {+ (JSONRPCMessage::Response(response), Ok(contents)) => {+ let read: FsReadFileResponse = serde_json::from_value(response.result)?;+ assert_eq!(+ STANDARD.decode(read.data_base64)?,+ contents,+ "{shape}: {case}"+ );+ }+ (JSONRPCMessage::Error(error), Err(-32602)) => assert_eq!(+ (error.error.code, error.error.message.as_str()),+ (+ -32602,+ "file system sandbox context with dynamic permissions requires cwd"+ ),+ "{shape}: {case}",+ ),+ (JSONRPCMessage::Error(error), Err(-32600)) => {+ assert_eq!(error.error.code, -32600, "{shape}: {case}: {error:?}");+ assert!(+ matches!(+ error.error.message.as_str(),+ "Permission denied (os error 13)"+ | "Operation not permitted (os error 1)"+ ),+ "{shape}: {case}: {error:?}",+ );+ }+ (response, expected) => anyhow::bail!(+ "unexpected {shape} nested cwd result for {case}: expected {expected:?}, got {response:?}"+ ),+ }+ }+ }++ server.shutdown().await?;+ Ok(())+}++#[cfg(unix)]+#[tokio::test]+async fn executor_legacy_exec_uses_process_cwd_for_relative_denials() -> anyhow::Result<()> {+ let workspace = tempfile::tempdir()?;+ std::fs::write(workspace.path().join("allowed.txt"), b"allowed")?;+ std::fs::write(workspace.path().join("secret.txt"), b"secret")?;+ let cwd = PathUri::from_host_native_path(workspace.path())?;+ let policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: "secret*".to_string(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );+ let process_env =+ std::collections::HashMap::from([("PATH".to_string(), std::env::var("PATH")?)]);+ #[cfg(target_os = "linux")]+ let process_env = {+ let mut process_env = process_env;+ // Bazel-provided bubblewrap lives in runfiles, not necessarily on the process PATH.+ for name in [+ "CARGO_BIN_EXE_bwrap",+ "RUNFILES_DIR",+ "RUNFILES_MANIFEST_FILE",+ "TEST_SRCDIR",+ "TEST_WORKSPACE",+ ] {+ if let Ok(value) = std::env::var(name) {+ process_env.insert(name.to_string(), value);+ }+ }+ process_env+ };+ let mut server = exec_server().await?;+ initialize(&mut server).await?;+ for (index, legacy_cwd) in [None, Some(serde_json::Value::Null)]+ .into_iter()+ .enumerate()+ {+ let mut sandbox = serde_json::to_value(&sandbox)?;+ let fields = sandbox.as_object_mut().expect("sandbox object");+ if let Some(legacy_cwd) = legacy_cwd {+ fields.insert("cwd".to_string(), legacy_cwd);+ } else {+ fields.remove("cwd");+ }+ let process = format!("legacy-relative-{index}");+ let request_id = server.send_request(EXEC_METHOD, serde_json::json!({+ "processId": process, "argv": ["/bin/sh", "-c", "cat allowed.txt && if cat secret.txt 2>/dev/null; then exit 9; fi"], "cwd": cwd,+ "env": process_env, "tty": false, "sandbox": sandbox,+ })).await?;+ let start = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ if !matches!(start, JSONRPCMessage::Response(_)) {+ anyhow::bail!("expected legacy process to start, got {start:?}");+ }+ let mut after_seq = None;+ let mut output = Vec::new();+ let (exit_code, failure, sandbox_denied) = loop {+ let request_id = server+ .send_request(+ EXEC_READ_METHOD,+ serde_json::json!({+ "processId": process, "afterSeq": after_seq, "waitMs": 1000,+ }),+ )+ .await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Response(response) = response else {+ anyhow::bail!("expected legacy process output, got {response:?}");+ };+ let response: ReadResponse = serde_json::from_value(response.result)?;+ output.extend(response.chunks.into_iter().flat_map(|chunk| chunk.chunk.0));+ after_seq = response.next_seq.checked_sub(1).or(after_seq);+ if response.closed {+ break (+ response.exit_code,+ response.failure,+ response.sandbox_denied,+ );+ }+ };+ assert_eq!(+ (exit_code, String::from_utf8(output)?),+ (Some(0), "allowed".to_string()),+ "legacy process failed: {failure:?}; sandbox denied: {sandbox_denied}"+ );+ }+ server.shutdown().await?;+ Ok(())+}++#[cfg(unix)]+#[tokio::test]+async fn executor_legacy_filesystem_cwd_keeps_absolute_read_allow_and_deny_rules()+-> anyhow::Result<()> {+ let workspace = tempfile::tempdir()?;+ let allowed = workspace.path().join("allowed");+ let denied = workspace.path().join("denied");+ for (root, name) in [(&allowed, "allowed"), (&denied, "denied")] {+ write_file(&root.join("note.txt"), "contents")?;+ write_file(+ &root.join(format!("skills/{name}/SKILL.md")),+ &format!("---\nname: {name}\ndescription: {name}.\n---\n"),+ )?;+ }+ let allowed = PathUri::from_host_native_path(allowed)?;+ let denied = PathUri::from_host_native_path(denied)?;+ let policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Path {+ path: denied.clone(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ PathUri::from_host_native_path(workspace.path())?,+ );+ let mut server = exec_server().await?;+ initialize(&mut server).await?;++ let request_id = server+ .send_request(+ FS_READ_FILE_METHOD,+ serde_json::json!({"path": denied.join("note.txt")?}),+ )+ .await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Response(response) = response else {+ anyhow::bail!(+ "expected the denied path to be readable without a sandbox, got {response:?}"+ );+ };+ let read: FsReadFileResponse = serde_json::from_value(response.result)?;+ assert_eq!(STANDARD.decode(read.data_base64)?, b"contents");++ for (index, legacy_cwd) in [None, Some(serde_json::Value::Null)]+ .into_iter()+ .enumerate()+ {+ let mut sandbox = serde_json::to_value(&sandbox)?;+ let fields = sandbox.as_object_mut().expect("sandbox object");+ if let Some(legacy_cwd) = legacy_cwd {+ fields.insert("cwd".to_string(), legacy_cwd);+ } else {+ fields.remove("cwd");+ }+ fields.remove("workspaceRoots");+ for (root, permitted) in [(&allowed, true), (&denied, false)] {+ let handle = format!("legacy-{index}-{permitted}");+ for (method, request) in [+ (+ FS_READ_FILE_METHOD,+ serde_json::json!({ "path": root.join("note.txt")?, "sandbox": sandbox }),+ ),+ (+ FS_OPEN_METHOD,+ serde_json::json!({ "handleId": handle, "path": root.join("note.txt")?, "sandbox": sandbox }),+ ),+ ] {+ let request_id = server.send_request(method, request).await?;+ let response = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ match response {+ JSONRPCMessage::Response(response) if permitted => {+ if method == FS_READ_FILE_METHOD {+ let read: FsReadFileResponse = serde_json::from_value(response.result)?;+ assert_eq!(STANDARD.decode(read.data_base64)?, b"contents");+ } else {+ let request_id = server.send_request(FS_READ_BLOCK_METHOD, serde_json::json!({ "handleId": handle, "offset": 0, "len": 16 })).await?;+ let block = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_)+ | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Response(block) = block else {+ anyhow::bail!("expected to read the legacy stream, got {block:?}");+ };+ let block: FsReadBlockResponse = serde_json::from_value(block.result)?;+ assert_eq!(block.chunk.0, b"contents");+ }+ }+ JSONRPCMessage::Error(error) if !permitted => {+ assert_eq!(error.error.code, -32600, "{method}: {error:?}");+ assert!(+ matches!(+ error.error.message.as_str(),+ "Permission denied (os error 13)"+ | "Operation not permitted (os error 1)"+ ),+ "expected a filesystem permission denial for {method}: {error:?}"+ );+ }+ response => {+ anyhow::bail!("unexpected legacy {method} result for {root}: {response:?}")+ }+ }+ }+ }+ let request_id = server+ .send_request(+ CAPABILITY_ROOTS_DISCOVER_METHOD,+ serde_json::json!({ "roots": [+ { "id": "allowed", "path": allowed, "sandbox": sandbox },+ { "id": "denied", "path": denied, "sandbox": sandbox },+ ] }),+ )+ .await?;+ let discovery = server+ .wait_for_event(|event| match event {+ JSONRPCMessage::Response(response) => response.id == request_id,+ JSONRPCMessage::Error(error) => error.id == request_id,+ JSONRPCMessage::Request(_) | JSONRPCMessage::Notification(_) => false,+ })+ .await?;+ let JSONRPCMessage::Response(discovery) = discovery else {+ anyhow::bail!("expected legacy capability discovery, got {discovery:?}");+ };+ let discovery: CapabilityRootsDiscoverResponse = serde_json::from_value(discovery.result)?;+ assert_eq!(+ discovery+ .roots+ .iter()+ .map(|root| (+ root.id.as_str(),+ root.skills+ .iter()+ .map(|skill| &skill.instructions.path)+ .collect::<Vec<_>>()+ ))+ .collect::<Vec<_>>(),+ vec![+ ("allowed", vec![&allowed.join("skills/allowed/SKILL.md")?]),+ ("denied", vec![]),+ ]+ );+ }++ server.shutdown().await?;+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn sandboxed_discovery_batches_roots_without_combining_different_permissions()-> anyhow::Result<()> {@@ -208,7 +933,7 @@ async fn sandboxed_discovery_batches_roots_without_combining_different_permissioFileSystemAccessMode::Read,);let policy = FileSystemSandboxPolicy::restricted(vec![read_workspace]);- let shared_sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let shared_sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),workspace_uri,);@@ -328,7 +1053,7 @@ async fn sandboxed_discovery_batches_roots_without_combining_different_permissioFileSystemAccessMode::Read,);let first_policy = FileSystemSandboxPolicy::restricted(vec![read_first_root]);- let first_only_sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let first_only_sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&first_policy,NetworkSandboxPolicy::Restricted,@@ -341,7 +1066,7 @@ async fn sandboxed_discovery_batches_roots_without_combining_different_permissioFileSystemAccessMode::Read,);let second_policy = FileSystemSandboxPolicy::restricted(vec![read_second_root]);- let second_only_sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let second_only_sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&second_policy,NetworkSandboxPolicy::Restricted,@@ -441,7 +1166,7 @@ async fn sandboxed_discovery_follows_only_permitted_external_symlinks() -> anyhofor (scenario, entries, has_skill, has_mcp) in cases {let policy = FileSystemSandboxPolicy::restricted(entries);- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),root_uri.clone(),);diff --git a/codex-rs/exec-server/tests/exec_process.rs b/codex-rs/exec-server/tests/exec_process.rsindex b4e861d50b..095cbe25e1 100644--- a/codex-rs/exec-server/tests/exec_process.rs+++ b/codex-rs/exec-server/tests/exec_process.rs@@ -140,7 +140,7 @@ async fn codex_home_symlink_opt_out_respects_host_config_and_scope() -> Result<(PathUri::from_host_native_path(root)?.into(),FileSystemAccessMode::Write,));- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy,NetworkSandboxPolicy::Restricted,@@ -345,7 +345,7 @@ async fn shell_snapshot_v2_filters_profile_exports_and_stays_in_memory(pipe_stdin: false,arg0: (shell_name == "bash-sh").then(|| "sh".to_string()),sandbox: (use_sandbox && attempt == 0).then(|| {- FileSystemSandboxContext::from_permission_profile_with_cwd(+ FileSystemSandboxContext::from_permission_profile(PermissionProfile::read_only(),cwd.clone(),)@@ -522,7 +522,7 @@ async fn shell_snapshot_v2_capture_failure_falls_back_and_retries(pipe_stdin: false,arg0: None,sandbox: use_remote.then(|| {- FileSystemSandboxContext::from_permission_profile_with_cwd(+ FileSystemSandboxContext::from_permission_profile(PermissionProfile::workspace_write(),cwd,)@@ -603,7 +603,7 @@ async fn remote_sandboxed_process_preserves_custom_arg0() -> Result<()> {missing_path_behavior: None,},]);- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),cwd.clone(),);@@ -706,7 +706,7 @@ async fn remote_process_keeps_sandbox_helper_visible_with_restricted_reads() ->missing_path_behavior: None,},]);- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),cwd.clone(),);@@ -777,7 +777,7 @@ async fn remote_tty_process_uses_configured_sandbox_helper_with_hostile_path() -missing_path_behavior: None,},]);- let sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),cwd.clone(),);@@ -833,7 +833,7 @@ async fn remote_process_preserves_empty_workspace_roots() -> Result<()> {access: FileSystemAccessMode::Read,missing_path_behavior: None,}]);- let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),cwd.clone(),);diff --git a/codex-rs/exec-server/tests/exec_process/windows_sandbox.rs b/codex-rs/exec-server/tests/exec_process/windows_sandbox.rsindex f7e725ff9e..d001687a93 100644--- a/codex-rs/exec-server/tests/exec_process/windows_sandbox.rs+++ b/codex-rs/exec-server/tests/exec_process/windows_sandbox.rs@@ -46,7 +46,7 @@ async fn mxc_tmpdir_uses_command_environment_over_rpc() -> Result<()> {FileSystemAccessMode::Write,),]);- let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted),cwd.clone(),);diff --git a/codex-rs/exec-server/tests/file_stream.rs b/codex-rs/exec-server/tests/file_stream.rsindex 9fd3201eeb..5de1b56991 100644--- a/codex-rs/exec-server/tests/file_stream.rs+++ b/codex-rs/exec-server/tests/file_stream.rs@@ -373,12 +373,14 @@ fn read_only_sandbox(path: std::path::PathBuf) -> codex_exec_server::FileSystemSlet path = AbsolutePathBuf::from_absolute_path(&path).unwrap_or_else(|err| panic!("sandbox path should be absolute: {err}"));- FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(+ let cwd = PathUri::from_abs_path(&path);+ let permissions = PermissionProfile::from_runtime_permissions(&FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {path: path.into(),access: FileSystemAccessMode::Read,missing_path_behavior: None,}]),NetworkSandboxPolicy::Restricted,- ))+ );+ FileSystemSandboxContext::from_permission_profile(permissions, cwd)}diff --git a/codex-rs/exec-server/tests/file_system/shared.rs b/codex-rs/exec-server/tests/file_system/shared.rsindex 96dfa14349..928d65cd7a 100644--- a/codex-rs/exec-server/tests/file_system/shared.rs+++ b/codex-rs/exec-server/tests/file_system/shared.rs@@ -48,8 +48,7 @@ fn sandbox_context_from_profile_preserves_workspace_write_read_only_subpaths() -std::fs::create_dir_all(&git_dir)?;let sandbox = workspace_write_sandbox(writable_dir.clone());- let permissions: PermissionProfile = sandbox.permissions.try_into()?;- let policy = permissions.file_system_sandbox_policy();+ let policy = sandbox.permissions.file_system_sandbox_policy();let cwd = absolute_path(writable_dir.clone());let writable_roots = policy.get_writable_roots_with_cwd(cwd.as_path());let writable_dir = absolute_path(std::fs::canonicalize(writable_dir)?);@@ -1080,21 +1079,20 @@ async fn file_system_sandboxed_write_allows_additional_write_root(Some(vec![absolute_path(writable_dir)]),)),};- let native_permissions: PermissionProfile = sandbox.permissions.clone().try_into()?;+ let permissions = &sandbox.permissions;let file_system_policy = effective_file_system_sandbox_policy(- &native_permissions.file_system_sandbox_policy(),+ &permissions.file_system_sandbox_policy(),Some(&additional_permissions),);let network_policy = effective_network_sandbox_policy(- native_permissions.network_sandbox_policy(),+ permissions.network_sandbox_policy(),Some(&additional_permissions),);sandbox.permissions = PermissionProfile::from_runtime_permissions_with_enforcement(- native_permissions.enforcement(),+ permissions.enforcement(),&file_system_policy,network_policy,- )- .into();+ );file_system.write_file(diff --git a/codex-rs/exec-server/tests/file_system/support.rs b/codex-rs/exec-server/tests/file_system/support.rsindex 34125c24ae..4db701d29e 100644--- a/codex-rs/exec-server/tests/file_system/support.rs+++ b/codex-rs/exec-server/tests/file_system/support.rs@@ -16,7 +16,6 @@ use codex_protocol::permissions::FileSystemSandboxPolicy;use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_utils_absolute_path::AbsolutePathBuf;-#[cfg(windows)]use codex_utils_path_uri::PathUri;use crate::common::exec_server::ExecServerHarness;@@ -93,13 +92,15 @@ pub(crate) fn absolute_path(path: std::path::PathBuf) -> AbsolutePathBuf {pub(crate) fn read_only_sandbox(readable_root: std::path::PathBuf) -> FileSystemSandboxContext {let readable_root = absolute_path(readable_root);- sandbox_context(vec![FileSystemSandboxEntry {+ let cwd = PathUri::from_abs_path(&readable_root);+ let entries = vec![FileSystemSandboxEntry {path: FileSystemPath::Path {path: readable_root.into(),},access: FileSystemAccessMode::Read,missing_path_behavior: None,- }])+ }];+ sandbox_context(entries, cwd)}#[cfg(not(windows))]@@ -107,13 +108,15 @@ pub(crate) fn workspace_write_sandbox(writable_root: std::path::PathBuf,) -> FileSystemSandboxContext {let writable_root = absolute_path(writable_root);- sandbox_context(vec![FileSystemSandboxEntry {+ let cwd = PathUri::from_abs_path(&writable_root);+ let entries = vec![FileSystemSandboxEntry {path: FileSystemPath::Path {path: writable_root.into(),},access: FileSystemAccessMode::Write,missing_path_behavior: None,- }])+ }];+ sandbox_context(entries, cwd)}#[cfg(windows)]@@ -137,7 +140,7 @@ pub(crate) fn workspace_write_sandbox(FileSystemAccessMode::Write,),]);- let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),PathUri::from_abs_path(&writable_root),);@@ -145,7 +148,10 @@ pub(crate) fn workspace_write_sandbox(sandbox}-fn sandbox_context(mut entries: Vec<FileSystemSandboxEntry>) -> FileSystemSandboxContext {+fn sandbox_context(+ mut entries: Vec<FileSystemSandboxEntry>,+ cwd: PathUri,+) -> FileSystemSandboxContext {if cfg!(windows) {// Restricted-token sandboxing cannot enforce read restrictions, so leave the root// readable while exercising the requested write restrictions.@@ -161,6 +167,7 @@ fn sandbox_context(mut entries: Vec<FileSystemSandboxEntry>) -> FileSystemSandbo&FileSystemSandboxPolicy::restricted(entries),NetworkSandboxPolicy::Restricted,),+ cwd,);if cfg!(windows) {sandbox.windows_sandbox_selection = WindowsSandboxSelection::RestrictedToken;diff --git a/codex-rs/exec-server/tests/file_system_unix.rs b/codex-rs/exec-server/tests/file_system_unix.rsindex 4b5615611f..6e45cd2dfc 100644--- a/codex-rs/exec-server/tests/file_system_unix.rs+++ b/codex-rs/exec-server/tests/file_system_unix.rs@@ -588,7 +588,7 @@ async fn remote_read_file_materializes_environment_workspace_roots() -> Result<(access: FileSystemAccessMode::Read,missing_path_behavior: None,}]);- let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),PathUri::from_host_native_path(tmp.path())?,);@@ -632,7 +632,7 @@ async fn remote_read_file_preserves_empty_workspace_roots() -> Result<()> {access: FileSystemAccessMode::Read,missing_path_behavior: None,}]);- let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),PathUri::from_host_native_path(tmp.path())?,);diff --git a/codex-rs/exec-server/tests/file_system_windows.rs b/codex-rs/exec-server/tests/file_system_windows.rsindex 7fe9df0f8e..7bc41bfe7c 100644--- a/codex-rs/exec-server/tests/file_system_windows.rs+++ b/codex-rs/exec-server/tests/file_system_windows.rs@@ -14,6 +14,7 @@ use std::path::Path;use std::process::Command;use std::time::Duration;+use anyhow::Context as _;use anyhow::Result;use codex_exec_server::CreateDirectoryOptions;use codex_exec_server::FileSystemSandboxContext;@@ -22,6 +23,13 @@ use codex_exec_server::ReadFileOptions;use codex_exec_server::RemoveOptions;use codex_exec_server::WindowsSandboxSelection;use codex_exec_server::WriteFileOptions;+use codex_protocol::models::PermissionProfile;+use codex_protocol::permissions::FileSystemAccessMode;+use codex_protocol::permissions::FileSystemPath;+use codex_protocol::permissions::FileSystemSandboxEntry;+use codex_protocol::permissions::FileSystemSandboxPolicy;+use codex_protocol::permissions::FileSystemSpecialPath;+use codex_protocol::permissions::NetworkSandboxPolicy;use codex_protocol::protocol::SandboxPolicy;use codex_sandboxing::SandboxType;use codex_utils_path_uri::PathUri;@@ -430,6 +438,118 @@ async fn file_system_remote_fs_helper_respects_windows_sandbox_write_policy(Ok(())}+/// An elevated filesystem helper must enforce relative deny globs from the policy cwd.+#[test_case(FileSystemImplementation::Local ; "local")]+#[test_case(FileSystemImplementation::Remote ; "remote")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+#[serial_test::serial(remote_exec_server)]+async fn file_system_elevated_relative_read_denial_uses_policy_cwd(+ implementation: FileSystemImplementation,+) -> Result<()> {+ // Both implementations re-enter this test binary; the elevated backend finds its helpers+ // next to that binary, while Cargo and Bazel provide them separately.+ let test_exe = std::env::current_exe()?;+ let resources = test_exe+ .parent()+ .context("Windows test executable should have a parent directory")?+ .join("codex-resources");+ if let Err(error) = std::fs::create_dir_all(&resources)+ && !(error.kind() == std::io::ErrorKind::PermissionDenied && resources.is_dir())+ {+ return Err(error).context("create Windows sandbox test resources");+ }+ for name in ["codex-windows-sandbox-setup", "codex-command-runner"] {+ let source = codex_utils_cargo_bin::cargo_bin(name)?;+ let destination = resources.join(Path::new(name).with_extension("exe"));+ if let Err(error) = std::fs::copy(&source, &destination)+ && !(error.kind() == std::io::ErrorKind::PermissionDenied && destination.is_file())+ {+ return Err(error).with_context(|| format!("stage Windows sandbox helper {name}"));+ }+ }+ let context = create_file_system_context(implementation).await?;+ let tmp = tempfile::TempDir::new()?;+ let policy_cwd = tmp.path().join("checkout");+ let selected_files = policy_cwd.join("files");+ let other_files = tmp.path().join("files");+ std::fs::create_dir_all(&selected_files)?;+ std::fs::create_dir(&other_files)?;+ let allowed_neighbor = selected_files.join("allowed.txt");+ let denied = selected_files.join("blocked.env");+ let same_name_outside = other_files.join("blocked.env");+ std::fs::write(&allowed_neighbor, b"allowed neighbor")?;+ std::fs::write(&denied, b"denied")?;+ std::fs::write(&same_name_outside, b"allowed outside")?;++ let cwd = PathUri::from_host_native_path(&policy_cwd)?;+ let policy = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Path {+ path: PathUri::from_host_native_path(tmp.path())?,+ },+ FileSystemAccessMode::Write,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: "files/*.env".to_string(),+ },+ FileSystemAccessMode::Deny,+ ),+ ]);+ let mut sandbox = FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted),+ cwd,+ );+ sandbox.windows_sandbox_selection = WindowsSandboxSelection::Elevated;++ let file_system = &context.file_system;+ let allowed_neighbor = file_system+ .read_file(+ &PathUri::from_host_native_path(&allowed_neighbor)?,+ ReadFileOptions::default(),+ Some(&sandbox),+ )+ .await?;+ let same_name_outside = file_system+ .read_file(+ &PathUri::from_host_native_path(&same_name_outside)?,+ ReadFileOptions::default(),+ Some(&sandbox),+ )+ .await?;+ let denied = file_system+ .read_file(+ &PathUri::from_host_native_path(&denied)?,+ ReadFileOptions::default(),+ Some(&sandbox),+ )+ .await+ .expect_err("read matching the policy-cwd denial must be rejected");+ assert_eq!(+ (+ allowed_neighbor.as_slice(),+ same_name_outside.as_slice(),+ denied.kind(),+ ),+ (+ b"allowed neighbor".as_slice(),+ b"allowed outside".as_slice(),+ std::io::ErrorKind::InvalidInput,+ )+ );+ assert!(+ denied.to_string().contains("Access is denied"),+ "expected Windows access denial, got: {denied}"+ );+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn file_system_private_desktop_survives_helper_exits_and_separates_permissions() -> 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 1f0f0e6ae6..ffdedc6e2f 100644--- a/codex-rs/ext/skills/tests/executor_file_system_authority.rs+++ b/codex-rs/ext/skills/tests/executor_file_system_authority.rs@@ -312,6 +312,7 @@ async fn windows_executor_skill_read_requires_a_requested_sandbox() {&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",@@ -978,7 +979,10 @@ async fn high_level_discovery_cache_separates_filesystem_permission_contexts() {.expect("update executor skill");let sandbox_contexts = HashMap::from([("local".to_string(),- FileSystemSandboxContext::from_permission_profile(PermissionProfile::Disabled),+ FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::Disabled,+ PathUri::from_host_native_path(&test_root).expect("skill root URI"),+ ),)]);let second_snapshot = cache.snapshot(&executor_roots, &sandbox_contexts).await;let second_discovery = second_snapshot.roots()[0]diff --git a/codex-rs/file-system/src/exec_permission_profile_serde.rs b/codex-rs/file-system/src/exec_permission_profile_serde.rsnew file mode 100644index 0000000000..f0f29896b3--- /dev/null+++ b/codex-rs/file-system/src/exec_permission_profile_serde.rs@@ -0,0 +1,22 @@+//! Uses executor file URIs for sandbox permissions instead of the profile's legacy native paths.++use crate::ExecPermissionProfile;+use codex_protocol::models::PermissionProfile;+use serde::Deserialize;+use serde::Deserializer;+use serde::Serialize;+use serde::Serializer;++pub(crate) fn serialize<S>(value: &PermissionProfile, serializer: S) -> Result<S::Ok, S::Error>+where+ S: Serializer,+{+ ExecPermissionProfile::from(value.clone()).serialize(serializer)+}++pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<PermissionProfile, D::Error>+where+ D: Deserializer<'de>,+{+ ExecPermissionProfile::deserialize(deserializer).map(PermissionProfile::from)+}diff --git a/codex-rs/file-system/src/lib.rs b/codex-rs/file-system/src/lib.rsindex ba825c5ce8..0abe9dba3d 100644--- a/codex-rs/file-system/src/lib.rs+++ b/codex-rs/file-system/src/lib.rs@@ -1,3 +1,4 @@+mod exec_permission_profile_serde;mod find_up;use bytes::Bytes;@@ -16,6 +17,7 @@ use codex_protocol::permissions::FileSystemSandboxPolicyContext;use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_protocol::protocol::SandboxPolicy;+use codex_utils_path_uri::LegacyAppPathString;use codex_utils_path_uri::PathUri;pub use find_up::FindUpErrorPolicy;pub use find_up::find_nearest_ancestor_with_markers;@@ -187,18 +189,13 @@ impl From<FileSystemPath> for ExecFileSystemPath {}}-impl TryFrom<ExecFileSystemPath> for FileSystemPath {- type Error = io::Error;-- fn try_from(value: ExecFileSystemPath) -> Result<Self, Self::Error> {- Ok(match value {- ExecFileSystemPath::Path { path } => {- path.to_abs_path()?;- Self::Path { path }- }+impl From<ExecFileSystemPath> for FileSystemPath {+ fn from(value: ExecFileSystemPath) -> Self {+ match value {+ ExecFileSystemPath::Path { path } => Self::Path { path },ExecFileSystemPath::GlobPattern { pattern } => Self::GlobPattern { pattern },ExecFileSystemPath::Special { value } => Self::Special { value },- })+ }}}@@ -220,15 +217,13 @@ impl From<FileSystemSandboxEntry> for ExecFileSystemSandboxEntry {}}-impl TryFrom<ExecFileSystemSandboxEntry> for FileSystemSandboxEntry {- type Error = io::Error;-- fn try_from(value: ExecFileSystemSandboxEntry) -> Result<Self, Self::Error> {- Ok(Self {- path: value.path.try_into()?,+impl From<ExecFileSystemSandboxEntry> for FileSystemSandboxEntry {+ fn from(value: ExecFileSystemSandboxEntry) -> Self {+ Self {+ path: value.path.into(),access: value.access,missing_path_behavior: value.missing_path_behavior,- })+ }}}@@ -258,26 +253,22 @@ impl From<ManagedFileSystemPermissions> for ExecManagedFileSystemPermissions {}}-impl TryFrom<ExecManagedFileSystemPermissions> for ManagedFileSystemPermissions {- type Error = io::Error;-- fn try_from(value: ExecManagedFileSystemPermissions) -> Result<Self, Self::Error> {- Ok(match value {+impl From<ExecManagedFileSystemPermissions> for ManagedFileSystemPermissions {+ fn from(value: ExecManagedFileSystemPermissions) -> Self {+ match value {ExecManagedFileSystemPermissions::Restricted {entries,glob_scan_max_depth,} => Self::Restricted {- entries: entries- .into_iter()- .map(TryInto::try_into)- .collect::<io::Result<_>>()?,+ entries: entries.into_iter().map(Into::into).collect(),glob_scan_max_depth,},ExecManagedFileSystemPermissions::Unrestricted => Self::Unrestricted,- })+ }}}+/// Executor permission profile whose explicit filesystem paths serialize as file URIs.#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]#[serde(tag = "type", rename_all = "snake_case")]pub enum ExecPermissionProfile {@@ -307,21 +298,19 @@ impl From<PermissionProfile> for ExecPermissionProfile {}}-impl TryFrom<ExecPermissionProfile> for PermissionProfile {- type Error = io::Error;-- fn try_from(value: ExecPermissionProfile) -> Result<Self, Self::Error> {- Ok(match value {+impl From<ExecPermissionProfile> for PermissionProfile {+ fn from(value: ExecPermissionProfile) -> Self {+ match value {ExecPermissionProfile::Managed {file_system,network,} => Self::Managed {- file_system: file_system.try_into()?,+ file_system: file_system.into(),network,},ExecPermissionProfile::Disabled => Self::Disabled,ExecPermissionProfile::External { network } => Self::External { network },- })+ }}}@@ -349,12 +338,16 @@ impl From<WindowsSandboxLevel> for WindowsSandboxSelection {}}+/// Filesystem sandbox policy and the selected executor paths needed to interpret it.#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct FileSystemSandboxContext {- pub permissions: ExecPermissionProfile,- #[serde(default, skip_serializing_if = "Option::is_none")]- pub cwd: Option<PathUri>,+ /// Serializes paths as executor file URIs instead of the profile's default native paths.+ #[serde(with = "exec_permission_profile_serde")]+ pub permissions: PermissionProfile,+ /// Working directory on the selected executor used to interpret sandbox permissions.+ /// Required even for absolute permissions; a process may use a different working directory.+ pub cwd: PathUri,#[serde(default, skip_serializing_if = "Vec::is_empty")]pub workspace_roots: Vec<PathUri>,/// Executor-local user home used to resolve home-relative policy paths.@@ -391,23 +384,14 @@ impl FileSystemSandboxContext {&file_system_sandbox_policy,NetworkSandboxPolicy::from(&sandbox_policy),);- Ok(Self::from_permission_profile_with_cwd(permissions, cwd))- }-- pub fn from_permission_profile(permissions: PermissionProfile) -> Self {- Self::from_permissions_and_cwd(permissions, /*cwd*/ None)+ Ok(Self::from_permission_profile(permissions, cwd))}- pub fn from_permission_profile_with_cwd(permissions: PermissionProfile, cwd: PathUri) -> Self {- Self::from_permissions_and_cwd(permissions, Some(cwd))- }-- fn from_permissions_and_cwd(permissions: PermissionProfile, cwd: Option<PathUri>) -> Self {- let workspace_roots = cwd.iter().cloned().collect();+ pub fn from_permission_profile(permissions: PermissionProfile, cwd: PathUri) -> Self {Self {- permissions: permissions.into(),+ permissions,+ workspace_roots: vec![cwd.clone()],cwd,- workspace_roots,user_home_dir: None,temporary_directories: None,windows_sandbox_selection: WindowsSandboxSelection::Disabled,@@ -418,11 +402,11 @@ impl FileSystemSandboxContext {}pub fn should_run_in_sandbox(&self) -> bool {- let Ok(permissions) = PermissionProfile::try_from(self.permissions.clone()) else {+ if self.validate_file_system_paths_for_current_host().is_err() {// A sandbox context for another host must not select the unsandboxed filesystem.return true;- };- let file_system_policy = permissions.file_system_sandbox_policy();+ }+ let file_system_policy = self.permissions.file_system_sandbox_policy();matches!(file_system_policy.kind, FileSystemSandboxKind::Restricted)&& !file_system_policy.has_full_disk_write_access()}@@ -432,25 +416,101 @@ impl FileSystemSandboxContext {self.windows_sandbox_selection != WindowsSandboxSelection::Disabled}+ /// Checks that explicit permission paths can be enforced by the current host. An+ /// orchestrator can still construct this context with paths belonging to another executor.+ pub fn validate_file_system_paths_for_current_host(&self) -> io::Result<()> {+ if let PermissionProfile::Managed {+ file_system: ManagedFileSystemPermissions::Restricted { entries, .. },+ ..+ } = &self.permissions+ {+ for entry in entries {+ if let FileSystemPath::Path { path } = &entry.path {+ path.to_abs_path().map_err(|error| {+ io::Error::new(+ error.kind(),+ format!("invalid sandbox permission path URI: {error}"),+ )+ })?;+ }+ }+ }+ Ok(())+ }+/// Borrows the executor-owned paths needed to interpret filesystem policy entries.- ///- /// Returns `None` after the cwd has been omitted from a transport context.- pub fn policy_context(&self) -> Option<FileSystemSandboxPolicyContext<'_>> {- Some(FileSystemSandboxPolicyContext {- cwd: self.cwd.as_ref()?,+ pub fn policy_context(&self) -> FileSystemSandboxPolicyContext<'_> {+ FileSystemSandboxPolicyContext {+ cwd: &self.cwd,workspace_roots: &self.workspace_roots,user_home_dir: self.user_home_dir.as_ref(),temporary_directories: self.temporary_directories.as_deref(),- })+ }}+}- pub fn has_cwd_dependent_permissions(&self) -> bool {- match &self.permissions {+/// Filesystem RPC wire context; older clients can omit the policy cwd before executor resolution.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct WireFileSystemSandboxContext {+ permissions: ExecPermissionProfile,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ cwd: Option<PathUri>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ policy_context: Option<WireFileSystemPolicyContext>,+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ workspace_roots: Vec<PathUri>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ user_home_dir: Option<PathUri>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ temporary_directories: Option<Vec<PathUri>>,+ #[serde(rename = "windowsSandboxLevel")]+ windows_sandbox_selection: WindowsSandboxSelection,+ #[serde(default)]+ windows_sandbox_private_desktop: bool,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ windows_sandbox_proxy_settings_mode: Option<WindowsSandboxProxySettingsMode>,+ #[serde(default)]+ use_legacy_landlock: bool,+}++/// New filesystem clients provide these paths independently of the legacy helper launch cwd.+#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+struct WireFileSystemPolicyContext {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ cwd: Option<PathUri>,+ #[serde(default)]+ workspace_roots: Vec<PathUri>,+}++impl From<FileSystemSandboxContext> for WireFileSystemSandboxContext {+ fn from(sandbox: FileSystemSandboxContext) -> Self {+ let FileSystemSandboxContext {+ permissions,+ cwd,+ workspace_roots,+ user_home_dir,+ temporary_directories,+ windows_sandbox_selection,+ windows_sandbox_private_desktop,+ windows_sandbox_proxy_settings_mode,+ use_legacy_landlock,+ } = sandbox;+ let permissions = ExecPermissionProfile::from(permissions);+ // Older filesystem clients sent cwd and roots only when permissions needed them; old+ // executors also use that cwd to launch their helper. The explicit context is independent.+ let legacy_needs_cwd = match &permissions {ExecPermissionProfile::Managed {file_system: ExecManagedFileSystemPermissions::Restricted { entries, .. },..} => entries.iter().any(|entry| match &entry.path {- ExecFileSystemPath::GlobPattern { pattern } => !Path::new(pattern).is_absolute(),+ ExecFileSystemPath::GlobPattern { pattern } => match cwd.infer_path_convention() {+ Some(convention) => LegacyAppPathString::from_string(pattern)+ .to_path_uri(convention)+ .is_err(),+ None => true,+ },ExecFileSystemPath::Special {value: FileSystemSpecialPath::ProjectRoots { .. },} => true,@@ -462,15 +522,73 @@ impl FileSystemSandboxContext {}| ExecPermissionProfile::Disabled| ExecPermissionProfile::External { .. } => false,+ };+ Self {+ permissions,+ cwd: legacy_needs_cwd.then(|| cwd.clone()),+ workspace_roots: if legacy_needs_cwd {+ workspace_roots.clone()+ } else {+ Vec::new()+ },+ policy_context: Some(WireFileSystemPolicyContext {+ cwd: Some(cwd),+ workspace_roots,+ }),+ user_home_dir,+ temporary_directories,+ windows_sandbox_selection,+ windows_sandbox_private_desktop,+ windows_sandbox_proxy_settings_mode,+ use_legacy_landlock,}}+}- pub fn drop_cwd_if_unused(mut self) -> Self {- if !self.has_cwd_dependent_permissions() {- self.cwd = None;- self.workspace_roots.clear();+impl WireFileSystemSandboxContext {+ /// Returns the policy cwd supplied by the client, falling back to the legacy cwd field.+ pub fn cwd(&self) -> Option<&PathUri> {+ match &self.policy_context {+ Some(policy_context) => policy_context.cwd.as_ref().or(self.cwd.as_ref()),+ None => self.cwd.as_ref(),+ }+ }++ /// Returns whether a legacy filesystem policy needs the client's cwd to be interpreted.+ pub fn requires_cwd(&self) -> bool {+ let ExecPermissionProfile::Managed {+ file_system: ExecManagedFileSystemPermissions::Restricted { entries, .. },+ ..+ } = &self.permissions+ else {+ return false;+ };++ entries.iter().any(|entry| match &entry.path {+ ExecFileSystemPath::GlobPattern { pattern } => !Path::new(pattern).is_absolute(),+ ExecFileSystemPath::Special {+ value: FileSystemSpecialPath::ProjectRoots { .. },+ } => true,+ ExecFileSystemPath::Path { .. } | ExecFileSystemPath::Special { .. } => false,+ })+ }++ /// Constructs the strict context after executor ingress has resolved the policy cwd.+ pub fn into_context(self, cwd: PathUri) -> FileSystemSandboxContext {+ FileSystemSandboxContext {+ permissions: self.permissions.into(),+ cwd,+ workspace_roots: match self.policy_context {+ Some(policy_context) => policy_context.workspace_roots,+ None => self.workspace_roots,+ },+ user_home_dir: self.user_home_dir,+ temporary_directories: self.temporary_directories,+ windows_sandbox_selection: self.windows_sandbox_selection,+ windows_sandbox_private_desktop: self.windows_sandbox_private_desktop,+ windows_sandbox_proxy_settings_mode: self.windows_sandbox_proxy_settings_mode,+ use_legacy_landlock: self.use_legacy_landlock,}- self}}