Lightweight coding agent that runs in your terminal
Rust
List managed worktrees for a repository (#42366)
Benjamin Carlssona2a9a434764b
diff --git a/codex-rs/worktree/src/lib.rs b/codex-rs/worktree/src/lib.rsindex 17ce30be88..3162bd3c5a 100644--- a/codex-rs/worktree/src/lib.rs+++ b/codex-rs/worktree/src/lib.rs@@ -6,6 +6,7 @@ mod settings;use crate::git::GitOperation;use crate::git::git_output;use crate::git::git_path;+use crate::git::git_path_from_bytes;use crate::git::git_stdout;use crate::paths::allocate_worktree_root;use crate::paths::remove_empty_bucket;@@ -14,6 +15,7 @@ use anyhow::Result;use anyhow::bail;use serde::Serialize;use std::ffi::OsStr;+use std::fs;use std::path::Component;use std::path::Path;use std::path::PathBuf;@@ -162,6 +164,112 @@ impl WorktreeManager {})}+ pub fn list(&self, source_cwd: &Path) -> Result<Vec<ManagedWorktree>> {+ let source_cwd = dunce::canonicalize(source_cwd)+ .with_context(|| format!("cannot resolve {}", source_cwd.display()))?;+ let source_root = repository_root(&source_cwd)?;+ let relative_cwd = source_cwd+ .strip_prefix(&source_root)+ .context("working directory is outside the repository root")?;+ let managed_root =+ dunce::canonicalize(&self.settings.root).unwrap_or_else(|_| self.settings.root.clone());+ let source_common_dir = resolve_git_path(&source_root, "--git-common-dir")?;+ let output = git_output(+ &source_cwd,+ GitOperation::Metadata,+ ["worktree", "list", "--porcelain", "-z"],+ )?;+ let fields = output+ .stdout+ .split(|byte| *byte == b'\0')+ .collect::<Vec<_>>();+ let mut worktrees = Vec::new();++ for entry in fields.split(|field| field.is_empty()) {+ let mut root = None;+ let mut head_sha = None;+ let mut branch = None;++ for field in entry {+ if let Some(path) = field.strip_prefix(b"worktree ") {+ root = Some(git_path_from_bytes(path)?);+ } else if let Some(head) = field.strip_prefix(b"HEAD ") {+ head_sha = Some(+ std::str::from_utf8(head)+ .context("worktree HEAD is not valid UTF-8")?+ .to_owned(),+ );+ } else if let Some(name) = field.strip_prefix(b"branch ") {+ branch = Some(name.strip_prefix(b"refs/heads/").unwrap_or(name));+ }+ }++ let Some(root) = root else {+ continue;+ };+ let Some(bucket) = root.parent() else {+ continue;+ };+ // Keep aliases from changing which registration supplies the metadata.+ if ![root.as_path(), bucket].into_iter().all(|path| {+ fs::symlink_metadata(path).is_ok_and(|metadata| metadata.file_type().is_dir())+ }) {+ continue;+ }+ let canonical_root = dunce::canonicalize(&root).unwrap_or_else(|_| root.clone());+ let linked_git_file = fs::symlink_metadata(canonical_root.join(".git"))+ .is_ok_and(|metadata| metadata.file_type().is_file());+ if !has_managed_layout(&managed_root, &canonical_root) || !linked_git_file {+ continue;+ }+ if linked_worktree_common_dir(&canonical_root).ok().as_ref() != Some(&source_common_dir)+ {+ continue;+ }+ // A different linked checkout can occupy a stale registration's path.+ // Require its administration directory to point back to this checkout.+ let Ok(git_dir) = resolve_git_path(&canonical_root, "--git-dir") else {+ continue;+ };+ let Ok(backlink) = fs::read(git_dir.join("gitdir")) else {+ continue;+ };+ let backlink = backlink.strip_suffix(b"\n").unwrap_or(&backlink);+ #[cfg(windows)]+ let backlink = backlink.strip_suffix(b"\r").unwrap_or(backlink);+ let Ok(backlink) = git_path_from_bytes(backlink) else {+ continue;+ };+ let Ok(backlink) = dunce::canonicalize(git_dir.join(backlink)) else {+ continue;+ };+ let Ok(git_file) = dunce::canonicalize(canonical_root.join(".git")) else {+ continue;+ };+ if backlink != git_file {+ continue;+ }+ let cwd = root.join(relative_cwd);+ if !is_safe_worktree_cwd(&canonical_root, &cwd) {+ continue;+ }++ let head_sha = head_sha+ .with_context(|| format!("managed worktree {} has no HEAD", root.display()))?;+ worktrees.push(ManagedWorktree {+ cwd,+ root,+ source_root: source_root.clone(),+ source_cwd: source_cwd.clone(),+ head_sha,+ branch: branch.and_then(|name| std::str::from_utf8(name).ok().map(str::to_owned)),+ });+ }++ worktrees.sort_by(|left, right| left.root.cmp(&right.root));+ Ok(worktrees)+ }+pub fn bind_thread(&self, checkout: &Path, thread_id: &str) -> Result<()> {let checkout = self.managed_checkout(checkout)?;metadata::bind_thread(&checkout, thread_id)diff --git a/codex-rs/worktree/tests/worktree.rs b/codex-rs/worktree/tests/worktree.rsindex 5d2fdafda0..1c59ba82ec 100644--- a/codex-rs/worktree/tests/worktree.rs+++ b/codex-rs/worktree/tests/worktree.rs@@ -546,3 +546,335 @@ fn creation_fails_for_a_directory_outside_a_git_repository() {"managed worktree creation requires a Git repository",);}++#[test]+fn listing_rejects_a_primary_checkout_even_when_its_path_matches_the_layout() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let primary = manager.settings().root.join("a1b2").join("ordinary");+ initialize_repository(&primary);++ assert!(+ manager+ .list(&primary)+ .expect("list managed worktrees for primary checkout")+ .is_empty(),+ "a primary checkout under a matching path is not a managed linked worktree",+ );++ let git_dir = fixture.codex_home.join("separate-git-dir");+ run_git(+ &primary,+ &[+ "init",+ "--separate-git-dir",+ git_dir.to_str().expect("UTF-8 fixture path"),+ ],+ );+ assert!(primary.join(".git").is_file());+ assert!(+ manager+ .list(&primary)+ .expect("fixture operation succeeds")+ .is_empty()+ );+}++#[test]+fn listing_skips_worktrees_without_a_safe_source_working_directory() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let source_cwd = fixture.repository.join("nested/component");+ let valid =+ create_worktree(&manager, &source_cwd, /*base*/ None).expect("fixture operation succeeds");+ let missing =+ create_worktree(&manager, &source_cwd, /*base*/ None).expect("fixture operation succeeds");+ let file =+ create_worktree(&manager, &source_cwd, /*base*/ None).expect("fixture operation succeeds");+ fs::remove_dir_all(&missing.cwd).expect("fixture operation succeeds");+ fs::remove_dir_all(&file.cwd).expect("fixture operation succeeds");+ fs::write(&file.cwd, "not a directory").expect("fixture operation succeeds");+ #[cfg(unix)]+ {+ let escaping = create_worktree(&manager, &source_cwd, /*base*/ None)+ .expect("fixture operation succeeds");+ fs::remove_dir_all(&escaping.cwd).expect("fixture operation succeeds");+ std::os::unix::fs::symlink(&source_cwd, &escaping.cwd).expect("fixture operation succeeds");+ }++ assert_eq!(+ manager+ .list(&source_cwd)+ .expect("fixture operation succeeds"),+ vec![valid]+ );+}++#[test]+fn listing_rejects_a_stale_registration_reused_by_another_repository() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let stale = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("fixture operation succeeds");+ fs::remove_dir_all(&stale.root).expect("fixture operation succeeds");+ let other = fixture.codex_home.join("other-repository");+ initialize_repository(&other);+ run_git(+ &other,+ &[+ "worktree",+ "add",+ "--detach",+ stale.root.to_str().expect("UTF-8 fixture path"),+ "HEAD",+ ],+ );++ assert!(+ manager+ .list(&fixture.repository)+ .expect("fixture operation succeeds")+ .is_empty()+ );+ assert_eq!(+ manager+ .list(&other)+ .expect("fixture operation succeeds")+ .len(),+ 1+ );+}++#[test]+fn listing_rejects_a_stale_registration_reused_by_the_same_repository() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let original = run_git(&fixture.repository, &["rev-parse", "HEAD"]);+ fs::write(fixture.repository.join("second.txt"), "second commit\n")+ .expect("write second revision");+ run_git(&fixture.repository, &["add", "second.txt"]);+ commit(&fixture.repository, "second commit");+ let current = run_git(&fixture.repository, &["rev-parse", "HEAD"]);+ let stale = manager.settings().root.join("a1b2/project");+ let moved = manager.settings().root.join("c3d4/project");+ // Use ordinary Git checkouts: manager.create pins core.worktree to its path.+ for (path, revision) in [(&stale, &original), (&moved, ¤t)] {+ fs::create_dir_all(path.parent().expect("worktree bucket"))+ .expect("create worktree bucket");+ run_git(+ &fixture.repository,+ &[+ "worktree",+ "add",+ "--detach",+ path.to_str().expect("UTF-8 fixture path"),+ revision,+ ],+ );+ }+ let valid = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("create unaffected worktree");+ fs::remove_dir_all(&stale).expect("remove stale checkout");+ fs::rename(&moved, &stale).expect("reuse stale path without repairing registration");++ assert_eq!(+ manager.list(&fixture.repository).expect("list worktrees"),+ vec![valid],+ );+}++#[cfg(unix)]+#[test]+fn listing_rejects_checkout_and_bucket_aliases_but_allows_a_root_alias() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let stale = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("create stale checkout");+ fs::write(fixture.repository.join("second.txt"), "second commit\n")+ .expect("write second revision");+ run_git(&fixture.repository, &["add", "second.txt"]);+ commit(&fixture.repository, "second commit");+ let valid = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("create valid checkout");+ let expected = vec![valid.clone()];++ fs::remove_dir_all(&stale.root).expect("remove stale checkout");+ std::os::unix::fs::symlink(&valid.root, &stale.root).expect("alias stale checkout");+ assert_eq!(+ manager.list(&fixture.repository).expect("list worktrees"),+ expected,+ );++ fs::remove_file(&stale.root).expect("remove checkout alias");+ let stale_bucket = stale.root.parent().expect("stale worktree bucket");+ fs::remove_dir(stale_bucket).expect("remove stale bucket");+ std::os::unix::fs::symlink(+ valid.root.parent().expect("valid worktree bucket"),+ stale_bucket,+ )+ .expect("alias stale bucket");+ assert_eq!(+ manager.list(&fixture.repository).expect("list worktrees"),+ expected,+ );++ let aliased_root = fixture.codex_home.join("aliased-worktrees");+ std::os::unix::fs::symlink(&manager.settings().root, &aliased_root)+ .expect("alias managed root");+ let aliased_manager = WorktreeManager::new(WorktreeSettings {+ root: aliased_root,+ ..manager.settings().clone()+ });+ assert_eq!(+ aliased_manager+ .list(&fixture.repository)+ .expect("list worktrees through managed-root alias"),+ expected,+ );+}++#[cfg(unix)]+#[test]+fn listing_preserves_inventory_when_a_branch_name_is_not_utf8() {+ use std::os::unix::ffi::OsStrExt;++ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let worktree = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("fixture operation succeeds");+ let branch = b"refs/heads/non-utf8-\xff";+ // Packed refs can represent these names even on filesystems that reject+ // non-UTF-8 filenames, including APFS.+ let mut packed_ref = format!("{} ", worktree.head_sha).into_bytes();+ packed_ref.extend_from_slice(branch);+ packed_ref.push(b'\n');+ fs::write(fixture.repository.join(".git/packed-refs"), packed_ref)+ .expect("fixture operation succeeds");+ let output = Command::new("git")+ .current_dir(&worktree.root)+ .args(["symbolic-ref", "HEAD"])+ .arg(std::ffi::OsStr::from_bytes(branch))+ .output()+ .expect("fixture operation succeeds");+ assert!(output.status.success());++ assert_eq!(+ manager+ .list(&fixture.repository)+ .expect("fixture operation succeeds"),+ vec![worktree]+ );+ // The primary checkout is not managed, but its metadata is parsed too.+ fs::write(+ fixture.repository.join(".git/HEAD"),+ [b"ref: ".as_slice(), branch, b"\n"].concat(),+ )+ .expect("fixture operation succeeds");+ assert_eq!(+ manager+ .list(&fixture.repository)+ .expect("fixture operation succeeds")+ .len(),+ 1+ );+}++#[test]+fn listing_only_includes_managed_worktrees_for_the_requested_repository() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let first = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("create first worktree");+ let second = create_worktree(&manager, &fixture.repository, /*base*/ None)+ .expect("create second worktree");++ let other_repository = fixture.codex_home.join("other-project");+ initialize_repository(&other_repository);+ let unrelated = create_worktree(&manager, &other_repository, /*base*/ None)+ .expect("create unrelated repository worktree");++ let listed = manager+ .list(&fixture.repository)+ .expect("list managed worktrees for source repository");+ let listed_roots: Vec<&Path> = listed.iter().map(|entry| entry.root.as_path()).collect();++ assert_eq!(listed_roots.len(), 2);+ assert!(listed_roots.contains(&first.root.as_path()));+ assert!(listed_roots.contains(&second.root.as_path()));+ assert!(!listed_roots.contains(&unrelated.root.as_path()));++ let unrelated_list = manager+ .list(&other_repository)+ .expect("list managed worktrees for the other repository");+ assert_eq!(unrelated_list.len(), 1);+ assert_eq!(unrelated_list[0].root, unrelated.root);+}++#[test]+fn listing_ignores_worktrees_outside_the_desktop_bucket_layout() {+ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();+ let root = manager.settings().root.join("scratch").join("project");+ fs::create_dir_all(root.parent().expect("scratch worktree parent"))+ .expect("create scratch worktree parent");+ run_git(+ &fixture.repository,+ &[+ "worktree",+ "add",+ "--detach",+ root.to_str().expect("UTF-8 scratch worktree"),+ "HEAD",+ ],+ );++ assert!(+ manager+ .list(&fixture.repository)+ .expect("list managed worktrees")+ .is_empty(),+ "non-Desktop worktrees must never enter the managed inventory",+ );+}++#[cfg(unix)]+#[test]+fn creation_listing_and_thread_binding_preserve_native_repository_paths() {+ use std::ffi::OsString;+ #[cfg(not(target_os = "macos"))]+ use std::os::unix::ffi::OsStringExt;++ let fixture = RepositoryFixture::new();+ let manager = fixture.manager();++ for name in [+ OsString::from("project with trailing space "),+ OsString::from("project-東京"),+ // APFS only supports creating filenames with valid UTF-8.+ #[cfg(not(target_os = "macos"))]+ OsString::from_vec(b"project-\xff".to_vec()),+ ] {+ let repository = fixture.codex_home.join(&name);+ initialize_repository(&repository);+ let worktree = create_worktree(&manager, &repository, /*base*/ None)+ .expect("create managed worktree with a native repository path");++ assert_eq!(worktree.source_root, repository);+ assert_eq!(worktree.root.file_name(), Some(name.as_os_str()));+ let listed = manager+ .list(&repository)+ .expect("list managed worktrees with a native repository path");+ assert_eq!(listed.len(), 1);+ assert_eq!(listed[0].root, worktree.root);++ manager+ .bind_thread(&worktree.root, "native-path-thread")+ .expect("bind managed worktree with a native repository path");+ assert_eq!(+ manager+ .owner(&worktree.root)+ .expect("read owner with a native repository path"),+ Some("native-path-thread".to_owned()),+ );+ }+}