Lightweight coding agent that runs in your terminal
Rust
Make permission transforms aware of executor path context (#41909)
iceweasel-oaib51b07785bcd
diff --git a/codex-rs/core/src/tools/handlers/apply_patch_tests.rs b/codex-rs/core/src/tools/handlers/apply_patch_tests.rsindex b78e62e2da..24d6f6ea4a 100644--- a/codex-rs/core/src/tools/handlers/apply_patch_tests.rs+++ b/codex-rs/core/src/tools/handlers/apply_patch_tests.rs@@ -303,8 +303,7 @@ fn write_permissions_for_paths_keep_dirs_outside_workspace_root() {);let permissions = write_permissions_for_paths(&[file_path], &sandbox_policy, &cwd_abs);- let expected_outside =- dunce::simplified(&outside.canonicalize().expect("canonicalize outside dir")).abs();+ let expected_outside = outside.abs();assert_eq!(permissionsdiff --git a/codex-rs/core/tests/suite/request_permissions.rs b/codex-rs/core/tests/suite/request_permissions.rsindex fa48e01442..3cc15273c3 100644--- a/codex-rs/core/tests/suite/request_permissions.rs+++ b/codex-rs/core/tests/suite/request_permissions.rs@@ -287,16 +287,6 @@ fn requested_directory_write_permissions(path: &Path) -> RequestPermissionProfil}}-fn normalized_directory_write_permissions(path: &Path) -> Result<RequestPermissionProfile> {- Ok(RequestPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![AbsolutePathBuf::try_from(path.canonicalize()?)?]),- )),- ..RequestPermissionProfile::default()- })-}-#[tokio::test(flavor = "current_thread")]async fn with_additional_permissions_requires_approval_under_on_request() -> Result<()> {skip_if_no_network!(Ok(()));@@ -508,7 +498,7 @@ async fn request_permissions_auto_review_applies_guardian_decision(outcome: &strlet requested_dir = test.workspace_path("guardian-requested-permissions");fs::create_dir_all(&requested_dir)?;let requested_permissions = requested_directory_write_permissions(&requested_dir);- let normalized_permissions = normalized_directory_write_permissions(&requested_dir)?;+ let normalized_permissions = requested_directory_write_permissions(&requested_dir);let call_id = "guardian-request-permissions";let reason = "Guardian should review access to the requested directory";let responses = mount_sse_sequence(@@ -576,9 +566,7 @@ async fn request_permissions_auto_review_applies_guardian_decision(outcome: &str}).context("expected Guardian review request")?;assert!(guardian_request.body_contains_text(reason));- assert!(- guardian_request.body_contains_text(&requested_dir.canonicalize()?.display().to_string())- );+ assert!(guardian_request.body_contains_text(&requested_dir.display().to_string()));let output = requests.iter()@@ -765,7 +753,6 @@ async fn relative_additional_permissions_resolve_against_tool_workdir() -> Resullet nested_dir = test.workspace_path("nested");fs::create_dir_all(&nested_dir)?;- let nested_dir_canonical = nested_dir.canonicalize()?;let requested_write = nested_dir.join("relative-write.txt");let _ = fs::remove_file(&requested_write);@@ -780,7 +767,7 @@ async fn relative_additional_permissions_resolve_against_tool_workdir() -> Resullet expected_permissions = PermissionProfile {file_system: Some(FileSystemPermissions::from_read_write_roots(/*read*/ None,- Some(vec![absolute_path(&nested_dir_canonical)]),+ Some(vec![absolute_path(&nested_dir)]),)),..Default::default()};@@ -1096,15 +1083,7 @@ async fn workspace_write_with_additional_permissions_can_write_outside_cwd() ->)),..RequestPermissionProfile::default()};- let normalized_requested_permissions = RequestPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![AbsolutePathBuf::try_from(- outside_dir.path().canonicalize()?,- )?]),- )),- ..RequestPermissionProfile::default()- };+ let normalized_requested_permissions = requested_permissions.clone();let event =exec_command_event_with_request_permissions(call_id, &command, &requested_permissions)?;@@ -1202,15 +1181,7 @@ async fn with_additional_permissions_denied_approval_blocks_execution() -> Resul)),..Default::default()};- let normalized_requested_permissions = PermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![AbsolutePathBuf::try_from(- outside_dir.path().canonicalize()?,- )?]),- )),- ..Default::default()- };+ let normalized_requested_permissions = requested_permissions.clone();let event =exec_command_event_with_request_permissions(call_id, &command, &requested_permissions)?;@@ -1308,15 +1279,7 @@ async fn request_permissions_grants_apply_to_later_exec_command_calls() -> Resul)),..Default::default()};- let normalized_requested_permissions = RequestPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![AbsolutePathBuf::try_from(- outside_dir.path().canonicalize()?,- )?]),- )),- ..Default::default()- };+ let normalized_requested_permissions = requested_permissions.clone();let responses = mount_sse_sequence(&server,vec![@@ -1430,7 +1393,7 @@ async fn request_permissions_preapprove_explicit_exec_permissions_outside_on_req);let requested_permissions = requested_directory_write_permissions(outside_dir.path());let normalized_requested_permissions =- normalized_directory_write_permissions(outside_dir.path())?;+ requested_directory_write_permissions(outside_dir.path());let responses = mount_sse_sequence(&server,vec![@@ -1550,7 +1513,7 @@ async fn request_permissions_grants_apply_to_later_exec_command_calls_without_in);let requested_permissions = requested_directory_write_permissions(outside_dir.path());let normalized_requested_permissions =- normalized_directory_write_permissions(outside_dir.path())?;+ requested_directory_write_permissions(outside_dir.path());let responses = mount_sse_sequence(&server,vec![@@ -1677,28 +1640,10 @@ async fn partial_request_permissions_grants_do_not_preapprove_new_permissions())),..RequestPermissionProfile::default()};- let normalized_requested_permissions = RequestPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![- AbsolutePathBuf::try_from(first_dir.path().canonicalize()?)?,- AbsolutePathBuf::try_from(second_dir.path().canonicalize()?)?,- ]),- )),- ..RequestPermissionProfile::default()- };- let granted_permissions = normalized_directory_write_permissions(first_dir.path())?;+ let normalized_requested_permissions = requested_permissions.clone();+ let granted_permissions = requested_directory_write_permissions(first_dir.path());let second_dir_permissions = requested_directory_write_permissions(second_dir.path());- let merged_permissions = PermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![- AbsolutePathBuf::try_from(first_dir.path().canonicalize()?)?,- AbsolutePathBuf::try_from(second_dir.path().canonicalize()?)?,- ]),- )),- ..Default::default()- };+ let merged_permissions = requested_permissions.clone();let responses = mount_sse_sequence(&server,@@ -1835,7 +1780,7 @@ async fn request_permissions_grants_do_not_carry_across_turns() -> Result<()> {let outside_dir = tempfile::tempdir()?;let requested_permissions = requested_directory_write_permissions(outside_dir.path());let normalized_requested_permissions =- normalized_directory_write_permissions(outside_dir.path())?;+ requested_directory_write_permissions(outside_dir.path());let _first_turn = mount_sse_sequence(&server,@@ -1952,7 +1897,7 @@ async fn request_permissions_session_grants_carry_across_turns() -> Result<()> {let outside_write = outside_dir.path().join("session-sticky-write.txt");let requested_permissions = requested_directory_write_permissions(outside_dir.path());let normalized_requested_permissions =- normalized_directory_write_permissions(outside_dir.path())?;+ requested_directory_write_permissions(outside_dir.path());let command = format!("printf {:?} > {:?} && cat {:?}","session-sticky-ok", outside_write, outside_writediff --git a/codex-rs/core/tests/suite/request_permissions_tool.rs b/codex-rs/core/tests/suite/request_permissions_tool.rsindex 9538743eae..e0adff8ded 100644--- a/codex-rs/core/tests/suite/request_permissions_tool.rs+++ b/codex-rs/core/tests/suite/request_permissions_tool.rs@@ -98,16 +98,6 @@ fn requested_directory_write_permissions(path: &Path) -> RequestPermissionProfil}}-fn normalized_directory_write_permissions(path: &Path) -> Result<RequestPermissionProfile> {- Ok(RequestPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- Some(vec![]),- Some(vec![AbsolutePathBuf::try_from(path.canonicalize()?)?]),- )),- ..RequestPermissionProfile::default()- })-}-fn parse_result(item: &Value) -> (Option<i64>, String) {let output_str = item.get("output")@@ -241,7 +231,7 @@ async fn approved_folder_write_request_permissions_unblocks_later_exec_without_s);let requested_permissions = requested_directory_write_permissions(requested_dir.path());let normalized_requested_permissions =- normalized_directory_write_permissions(requested_dir.path())?;+ requested_directory_write_permissions(requested_dir.path());let responses = mount_sse_sequence(&server,@@ -378,13 +368,10 @@ async fn apply_patch_after_request_permissions(strict_auto_review: bool) -> Resu} else {"patched-via-request-permissions"};- let requested_file = requested_dir- .path()- .canonicalize()?- .join(requested_file_name);+ let requested_file = requested_dir.path().join(requested_file_name);let requested_permissions = requested_directory_write_permissions(requested_dir.path());let normalized_requested_permissions =- normalized_directory_write_permissions(requested_dir.path())?;+ requested_directory_write_permissions(requested_dir.path());let patch = build_add_file_patch(&requested_file, patch_content);let response_prefix = if strict_auto_review {diff --git a/codex-rs/protocol/src/permissions.rs b/codex-rs/protocol/src/permissions.rsindex 4f6303a709..dcdae60f28 100644--- a/codex-rs/protocol/src/permissions.rs+++ b/codex-rs/protocol/src/permissions.rs@@ -288,15 +288,43 @@ struct FileSystemSemanticSignature {/// Runtime matcher for read-deny entries in a filesystem sandbox policy.pub struct ReadDenyMatcher {- cwd: AbsolutePathBuf,+ native_cwd: Option<AbsolutePathBuf>,user_home_dir: Option<PathUri>,temporary_directories: Vec<PathUri>,+ prepared: PreparedReadDenyMatcher,+}++/// Prepared PathUri deny roots and globs for repeated executor-owned read checks.+struct PreparedReadDenyMatcher {denied_roots: Vec<PathUri>,deny_read_matchers: Vec<GlobMatcher>,invalid_pattern: bool,}impl ReadDenyMatcher {+ /// Builds a matcher for executor-owned URI paths without host projection.+ pub fn from_context(+ file_system_sandbox_policy: &FileSystemSandboxPolicy,+ context: &FileSystemSandboxPolicyContext<'_>,+ ) -> Option<Self> {+ file_system_sandbox_policy+ .entries+ .iter()+ .any(|entry| entry.access == FileSystemAccessMode::Deny)+ .then(|| {+ file_system_sandbox_policy+ .prepare_deny_read_matcher(context, InvalidDenyReadGlobBehavior::FailClosed)+ .map(|prepared| Self {+ native_cwd: None,+ user_home_dir: None,+ temporary_directories: Vec::new(),+ prepared,+ })+ .ok()+ })+ .flatten()+ }+/// Builds a matcher from exact deny-read roots and deny-read glob entries.////// Returns `None` when the policy has no deny-read restrictions, so callers@@ -348,38 +376,42 @@ impl ReadDenyMatcher {user_home_dir: user_home_dir.as_ref(),temporary_directories: Some(&temporary_directories),};- let (denied_roots, deny_read_matchers, invalid_pattern) = file_system_sandbox_policy+ let prepared = file_system_sandbox_policy.prepare_deny_read_matcher(&context, invalid_glob_behavior)?;Ok(Some(Self {- cwd,+ native_cwd: Some(cwd),user_home_dir,temporary_directories,- denied_roots,- deny_read_matchers,- invalid_pattern,+ prepared,}))}/// Returns whether `path` is denied by the policy used to build this matcher.pub fn is_read_denied(&self, path: &Path) -> bool {- let Some(path) = resolve_candidate_path(path, self.cwd.as_path()) else {+ let Some(cwd) = self.native_cwd.as_ref() else {+ return true;+ };+ let Some(path) = resolve_candidate_path(path, cwd.as_path()) else {return true;};let path = PathUri::from(path);- let cwd = PathUri::from_abs_path(&self.cwd);+ let cwd = PathUri::from_abs_path(cwd);let context = FileSystemSandboxPolicyContext {cwd: &cwd,workspace_roots: std::slice::from_ref(&cwd),user_home_dir: self.user_home_dir.as_ref(),temporary_directories: Some(&self.temporary_directories),};- FileSystemSandboxPolicy::matches_prepared_read_deny(- &path,- &context,- &self.denied_roots,- &self.deny_read_matchers,- self.invalid_pattern,- )+ self.is_read_denied_uri(&path, &context)+ }++ /// Returns whether an executor-owned URI is denied under its matching path context.+ pub fn is_read_denied_uri(+ &self,+ path: &PathUri,+ context: &FileSystemSandboxPolicyContext<'_>,+ ) -> bool {+ FileSystemSandboxPolicy::matches_prepared_read_deny(path, context, &self.prepared)}/// Checks an enumerated path using a canonical location already resolved by@@ -891,7 +923,7 @@ impl FileSystemSandboxPolicy {.unwrap_or(false)}- fn resolve_access(+ pub fn resolve_access(&self,path: &PathUri,context: &FileSystemSandboxPolicyContext<'_>,@@ -973,7 +1005,7 @@ impl FileSystemSandboxPolicy {&self,context: &FileSystemSandboxPolicyContext<'_>,invalid_glob_behavior: InvalidDenyReadGlobBehavior,- ) -> Result<(Vec<PathUri>, Vec<GlobMatcher>, bool), String> {+ ) -> Result<PreparedReadDenyMatcher, String> {let file_system_root = file_system_root(context);let denied_roots = self.resolved_entries(context)@@ -987,7 +1019,11 @@ impl FileSystemSandboxPolicy {.map(|(root, _)| root).collect();let Some(convention) = context.cwd.infer_path_convention() else {- return Ok((denied_roots, Vec::new(), true));+ return Ok(PreparedReadDenyMatcher {+ denied_roots,+ deny_read_matchers: Vec::new(),+ invalid_pattern: true,+ });};let mut deny_read_matchers = Vec::new();let mut invalid_pattern = false;@@ -995,7 +1031,11 @@ impl FileSystemSandboxPolicy {Ok(patterns) => patterns,Err(err) => match invalid_glob_behavior {InvalidDenyReadGlobBehavior::FailClosed => {- return Ok((denied_roots, Vec::new(), true));+ return Ok(PreparedReadDenyMatcher {+ denied_roots,+ deny_read_matchers: Vec::new(),+ invalid_pattern: true,+ });}InvalidDenyReadGlobBehavior::ReturnError => return Err(err),},@@ -1011,15 +1051,17 @@ impl FileSystemSandboxPolicy {},}}- Ok((denied_roots, deny_read_matchers, invalid_pattern))+ Ok(PreparedReadDenyMatcher {+ denied_roots,+ deny_read_matchers,+ invalid_pattern,+ })}fn matches_prepared_read_deny(path: &PathUri,context: &FileSystemSandboxPolicyContext<'_>,- denied_roots: &[PathUri],- deny_read_matchers: &[GlobMatcher],- invalid_pattern: bool,+ prepared: &PreparedReadDenyMatcher,) -> bool {let Some(convention) = context.cwd.infer_path_convention() else {return true;@@ -1030,11 +1072,14 @@ impl FileSystemSandboxPolicy {{return true;}- if invalid_pattern {+ if prepared.invalid_pattern {return true;}- denied_roots.iter().any(|root| path.starts_with(root))- || deny_read_matchers.iter().any(|matcher| {+ prepared+ .denied_roots+ .iter()+ .any(|root| path.starts_with(root))+ || prepared.deny_read_matchers.iter().any(|matcher| {let path = match convention {PathConvention::Posix => path.decoded_path_bytes(),PathConvention::Windows => Cow::Owned(@@ -1897,7 +1942,7 @@ fn with_local_policy_context<T>(Some(evaluate(&path, &context))}-fn file_system_root(context: &FileSystemSandboxPolicyContext<'_>) -> Option<PathUri> {+pub fn file_system_root(context: &FileSystemSandboxPolicyContext<'_>) -> Option<PathUri> {context.cwd.lexical_depth()?;context.cwd.ancestors().last()}@@ -2725,25 +2770,21 @@ mod tests {),unreadable_glob_entry(r"C:\workspace\**\*.env".to_string()),]);- let (roots, globs, invalid) = policy+ let prepared = policy.prepare_deny_read_matcher(&context, InvalidDenyReadGlobBehavior::ReturnError).expect("remote deny matcher");- assert!(roots.is_empty());+ assert!(prepared.denied_roots.is_empty());assert!(FileSystemSandboxPolicy::matches_prepared_read_deny(&path("file:///c:/WORKSPACE/app/.ENV"),&context,- &roots,- &globs,- invalid,+ &prepared,));for candidate in ["file:///%00/bad/path/YQ", "file:///C:/workspace/%2Fsecret"] {assert!(FileSystemSandboxPolicy::matches_prepared_read_deny(&path(candidate),&context,- &roots,- &globs,- invalid,+ &prepared,));}assert!(!policy.can_write_path(&path("file:///C:/workspace/.codex/config"), &context));@@ -2793,12 +2834,12 @@ mod tests {let policy = FileSystemSandboxPolicy::restricted(vec![unreadable_glob_entry(pattern.to_string(),)]);- let (roots, globs, invalid) = policy+ let prepared = policy.prepare_deny_read_matcher(&context, InvalidDenyReadGlobBehavior::ReturnError).expect("home-relative deny glob");assert!(FileSystemSandboxPolicy::matches_prepared_read_deny(- &candidate, &context, &roots, &globs, invalid,+ &candidate, &context, &prepared,));let without_home = FileSystemSandboxPolicyContext {@@ -2813,10 +2854,10 @@ mod tests {).is_err());- let (_, _, invalid) = policy+ let prepared = policy.prepare_deny_read_matcher(&without_home, InvalidDenyReadGlobBehavior::FailClosed).expect("missing executor home fails closed");- assert!(invalid);+ assert!(prepared.invalid_pattern);}}diff --git a/codex-rs/sandboxing/src/policy_transforms.rs b/codex-rs/sandboxing/src/policy_transforms.rsindex 8012564f3a..ad35730843 100644--- a/codex-rs/sandboxing/src/policy_transforms.rs+++ b/codex-rs/sandboxing/src/policy_transforms.rs@@ -7,15 +7,16 @@ use codex_protocol::permissions::FileSystemPath;use codex_protocol::permissions::FileSystemSandboxEntry;use codex_protocol::permissions::FileSystemSandboxKind;use codex_protocol::permissions::FileSystemSandboxPolicy;+use codex_protocol::permissions::FileSystemSandboxPolicyContext;use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use codex_protocol::permissions::ReadDenyMatcher;+use codex_protocol::permissions::file_system_root;use codex_utils_absolute_path::AbsolutePathBuf;-use codex_utils_absolute_path::canonicalize_preserving_symlinks;+use codex_utils_path_uri::PathConvention;use codex_utils_path_uri::PathUri;use std::num::NonZeroUsize;use std::path::Path;-use std::path::PathBuf;pub fn normalize_additional_permissions(additional_permissions: AdditionalPermissionProfile,@@ -35,28 +36,8 @@ pub fn normalize_additional_permissions("glob file system permissions only support deny-read entries".to_string(),);}- let path = match entry.path {- FileSystemPath::Path { path } => FileSystemPath::Path {- path: path- .to_abs_path()- .ok()- .and_then(|path| canonicalize_preserving_symlinks(path.as_path()).ok())- .and_then(|path| AbsolutePathBuf::from_absolute_path(path).ok())- .map(Into::into)- .unwrap_or(path),- },- FileSystemPath::GlobPattern { pattern } => {- FileSystemPath::GlobPattern { pattern }- }- FileSystemPath::Special { value } => FileSystemPath::Special { value },- };- let normalized_entry = FileSystemSandboxEntry {- path,- access: entry.access,- missing_path_behavior: entry.missing_path_behavior,- };- if !entries.contains(&normalized_entry) {- entries.push(normalized_entry);+ if !entries.contains(&entry) {+ entries.push(entry);}}let file_system = FileSystemPermissions {@@ -73,19 +54,55 @@ pub fn normalize_additional_permissions(})}+pub fn normalize_additional_permissions_with_context(+ additional_permissions: AdditionalPermissionProfile,+ context: &FileSystemSandboxPolicyContext<'_>,+) -> Result<AdditionalPermissionProfile, String> {+ let normalized = normalize_additional_permissions(additional_permissions)?;+ if let Some(file_system) = normalized.file_system.as_ref() {+ for entry in &file_system.entries {+ let FileSystemPath::Path { path } = &entry.path else {+ continue;+ };+ 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 `{}`",+ context.cwd+ ));+ }+ }+ }+ Ok(normalized)+}+/// Resolves cwd-dependent permission entries without filtering their authority.////// Unlike intersection, this preserves narrower grants beneath denied paths.pub fn materialize_additional_permissions(- mut additional_permissions: AdditionalPermissionProfile,+ additional_permissions: AdditionalPermissionProfile,cwd: &Path,+) -> Result<AdditionalPermissionProfile, String> {+ let cwd = AbsolutePathBuf::from_absolute_path(cwd)+ .map_err(|err| format!("invalid permission cwd: {err}"))?;+ let cwd = PathUri::from(cwd);+ with_local_context_for_cwd(&cwd, |context| {+ materialize_additional_permissions_with_context(additional_permissions, context)+ })+}++pub fn materialize_additional_permissions_with_context(+ mut additional_permissions: AdditionalPermissionProfile,+ context: &FileSystemSandboxPolicyContext<'_>,) -> Result<AdditionalPermissionProfile, String> {if let Some(file_system) = additional_permissions.file_system.as_mut() {- for entry in &mut file_system.entries {- *entry = materialize_cwd_dependent_entry(entry, cwd);- }+ file_system.entries = materialize_context_dependent_entries(&file_system.entries, context)+ .ok_or_else(|| format!("unable to resolve permission path in `{}`", context.cwd))?;}- normalize_additional_permissions(additional_permissions)+ normalize_additional_permissions_with_context(additional_permissions, context)}pub fn merge_permission_profiles(@@ -146,43 +163,61 @@ pub fn intersect_permission_profiles(requested: AdditionalPermissionProfile,granted: AdditionalPermissionProfile,cwd: &Path,+) -> AdditionalPermissionProfile {+ AbsolutePathBuf::from_absolute_path(cwd)+ .ok()+ .map(PathUri::from)+ .map_or_else(AdditionalPermissionProfile::default, |cwd| {+ with_local_context_for_cwd(&cwd, |context| {+ intersect_permission_profiles_with_context(requested, granted, context)+ })+ })+}++pub fn intersect_permission_profiles_with_context(+ requested: AdditionalPermissionProfile,+ granted: AdditionalPermissionProfile,+ context: &FileSystemSandboxPolicyContext<'_>,) -> AdditionalPermissionProfile {let file_system = requested.file_system- .map(|requested_file_system| {+ .and_then(|requested_file_system| {let granted_file_system = granted.file_system.unwrap_or_default();- let requested_policy =- FileSystemSandboxPolicy::restricted(requested_file_system.entries.clone());- let requested_read_deny_matcher = ReadDenyMatcher::new(&requested_policy, cwd);+ let requested_entries =+ materialize_context_dependent_entries(&requested_file_system.entries, context)?;+ let granted_entries =+ materialize_context_dependent_entries(&granted_file_system.entries, context)?;+ let requested_policy = FileSystemSandboxPolicy::restricted(requested_entries.clone());+ let requested_read_deny_matcher =+ ReadDenyMatcher::from_context(&requested_policy, context);let mut accepted_entries = Vec::new();- for entry in granted_file_system.entries.iter().filter(|entry| {+ for entry in granted_entries.iter().filter(|entry| {granted_file_system_entry_within_request(&requested_file_system,&requested_policy,requested_read_deny_matcher.as_ref(),entry,- cwd,+ context,)}) {- let entry = materialize_cwd_dependent_entry(entry, cwd);- if !accepted_entries.contains(&entry) {- accepted_entries.push(entry);+ if !accepted_entries.contains(entry) {+ accepted_entries.push(entry.clone());}}let mut entries = accepted_entries.clone();let requested_retained_deny_entries = retain_constraining_deny_entries(- &requested_file_system.entries,+ &requested_entries,&accepted_entries,- cwd,+ context,&mut entries,);let granted_retained_deny_entries = retain_constraining_deny_entries(- &granted_file_system.entries,+ &granted_entries,&accepted_entries,- cwd,+ context,&mut entries,);- FileSystemPermissions {+ Some(FileSystemPermissions {glob_scan_max_depth: merge_glob_scan_max_depth(&requested_retained_deny_entries,requested_file_system.glob_scan_max_depth.map(usize::from),@@ -191,7 +226,7 @@ pub fn intersect_permission_profiles().and_then(NonZeroUsize::new),entries,- }+ })}).filter(|file_system| !file_system.is_empty());let network = match (requested.network, granted.network) {@@ -214,6 +249,46 @@ pub fn intersect_permission_profiles(}}+fn with_local_context_for_cwd<T>(+ cwd: &PathUri,+ evaluate: impl FnOnce(&FileSystemSandboxPolicyContext<'_>) -> T,+) -> T {+ let user_home_dir = PathUri::from_host_native_path("~").ok();+ let local_cwd = std::env::current_dir().ok();+ let temporary_directory_env_vars: &[&str] = if cfg!(windows) {+ &["TEMP", "TMP"]+ } else {+ &["TMPDIR"]+ };+ let normalize_temp_path = |path: std::ffi::OsString| {+ PathUri::from_host_native_path(&path).ok().or_else(|| {+ if cfg!(unix) {+ PathUri::from_host_native_path(local_cwd.as_ref()?.join(path)).ok()+ } else {+ None+ }+ })+ };+ let mut temporary_directories = Vec::new();+ for name in temporary_directory_env_vars {+ if let Some(path) = std::env::var_os(name)+ .filter(|path| !path.is_empty())+ .filter(|path| cfg!(unix) || Path::new(path).is_absolute())+ .and_then(&normalize_temp_path)+ && !temporary_directories.contains(&path)+ {+ temporary_directories.push(path);+ }+ }+ let context = FileSystemSandboxPolicyContext {+ cwd,+ workspace_roots: std::slice::from_ref(cwd),+ user_home_dir: user_home_dir.as_ref(),+ temporary_directories: Some(&temporary_directories),+ };+ evaluate(&context)+}+fn merge_glob_scan_max_depth(left_entries: &[FileSystemSandboxEntry],left_depth: Option<usize>,@@ -261,26 +336,37 @@ fn granted_file_system_entry_within_request(requested_policy: &FileSystemSandboxPolicy,requested_read_deny_matcher: Option<&ReadDenyMatcher>,granted_entry: &FileSystemSandboxEntry,- cwd: &Path,+ context: &FileSystemSandboxPolicyContext<'_>,) -> bool {if !granted_entry.access.can_read()|| matches!(&granted_entry.path,FileSystemPath::Special {value: FileSystemSpecialPath::SlashTmp,- } if !cfg!(unix)+ } if context.cwd.infer_path_convention() != Some(PathConvention::Posix)){return false;}+ if context.cwd.infer_path_convention() == Some(PathConvention::Windows)+ && is_root_entry(granted_entry)+ && !requested.entries.iter().any(|requested_entry| {+ is_root_entry(requested_entry)+ && access_covers(requested_entry.access, granted_entry.access)+ })+ {+ return false;+ }- if let Some(path) = resolve_permission_path(&granted_entry.path, cwd) {- if requested_read_deny_matcher.is_some_and(|matcher| matcher.is_read_denied(path.as_path()))+ if let Some(path) = resolve_permission_path(&granted_entry.path, context) {+ if path.infer_path_convention() != context.cwd.infer_path_convention()+ || requested_read_deny_matcher+ .is_some_and(|matcher| matcher.is_read_denied_uri(&path, context)){return false;}return access_covers(- requested_policy.resolve_access_with_cwd(path.as_path(), cwd),+ requested_policy.resolve_access(&path, context),granted_entry.access,);}@@ -294,7 +380,7 @@ fn granted_file_system_entry_within_request(fn retain_constraining_deny_entries(source_entries: &[FileSystemSandboxEntry],accepted_entries: &[FileSystemSandboxEntry],- cwd: &Path,+ context: &FileSystemSandboxPolicyContext<'_>,output_entries: &mut Vec<FileSystemSandboxEntry>,) -> Vec<FileSystemSandboxEntry> {let mut retained_entries = Vec::new();@@ -302,14 +388,13 @@ fn retain_constraining_deny_entries(.iter().filter(|entry| entry.access == FileSystemAccessMode::Deny){- if !deny_entry_constrains_accepted_grant(entry, accepted_entries, cwd) {+ if !deny_entry_constrains_accepted_grant(entry, accepted_entries, context) {continue;}- let entry = materialize_cwd_dependent_entry(entry, cwd);- if !output_entries.contains(&entry) {+ if !output_entries.contains(entry) {output_entries.push(entry.clone());}- retained_entries.push(entry);+ retained_entries.push(entry.clone());}retained_entries}@@ -317,51 +402,57 @@ fn retain_constraining_deny_entries(fn deny_entry_constrains_accepted_grant(deny_entry: &FileSystemSandboxEntry,accepted_entries: &[FileSystemSandboxEntry],- cwd: &Path,+ context: &FileSystemSandboxPolicyContext<'_>,) -> bool {accepted_entries.iter().filter(|entry| entry.access.can_read()).any(|entry| {- let Some(grant_path) = resolve_permission_path(&entry.path, cwd) else {+ if is_root_entry(entry) {+ return true;+ }+ let Some(grant_path) = resolve_permission_path(&entry.path, context) else {return false;};match &deny_entry.path {- FileSystemPath::GlobPattern { pattern } => glob_static_prefix_path(pattern, cwd)- .is_some_and(|prefix| paths_may_overlap(&prefix, &grant_path)),+ FileSystemPath::GlobPattern { pattern } => {+ glob_static_prefix_path(pattern, context)+ .is_none_or(|prefix| paths_overlap(&prefix, &grant_path))+ }FileSystemPath::Path { .. } | FileSystemPath::Special { .. } => {- resolve_permission_path(&deny_entry.path, cwd)- .is_some_and(|deny_path| paths_may_overlap(&deny_path, &grant_path))+ resolve_permission_path(&deny_entry.path, context)+ .is_none_or(|deny_path| paths_overlap(&deny_path, &grant_path))}}})}-fn glob_static_prefix_path(pattern: &str, cwd: &Path) -> Option<AbsolutePathBuf> {- let resolved_pattern = AbsolutePathBuf::resolve_path_against_base(pattern, cwd);- let resolved_pattern = resolved_pattern.as_path().to_string_lossy();- let prefix = match resolved_pattern.find(['*', '?', '[', ']']) {+fn glob_static_prefix_path(+ pattern: &str,+ context: &FileSystemSandboxPolicyContext<'_>,+) -> Option<PathUri> {+ let is_windows = context.cwd.infer_path_convention() == Some(PathConvention::Windows);+ let (prefix, wildcard_in_segment) = match pattern.find(['*', '?', '[', ']']) {Some(0) => return None,Some(index) => {- let prefix = &resolved_pattern[..index];- if prefix.ends_with(std::path::MAIN_SEPARATOR)- || prefix.ends_with('/')- || prefix.ends_with('\\')- {- Path::new(prefix)- } else {- Path::new(prefix).parent()?- }+ let prefix = &pattern[..index];+ (+ prefix,+ !(prefix.ends_with('/') || is_windows && prefix.ends_with('\\')),+ )}- None => Path::new(resolved_pattern.as_ref()),+ None => (pattern, false),};- AbsolutePathBuf::from_absolute_path(prefix).ok()+ let prefix = context.cwd.join(prefix).ok()?;+ if wildcard_in_segment {+ prefix.parent()+ } else {+ Some(prefix)+ }}-fn paths_may_overlap(left: &AbsolutePathBuf, right: &AbsolutePathBuf) -> bool {- let left = PathUri::from_abs_path(left);- let right = PathUri::from_abs_path(right);- left.overlaps(&right).unwrap_or(true)+fn paths_overlap(left: &PathUri, right: &PathUri) -> bool {+ left.overlaps(right).unwrap_or(true)}fn access_covers(requested: FileSystemAccessMode, granted: FileSystemAccessMode) -> bool {@@ -372,63 +463,70 @@ fn access_covers(requested: FileSystemAccessMode, granted: FileSystemAccessMode)}}+fn is_root_entry(entry: &FileSystemSandboxEntry) -> bool {+ matches!(+ &entry.path,+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ }+ )+}+fn materialize_cwd_dependent_entry(entry: &FileSystemSandboxEntry,- cwd: &Path,-) -> FileSystemSandboxEntry {+ context: &FileSystemSandboxPolicyContext<'_>,+) -> Option<FileSystemSandboxEntry> {match &entry.path {- FileSystemPath::Special {- value: FileSystemSpecialPath::ProjectRoots { .. },- } => resolve_permission_path(&entry.path, cwd)- .map(|path| FileSystemSandboxEntry {- path: path.into(),+ FileSystemPath::GlobPattern { pattern } => {+ let is_windows = context.cwd.infer_path_convention() == Some(PathConvention::Windows);+ let home_relative = pattern+ .strip_prefix("~/")+ .or_else(|| (pattern == "~").then_some(""))+ .or_else(|| is_windows.then(|| pattern.strip_prefix("~\\")).flatten());+ let (root, pattern) = match home_relative {+ Some(suffix) => (+ context.user_home_dir?,+ suffix.trim_start_matches(|separator| {+ separator == '/' || is_windows && separator == '\\'+ }),+ ),+ None => (context.cwd, pattern.as_str()),+ };+ let path = root.join(pattern).ok()?;+ let path = FileSystemPath::GlobPattern {+ pattern: path.inferred_native_path_string(),+ };+ Some(FileSystemSandboxEntry {+ path,access: entry.access,missing_path_behavior: entry.missing_path_behavior,})- .unwrap_or_else(|| entry.clone()),- FileSystemPath::GlobPattern { pattern } => FileSystemSandboxEntry {- path: FileSystemPath::GlobPattern {- pattern: AbsolutePathBuf::resolve_path_against_base(pattern, cwd)- .to_string_lossy()- .into_owned(),- },- access: entry.access,- missing_path_behavior: entry.missing_path_behavior,- },- FileSystemPath::Path { .. } | FileSystemPath::Special { .. } => entry.clone(),+ }+ FileSystemPath::Path { .. } | FileSystemPath::Special { .. } => Some(entry.clone()),}}-fn resolve_permission_path(path: &FileSystemPath, cwd: &Path) -> Option<AbsolutePathBuf> {+fn resolve_permission_path(+ path: &FileSystemPath,+ context: &FileSystemSandboxPolicyContext<'_>,+) -> Option<PathUri> {match path {- FileSystemPath::Path { path } => path.to_abs_path().ok(),+ FileSystemPath::Path { path } => Some(path.clone()),FileSystemPath::GlobPattern { .. } => None,FileSystemPath::Special { value } => match value {- FileSystemSpecialPath::Root => {- let root = cwd.ancestors().last()?;- AbsolutePathBuf::from_absolute_path(root).ok()- }+ FileSystemSpecialPath::Root => file_system_root(context),FileSystemSpecialPath::ProjectRoots { subpath } => {- let cwd = AbsolutePathBuf::from_absolute_path(cwd).ok()?;- Some(match subpath {- Some(subpath) => {- AbsolutePathBuf::resolve_path_against_base(subpath, cwd.as_path())- }- None => cwd,- })- }- FileSystemSpecialPath::Tmpdir => {- let tmpdir = std::env::var_os("TMPDIR")?;- if tmpdir.is_empty() {- None- } else {- AbsolutePathBuf::from_absolute_path(PathBuf::from(tmpdir)).ok()+ let root = context.workspace_roots.first()?;+ match subpath {+ Some(subpath) => root.join(subpath).ok(),+ None => Some(root.clone()),}}- FileSystemSpecialPath::SlashTmp if cfg!(unix) => {- AbsolutePathBuf::from_absolute_path("/tmp")- .ok()- .filter(|path| path.as_path().is_dir())+ FileSystemSpecialPath::Tmpdir => context.temporary_directories?.first().cloned(),+ FileSystemSpecialPath::SlashTmp+ if context.cwd.infer_path_convention() == Some(PathConvention::Posix) =>+ {+ context.cwd.join("/tmp").ok()}FileSystemSpecialPath::SlashTmp| FileSystemSpecialPath::Minimal@@ -437,6 +535,81 @@ fn resolve_permission_path(path: &FileSystemPath, cwd: &Path) -> Option<Absolute}}+fn materialize_context_dependent_entries(+ entries: &[FileSystemSandboxEntry],+ context: &FileSystemSandboxPolicyContext<'_>,+) -> Option<Vec<FileSystemSandboxEntry>> {+ let mut materialized = Vec::new();+ for entry in entries {+ match &entry.path {+ FileSystemPath::Special {+ value: FileSystemSpecialPath::ProjectRoots { .. },+ } => {+ let mut resolved = Vec::new();+ for root in context.workspace_roots {+ let mut root_context = *context;+ root_context.workspace_roots = std::slice::from_ref(root);+ let Some(path) = resolve_permission_path(&entry.path, &root_context) else {+ if entry.access == FileSystemAccessMode::Deny {+ return None;+ }+ continue;+ };+ resolved.push(materialized_path_entry(entry, path));+ }+ if entry.access == FileSystemAccessMode::Deny && resolved.is_empty() {+ return None;+ }+ materialized.extend(resolved);+ }+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Tmpdir,+ } => {+ let Some(temporary_directories) = context.temporary_directories else {+ if entry.access == FileSystemAccessMode::Deny {+ return None;+ }+ materialized.push(entry.clone());+ continue;+ };+ materialized.extend(+ temporary_directories+ .iter()+ .cloned()+ .map(|path| materialized_path_entry(entry, path)),+ );+ }+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ } => {+ resolve_permission_path(&entry.path, context)?;+ materialized.push(entry.clone());+ }+ _ => {+ let Some(entry) = materialize_cwd_dependent_entry(entry, context) else {+ if entry.access == FileSystemAccessMode::Deny {+ return None;+ }+ continue;+ };+ materialized.push(entry);+ }+ }+ }+ Some(materialized)+}++fn materialized_path_entry(+ entry: &FileSystemSandboxEntry,+ path: PathUri,+) -> FileSystemSandboxEntry {+ FileSystemSandboxEntry {+ path: FileSystemPath::Path { path },+ access: entry.access,+ missing_path_behavior: entry.missing_path_behavior,+ }+}+fn merge_permission_entries(base: &[FileSystemSandboxEntry],permissions: &[FileSystemSandboxEntry],diff --git a/codex-rs/sandboxing/src/policy_transforms_tests.rs b/codex-rs/sandboxing/src/policy_transforms_tests.rsindex ae7fe9ae41..97334bfc40 100644--- a/codex-rs/sandboxing/src/policy_transforms_tests.rs+++ b/codex-rs/sandboxing/src/policy_transforms_tests.rs@@ -1,8 +1,11 @@use super::effective_file_system_sandbox_policy;use super::intersect_permission_profiles;+use super::intersect_permission_profiles_with_context;use super::materialize_additional_permissions;+use super::materialize_additional_permissions_with_context;use super::merge_file_system_policy_with_additional_permissions;use super::normalize_additional_permissions;+use super::normalize_additional_permissions_with_context;use super::should_require_platform_sandbox;use codex_protocol::models::AdditionalPermissionProfile as PermissionProfile;use codex_protocol::models::FileSystemPermissions;@@ -11,9 +14,11 @@ use codex_protocol::permissions::FileSystemAccessMode;use codex_protocol::permissions::FileSystemPath;use codex_protocol::permissions::FileSystemSandboxEntry;use codex_protocol::permissions::FileSystemSandboxPolicy;+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::PathUri;use dunce::canonicalize;use pretty_assertions::assert_eq;#[cfg(unix)]@@ -129,6 +134,39 @@ fn normalize_additional_permissions_preserves_network() {);}+#[test]+fn normalize_additional_permissions_only_checks_convention_with_context() {+ let windows_path = PathUri::parse("file:///C:/workspace/out").expect("Windows path URI");+ let permissions = PermissionProfile {+ file_system: Some(FileSystemPermissions {+ entries: vec![FileSystemSandboxEntry::new(+ FileSystemPath::Path { path: windows_path },+ FileSystemAccessMode::Write,+ )],+ glob_scan_max_depth: None,+ }),+ ..Default::default()+ };++ assert_eq!(+ normalize_additional_permissions(permissions.clone()).expect("context-free permissions"),+ permissions+ );++ let cwd = PathUri::parse("file:///workspace").expect("POSIX cwd URI");+ let workspace_roots = [cwd.clone()];+ let context = FileSystemSandboxPolicyContext {+ cwd: &cwd,+ workspace_roots: &workspace_roots,+ user_home_dir: None,+ temporary_directories: None,+ };+ assert!(+ normalize_additional_permissions_with_context(permissions, &context).is_err(),+ "context-aware normalization should reject mismatched conventions"+ );+}+#[cfg(unix)]#[test]fn normalize_additional_permissions_preserves_symlinked_write_paths() {@@ -242,6 +280,7 @@ fn materialize_additional_permissions_preserves_authority_and_constraints() {canonicalize(temp_dir.path()).expect("canonicalize temp dir"),).expect("absolute temp dir");+ let home = PathUri::from_host_native_path("~").expect("host home");let project_path = |subpath: &str| FileSystemPath::Special {value: FileSystemSpecialPath::project_roots(Some(subpath.to_owned())),};@@ -263,6 +302,8 @@ fn materialize_additional_permissions_preserves_authority_and_constraints() {FileSystemSandboxEntry::new(project_path("private/reopened"), Write),reopened.clone(),deny_glob("**/*.env".to_owned()),+ deny_glob("~".to_owned()),+ deny_glob("~/private/*.env".to_owned()),]);let expected = profile(vec![FileSystemSandboxEntry::new(cwd.clone().into(), Write),@@ -270,6 +311,12 @@ fn materialize_additional_permissions_preserves_authority_and_constraints() {FileSystemSandboxEntry::skip_missing_path(cwd.join("readonly").into(), Read),reopened,deny_glob(cwd.join("**/*.env").to_string_lossy().into_owned()),+ deny_glob(home.inferred_native_path_string()),+ deny_glob(+ home.join("private/*.env")+ .expect("home-relative deny glob")+ .inferred_native_path_string(),+ ),]);assert_eq!(@@ -279,6 +326,50 @@ fn materialize_additional_permissions_preserves_authority_and_constraints() {);}+#[test]+fn materialize_additional_permissions_ignores_empty_tmpdir_deny() {+ let cwd = PathUri::parse("file:///workspace").expect("cwd URI");+ let workspace_roots = [cwd.clone()];+ let temporary_directories = [];+ let context = FileSystemSandboxPolicyContext {+ cwd: &cwd,+ workspace_roots: &workspace_roots,+ user_home_dir: None,+ temporary_directories: Some(&temporary_directories),+ };+ let write = FileSystemSandboxEntry::new(+ FileSystemPath::Path { path: cwd.clone() },+ FileSystemAccessMode::Write,+ );+ let permissions = PermissionProfile {+ file_system: Some(FileSystemPermissions {+ entries: vec![+ write.clone(),+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Tmpdir,+ },+ FileSystemAccessMode::Deny,+ ),+ ],+ glob_scan_max_depth: None,+ }),+ ..Default::default()+ };++ assert_eq!(+ materialize_additional_permissions_with_context(permissions, &context)+ .expect("permissions"),+ PermissionProfile {+ file_system: Some(FileSystemPermissions {+ entries: vec![write],+ glob_scan_max_depth: None,+ }),+ ..Default::default()+ }+ );+}+#[test]fn intersect_permission_profiles_preserves_explicit_empty_requested_reads() {let temp_dir = TempDir::new().expect("create temp dir");@@ -449,6 +540,58 @@ fn intersect_permission_profiles_preserves_deny_across_case_variant_grant() {);}+#[test]+fn intersect_permission_profiles_preserves_rooted_first_segment_glob_deny() {+ use FileSystemAccessMode::Deny;+ use FileSystemAccessMode::Write;++ for (cwd_uri, grant_uri, pattern) in [+ ("file:///workspace", "file:///fooX", "/foo*/*"),+ ("file:///workspace", "file:///foo%5Cbar", r"/foo\\*/*"),+ ("file:///C:/workspace", "file:///C:/fooX", r"C:\foo*\*"),+ (+ "file://server/share/workspace",+ "file://server/share/fooX",+ r"\\server\share\foo*\*",+ ),+ ] {+ let cwd = PathUri::parse(cwd_uri).expect("cwd URI");+ let grant_path = PathUri::parse(grant_uri).expect("grant URI");+ let workspace_roots = [cwd.clone()];+ let context = FileSystemSandboxPolicyContext {+ cwd: &cwd,+ workspace_roots: &workspace_roots,+ user_home_dir: None,+ temporary_directories: None,+ };+ let grant_entry =+ FileSystemSandboxEntry::new(FileSystemPath::Path { path: grant_path }, Write);+ let deny_entry = FileSystemSandboxEntry::new(+ FileSystemPath::GlobPattern {+ pattern: pattern.to_string(),+ },+ Deny,+ );+ let profile = |entries| PermissionProfile {+ file_system: Some(FileSystemPermissions {+ entries,+ glob_scan_max_depth: None,+ }),+ ..Default::default()+ };++ assert_eq!(+ intersect_permission_profiles_with_context(+ profile(vec![grant_entry.clone(), deny_entry.clone()]),+ profile(vec![grant_entry.clone()]),+ &context,+ ),+ profile(vec![grant_entry, deny_entry]),+ "deny glob should survive for {pattern}",+ );+ }+}+#[test]fn intersect_permission_profiles_preserves_opaque_child_deny() {use std::ffi::OsString;