permissions: remove cwd special path

codex-rs/protocol/src/models.rs

@@ -402,8 +402,12 @@ impl PermissionProfile {
         }
     }
 
-    /// Managed workspace-write filesystem access with restricted network access.
-    pub fn workspace_write() -> Self {
+    /// Managed legacy workspace-write filesystem template with restricted
+    /// network access.
+    ///
+    /// The returned profile contains symbolic `:project_roots` entries that
+    /// must be resolved against the active permission root before enforcement.
+    pub fn legacy_workspace_write_template() -> Self {
         Self::Managed {
             file_system: ManagedFileSystemPermissions::Restricted {
                 entries: vec![
@@ -415,7 +419,7 @@ impl PermissionProfile {
                     },
                     FileSystemSandboxEntry {
                         path: FileSystemPath::Special {
-                            value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                            value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                         },
                         access: FileSystemAccessMode::Write,
                     },
@@ -1831,7 +1835,7 @@ mod tests {
             PermissionProfile::from_legacy_sandbox_policy(&SandboxPolicy::new_read_only_policy())
         );
         assert_eq!(
-            PermissionProfile::workspace_write(),
+            PermissionProfile::legacy_workspace_write_template(),
             PermissionProfile::from_legacy_sandbox_policy(
                 &SandboxPolicy::new_workspace_write_policy()
             )

codex-rs/protocol/src/permissions.rs

@@ -80,7 +80,7 @@ impl FileSystemAccessMode {
 pub enum FileSystemSpecialPath {
     Root,
     Minimal,
-    CurrentWorkingDirectory,
+    #[serde(alias = "current_working_directory")]
     ProjectRoots {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         #[ts(optional)]
@@ -414,9 +414,9 @@ impl FileSystemSandboxPolicy {
 
     /// Converts a legacy sandbox policy into a cwd-independent filesystem policy.
     ///
-    /// `WorkspaceWrite` uses symbolic entries for cwd-scoped access so callers
-    /// can preserve the active cwd binding until the policy is actually
-    /// resolved for a turn or command.
+    /// `WorkspaceWrite` uses symbolic project-root entries so callers can keep
+    /// the profile independent of the concrete root until it is resolved for a
+    /// turn or command.
     pub fn from_legacy_sandbox_policy(sandbox_policy: &SandboxPolicy) -> Self {
         let mut file_system_policy = Self::from(sandbox_policy);
         let SandboxPolicy::WorkspaceWrite {
@@ -571,6 +571,28 @@ impl FileSystemSandboxPolicy {
         self.resolve_access_with_cwd(path, cwd).can_write()
     }
 
+    /// Replaces symbolic `:project_roots` entries with absolute paths resolved
+    /// against `cwd`.
+    ///
+    /// Use this when a durable permission profile must survive a cwd-only
+    /// update without rebinding its project-root authority to the new cwd.
+    pub fn materialize_project_roots_with_cwd(mut self, cwd: &Path) -> Self {
+        let cwd = AbsolutePathBuf::from_absolute_path(cwd).ok();
+        for entry in &mut self.entries {
+            let FileSystemPath::Special {
+                value: FileSystemSpecialPath::ProjectRoots { .. },
+            } = &entry.path
+            else {
+                continue;
+            };
+
+            if let Some(path) = resolve_file_system_path(&entry.path, cwd.as_ref()) {
+                entry.path = FileSystemPath::Path { path };
+            }
+        }
+        self
+    }
+
     pub fn with_additional_readable_roots(
         mut self,
         cwd: &Path,
@@ -867,11 +889,6 @@ impl FileSystemSandboxPolicy {
                                 }
                             },
                             FileSystemSpecialPath::Minimal => {}
-                            FileSystemSpecialPath::CurrentWorkingDirectory => {
-                                if entry.access.can_write() {
-                                    workspace_root_writable = true;
-                                }
-                            }
                             FileSystemSpecialPath::ProjectRoots { subpath } => {
                                 if subpath.is_none() && entry.access.can_write() {
                                     workspace_root_writable = true;
@@ -1001,7 +1018,7 @@ impl From<&SandboxPolicy> for FileSystemSandboxPolicy {
 
                 entries.push(FileSystemSandboxEntry {
                     path: FileSystemPath::Special {
-                        value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                        value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                     },
                     access: FileSystemAccessMode::Write,
                 });
@@ -1099,20 +1116,8 @@ fn special_paths_share_target(left: &FileSystemSpecialPath, right: &FileSystemSp
     match (left, right) {
         (FileSystemSpecialPath::Root, FileSystemSpecialPath::Root)
         | (FileSystemSpecialPath::Minimal, FileSystemSpecialPath::Minimal)
-        | (
-            FileSystemSpecialPath::CurrentWorkingDirectory,
-            FileSystemSpecialPath::CurrentWorkingDirectory,
-        )
         | (FileSystemSpecialPath::Tmpdir, FileSystemSpecialPath::Tmpdir)
         | (FileSystemSpecialPath::SlashTmp, FileSystemSpecialPath::SlashTmp) => true,
-        (
-            FileSystemSpecialPath::CurrentWorkingDirectory,
-            FileSystemSpecialPath::ProjectRoots { subpath: None },
-        )
-        | (
-            FileSystemSpecialPath::ProjectRoots { subpath: None },
-            FileSystemSpecialPath::CurrentWorkingDirectory,
-        ) => true,
         (
             FileSystemSpecialPath::ProjectRoots { subpath: left },
             FileSystemSpecialPath::ProjectRoots { subpath: right },
@@ -1210,10 +1215,6 @@ fn resolve_file_system_special_path(
         FileSystemSpecialPath::Root
         | FileSystemSpecialPath::Minimal
         | FileSystemSpecialPath::Unknown { .. } => None,
-        FileSystemSpecialPath::CurrentWorkingDirectory => {
-            let cwd = cwd?;
-            Some(cwd.clone())
-        }
         FileSystemSpecialPath::ProjectRoots { subpath } => {
             let cwd = cwd?;
             match subpath.as_ref() {
@@ -1538,6 +1539,28 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn legacy_current_working_directory_special_path_deserializes_as_project_roots() {
+        let entry: FileSystemSandboxEntry = serde_json::from_value(serde_json::json!({
+            "path": {
+                "type": "special",
+                "value": { "kind": "current_working_directory" },
+            },
+            "access": "write",
+        }))
+        .expect("legacy cwd special path should deserialize");
+
+        assert_eq!(
+            entry,
+            FileSystemSandboxEntry {
+                path: FileSystemPath::Special {
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
+                },
+                access: FileSystemAccessMode::Write,
+            }
+        );
+    }
+
     #[cfg(unix)]
     #[test]
     fn writable_roots_proactively_protect_missing_dot_codex() {
@@ -1550,7 +1573,7 @@ mod tests {
 
         let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
             path: FileSystemPath::Special {
-                value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
             },
             access: FileSystemAccessMode::Write,
         }]);
@@ -1566,7 +1589,7 @@ mod tests {
     }
 
     #[test]
-    fn legacy_workspace_write_projection_preserves_symbolic_cwd() {
+    fn legacy_workspace_write_projection_preserves_symbolic_project_root() {
         let policy = SandboxPolicy::WorkspaceWrite {
             writable_roots: Vec::new(),
             network_access: false,
@@ -1585,7 +1608,7 @@ mod tests {
                 },
                 FileSystemSandboxEntry {
                     path: FileSystemPath::Special {
-                        value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                        value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                     },
                     access: FileSystemAccessMode::Write,
                 },
@@ -1624,7 +1647,7 @@ mod tests {
         let policy = FileSystemSandboxPolicy::restricted(vec![
             FileSystemSandboxEntry {
                 path: FileSystemPath::Special {
-                    value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                 },
                 access: FileSystemAccessMode::Write,
             },
@@ -1703,7 +1726,7 @@ mod tests {
                 },
                 FileSystemSandboxEntry {
                     path: FileSystemPath::Special {
-                        value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                        value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                     },
                     access: FileSystemAccessMode::Write,
                 },
@@ -1774,7 +1797,7 @@ mod tests {
 
     #[cfg(unix)]
     #[test]
-    fn current_working_directory_special_path_preserves_symlinked_cwd() {
+    fn project_roots_special_path_preserves_symlinked_root() {
         let cwd = TempDir::new().expect("tempdir");
         let real_root = cwd.path().join("real");
         let link_root = cwd.path().join("link");
@@ -1804,7 +1827,7 @@ mod tests {
             },
             FileSystemSandboxEntry {
                 path: FileSystemPath::Special {
-                    value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                 },
                 access: FileSystemAccessMode::Write,
             },
@@ -2094,7 +2117,7 @@ mod tests {
         let policy = FileSystemSandboxPolicy::restricted(vec![
             FileSystemSandboxEntry {
                 path: FileSystemPath::Special {
-                    value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                 },
                 access: FileSystemAccessMode::Write,
             },
@@ -2141,7 +2164,7 @@ mod tests {
         let policy = FileSystemSandboxPolicy::restricted(vec![
             FileSystemSandboxEntry {
                 path: FileSystemPath::Special {
-                    value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                 },
                 access: FileSystemAccessMode::Write,
             },
@@ -2318,7 +2341,7 @@ mod tests {
         let cwd_root = AbsolutePathBuf::from_absolute_path(cwd.path()).expect("absolute cwd");
         let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
             path: FileSystemPath::Special {
-                value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
             },
             access: FileSystemAccessMode::Read,
         }]);
@@ -2336,7 +2359,7 @@ mod tests {
         let cwd_root = AbsolutePathBuf::from_absolute_path(cwd.path()).expect("absolute cwd");
         let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
             path: FileSystemPath::Special {
-                value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
             },
             access: FileSystemAccessMode::Write,
         }]);
@@ -2356,7 +2379,7 @@ mod tests {
             .expect("resolve extra root");
         let policy = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
             path: FileSystemPath::Special {
-                value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
             },
             access: FileSystemAccessMode::Write,
         }]);
@@ -2368,7 +2391,7 @@ mod tests {
             FileSystemSandboxPolicy::restricted(vec![
                 FileSystemSandboxEntry {
                     path: FileSystemPath::Special {
-                        value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                        value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                     },
                     access: FileSystemAccessMode::Write,
                 },

codex-rs/protocol/src/protocol.rs

@@ -4397,7 +4397,7 @@ mod tests {
             },
             FileSystemSandboxEntry {
                 path: FileSystemPath::Special {
-                    value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                 },
                 access: FileSystemAccessMode::Write,
             },
@@ -4459,7 +4459,7 @@ mod tests {
         let policy = FileSystemSandboxPolicy::restricted(vec![
             FileSystemSandboxEntry {
                 path: FileSystemPath::Special {
-                    value: FileSystemSpecialPath::CurrentWorkingDirectory,
+                    value: FileSystemSpecialPath::project_roots(/*subpath*/ None),
                 },
                 access: FileSystemAccessMode::Write,
             },