diff --git a/codex-rs/protocol/src/permissions.rs b/codex-rs/protocol/src/permissions.rs index 3409237a71..b3983699fe 100644 --- a/codex-rs/protocol/src/permissions.rs +++ b/codex-rs/protocol/src/permissions.rs @@ -20,6 +20,7 @@ use strum_macros::Display; use tracing::error; use ts_rs::TS; +use crate::models::PermissionProfile; use crate::protocol::NetworkAccess; use crate::protocol::SandboxPolicy; use crate::protocol::WritableRoot; @@ -2424,6 +2425,52 @@ pub(crate) fn default_read_only_subpaths_for_writable_root( dedup_absolute_paths(subpaths, /*normalize_effective_paths*/ false) } +/// Resolves the compatibility writable roots for a permission profile. +pub fn compatibility_writable_roots_for_permission_profile( + permissions: &PermissionProfile, + cwd: &Path, +) -> Vec { + compatibility_sandbox_policy_for_permission_profile(permissions, cwd) + .get_writable_roots_with_cwd(cwd) +} + +/// Builds a legacy sandbox policy, using the workspace-write fallback for +/// profiles that cannot be expressed directly. +pub fn compatibility_sandbox_policy_for_permission_profile( + permissions: &PermissionProfile, + cwd: &Path, +) -> SandboxPolicy { + if let Ok(policy) = permissions.to_legacy_sandbox_policy(cwd) { + return policy; + } + + let (file_system_policy, network_policy) = permissions.to_runtime_permissions(); + let cwd_abs = AbsolutePathBuf::from_absolute_path(cwd).ok(); + let writable_roots = file_system_policy + .get_writable_roots_with_cwd(cwd) + .into_iter() + .map(|root| root.root) + .filter(|root| cwd_abs.as_ref() != Some(root)) + .collect(); + let tmpdir_writable = std::env::var_os("TMPDIR") + .filter(|tmpdir| !tmpdir.is_empty()) + .and_then(|tmpdir| AbsolutePathBuf::from_absolute_path(PathBuf::from(tmpdir)).ok()) + .is_some_and(|tmpdir| { + file_system_policy.can_write_local_path_with_cwd(tmpdir.as_path(), cwd) + }); + let slash_tmp = Path::new("/tmp"); + let slash_tmp_writable = slash_tmp.is_absolute() + && slash_tmp.is_dir() + && file_system_policy.can_write_local_path_with_cwd(slash_tmp, cwd); + + SandboxPolicy::WorkspaceWrite { + writable_roots, + network_access: network_policy.is_enabled(), + exclude_tmpdir_env_var: !tmpdir_writable, + exclude_slash_tmp: !slash_tmp_writable, + } +} + /// Rebuilds the filesystem policy that legacy sandbox runtimes enforce for a /// concrete cwd. /// diff --git a/codex-rs/protocol/src/permissions_tests.rs b/codex-rs/protocol/src/permissions_tests.rs index e0e1078e9c..11293b348d 100644 --- a/codex-rs/protocol/src/permissions_tests.rs +++ b/codex-rs/protocol/src/permissions_tests.rs @@ -1452,6 +1452,39 @@ fn missing_symbolic_metadata_carveouts_need_direct_runtime_enforcement() { ); } +#[test] +fn compatibility_writable_roots_preserve_the_output_only_fallback() -> io::Result<()> { + let temp = TempDir::new()?; + let root = AbsolutePathBuf::from_absolute_path(canonicalize_preserving_symlinks(temp.path())?)?; + let cwd = root.join("workspace"); + let output = root.join("output"); + std::fs::create_dir_all(output.join(".git"))?; + let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry::new( + output.clone().into(), + FileSystemAccessMode::Write, + )]); + + let profile = + PermissionProfile::from_runtime_permissions(&policy, NetworkSandboxPolicy::Restricted); + + assert_eq!( + compatibility_writable_roots_for_permission_profile(&profile, &cwd), + [ + WritableRoot { + root: output.clone(), + read_only_subpaths: vec![output.join(".git")], + protected_metadata_names: Vec::new(), + }, + WritableRoot { + root: cwd.clone(), + read_only_subpaths: vec![cwd.join(".codex")], + protected_metadata_names: Vec::new(), + }, + ] + ); + Ok(()) +} + #[test] fn root_write_with_read_only_child_is_not_full_disk_write() { let cwd = TempDir::new().expect("tempdir"); diff --git a/codex-rs/sandboxing/src/lib.rs b/codex-rs/sandboxing/src/lib.rs index 4b8583ff53..1c9ff49e1b 100644 --- a/codex-rs/sandboxing/src/lib.rs +++ b/codex-rs/sandboxing/src/lib.rs @@ -26,6 +26,7 @@ pub use bwrap::system_bwrap_warning; pub use codex_mxc_sandbox::CODEX_WINDOWS_MXC_ARG1; pub use codex_mxc_sandbox::is_available as windows_mxc_available; pub use codex_mxc_sandbox::run_main as run_windows_mxc_main; +pub use codex_protocol::permissions::compatibility_sandbox_policy_for_permission_profile; pub use codex_windows_sandbox::WindowsSandboxProxySettingsMode; pub use denial::is_likely_executor_managed_sandbox_denied; pub use denial::is_likely_sandbox_denied; @@ -38,7 +39,6 @@ pub use manager::SandboxTransformError; pub use manager::SandboxTransformRequest; pub use manager::SandboxType; pub use manager::SandboxablePreference; -pub use manager::compatibility_sandbox_policy_for_permission_profile; pub use manager::get_platform_sandbox; pub use manager::launch::WrappedSandboxCommand; pub use manager::with_managed_mitm_ca_readable_root; diff --git a/codex-rs/sandboxing/src/manager.rs b/codex-rs/sandboxing/src/manager.rs index 98f13e53d7..c4b0dd8868 100644 --- a/codex-rs/sandboxing/src/manager.rs +++ b/codex-rs/sandboxing/src/manager.rs @@ -16,9 +16,8 @@ use codex_network_proxy::NetworkProxy; use codex_protocol::config_types::WindowsSandboxLevel; use codex_protocol::models::AdditionalPermissionProfile; use codex_protocol::models::PermissionProfile; +#[cfg(target_os = "linux")] use codex_protocol::permissions::FileSystemSandboxPolicy; -use codex_protocol::permissions::NetworkSandboxPolicy; -use codex_protocol::protocol::SandboxPolicy; use codex_protocol::sandbox::SandboxOverride; pub use codex_protocol::sandbox::SandboxType; use codex_utils_absolute_path::AbsolutePathBuf; @@ -831,51 +830,6 @@ fn add_windows_sandbox_wrapper_setup_env_from_vars( } } -pub fn compatibility_sandbox_policy_for_permission_profile( - permissions: &PermissionProfile, - cwd: &Path, -) -> SandboxPolicy { - permissions - .to_legacy_sandbox_policy(cwd) - .unwrap_or_else(|_| { - let (file_system_policy, network_policy) = permissions.to_runtime_permissions(); - compatibility_workspace_write_policy(file_system_policy, network_policy, cwd) - }) -} - -fn compatibility_workspace_write_policy( - file_system_policy: FileSystemSandboxPolicy, - network_policy: NetworkSandboxPolicy, - cwd: &Path, -) -> SandboxPolicy { - let cwd_abs = AbsolutePathBuf::from_absolute_path(cwd).ok(); - let writable_roots = file_system_policy - .get_writable_roots_with_cwd(cwd) - .into_iter() - .map(|root| root.root) - .filter(|root| cwd_abs.as_ref() != Some(root)) - .collect(); - let tmpdir_writable = std::env::var_os("TMPDIR") - .filter(|tmpdir| !tmpdir.is_empty()) - .and_then(|tmpdir| { - AbsolutePathBuf::from_absolute_path(std::path::PathBuf::from(tmpdir)).ok() - }) - .is_some_and(|tmpdir| { - file_system_policy.can_write_local_path_with_cwd(tmpdir.as_path(), cwd) - }); - let slash_tmp = Path::new("/tmp"); - let slash_tmp_writable = slash_tmp.is_absolute() - && slash_tmp.is_dir() - && file_system_policy.can_write_local_path_with_cwd(slash_tmp, cwd); - - SandboxPolicy::WorkspaceWrite { - writable_roots, - network_access: network_policy.is_enabled(), - exclude_tmpdir_env_var: !tmpdir_writable, - exclude_slash_tmp: !slash_tmp_writable, - } -} - #[cfg(target_os = "linux")] fn ensure_linux_bubblewrap_is_supported( file_system_sandbox_policy: &FileSystemSandboxPolicy, diff --git a/codex-rs/sandboxing/src/windows.rs b/codex-rs/sandboxing/src/windows.rs index 643e784ab3..2671e460ad 100644 --- a/codex-rs/sandboxing/src/windows.rs +++ b/codex-rs/sandboxing/src/windows.rs @@ -7,11 +7,11 @@ use codex_protocol::config_types::WindowsSandboxLevel; use codex_protocol::models::PermissionProfile; use codex_protocol::permissions::FileSystemPolicyProjection; use codex_protocol::permissions::FileSystemSandboxPolicy; +use codex_protocol::permissions::compatibility_writable_roots_for_permission_profile; use codex_protocol::protocol::WritableRoot; use codex_utils_absolute_path::AbsolutePathBuf; use crate::SandboxType; -use crate::compatibility_sandbox_policy_for_permission_profile; /// Resolved filesystem overrides for the Windows sandbox backends. /// @@ -135,11 +135,8 @@ pub fn resolve_windows_restricted_token_filesystem_overrides( ); } - let legacy_projection = compatibility_sandbox_policy_for_permission_profile( - permission_profile, - sandbox_policy_cwd.as_path(), - ); - let legacy_writable_roots = legacy_projection.get_writable_roots_with_cwd(sandbox_policy_cwd); + let legacy_writable_roots = + compatibility_writable_roots_for_permission_profile(permission_profile, sandbox_policy_cwd); let split_writable_roots = resolved.writable_roots; let legacy_root_paths: BTreeSet = legacy_writable_roots .iter() @@ -266,11 +263,8 @@ pub fn resolve_windows_elevated_filesystem_overrides( }) }); let normalize_path = |path: PathBuf| dunce::canonicalize(&path).unwrap_or(path); - let legacy_projection = compatibility_sandbox_policy_for_permission_profile( - permission_profile, - sandbox_policy_cwd.as_path(), - ); - let legacy_writable_roots = legacy_projection.get_writable_roots_with_cwd(sandbox_policy_cwd); + let legacy_writable_roots = + compatibility_writable_roots_for_permission_profile(permission_profile, sandbox_policy_cwd); let legacy_root_paths: BTreeSet = legacy_writable_roots .iter() .map(|root| normalize_path(root.root.to_path_buf()))