Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

sidebar: Don't block worktree archival on empty drafts (#57145)

Ben Brandt0535f4729189
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index 151a04d8bf3..862b007f52c 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -2758,6 +2758,25 @@ impl AgentPanel {
/// the panel and deletes its metadata row. Used by the sidebar when
/// the user dismisses a parked draft.
pub fn remove_thread(&mut self, id: ThreadId, window: &mut Window, cx: &mut Context<Self>) {
+ self.remove_thread_internal(id, true, window, cx);
+ }
+
+ pub fn remove_thread_without_activating_draft(
+ &mut self,
+ id: ThreadId,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ self.remove_thread_internal(id, false, window, cx);
+ }
+
+ fn remove_thread_internal(
+ &mut self,
+ id: ThreadId,
+ activate_draft_after_remove: bool,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
self.retained_threads.remove(&id);
ThreadMetadataStore::global(cx).update(cx, |store, cx| {
store.delete(id, cx);
@@ -2774,7 +2793,12 @@ impl AgentPanel {
if self.active_thread_id(cx) == Some(id) {
self.clear_overlay_state();
- self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+ if activate_draft_after_remove {
+ self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+ } else {
+ self.base_view = BaseView::Uninitialized;
+ self.refresh_base_view_subscriptions(window, cx);
+ }
self.serialize(cx);
cx.emit(AgentPanelEvent::ActiveViewChanged);
cx.notify();
@@ -2845,6 +2869,37 @@ impl AgentPanel {
}
}
+ pub fn draft_prompt_blocks_if_in_memory(
+ &self,
+ id: ThreadId,
+ cx: &App,
+ ) -> Option<Vec<acp::ContentBlock>> {
+ let cv = self
+ .retained_threads
+ .get(&id)
+ .or_else(|| {
+ self.draft_thread
+ .as_ref()
+ .filter(|draft| draft.read(cx).thread_id == id)
+ })
+ .or_else(|| match &self.base_view {
+ BaseView::AgentThread { conversation_view }
+ if conversation_view.read(cx).thread_id == id =>
+ {
+ Some(conversation_view)
+ }
+ _ => None,
+ })?;
+ let thread_view = cv.read(cx).root_thread_view()?;
+ let thread_view = thread_view.read(cx);
+ Some(
+ thread_view
+ .message_editor
+ .read(cx)
+ .draft_content_blocks_snapshot(cx),
+ )
+ }
+
fn new_native_agent_thread_from_summary(
&mut self,
action: &NewNativeAgentThreadFromSummary,
@@ -6681,6 +6736,184 @@ mod tests {
}
}
+ #[gpui::test]
+ async fn test_draft_prompt_blocks_use_current_editor_snapshot(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.update(|cx| {
+ agent::ThreadStore::init_global(cx);
+ language_model::LanguageModelRegistry::test(cx);
+ });
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree("/project", json!({ "file.txt": "" })).await;
+ let project = Project::test(fs.clone(), [Path::new("/project")], cx).await;
+
+ let multi_workspace =
+ cx.add_window(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let workspace = multi_workspace
+ .read_with(cx, |multi_workspace, _cx| {
+ multi_workspace.workspace().clone()
+ })
+ .unwrap();
+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+ let panel = workspace.update_in(cx, |workspace, window, cx| {
+ let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+ workspace.add_panel(panel.clone(), window, cx);
+ panel
+ });
+
+ let _stub_connection =
+ crate::test_support::set_stub_agent_connection(StubAgentConnection::new());
+ panel.update_in(cx, |panel, window, cx| {
+ panel.selected_agent = Agent::Stub;
+ panel.activate_draft(true, AgentThreadSource::AgentPanel, window, cx);
+ });
+ cx.run_until_parked();
+
+ let thread_id = active_thread_id(&panel, cx);
+ let thread = panel.read_with(cx, |panel, cx| {
+ panel
+ .active_agent_thread(cx)
+ .expect("draft thread should be active")
+ });
+ let message_editor = panel.read_with(cx, |panel, cx| {
+ panel
+ .active_thread_view(cx)
+ .expect("draft thread view should be active")
+ .read(cx)
+ .message_editor
+ .clone()
+ });
+
+ thread.update(cx, |thread, cx| {
+ thread.set_draft_prompt(
+ Some(vec![acp::ContentBlock::Text(acp::TextContent::new(
+ "stale prompt",
+ ))]),
+ cx,
+ );
+ });
+ message_editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("fresh prompt", window, cx);
+ });
+ let blocks = panel.read_with(cx, |panel, cx| {
+ panel
+ .draft_prompt_blocks_if_in_memory(thread_id, cx)
+ .expect("draft should be in memory")
+ });
+ assert_eq!(blocks.len(), 1);
+ assert_eq!(expect_text_block(&blocks[0]), "fresh prompt");
+
+ thread.update(cx, |thread, cx| {
+ thread.set_draft_prompt(
+ Some(vec![acp::ContentBlock::Text(acp::TextContent::new(
+ "stale prompt after clear",
+ ))]),
+ cx,
+ );
+ });
+ message_editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("", window, cx);
+ });
+ let blocks = panel.read_with(cx, |panel, cx| {
+ panel
+ .draft_prompt_blocks_if_in_memory(thread_id, cx)
+ .expect("draft should be in memory")
+ });
+ assert!(
+ blocks.is_empty(),
+ "cleared editor snapshot should override stale saved draft prompt"
+ );
+ }
+
+ #[gpui::test]
+ async fn test_draft_has_user_content_checks_all_live_copies(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.update(|cx| {
+ agent::ThreadStore::init_global(cx);
+ language_model::LanguageModelRegistry::test(cx);
+ });
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree("/project_a", json!({ "file.txt": "" }))
+ .await;
+ fs.insert_tree("/project_b", json!({ "file.txt": "" }))
+ .await;
+ let project_a = Project::test(fs.clone(), [Path::new("/project_a")], cx).await;
+ let project_b = Project::test(fs.clone(), [Path::new("/project_b")], cx).await;
+
+ let multi_workspace =
+ cx.add_window(|window, cx| MultiWorkspace::test_new(project_a.clone(), window, cx));
+ let workspace_a = multi_workspace
+ .read_with(cx, |multi_workspace, _cx| {
+ multi_workspace.workspace().clone()
+ })
+ .unwrap();
+ let workspace_b = multi_workspace
+ .update(cx, |multi_workspace, window, cx| {
+ multi_workspace.test_add_workspace(project_b.clone(), window, cx)
+ })
+ .unwrap();
+
+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+ let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {
+ let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+ workspace.add_panel(panel.clone(), window, cx);
+ panel
+ });
+ let panel_b = workspace_b.update_in(cx, |workspace, window, cx| {
+ let panel = cx.new(|cx| AgentPanel::new(workspace, None, window, cx));
+ workspace.add_panel(panel.clone(), window, cx);
+ panel
+ });
+
+ let _stub_connection =
+ crate::test_support::set_stub_agent_connection(StubAgentConnection::new());
+ panel_a.update_in(cx, |panel, window, cx| {
+ panel.selected_agent = Agent::Stub;
+ panel.activate_draft(true, AgentThreadSource::AgentPanel, window, cx);
+ });
+ cx.run_until_parked();
+ let thread_id = active_thread_id(&panel_a, cx);
+
+ panel_b.update_in(cx, |panel, window, cx| {
+ panel.load_agent_thread(
+ Agent::Stub,
+ thread_id,
+ Some(PathList::new(&[PathBuf::from("/project_b")])),
+ None,
+ false,
+ AgentThreadSource::AgentPanel,
+ window,
+ cx,
+ );
+ });
+ cx.run_until_parked();
+
+ crate::test_support::type_draft_prompt(&panel_b, "content in second panel", cx);
+ let panel_a_blocks = panel_a.read_with(cx, |panel, cx| {
+ panel
+ .draft_prompt_blocks_if_in_memory(thread_id, cx)
+ .expect("draft should be live in first panel")
+ });
+ assert!(
+ panel_a_blocks.is_empty(),
+ "first live draft copy should be empty"
+ );
+
+ let has_user_content = cx.update(|_, cx| {
+ crate::draft_prompt_store::draft_has_user_content(
+ thread_id,
+ [&workspace_a, &workspace_b],
+ cx,
+ )
+ });
+ assert!(
+ has_user_content,
+ "a later live draft copy with content should keep the draft"
+ );
+ }
+
#[test]
fn test_build_conflict_resolution_prompt_single_conflict() {
let conflicts = vec![ConflictContent {
diff --git a/crates/agent_ui/src/draft_prompt_store.rs b/crates/agent_ui/src/draft_prompt_store.rs
index 34d17d49994..c0b45ed7589 100644
--- a/crates/agent_ui/src/draft_prompt_store.rs
+++ b/crates/agent_ui/src/draft_prompt_store.rs
@@ -29,7 +29,7 @@ pub fn read(thread_id: ThreadId, cx: &App) -> Option<Vec<acp::ContentBlock>> {
let kvp = KeyValueStore::global(cx);
let raw = kvp
.scoped(NAMESPACE)
- .read(&thread_id_key(thread_id))
+ .read(&thread_id.to_key_string())
.log_err()
.flatten()?;
serde_json::from_str(&raw).log_err()
@@ -41,7 +41,7 @@ pub fn write(
cx: &App,
) -> Task<anyhow::Result<()>> {
let kvp = KeyValueStore::global(cx);
- let key = thread_id_key(thread_id);
+ let key = thread_id.to_key_string();
let payload = match serde_json::to_string(prompt).context("serializing draft prompt") {
Ok(payload) => payload,
Err(err) => return Task::ready(Err(err)),
@@ -51,12 +51,43 @@ pub fn write(
pub fn delete(thread_id: ThreadId, cx: &App) -> Task<anyhow::Result<()>> {
let kvp = KeyValueStore::global(cx);
- let key = thread_id_key(thread_id);
+ let key = thread_id.to_key_string();
cx.background_spawn(async move { kvp.scoped(NAMESPACE).delete(key).await })
}
-fn thread_id_key(thread_id: ThreadId) -> String {
- thread_id.to_key_string()
+pub fn draft_has_user_content<'a>(
+ thread_id: ThreadId,
+ workspaces: impl IntoIterator<Item = &'a Entity<Workspace>>,
+ cx: &App,
+) -> bool {
+ let mut found_live_copy = false;
+ for blocks in workspaces
+ .into_iter()
+ .filter_map(|workspace| workspace.read(cx).panel::<AgentPanel>(cx))
+ .filter_map(|panel| {
+ panel
+ .read(cx)
+ .draft_prompt_blocks_if_in_memory(thread_id, cx)
+ })
+ {
+ found_live_copy = true;
+ if blocks_have_user_content(&blocks) {
+ return true;
+ }
+ }
+
+ if found_live_copy {
+ false
+ } else {
+ read(thread_id, cx).is_some_and(|blocks| blocks_have_user_content(&blocks))
+ }
+}
+
+fn blocks_have_user_content(blocks: &[acp::ContentBlock]) -> bool {
+ blocks.iter().any(|block| match block {
+ acp::ContentBlock::Text(text) => !text.text.trim().is_empty(),
+ _ => true,
+ })
}
/// Rewrites `[@Something](scheme://...)` mention links as `@Something` so the
diff --git a/crates/agent_ui/src/thread_metadata_store.rs b/crates/agent_ui/src/thread_metadata_store.rs
index 594b0d00b83..f3bbdaa0c9e 100644
--- a/crates/agent_ui/src/thread_metadata_store.rs
+++ b/crates/agent_ui/src/thread_metadata_store.rs
@@ -347,6 +347,20 @@ impl ThreadMetadata {
pub fn main_worktree_paths(&self) -> &PathList {
self.worktree_paths.main_worktree_path_list()
}
+
+ pub fn references_folder_path(&self, path: &Path) -> bool {
+ self.folder_paths()
+ .paths()
+ .iter()
+ .any(|folder_path| folder_path.as_path() == path)
+ }
+
+ pub fn matches_remote_connection(
+ &self,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ ) -> bool {
+ same_remote_connection_identity(self.remote_connection.as_ref(), remote_connection)
+ }
}
/// Derives worktree display info from a thread's stored path list.
@@ -615,9 +629,7 @@ impl ThreadMetadataStore {
.flatten()
.filter_map(|s| self.threads.get(s))
.filter(|s| !s.archived)
- .filter(move |s| {
- same_remote_connection_identity(s.remote_connection.as_ref(), remote_connection)
- })
+ .filter(move |s| s.matches_remote_connection(remote_connection))
}
/// Returns threads whose `main_worktree_paths` matches the given path list
@@ -639,9 +651,7 @@ impl ThreadMetadataStore {
.flatten()
.filter_map(|s| self.threads.get(s))
.filter(|s| !s.archived)
- .filter(move |s| {
- same_remote_connection_identity(s.remote_connection.as_ref(), remote_connection)
- })
+ .filter(move |s| s.matches_remote_connection(remote_connection))
}
fn reload(&mut self, cx: &mut Context<Self>) -> Shared<Task<()>> {
@@ -858,19 +868,28 @@ impl ThreadMetadataStore {
thread_id: Option<ThreadId>,
path: &Path,
remote_connection: Option<&RemoteConnectionOptions>,
+ ) -> bool {
+ self.path_is_referenced_by_unarchived_threads_matching(
+ thread_id,
+ path,
+ remote_connection,
+ |_| true,
+ )
+ }
+
+ pub fn path_is_referenced_by_unarchived_threads_matching(
+ &self,
+ thread_id: Option<ThreadId>,
+ path: &Path,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ matches: impl Fn(&ThreadMetadata) -> bool,
) -> bool {
self.entries().any(|thread| {
Some(thread.thread_id) != thread_id
&& !thread.archived
- && same_remote_connection_identity(
- thread.remote_connection.as_ref(),
- remote_connection,
- )
- && thread
- .folder_paths()
- .paths()
- .iter()
- .any(|other_path| other_path.as_path() == path)
+ && thread.matches_remote_connection(remote_connection)
+ && thread.references_folder_path(path)
+ && matches(thread)
})
}
@@ -1123,6 +1142,26 @@ impl ThreadMetadataStore {
cx.notify();
}
+ pub fn unarchived_draft_ids_matching(
+ &self,
+ matches: impl Fn(&ThreadMetadata) -> bool,
+ ) -> Vec<ThreadId> {
+ self.entries()
+ .filter(|thread| thread.is_draft() && !thread.archived && matches(thread))
+ .map(|thread| thread.thread_id)
+ .collect()
+ }
+
+ pub fn delete_all(
+ &mut self,
+ thread_ids: impl IntoIterator<Item = ThreadId>,
+ cx: &mut Context<Self>,
+ ) {
+ for thread_id in thread_ids {
+ self.delete(thread_id, cx);
+ }
+ }
+
fn new(db: ThreadMetadataDb, cx: &mut Context<Self>) -> Self {
let weak_store = cx.weak_entity();
diff --git a/crates/agent_ui/src/thread_worktree_archive.rs b/crates/agent_ui/src/thread_worktree_archive.rs
index b510da96b4e..f3d54657d49 100644
--- a/crates/agent_ui/src/thread_worktree_archive.rs
+++ b/crates/agent_ui/src/thread_worktree_archive.rs
@@ -831,6 +831,27 @@ pub fn all_open_workspaces(cx: &App) -> Vec<Entity<Workspace>> {
.collect()
}
+pub fn workspaces_for_archive(
+ multi_workspace: Option<&Entity<MultiWorkspace>>,
+ cx: &App,
+) -> Vec<Entity<Workspace>> {
+ let mut workspaces = multi_workspace
+ .map(|multi_workspace| {
+ multi_workspace
+ .read(cx)
+ .workspaces()
+ .cloned()
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ for workspace in all_open_workspaces(cx) {
+ if !workspaces.contains(&workspace) {
+ workspaces.push(workspace);
+ }
+ }
+ workspaces
+}
+
fn current_app_state(cx: &mut AsyncApp) -> Option<Arc<AppState>> {
cx.update(|cx| {
all_open_workspaces(cx)
diff --git a/crates/sidebar/src/sidebar.rs b/crates/sidebar/src/sidebar.rs
index 7fcaf38a3f5..1dfec54ebaa 100644
--- a/crates/sidebar/src/sidebar.rs
+++ b/crates/sidebar/src/sidebar.rs
@@ -475,10 +475,6 @@ fn linked_worktree_path_lists_for_workspaces(
.collect()
}
-fn workspace_has_terminal_metadata(workspace: &Entity<Workspace>, cx: &App) -> bool {
- workspace_has_terminal_metadata_except(workspace, None, cx)
-}
-
fn workspace_has_terminal_metadata_except(
workspace: &Entity<Workspace>,
except_terminal_id: Option<TerminalId>,
@@ -3657,6 +3653,7 @@ impl Sidebar {
}
fn should_load_closed_workspace_for_archive(
+ &self,
folder_paths: &PathList,
project_group_key: &ProjectGroupKey,
remote_connection: Option<&RemoteConnectionOptions>,
@@ -3668,13 +3665,17 @@ impl Sidebar {
return false;
}
+ let archive_workspaces = self.archive_workspaces(cx);
let thread_store = ThreadMetadataStore::global(cx);
let thread_store = thread_store.read(cx);
if folder_paths.ordered_paths().any(|path| {
- thread_store.path_is_referenced_by_unarchived_threads(
+ Self::path_is_referenced_by_unarchived_threads_for_archive(
+ &thread_store,
except_thread_id,
path,
remote_connection,
+ &archive_workspaces,
+ cx,
)
}) {
return false;
@@ -3692,6 +3693,208 @@ impl Sidebar {
})
}
+ fn path_is_referenced_by_unarchived_threads_for_archive(
+ thread_store: &ThreadMetadataStore,
+ except_thread_id: Option<ThreadId>,
+ path: &Path,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ archive_workspaces: &[Entity<Workspace>],
+ cx: &App,
+ ) -> bool {
+ thread_store.path_is_referenced_by_unarchived_threads_matching(
+ except_thread_id,
+ path,
+ remote_connection,
+ |thread| Self::thread_blocks_worktree_archive(thread, archive_workspaces, cx),
+ )
+ }
+
+ fn archive_workspaces(&self, cx: &App) -> Vec<Entity<Workspace>> {
+ let multi_workspace = self.multi_workspace.upgrade();
+ thread_worktree_archive::workspaces_for_archive(multi_workspace.as_ref(), cx)
+ }
+
+ fn count_threads_blocking_worktree_archive(
+ &self,
+ path_list: &PathList,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ except_thread_id: Option<ThreadId>,
+ cx: &App,
+ ) -> usize {
+ let archive_workspaces = self.archive_workspaces(cx);
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entries_for_path(path_list, remote_connection)
+ .filter(|thread| Some(thread.thread_id) != except_thread_id)
+ .filter(|thread| Self::thread_blocks_worktree_archive(thread, &archive_workspaces, cx))
+ .count()
+ }
+
+ fn roots_to_archive_for_paths(
+ &self,
+ folder_paths: &PathList,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ except_thread_id: Option<ThreadId>,
+ except_terminal_id: Option<TerminalId>,
+ cx: &App,
+ ) -> Vec<thread_worktree_archive::RootPlan> {
+ let workspaces = self.archive_workspaces(cx);
+ folder_paths
+ .ordered_paths()
+ .filter_map(|path| {
+ thread_worktree_archive::build_root_plan(path, remote_connection, &workspaces, cx)
+ })
+ .filter(|plan| {
+ let store = ThreadMetadataStore::global(cx);
+ let store = store.read(cx);
+ !Self::path_is_referenced_by_unarchived_threads_for_archive(
+ &store,
+ except_thread_id,
+ plan.root_path.as_path(),
+ remote_connection,
+ &workspaces,
+ cx,
+ )
+ })
+ .filter(|root| {
+ TerminalThreadMetadataStore::try_global(cx).is_none_or(|terminal_store| {
+ !terminal_store.read(cx).path_is_referenced_by_terminal(
+ except_terminal_id,
+ root.root_path.as_path(),
+ remote_connection,
+ )
+ })
+ })
+ .collect()
+ }
+
+ fn linked_worktree_workspace_to_remove(
+ &self,
+ folder_paths: &PathList,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ except_thread_id: Option<ThreadId>,
+ except_terminal_id: Option<TerminalId>,
+ roots_to_archive: &[thread_worktree_archive::RootPlan],
+ cx: &App,
+ ) -> Option<Entity<Workspace>> {
+ if folder_paths.is_empty() {
+ return None;
+ }
+
+ let remaining = self.count_threads_blocking_worktree_archive(
+ folder_paths,
+ remote_connection,
+ except_thread_id,
+ cx,
+ );
+
+ if remaining > 0 {
+ return None;
+ }
+
+ let multi_workspace = self.multi_workspace.upgrade()?;
+ let workspace =
+ multi_workspace
+ .read(cx)
+ .workspace_for_paths(folder_paths, remote_connection, cx)?;
+
+ if workspace_has_terminal_metadata_except(&workspace, except_terminal_id, cx) {
+ return None;
+ }
+
+ if !roots_to_archive.is_empty() {
+ let archive_paths: HashSet<&Path> = roots_to_archive
+ .iter()
+ .map(|root| root.root_path.as_path())
+ .collect();
+ let project = workspace.read(cx).project().clone();
+ let visible_worktree_paths = project
+ .read(cx)
+ .visible_worktrees(cx)
+ .map(|worktree| worktree.read(cx).abs_path())
+ .collect::<Vec<_>>();
+ return (!visible_worktree_paths.is_empty()
+ && visible_worktree_paths
+ .iter()
+ .all(|path| archive_paths.contains(path.as_ref())))
+ .then_some(workspace);
+ }
+
+ let group_key = workspace.read(cx).project_group_key(cx);
+ (group_key.path_list() != folder_paths).then_some(workspace)
+ }
+
+ fn delete_empty_drafts_for_archive_roots(
+ &self,
+ roots: &[thread_worktree_archive::RootPlan],
+ cx: &mut Context<Self>,
+ ) {
+ self.delete_empty_drafts_for_archive_targets(
+ roots
+ .iter()
+ .map(|root| (root.root_path.as_path(), root.remote_connection.as_ref())),
+ cx,
+ );
+ }
+
+ fn delete_empty_drafts_for_archive_paths(
+ &self,
+ paths: &PathList,
+ remote_connection: Option<&RemoteConnectionOptions>,
+ cx: &mut Context<Self>,
+ ) {
+ self.delete_empty_drafts_for_archive_targets(
+ paths
+ .ordered_paths()
+ .map(|path| (path.as_path(), remote_connection)),
+ cx,
+ );
+ }
+
+ fn delete_empty_drafts_for_archive_targets<'a>(
+ &self,
+ targets: impl IntoIterator<Item = (&'a Path, Option<&'a RemoteConnectionOptions>)>,
+ cx: &mut Context<Self>,
+ ) {
+ let targets = targets.into_iter().collect::<Vec<_>>();
+ if targets.is_empty() {
+ return;
+ }
+
+ let archive_workspaces = self.archive_workspaces(cx);
+ let draft_thread_ids = ThreadMetadataStore::global(cx)
+ .read(cx)
+ .unarchived_draft_ids_matching(|thread| {
+ targets.iter().any(|(path, remote_connection)| {
+ thread.matches_remote_connection(*remote_connection)
+ && thread.references_folder_path(path)
+ }) && !Self::thread_blocks_worktree_archive(thread, &archive_workspaces, cx)
+ });
+ if draft_thread_ids.is_empty() {
+ return;
+ }
+
+ ThreadMetadataStore::global(cx).update(cx, |store, cx| {
+ store.delete_all(draft_thread_ids, cx);
+ });
+ }
+
+ fn thread_blocks_worktree_archive(
+ thread: &ThreadMetadata,
+ archive_workspaces: &[Entity<Workspace>],
+ cx: &App,
+ ) -> bool {
+ if !thread.is_draft() {
+ return true;
+ }
+
+ agent_ui::draft_prompt_store::draft_has_user_content(
+ thread.thread_id,
+ archive_workspaces,
+ cx,
+ )
+ }
+
async fn wait_for_archive_workspace_metadata(
workspace: &Entity<Workspace>,
cx: &mut gpui::AsyncApp,
@@ -3821,7 +4024,7 @@ impl Sidebar {
folder_paths,
project_group_key,
} = workspace
- && Self::should_load_closed_workspace_for_archive(
+ && self.should_load_closed_workspace_for_archive(
folder_paths,
project_group_key,
metadata.remote_connection.as_ref(),
@@ -3859,83 +4062,22 @@ impl Sidebar {
.and_then(|position| self.neighboring_activatable_entry(position));
let terminal_folder_paths = metadata.folder_paths().clone();
- let roots_to_archive = {
- let mut workspaces = self
- .multi_workspace
- .upgrade()
- .map(|multi_workspace| {
- multi_workspace
- .read(cx)
- .workspaces()
- .cloned()
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- for workspace in thread_worktree_archive::all_open_workspaces(cx) {
- if !workspaces.contains(&workspace) {
- workspaces.push(workspace);
- }
- }
-
- metadata
- .folder_paths()
- .ordered_paths()
- .filter_map(|path| {
- thread_worktree_archive::build_root_plan(
- path,
- metadata.remote_connection.as_ref(),
- &workspaces,
- cx,
- )
- })
- .filter(|plan| {
- let store = ThreadMetadataStore::global(cx);
- let store = store.read(cx);
- !store.path_is_referenced_by_unarchived_threads(
- None,
- &plan.root_path,
- metadata.remote_connection.as_ref(),
- )
- })
- .filter(|root| {
- TerminalThreadMetadataStore::try_global(cx).is_none_or(|terminal_store| {
- !terminal_store.read(cx).path_is_referenced_by_terminal(
- Some(terminal_id),
- root.root_path.as_path(),
- metadata.remote_connection.as_ref(),
- )
- })
- })
- .collect::<Vec<_>>()
- };
-
- let workspace_to_remove = if terminal_folder_paths.is_empty() {
- None
- } else {
- let remaining = ThreadMetadataStore::global(cx)
- .read(cx)
- .entries_for_path(&terminal_folder_paths, metadata.remote_connection.as_ref())
- .count();
-
- if remaining > 0 {
- None
- } else {
- let workspace = self.multi_workspace.upgrade().and_then(|multi_workspace| {
- multi_workspace
- .read(cx)
- .workspace_for_paths(&terminal_folder_paths, None, cx)
- });
-
- workspace.and_then(|workspace| {
- if workspace_has_terminal_metadata_except(&workspace, Some(terminal_id), cx) {
- return None;
- }
+ let roots_to_archive = self.roots_to_archive_for_paths(
+ metadata.folder_paths(),
+ metadata.remote_connection.as_ref(),
+ None,
+ Some(terminal_id),
+ cx,
+ );
- let group_key = workspace.read(cx).project_group_key(cx);
- (group_key.path_list() != &terminal_folder_paths).then_some(workspace)
- })
- }
- };
+ let workspace_to_remove = self.linked_worktree_workspace_to_remove(
+ &terminal_folder_paths,
+ metadata.remote_connection.as_ref(),
+ None,
+ Some(terminal_id),
+ &roots_to_archive,
+ cx,
+ );
let mut workspaces_to_remove: Vec<Entity<Workspace>> =
workspace_to_remove.into_iter().collect();
@@ -4003,6 +4145,13 @@ impl Sidebar {
}
this.update_in(cx, |this, window, cx| {
+ if terminal_workspace_removed {
+ this.delete_empty_drafts_for_archive_paths(
+ metadata.folder_paths(),
+ metadata.remote_connection.as_ref(),
+ cx,
+ );
+ }
// If the terminal's workspace has already been removed,
// don't synthesize a fallback draft in the detached
// AgentPanel.
@@ -4193,33 +4342,44 @@ impl Sidebar {
) {
let store = ThreadMetadataStore::global(cx);
let metadata = store.read(cx).entry_by_session(session_id).cloned();
- let active_workspace = metadata.as_ref().and_then(|metadata| {
+ let metadata_thread_id = metadata.as_ref().map(|metadata| metadata.thread_id);
+ let thread_entry = self.contents.entries.iter().find_map(|entry| match entry {
+ ListEntry::Thread(thread) => metadata_thread_id
+ .map_or_else(
+ || thread.metadata.session_id.as_ref() == Some(session_id),
+ |thread_id| thread.metadata.thread_id == thread_id,
+ )
+ .then(|| thread.clone()),
+ _ => None,
+ });
+ let thread_id = metadata_thread_id.or_else(|| {
+ thread_entry
+ .as_ref()
+ .map(|thread| thread.metadata.thread_id)
+ });
+ let active_workspace = thread_id.and_then(|thread_id| {
self.active_entry.as_ref().and_then(|entry| {
- if entry.is_active_thread(&metadata.thread_id) {
+ if entry.is_active_thread(&thread_id) {
Some(entry.workspace().clone())
} else {
None
}
})
});
- let thread_id = metadata.as_ref().map(|metadata| metadata.thread_id);
let thread_folder_paths = metadata
.as_ref()
.map(|metadata| metadata.folder_paths().clone())
+ .or_else(|| {
+ thread_entry
+ .as_ref()
+ .map(|thread| thread.metadata.folder_paths().clone())
+ })
.or_else(|| {
active_workspace
.as_ref()
.map(|workspace| PathList::new(&workspace.read(cx).root_paths(cx)))
});
- let thread_entry_workspace = self.contents.entries.iter().find_map(|entry| match entry {
- ListEntry::Thread(thread) => thread_id
- .map_or_else(
- || thread.metadata.session_id.as_ref() == Some(session_id),
- |tid| thread.metadata.thread_id == tid,
- )
- .then(|| thread.workspace.clone()),
- _ => None,
- });
+ let thread_entry_workspace = thread_entry.map(|thread| thread.workspace);
if let (
Some(metadata),
@@ -4228,7 +4388,7 @@ impl Sidebar {
project_group_key,
}),
) = (metadata.as_ref(), thread_entry_workspace)
- && Self::should_load_closed_workspace_for_archive(
+ && self.should_load_closed_workspace_for_archive(
&folder_paths,
&project_group_key,
metadata.remote_connection.as_ref(),
@@ -4255,52 +4415,13 @@ impl Sidebar {
let roots_to_archive = metadata
.as_ref()
.map(|metadata| {
- let mut workspaces = self
- .multi_workspace
- .upgrade()
- .map(|multi_workspace| {
- multi_workspace
- .read(cx)
- .workspaces()
- .cloned()
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- for workspace in thread_worktree_archive::all_open_workspaces(cx) {
- if !workspaces.contains(&workspace) {
- workspaces.push(workspace);
- }
- }
- metadata
- .folder_paths()
- .ordered_paths()
- .filter_map(|path| {
- thread_worktree_archive::build_root_plan(
- path,
- metadata.remote_connection.as_ref(),
- &workspaces,
- cx,
- )
- })
- .filter(|plan| {
- thread_id.map_or(true, |tid| {
- !store.read(cx).path_is_referenced_by_unarchived_threads(
- Some(tid),
- &plan.root_path,
- metadata.remote_connection.as_ref(),
- )
- })
- })
- .filter(|root| {
- TerminalThreadMetadataStore::try_global(cx).is_none_or(|terminal_store| {
- !terminal_store.read(cx).path_is_referenced_by_terminal(
- None,
- root.root_path.as_path(),
- metadata.remote_connection.as_ref(),
- )
- })
- })
- .collect::<Vec<_>>()
+ self.roots_to_archive_for_paths(
+ metadata.folder_paths(),
+ metadata.remote_connection.as_ref(),
+ thread_id,
+ None,
+ cx,
+ )
})
.unwrap_or_default();
@@ -4317,35 +4438,16 @@ impl Sidebar {
// Check if archiving this thread would leave its worktree workspace
// with no threads, requiring workspace removal.
let workspace_to_remove = thread_folder_paths.as_ref().and_then(|folder_paths| {
- if folder_paths.is_empty() {
- return None;
- }
-
let thread_remote_connection =
metadata.as_ref().and_then(|m| m.remote_connection.as_ref());
- let remaining = ThreadMetadataStore::global(cx)
- .read(cx)
- .entries_for_path(folder_paths, thread_remote_connection)
- .filter(|t| t.session_id.as_ref() != Some(session_id))
- .count();
-
- if remaining > 0 {
- return None;
- }
-
- let multi_workspace = self.multi_workspace.upgrade()?;
- let workspace = multi_workspace
- .read(cx)
- .workspace_for_paths(folder_paths, None, cx)?;
-
- if workspace_has_terminal_metadata(&workspace, cx) {
- return None;
- }
-
- let group_key = workspace.read(cx).project_group_key(cx);
- let is_linked_worktree = group_key.path_list() != folder_paths;
-
- is_linked_worktree.then_some(workspace)
+ self.linked_worktree_workspace_to_remove(
+ folder_paths,
+ thread_remote_connection,
+ thread_id,
+ None,
+ &roots_to_archive,
+ cx,
+ )
});
// Also find workspaces for root plans that aren't covered by
@@ -4407,6 +4509,9 @@ impl Sidebar {
});
let thread_folder_paths = thread_folder_paths.clone();
+ let thread_remote_connection = metadata
+ .as_ref()
+ .and_then(|metadata| metadata.remote_connection.clone());
cx.spawn_in(window, async move |this, cx| {
if !remove_task.await? {
return anyhow::Ok(());
@@ -4418,6 +4523,13 @@ impl Sidebar {
}
this.update_in(cx, |this, window, cx| {
+ if let Some(thread_folder_paths) = thread_folder_paths.as_ref() {
+ this.delete_empty_drafts_for_archive_paths(
+ thread_folder_paths,
+ thread_remote_connection.as_ref(),
+ cx,
+ );
+ }
let in_flight = thread_id.and_then(|tid| {
this.start_archive_worktree_task(tid, roots_to_archive, cx)
});
@@ -4426,6 +4538,7 @@ impl Sidebar {
thread_id,
neighbor.as_ref(),
thread_folder_paths.as_ref(),
+ thread_remote_connection.as_ref(),
in_flight,
window,
cx,
@@ -4437,6 +4550,9 @@ impl Sidebar {
} else if !close_item_tasks.is_empty() {
let session_id = session_id.clone();
let thread_folder_paths = thread_folder_paths.clone();
+ let thread_remote_connection = metadata
+ .as_ref()
+ .and_then(|metadata| metadata.remote_connection.clone());
cx.spawn_in(window, async move |this, cx| {
for task in close_item_tasks {
let result: anyhow::Result<()> = task.await;
@@ -4452,6 +4568,7 @@ impl Sidebar {
thread_id,
neighbor.as_ref(),
thread_folder_paths.as_ref(),
+ thread_remote_connection.as_ref(),
in_flight,
window,
cx,
@@ -4468,6 +4585,9 @@ impl Sidebar {
thread_id,
neighbor.as_ref(),
thread_folder_paths.as_ref(),
+ metadata
+ .as_ref()
+ .and_then(|metadata| metadata.remote_connection.as_ref()),
in_flight,
window,
cx,
@@ -4497,6 +4617,7 @@ impl Sidebar {
thread_id: Option<agent_ui::ThreadId>,
neighbor: Option<&ActivatableEntry>,
thread_folder_paths: Option<&PathList>,
+ thread_remote_connection: Option<&RemoteConnectionOptions>,
in_flight_archive: Option<(Task<()>, async_channel::Sender<()>)>,
window: &mut Window,
cx: &mut Context<Self>,
@@ -4521,11 +4642,10 @@ impl Sidebar {
// archived thread from its workspace's panel so that switching
// to that workspace later doesn't show a stale thread.
if let Some(folder_paths) = thread_folder_paths {
- if let Some(workspace) = self
- .multi_workspace
- .upgrade()
- .and_then(|mw| mw.read(cx).workspace_for_paths(folder_paths, None, cx))
- {
+ if let Some(workspace) = self.multi_workspace.upgrade().and_then(|mw| {
+ mw.read(cx)
+ .workspace_for_paths(folder_paths, thread_remote_connection, cx)
+ }) {
if let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) {
let panel_shows_archived = panel
.read(cx)
@@ -4552,10 +4672,10 @@ impl Sidebar {
// No neighbor or its workspace isn't open — just clear the
// panel so the group is left empty.
if let Some(folder_paths) = thread_folder_paths {
- let workspace = self
- .multi_workspace
- .upgrade()
- .and_then(|mw| mw.read(cx).workspace_for_paths(folder_paths, None, cx));
+ let workspace = self.multi_workspace.upgrade().and_then(|mw| {
+ mw.read(cx)
+ .workspace_for_paths(folder_paths, thread_remote_connection, cx)
+ });
if let Some(workspace) = workspace {
if let Some(panel) = workspace.read(cx).panel::<AgentPanel>(cx) {
panel.update(cx, |panel, cx| {
@@ -4576,6 +4696,8 @@ impl Sidebar {
return None;
}
+ self.delete_empty_drafts_for_archive_roots(&roots, cx);
+
let (cancel_tx, cancel_rx) = async_channel::bounded::<()>(1);
let task = cx.spawn(async move |_this, cx| {
match Self::archive_worktree_roots(roots, cancel_rx, cx).await {
@@ -4610,6 +4732,8 @@ impl Sidebar {
return;
}
+ self.delete_empty_drafts_for_archive_roots(&roots, cx);
+
let (cancel_tx, cancel_rx) = async_channel::bounded::<()>(1);
cx.spawn(async move |_this, cx| {
let outcome = Self::archive_worktree_roots(roots, cancel_rx, cx).await;
@@ -4617,7 +4741,7 @@ impl Sidebar {
match outcome {
Ok(ArchiveWorktreeOutcome::Success | ArchiveWorktreeOutcome::Cancelled) => {}
Err(error) => {
- log::error!("Failed to archive worktree after closing terminal: {error:#}");
+ log::error!("Failed to archive worktree after closing sidebar item: {error:#}");
}
}
})
@@ -4706,11 +4830,9 @@ impl Sidebar {
AgentThreadStatus::Completed | AgentThreadStatus::Error => {}
}
if thread.is_draft {
- if let ThreadEntryWorkspace::Open(workspace) = &thread.workspace {
- let workspace = workspace.clone();
- let draft_id = thread.metadata.thread_id;
- self.remove_draft(draft_id, &workspace, window, cx);
- }
+ let workspace = thread.workspace.clone();
+ let draft_id = thread.metadata.thread_id;
+ self.remove_draft(draft_id, &workspace, window, cx);
} else if let Some(session_id) = thread.metadata.session_id.clone() {
self.archive_thread(&session_id, window, cx);
}
@@ -5263,9 +5385,12 @@ impl Sidebar {
.on_click({
let thread_workspace = thread_workspace.clone();
cx.listener(move |this, _, window, cx| {
- if let ThreadEntryWorkspace::Open(workspace) = &thread_workspace {
- this.remove_draft(thread_id_for_actions, workspace, window, cx);
- }
+ this.remove_draft(
+ thread_id_for_actions,
+ &thread_workspace,
+ window,
+ cx,
+ );
})
}),
)
@@ -5460,30 +5585,301 @@ impl Sidebar {
}
}
- /// Deletes a parked draft thread (its metadata row, any kvp-stored
- /// draft prompt) and promotes a sibling in the same group, if any, to
- /// the active entry.
+ /// Closed linked-worktree drafts need an open workspace so archive root
+ /// planning can inspect repositories before deleting the worktree.
+ fn open_workspace_and_remove_draft(
+ &mut self,
+ draft_id: ThreadId,
+ folder_paths: PathList,
+ project_group_key: ProjectGroupKey,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ let Some((open_task, modal_workspace)) =
+ self.open_workspace_for_archive(folder_paths, project_group_key, window, cx)
+ else {
+ return;
+ };
+
+ cx.spawn_in(window, async move |this, cx| {
+ let result = open_task.await;
+ remote_connection::dismiss_connection_modal(&modal_workspace, cx);
+ let workspace = result?;
+ Self::wait_for_archive_workspace_metadata(&workspace, cx).await;
+
+ this.update_in(cx, |this, window, cx| {
+ let workspace = ThreadEntryWorkspace::Open(workspace);
+ this.remove_draft(draft_id, &workspace, window, cx);
+ })?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ }
+
fn remove_draft(
&mut self,
draft_id: ThreadId,
- workspace: &Entity<Workspace>,
+ workspace: &ThreadEntryWorkspace,
window: &mut Window,
cx: &mut Context<Self>,
) {
- workspace.update(cx, |ws, cx| {
- if let Some(panel) = ws.panel::<AgentPanel>(cx) {
- panel.update(cx, |panel, cx| {
- panel.remove_thread(draft_id, window, cx);
- });
- }
- });
+ let metadata = ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(draft_id)
+ .cloned();
+
+ if let ThreadEntryWorkspace::Closed {
+ folder_paths,
+ project_group_key,
+ } = workspace
+ && self.should_load_closed_workspace_for_archive(
+ folder_paths,
+ project_group_key,
+ metadata
+ .as_ref()
+ .and_then(|metadata| metadata.remote_connection.as_ref()),
+ Some(draft_id),
+ None,
+ cx,
+ )
+ {
+ self.open_workspace_and_remove_draft(
+ draft_id,
+ folder_paths.clone(),
+ project_group_key.clone(),
+ window,
+ cx,
+ );
+ return;
+ }
+
+ let draft_folder_paths = metadata
+ .as_ref()
+ .map(|metadata| metadata.folder_paths().clone())
+ .or_else(|| match workspace {
+ ThreadEntryWorkspace::Open(workspace) => {
+ Some(PathList::new(&workspace.read(cx).root_paths(cx)))
+ }
+ ThreadEntryWorkspace::Closed { folder_paths, .. } => Some(folder_paths.clone()),
+ });
+ let draft_remote_connection = metadata
+ .as_ref()
+ .and_then(|metadata| metadata.remote_connection.clone());
+ let roots_to_archive = metadata
+ .as_ref()
+ .map(|metadata| {
+ self.roots_to_archive_for_paths(
+ metadata.folder_paths(),
+ metadata.remote_connection.as_ref(),
+ Some(draft_id),
+ None,
+ cx,
+ )
+ })
+ .unwrap_or_default();
let was_active = self
.active_entry
.as_ref()
- .is_some_and(|e| e.is_active_thread(&draft_id));
+ .is_some_and(|entry| entry.is_active_thread(&draft_id));
+ let neighbor = self
+ .contents
+ .entries
+ .iter()
+ .position(|entry| {
+ matches!(
+ entry,
+ ListEntry::Thread(thread) if thread.metadata.thread_id == draft_id
+ )
+ })
+ .and_then(|position| self.neighboring_activatable_entry(position));
+
+ let workspace_to_remove = draft_folder_paths.as_ref().and_then(|folder_paths| {
+ self.linked_worktree_workspace_to_remove(
+ folder_paths,
+ draft_remote_connection.as_ref(),
+ Some(draft_id),
+ None,
+ &roots_to_archive,
+ cx,
+ )
+ });
+ let mut workspaces_to_remove: Vec<Entity<Workspace>> =
+ workspace_to_remove.into_iter().collect();
+ let close_item_tasks = self.close_items_for_archived_worktrees(
+ &roots_to_archive,
+ &mut workspaces_to_remove,
+ window,
+ cx,
+ );
+
+ if !workspaces_to_remove.is_empty() {
+ let Some(multi_workspace) = self.multi_workspace.upgrade() else {
+ return;
+ };
+ let draft_workspace_removed = matches!(
+ workspace,
+ ThreadEntryWorkspace::Open(workspace) if workspaces_to_remove.contains(workspace)
+ );
+ let (fallback_paths, project_group_key) = neighbor
+ .as_ref()
+ .map(|neighbor| neighbor.project_location(cx))
+ .unwrap_or_else(|| {
+ workspaces_to_remove
+ .first()
+ .map(|workspace| {
+ let key = workspace.read(cx).project_group_key(cx);
+ (key.path_list().clone(), key)
+ })
+ .unwrap_or_default()
+ });
+
+ let excluded = workspaces_to_remove.clone();
+ let remove_task = multi_workspace.update(cx, |multi_workspace, cx| {
+ multi_workspace.remove(
+ workspaces_to_remove,
+ move |this, window, cx| {
+ let active_workspace = this.workspace().clone();
+ this.find_or_create_workspace(
+ fallback_paths,
+ project_group_key.host(),
+ Some(project_group_key),
+ |options, window, cx| {
+ connect_remote(active_workspace, options, window, cx)
+ },
+ &excluded,
+ None,
+ OpenMode::Activate,
+ window,
+ cx,
+ )
+ },
+ window,
+ cx,
+ )
+ });
+
+ let workspace = workspace.clone();
+ cx.spawn_in(window, async move |this, cx| {
+ if !remove_task.await? {
+ return anyhow::Ok(());
+ }
+
+ for task in close_item_tasks {
+ let result: anyhow::Result<()> = task.await;
+ result.log_err();
+ }
+
+ this.update_in(cx, |this, window, cx| {
+ if draft_workspace_removed {
+ if let Some(draft_folder_paths) = draft_folder_paths.as_ref() {
+ this.delete_empty_drafts_for_archive_paths(
+ draft_folder_paths,
+ draft_remote_connection.as_ref(),
+ cx,
+ );
+ }
+ }
+ this.remove_draft_entry(
+ draft_id,
+ &workspace,
+ was_active,
+ neighbor.as_ref(),
+ !draft_workspace_removed,
+ roots_to_archive,
+ window,
+ cx,
+ );
+ })?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ } else if !close_item_tasks.is_empty() {
+ let workspace = workspace.clone();
+ cx.spawn_in(window, async move |this, cx| {
+ for task in close_item_tasks {
+ let result: anyhow::Result<()> = task.await;
+ result.log_err();
+ }
+
+ this.update_in(cx, |this, window, cx| {
+ this.remove_draft_entry(
+ draft_id,
+ &workspace,
+ was_active,
+ neighbor.as_ref(),
+ true,
+ roots_to_archive,
+ window,
+ cx,
+ );
+ })?;
+ anyhow::Ok(())
+ })
+ .detach_and_log_err(cx);
+ } else {
+ self.remove_draft_entry(
+ draft_id,
+ workspace,
+ was_active,
+ neighbor.as_ref(),
+ true,
+ roots_to_archive,
+ window,
+ cx,
+ );
+ }
+ }
+
+ fn remove_draft_entry(
+ &mut self,
+ draft_id: ThreadId,
+ workspace: &ThreadEntryWorkspace,
+ was_active: bool,
+ neighbor: Option<&ActivatableEntry>,
+ activate_panel_draft: bool,
+ roots_to_archive: Vec<thread_worktree_archive::RootPlan>,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ let removed_from_panel = if let ThreadEntryWorkspace::Open(workspace) = workspace {
+ workspace.update(cx, |workspace, cx| {
+ if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
+ panel.update(cx, |panel, cx| {
+ if activate_panel_draft {
+ panel.remove_thread(draft_id, window, cx);
+ } else {
+ panel.remove_thread_without_activating_draft(draft_id, window, cx);
+ }
+ });
+ true
+ } else {
+ false
+ }
+ })
+ } else {
+ false
+ };
+
+ if !removed_from_panel {
+ ThreadMetadataStore::global(cx).update(cx, |store, cx| {
+ store.delete(draft_id, cx);
+ });
+ }
+
+ self.start_detached_archive_worktree_task(roots_to_archive, cx);
+
if was_active {
self.active_entry = None;
+ if !activate_panel_draft {
+ if neighbor
+ .as_ref()
+ .is_some_and(|neighbor| self.activate_entry(neighbor, window, cx))
+ {
+ return;
+ }
+ self.sync_active_entry_from_active_workspace(cx);
+ }
}
self.update_entries(cx);
diff --git a/crates/sidebar/src/sidebar_tests.rs b/crates/sidebar/src/sidebar_tests.rs
index 982f0c6cd24..c65eda086ab 100644
--- a/crates/sidebar/src/sidebar_tests.rs
+++ b/crates/sidebar/src/sidebar_tests.rs
@@ -454,6 +454,34 @@ fn save_thread_metadata_with_main_paths(
cx.run_until_parked();
}
+fn save_draft_metadata_with_main_paths(
+ title: Option<SharedString>,
+ folder_paths: PathList,
+ main_worktree_paths: PathList,
+ updated_at: DateTime<Utc>,
+ cx: &mut TestAppContext,
+) -> ThreadId {
+ let thread_id = ThreadId::new();
+ let metadata = ThreadMetadata {
+ thread_id,
+ session_id: None,
+ agent_id: agent::ZED_AGENT_ID.clone(),
+ title,
+ title_override: None,
+ updated_at,
+ created_at: None,
+ interacted_at: None,
+ worktree_paths: WorktreePaths::from_path_lists(main_worktree_paths, folder_paths).unwrap(),
+ archived: false,
+ remote_connection: None,
+ };
+ cx.update(|cx| {
+ ThreadMetadataStore::global(cx).update(cx, |store, cx| store.save(metadata, cx));
+ });
+ cx.run_until_parked();
+ thread_id
+}
+
fn focus_sidebar(sidebar: &Entity<Sidebar>, cx: &mut gpui::VisualTestContext) {
sidebar.update_in(cx, |_, window, cx| {
cx.focus_self(window);
@@ -1884,6 +1912,8 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
});
let worktree_panel = add_agent_panel(&worktree_workspace, cx);
+ let worktree_folder_paths =
+ PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
let archived_session_id = acp::SessionId::new(Arc::from("archived-wt-thread"));
save_thread_metadata(
@@ -1916,6 +1946,19 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
&main_project,
cx,
);
+ let empty_draft_id = save_draft_metadata_with_main_paths(
+ None,
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
+ cx.update(|_, cx| {
+ assert!(
+ agent_ui::draft_prompt_store::read(empty_draft_id, cx).is_none(),
+ "empty draft should not have persisted prompt content"
+ );
+ });
let terminal_id = worktree_panel
.update_in(cx, |panel, window, cx| {
@@ -1956,12 +1999,20 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
terminal_metadata_deleted,
"terminal metadata should be deleted after close"
);
+ let empty_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(empty_draft_id)
+ .is_none()
+ });
+ assert!(
+ empty_draft_metadata_deleted,
+ "empty draft metadata should be deleted before archiving the linked worktree"
+ );
let unarchived_worktree_threads = cx.update(|_, cx| {
- let worktree_path_list =
- PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
ThreadMetadataStore::global(cx)
.read(cx)
- .entries_for_path(&worktree_path_list, None)
+ .entries_for_path(&worktree_folder_paths, None)
.count()
});
assert_eq!(
@@ -1988,96 +2039,762 @@ async fn test_terminal_close_event_on_archived_linked_worktree_removes_workspace
}
#[gpui::test]
-async fn test_terminal_close_event_closes_sidebar_terminal(cx: &mut TestAppContext) {
- let project = init_test_project_with_agent_panel("/my-project", cx).await;
+async fn test_terminal_close_event_deletes_empty_draft_when_linked_worktree_has_no_archive_root(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/project",
+ serde_json::json!({
+ ".git": {},
+ "src": {},
+ }),
+ )
+ .await;
+ fs.set_branch_name(Path::new("/project/.git"), Some("main"));
+ fs.insert_branches(Path::new("/project/.git"), &["main", "feature-a"]);
+ fs.add_linked_worktree_for_repo(
+ Path::new("/project/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/external-worktree"),
+ ref_name: Some("refs/heads/feature-a".into()),
+ sha: "aaa".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .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;
+ let worktree_project =
+ project::Project::test(fs.clone(), ["/external-worktree".as_ref()], cx).await;
+
+ main_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ worktree_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+
let (multi_workspace, cx) =
- cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
- let (sidebar, panel) = setup_sidebar_with_agent_panel(&multi_workspace, cx);
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+ let _sidebar = setup_sidebar(&multi_workspace, cx);
+ let worktree_workspace = multi_workspace.update_in(cx, |multi_workspace, window, cx| {
+ multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
+ });
+ let worktree_panel = add_agent_panel(&worktree_workspace, cx);
- let terminal_id = panel
+ save_thread_metadata(
+ acp::SessionId::new(Arc::from("main-thread")),
+ Some("Main Thread".into()),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ None,
+ None,
+ &main_project,
+ cx,
+ );
+
+ let worktree_folder_paths = PathList::new(&[PathBuf::from("/external-worktree")]);
+ let empty_draft_id = save_draft_metadata_with_main_paths(
+ None,
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
+
+ let terminal_id = worktree_panel
.update_in(cx, |panel, window, cx| {
panel.insert_test_terminal("Dev Server", true, window, cx)
})
.expect("test terminal should be inserted");
cx.run_until_parked();
- assert_eq!(
- visible_entries_as_strings(&sidebar, cx),
- vec!["v [my-project]", " Dev Server"]
- );
-
- panel.update(cx, |panel, cx| {
+ worktree_panel.update(cx, |panel, cx| {
panel.emit_test_terminal_close(terminal_id, cx);
});
- cx.run_until_parked();
+ for _ in 0..4 {
+ cx.run_until_parked();
+ }
- panel.read_with(cx, |panel, _cx| {
- assert!(!panel.has_terminal(terminal_id));
- });
- sidebar.read_with(cx, |sidebar, _cx| {
- assert!(sidebar.contents.entries.iter().all(|entry| {
- !matches!(entry, ListEntry::Terminal(terminal) if terminal.metadata.terminal_id == terminal_id)
- }));
- });
- sidebar.read_with(cx, |_sidebar, cx| {
- assert!(
- TerminalThreadMetadataStore::global(cx)
- .read(cx)
- .entry(terminal_id)
- .is_none(),
- "terminal metadata should be deleted when the terminal requests close"
- );
+ let empty_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(empty_draft_id)
+ .is_none()
});
+ assert!(
+ empty_draft_metadata_deleted,
+ "empty draft metadata should be deleted when removing the linked worktree workspace"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_none(),
+ "linked worktree workspace should be removed after closing its last terminal"
+ );
+ assert!(
+ fs.is_dir(Path::new("/external-worktree")).await,
+ "external linked worktree directory should remain on disk when no archive root is produced"
+ );
}
#[gpui::test]
-async fn test_agent_panel_terminal_notifications_update_sidebar(cx: &mut TestAppContext) {
- let project = init_test_project_with_agent_panel("/my-project", cx).await;
- let (multi_workspace, cx) =
- cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
- let (sidebar, panel) = setup_sidebar_with_agent_panel(&multi_workspace, cx);
+async fn test_terminal_close_event_keeps_linked_worktree_workspace_with_live_editor_draft(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
- let build_terminal_id = panel
- .update_in(cx, |panel, window, cx| {
- panel.insert_test_terminal("Build", true, window, cx)
- })
- .expect("build test terminal should be inserted");
- let server_terminal_id = panel
- .update_in(cx, |panel, window, cx| {
- panel.insert_test_terminal("Server", true, window, cx)
- })
- .expect("server test terminal should be inserted");
- cx.run_until_parked();
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/project",
+ serde_json::json!({
+ ".git": {
+ "worktrees": {
+ "feature-a": {
+ "commondir": "../../",
+ "HEAD": "ref: refs/heads/feature-a",
+ },
+ },
+ },
+ "src": {},
+ }),
+ )
+ .await;
+ fs.insert_tree(
+ "/worktrees/project/feature-a/project",
+ serde_json::json!({
+ ".git": "gitdir: /project/.git/worktrees/feature-a",
+ "src": {},
+ }),
+ )
+ .await;
+ fs.add_linked_worktree_for_repo(
+ Path::new("/project/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/worktrees/project/feature-a/project"),
+ ref_name: Some("refs/heads/feature-a".into()),
+ sha: "aaa".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .await;
+ cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
- panel.read_with(cx, |panel, _cx| {
- assert_eq!(panel.active_terminal_id(), Some(server_terminal_id));
- });
+ let main_project = project::Project::test(fs.clone(), ["/project".as_ref()], cx).await;
+ let worktree_project = project::Project::test(
+ fs.clone(),
+ ["/worktrees/project/feature-a/project".as_ref()],
+ cx,
+ )
+ .await;
- panel.update(cx, |panel, cx| {
- panel.emit_test_terminal_bell(build_terminal_id, cx);
- });
- cx.run_until_parked();
+ main_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ worktree_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
- sidebar.read_with(cx, |sidebar, cx| {
- assert!(sidebar.has_notifications(cx));
- assert!(sidebar.contents.notified_terminals.contains(&build_terminal_id));
- assert!(sidebar.contents.entries.iter().any(|entry| {
- matches!(entry, ListEntry::Terminal(terminal) if terminal.metadata.terminal_id == build_terminal_id && terminal.has_notification)
- }));
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+ let _sidebar = setup_sidebar(&multi_workspace, cx);
+ let worktree_workspace = multi_workspace.update_in(cx, |multi_workspace, window, cx| {
+ multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
});
+ let worktree_panel = add_agent_panel(&worktree_workspace, cx);
- panel.update_in(cx, |panel, window, cx| {
- panel.activate_terminal(build_terminal_id, true, window, cx);
- });
- cx.run_until_parked();
+ save_thread_metadata(
+ acp::SessionId::new(Arc::from("main-thread")),
+ Some("Main Thread".into()),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ None,
+ None,
+ &main_project,
+ cx,
+ );
- sidebar.read_with(cx, |sidebar, cx| {
- assert!(!sidebar.has_notifications(cx));
- assert!(
- !sidebar
- .contents
- .notified_terminals
- .contains(&build_terminal_id)
+ let worktree_folder_paths =
+ PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+ let draft_id = save_draft_metadata_with_main_paths(
+ Some("Worktree Draft".into()),
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
+
+ worktree_panel.update_in(cx, |panel, window, cx| {
+ panel.load_agent_thread(
+ Agent::Stub,
+ draft_id,
+ Some(worktree_folder_paths.clone()),
+ None,
+ false,
+ AgentThreadSource::AgentPanel,
+ window,
+ cx,
+ );
+ });
+ cx.run_until_parked();
+ let editor_text =
+ worktree_panel.read_with(cx, |panel, cx| panel.editor_text_if_in_memory(draft_id, cx));
+ assert_eq!(
+ editor_text,
+ Some(None),
+ "draft should be in memory with empty editor text before editing"
+ );
+
+ let message_editor = worktree_panel.read_with(cx, |panel, cx| {
+ panel
+ .active_thread_view(cx)
+ .expect("draft should be loaded in the agent panel")
+ .read(cx)
+ .message_editor
+ .clone()
+ });
+ message_editor.update_in(cx, |editor, window, cx| {
+ editor.set_text("keep this draft", window, cx);
+ });
+
+ let terminal_id = worktree_panel
+ .update_in(cx, |panel, window, cx| {
+ panel.insert_test_terminal("Dev Server", true, window, cx)
+ })
+ .expect("test terminal should be inserted");
+ cx.run_until_parked();
+ let live_blocks = worktree_panel.read_with(cx, |panel, cx| {
+ panel.draft_prompt_blocks_if_in_memory(draft_id, cx)
+ });
+ assert!(
+ matches!(
+ live_blocks.as_deref(),
+ Some([acp::ContentBlock::Text(text)]) if text.text == "keep this draft"
+ ),
+ "edited draft should still be readable from the panel after opening the terminal"
+ );
+
+ assert_eq!(
+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+ .workspaces()
+ .count()),
+ 2,
+ "should start with main and linked worktree workspaces"
+ );
+
+ worktree_panel.update(cx, |panel, cx| {
+ panel.emit_test_terminal_close(terminal_id, cx);
+ });
+ for _ in 0..4 {
+ cx.run_until_parked();
+ }
+
+ let terminal_metadata_deleted = cx.update(|_, cx| {
+ TerminalThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(terminal_id)
+ .is_none()
+ });
+ assert!(
+ terminal_metadata_deleted,
+ "terminal metadata should be deleted after close"
+ );
+ let unarchived_worktree_threads = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entries_for_path(&worktree_folder_paths, None)
+ .count()
+ });
+ assert_eq!(
+ unarchived_worktree_threads, 1,
+ "edited draft should remain as a worktree thread reference"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_some(),
+ "linked worktree workspace should stay open while an edited draft references it"
+ );
+ assert!(
+ fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+ .await,
+ "linked worktree directory should remain on disk while an edited draft references it"
+ );
+}
+
+#[gpui::test]
+async fn test_archive_selected_draft_archives_linked_worktree_after_last_draft(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/project",
+ serde_json::json!({
+ ".git": {
+ "worktrees": {
+ "feature-a": {
+ "commondir": "../../",
+ "HEAD": "ref: refs/heads/feature-a",
+ },
+ },
+ },
+ "src": {},
+ }),
+ )
+ .await;
+ fs.insert_tree(
+ "/worktrees/project/feature-a/project",
+ serde_json::json!({
+ ".git": "gitdir: /project/.git/worktrees/feature-a",
+ "src": {},
+ }),
+ )
+ .await;
+ fs.add_linked_worktree_for_repo(
+ Path::new("/project/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/worktrees/project/feature-a/project"),
+ ref_name: Some("refs/heads/feature-a".into()),
+ sha: "aaa".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .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;
+ let worktree_project = project::Project::test(
+ fs.clone(),
+ ["/worktrees/project/feature-a/project".as_ref()],
+ cx,
+ )
+ .await;
+
+ main_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ worktree_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+ let sidebar = setup_sidebar(&multi_workspace, cx);
+ let worktree_workspace = multi_workspace.update_in(cx, |multi_workspace, window, cx| {
+ multi_workspace.test_add_workspace(worktree_project.clone(), window, cx)
+ });
+ add_agent_panel(&worktree_workspace, cx);
+
+ save_thread_metadata(
+ acp::SessionId::new(Arc::from("main-thread")),
+ Some("Main Thread".into()),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ None,
+ None,
+ &main_project,
+ cx,
+ );
+
+ let worktree_folder_paths =
+ PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+ let first_draft_id = save_draft_metadata_with_main_paths(
+ Some("First Draft".into()),
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
+ let second_draft_id = save_draft_metadata_with_main_paths(
+ Some("Second Draft".into()),
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 4, 0, 0, 0).unwrap(),
+ cx,
+ );
+ cx.update(|_, cx| {
+ agent_ui::draft_prompt_store::write(
+ first_draft_id,
+ &[acp::ContentBlock::Text(acp::TextContent::new(
+ "first draft",
+ ))],
+ cx,
+ )
+ })
+ .await
+ .expect("first draft prompt should persist");
+ cx.update(|_, cx| {
+ agent_ui::draft_prompt_store::write(
+ second_draft_id,
+ &[acp::ContentBlock::Text(acp::TextContent::new(
+ "second draft",
+ ))],
+ cx,
+ )
+ })
+ .await
+ .expect("second draft prompt should persist");
+ sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+ cx.run_until_parked();
+
+ let first_draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+ sidebar
+ .contents
+ .entries
+ .iter()
+ .position(|entry| {
+ matches!(
+ entry,
+ ListEntry::Thread(thread) if thread.metadata.thread_id == first_draft_id
+ )
+ })
+ .expect("first draft should be visible in sidebar")
+ });
+ focus_sidebar(&sidebar, cx);
+ sidebar.update_in(cx, |sidebar, _window, _cx| {
+ sidebar.selection = Some(first_draft_index);
+ });
+ cx.dispatch_action(ArchiveSelectedThread);
+ for _ in 0..4 {
+ cx.run_until_parked();
+ }
+
+ let first_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(first_draft_id)
+ .is_none()
+ });
+ assert!(
+ first_draft_metadata_deleted,
+ "first discarded draft metadata should be deleted"
+ );
+ let second_draft_metadata_kept = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(second_draft_id)
+ .is_some()
+ });
+ assert!(
+ second_draft_metadata_kept,
+ "remaining contentful draft should still block worktree archival"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_some(),
+ "linked worktree workspace should remain while another draft references it"
+ );
+ assert!(
+ fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+ .await,
+ "linked worktree directory should remain while another draft references it"
+ );
+
+ let second_draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+ sidebar
+ .contents
+ .entries
+ .iter()
+ .position(|entry| {
+ matches!(
+ entry,
+ ListEntry::Thread(thread) if thread.metadata.thread_id == second_draft_id
+ )
+ })
+ .expect("second draft should be visible in sidebar")
+ });
+ sidebar.update_in(cx, |sidebar, _window, _cx| {
+ sidebar.selection = Some(second_draft_index);
+ });
+ cx.dispatch_action(ArchiveSelectedThread);
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
+
+ let second_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(second_draft_id)
+ .is_none()
+ });
+ assert!(
+ second_draft_metadata_deleted,
+ "last discarded draft metadata should be deleted"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_none(),
+ "linked worktree workspace should be removed after closing its last draft"
+ );
+ assert!(
+ !fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+ .await,
+ "linked worktree directory should be removed from disk after closing its last draft"
+ );
+}
+
+#[gpui::test]
+async fn test_archive_selected_draft_archives_closed_linked_worktree(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/project",
+ serde_json::json!({
+ ".git": {
+ "worktrees": {
+ "feature-a": {
+ "commondir": "../../",
+ "HEAD": "ref: refs/heads/feature-a",
+ },
+ },
+ },
+ "src": {},
+ }),
+ )
+ .await;
+ fs.insert_tree(
+ "/worktrees/project/feature-a/project",
+ serde_json::json!({
+ ".git": "gitdir: /project/.git/worktrees/feature-a",
+ "src": {},
+ }),
+ )
+ .await;
+ fs.add_linked_worktree_for_repo(
+ Path::new("/project/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/worktrees/project/feature-a/project"),
+ ref_name: Some("refs/heads/feature-a".into()),
+ sha: "aaa".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .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;
+ main_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+ let sidebar = setup_sidebar(&multi_workspace, cx);
+
+ save_thread_metadata(
+ acp::SessionId::new(Arc::from("main-thread")),
+ Some("Main Thread".into()),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ None,
+ None,
+ &main_project,
+ cx,
+ );
+
+ let worktree_folder_paths =
+ PathList::new(&[PathBuf::from("/worktrees/project/feature-a/project")]);
+ let draft_id = save_draft_metadata_with_main_paths(
+ Some("Closed Worktree Draft".into()),
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
+ cx.update(|_, cx| {
+ agent_ui::draft_prompt_store::write(
+ draft_id,
+ &[acp::ContentBlock::Text(acp::TextContent::new(
+ "closed draft",
+ ))],
+ cx,
+ )
+ })
+ .await
+ .expect("draft prompt should persist");
+ sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+ cx.run_until_parked();
+
+ let draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+ sidebar
+ .contents
+ .entries
+ .iter()
+ .position(|entry| {
+ matches!(
+ entry,
+ ListEntry::Thread(thread) if thread.metadata.thread_id == draft_id
+ )
+ })
+ .expect("closed worktree draft should be visible in sidebar")
+ });
+ sidebar.read_with(cx, |sidebar, _cx| {
+ match &sidebar.contents.entries[draft_index] {
+ ListEntry::Thread(thread) => match &thread.workspace {
+ ThreadEntryWorkspace::Closed { folder_paths, .. } => {
+ assert_eq!(folder_paths, &worktree_folder_paths);
+ }
+ ThreadEntryWorkspace::Open(_) => {
+ panic!("linked worktree draft should start closed")
+ }
+ },
+ _ => panic!("expected draft row"),
+ }
+ });
+
+ focus_sidebar(&sidebar, cx);
+ sidebar.update_in(cx, |sidebar, _window, _cx| {
+ sidebar.selection = Some(draft_index);
+ });
+ cx.dispatch_action(ArchiveSelectedThread);
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
+
+ let draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(draft_id)
+ .is_none()
+ });
+ assert!(
+ draft_metadata_deleted,
+ "discarded closed worktree draft metadata should be deleted"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_none(),
+ "temporary linked worktree workspace should be removed after discarding its last draft"
+ );
+ assert_eq!(
+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+ .workspaces()
+ .count()),
+ 1,
+ "discarding a closed linked worktree draft should leave only the main workspace"
+ );
+ assert!(
+ !fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+ .await,
+ "linked worktree directory should be removed from disk after discarding its last draft"
+ );
+}
+
+#[gpui::test]
+async fn test_terminal_close_event_closes_sidebar_terminal(cx: &mut TestAppContext) {
+ let project = init_test_project_with_agent_panel("/my-project", cx).await;
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let (sidebar, panel) = setup_sidebar_with_agent_panel(&multi_workspace, cx);
+
+ let terminal_id = panel
+ .update_in(cx, |panel, window, cx| {
+ panel.insert_test_terminal("Dev Server", true, window, cx)
+ })
+ .expect("test terminal should be inserted");
+ cx.run_until_parked();
+
+ assert_eq!(
+ visible_entries_as_strings(&sidebar, cx),
+ vec!["v [my-project]", " Dev Server"]
+ );
+
+ panel.update(cx, |panel, cx| {
+ panel.emit_test_terminal_close(terminal_id, cx);
+ });
+ cx.run_until_parked();
+
+ panel.read_with(cx, |panel, _cx| {
+ assert!(!panel.has_terminal(terminal_id));
+ });
+ sidebar.read_with(cx, |sidebar, _cx| {
+ assert!(sidebar.contents.entries.iter().all(|entry| {
+ !matches!(entry, ListEntry::Terminal(terminal) if terminal.metadata.terminal_id == terminal_id)
+ }));
+ });
+ sidebar.read_with(cx, |_sidebar, cx| {
+ assert!(
+ TerminalThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(terminal_id)
+ .is_none(),
+ "terminal metadata should be deleted when the terminal requests close"
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_agent_panel_terminal_notifications_update_sidebar(cx: &mut TestAppContext) {
+ let project = init_test_project_with_agent_panel("/my-project", cx).await;
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
+ let (sidebar, panel) = setup_sidebar_with_agent_panel(&multi_workspace, cx);
+
+ let build_terminal_id = panel
+ .update_in(cx, |panel, window, cx| {
+ panel.insert_test_terminal("Build", true, window, cx)
+ })
+ .expect("build test terminal should be inserted");
+ let server_terminal_id = panel
+ .update_in(cx, |panel, window, cx| {
+ panel.insert_test_terminal("Server", true, window, cx)
+ })
+ .expect("server test terminal should be inserted");
+ cx.run_until_parked();
+
+ panel.read_with(cx, |panel, _cx| {
+ assert_eq!(panel.active_terminal_id(), Some(server_terminal_id));
+ });
+
+ panel.update(cx, |panel, cx| {
+ panel.emit_test_terminal_bell(build_terminal_id, cx);
+ });
+ cx.run_until_parked();
+
+ sidebar.read_with(cx, |sidebar, cx| {
+ assert!(sidebar.has_notifications(cx));
+ assert!(sidebar.contents.notified_terminals.contains(&build_terminal_id));
+ assert!(sidebar.contents.entries.iter().any(|entry| {
+ matches!(entry, ListEntry::Terminal(terminal) if terminal.metadata.terminal_id == build_terminal_id && terminal.has_notification)
+ }));
+ });
+
+ panel.update_in(cx, |panel, window, cx| {
+ panel.activate_terminal(build_terminal_id, true, window, cx);
+ });
+ cx.run_until_parked();
+
+ sidebar.read_with(cx, |sidebar, cx| {
+ assert!(!sidebar.has_notifications(cx));
+ assert!(
+ !sidebar
+ .contents
+ .notified_terminals
+ .contains(&build_terminal_id)
);
});
}
@@ -2459,6 +3176,19 @@ async fn test_archive_selected_terminal_archives_closed_linked_worktree(cx: &mut
store.save(metadata, cx);
});
});
+ let empty_draft_id = save_draft_metadata_with_main_paths(
+ None,
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ cx,
+ );
+ cx.update(|_, cx| {
+ assert!(
+ agent_ui::draft_prompt_store::read(empty_draft_id, cx).is_none(),
+ "empty draft should not have persisted prompt content"
+ );
+ });
sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
cx.run_until_parked();
@@ -2503,6 +3233,16 @@ async fn test_archive_selected_terminal_archives_closed_linked_worktree(cx: &mut
terminal_metadata_deleted,
"terminal metadata should be deleted after closing from the sidebar"
);
+ let empty_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(empty_draft_id)
+ .is_none()
+ });
+ assert!(
+ empty_draft_metadata_deleted,
+ "empty draft metadata should be deleted before archiving the linked worktree"
+ );
assert!(
multi_workspace
.read_with(cx, |multi_workspace, cx| {
@@ -2596,6 +3336,162 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
&main_project,
cx,
);
+ let empty_draft_id = save_draft_metadata_with_main_paths(
+ None,
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
+ cx.update(|_, cx| {
+ assert!(
+ agent_ui::draft_prompt_store::read(empty_draft_id, cx).is_none(),
+ "empty draft should not have persisted prompt content"
+ );
+ });
+ sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
+ cx.run_until_parked();
+
+ let thread_index = sidebar.read_with(cx, |sidebar, _cx| {
+ sidebar
+ .contents
+ .entries
+ .iter()
+ .position(|entry| matches!(entry, ListEntry::Thread(thread) if thread.metadata.session_id.as_ref() == Some(&worktree_session_id)))
+ .expect("worktree thread should be visible in sidebar")
+ });
+ sidebar.read_with(cx, |sidebar, _cx| {
+ match &sidebar.contents.entries[thread_index] {
+ ListEntry::Thread(thread) => match &thread.workspace {
+ ThreadEntryWorkspace::Closed { folder_paths, .. } => {
+ assert_eq!(folder_paths, &worktree_folder_paths);
+ }
+ ThreadEntryWorkspace::Open(_) => {
+ panic!("linked worktree thread should start closed")
+ }
+ },
+ _ => panic!("expected thread row"),
+ }
+ });
+
+ focus_sidebar(&sidebar, cx);
+ sidebar.update_in(cx, |sidebar, _window, _cx| {
+ sidebar.selection = Some(thread_index);
+ });
+ cx.dispatch_action(ArchiveSelectedThread);
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
+
+ let thread_archived = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry_by_session(&worktree_session_id)
+ .map(|thread| thread.archived)
+ });
+ assert_eq!(
+ thread_archived,
+ Some(true),
+ "thread metadata should remain archived after worktree archival"
+ );
+ let empty_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(empty_draft_id)
+ .is_none()
+ });
+ assert!(
+ empty_draft_metadata_deleted,
+ "empty draft metadata should be deleted before archiving the linked worktree"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_none(),
+ "temporary linked worktree workspace should be removed after archiving"
+ );
+ assert_eq!(
+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+ .workspaces()
+ .count()),
+ 1,
+ "archiving a closed linked worktree thread should leave only the main workspace"
+ );
+ assert!(
+ !fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
+ .await,
+ "linked worktree directory should be removed from disk after archiving its thread"
+ );
+}
+
+#[gpui::test]
+async fn test_archive_selected_thread_deletes_empty_draft_when_linked_worktree_has_no_archive_root(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/project",
+ serde_json::json!({
+ ".git": {},
+ "src": {},
+ }),
+ )
+ .await;
+ fs.set_branch_name(Path::new("/project/.git"), Some("main"));
+ fs.insert_branches(Path::new("/project/.git"), &["main", "feature-a"]);
+ fs.add_linked_worktree_for_repo(
+ Path::new("/project/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/external-worktree"),
+ ref_name: Some("refs/heads/feature-a".into()),
+ sha: "aaa".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .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;
+ main_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+
+ let (multi_workspace, cx) =
+ cx.add_window_view(|window, cx| MultiWorkspace::test_new(main_project.clone(), window, cx));
+ let sidebar = setup_sidebar(&multi_workspace, cx);
+
+ let worktree_session_id = acp::SessionId::new(Arc::from("external-worktree-thread"));
+ let worktree_folder_paths = PathList::new(&[PathBuf::from("/external-worktree")]);
+ save_thread_metadata_with_main_paths(
+ "external-worktree-thread",
+ "External Worktree Thread",
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
+ cx,
+ );
+ save_thread_metadata(
+ acp::SessionId::new(Arc::from("main-thread")),
+ Some("Main Thread".into()),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ None,
+ None,
+ &main_project,
+ cx,
+ );
+ let empty_draft_id = save_draft_metadata_with_main_paths(
+ None,
+ worktree_folder_paths.clone(),
+ PathList::new(&[PathBuf::from("/project")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 3, 0, 0, 0).unwrap(),
+ cx,
+ );
sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
cx.run_until_parked();
@@ -2607,20 +3503,6 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
.position(|entry| matches!(entry, ListEntry::Thread(thread) if thread.metadata.session_id.as_ref() == Some(&worktree_session_id)))
.expect("worktree thread should be visible in sidebar")
});
- sidebar.read_with(cx, |sidebar, _cx| {
- match &sidebar.contents.entries[thread_index] {
- ListEntry::Thread(thread) => match &thread.workspace {
- ThreadEntryWorkspace::Closed { folder_paths, .. } => {
- assert_eq!(folder_paths, &worktree_folder_paths);
- }
- ThreadEntryWorkspace::Open(_) => {
- panic!("linked worktree thread should start closed")
- }
- },
- _ => panic!("expected thread row"),
- }
- });
-
focus_sidebar(&sidebar, cx);
sidebar.update_in(cx, |sidebar, _window, _cx| {
sidebar.selection = Some(thread_index);
@@ -2639,7 +3521,17 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
assert_eq!(
thread_archived,
Some(true),
- "thread metadata should remain archived after worktree archival"
+ "thread metadata should remain archived after workspace removal"
+ );
+ let empty_draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(empty_draft_id)
+ .is_none()
+ });
+ assert!(
+ empty_draft_metadata_deleted,
+ "empty draft metadata should be deleted when removing the linked worktree workspace"
);
assert!(
multi_workspace
@@ -2647,19 +3539,11 @@ async fn test_archive_selected_thread_archives_closed_linked_worktree(cx: &mut T
multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
})
.is_none(),
- "temporary linked worktree workspace should be removed after archiving"
- );
- assert_eq!(
- multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
- .workspaces()
- .count()),
- 1,
- "archiving a closed linked worktree thread should leave only the main workspace"
+ "linked worktree workspace should be removed after archiving its last thread"
);
assert!(
- !fs.is_dir(Path::new("/worktrees/project/feature-a/project"))
- .await,
- "linked worktree directory should be removed from disk after archiving its thread"
+ fs.is_dir(Path::new("/external-worktree")).await,
+ "external linked worktree directory should remain on disk when no archive root is produced"
);
}
@@ -12250,11 +13134,232 @@ async fn test_archive_removes_worktree_even_when_workspace_paths_diverge(cx: &mu
}
#[gpui::test]
-async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &mut TestAppContext) {
- // When a workspace contains both a worktree being archived and other
- // worktrees that should remain, only the editor items referencing the
- // archived worktree should be closed — the workspace itself must be
- // preserved.
+async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &mut TestAppContext) {
+ // When a workspace contains both a worktree being archived and other
+ // worktrees that should remain, only the editor items referencing the
+ // archived worktree should be closed — the workspace itself must be
+ // preserved.
+ init_test(cx);
+ let fs = FakeFs::new(cx.executor());
+
+ fs.insert_tree(
+ "/main-repo",
+ serde_json::json!({
+ ".git": {
+ "worktrees": {
+ "feature-b": {
+ "commondir": "../../",
+ "HEAD": "ref: refs/heads/feature-b",
+ },
+ },
+ },
+ "src": {
+ "lib.rs": "pub fn hello() {}",
+ },
+ }),
+ )
+ .await;
+
+ fs.insert_tree(
+ "/worktrees/main-repo/feature-b/main-repo",
+ serde_json::json!({
+ ".git": "gitdir: /main-repo/.git/worktrees/feature-b",
+ "src": {
+ "main.rs": "fn main() { hello(); }",
+ },
+ }),
+ )
+ .await;
+
+ fs.add_linked_worktree_for_repo(
+ Path::new("/main-repo/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/worktrees/main-repo/feature-b/main-repo"),
+ ref_name: Some("refs/heads/feature-b".into()),
+ sha: "def".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .await;
+
+ cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+ // Create a single project that contains BOTH the main repo and the
+ // linked worktree — this makes it a "mixed" workspace.
+ let mixed_project = project::Project::test(
+ fs.clone(),
+ [
+ "/main-repo".as_ref(),
+ "/worktrees/main-repo/feature-b/main-repo".as_ref(),
+ ],
+ cx,
+ )
+ .await;
+
+ mixed_project
+ .update(cx, |p, cx| p.git_scans_complete(cx))
+ .await;
+
+ let (multi_workspace, cx) = cx
+ .add_window_view(|window, cx| MultiWorkspace::test_new(mixed_project.clone(), window, cx));
+ let sidebar = setup_sidebar(&multi_workspace, cx);
+
+ // Open editor items in both worktrees so we can verify which ones
+ // get closed.
+ let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
+
+ let worktree_ids: Vec<(WorktreeId, Arc<Path>)> = workspace.read_with(cx, |ws, cx| {
+ ws.project()
+ .read(cx)
+ .visible_worktrees(cx)
+ .map(|wt| (wt.read(cx).id(), wt.read(cx).abs_path()))
+ .collect()
+ });
+
+ let main_repo_wt_id = worktree_ids
+ .iter()
+ .find(|(_, path)| path.as_ref() == Path::new("/main-repo"))
+ .map(|(id, _)| *id)
+ .expect("should find main-repo worktree");
+
+ let feature_b_wt_id = worktree_ids
+ .iter()
+ .find(|(_, path)| path.as_ref() == Path::new("/worktrees/main-repo/feature-b/main-repo"))
+ .map(|(id, _)| *id)
+ .expect("should find feature-b worktree");
+
+ // Open files from both worktrees.
+ let main_repo_path = project::ProjectPath {
+ worktree_id: main_repo_wt_id,
+ path: Arc::from(rel_path("src/lib.rs")),
+ };
+ let feature_b_path = project::ProjectPath {
+ worktree_id: feature_b_wt_id,
+ path: Arc::from(rel_path("src/main.rs")),
+ };
+
+ workspace
+ .update_in(cx, |ws, window, cx| {
+ ws.open_path(main_repo_path.clone(), None, true, window, cx)
+ })
+ .await
+ .expect("should open main-repo file");
+ workspace
+ .update_in(cx, |ws, window, cx| {
+ ws.open_path(feature_b_path.clone(), None, true, window, cx)
+ })
+ .await
+ .expect("should open feature-b file");
+
+ cx.run_until_parked();
+
+ // Verify both items are open.
+ let open_paths_before: Vec<project::ProjectPath> = workspace.read_with(cx, |ws, cx| {
+ ws.panes()
+ .iter()
+ .flat_map(|pane| {
+ pane.read(cx)
+ .items()
+ .filter_map(|item| item.project_path(cx))
+ })
+ .collect()
+ });
+ assert!(
+ open_paths_before
+ .iter()
+ .any(|pp| pp.worktree_id == main_repo_wt_id),
+ "main-repo file should be open"
+ );
+ assert!(
+ open_paths_before
+ .iter()
+ .any(|pp| pp.worktree_id == feature_b_wt_id),
+ "feature-b file should be open"
+ );
+
+ // Save thread metadata for the linked worktree with deliberately
+ // mismatched folder_paths to trigger the scan-based detection.
+ save_thread_metadata_with_main_paths(
+ "feature-b-thread",
+ "Feature B Thread",
+ PathList::new(&[
+ PathBuf::from("/worktrees/main-repo/feature-b/main-repo"),
+ PathBuf::from("/nonexistent"),
+ ]),
+ PathList::new(&[PathBuf::from("/main-repo"), PathBuf::from("/nonexistent")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
+ cx,
+ );
+
+ // Save another thread that references only the main repo (not the
+ // linked worktree) so archiving the feature-b thread's worktree isn't
+ // blocked by another unarchived thread referencing the same path.
+ save_thread_metadata_with_main_paths(
+ "other-thread",
+ "Other Thread",
+ PathList::new(&[PathBuf::from("/main-repo")]),
+ PathList::new(&[PathBuf::from("/main-repo")]),
+ chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
+ cx,
+ );
+ cx.run_until_parked();
+
+ multi_workspace.update_in(cx, |_, _window, cx| cx.notify());
+ cx.run_until_parked();
+
+ // There should still be exactly 1 workspace.
+ assert_eq!(
+ multi_workspace.read_with(cx, |mw, _| mw.workspaces().count()),
+ 1,
+ "should have 1 workspace (the mixed workspace)"
+ );
+
+ // Archive the feature-b thread.
+ let fb_session_id = acp::SessionId::new(Arc::from("feature-b-thread"));
+ sidebar.update_in(cx, |sidebar, window, cx| {
+ sidebar.archive_thread(&fb_session_id, window, cx);
+ });
+
+ cx.run_until_parked();
+
+ // The workspace should still exist (it's "mixed" — has non-archived worktrees).
+ assert_eq!(
+ multi_workspace.read_with(cx, |mw, _| mw.workspaces().count()),
+ 1,
+ "mixed workspace should be preserved"
+ );
+
+ // Only the feature-b editor item should have been closed.
+ let open_paths_after: Vec<project::ProjectPath> = workspace.read_with(cx, |ws, cx| {
+ ws.panes()
+ .iter()
+ .flat_map(|pane| {
+ pane.read(cx)
+ .items()
+ .filter_map(|item| item.project_path(cx))
+ })
+ .collect()
+ });
+ assert!(
+ open_paths_after
+ .iter()
+ .any(|pp| pp.worktree_id == main_repo_wt_id),
+ "main-repo file should still be open"
+ );
+ assert!(
+ !open_paths_after
+ .iter()
+ .any(|pp| pp.worktree_id == feature_b_wt_id),
+ "feature-b file should have been closed"
+ );
+}
+
+#[gpui::test]
+async fn test_discard_mixed_workspace_draft_closes_only_archived_worktree_items(
+ cx: &mut TestAppContext,
+) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
@@ -12302,8 +13407,6 @@ async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &m
cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
- // Create a single project that contains BOTH the main repo and the
- // linked worktree — this makes it a "mixed" workspace.
let mixed_project = project::Project::test(
fs.clone(),
[
@@ -12315,141 +13418,120 @@ async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &m
.await;
mixed_project
- .update(cx, |p, cx| p.git_scans_complete(cx))
+ .update(cx, |project, cx| project.git_scans_complete(cx))
.await;
let (multi_workspace, cx) = cx
.add_window_view(|window, cx| MultiWorkspace::test_new(mixed_project.clone(), window, cx));
let sidebar = setup_sidebar(&multi_workspace, cx);
+ let workspace =
+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
- // Open editor items in both worktrees so we can verify which ones
- // get closed.
- let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
-
- let worktree_ids: Vec<(WorktreeId, Arc<Path>)> = workspace.read_with(cx, |ws, cx| {
- ws.project()
+ let worktree_ids: Vec<(WorktreeId, Arc<Path>)> = workspace.read_with(cx, |workspace, cx| {
+ workspace
+ .project()
.read(cx)
.visible_worktrees(cx)
- .map(|wt| (wt.read(cx).id(), wt.read(cx).abs_path()))
+ .map(|worktree| (worktree.read(cx).id(), worktree.read(cx).abs_path()))
.collect()
});
- let main_repo_wt_id = worktree_ids
+ let main_repo_worktree_id = worktree_ids
.iter()
.find(|(_, path)| path.as_ref() == Path::new("/main-repo"))
.map(|(id, _)| *id)
.expect("should find main-repo worktree");
- let feature_b_wt_id = worktree_ids
+ let feature_b_worktree_id = worktree_ids
.iter()
.find(|(_, path)| path.as_ref() == Path::new("/worktrees/main-repo/feature-b/main-repo"))
.map(|(id, _)| *id)
.expect("should find feature-b worktree");
- // Open files from both worktrees.
let main_repo_path = project::ProjectPath {
- worktree_id: main_repo_wt_id,
+ worktree_id: main_repo_worktree_id,
path: Arc::from(rel_path("src/lib.rs")),
};
let feature_b_path = project::ProjectPath {
- worktree_id: feature_b_wt_id,
+ worktree_id: feature_b_worktree_id,
path: Arc::from(rel_path("src/main.rs")),
};
workspace
- .update_in(cx, |ws, window, cx| {
- ws.open_path(main_repo_path.clone(), None, true, window, cx)
+ .update_in(cx, |workspace, window, cx| {
+ workspace.open_path(main_repo_path.clone(), None, true, window, cx)
})
.await
.expect("should open main-repo file");
workspace
- .update_in(cx, |ws, window, cx| {
- ws.open_path(feature_b_path.clone(), None, true, window, cx)
+ .update_in(cx, |workspace, window, cx| {
+ workspace.open_path(feature_b_path.clone(), None, true, window, cx)
})
.await
.expect("should open feature-b file");
- cx.run_until_parked();
-
- // Verify both items are open.
- let open_paths_before: Vec<project::ProjectPath> = workspace.read_with(cx, |ws, cx| {
- ws.panes()
- .iter()
- .flat_map(|pane| {
- pane.read(cx)
- .items()
- .filter_map(|item| item.project_path(cx))
- })
- .collect()
- });
- assert!(
- open_paths_before
- .iter()
- .any(|pp| pp.worktree_id == main_repo_wt_id),
- "main-repo file should be open"
- );
- assert!(
- open_paths_before
- .iter()
- .any(|pp| pp.worktree_id == feature_b_wt_id),
- "feature-b file should be open"
- );
-
- // Save thread metadata for the linked worktree with deliberately
- // mismatched folder_paths to trigger the scan-based detection.
- save_thread_metadata_with_main_paths(
- "feature-b-thread",
- "Feature B Thread",
- PathList::new(&[
- PathBuf::from("/worktrees/main-repo/feature-b/main-repo"),
- PathBuf::from("/nonexistent"),
- ]),
- PathList::new(&[PathBuf::from("/main-repo"), PathBuf::from("/nonexistent")]),
+ let folder_paths = PathList::new(&[
+ PathBuf::from("/main-repo"),
+ PathBuf::from("/worktrees/main-repo/feature-b/main-repo"),
+ ]);
+ let main_worktree_paths =
+ PathList::new(&[PathBuf::from("/main-repo"), PathBuf::from("/main-repo")]);
+ let draft_id = save_draft_metadata_with_main_paths(
+ Some("Mixed Workspace Draft".into()),
+ folder_paths,
+ main_worktree_paths,
chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
cx,
);
+ cx.update(|_, cx| {
+ agent_ui::draft_prompt_store::write(
+ draft_id,
+ &[acp::ContentBlock::Text(acp::TextContent::new(
+ "mixed workspace draft",
+ ))],
+ cx,
+ )
+ })
+ .await
+ .expect("draft prompt should persist");
- // Save another thread that references only the main repo (not the
- // linked worktree) so archiving the feature-b thread's worktree isn't
- // blocked by another unarchived thread referencing the same path.
- save_thread_metadata_with_main_paths(
- "other-thread",
- "Other Thread",
- PathList::new(&[PathBuf::from("/main-repo")]),
- PathList::new(&[PathBuf::from("/main-repo")]),
- chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 2, 0, 0, 0).unwrap(),
- cx,
- );
- cx.run_until_parked();
-
- multi_workspace.update_in(cx, |_, _window, cx| cx.notify());
+ sidebar.update(cx, |sidebar, cx| sidebar.update_entries(cx));
cx.run_until_parked();
- // There should still be exactly 1 workspace.
- assert_eq!(
- multi_workspace.read_with(cx, |mw, _| mw.workspaces().count()),
- 1,
- "should have 1 workspace (the mixed workspace)"
- );
-
- // Archive the feature-b thread.
- let fb_session_id = acp::SessionId::new(Arc::from("feature-b-thread"));
- sidebar.update_in(cx, |sidebar, window, cx| {
- sidebar.archive_thread(&fb_session_id, window, cx);
+ let draft_index = sidebar.read_with(cx, |sidebar, _cx| {
+ sidebar
+ .contents
+ .entries
+ .iter()
+ .position(|entry| {
+ matches!(
+ entry,
+ ListEntry::Thread(thread) if thread.metadata.thread_id == draft_id
+ )
+ })
+ .expect("mixed workspace draft should be visible")
});
- cx.run_until_parked();
+ focus_sidebar(&sidebar, cx);
+ sidebar.update_in(cx, |sidebar, _window, _cx| {
+ sidebar.selection = Some(draft_index);
+ });
+ cx.dispatch_action(ArchiveSelectedThread);
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
- // The workspace should still exist (it's "mixed" — has non-archived worktrees).
assert_eq!(
- multi_workspace.read_with(cx, |mw, _| mw.workspaces().count()),
+ multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace
+ .workspaces()
+ .count()),
1,
"mixed workspace should be preserved"
);
- // Only the feature-b editor item should have been closed.
- let open_paths_after: Vec<project::ProjectPath> = workspace.read_with(cx, |ws, cx| {
- ws.panes()
+ let open_paths_after: Vec<project::ProjectPath> = workspace.read_with(cx, |workspace, cx| {
+ workspace
+ .panes()
.iter()
.flat_map(|pane| {
pane.read(cx)
@@ -12461,15 +13543,26 @@ async fn test_archive_mixed_workspace_closes_only_archived_worktree_items(cx: &m
assert!(
open_paths_after
.iter()
- .any(|pp| pp.worktree_id == main_repo_wt_id),
+ .any(|project_path| project_path.worktree_id == main_repo_worktree_id),
"main-repo file should still be open"
);
assert!(
!open_paths_after
.iter()
- .any(|pp| pp.worktree_id == feature_b_wt_id),
+ .any(|project_path| project_path.worktree_id == feature_b_worktree_id),
"feature-b file should have been closed"
);
+
+ let draft_metadata_deleted = cx.update(|_, cx| {
+ ThreadMetadataStore::global(cx)
+ .read(cx)
+ .entry(draft_id)
+ .is_none()
+ });
+ assert!(
+ draft_metadata_deleted,
+ "discarded draft metadata should be deleted"
+ );
}
#[test]
@@ -12715,6 +13808,164 @@ async fn test_remote_archive_thread_with_active_connection(
);
}
+#[gpui::test]
+async fn test_remote_linked_worktree_workspace_to_remove_uses_remote_connection(
+ cx: &mut TestAppContext,
+ server_cx: &mut TestAppContext,
+) {
+ init_test(cx);
+
+ cx.update(|cx| {
+ release_channel::init(semver::Version::new(0, 0, 0), cx);
+ });
+ server_cx.update(|cx| {
+ release_channel::init(semver::Version::new(0, 0, 0), cx);
+ });
+
+ let app_state = cx.update(|cx| {
+ let app_state = workspace::AppState::test(cx);
+ workspace::init(app_state.clone(), cx);
+ app_state
+ });
+
+ let server_fs = FakeFs::new(server_cx.executor());
+ server_fs
+ .insert_tree(
+ "/project",
+ serde_json::json!({
+ ".git": {},
+ "src": {},
+ }),
+ )
+ .await;
+ server_fs
+ .insert_tree(
+ "/external-worktree",
+ serde_json::json!({
+ ".git": "gitdir: /project/.git/worktrees/feature-a",
+ "src": {},
+ }),
+ )
+ .await;
+ server_fs.set_branch_name(Path::new("/project/.git"), Some("main"));
+ server_fs.insert_branches(Path::new("/project/.git"), &["main", "feature-a"]);
+ server_fs
+ .add_linked_worktree_for_repo(
+ Path::new("/project/.git"),
+ false,
+ git::repository::Worktree {
+ path: PathBuf::from("/external-worktree"),
+ ref_name: Some("refs/heads/feature-a".into()),
+ sha: "abc".into(),
+ is_main: false,
+ is_bare: false,
+ },
+ )
+ .await;
+
+ let (worktree_project, _headless, remote_connection) = start_remote_project(
+ &server_fs,
+ Path::new("/external-worktree"),
+ &app_state,
+ None,
+ cx,
+ server_cx,
+ )
+ .await;
+ worktree_project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ cx.run_until_parked();
+
+ cx.update(|cx| <dyn fs::Fs>::set_global(app_state.fs.clone(), cx));
+
+ let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
+ MultiWorkspace::test_new(worktree_project.clone(), window, cx)
+ });
+ let sidebar = setup_sidebar(&multi_workspace, cx);
+
+ let worktree_session_id = acp::SessionId::new(Arc::from("remote-worktree-thread"));
+ let worktree_folder_paths = PathList::new(&[PathBuf::from("/external-worktree")]);
+ let main_folder_paths = PathList::new(&[PathBuf::from("/project")]);
+ let worktree_thread_id = ThreadId::new();
+ cx.update(|_window, cx| {
+ let metadata = ThreadMetadata {
+ thread_id: worktree_thread_id,
+ session_id: Some(worktree_session_id.clone()),
+ agent_id: agent::ZED_AGENT_ID.clone(),
+ title: Some("Remote Worktree Thread".into()),
+ title_override: None,
+ updated_at: chrono::TimeZone::with_ymd_and_hms(&Utc, 2024, 1, 1, 0, 0, 0).unwrap(),
+ created_at: None,
+ interacted_at: None,
+ worktree_paths: WorktreePaths::from_path_lists(
+ main_folder_paths,
+ worktree_folder_paths.clone(),
+ )
+ .unwrap(),
+ archived: false,
+ remote_connection: Some(remote_connection.clone()),
+ };
+ ThreadMetadataStore::global(cx).update(cx, |store, cx| store.save(metadata, cx));
+ });
+ cx.run_until_parked();
+
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(
+ &worktree_folder_paths,
+ Some(&remote_connection),
+ cx,
+ )
+ })
+ .is_some(),
+ "remote linked-worktree workspace should be open before archiving"
+ );
+ assert!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace_for_paths(&worktree_folder_paths, None, cx)
+ })
+ .is_none(),
+ "the test must exercise a remote-only workspace lookup"
+ );
+ assert_ne!(
+ multi_workspace
+ .read_with(cx, |multi_workspace, cx| {
+ multi_workspace.workspace().read(cx).project_group_key(cx)
+ })
+ .path_list(),
+ &worktree_folder_paths,
+ "remote workspace must be classified as a linked worktree under the main project"
+ );
+
+ let workspace_to_remove = sidebar.read_with(cx, |sidebar, cx| {
+ sidebar
+ .linked_worktree_workspace_to_remove(
+ &worktree_folder_paths,
+ Some(&remote_connection),
+ Some(worktree_thread_id),
+ None,
+ &[],
+ cx,
+ )
+ .map(|workspace| workspace.entity_id())
+ });
+ let active_workspace_id = multi_workspace.read_with(cx, |multi_workspace, _cx| {
+ multi_workspace.workspace().entity_id()
+ });
+ assert_eq!(
+ workspace_to_remove,
+ Some(active_workspace_id),
+ "archive helper should resolve the remote linked-worktree workspace"
+ );
+ assert!(
+ server_fs.is_dir(Path::new("/external-worktree")).await,
+ "direct helper check should not remove the linked worktree from disk"
+ );
+}
+
#[gpui::test]
async fn test_remote_archive_thread_with_disconnected_remote(
cx: &mut TestAppContext,