Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add executor-context filesystem permission helpers (#43939)

Sean Huangc53f342fecfb
diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs
index f555f74584..9af0ec6d0d 100644
--- a/codex-rs/core/src/config/mod.rs
+++ b/codex-rs/core/src/config/mod.rs
@@ -116,10 +116,12 @@ use codex_protocol::models::SandboxEnforcement;
use codex_protocol::openai_models::ModelMessages;
use codex_protocol::openai_models::ModelsResponse;
use codex_protocol::openai_models::ReasoningEffort;
+use codex_protocol::permissions::DenyReadValidator;
+use codex_protocol::permissions::DenyReadViolation;
use codex_protocol::permissions::FileSystemPath;
use codex_protocol::permissions::FileSystemSandboxPolicy;
+use codex_protocol::permissions::FileSystemSandboxPolicyContext;
use codex_protocol::permissions::NetworkSandboxPolicy;
-use codex_protocol::permissions::ReadDenyMatcher;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::MultiAgentVersion;
use codex_protocol::protocol::SandboxPolicy;
@@ -4101,49 +4103,65 @@ impl Config {
}) = filesystem_requirements.as_ref()
&& let Some(managed_file_system_policy) = managed_deny_read_policy.as_ref()
{
- let managed_deny_matcher =
- ReadDenyMatcher::try_new_for_local_paths(managed_file_system_policy, resolved_cwd.as_path())
- .map_err(std::io::Error::other)?;
- let managed_file_system_policy = Arc::clone(managed_file_system_policy);
+ let cwd = PathUri::from_abs_path(&resolved_cwd);
+ let user_home_dir = PathUri::from_host_native_path("~").ok();
+ let temporary_directories = std::env::var_os("TMPDIR")
+ .filter(|path| !path.is_empty())
+ .and_then(|path| AbsolutePathBuf::from_absolute_path(PathBuf::from(path)).ok())
+ .map(PathUri::from)
+ .into_iter()
+ .collect::<Vec<_>>();
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: std::slice::from_ref(&cwd),
+ user_home_dir: user_home_dir.as_ref(),
+ temporary_directories: Some(&temporary_directories),
+ };
+ let validator = DenyReadValidator::new(managed_file_system_policy, &context)
+ .map_err(std::io::Error::other)?;
let requirement_source = requirement_source.clone();
constrained_permission_profile
.value
.add_validator(move |permission_profile| {
- let file_system_policy = permission_profile.file_system_sandbox_policy();
- let missing_required_deny = managed_file_system_policy
- .entries
- .iter()
- .any(|entry| !file_system_policy.entries.contains(entry));
- let violating_root = file_system_policy
- .entries
- .iter()
- .filter(|entry| entry.access.can_read())
- .find_map(|entry| {
- let FileSystemPath::Path { path } = &entry.path else {
- return None;
+ let mut file_system_policy = permission_profile.file_system_sandbox_policy();
+ // Preserve the native conversion boundary before the shared URI checks.
+ // Mandatory entries are Deny entries, so their identity stays unchanged.
+ file_system_policy.entries.retain_mut(|entry| {
+ if entry.access.can_read()
+ && let FileSystemPath::Path { path } = &mut entry.path
+ {
+ let Ok(native_path) = path.to_abs_path() else {
+ return false;
};
- let path = path.to_abs_path().ok()?;
- managed_deny_matcher
- .as_ref()
- .is_some_and(|matcher| matcher.is_local_path_read_denied(path.as_path()))
- .then_some(path)
- });
- if missing_required_deny || violating_root.is_some() {
- return Err(ConstraintError::InvalidValue {
+ *path = PathUri::from(native_path);
+ }
+ true
+ });
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: std::slice::from_ref(&cwd),
+ user_home_dir: user_home_dir.as_ref(),
+ temporary_directories: Some(&temporary_directories),
+ };
+ validator.validate(&file_system_policy, &context).map_err(|violation| {
+ let candidate = match violation {
+ DenyReadViolation::MissingRequiredDeny => "missing managed deny".to_string(),
+ DenyReadViolation::ReadablePath(path) => path.to_abs_path().map_or_else(
+ |_| path.to_string(),
+ |path| path.to_string_lossy().into_owned(),
+ ),
+ };
+ ConstraintError::InvalidValue {
field_name: "permissions.filesystem",
- candidate: violating_root
- .map_or_else(|| "missing managed deny".to_string(), |path| {
- path.to_string_lossy().into_owned()
- }),
+ candidate,
allowed: "all managed deny_read restrictions".to_string(),
requirement_source: requirement_source.clone(),
- });
- }
-
- Ok(())
+ }
+ })
})
.map_err(std::io::Error::from)?;
}
+
let permission_profile_state = PermissionProfileState::from_constrained_active_profile(
constrained_permission_profile.value,
active_permission_profile,
diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rs
index d9fed84077..f2fe1af541 100644
--- a/codex-rs/protocol/src/models.rs
+++ b/codex-rs/protocol/src/models.rs
@@ -550,6 +550,24 @@ impl PermissionProfile {
}
}
+ /// Legacy workspace-write settings interpreted for executor-owned paths.
+ pub fn workspace_write_with_path_uris(
+ writable_roots: &[PathUri],
+ network: NetworkSandboxPolicy,
+ exclude_tmpdir_env_var: bool,
+ exclude_slash_tmp: bool,
+ ) -> Self {
+ let file_system = FileSystemSandboxPolicy::workspace_write_with_path_uris(
+ writable_roots,
+ exclude_tmpdir_env_var,
+ exclude_slash_tmp,
+ );
+ Self::Managed {
+ file_system: ManagedFileSystemPermissions::from_sandbox_policy(&file_system),
+ network,
+ }
+ }
+
pub fn materialize_project_roots_with_workspace_roots(
self,
workspace_roots: &[AbsolutePathBuf],
diff --git a/codex-rs/protocol/src/permissions.rs b/codex-rs/protocol/src/permissions.rs
index 71bf57d66d..894e1268c3 100644
--- a/codex-rs/protocol/src/permissions.rs
+++ b/codex-rs/protocol/src/permissions.rs
@@ -24,8 +24,12 @@ use crate::protocol::NetworkAccess;
use crate::protocol::SandboxPolicy;
use crate::protocol::WritableRoot;
+mod deny_read_validator;
+mod target;
mod windows_glob;
+pub use deny_read_validator::DenyReadValidator;
+pub use deny_read_validator::DenyReadViolation;
pub use windows_glob::WindowsDenyReadGlobScan;
pub use windows_glob::windows_deny_read_glob_scan;
diff --git a/codex-rs/protocol/src/permissions/deny_read_validator.rs b/codex-rs/protocol/src/permissions/deny_read_validator.rs
new file mode 100644
index 0000000000..5a1a9a21d7
--- /dev/null
+++ b/codex-rs/protocol/src/permissions/deny_read_validator.rs
@@ -0,0 +1,102 @@
+//! Core's mandatory-denial validation, shared without resolving paths on the controller.
+//! Checks raw concrete grants; policy application and sandbox enforcement remain caller-owned.
+
+use super::FileSystemAccessMode;
+use super::FileSystemPath;
+use super::FileSystemSandboxEntry;
+use super::FileSystemSandboxKind;
+use super::FileSystemSandboxPolicy;
+use super::FileSystemSandboxPolicyContext;
+use super::FileSystemSpecialPath;
+use super::InvalidDenyReadGlobBehavior;
+use super::PreparedReadDenyMatcher;
+use codex_utils_path_uri::PathConvention;
+use codex_utils_path_uri::PathUri;
+
+/// Prepared mandatory rules reused when a caller replaces its selected profile.
+pub struct DenyReadValidator {
+ required_entries: Vec<FileSystemSandboxEntry>,
+ matcher: Option<PreparedReadDenyMatcher>,
+}
+
+/// Details needed to retain the caller's existing sourced constraint diagnostics.
+#[derive(Debug, PartialEq, Eq)]
+pub enum DenyReadViolation {
+ MissingRequiredDeny,
+ ReadablePath(PathUri),
+}
+
+impl DenyReadValidator {
+ /// Prepares the strict matcher once, using the supplied executor facts.
+ pub fn new(
+ required: &FileSystemSandboxPolicy,
+ context: &FileSystemSandboxPolicyContext<'_>,
+ ) -> Result<Self, String> {
+ let matcher = has_context_read_denials(required, context)
+ .then(|| {
+ required
+ .prepare_deny_read_matcher(context, InvalidDenyReadGlobBehavior::ReturnError)
+ })
+ .transpose()?;
+ Ok(Self {
+ required_entries: required.entries.clone(),
+ matcher,
+ })
+ }
+
+ /// Preserves Core's entry-presence and raw readable-path checks.
+ ///
+ /// Symbolic entries are not expanded. An equally specific deny does not
+ /// exempt a concrete readable grant from this validation. Native callers
+ /// retain their native-path conversion boundary before passing the policy.
+ pub fn validate(
+ &self,
+ selected: &FileSystemSandboxPolicy,
+ context: &FileSystemSandboxPolicyContext<'_>,
+ ) -> Result<(), DenyReadViolation> {
+ let missing_required_deny = self
+ .required_entries
+ .iter()
+ .any(|entry| !selected.entries.contains(entry));
+ let violating_root = selected
+ .entries
+ .iter()
+ .filter(|entry| entry.access.can_read())
+ .find_map(|entry| {
+ let FileSystemPath::Path { path } = &entry.path else {
+ return None;
+ };
+ if path.infer_path_convention() != context.cwd.infer_path_convention() {
+ return None;
+ }
+ self.matcher
+ .as_ref()
+ .is_some_and(|matcher| {
+ FileSystemSandboxPolicy::matches_prepared_read_deny(path, context, matcher)
+ })
+ .then_some(path)
+ });
+ // Core reports the first conflicting path even when a required entry is missing too.
+ if let Some(path) = violating_root {
+ return Err(DenyReadViolation::ReadablePath(path.clone()));
+ }
+ if missing_required_deny {
+ return Err(DenyReadViolation::MissingRequiredDeny);
+ }
+ Ok(())
+ }
+}
+
+pub(super) fn has_context_read_denials(
+ policy: &FileSystemSandboxPolicy,
+ context: &FileSystemSandboxPolicyContext<'_>,
+) -> bool {
+ policy.kind == FileSystemSandboxKind::Restricted
+ && policy.entries.iter().any(|entry| {
+ entry.access == FileSystemAccessMode::Deny
+ && !matches!(&entry.path,
+ FileSystemPath::Special { value: FileSystemSpecialPath::SlashTmp }
+ if context.cwd.infer_path_convention() != Some(PathConvention::Posix)
+ )
+ })
+}
diff --git a/codex-rs/protocol/src/permissions/target.rs b/codex-rs/protocol/src/permissions/target.rs
new file mode 100644
index 0000000000..fd6c98d809
--- /dev/null
+++ b/codex-rs/protocol/src/permissions/target.rs
@@ -0,0 +1,149 @@
+//! Executor-context policy operations that never consult controller paths or environment.
+
+use super::FileSystemPath;
+use super::FileSystemSandboxPolicy;
+use super::FileSystemSandboxPolicyContext;
+use super::FileSystemSpecialPath;
+use super::InvalidDenyReadGlobBehavior;
+use super::ReadDenyMatcher;
+use super::deny_read_validator::DenyReadValidator;
+use super::deny_read_validator::has_context_read_denials;
+use codex_utils_path_uri::PathConvention;
+use codex_utils_path_uri::PathUri;
+
+const INVALID_PATH: &str = "managed filesystem denial cannot be materialized safely";
+const SHADOWED: &str = "managed filesystem denial is shadowed by a selected profile grant";
+
+impl ReadDenyMatcher {
+ /// Builds a strict matcher using only the supplied execution-host paths.
+ pub fn try_new_with_context(
+ policy: &FileSystemSandboxPolicy,
+ context: &FileSystemSandboxPolicyContext<'_>,
+ ) -> Result<Option<Self>, String> {
+ if !has_context_read_denials(policy, context) {
+ return Ok(None);
+ }
+ validate_context_paths(policy, context)?;
+ let prepared =
+ policy.prepare_deny_read_matcher(context, InvalidDenyReadGlobBehavior::ReturnError)?;
+ Ok(Some(Self {
+ native_cwd: None,
+ user_home_dir: None,
+ temporary_directories: Vec::new(),
+ prepared,
+ }))
+ }
+}
+
+impl FileSystemSandboxPolicy {
+ /// Checks exact-root read access using paths owned by the execution host.
+ /// Deny glob enforcement is checked separately with [`ReadDenyMatcher`].
+ pub fn can_read_path(
+ &self,
+ path: &PathUri,
+ context: &FileSystemSandboxPolicyContext<'_>,
+ ) -> bool {
+ self.resolve_access(path, context).can_read()
+ }
+
+ /// Preserves workspace-root symbols and adds their executor-owned concrete paths.
+ pub fn with_materialized_project_roots_for_path_uris(mut self, roots: &[PathUri]) -> Self {
+ for entry in self
+ .clone()
+ .materialize_project_roots_with_path_uris(roots)
+ .entries
+ {
+ if !self.entries.contains(&entry) {
+ self.entries.push(entry);
+ }
+ }
+ self
+ }
+
+ /// Builds workspace-write defaults without inspecting the execution host's filesystem.
+ pub fn workspace_write_with_path_uris(
+ roots: &[PathUri],
+ exclude_tmpdir_env_var: bool,
+ exclude_slash_tmp: bool,
+ ) -> Self {
+ Self::workspace_write(&[], exclude_tmpdir_env_var, exclude_slash_tmp)
+ .with_materialized_project_roots_for_path_uris(roots)
+ }
+
+ /// Resolves deny glob text using the execution host's convention and home.
+ pub fn get_unreadable_globs_with_context(
+ &self,
+ context: &FileSystemSandboxPolicyContext<'_>,
+ ) -> Result<Vec<String>, String> {
+ self.deny_read_globs(context)
+ }
+
+ /// Checks the existing Core rules for required entries and readable concrete paths.
+ ///
+ /// Sandbox-mode selection and native glob expansion remain caller-owned.
+ pub fn validate_managed_deny_read(
+ &self,
+ required: &Self,
+ context: &FileSystemSandboxPolicyContext<'_>,
+ ) -> Result<(), String> {
+ DenyReadValidator::new(required, context)?
+ .validate(self, context)
+ .map_err(|_| SHADOWED.to_string())
+ }
+}
+
+fn validate_context_paths(
+ policy: &FileSystemSandboxPolicy,
+ context: &FileSystemSandboxPolicyContext<'_>,
+) -> Result<(), String> {
+ let convention = context.cwd.infer_path_convention().ok_or(INVALID_PATH)?;
+ let valid = |path: &PathUri| {
+ path.infer_path_convention() == Some(convention) && path.lexical_depth().is_some()
+ };
+ if !valid(context.cwd) || context.workspace_roots.iter().any(|path| !valid(path)) {
+ return Err(INVALID_PATH.into());
+ }
+ for entry in &policy.entries {
+ match &entry.path {
+ FileSystemPath::Path { path } if !valid(path) => return Err(INVALID_PATH.into()),
+ FileSystemPath::Special {
+ value: FileSystemSpecialPath::Tmpdir,
+ } => {
+ let directories = context.temporary_directories.ok_or(
+ "executor temporary-directory metadata is unavailable for managed filesystem denials",
+ )?;
+ if directories.iter().any(|path| !valid(path)) {
+ return Err(
+ "executor temporary-directory metadata cannot be materialized safely"
+ .into(),
+ );
+ }
+ }
+ FileSystemPath::Special {
+ value:
+ FileSystemSpecialPath::ProjectRoots {
+ subpath: Some(subpath),
+ },
+ } if context
+ .workspace_roots
+ .iter()
+ .any(|root| root.join(subpath).is_err()) =>
+ {
+ return Err(INVALID_PATH.into());
+ }
+ FileSystemPath::GlobPattern { pattern }
+ if (pattern.starts_with("~/")
+ || convention == PathConvention::Windows && pattern.starts_with("~\\"))
+ && !context.user_home_dir.is_some_and(valid) =>
+ {
+ return Err(INVALID_PATH.into());
+ }
+ _ => {}
+ }
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+#[path = "target_tests.rs"]
+mod tests;
diff --git a/codex-rs/protocol/src/permissions/target_tests.rs b/codex-rs/protocol/src/permissions/target_tests.rs
new file mode 100644
index 0000000000..7e4876c222
--- /dev/null
+++ b/codex-rs/protocol/src/permissions/target_tests.rs
@@ -0,0 +1,269 @@
+//! Regression coverage for remote path matching and managed-denial enforcement.
+
+use super::*;
+use crate::permissions::FileSystemAccessMode;
+use crate::permissions::FileSystemSandboxEntry;
+use crate::permissions::PROTECTED_METADATA_PATH_NAMES;
+use pretty_assertions::assert_eq;
+
+fn uri(input: &str) -> PathUri {
+ PathUri::parse(input).unwrap()
+}
+
+fn deny(path: FileSystemPath) -> FileSystemSandboxEntry {
+ FileSystemSandboxEntry::new(path, FileSystemAccessMode::Deny)
+}
+
+#[test]
+fn read_denials_use_target_paths_and_native_glob_semantics() {
+ for base in [
+ "file:///work/repo",
+ "file:///Users/agent/repo",
+ "file:///C:/work/repo",
+ "file://server/share/repo",
+ ] {
+ let cwd = uri(base);
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: std::slice::from_ref(&cwd),
+ user_home_dir: Some(&cwd),
+ temporary_directories: Some(&[]),
+ };
+ let policy = FileSystemSandboxPolicy::restricted(vec![
+ deny(FileSystemPath::Path {
+ path: cwd.join("private").unwrap(),
+ }),
+ deny(FileSystemPath::GlobPattern {
+ pattern: "~/secrets/*.key".into(),
+ }),
+ deny(FileSystemPath::GlobPattern {
+ pattern: "nested/**/*.env".into(),
+ }),
+ ]);
+ let matcher = ReadDenyMatcher::try_new_with_context(&policy, &context)
+ .unwrap()
+ .unwrap();
+ for (path, expected) in [
+ ("private", true),
+ ("private/file", true),
+ ("private-other/file", false),
+ ("secrets/token.key", true),
+ ("secrets/nested/token.key", false),
+ ("nested/.env", true),
+ ("nested/deep/token.env", true),
+ ("public/file", false),
+ ] {
+ assert_eq!(
+ matcher.is_read_denied_uri(&cwd.join(path).unwrap(), &context),
+ expected,
+ "{base}: {path}"
+ );
+ }
+ assert_eq!(
+ matcher.is_read_denied_uri(&cwd.join("PRIVATE/file").unwrap(), &context),
+ cwd.infer_path_convention() == Some(PathConvention::Windows),
+ );
+ assert!(matcher.is_read_denied_uri(&uri("file:///C:/foreign%2Fpath"), &context));
+ }
+}
+
+#[test]
+fn managed_denials_reject_concrete_read_and_write_grants() {
+ for base in [
+ "file:///work/repo",
+ "file:///C:/work/repo",
+ "file://server/share/repo",
+ ] {
+ let cwd = uri(base);
+ let private = cwd.join("private").unwrap();
+ let required = FileSystemSandboxPolicy::restricted(vec![deny(FileSystemPath::Path {
+ path: private.clone(),
+ })]);
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: std::slice::from_ref(&cwd),
+ user_home_dir: None,
+ temporary_directories: Some(&[]),
+ };
+ let mut policy = FileSystemSandboxPolicy::workspace_write_with_path_uris(
+ &[],
+ /*exclude_tmpdir_env_var*/ true,
+ /*exclude_slash_tmp*/ true,
+ );
+ policy.entries.extend(required.entries.clone());
+ assert_eq!(
+ policy.validate_managed_deny_read(&required, &context),
+ Ok(())
+ );
+ for access in [FileSystemAccessMode::Read, FileSystemAccessMode::Write] {
+ let mut carveout = policy.clone();
+ carveout.entries.push(FileSystemSandboxEntry::new(
+ FileSystemPath::Path {
+ path: private.join("carveout").unwrap(),
+ },
+ access,
+ ));
+ assert_eq!(
+ carveout.validate_managed_deny_read(&required, &context),
+ Err(SHADOWED.into())
+ );
+ }
+ }
+}
+
+#[test]
+fn managed_denials_preserve_native_metadata_read_rejections() {
+ for base in [
+ "file:///executor/home",
+ "file:///C:/Users/executor",
+ "file://server/share/executor",
+ ] {
+ let extra_root = uri(base);
+ let cwd = extra_root.join("workspace").unwrap();
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: std::slice::from_ref(&cwd),
+ user_home_dir: Some(&extra_root),
+ temporary_directories: Some(&[]),
+ };
+ let legacy = FileSystemSandboxPolicy::workspace_write_with_path_uris(
+ std::slice::from_ref(&extra_root),
+ /*exclude_tmpdir_env_var*/ true,
+ /*exclude_slash_tmp*/ true,
+ );
+ for name in [".codex", ".git"] {
+ let denied_root = extra_root.join(name).unwrap();
+ let child = denied_root.join("reopened").unwrap();
+ for (path, expected_root_access) in [
+ (
+ FileSystemPath::Path {
+ path: denied_root.clone(),
+ },
+ FileSystemAccessMode::Deny,
+ ),
+ (
+ FileSystemPath::GlobPattern {
+ pattern: denied_root.join("*").unwrap().inferred_native_path_string(),
+ },
+ FileSystemAccessMode::Read,
+ ),
+ ] {
+ let required = FileSystemSandboxPolicy::restricted(vec![deny(path)]);
+ let mut policy = legacy.clone();
+ policy.preserve_deny_read_restrictions_from(&required);
+ assert_eq!(
+ (
+ policy.resolve_access(&denied_root, &context),
+ policy.validate_managed_deny_read(&required, &context),
+ ),
+ (
+ expected_root_access,
+ if expected_root_access == FileSystemAccessMode::Deny {
+ Err(SHADOWED.into())
+ } else {
+ Ok(())
+ },
+ ),
+ "{base}: {name}",
+ );
+ let matcher = ReadDenyMatcher::try_new_with_context(&required, &context)
+ .unwrap()
+ .unwrap();
+ assert!(matcher.is_read_denied_uri(&child, &context));
+ for access in [FileSystemAccessMode::Read, FileSystemAccessMode::Write] {
+ let mut reopened = policy.clone();
+ reopened.entries.push(FileSystemSandboxEntry::new(
+ FileSystemPath::Path {
+ path: child.clone(),
+ },
+ access,
+ ));
+ assert_eq!(
+ reopened.validate_managed_deny_read(&required, &context),
+ Err(SHADOWED.into()),
+ "{base}: {name}: {access}",
+ );
+ }
+ }
+ }
+ }
+}
+
+#[test]
+fn malformed_or_unresolvable_denials_fail_closed() {
+ let cwd = uri("file:///work/repo");
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: &[],
+ user_home_dir: None,
+ temporary_directories: Some(&[]),
+ };
+ for pattern in ["~/secrets/**", "secrets/[z-a]"] {
+ let policy = FileSystemSandboxPolicy::restricted(vec![deny(FileSystemPath::GlobPattern {
+ pattern: pattern.into(),
+ })]);
+ assert!(ReadDenyMatcher::try_new_with_context(&policy, &context).is_err());
+ }
+ let policy = FileSystemSandboxPolicy::restricted(vec![deny(FileSystemPath::Path {
+ path: uri("file:///C:/private"),
+ })]);
+ assert!(ReadDenyMatcher::try_new_with_context(&policy, &context).is_err());
+}
+
+#[test]
+fn slash_tmp_denials_follow_the_executor_convention() {
+ let policy = FileSystemSandboxPolicy::restricted(vec![deny(FileSystemPath::Special {
+ value: FileSystemSpecialPath::SlashTmp,
+ })]);
+ for (base, active) in [("file:///work", true), ("file:///C:/work", false)] {
+ let cwd = uri(base);
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: &[],
+ user_home_dir: None,
+ temporary_directories: None,
+ };
+ let matcher = ReadDenyMatcher::try_new_with_context(&policy, &context).unwrap();
+ assert_eq!(matcher.is_some(), active);
+ if let Some(matcher) = matcher {
+ assert!(matcher.is_read_denied_uri(&cwd.join("/tmp/file").unwrap(), &context));
+ }
+ }
+}
+
+#[test]
+fn remote_workspace_write_keeps_metadata_protected() {
+ let cwd = uri("file:///C:/repo");
+ let extra = uri("file:///D:/extra");
+ let policy = FileSystemSandboxPolicy::workspace_write_with_path_uris(
+ std::slice::from_ref(&extra),
+ /*exclude_tmpdir_env_var*/ true,
+ /*exclude_slash_tmp*/ true,
+ );
+ let context = FileSystemSandboxPolicyContext {
+ cwd: &cwd,
+ workspace_roots: std::slice::from_ref(&cwd),
+ user_home_dir: None,
+ temporary_directories: Some(&[]),
+ };
+ for name in PROTECTED_METADATA_PATH_NAMES {
+ assert!(
+ policy
+ .entries
+ .contains(&FileSystemSandboxEntry::skip_missing_path(
+ FileSystemPath::Path {
+ path: extra.join(name).unwrap()
+ },
+ FileSystemAccessMode::Read,
+ ))
+ );
+ }
+ for root in [cwd.clone(), extra] {
+ assert!(policy.can_write_path(&root.join("file").unwrap(), &context));
+ for name in PROTECTED_METADATA_PATH_NAMES {
+ let path = root.join(name).unwrap().join("file").unwrap();
+ assert!(policy.can_read_path(&path, &context));
+ assert!(!policy.can_write_path(&path, &context));
+ }
+ }
+}
diff --git a/codex-rs/protocol/src/permissions/windows_glob.rs b/codex-rs/protocol/src/permissions/windows_glob.rs
index 641caa5ff0..3f424ead95 100644
--- a/codex-rs/protocol/src/permissions/windows_glob.rs
+++ b/codex-rs/protocol/src/permissions/windows_glob.rs
@@ -1,4 +1,5 @@
//! Windows deny-glob scan bounds shared by policy validation and native ACL expansion.
+use codex_utils_path_uri::PathConvention;
/// Literal scan root and maximum traversal depth for a Windows deny glob.
pub struct WindowsDenyReadGlobScan<'a> {
@@ -26,8 +27,8 @@ pub fn windows_deny_read_glob_scan(
}
None => (".", pattern),
};
- let components = pattern_suffix
- .split(['/', '\\'])
+ let components = PathConvention::Windows
+ .path_segments(pattern_suffix)
.filter(|component| !component.is_empty())
.collect::<Vec<_>>();
let max_depth = if components.contains(&"**") {