Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Prevent archival of manually-created worktrees (#58275)
Richard Feldman29622911de00
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rsindex bf1dca28b83..2d8eabbee02 100644--- a/crates/agent_ui/src/conversation_view.rs+++ b/crates/agent_ui/src/conversation_view.rs@@ -5627,6 +5627,9 @@ pub(crate) mod tests {cx.update(|cx| {let settings_store = SettingsStore::test(cx);cx.set_global(settings_store);+ // Use an isolated DB so parallel tests can't overwrite each+ // other's global keys (e.g. the last-created entry kind).+ cx.set_global(db::AppDatabase::test_new());ThreadMetadataStore::init_global(cx);theme_settings::init(theme::LoadThemes::JustBase, cx);editor::init(cx);diff --git a/crates/agent_ui/src/test_support.rs b/crates/agent_ui/src/test_support.rsindex 3f8d5c8c6df..2390784ce40 100644--- a/crates/agent_ui/src/test_support.rs+++ b/crates/agent_ui/src/test_support.rs@@ -10,7 +10,9 @@ use project::Project;use settings::SettingsStore;use std::any::Any;use std::cell::RefCell;+use std::path::Path;use std::rc::Rc;+use std::time::{Duration, SystemTime, UNIX_EPOCH};use workspace::{MultiWorkspace, Sidebar as WorkspaceSidebar, SidebarEvent, SidebarSide};use crate::AgentPanel;@@ -102,6 +104,9 @@ pub fn init_test(cx: &mut TestAppContext) {cx.update(|cx| {let settings_store = SettingsStore::test(cx);cx.set_global(settings_store);+ // Use an isolated DB so parallel tests can't see each other's+ // persisted records (e.g. created-worktree records).+ cx.set_global(db::AppDatabase::test_new());cx.set_global(acp_thread::StubSessionCounter(std::sync::atomic::AtomicUsize::new(0),));@@ -113,6 +118,40 @@ pub fn init_test(cx: &mut TestAppContext) {});}+/// Returns the creation time assigned to a linked worktree's git metadata+/// directory, mirroring `FakeGitRepository::worktree_created_at` (which uses+/// the FakeFs directory mtime as a stand-in for the creation time).+pub async fn fake_worktree_created_at(fs: &dyn fs::Fs, worktree_path: &Path) -> SystemTime {+ let git_file = fs.load(&worktree_path.join(".git")).await.unwrap();+ let git_dir = worktree_path.join(git_file.strip_prefix("gitdir:").unwrap().trim());+ let (seconds, nanos) = fs+ .metadata(&git_dir)+ .await+ .unwrap()+ .unwrap()+ .mtime+ .to_seconds_and_nanos_for_persistence()+ .unwrap();+ UNIX_EPOCH + Duration::new(seconds, nanos)+}++/// Records the worktree in the created-worktrees registry with its actual+/// (fake) creation time, as the worktree creation flow would. Tests that+/// expect a worktree to be archivable must call this after setting it up.+pub async fn record_zed_created_worktree(+ fs: &dyn fs::Fs,+ worktree_path: &Path,+ remote: Option<&remote::RemoteConnectionOptions>,+ cx: &mut TestAppContext,+) {+ let created_at = fake_worktree_created_at(fs, worktree_path).await;+ cx.update(|cx| {+ git_ui::created_worktrees::record_created_worktree(worktree_path, remote, created_at, cx)+ })+ .await+ .unwrap();+}+pub struct TestWorkspaceSidebar {focus_handle: FocusHandle,threads_list_active: bool,diff --git a/crates/agent_ui/src/thread_worktree_archive.rs b/crates/agent_ui/src/thread_worktree_archive.rsindex f3d54657d49..1d392a86352 100644--- a/crates/agent_ui/src/thread_worktree_archive.rs+++ b/crates/agent_ui/src/thread_worktree_archive.rs@@ -1,6 +1,7 @@use std::{path::{Path, PathBuf},sync::Arc,+ time::SystemTime,};use anyhow::{Context as _, Result, anyhow};@@ -52,6 +53,11 @@ pub struct RootPlan {/// used to create temporary remote projects when the main repo isn't/// loaded in any open workspace.pub remote_connection: Option<RemoteConnectionOptions>,+ /// The creation time of the worktree's git metadata directory that was+ /// recorded when Zed created the worktree. [`remove_root`] re-stats the+ /// directory and refuses to delete anything if the time has changed,+ /// which means the worktree was recreated outside Zed.+ pub recorded_created_at: SystemTime,}/// A `Project` that references a worktree being archived, paired with the@@ -174,6 +180,15 @@ pub fn build_root_plan(return None;}+ // Only archive worktrees that Zed explicitly created. The directory+ // check above constrains paths, but the database record is what+ // distinguishes a Zed-created worktree from one the user manually+ // created under the same directory layout. The recorded creation time+ // is re-verified against the filesystem in [`remove_root`] before+ // anything is deleted.+ let recorded_created_at =+ git_ui::created_worktrees::recorded_created_at(&path, remote_connection, cx)?;+let branch_name = linked_snapshot.branch.as_ref()@@ -186,6 +201,7 @@ pub fn build_root_plan(worktree_repo: repo,branch_name,remote_connection: remote_connection.cloned(),+ recorded_created_at,})}@@ -198,6 +214,8 @@ pub fn build_root_plan(/// delete the worktree directory. If the git removal fails, the worktree/// is re-added to each project via [`rollback_root`].pub async fn remove_root(root: RootPlan, cx: &mut AsyncApp) -> Result<()> {+ verify_created_by_zed(&root, cx).await?;+let release_tasks: Vec<_> = root.affected_projects.iter()@@ -217,9 +235,73 @@ pub async fn remove_root(root: RootPlan, cx: &mut AsyncApp) -> Result<()> {return Err(error);}+ // The worktree is gone, so its registry record is now stale. If the+ // user later creates a new worktree at the same path outside Zed, a+ // leftover record would only be saved by the creation time check, so+ // remove it eagerly.+ cx.update(|cx| {+ git_ui::created_worktrees::forget_created_worktree(+ &root.root_path,+ root.remote_connection.as_ref(),+ cx,+ )+ })+ .await+ .log_err();+Ok(())}+/// Confirms that the worktree on disk is still the one Zed created, by+/// comparing the creation time of its git metadata directory against the+/// time recorded when Zed created it.+///+/// Outcomes:+/// - Creation time matches the recorded one: proceed.+/// - Worktree directory no longer exists: proceed — there is nothing on+/// disk to protect, and removal will only clean up git metadata.+/// - Creation time differs: the worktree was removed and recreated outside+/// Zed. The registry record is removed (so subsequent archival attempts+/// skip the worktree entirely) and an error is returned so the caller+/// leaves the directory untouched.+/// - Creation time cannot be read: return an error but keep the record,+/// since the failure may be transient (e.g. a disconnected remote).+async fn verify_created_by_zed(root: &RootPlan, cx: &mut AsyncApp) -> Result<()> {+ let receiver = root.worktree_repo.update(cx, |repo: &mut Repository, _cx| {+ repo.worktree_created_at(root.root_path.clone())+ });+ let created_at = receiver+ .await+ .map_err(|_| anyhow!("worktree creation time check was canceled"))?+ .with_context(|| {+ format!(+ "refusing to delete worktree at {}: failed to verify that Zed created it",+ root.root_path.display()+ )+ })?;++ match created_at {+ None => Ok(()),+ Some(created_at) if created_at == root.recorded_created_at => Ok(()),+ Some(_) => {+ cx.update(|cx| {+ git_ui::created_worktrees::forget_created_worktree(+ &root.root_path,+ root.remote_connection.as_ref(),+ cx,+ )+ })+ .await+ .log_err();+ Err(anyhow!(+ "refusing to delete worktree at {}: it is not the worktree Zed created \+ (it was likely removed and recreated outside Zed)",+ root.root_path.display()+ ))+ }+ }+}+async fn remove_root_after_worktree_removal(root: &RootPlan,release_tasks: Vec<Task<Result<()>>>,@@ -707,6 +789,18 @@ pub async fn restore_worktree_via_git(return Err(error.context("failed to restore archive checkpoint"));}+ if created_new_worktree {+ // Re-register the restored worktree as Zed-created so it can be+ // archived again later.+ git_ui::created_worktrees::record_created_worktree_for_repo(+ &wt_repo,+ worktree_path,+ remote_connection,+ cx,+ )+ .await;+ }+Ok(worktree_path.clone())}@@ -869,18 +963,34 @@ mod tests {use project::Project;use serde_json::json;use settings::SettingsStore;+ use std::time::Duration;use workspace::MultiWorkspace;fn init_test(cx: &mut TestAppContext) {cx.update(|cx| {let settings_store = SettingsStore::test(cx);cx.set_global(settings_store);+ // Use an isolated DB so parallel tests can't see each other's+ // created-worktree records.+ cx.set_global(db::AppDatabase::test_new());theme_settings::init(theme::LoadThemes::JustBase, cx);editor::init(cx);release_channel::init(semver::Version::new(0, 0, 0), cx);});}+ async fn fake_worktree_created_at(fs: &FakeFs, worktree_path: &Path) -> SystemTime {+ crate::test_support::fake_worktree_created_at(fs, worktree_path).await+ }++ async fn record_zed_created_worktree(+ fs: &FakeFs,+ worktree_path: &Path,+ cx: &mut TestAppContext,+ ) {+ crate::test_support::record_zed_created_worktree(fs, worktree_path, None, cx).await+ }+#[gpui::test]async fn test_build_root_plan_returns_none_for_main_worktree(cx: &mut TestAppContext) {init_test(cx);@@ -949,6 +1059,7 @@ mod tests {},).await;+ record_zed_created_worktree(&fs, Path::new("/worktrees/project/feature/project"), cx).await;let project = Project::test(fs.clone(),@@ -1069,6 +1180,75 @@ mod tests {});}+ #[gpui::test]+ async fn test_build_root_plan_returns_none_for_unrecorded_linked_worktree_in_managed_directory(+ cx: &mut TestAppContext,+ ) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ "/project",+ json!({+ ".git": {},+ "src": { "main.rs": "fn main() {}" }+ }),+ )+ .await;+ fs.set_branch_name(Path::new("/project/.git"), Some("main"));+ fs.insert_branches(Path::new("/project/.git"), &["main", "feature"]);++ fs.add_linked_worktree_for_repo(+ Path::new("/project/.git"),+ true,+ GitWorktree {+ path: PathBuf::from("/worktrees/project/feature/project"),+ ref_name: Some("refs/heads/feature".into()),+ sha: "abc123".into(),+ is_main: false,+ is_bare: false,+ },+ )+ .await;+ // Deliberately don't record the worktree in the created-worktrees+ // registry: it represents a worktree the user created manually.++ let project = Project::test(+ fs.clone(),+ [+ Path::new("/project"),+ Path::new("/worktrees/project/feature/project"),+ ],+ cx,+ )+ .await;+ project+ .update(cx, |project, cx| project.git_scans_complete(cx))+ .await;++ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace+ .read_with(cx, |mw, _cx| mw.workspace().clone())+ .unwrap();++ cx.run_until_parked();++ workspace.read_with(cx, |_workspace, cx| {+ let plan = build_root_plan(+ Path::new("/worktrees/project/feature/project"),+ None,+ std::slice::from_ref(&workspace),+ cx,+ );+ assert!(+ plan.is_none(),+ "build_root_plan should return None for a linked worktree Zed didn't create, \+ even when it lives inside the Zed-managed worktrees directory",+ );+ });+ }+#[gpui::test]async fn test_build_root_plan_with_custom_worktree_directory(cx: &mut TestAppContext) {init_test(cx);@@ -1110,9 +1290,17 @@ mod tests {},).await;+ record_zed_created_worktree(+ &fs,+ Path::new("/custom-worktrees/project/feature/project"),+ cx,+ )+ .await;// Worktree outside the custom managed directory (at the default// `../worktrees` location, which is not what the setting says).+ // It is recorded as Zed-created so that the directory check, not+ // the registry, is what excludes it below.fs.add_linked_worktree_for_repo(Path::new("/project/.git"),true,@@ -1125,6 +1313,8 @@ mod tests {},).await;+ record_zed_created_worktree(&fs, Path::new("/worktrees/project/feature2/project"), cx)+ .await;let project = Project::test(fs.clone(),@@ -1206,6 +1396,7 @@ mod tests {},).await;+ record_zed_created_worktree(&fs, Path::new("/worktrees/project/feature/project"), cx).await;let project = Project::test(fs.clone(),@@ -1287,6 +1478,7 @@ mod tests {},).await;+ record_zed_created_worktree(&fs, Path::new("/worktrees/project/feature/project"), cx).await;let project = Project::test(fs.clone(),@@ -1346,6 +1538,116 @@ mod tests {.expect("remove_root should succeed even when directory is already gone");}+ #[gpui::test]+ async fn test_remove_root_refuses_when_worktree_recreated_outside_zed(cx: &mut TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ "/project",+ json!({+ ".git": {},+ "src": { "main.rs": "fn main() {}" }+ }),+ )+ .await;+ fs.set_branch_name(Path::new("/project/.git"), Some("main"));+ fs.insert_branches(Path::new("/project/.git"), &["main", "feature"]);++ fs.add_linked_worktree_for_repo(+ Path::new("/project/.git"),+ true,+ GitWorktree {+ path: PathBuf::from("/worktrees/project/feature/project"),+ ref_name: Some("refs/heads/feature".into()),+ sha: "abc123".into(),+ is_main: false,+ is_bare: false,+ },+ )+ .await;++ // Record a creation time that doesn't match the directory on disk,+ // simulating a worktree that was removed and recreated outside Zed+ // after Zed recorded the original.+ let worktree_path = Path::new("/worktrees/project/feature/project");+ let actual_created_at = fake_worktree_created_at(&fs, worktree_path).await;+ cx.update(|cx| {+ git_ui::created_worktrees::record_created_worktree(+ worktree_path,+ None,+ actual_created_at + Duration::from_secs(1),+ cx,+ )+ })+ .await+ .unwrap();++ let project = Project::test(+ fs.clone(),+ [+ Path::new("/project"),+ Path::new("/worktrees/project/feature/project"),+ ],+ cx,+ )+ .await;+ project+ .update(cx, |project, cx| project.git_scans_complete(cx))+ .await;++ let multi_workspace =+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));+ let workspace = multi_workspace+ .read_with(cx, |mw, _cx| mw.workspace().clone())+ .unwrap();++ cx.run_until_parked();++ let root = workspace+ .read_with(cx, |_workspace, cx| {+ build_root_plan(+ Path::new("/worktrees/project/feature/project"),+ None,+ std::slice::from_ref(&workspace),+ cx,+ )+ })+ .expect("should produce a root plan while the record exists");++ let task = cx.update(|cx| cx.spawn(async move |cx| remove_root(root, cx).await));+ let error = task+ .await+ .expect_err("remove_root should refuse to delete a recreated worktree");+ assert!(+ error.to_string().contains("not the worktree Zed created"),+ "unexpected error: {error:#}"+ );++ cx.run_until_parked();++ // The directory must be left untouched.+ assert!(+ fs.is_dir(Path::new("/worktrees/project/feature/project"))+ .await,+ "worktree directory should not be deleted on creation time mismatch"+ );++ // The stale record should be forgotten, so subsequent archival+ // attempts skip the worktree entirely.+ workspace.read_with(cx, |_workspace, cx| {+ assert!(+ git_ui::created_worktrees::recorded_created_at(worktree_path, None, cx).is_none(),+ "stale created-worktree record should be removed"+ );+ let plan = build_root_plan(worktree_path, None, std::slice::from_ref(&workspace), cx);+ assert!(+ plan.is_none(),+ "build_root_plan should return None after the stale record is removed"+ );+ });+ }+#[gpui::test]async fn test_remove_root_returns_error_and_rolls_back_on_remove_dir_failure(cx: &mut TestAppContext,@@ -1376,6 +1678,7 @@ mod tests {},).await;+ record_zed_created_worktree(&fs, Path::new("/worktrees/project/feature/project"), cx).await;let project = Project::test(fs.clone(),@@ -1409,25 +1712,10 @@ mod tests {}).expect("should produce a root plan for the linked worktree");- // Replace the worktree directory with a file so that fs.remove_dir- // fails with a "not a directory" error.+ // Make deleting the worktree directory fail, while leaving the+ // worktree itself intact so the created-by-Zed verification passes.let worktree_path = Path::new("/worktrees/project/feature/project");- fs.remove_dir(- worktree_path,- fs::RemoveOptions {- recursive: true,- ignore_if_not_exists: false,- },- )- .await- .unwrap();- fs.create_file(worktree_path, fs::CreateOptions::default())- .await- .unwrap();- assert!(- fs.is_file(worktree_path).await,- "path should now be a file, not a directory"- );+ fs.set_remove_dir_error(worktree_path, "simulated remove_dir failure".to_string());let task = cx.update(|cx| cx.spawn(async move |cx| remove_root(root, cx).await));let result = task.await;diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rsindex 176d504ae1a..337e363db69 100644--- a/crates/collab/src/rpc.rs+++ b/crates/collab/src/rpc.rs@@ -493,6 +493,7 @@ impl Server {.add_request_handler(forward_mutating_project_request::<proto::GitCreateRemote>).add_request_handler(forward_mutating_project_request::<proto::GitRemoveRemote>).add_request_handler(forward_read_only_project_request::<proto::GitGetWorktrees>)+ .add_request_handler(forward_read_only_project_request::<proto::GitWorktreeCreatedAt>).add_request_handler(forward_read_only_project_request::<proto::GitGetHeadSha>).add_request_handler(forward_read_only_project_request::<proto::GetCommitData>).add_request_stream_handler(diff --git a/crates/fs/src/fake_git_repo.rs b/crates/fs/src/fake_git_repo.rsindex c2522576e85..5d8fc647fe0 100644--- a/crates/fs/src/fake_git_repo.rs+++ b/crates/fs/src/fake_git_repo.rs@@ -26,7 +26,7 @@ use gpui::{AsyncApp, BackgroundExecutor, SharedString, Task};use ignore::gitignore::GitignoreBuilder;use parking_lot::Mutex;use rope::Rope;-use std::{path::PathBuf, sync::Arc, sync::atomic::AtomicBool};+use std::{path::PathBuf, sync::Arc, sync::atomic::AtomicBool, time::SystemTime};use text::LineEnding;use util::{paths::PathStyle, rel_path::RelPath};@@ -590,6 +590,37 @@ impl GitRepository for FakeGitRepository {.boxed()}+ fn worktree_created_at(+ &self,+ worktree_path: PathBuf,+ ) -> BoxFuture<'_, Result<Option<SystemTime>>> {+ let fs = self.fs.clone();+ async move {+ if fs.metadata(&worktree_path).await?.is_none() {+ return Ok(None);+ }+ let dot_git_path = worktree_path.join(".git");+ let git_file = fs+ .load(&dot_git_path)+ .await+ .with_context(|| format!("failed to read {}", dot_git_path.display()))?;+ let git_dir = git_file+ .strip_prefix("gitdir:")+ .context("worktree .git file missing gitdir pointer")?+ .trim();+ let git_dir = worktree_path.join(git_dir);+ let metadata = fs+ .metadata(&git_dir)+ .await?+ .with_context(|| format!("missing worktree git dir {}", git_dir.display()))?;+ // FakeFs assigns directories a monotonically increasing mtime at+ // creation and never updates it afterwards, so a directory's+ // mtime doubles as its creation time.+ Ok(Some(metadata.mtime.0))+ }+ .boxed()+ }+fn create_worktree(&self,target: CreateWorktreeTarget,diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rsindex 68c57c655d5..59fe449b185 100644--- a/crates/fs/src/fs.rs+++ b/crates/fs/src/fs.rs@@ -1336,6 +1336,7 @@ struct FakeFsState {job_event_subscribers: Arc<Mutex<Vec<JobEventSender>>>,trash: Vec<(TrashedEntry, FakeFsEntry)>,file_to_create_before_watch_add: Option<(PathBuf, PathBuf)>,+ remove_dir_errors: std::collections::HashMap<PathBuf, String>,}#[cfg(feature = "test-support")]@@ -1655,6 +1656,7 @@ impl FakeFs {job_event_subscribers: Arc::new(Mutex::new(Vec::new())),trash: Vec::new(),file_to_create_before_watch_add: None,+ remove_dir_errors: Default::default(),})),});@@ -2397,6 +2399,14 @@ impl FakeFs {.unwrap();}+ /// Makes subsequent `remove_dir` calls for `path` fail with `message`.+ pub fn set_remove_dir_error(&self, path: impl AsRef<Path>, message: String) {+ self.state+ .lock()+ .remove_dir_errors+ .insert(normalize_path(path.as_ref()), message);+ }+pub fn paths(&self, include_dot_git: bool) -> Vec<PathBuf> {let mut result = Vec::new();let mut queue = collections::VecDeque::new();@@ -2539,6 +2549,9 @@ impl FakeFs {self.simulate_random_delay().await;let path = normalize_path(path);+ if let Some(message) = self.state.lock().remove_dir_errors.get(&path) {+ anyhow::bail!("{message}");+ }let parent_path = path.parent().context("cannot remove the root")?;let base_name = path.file_name().context("cannot remove the root")?;diff --git a/crates/git/src/repository.rs b/crates/git/src/repository.rsindex 3d164af6a07..8547462e8ed 100644--- a/crates/git/src/repository.rs+++ b/crates/git/src/repository.rs@@ -24,6 +24,7 @@ use std::sync::atomic::AtomicBool;use std::process::{ExitStatus, Output};use std::str::FromStr;+use std::time::SystemTime;use std::{cmp::Ordering,path::{Path, PathBuf},@@ -75,6 +76,17 @@ pub fn original_repo_path_from_common_dir(common_dir: &Path) -> Option<PathBuf>}}+fn linked_worktree_git_dir(worktree_path: &Path) -> Result<PathBuf> {+ let dot_git_path = worktree_path.join(".git");+ let git_file = std::fs::read_to_string(&dot_git_path)+ .with_context(|| format!("failed to read {}", dot_git_path.display()))?;+ let git_dir = git_file+ .strip_prefix("gitdir:")+ .context("worktree .git file missing gitdir pointer")?+ .trim();+ Ok(worktree_path.join(git_dir))+}+fn normalize_git_metadata_path(path: PathBuf) -> Result<PathBuf> {paths::normalize_lexically(&path).map_err(|_| anyhow!("git metadata path escapes its filesystem root: {path:?}"))@@ -845,6 +857,24 @@ pub trait GitRepository: Send + Sync {fn worktrees(&self) -> BoxFuture<'_, Result<Vec<Worktree>>>;+ /// Returns the creation time of a linked worktree's git metadata+ /// directory (`.git/worktrees/<name>/`), resolved via the worktree's+ /// `.git` file.+ ///+ /// The metadata directory is created by `git worktree add` and removed+ /// by `git worktree remove`, so its creation time identifies a+ /// particular incarnation of the worktree: if the worktree is removed+ /// and recreated at the same path, the creation time changes.+ ///+ /// Returns `Ok(None)` when the worktree directory does not exist at+ /// all, and an error when the directory exists but the time cannot be+ /// determined (e.g. on filesystems without birthtime support); callers+ /// should fail safe in the error case.+ fn worktree_created_at(+ &self,+ worktree_path: PathBuf,+ ) -> BoxFuture<'_, Result<Option<SystemTime>>>;+fn create_worktree(&self,target: CreateWorktreeTarget,@@ -1921,6 +1951,34 @@ impl GitRepository for RealGitRepository {.boxed()}+ fn worktree_created_at(+ &self,+ worktree_path: PathBuf,+ ) -> BoxFuture<'_, Result<Option<SystemTime>>> {+ self.executor+ .spawn(async move {+ match std::fs::metadata(&worktree_path) {+ Err(error) if error.kind() == std::io::ErrorKind::NotFound => {+ return Ok(None);+ }+ Err(error) => {+ return Err(error).with_context(|| {+ format!("failed to stat {}", worktree_path.display())+ });+ }+ Ok(_) => {}+ }+ let git_dir = linked_worktree_git_dir(&worktree_path)?;+ let metadata = std::fs::metadata(&git_dir)+ .with_context(|| format!("failed to stat {}", git_dir.display()))?;+ let created_at = metadata.created().with_context(|| {+ format!("creation time unavailable for {}", git_dir.display())+ })?;+ Ok(Some(created_at))+ })+ .boxed()+ }+fn create_worktree(&self,target: CreateWorktreeTarget,@@ -4907,6 +4965,24 @@ mod tests {new_worktree.path.canonicalize().unwrap(),worktree_path.canonicalize().unwrap(),);++ // The new worktree's git metadata directory should report a creation+ // time, resolved via the worktree's `.git` file.+ let created_at = repo+ .worktree_created_at(worktree_path.clone())+ .await+ .unwrap();+ assert!(+ created_at.is_some(),+ "creation time should be available for a freshly created worktree"+ );++ // A path with no worktree at all reports `None`.+ let missing = repo+ .worktree_created_at(worktrees_dir.join("does-not-exist"))+ .await+ .unwrap();+ assert_eq!(missing, None);}#[gpui::test]diff --git a/crates/git_ui/src/created_worktrees.rs b/crates/git_ui/src/created_worktrees.rsnew file mode 100644index 00000000000..b026d99a413--- /dev/null+++ b/crates/git_ui/src/created_worktrees.rs@@ -0,0 +1,150 @@+//! A persistent registry of git worktrees that Zed itself created.+//!+//! Thread archival deletes a worktree's directory from disk, so it must be+//! certain the worktree was created by Zed rather than by the user. This+//! module records each Zed-created worktree in the local database, keyed by+//! its path (and remote host, for remote projects), along with the creation+//! time of the worktree's git metadata directory at the time Zed created it.+//!+//! Before deleting a worktree, callers re-stat that directory and compare+//! against the recorded time. A mismatch means the worktree was removed and+//! recreated outside Zed, so deletion must be skipped. Every failure mode+//! (no record, unreadable creation time, mismatched time) fails safe by+//! leaving the directory untouched.+//!+//! Because the registry lives in the local database, worktrees created by a+//! different Zed install (e.g. another release channel, or another machine+//! connecting to the same remote host) are treated as manually created and+//! never archived. That is intentional: when in doubt, don't delete.++use std::{+ future::Future,+ path::Path,+ time::{Duration, SystemTime, UNIX_EPOCH},+};++use anyhow::{Context as _, Result};+use db::kvp::KeyValueStore;+use gpui::{App, AsyncApp, Entity};+use project::git_store::Repository;+use remote::{RemoteConnectionOptions, remote_connection_identity};+use serde::{Deserialize, Serialize};+use util::ResultExt as _;++const NAMESPACE: &str = "created_git_worktrees";++#[derive(Serialize, Deserialize)]+struct CreatedWorktreeRecord {+ created_at_seconds: u64,+ created_at_subsec_nanos: u32,+}++fn record_key(worktree_path: &Path, remote: Option<&RemoteConnectionOptions>) -> String {+ let host = match remote {+ None => "local".to_string(),+ Some(options) => remote_connection_identity(options).persistence_key(),+ };+ // Paths cannot contain newlines in practice, so this separator is+ // unambiguous.+ format!("{host}\n{}", worktree_path.display())+}++/// Records that Zed created the worktree at `worktree_path`, along with the+/// creation time of its git metadata directory.+pub fn record_created_worktree(+ worktree_path: &Path,+ remote: Option<&RemoteConnectionOptions>,+ created_at: SystemTime,+ cx: &App,+) -> impl Future<Output = Result<()>> + use<> {+ let store = KeyValueStore::global(cx);+ let key = record_key(worktree_path, remote);+ let value = created_at+ .duration_since(UNIX_EPOCH)+ .context("worktree creation time predates the unix epoch")+ .and_then(|duration| {+ serde_json::to_string(&CreatedWorktreeRecord {+ created_at_seconds: duration.as_secs(),+ created_at_subsec_nanos: duration.subsec_nanos(),+ })+ .context("failed to serialize created worktree record")+ });+ async move { store.scoped(NAMESPACE).write(key, value?).await }+}++/// Returns the recorded creation time for a worktree Zed created, or `None`+/// if Zed has no record of creating it.+pub fn recorded_created_at(+ worktree_path: &Path,+ remote: Option<&RemoteConnectionOptions>,+ cx: &App,+) -> Option<SystemTime> {+ let store = KeyValueStore::global(cx);+ let value = store+ .scoped(NAMESPACE)+ .read(&record_key(worktree_path, remote))+ .log_err()??;+ let record: CreatedWorktreeRecord = serde_json::from_str(&value).log_err()?;+ Some(UNIX_EPOCH + Duration::new(record.created_at_seconds, record.created_at_subsec_nanos))+}++/// Looks up the creation time of a freshly created worktree's git metadata+/// directory through the repository and records it in the registry.+///+/// Failures are logged and swallowed: the worktree just won't be eligible+/// for automatic archival.+pub async fn record_created_worktree_for_repo(+ repo: &Entity<Repository>,+ worktree_path: &Path,+ remote: Option<&RemoteConnectionOptions>,+ cx: &mut AsyncApp,+) {+ let receiver = repo.update(cx, |repo, _cx| {+ repo.worktree_created_at(worktree_path.to_path_buf())+ });+ let created_at = match receiver.await {+ Ok(Ok(Some(created_at))) => created_at,+ Ok(Ok(None)) => {+ log::warn!(+ "Newly created worktree {} not found on disk; \+ it won't be eligible for automatic archival",+ worktree_path.display()+ );+ return;+ }+ Ok(Err(error)) => {+ log::warn!(+ "Couldn't determine creation time for worktree {}; \+ it won't be eligible for automatic archival: {error:#}",+ worktree_path.display()+ );+ return;+ }+ Err(_) => {+ log::warn!(+ "Worktree creation time lookup was canceled for {}",+ worktree_path.display()+ );+ return;+ }+ };+ let record = cx.update(|cx| record_created_worktree(worktree_path, remote, created_at, cx));+ if let Err(error) = record.await {+ log::warn!(+ "Failed to record created worktree {}: {error:#}",+ worktree_path.display()+ );+ }+}++/// Removes the record for a worktree, either because Zed deleted it or+/// because the directory on disk turned out not to be the one Zed created.+pub fn forget_created_worktree(+ worktree_path: &Path,+ remote: Option<&RemoteConnectionOptions>,+ cx: &App,+) -> impl Future<Output = Result<()>> + use<> {+ let store = KeyValueStore::global(cx);+ let key = record_key(worktree_path, remote);+ async move { store.scoped(NAMESPACE).delete(key).await }+}diff --git a/crates/git_ui/src/git_ui.rs b/crates/git_ui/src/git_ui.rsindex 5c211a87466..7e5b2ade32a 100644--- a/crates/git_ui/src/git_ui.rs+++ b/crates/git_ui/src/git_ui.rs@@ -35,6 +35,7 @@ mod commit_modal;pub mod commit_tooltip;pub mod commit_view;mod conflict_view;+pub mod created_worktrees;pub mod file_diff_view;pub mod git_graph;pub mod git_panel;diff --git a/crates/git_ui/src/worktree_service.rs b/crates/git_ui/src/worktree_service.rsindex 8c0153c49ad..a9dcdb8406a 100644--- a/crates/git_ui/src/worktree_service.rs+++ b/crates/git_ui/src/worktree_service.rs@@ -958,8 +958,26 @@ async fn do_create_worktree(let fs = cx.update(|_, cx| <dyn Fs>::global(cx))?;+ let creation_pairs: Vec<(Entity<Repository>, PathBuf)> = creation_infos+ .iter()+ .map(|(repo, path, _)| (repo.clone(), path.clone()))+ .collect();+let created_paths = await_and_rollback_on_failure(creation_infos, fs, cx).await?;+ // Record each created worktree so thread archival can later verify that+ // Zed created it before deleting it from disk. Failures are non-fatal:+ // the worktree just won't be eligible for automatic archival.+ for (repo, path) in creation_pairs {+ crate::created_worktrees::record_created_worktree_for_repo(+ &repo,+ &path,+ remote_connection_options.as_ref(),+ cx,+ )+ .await;+ }+// `path_remapping` has one entry per source git repo, while `created_paths`// has one per *unique* target worktree. When the former is larger, two or// more source repos were linked worktrees of the same underlyingdiff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rsindex 0af840fbbeb..d7c0e73c9f4 100644--- a/crates/project/src/git_store.rs+++ b/crates/project/src/git_store.rs@@ -78,7 +78,7 @@ use std::{Arc,atomic::{self, AtomicU64},},- time::{Duration, Instant},+ time::{Duration, Instant, SystemTime},};use sum_tree::{Edit, SumTree, TreeMap};use task::Shell;@@ -702,6 +702,7 @@ impl GitStore {client.add_entity_request_handler(Self::handle_create_worktree);client.add_entity_request_handler(Self::handle_remove_worktree);client.add_entity_request_handler(Self::handle_rename_worktree);+ client.add_entity_request_handler(Self::handle_worktree_created_at);client.add_entity_request_handler(Self::handle_get_head_sha);client.add_entity_request_handler(Self::handle_edit_ref);client.add_entity_request_handler(Self::handle_repair_worktrees);@@ -2853,6 +2854,26 @@ impl GitStore {Ok(proto::Ack {})}+ async fn handle_worktree_created_at(+ this: Entity<Self>,+ envelope: TypedEnvelope<proto::GitWorktreeCreatedAt>,+ mut cx: AsyncApp,+ ) -> Result<proto::GitWorktreeCreatedAtResponse> {+ let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);+ let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;+ let worktree_path = PathBuf::from(envelope.payload.worktree_path);++ let created_at = repository_handle+ .update(&mut cx, |repository_handle, _| {+ repository_handle.worktree_created_at(worktree_path)+ })+ .await??;++ Ok(proto::GitWorktreeCreatedAtResponse {+ created_at: created_at.map(Into::into),+ })+ }+async fn handle_get_head_sha(this: Entity<Self>,envelope: TypedEnvelope<proto::GitGetHeadSha>,@@ -7497,6 +7518,34 @@ impl Repository {)}+ /// Returns the creation time of a linked worktree's git metadata+ /// directory. See [`GitRepository::worktree_created_at`]. For remote+ /// projects the stat runs on the remote host, where the worktree's+ /// filesystem lives.+ pub fn worktree_created_at(+ &mut self,+ worktree_path: PathBuf,+ ) -> oneshot::Receiver<Result<Option<SystemTime>>> {+ let id = self.id;+ self.send_job("worktree_created_at", None, move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend.worktree_created_at(worktree_path).await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ let response = client+ .request(proto::GitWorktreeCreatedAt {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ worktree_path: worktree_path.to_string_lossy().to_string(),+ })+ .await?;+ Ok(response.created_at.map(SystemTime::from))+ }+ }+ })+ }+pub fn create_worktree_detached(&mut self,path: PathBuf,diff --git a/crates/proto/proto/git.proto b/crates/proto/proto/git.protoindex ac7e39a83d9..c4c838042c0 100644--- a/crates/proto/proto/git.proto+++ b/crates/proto/proto/git.proto@@ -666,6 +666,16 @@ message GitRenameWorktree {string new_path = 4;}+message GitWorktreeCreatedAt {+ uint64 project_id = 1;+ uint64 repository_id = 2;+ string worktree_path = 3;+}++message GitWorktreeCreatedAtResponse {+ optional Timestamp created_at = 1;+}+message RunGitHook {enum GitHook {PRE_COMMIT = 0;diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.protoindex ab5ea5ce729..1af251f0ab4 100644--- a/crates/proto/proto/zed.proto+++ b/crates/proto/proto/zed.proto@@ -488,7 +488,9 @@ message Envelope {GetDocumentLinks get_document_links = 453;GetDocumentLinksResponse get_document_links_response = 454;ResolveDocumentLink resolve_document_link = 455;- ResolveDocumentLinkResponse resolve_document_link_response = 456; // current max+ ResolveDocumentLinkResponse resolve_document_link_response = 456;+ GitWorktreeCreatedAt git_worktree_created_at = 457;+ GitWorktreeCreatedAtResponse git_worktree_created_at_response = 458; // current max}reserved 87 to 88;diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rsindex 2836c28a552..16b8f38fb07 100644--- a/crates/proto/src/proto.rs+++ b/crates/proto/src/proto.rs@@ -370,6 +370,8 @@ messages!((GitCreateWorktree, Background),(GitRemoveWorktree, Background),(GitRenameWorktree, Background),+ (GitWorktreeCreatedAt, Background),+ (GitWorktreeCreatedAtResponse, Background),(ShareAgentThread, Foreground),(GetSharedAgentThread, Foreground),(GetSharedAgentThreadResponse, Foreground),@@ -588,6 +590,7 @@ request_messages!((GitCreateWorktree, Ack),(GitRemoveWorktree, Ack),(GitRenameWorktree, Ack),+ (GitWorktreeCreatedAt, GitWorktreeCreatedAtResponse),(TrustWorktrees, Ack),(RestrictWorktrees, Ack),(FindSearchCandidatesChunk, Ack),@@ -789,6 +792,7 @@ entity_messages!(GitCreateWorktree,GitRemoveWorktree,GitRenameWorktree,+ GitWorktreeCreatedAt,TrustWorktrees,RestrictWorktrees,FindSearchCandidatesChunk,diff --git a/crates/remote/src/remote_identity.rs b/crates/remote/src/remote_identity.rsindex 92d9534e7d2..f776bdb7a90 100644--- a/crates/remote/src/remote_identity.rs+++ b/crates/remote/src/remote_identity.rs@@ -26,6 +26,37 @@ pub enum RemoteConnectionIdentity {Mock { id: u64 },}+impl RemoteConnectionIdentity {+ /// A stable string form of this identity, suitable for use in+ /// persistence keys (e.g. database keys scoped to a remote host).+ pub fn persistence_key(&self) -> String {+ match self {+ Self::Ssh {+ host,+ username,+ port,+ } => format!(+ "ssh:{}@{}:{}",+ username.as_deref().unwrap_or_default(),+ host,+ port.map(|port| port.to_string()).unwrap_or_default()+ ),+ Self::Wsl { distro_name, user } => format!(+ "wsl:{}@{}",+ user.as_deref().unwrap_or_default(),+ distro_name+ ),+ Self::Docker {+ container_id,+ name,+ remote_user,+ } => format!("docker:{remote_user}@{name}:{container_id}"),+ #[cfg(any(test, feature = "test-support"))]+ Self::Mock { id } => format!("mock:{id}"),+ }+ }+}+impl From<&RemoteConnectionOptions> for RemoteConnectionIdentity {fn from(options: &RemoteConnectionOptions) -> Self {match options {diff --git a/crates/sidebar/src/sidebar_tests.rs b/crates/sidebar/src/sidebar_tests.rsindex 2991b2d3324..e5c7cca5d67 100644--- a/crates/sidebar/src/sidebar_tests.rs+++ b/crates/sidebar/src/sidebar_tests.rs@@ -28,6 +28,9 @@ fn init_test(cx: &mut TestAppContext) {cx.update(|cx| {let settings_store = SettingsStore::test(cx);cx.set_global(settings_store);+ // Use an isolated DB so parallel tests can't see each other's+ // persisted records (e.g. created-worktree records).+ cx.set_global(db::AppDatabase::test_new());theme_settings::init(theme::LoadThemes::JustBase, cx);editor::init(cx);ThreadStore::init_global(cx);@@ -2047,6 +2050,13 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;@@ -2533,6 +2543,13 @@ async fn test_archive_selected_draft_archives_linked_worktree_after_last_draft(},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;@@ -2751,6 +2768,13 @@ async fn test_archive_selected_draft_archives_closed_linked_worktree(cx: &mut Te},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;@@ -3296,6 +3320,13 @@ async fn test_archive_selected_terminal_archives_closed_linked_worktree(cx: &mut},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;@@ -3464,6 +3495,13 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;@@ -8130,6 +8168,13 @@ async fn test_archive_last_worktree_thread_removes_workspace(cx: &mut TestAppCon},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));@@ -13488,6 +13533,13 @@ async fn test_archive_removes_worktree_even_when_workspace_paths_diverge(cx: &mu},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));@@ -13640,6 +13692,13 @@ async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &m},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/main-repo/feature-b/main-repo"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));@@ -13861,6 +13920,13 @@ async fn test_discard_mixed_workspace_draft_closes_only_archived_worktree_items(},).await;+ agent_ui::test_support::record_zed_created_worktree(+ fs.as_ref(),+ Path::new("/worktrees/main-repo/feature-b/main-repo"),+ None,+ cx,+ )+ .await;cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));@@ -14202,6 +14268,18 @@ async fn test_remote_archive_thread_with_active_connection(// parent repo, so `build_root_plan` targets the linked worktree// specifically and knows which main repo owns it.let remote_connection = project.read_with(cx, |p, cx| p.remote_connection_options(cx));++ // Record the worktree as Zed-created on the client, keyed by the remote+ // connection identity, with the creation time of the gitdir on the+ // *remote* filesystem (where the archive flow will re-stat it).+ agent_ui::test_support::record_zed_created_worktree(+ server_fs.as_ref(),+ Path::new("/worktrees/project/feature-a/project"),+ remote_connection.as_ref(),+ cx,+ )+ .await;+let wt_thread_id = acp::SessionId::new(Arc::from("worktree-thread"));cx.update(|_window, cx| {let metadata = ThreadMetadata {