Lightweight coding agent that runs in your terminal
Rust
Use executor path context for permission preapproval (#41928)
iceweasel-oaic4350b4ca2a5
diff --git a/codex-rs/core/src/tools/handlers/apply_patch.rs b/codex-rs/core/src/tools/handlers/apply_patch.rsindex f1559f5407..b945bf6fbd 100644--- a/codex-rs/core/src/tools/handlers/apply_patch.rs+++ b/codex-rs/core/src/tools/handlers/apply_patch.rs@@ -314,8 +314,8 @@ async fn effective_patch_permissions(.collect::<Result<Vec<_>, _>>()?;let effective_additional_permissions = apply_granted_turn_permissions(session,- environment_id,- native_cwd.as_path(),+ environment,+ cwd,crate::sandboxing::SandboxPermissions::UseDefault,write_permissions_for_paths(&native_file_paths, &file_system_sandbox_policy, &native_cwd),)diff --git a/codex-rs/core/src/tools/handlers/extension_tools.rs b/codex-rs/core/src/tools/handlers/extension_tools.rsindex cad51e0be7..9a6d56f22e 100644--- a/codex-rs/core/src/tools/handlers/extension_tools.rs+++ b/codex-rs/core/src/tools/handlers/extension_tools.rs@@ -184,8 +184,8 @@ async fn to_extension_call(invocation: &ToolInvocation) -> ExtensionToolCall<'_>};let additional_permissions = apply_granted_turn_permissions(invocation.session.as_ref(),- &environment.selection.environment_id,- native_cwd.as_path(),+ environment,+ environment.cwd(),SandboxPermissions::UseDefault,/*additional_permissions*/ None,)diff --git a/codex-rs/core/src/tools/handlers/mod.rs b/codex-rs/core/src/tools/handlers/mod.rsindex 1217131be2..35268fe55f 100644--- a/codex-rs/core/src/tools/handlers/mod.rs+++ b/codex-rs/core/src/tools/handlers/mod.rs@@ -35,15 +35,16 @@ mod view_image;pub(crate) mod view_image_spec;mod wait_for_environment;-use codex_sandboxing::policy_transforms::materialize_additional_permissions;+use codex_file_system::FileSystemSandboxContext;+use codex_sandboxing::policy_transforms::materialize_additional_permissions_with_context;use codex_sandboxing::policy_transforms::merge_permission_profiles;-use codex_sandboxing::policy_transforms::normalize_additional_permissions;+use codex_sandboxing::policy_transforms::normalize_additional_permissions_with_context;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_absolute_path::AbsolutePathBufGuard;+use codex_utils_path_uri::PathUri;use serde::Deserialize;use serde_json::Map;use serde_json::Value;-use std::path::Path;use crate::environment_selection::TurnEnvironmentSnapshot;use crate::function_tool::FunctionCallError;@@ -181,7 +182,7 @@ pub(crate) fn normalize_and_validate_additional_permissions(sandbox_permissions: SandboxPermissions,additional_permissions: Option<AdditionalPermissionProfile>,permissions_preapproved: bool,- _cwd: &Path,+ context: &codex_protocol::permissions::FileSystemSandboxPolicyContext<'_>,) -> Result<Option<AdditionalPermissionProfile>, String> {let uses_additional_permissions = matches!(sandbox_permissions,@@ -210,7 +211,8 @@ pub(crate) fn normalize_and_validate_additional_permissions(.to_string(),);};- let normalized = normalize_additional_permissions(additional_permissions)?;+ let normalized =+ normalize_additional_permissions_with_context(additional_permissions, context)?;if normalized.is_empty() {return Err("`additional_permissions` must include at least one requested permission in `network` or `file_system`"@@ -236,6 +238,15 @@ pub(super) struct EffectiveAdditionalPermissions {pub permissions_preapproved: bool,}+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()?;+ context.cwd = cwd;+ Some(context)+}+pub(super) fn implicit_granted_permissions(sandbox_permissions: SandboxPermissions,additional_permissions: Option<&AdditionalPermissionProfile>,@@ -255,8 +266,8 @@ pub(super) fn implicit_granted_permissions(pub(super) async fn apply_granted_turn_permissions(session: &Session,- environment_id: &str,- cwd: &Path,+ environment: &TurnEnvironment,+ cwd: &PathUri,sandbox_permissions: SandboxPermissions,additional_permissions: Option<AdditionalPermissionProfile>,) -> EffectiveAdditionalPermissions {@@ -268,6 +279,7 @@ pub(super) async fn apply_granted_turn_permissions(};}+ let environment_id = &environment.selection.environment_id;let granted_session_permissions = session.granted_session_permissions(environment_id).await;let granted_turn_permissions = session.granted_turn_permissions(environment_id).await;let granted_permissions = merge_permission_profiles(@@ -278,13 +290,15 @@ pub(super) async fn apply_granted_turn_permissions(additional_permissions.as_ref(),granted_permissions.as_ref(),);+ let sandbox_context = environment.sandbox_context(/*additional_permissions*/ None);+ let context = file_system_sandbox_policy_context_for_cwd(&sandbox_context, cwd);let preapproved_permissions = granted_permissions.as_ref().and_then(|granted| {if additional_permissions.is_none() {Some(granted.clone())} else {- effective_permissions- .as_ref()- .and_then(|effective| preapproved_permission_profile(effective, granted, cwd))+ effective_permissions.as_ref().and_then(|effective| {+ preapproved_permission_profile(effective, granted, context.as_ref()?)+ })}});let permissions_preapproved = preapproved_permissions.is_some();@@ -309,11 +323,35 @@ pub(super) async fn apply_granted_turn_permissions(fn preapproved_permission_profile(effective_permissions: &AdditionalPermissionProfile,granted_permissions: &AdditionalPermissionProfile,- cwd: &Path,+ context: &codex_protocol::permissions::FileSystemSandboxPolicyContext<'_>,) -> Option<AdditionalPermissionProfile> {+ if effective_permissions+ .file_system+ .as_ref()+ .is_some_and(|permissions| {+ permissions.entries.iter().any(|entry| {+ (matches!(+ &entry.path,+ codex_protocol::permissions::FileSystemPath::Special {+ value: codex_protocol::permissions::FileSystemSpecialPath::Tmpdir,+ }+ ) && context+ .temporary_directories+ .is_none_or(<[PathUri]>::is_empty))+ || matches!(+ &entry.path,+ codex_protocol::permissions::FileSystemPath::Special {+ value: codex_protocol::permissions::FileSystemSpecialPath::ProjectRoots { .. },+ } if context.workspace_roots.is_empty()+ )+ })+ })+ {+ return None;+ }let (Ok(effective), Ok(granted)) = (- materialize_additional_permissions(effective_permissions.clone(), cwd),- materialize_additional_permissions(granted_permissions.clone(), cwd),+ materialize_additional_permissions_with_context(effective_permissions.clone(), context),+ materialize_additional_permissions_with_context(granted_permissions.clone(), context),) else {return None;};@@ -352,12 +390,14 @@ mod tests {use codex_protocol::permissions::FileSystemAccessMode;use codex_protocol::permissions::FileSystemPath;use codex_protocol::permissions::FileSystemSandboxEntry;+ use codex_protocol::permissions::FileSystemSandboxPolicyContext;use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::protocol::AskForApproval;use codex_protocol::protocol::GranularApprovalConfig;use codex_sandboxing::policy_transforms::intersect_permission_profiles;use codex_sandboxing::policy_transforms::merge_permission_profiles;use codex_utils_absolute_path::AbsolutePathBuf;+ use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;use tempfile::tempdir;@@ -382,10 +422,20 @@ mod tests {}}+ fn local_context(cwd: &PathUri) -> FileSystemSandboxPolicyContext<'_> {+ FileSystemSandboxPolicyContext {+ cwd,+ workspace_roots: std::slice::from_ref(cwd),+ temporary_directories: None,+ user_home_dir: None,+ }+ }+#[test]fn preapproved_permissions_work_when_request_permissions_tool_is_enabled_without_exec_permission_approvals_feature(){let cwd = tempdir().expect("tempdir");+ let cwd = PathUri::from_host_native_path(cwd.path()).expect("cwd URI");let normalized = normalize_and_validate_additional_permissions(/*additional_permissions_allowed*/ false,@@ -399,7 +449,7 @@ mod tests {SandboxPermissions::WithAdditionalPermissions,Some(network_permissions()),/*permissions_preapproved*/ true,- cwd.path(),+ &local_context(&cwd),).expect("preapproved permissions should be allowed");@@ -409,6 +459,7 @@ mod tests {#[test]fn fresh_additional_permissions_still_require_exec_permission_approvals_feature() {let cwd = tempdir().expect("tempdir");+ let cwd = PathUri::from_host_native_path(cwd.path()).expect("cwd URI");let err = normalize_and_validate_additional_permissions(/*additional_permissions_allowed*/ false,@@ -416,7 +467,7 @@ mod tests {SandboxPermissions::WithAdditionalPermissions,Some(network_permissions()),/*permissions_preapproved*/ false,- cwd.path(),+ &local_context(&cwd),).expect_err("fresh inline permission requests should remain disabled");@@ -493,10 +544,71 @@ mod tests {let effective_permissions =merge_permission_profiles(Some(&requested_permissions), Some(&stored_grant)).expect("merged permissions");+ let cwd = PathUri::from_host_native_path(cwd.path()).expect("cwd URI");assert_eq!(- preapproved_permission_profile(&effective_permissions, &stored_grant, cwd.path()),+ preapproved_permission_profile(+ &effective_permissions,+ &stored_grant,+ &local_context(&cwd),+ ),Some(stored_grant));}++ #[test]+ fn symbolic_tmpdir_preapproval_requires_executor_metadata() {+ let cwd = PathUri::parse("file:///C:/workspace").expect("Windows cwd");+ let temporary_directory = PathUri::parse("file:///C:/Temp").expect("Windows temp dir");+ let concrete = FileSystemSandboxEntry::new(+ temporary_directory.clone().into(),+ FileSystemAccessMode::Write,+ );+ let symbolic = FileSystemSandboxEntry {+ path: FileSystemPath::Special {+ value: FileSystemSpecialPath::Tmpdir,+ },+ access: FileSystemAccessMode::Write,+ missing_path_behavior: None,+ };+ let effective = AdditionalPermissionProfile {+ file_system: Some(FileSystemPermissions {+ entries: vec![concrete.clone(), symbolic],+ glob_scan_max_depth: None,+ }),+ ..Default::default()+ };+ let granted = AdditionalPermissionProfile {+ file_system: Some(FileSystemPermissions {+ entries: vec![concrete],+ glob_scan_max_depth: None,+ }),+ ..Default::default()+ };++ assert_eq!(+ preapproved_permission_profile(&effective, &granted, &local_context(&cwd)),+ None+ );++ let empty_temporary_directories = [];+ let empty_tmpdir_context = FileSystemSandboxPolicyContext {+ temporary_directories: Some(&empty_temporary_directories),+ ..local_context(&cwd)+ };+ assert_eq!(+ preapproved_permission_profile(&effective, &granted, &empty_tmpdir_context),+ None+ );++ let temporary_directories = [temporary_directory];+ let tmpdir_context = FileSystemSandboxPolicyContext {+ temporary_directories: Some(&temporary_directories),+ ..local_context(&cwd)+ };+ assert_eq!(+ preapproved_permission_profile(&effective, &granted, &tmpdir_context),+ Some(granted)+ );+ }}diff --git a/codex-rs/core/src/tools/handlers/permission_preapproval_tests.rs b/codex-rs/core/src/tools/handlers/permission_preapproval_tests.rsindex 13826255b6..4876caa94f 100644--- a/codex-rs/core/src/tools/handlers/permission_preapproval_tests.rs+++ b/codex-rs/core/src/tools/handlers/permission_preapproval_tests.rs@@ -5,8 +5,10 @@ use codex_protocol::models::NetworkPermissions;use codex_protocol::permissions::FileSystemAccessMode;use codex_protocol::permissions::FileSystemPath;use codex_protocol::permissions::FileSystemSandboxEntry;+use codex_protocol::permissions::FileSystemSandboxPolicyContext;use codex_sandboxing::policy_transforms::merge_permission_profiles;use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;use tempfile::tempdir;@@ -20,6 +22,15 @@ fn file_system_permissions(entries: Vec<FileSystemSandboxEntry>) -> AdditionalPe}}+fn local_context(cwd: &PathUri) -> FileSystemSandboxPolicyContext<'_> {+ FileSystemSandboxPolicyContext {+ cwd,+ workspace_roots: std::slice::from_ref(cwd),+ temporary_directories: None,+ user_home_dir: None,+ }+}+#[test]fn preapproval_accepts_reordered_replay_of_one_accumulated_grant() {let cwd = tempdir().expect("tempdir");@@ -35,9 +46,10 @@ fn preapproval_accepts_reordered_replay_of_one_accumulated_grant() {});let replay = file_system_permissions(vec![write]);let effective = merge_permission_profiles(Some(&replay), Some(&granted)).expect("permissions");+ let cwd = PathUri::from_host_native_path(cwd.path()).expect("cwd URI");assert_eq!(- preapproved_permission_profile(&effective, &granted, cwd.path()),+ preapproved_permission_profile(&effective, &granted, &local_context(&cwd)),Some(granted));}@@ -50,6 +62,8 @@ fn preapproval_requires_fresh_read_and_write_beneath_a_deny() {FileSystemSandboxEntry::new(root.clone().into(), FileSystemAccessMode::Write),FileSystemSandboxEntry::new(root.join("secrets").into(), FileSystemAccessMode::Deny),]);+ let cwd = PathUri::from_host_native_path(cwd.path()).expect("cwd URI");+ let context = local_context(&cwd);let preapproved = [FileSystemAccessMode::Read, FileSystemAccessMode::Write].map(|access| {let requested = file_system_permissions(vec![FileSystemSandboxEntry::new(@@ -59,7 +73,7 @@ fn preapproval_requires_fresh_read_and_write_beneath_a_deny() {let effective =merge_permission_profiles(Some(&requested), Some(&granted)).expect("permissions");- preapproved_permission_profile(&effective, &granted, cwd.path())+ preapproved_permission_profile(&effective, &granted, &context)});assert_eq!(preapproved, [None, None]);@@ -74,9 +88,10 @@ fn preapproval_fails_closed_when_materialization_rejects_both_profiles() {},FileSystemAccessMode::Write,)]);+ let cwd = PathUri::from_host_native_path(cwd.path()).expect("cwd URI");assert_eq!(- preapproved_permission_profile(&invalid, &invalid, cwd.path()),+ preapproved_permission_profile(&invalid, &invalid, &local_context(&cwd)),None);}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 6b54a2beb5..2c7b7a2ef8 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@@ -12,6 +12,7 @@ use crate::tools::context::ToolPayload;use crate::tools::context::boxed_tool_output;use crate::tools::handlers::apply_granted_turn_permissions;use crate::tools::handlers::apply_patch::intercept_apply_patch;+use crate::tools::handlers::file_system_sandbox_policy_context_for_cwd;use crate::tools::handlers::implicit_granted_permissions;use crate::tools::handlers::normalize_and_validate_additional_permissions;use crate::tools::handlers::parse_arguments;@@ -301,12 +302,20 @@ impl ExecCommandHandler {let exec_permission_approvals_enabled =session.features().enabled(Feature::ExecPermissionApprovals);let requested_additional_permissions = additional_permissions.clone();- // TODO(anp): Make permission matching operate on PathUri for remote environments.- let permission_cwd = native_cwd.as_ref().unwrap_or(&turn.config.cwd);+ 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 effective_additional_permissions = apply_granted_turn_permissions(context.session.as_ref(),- &turn_environment.selection.environment_id,- permission_cwd.as_path(),+ turn_environment,+ &cwd,sandbox_permissions,additional_permissions,)@@ -343,7 +352,7 @@ impl ExecCommandHandler {effective_additional_permissions.sandbox_permissions,effective_additional_permissions.additional_permissions,effective_additional_permissions.permissions_preapproved,- permission_cwd,+ &permission_context,)},|permissions| Ok(Some(permissions)),diff --git a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs b/codex-rs/core/src/tools/handlers/unified_exec_tests.rsindex 775d78cc1f..f75b57d213 100644--- a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs+++ b/codex-rs/core/src/tools/handlers/unified_exec_tests.rs@@ -280,6 +280,99 @@ async fn shell_mode_for_environment_uses_direct_mode_for_remote_environments() -Ok(())}+#[tokio::test]+#[cfg(not(windows))]+async fn exec_command_reuses_foreign_windows_grant() {+ use crate::session::tests::make_session_and_context_with_auth_and_config_and_rx;+ use codex_features::Feature;+ use codex_protocol::models::AdditionalPermissionProfile;+ use codex_protocol::models::FileSystemPermissions;+ use codex_utils_path_uri::PathUri;++ let (session, mut turn, _events) = make_session_and_context_with_auth_and_config_and_rx(+ codex_login::CodexAuth::from_api_key("Test API Key"),+ Vec::new(),+ |config| {+ config+ .features+ .enable(Feature::RequestPermissionsTool)+ .expect("test setup should allow request permissions");+ },+ )+ .await;++ let cwd = PathUri::parse("file:///C:/workspace").expect("valid Windows cwd");+ let granted_permissions = AdditionalPermissionProfile {+ file_system: Some(FileSystemPermissions::from_read_write_path_uris(+ /*read*/ Some(Vec::new()),+ /*write*/+ Some(vec![+ PathUri::parse("file:///C:/workspace/granted").expect("valid Windows grant"),+ ]),+ )),+ ..Default::default()+ };+ *session.active_turn.lock().await = Some(crate::state::ActiveTurn::default());+ let turn_state = {+ let active_turn = session.active_turn.lock().await;+ Arc::clone(&active_turn.as_ref().expect("active turn").turn_state)+ };+ turn_state.lock().await.record_granted_permissions(+ codex_exec_server::REMOTE_ENVIRONMENT_ID,+ granted_permissions.clone(),+ );++ {+ let turn = Arc::get_mut(&mut turn).expect("turn should be uniquely owned");+ let TurnEnvironmentState::Ready(environment) = turn+ .environments+ .environments+ .first_mut()+ .expect("primary environment")+ else {+ panic!("primary environment should be ready");+ };+ environment.selection.environment_id = codex_exec_server::REMOTE_ENVIRONMENT_ID.to_string();+ environment.selection.cwd = cwd.clone();+ environment.selection.workspace_roots = vec![cwd.clone()];+ environment.config_mut().workspace_roots = vec![cwd];+ environment.environment = Arc::new(+ Environment::create_for_tests(Some("ws://127.0.0.1:1/remote-exec-server".to_string()))+ .expect("remote environment"),+ );+ }++ let response = ExecCommandHandler::default()+ .handle(ToolInvocation {+ session: Arc::clone(&session),+ step_context: StepContext::for_test(Arc::clone(&turn)),+ turn,+ cancellation_token: tokio_util::sync::CancellationToken::new(),+ tracker: Arc::new(Mutex::new(TurnDiffTracker::new())),+ call_id: "foreign-windows-grant".to_string(),+ tool_name: codex_tools::ToolName::plain("exec_command"),+ source: ToolCallSource::Direct,+ payload: ToolPayload::Function {+ arguments: serde_json::json!({+ "cmd": "*** Begin Patch\n*** Add File: granted/file.txt\n+text\n*** End Patch",+ "workdir": "nested",+ "sandbox_permissions": "with_additional_permissions",+ "additional_permissions": granted_permissions,+ })+ .to_string(),+ },+ })+ .await;++ let Err(FunctionCallError::RespondToModel(message)) = response else {+ panic!("raw patch should stop before remote execution");+ };+ assert!(+ message.contains("apply_patch verification failed"),+ "matching foreign grant should reach patch interception: {message}"+ );+}+#[tokio::test]async fn exec_command_pre_tool_use_payload_uses_raw_command() {let payload = ToolPayload::Function {diff --git a/codex-rs/sandboxing/src/policy_transforms.rs b/codex-rs/sandboxing/src/policy_transforms.rsindex ad35730843..0f8918df5c 100644--- a/codex-rs/sandboxing/src/policy_transforms.rs+++ b/codex-rs/sandboxing/src/policy_transforms.rs@@ -67,7 +67,6 @@ pub fn normalize_additional_permissions_with_context(if path.infer_path_convention().is_none()|| path.infer_path_convention() != context.cwd.infer_path_convention()|| path.join(".").is_err()- || context.cwd.join(".").is_err(){return Err(format!("permission path `{path}` does not match executor cwd `{}`",diff --git a/codex-rs/sandboxing/src/policy_transforms_tests.rs b/codex-rs/sandboxing/src/policy_transforms_tests.rsindex 97334bfc40..2a13575cdf 100644--- a/codex-rs/sandboxing/src/policy_transforms_tests.rs+++ b/codex-rs/sandboxing/src/policy_transforms_tests.rs@@ -18,6 +18,8 @@ use codex_protocol::permissions::FileSystemSandboxPolicyContext;use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_utils_absolute_path::AbsolutePathBuf;+use codex_utils_path_uri::LegacyAppPathString;+use codex_utils_path_uri::PathConvention;use codex_utils_path_uri::PathUri;use dunce::canonicalize;use pretty_assertions::assert_eq;@@ -162,9 +164,29 @@ fn normalize_additional_permissions_only_checks_convention_with_context() {temporary_directories: None,};assert!(- normalize_additional_permissions_with_context(permissions, &context).is_err(),+ normalize_additional_permissions_with_context(permissions.clone(), &context).is_err(),"context-aware normalization should reject mismatched conventions");++ let cwd = LegacyAppPathString::from_string(+ r"\\?\Volume{00000000-0000-0000-0000-000000000000}\workspace",+ )+ .to_path_uri(PathConvention::Windows)+ .expect("opaque Windows cwd");+ assert!(cwd.is_opaque(), "volume GUID cwd should stay opaque");+ let workspace_roots = [cwd.clone()];+ let context = FileSystemSandboxPolicyContext {+ cwd: &cwd,+ workspace_roots: &workspace_roots,+ user_home_dir: None,+ temporary_directories: None,+ };++ assert_eq!(+ normalize_additional_permissions_with_context(permissions.clone(), &context)+ .expect("absolute path with opaque cwd"),+ permissions+ );}#[cfg(unix)]