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.

agent_ui: Restore last active agent panel entry (#57150)

Ben Brandt589dc95c87e8
diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs
index f13415d0cd5..151a04d8bf3 100644
--- a/crates/agent_ui/src/agent_panel.rs
+++ b/crates/agent_ui/src/agent_panel.rs
@@ -94,6 +94,7 @@ use workspace::{
const AGENT_PANEL_KEY: &str = "agent_panel";
const MIN_PANEL_WIDTH: Pixels = px(300.);
const LAST_USED_AGENT_KEY: &str = "agent_panel__last_used_external_agent";
+const LAST_CREATED_ENTRY_KIND_KEY: &str = "agent_panel__last_created_entry_kind";
const TERMINAL_AGENT_TELEMETRY_ID: &str = "terminal";
/// Maximum number of idle threads kept in the agent panel's retained list.
@@ -145,6 +146,11 @@ struct LastUsedAgent {
agent: Agent,
}
+#[derive(Serialize, Deserialize)]
+struct LastCreatedEntryKind {
+ entry_kind: AgentPanelEntryKind,
+}
+
/// Reads the most recently used agent across all workspaces. Used as a fallback
/// when opening a workspace that has no per-workspace agent preference yet.
fn read_global_last_used_agent(kvp: &KeyValueStore) -> Option<Agent> {
@@ -163,6 +169,22 @@ async fn write_global_last_used_agent(kvp: KeyValueStore, agent: Agent) {
}
}
+fn read_global_last_created_entry_kind(kvp: &KeyValueStore) -> Option<AgentPanelEntryKind> {
+ kvp.read_kvp(LAST_CREATED_ENTRY_KIND_KEY)
+ .log_err()
+ .flatten()
+ .and_then(|json| serde_json::from_str::<LastCreatedEntryKind>(&json).log_err())
+ .map(|entry| entry.entry_kind)
+}
+
+async fn write_global_last_created_entry_kind(kvp: KeyValueStore, entry_kind: AgentPanelEntryKind) {
+ if let Some(json) = serde_json::to_string(&LastCreatedEntryKind { entry_kind }).log_err() {
+ kvp.write_kvp(LAST_CREATED_ENTRY_KIND_KEY.to_string(), json)
+ .await
+ .log_err();
+ }
+}
+
fn read_serialized_panel(
workspace_id: workspace::WorkspaceId,
kvp: &KeyValueStore,
@@ -211,6 +233,8 @@ struct SerializedAgentPanel {
#[serde(default)]
last_active_thread: Option<SerializedActiveThread>,
#[serde(default)]
+ last_active_terminal_id: Option<String>,
+ #[serde(default)]
new_draft_thread_id: Option<ThreadId>,
}
@@ -844,6 +868,7 @@ pub struct AgentPanel {
draft_thread: Option<Entity<ConversationView>>,
retained_threads: HashMap<ThreadId, Entity<ConversationView>>,
terminals: HashMap<TerminalId, AgentTerminal>,
+ pending_terminal_spawn: Option<TerminalId>,
new_thread_menu_handle: PopoverMenuHandle<ContextMenu>,
agent_panel_menu_handle: PopoverMenuHandle<ContextMenu>,
_extension_subscription: Option<Subscription>,
@@ -872,52 +897,58 @@ impl AgentPanel {
let selected_agent = self.selected_agent.clone();
let last_created_entry_kind = self.last_created_entry_kind;
+ let last_active_terminal_id = self
+ .active_terminal_id()
+ .map(|terminal_id| terminal_id.to_key_string());
- let is_draft_active = self.active_thread_is_draft(cx);
- let active_thread_id = self.active_thread_id(cx);
- let active_thread_agent = self
- .active_conversation_view()
- .map(|cv| cv.read(cx).agent_key().clone())
- .unwrap_or_else(|| self.selected_agent.clone());
- let last_active_thread = self
- .active_agent_thread(cx)
- .map(|thread| {
- let thread = thread.read(cx);
-
- let title = thread.title();
- let work_dirs = thread.work_dirs().cloned();
- SerializedActiveThread {
- session_id: (!is_draft_active).then(|| thread.session_id().0.to_string()),
- thread_id: active_thread_id,
- agent_type: active_thread_agent.clone(),
- title: title.map(|t| t.to_string()),
- work_dirs: work_dirs.map(|dirs| dirs.serialize()),
- }
- })
- .or_else(|| {
- // The active view may be in `Loading` or `LoadError` — for
- // example, while a restored thread is waiting for a custom
- // agent to finish registering. Without this fallback, a
- // stray `serialize()` triggered during that window would
- // write `session_id=None` and wipe the restored session
- if is_draft_active {
- return None;
- }
- let conversation_view = self.active_conversation_view()?;
- let session_id = conversation_view.read(cx).root_session_id.clone()?;
- let metadata = ThreadMetadataStore::try_global(cx)
- .and_then(|store| store.read(cx).entry_by_session(&session_id).cloned());
- Some(SerializedActiveThread {
- session_id: Some(session_id.0.to_string()),
- thread_id: active_thread_id,
- agent_type: active_thread_agent.clone(),
- title: metadata
- .as_ref()
- .and_then(|m| m.title.as_ref())
- .map(|t| t.to_string()),
- work_dirs: metadata.map(|m| m.folder_paths().serialize()),
+ let last_active_thread = if last_active_terminal_id.is_some() {
+ None
+ } else {
+ let is_draft_active = self.active_thread_is_draft(cx);
+ let active_thread_id = self.active_thread_id(cx);
+ let active_thread_agent = self
+ .active_conversation_view()
+ .map(|cv| cv.read(cx).agent_key().clone())
+ .unwrap_or_else(|| self.selected_agent.clone());
+ self.active_agent_thread(cx)
+ .map(|thread| {
+ let thread = thread.read(cx);
+
+ let title = thread.title();
+ let work_dirs = thread.work_dirs().cloned();
+ SerializedActiveThread {
+ session_id: (!is_draft_active).then(|| thread.session_id().0.to_string()),
+ thread_id: active_thread_id,
+ agent_type: active_thread_agent.clone(),
+ title: title.map(|t| t.to_string()),
+ work_dirs: work_dirs.map(|dirs| dirs.serialize()),
+ }
})
- });
+ .or_else(|| {
+ // The active view may be in `Loading` or `LoadError` — for
+ // example, while a restored thread is waiting for a custom
+ // agent to finish registering. Without this fallback, a
+ // stray `serialize()` triggered during that window would
+ // write `session_id=None` and wipe the restored session
+ if is_draft_active {
+ return None;
+ }
+ let conversation_view = self.active_conversation_view()?;
+ let session_id = conversation_view.read(cx).root_session_id.clone()?;
+ let metadata = ThreadMetadataStore::try_global(cx)
+ .and_then(|store| store.read(cx).entry_by_session(&session_id).cloned());
+ Some(SerializedActiveThread {
+ session_id: Some(session_id.0.to_string()),
+ thread_id: active_thread_id,
+ agent_type: active_thread_agent.clone(),
+ title: metadata
+ .as_ref()
+ .and_then(|m| m.title.as_ref())
+ .map(|t| t.to_string()),
+ work_dirs: metadata.map(|m| m.folder_paths().serialize()),
+ })
+ })
+ };
let new_draft_thread_id = self
.draft_thread
@@ -932,6 +963,7 @@ impl AgentPanel {
selected_agent: Some(selected_agent),
last_created_entry_kind,
last_active_thread,
+ last_active_terminal_id,
new_draft_thread_id,
},
kvp,
@@ -957,7 +989,7 @@ impl AgentPanel {
.ok()
.flatten();
- let (serialized_panel, global_last_used_agent) = cx
+ let (serialized_panel, global_last_used_agent, global_last_created_entry_kind) = cx
.background_spawn(async move {
match kvp {
Some(kvp) => {
@@ -965,9 +997,10 @@ impl AgentPanel {
.and_then(|id| read_serialized_panel(id, &kvp))
.or_else(|| read_legacy_serialized_panel(&kvp));
let global_agent = read_global_last_used_agent(&kvp);
- (panel, global_agent)
+ let global_entry_kind = read_global_last_created_entry_kind(&kvp);
+ (panel, global_agent, global_entry_kind)
}
- None => (None, None),
+ None => (None, None, None),
}
})
.await;
@@ -975,37 +1008,101 @@ impl AgentPanel {
let has_open_project = workspace
.read_with(cx, |workspace, cx| !workspace.root_paths(cx).is_empty())
.unwrap_or(false);
- let thread_to_restore = if has_open_project {
+ let terminal_id_to_restore = if has_open_project {
serialized_panel
.as_ref()
- .and_then(|panel| panel.last_active_thread.as_ref())
- .and_then(|info| {
- let lookup = cx.update(|_window, cx| {
- let store = ThreadMetadataStore::global(cx);
- let store = store.read(cx);
- let primary = info.thread_id.and_then(|tid| store.entry(tid));
- let fallback = info.session_id.as_ref().and_then(|sid| {
- store.entry_by_session(&acp::SessionId::new(sid.clone()))
- });
- primary
- .or(fallback)
- .filter(|entry| !entry.archived)
- .map(|entry| entry.thread_id)
- });
- match lookup {
- Ok(Some(thread_id)) => Some((info, thread_id)),
- Ok(None) => {
+ .and_then(|panel| panel.last_active_terminal_id.as_deref())
+ .and_then(|terminal_id| {
+ match TerminalId::from_key_string(terminal_id) {
+ Ok(terminal_id) => Some(terminal_id),
+ Err(error) => {
+ log::warn!("failed to parse last active terminal id: {error}");
+ None
+ }
+ }
+ })
+ } else {
+ None
+ };
+ let terminal_to_restore = if let Some(terminal_id) = terminal_id_to_restore {
+ match cx.update(|_window, cx| {
+ TerminalThreadMetadataStore::try_global(cx).map(|store| {
+ let reload_task = store.read(cx).reload_task();
+ (store, reload_task)
+ })
+ }) {
+ Ok(Some((store, reload_task))) => {
+ reload_task.await;
+ match store
+ .read_with(cx, |store, _cx| store.entry(terminal_id).cloned())
+ {
+ Some(metadata) => Some(metadata),
+ None => {
log::info!(
- "last active thread is archived or missing, skipping restoration"
+ "last active terminal is missing, skipping restoration"
);
None
}
- Err(err) => {
- log::warn!("failed to look up last active thread metadata: {err}");
- None
+ }
+ }
+ Ok(None) => {
+ log::warn!("failed to restore active terminal: metadata store missing");
+ None
+ }
+ Err(err) => {
+ log::warn!("failed to access terminal metadata store: {err}");
+ None
+ }
+ }
+ } else {
+ None
+ };
+
+ let thread_to_restore = if has_open_project && terminal_to_restore.is_none() {
+ if let Some(info) = serialized_panel
+ .as_ref()
+ .and_then(|panel| panel.last_active_thread.as_ref())
+ {
+ match cx.update(|_window, cx| {
+ ThreadMetadataStore::try_global(cx).map(|store| {
+ let reload_task = store.read(cx).reload_task();
+ (store, reload_task)
+ })
+ }) {
+ Ok(Some((store, reload_task))) => {
+ reload_task.await;
+ let thread_id = store.read_with(cx, |store, _cx| {
+ let primary = info.thread_id.and_then(|tid| store.entry(tid));
+ let fallback = info.session_id.as_ref().and_then(|sid| {
+ store.entry_by_session(&acp::SessionId::new(sid.clone()))
+ });
+ primary
+ .or(fallback)
+ .filter(|entry| !entry.archived)
+ .map(|entry| entry.thread_id)
+ });
+ match thread_id {
+ Some(thread_id) => Some((info, thread_id)),
+ None => {
+ log::info!(
+ "last active thread is archived or missing, skipping restoration"
+ );
+ None
+ }
}
}
- })
+ Ok(None) => {
+ log::warn!("failed to restore active thread: metadata store missing");
+ None
+ }
+ Err(err) => {
+ log::warn!("failed to access thread metadata store: {err}");
+ None
+ }
+ }
+ } else {
+ None
+ }
} else {
None
};
@@ -1030,6 +1127,8 @@ impl AgentPanel {
if let Some(serialized_panel) = &serialized_panel {
panel.last_created_entry_kind = serialized_panel.last_created_entry_kind;
+ } else if let Some(entry_kind) = global_last_created_entry_kind {
+ panel.last_created_entry_kind = entry_kind;
}
// The thread being restored may have been bound to an
@@ -1051,7 +1150,16 @@ impl AgentPanel {
panel.selected_agent = agent;
}
- if let Some((info, thread_id)) = thread_to_restore {
+ if let Some(metadata) = terminal_to_restore {
+ panel.restore_terminal_for_panel_load(
+ metadata,
+ false,
+ AgentThreadSource::AgentPanel,
+ Some(workspace),
+ window,
+ cx,
+ );
+ } else if let Some((info, thread_id)) = thread_to_restore {
let agent = panel.selected_agent.clone();
panel.load_agent_thread(
agent,
@@ -1178,6 +1286,7 @@ impl AgentPanel {
draft_thread: None,
retained_threads: HashMap::default(),
terminals: HashMap::default(),
+ pending_terminal_spawn: None,
new_thread_menu_handle: PopoverMenuHandle::default(),
agent_panel_menu_handle: PopoverMenuHandle::default(),
@@ -1392,7 +1501,7 @@ impl AgentPanel {
return;
}
- self.set_last_created_entry_kind(AgentPanelEntryKind::Thread, cx);
+ self.set_last_created_entry_kind_from_user_action(AgentPanelEntryKind::Thread, cx);
// If the user is viewing a *parked* draft and the ephemeral
// new-draft slot is occupied, pressing `+` should just focus the
@@ -1545,6 +1654,7 @@ impl AgentPanel {
if !self.supports_terminal(cx) {
return;
}
+ self.set_last_created_entry_kind_from_user_action(AgentPanelEntryKind::Terminal, cx);
let working_directory = self.terminal_working_directory(workspace, cx);
self.spawn_terminal(
TerminalId::new(),
@@ -1579,7 +1689,7 @@ impl AgentPanel {
&& self.project.read(cx).supports_terminal(cx)
}
- fn set_last_created_entry_kind(
+ fn set_last_created_entry_kind_from_user_action(
&mut self,
entry_kind: AgentPanelEntryKind,
cx: &mut Context<Self>,
@@ -1588,6 +1698,14 @@ impl AgentPanel {
self.last_created_entry_kind = entry_kind;
self.serialize(cx);
}
+
+ cx.background_spawn({
+ let kvp = KeyValueStore::global(cx);
+ async move {
+ write_global_last_created_entry_kind(kvp, entry_kind).await;
+ }
+ })
+ .detach();
}
fn spawn_terminal(
@@ -1619,6 +1737,13 @@ impl AgentPanel {
workspace
.update(cx, |workspace, cx| workspace.show_error(&error, cx))
.log_err();
+ this.update(cx, |this, cx| {
+ if this.pending_terminal_spawn == Some(terminal_id) {
+ this.pending_terminal_spawn = None;
+ cx.notify();
+ }
+ })
+ .log_err();
return anyhow::Ok(());
}
};
@@ -1711,7 +1836,9 @@ impl AgentPanel {
notification_subscriptions: Vec::new(),
_subscriptions: vec![view_subscription, terminal_subscription],
};
- self.set_last_created_entry_kind(AgentPanelEntryKind::Terminal, cx);
+ if self.pending_terminal_spawn == Some(terminal_id) {
+ self.pending_terminal_spawn = None;
+ }
terminal.refresh_metadata(cx);
self.terminals.insert(terminal_id, terminal);
self.persist_terminal_metadata(terminal_id, cx);
@@ -1773,6 +1900,9 @@ impl AgentPanel {
) {
let was_active = self.active_terminal_id() == Some(terminal_id);
+ if self.pending_terminal_spawn == Some(terminal_id) {
+ self.pending_terminal_spawn = None;
+ }
self.dismiss_terminal_notifications(terminal_id, cx);
if self.terminals.remove(&terminal_id).is_none() {
return;
@@ -1882,6 +2012,7 @@ impl AgentPanel {
return;
}
+ self.pending_terminal_spawn = Some(metadata.terminal_id);
let working_directory = self.terminal_restore_working_directory(&metadata, workspace, cx);
let initial_title = Self::terminal_restore_initial_title(&metadata);
self.spawn_terminal(
@@ -1898,6 +2029,23 @@ impl AgentPanel {
);
}
+ fn restore_terminal_for_panel_load(
+ &mut self,
+ metadata: TerminalThreadMetadata,
+ focus: bool,
+ source: AgentThreadSource,
+ workspace: Option<&Workspace>,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ #[cfg(test)]
+ self.restore_test_terminal(metadata, focus, source, workspace, window, cx)
+ .log_err();
+
+ #[cfg(not(test))]
+ self.restore_terminal(metadata, focus, source, workspace, window, cx);
+ }
+
fn terminal_restore_working_directory(
&self,
metadata: &TerminalThreadMetadata,
@@ -4050,7 +4198,99 @@ impl Panel for AgentPanel {
impl AgentPanel {
fn ensure_thread_initialized(&mut self, window: &mut Window, cx: &mut Context<Self>) {
if matches!(self.base_view, BaseView::Uninitialized) {
- self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+ if self.pending_terminal_spawn.is_some() {
+ return;
+ }
+ if self.should_create_terminal_for_new_entry(cx) {
+ let terminal_id = TerminalId::new();
+ self.pending_terminal_spawn = Some(terminal_id);
+ cx.defer_in(window, move |this, window, cx| {
+ if matches!(this.base_view, BaseView::Uninitialized)
+ && this.pending_terminal_spawn == Some(terminal_id)
+ && this.should_create_terminal_for_new_entry(cx)
+ {
+ this.create_initial_terminal(
+ terminal_id,
+ AgentThreadSource::AgentPanel,
+ window,
+ cx,
+ );
+ } else if this.pending_terminal_spawn == Some(terminal_id) {
+ this.pending_terminal_spawn = None;
+ }
+ });
+ } else {
+ self.activate_draft(false, AgentThreadSource::AgentPanel, window, cx);
+ }
+ }
+ }
+
+ fn create_initial_terminal(
+ &mut self,
+ terminal_id: TerminalId,
+ source: AgentThreadSource,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if !self.supports_terminal(cx) {
+ if self.pending_terminal_spawn == Some(terminal_id) {
+ self.pending_terminal_spawn = None;
+ }
+ return;
+ }
+ let working_directory = self.terminal_working_directory(None, cx);
+ self.spawn_initial_terminal(terminal_id, working_directory, source, window, cx);
+ }
+
+ #[cfg(not(test))]
+ fn spawn_initial_terminal(
+ &mut self,
+ terminal_id: TerminalId,
+ working_directory: Option<PathBuf>,
+ source: AgentThreadSource,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ self.spawn_terminal(
+ terminal_id,
+ working_directory,
+ None,
+ None,
+ None,
+ true,
+ false,
+ source,
+ window,
+ cx,
+ );
+ }
+
+ #[cfg(test)]
+ fn spawn_initial_terminal(
+ &mut self,
+ terminal_id: TerminalId,
+ working_directory: Option<PathBuf>,
+ source: AgentThreadSource,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if let Err(error) = self.insert_display_only_terminal(
+ terminal_id,
+ working_directory,
+ None,
+ None,
+ None,
+ true,
+ false,
+ source,
+ window,
+ cx,
+ ) {
+ log::error!("failed to spawn test agent panel terminal: {error:#}");
+ if self.pending_terminal_spawn == Some(terminal_id) {
+ self.pending_terminal_spawn = None;
+ cx.notify();
+ }
}
}
@@ -5528,6 +5768,7 @@ impl AgentPanel {
cx: &mut Context<Self>,
) -> Result<TerminalId> {
let terminal_id = TerminalId::new();
+ self.set_last_created_entry_kind_from_user_action(AgentPanelEntryKind::Terminal, cx);
self.insert_display_only_terminal(
terminal_id,
None,
@@ -5909,6 +6150,27 @@ mod tests {
panel_b.update(cx, |panel, cx| panel.serialize(cx));
cx.run_until_parked();
+ let workspace_a_id = workspace_a
+ .read_with(cx, |workspace, _cx| workspace.database_id())
+ .expect("workspace A should have a database id");
+ let kvp = cx.update(|_window, cx| KeyValueStore::global(cx));
+ let serialized_a: SerializedAgentPanel = cx
+ .background_spawn(async move { read_serialized_panel(workspace_a_id, &kvp) })
+ .await
+ .expect("workspace A should serialize panel state");
+ assert!(
+ serialized_a.last_active_thread.is_some(),
+ "active thread should be the thread restore target"
+ );
+ assert!(
+ serialized_a.last_active_terminal_id.is_none(),
+ "active thread serialization should not also include a terminal restore target"
+ );
+
+ cx.update(|_window, cx| {
+ ThreadMetadataStore::init_global(cx);
+ });
+
// Load fresh panels for each workspace and verify independent state.
let async_cx = cx.update(|window, cx| window.to_async(cx));
let loaded_a = AgentPanel::load(workspace_a.downgrade(), async_cx)
@@ -5950,6 +6212,278 @@ mod tests {
});
}
+ #[gpui::test]
+ async fn test_active_terminal_serialize_and_load_round_trip(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.update(|cx| {
+ agent::ThreadStore::init_global(cx);
+ TerminalThreadMetadataStore::init_global(cx);
+ language_model::LanguageModelRegistry::test(cx);
+ });
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree("/project", json!({ "file.txt": "" })).await;
+ cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+ 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();
+ workspace.update(cx, |workspace, _cx| {
+ workspace.set_random_database_id();
+ });
+
+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+ let panel = workspace.update_in(cx, |workspace, window, cx| {
+ cx.new(|cx| AgentPanel::new(workspace, None, window, cx))
+ });
+
+ panel.update_in(cx, |panel, window, cx| {
+ panel.activate_new_thread(false, AgentThreadSource::AgentPanel, window, 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");
+ panel.update(cx, |panel, cx| panel.serialize(cx));
+ cx.run_until_parked();
+
+ let workspace_id = workspace
+ .read_with(cx, |workspace, _cx| workspace.database_id())
+ .expect("workspace should have a database id");
+ let kvp = cx.update(|_window, cx| KeyValueStore::global(cx));
+ let serialized: SerializedAgentPanel = cx
+ .background_spawn(async move { read_serialized_panel(workspace_id, &kvp) })
+ .await
+ .expect("workspace should serialize panel state");
+ assert_eq!(
+ serialized.last_active_terminal_id,
+ Some(terminal_id.to_key_string())
+ );
+ assert!(
+ serialized.last_active_thread.is_none(),
+ "active terminal serialization should not also include a thread restore target"
+ );
+
+ cx.update(|_window, cx| {
+ TerminalThreadMetadataStore::init_global(cx);
+ });
+ let async_cx = cx.update(|window, cx| window.to_async(cx));
+ let loaded = AgentPanel::load(workspace.downgrade(), async_cx)
+ .await
+ .expect("panel load should succeed");
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
+
+ loaded.read_with(cx, |panel, cx| {
+ assert_eq!(panel.active_terminal_id(), Some(terminal_id));
+ assert!(
+ panel.active_conversation_view().is_none(),
+ "the restored terminal should remain active instead of falling back to a draft"
+ );
+ assert!(
+ panel
+ .terminals(cx)
+ .into_iter()
+ .any(|terminal| terminal.id == terminal_id),
+ "active terminal metadata should be restored into the loaded panel"
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_pending_terminal_restore_prevents_initial_terminal_creation(
+ cx: &mut TestAppContext,
+ ) {
+ let (panel, mut cx) = setup_panel(cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.last_created_entry_kind = AgentPanelEntryKind::Terminal;
+ panel.pending_terminal_spawn = Some(TerminalId::new());
+ panel.set_active(true, window, cx);
+ });
+ for _ in 0..4 {
+ cx.run_until_parked();
+ }
+
+ panel.read_with(&cx, |panel, cx| {
+ assert!(
+ panel.terminals(cx).is_empty(),
+ "activation while a terminal restore is pending should not create a second terminal"
+ );
+ assert!(
+ panel.active_conversation_view().is_none(),
+ "activation while a terminal restore is pending should not fall back to a draft"
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_repeated_activation_only_creates_one_initial_terminal(cx: &mut TestAppContext) {
+ let (panel, mut cx) = setup_panel(cx).await;
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.last_created_entry_kind = AgentPanelEntryKind::Terminal;
+ panel.set_active(true, window, cx);
+ panel.set_active(true, window, cx);
+ });
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
+
+ panel.read_with(&cx, |panel, cx| {
+ assert_eq!(
+ panel.terminals(cx).len(),
+ 1,
+ "repeated activation should only enqueue one initial terminal"
+ );
+ assert!(
+ panel.active_terminal_id().is_some(),
+ "the single initial terminal should become active"
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_restored_terminal_does_not_update_global_entry_kind(cx: &mut TestAppContext) {
+ let (panel, mut cx) = setup_panel(cx).await;
+ cx.update(|_, cx| {
+ TerminalThreadMetadataStore::init_global(cx);
+ });
+
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.activate_new_thread(false, AgentThreadSource::AgentPanel, window, cx);
+ });
+ cx.run_until_parked();
+ cx.update(|_, cx| {
+ assert_eq!(
+ read_global_last_created_entry_kind(&KeyValueStore::global(cx)),
+ Some(AgentPanelEntryKind::Thread)
+ );
+ });
+
+ let metadata = TerminalThreadMetadata {
+ terminal_id: TerminalId::new(),
+ title: "Restored Terminal".into(),
+ custom_title: None,
+ created_at: Utc::now(),
+ worktree_paths: WorktreePaths::from_folder_paths(&PathList::new(&[PathBuf::from(
+ "/project",
+ )])),
+ remote_connection: None,
+ working_directory: None,
+ };
+ panel
+ .update_in(&mut cx, |panel, window, cx| {
+ panel.restore_test_terminal(
+ metadata,
+ true,
+ AgentThreadSource::AgentPanel,
+ None,
+ window,
+ cx,
+ )
+ })
+ .expect("test terminal should be restored");
+ cx.run_until_parked();
+
+ cx.update(|_, cx| {
+ assert_eq!(
+ read_global_last_created_entry_kind(&KeyValueStore::global(cx)),
+ Some(AgentPanelEntryKind::Thread),
+ "restoring a terminal should not change the global new-entry default"
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_new_workspace_load_uses_global_terminal_entry_kind(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.update(|cx| {
+ agent::ThreadStore::init_global(cx);
+ TerminalThreadMetadataStore::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;
+ cx.update(|cx| <dyn fs::Fs>::set_global(fs.clone(), cx));
+
+ 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 multi_workspace_entity = multi_workspace.root(cx).unwrap();
+ let workspace_a = multi_workspace
+ .read_with(cx, |multi_workspace, _cx| {
+ multi_workspace.workspace().clone()
+ })
+ .unwrap();
+ workspace_a.update(cx, |workspace, _cx| {
+ workspace.set_random_database_id();
+ });
+
+ let cx = &mut VisualTestContext::from_window(multi_workspace.into(), cx);
+ let panel_a = workspace_a.update_in(cx, |workspace, window, cx| {
+ cx.new(|cx| AgentPanel::new(workspace, None, window, cx))
+ });
+ panel_a
+ .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();
+
+ cx.update(|_window, cx| {
+ assert_eq!(
+ read_global_last_created_entry_kind(&KeyValueStore::global(cx)),
+ Some(AgentPanelEntryKind::Terminal)
+ );
+ });
+
+ let workspace_b = multi_workspace_entity.update_in(cx, |multi_workspace, window, cx| {
+ multi_workspace.test_add_workspace(project_b.clone(), window, cx)
+ });
+ workspace_b.update(cx, |workspace, _cx| {
+ workspace.set_random_database_id();
+ });
+
+ let async_cx = cx.update(|window, cx| window.to_async(cx));
+ let loaded = AgentPanel::load(workspace_b.downgrade(), async_cx)
+ .await
+ .expect("panel load should succeed");
+ workspace_b.update_in(cx, |workspace, window, cx| {
+ workspace.add_panel(loaded.clone(), window, cx);
+ });
+ loaded.update_in(cx, |panel, window, cx| {
+ panel.set_active(true, window, cx);
+ });
+ for _ in 0..8 {
+ cx.run_until_parked();
+ }
+
+ loaded.read_with(cx, |panel, cx| {
+ assert!(
+ panel.active_terminal_id().is_some(),
+ "new workspace should initialize to a terminal when terminal was the globally last used entry kind"
+ );
+ assert!(
+ panel.active_conversation_view().is_none(),
+ "new workspace should not initialize to a draft when terminal is the global entry kind"
+ );
+ assert!(panel.should_create_terminal_for_new_entry(cx));
+ });
+ }
+
#[gpui::test]
async fn test_non_native_thread_without_metadata_is_not_restored(cx: &mut TestAppContext) {
init_test(cx);
diff --git a/crates/agent_ui/src/terminal_thread_metadata_store.rs b/crates/agent_ui/src/terminal_thread_metadata_store.rs
index e3d5c9fdef8..c5e2dbbdfba 100644
--- a/crates/agent_ui/src/terminal_thread_metadata_store.rs
+++ b/crates/agent_ui/src/terminal_thread_metadata_store.rs
@@ -10,6 +10,7 @@ use db::{
},
sqlez_macros::sql,
};
+use futures::{FutureExt, future::Shared};
use gpui::{AppContext as _, Entity, Global, Task};
use remote::{RemoteConnectionOptions, same_remote_connection_identity};
use ui::{App, Context, SharedString};
@@ -69,6 +70,7 @@ pub struct TerminalThreadMetadataStore {
terminals: HashMap<TerminalId, TerminalThreadMetadata>,
terminals_by_paths: HashMap<PathList, HashSet<TerminalId>>,
terminals_by_main_paths: HashMap<PathList, HashSet<TerminalId>>,
+ reload_task: Option<Shared<Task<()>>>,
pending_terminal_ops_tx: async_channel::Sender<DbOperation>,
_db_operations_task: Task<()>,
}
@@ -125,6 +127,12 @@ impl TerminalThreadMetadataStore {
self.terminals.values()
}
+ pub fn reload_task(&self) -> Shared<Task<()>> {
+ self.reload_task
+ .clone()
+ .unwrap_or_else(|| Task::ready(()).shared())
+ }
+
pub fn entries_for_path<'a>(
&'a self,
path_list: &PathList,
@@ -312,6 +320,7 @@ impl TerminalThreadMetadataStore {
terminals: HashMap::default(),
terminals_by_paths: HashMap::default(),
terminals_by_main_paths: HashMap::default(),
+ reload_task: None,
pending_terminal_ops_tx: tx,
_db_operations_task,
};
@@ -332,30 +341,32 @@ impl TerminalThreadMetadataStore {
fn reload(&mut self, cx: &mut Context<Self>) {
let db = self.db.clone();
- cx.spawn(async move |this, cx| {
- let rows = cx
- .background_spawn(async move {
- db.list()
- .context("Failed to fetch terminal thread metadata")
- })
- .await
- .log_err()
- .unwrap_or_default();
-
- this.update(cx, |this, cx| {
- this.terminals.clear();
- this.terminals_by_paths.clear();
- this.terminals_by_main_paths.clear();
-
- for row in rows {
- this.cache_terminal_metadata(row);
- }
+ self.reload_task = Some(
+ cx.spawn(async move |this, cx| {
+ let rows = cx
+ .background_spawn(async move {
+ db.list()
+ .context("Failed to fetch terminal thread metadata")
+ })
+ .await
+ .log_err()
+ .unwrap_or_default();
+
+ this.update(cx, |this, cx| {
+ this.terminals.clear();
+ this.terminals_by_paths.clear();
+ this.terminals_by_main_paths.clear();
+
+ for row in rows {
+ this.cache_terminal_metadata(row);
+ }
- cx.notify();
+ cx.notify();
+ })
+ .ok();
})
- .ok();
- })
- .detach();
+ .shared(),
+ );
}
}
diff --git a/crates/agent_ui/src/thread_metadata_store.rs b/crates/agent_ui/src/thread_metadata_store.rs
index 9787d3d9d7d..594b0d00b83 100644
--- a/crates/agent_ui/src/thread_metadata_store.rs
+++ b/crates/agent_ui/src/thread_metadata_store.rs
@@ -587,6 +587,12 @@ impl ThreadMetadataStore {
self.threads.values()
}
+ pub fn reload_task(&self) -> Shared<Task<()>> {
+ self.reload_task
+ .clone()
+ .unwrap_or_else(|| Task::ready(()).shared())
+ }
+
/// Returns all archived threads.
pub fn archived_entries(&self) -> impl Iterator<Item = &ThreadMetadata> + '_ {
self.entries().filter(|t| t.archived)