{
- row_button(id, group, "ellipsis", label)
+ row_button(id, group, "ellipsis", label).when(open, |button| {
+ button
+ .opacity(1.)
+ .bg(gpui::rgb(theme::bg_sidebar_row_selected()))
+ })
+}
+
+/// An icon button of the Projects header. It stays pressed, without its
+/// tooltip, while its menu is open.
+fn header_button(
+ id: &'static str,
+ icon_name: &'static str,
+ label: &'static str,
+ open: bool,
+) -> gpui::Stateful
{
+ div()
+ .id(id)
+ .role(gpui::Role::Button)
+ .aria_label(label)
+ .flex_none()
+ .size_6()
+ .flex()
+ .items_center()
+ .justify_center()
+ .rounded(theme::RADIUS_SM)
+ .hover(|style| {
+ style
+ .bg(gpui::rgb(theme::bg_sidebar_row_hover()))
+ .cursor_pointer()
+ })
.when(open, |button| {
- button
- .opacity(1.)
- .bg(gpui::rgb(theme::bg_sidebar_row_selected()))
+ button.bg(gpui::rgb(theme::bg_sidebar_row_selected()))
})
.when(!open, |button| {
button.tooltip(widgets::tooltip(label, None))
})
+ .child(icon(icon_name, px(16.), theme::text_secondary()))
}
/// The small icon button a sidebar row shows while it is hovered.
@@ -3336,14 +4284,16 @@ mod tests {
#[gpui::test]
fn sidebar_remeasures_an_offscreen_heading_when_its_gap_changes(cx: &mut gpui::TestAppContext) {
use super::*;
+ let _settings = crate::settings::SETTINGS_IO_LOCK.lock();
cx.executor().allow_parking();
let backend =
Arc::new(AgentBackend::for_test("http://127.0.0.1:9".into(), String::new()).unwrap());
let chat = cx.new(|cx| ChatScreen::new_without_start(backend, "user".into(), cx));
let sidebar = chat.update(cx, |chat, _| chat.sidebar.clone());
sidebar.update(cx, |sidebar, cx| {
+ sidebar.reset_persisted_for_test();
+ sidebar.project_filter = Some("/tmp/proj".into());
sidebar.application_vim_enabled = true;
- sidebar.list = gpui::ListState::new(0, gpui::ListAlignment::Top, px(0.));
let sessions = (0..102)
.map(|ix| AgentSessionSummary {
id: format!("s{ix}"),
@@ -3364,6 +4314,8 @@ mod tests {
.collect();
sidebar.pinned_tasks = (0..100).map(|ix| format!("s{ix}")).collect();
sidebar.set_sessions(sessions, cx);
+ sidebar.list =
+ gpui::ListState::new(sidebar.entries.len(), gpui::ListAlignment::Top, px(0.));
});
let list = sidebar.update(cx, |sidebar, _| sidebar.list.clone());
struct Host(Entity
);
diff --git a/apps/maple-agent/app/src/ui/chat/sidebar_catalog.rs b/apps/maple-agent/app/src/ui/chat/sidebar_catalog.rs
new file mode 100644
index 000000000..c87891d91
--- /dev/null
+++ b/apps/maple-agent/app/src/ui/chat/sidebar_catalog.rs
@@ -0,0 +1,677 @@
+//! Desktop-only manual ordering over the unchanged summary paging protocol.
+//! Only complete small inventories are reused. Larger scopes are scanned with
+//! a bounded candidate heap; neither saved ranks nor local cursors leave here.
+use std::cmp::Ordering;
+use std::collections::{BinaryHeap, HashMap, VecDeque};
+use std::sync::{Arc, Mutex, Weak};
+
+use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
+use maple_agent::store::{
+ NavigationSearchQuery, NavigationTaskPage, NavigationTaskQuery, TaskSummary,
+};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use tokio::sync::Semaphore;
+use tokio_util::sync::CancellationToken;
+
+use crate::backend::{AgentBackend, PinnedTasksRequest};
+
+pub(super) const CANCELLED: &str = "Sidebar manual ordering was cancelled";
+const BAD_CURSOR: &str = "The sidebar order changed; refresh this list";
+const CURSOR_PREFIX: &str = "sidebar-manual-v1:";
+const MAX_CURSOR_BYTES: usize = 4096;
+const MAX_WIRE_CURSOR_BYTES: usize = 16 * 1024;
+const MAX_PAGE: usize = 200;
+const MAX_INVENTORY_ROWS: usize = 2048;
+const MAX_INVENTORY_BYTES: usize = 8 * 1024 * 1024;
+const MAX_CACHE_BYTES: usize = 16 * 1024 * 1024;
+const MAX_CACHE_SCOPES: usize = 8;
+
+/// The paged catalog and loaded sidebar rows use the same manual order bands.
+pub(super) fn manual_order_key(rank: Option, created: i64, cutoff: i64) -> (u8, i64) {
+ if let Some(rank) = rank {
+ (1, rank as i64)
+ } else if created > cutoff {
+ (0, created.saturating_neg())
+ } else {
+ (2, created.saturating_neg())
+ }
+}
+
+#[derive(Clone, Serialize)]
+pub(super) struct ManualOrder {
+ pub(super) cutoff: i64,
+ pub(super) tasks: Vec,
+}
+
+impl ManualOrder {
+ /// Used after independently read active/settled prefixes are combined.
+ /// Callers run their summary preparation on the backend executor.
+ pub(super) fn sort(&self, tasks: &mut [TaskSummary]) {
+ let ranks = Ranks::new(self);
+ tasks.sort_by_cached_key(|task| ranks.position(task));
+ }
+
+ fn validate(&self) -> Result<(), String> {
+ if self.cutoff < 0 || self.tasks.len() > 8192 {
+ return Err("Invalid sidebar manual order".into());
+ }
+ let mut seen = std::collections::HashSet::new();
+ for task in &self.tasks {
+ if task.is_empty()
+ || task.len() > 256
+ || task.chars().any(char::is_control)
+ || !seen.insert(task)
+ {
+ return Err("Invalid sidebar manual order".into());
+ }
+ }
+ Ok(())
+ }
+}
+
+#[derive(Clone, Serialize)]
+#[serde(tag = "kind", content = "query")]
+pub(super) enum TaskQuery {
+ Tasks(NavigationTaskQuery),
+ Search(NavigationSearchQuery),
+ Pinned(PinnedTasksRequest),
+}
+
+impl TaskQuery {
+ fn cursor(&self) -> Option<&str> {
+ match self {
+ Self::Tasks(query) => query.cursor.as_deref(),
+ Self::Search(query) => query.cursor.as_deref(),
+ Self::Pinned(query) => query.cursor.as_deref(),
+ }
+ }
+
+ fn limit(&self) -> usize {
+ usize::from(match self {
+ Self::Tasks(query) => query.limit,
+ Self::Search(query) => query.limit,
+ Self::Pinned(query) => query.limit,
+ })
+ }
+
+ fn wire_query(&self, cursor: Option) -> Self {
+ let mut query = self.clone();
+ match &mut query {
+ Self::Tasks(query) => {
+ query.cursor = cursor;
+ query.limit = 200;
+ }
+ Self::Search(query) => {
+ query.cursor = cursor;
+ // Protocol seven bounds search pages to one hundred rows.
+ query.limit = 100;
+ }
+ Self::Pinned(query) => {
+ query.cursor = cursor;
+ query.limit = 200;
+ }
+ }
+ query
+ }
+
+ async fn fetch(
+ &self,
+ backend: &AgentBackend,
+ user: &str,
+ cursor: Option,
+ ) -> Result {
+ match self.wire_query(cursor) {
+ Self::Tasks(query) => backend.list_tasks(user, query).await,
+ Self::Search(query) => backend.search_tasks(user, query).await,
+ Self::Pinned(query) => backend.pinned_tasks(user, query).await,
+ }
+ }
+}
+
+#[derive(Default, Clone)]
+pub(super) struct Catalog {
+ shared: Arc,
+}
+
+struct Shared {
+ state: Mutex,
+ scan_slots: Arc,
+}
+
+impl Default for Shared {
+ fn default() -> Self {
+ Self {
+ state: Mutex::new(State::default()),
+ scan_slots: Arc::new(Semaphore::new(2)),
+ }
+ }
+}
+
+impl Drop for Shared {
+ fn drop(&mut self) {
+ self.state
+ .get_mut()
+ .unwrap_or_else(|error| error.into_inner())
+ .pending
+ .cancel();
+ }
+}
+
+#[derive(Default)]
+struct State {
+ generation: u64,
+ pending: CancellationToken,
+ cache: VecDeque,
+ cache_bytes: usize,
+}
+
+struct Inventory {
+ scope: [u8; 32],
+ backend: Weak,
+ tasks: Arc>,
+ bytes: usize,
+}
+
+impl Catalog {
+ pub(super) fn reader(&self) -> Reader {
+ let state = self
+ .shared
+ .state
+ .lock()
+ .unwrap_or_else(|error| error.into_inner());
+ Reader {
+ shared: Arc::downgrade(&self.shared),
+ generation: state.generation,
+ pending: state.pending.clone(),
+ }
+ }
+
+ /// Live activity invalidates reuse without starving scans already reading.
+ /// Their result can finish, but cannot refill this generation's cache.
+ pub(super) fn invalidate(&self) {
+ let mut state = self
+ .shared
+ .state
+ .lock()
+ .unwrap_or_else(|error| error.into_inner());
+ state.generation = state.generation.wrapping_add(1);
+ state.cache.clear();
+ state.cache_bytes = 0;
+ }
+
+ /// Explicit scope/order refreshes also fence the caller's request generation.
+ pub(super) fn cancel_pending(&self) {
+ let mut state = self
+ .shared
+ .state
+ .lock()
+ .unwrap_or_else(|error| error.into_inner());
+ state.pending.cancel();
+ state.pending = CancellationToken::new();
+ }
+}
+
+#[derive(Clone)]
+pub(super) struct Reader {
+ shared: Weak,
+ generation: u64,
+ pending: CancellationToken,
+}
+
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+struct Position {
+ band: u8,
+ value: i64,
+ id: String,
+}
+
+struct Ranks<'a> {
+ cutoff: i64,
+ tasks: HashMap<&'a str, usize>,
+}
+
+impl<'a> Ranks<'a> {
+ fn new(order: &'a ManualOrder) -> Self {
+ Self {
+ cutoff: order.cutoff,
+ tasks: order
+ .tasks
+ .iter()
+ .enumerate()
+ .map(|(rank, id)| (id.as_str(), rank))
+ .collect(),
+ }
+ }
+
+ fn position(&self, task: &TaskSummary) -> Position {
+ let (band, value) = manual_order_key(
+ self.tasks.get(task.uuid.as_str()).copied(),
+ task.created_ms,
+ self.cutoff,
+ );
+ Position {
+ band,
+ value,
+ id: task.uuid.clone(),
+ }
+ }
+}
+
+struct Candidate {
+ position: Position,
+ task: TaskSummary,
+}
+
+impl PartialEq for Candidate {
+ fn eq(&self, other: &Self) -> bool {
+ self.position == other.position
+ }
+}
+impl Eq for Candidate {}
+impl PartialOrd for Candidate {
+ fn partial_cmp(&self, other: &Self) -> Option {
+ Some(self.cmp(other))
+ }
+}
+impl Ord for Candidate {
+ fn cmp(&self, other: &Self) -> Ordering {
+ self.position.cmp(&other.position)
+ }
+}
+
+/// The heap contains only the next page and one lookahead row. Its root is the
+/// worst retained row, so no number of discarded history pages grows memory.
+struct Candidates {
+ rows: BinaryHeap,
+ maximum: usize,
+}
+
+impl Candidates {
+ fn new(limit: usize) -> Self {
+ Self {
+ rows: BinaryHeap::new(),
+ maximum: limit + 1,
+ }
+ }
+
+ fn offer(&mut self, candidate: Candidate) {
+ if let Some(previous) = self
+ .rows
+ .iter()
+ .find(|row| row.task.uuid == candidate.task.uuid)
+ {
+ if previous.task.updated_ms > candidate.task.updated_ms {
+ return;
+ }
+ self.rows.retain(|row| row.task.uuid != candidate.task.uuid);
+ }
+ if self.rows.len() < self.maximum {
+ self.rows.push(candidate);
+ } else if self
+ .rows
+ .peek()
+ .is_some_and(|worst| candidate.position < worst.position)
+ {
+ self.rows.pop();
+ self.rows.push(candidate);
+ }
+ }
+
+ fn finish(
+ self,
+ scope: [u8; 32],
+ after: Option,
+ limit: usize,
+ ) -> Result {
+ let mut rows = self.rows.into_sorted_vec();
+ let more = rows.len() > limit;
+ rows.truncate(limit);
+ let last = rows.last().map(|row| row.position.clone()).or(after);
+ Ok(NavigationTaskPage {
+ tasks: rows.into_iter().map(|row| row.task).collect(),
+ next_cursor: more.then(|| encode_cursor(scope, last)).transpose()?,
+ })
+ }
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Cursor {
+ scope: [u8; 32],
+ after: Option,
+}
+
+fn encode_cursor(scope: [u8; 32], after: Option) -> Result {
+ let bytes = serde_json::to_vec(&Cursor { scope, after }).map_err(|_| BAD_CURSOR.to_string())?;
+ Ok(format!("{CURSOR_PREFIX}{}", URL_SAFE_NO_PAD.encode(bytes)))
+}
+
+fn decode_cursor(cursor: Option<&str>, scope: [u8; 32]) -> Result, String> {
+ let Some(cursor) = cursor else {
+ return Ok(None);
+ };
+ if cursor.len() > MAX_CURSOR_BYTES {
+ return Err(BAD_CURSOR.into());
+ }
+ let encoded = cursor.strip_prefix(CURSOR_PREFIX).ok_or(BAD_CURSOR)?;
+ let bytes = URL_SAFE_NO_PAD
+ .decode(encoded)
+ .map_err(|_| BAD_CURSOR.to_string())?;
+ let cursor: Cursor = serde_json::from_slice(&bytes).map_err(|_| BAD_CURSOR.to_string())?;
+ if cursor.scope != scope
+ || cursor
+ .after
+ .as_ref()
+ .is_some_and(|after| after.band > 2 || after.id.is_empty() || after.id.len() > 256)
+ {
+ return Err(BAD_CURSOR.into());
+ }
+ Ok(cursor.after)
+}
+
+fn scopes(
+ backend: &Arc,
+ user: &str,
+ query: &TaskQuery,
+ order: &ManualOrder,
+) -> Result<([u8; 32], [u8; 32]), String> {
+ let mut hash = Sha256::new();
+ hash.update(b"maple.sidebar.catalog.v1");
+ hash.update((Arc::as_ptr(backend) as usize).to_be_bytes());
+ hash.update((user.len() as u64).to_be_bytes());
+ hash.update(user.as_bytes());
+ let host = backend.remote_host().unwrap_or("");
+ hash.update((host.len() as u64).to_be_bytes());
+ hash.update(host.as_bytes());
+ hash.update(serde_json::to_vec(&query.wire_query(None)).map_err(|_| BAD_CURSOR.to_string())?);
+ let inventory: [u8; 32] = hash.finalize().into();
+ let mut hash = Sha256::new();
+ hash.update(inventory);
+ hash.update(serde_json::to_vec(order).map_err(|_| BAD_CURSOR.to_string())?);
+ Ok((inventory, hash.finalize().into()))
+}
+
+fn charged_bytes(task: &TaskSummary) -> Result {
+ // Charge owned strings, struct/index overhead and JSON escaping conservatively.
+ Ok(serde_json::to_vec(task)
+ .map_err(|_| "Could not prepare sidebar summaries".to_string())?
+ .len()
+ .saturating_add(std::mem::size_of::())
+ .saturating_add(task.uuid.len())
+ .saturating_add(64))
+}
+
+impl Reader {
+ fn owner(&self) -> Result, String> {
+ if self.pending.is_cancelled() {
+ return Err(CANCELLED.into());
+ }
+ self.shared.upgrade().ok_or_else(|| CANCELLED.into())
+ }
+
+ fn authorize(&self, backend: &AgentBackend, user: &str) -> Result<(), String> {
+ self.owner()?;
+ // The IPC client's current account is maintained by its host event
+ // stream. This also fences cache-only replies without a network call.
+ if backend.saved_user_id().as_deref() != Some(user) {
+ return Err("The sidebar account is no longer active".into());
+ }
+ Ok(())
+ }
+
+ fn cached(
+ &self,
+ backend: &Arc,
+ scope: [u8; 32],
+ ) -> Result>>, String> {
+ let shared = self.owner()?;
+ let mut state = shared
+ .state
+ .lock()
+ .unwrap_or_else(|error| error.into_inner());
+ let found = state.cache.iter().position(|entry| {
+ entry.scope == scope
+ && entry
+ .backend
+ .upgrade()
+ .is_some_and(|owner| Arc::ptr_eq(&owner, backend))
+ });
+ let Some(index) = found else {
+ return Ok(None);
+ };
+ let inventory = state.cache.remove(index).expect("located cache entry");
+ let tasks = inventory.tasks.clone();
+ state.cache.push_back(inventory);
+ Ok(Some(tasks))
+ }
+
+ fn install(
+ &self,
+ backend: &Arc,
+ scope: [u8; 32],
+ tasks: Vec,
+ bytes: usize,
+ ) {
+ let Ok(shared) = self.owner() else {
+ return;
+ };
+ let mut state = shared
+ .state
+ .lock()
+ .unwrap_or_else(|error| error.into_inner());
+ if state.generation != self.generation {
+ return;
+ }
+ if let Some(index) = state.cache.iter().position(|entry| entry.scope == scope)
+ && let Some(previous) = state.cache.remove(index)
+ {
+ state.cache_bytes = state.cache_bytes.saturating_sub(previous.bytes);
+ }
+ while state.cache.len() >= MAX_CACHE_SCOPES
+ || state.cache_bytes.saturating_add(bytes) > MAX_CACHE_BYTES
+ {
+ let Some(previous) = state.cache.pop_front() else {
+ break;
+ };
+ state.cache_bytes = state.cache_bytes.saturating_sub(previous.bytes);
+ }
+ state.cache_bytes = state.cache_bytes.saturating_add(bytes);
+ state.cache.push_back(Inventory {
+ scope,
+ backend: Arc::downgrade(backend),
+ tasks: Arc::new(tasks),
+ bytes,
+ });
+ }
+
+ /// Derive an exact continuation for a prefix of this same returned page.
+ /// Group projection can merge two state prefixes without a second scan.
+ pub(super) fn prefix_cursor(
+ &self,
+ backend: &Arc,
+ user: &str,
+ query: &TaskQuery,
+ order: &ManualOrder,
+ page: &NavigationTaskPage,
+ keep: usize,
+ ) -> Result, String> {
+ self.authorize(backend, user)?;
+ order.validate()?;
+ if keep > page.tasks.len() {
+ return Err(BAD_CURSOR.into());
+ }
+ if keep == page.tasks.len() && page.next_cursor.is_none() {
+ return Ok(None);
+ }
+ let (_, scope) = scopes(backend, user, query, order)?;
+ let after = if let Some(task) = keep.checked_sub(1).and_then(|index| page.tasks.get(index))
+ {
+ Some(Ranks::new(order).position(task))
+ } else {
+ decode_cursor(query.cursor(), scope)?
+ };
+ encode_cursor(scope, after).map(Some)
+ }
+
+ async fn scan_slot(&self) -> Result {
+ let slots = self.owner()?.scan_slots.clone();
+ tokio::select! {
+ biased;
+ _ = self.pending.cancelled() => Err(CANCELLED.into()),
+ permit = slots.acquire_owned() => permit.map_err(|_| CANCELLED.to_string()),
+ }
+ }
+
+ pub(super) async fn page(
+ self,
+ backend: Arc,
+ user: String,
+ query: TaskQuery,
+ order: ManualOrder,
+ ) -> Result {
+ self.authorize(&backend, &user)?;
+ order.validate()?;
+ let limit = query.limit();
+ if limit > MAX_PAGE {
+ return Err("Sidebar page is too large".into());
+ }
+ let (inventory_scope, scope) = scopes(&backend, &user, &query, &order)?;
+ let after = decode_cursor(query.cursor(), scope)?;
+ let ranks = Ranks::new(&order);
+ let mut candidates = Candidates::new(limit);
+ if let Some(tasks) = self.cached(&backend, inventory_scope)? {
+ for task in tasks.iter() {
+ let position = ranks.position(task);
+ if after.as_ref().is_none_or(|after| position > *after) {
+ candidates.offer(Candidate {
+ position,
+ task: task.clone(),
+ });
+ }
+ }
+ self.authorize(&backend, &user)?;
+ return candidates.finish(scope, after, limit);
+ }
+ let _permit = self.scan_slot().await?;
+ // A preceding scan may have completed while this reader waited.
+ if let Some(tasks) = self.cached(&backend, inventory_scope)? {
+ for task in tasks.iter() {
+ let position = ranks.position(task);
+ if after.as_ref().is_none_or(|after| position > *after) {
+ candidates.offer(Candidate {
+ position,
+ task: task.clone(),
+ });
+ }
+ }
+ self.authorize(&backend, &user)?;
+ return candidates.finish(scope, after, limit);
+ }
+ let mut inventory = Some(HashMap::::new());
+ let mut bytes = 0_usize;
+ let mut wire_cursor = None;
+ // Brent's cycle guard retains one cursor, rather than unbounded history.
+ let mut checkpoint = None;
+ let mut distance = 0_usize;
+ let mut power = 1_usize;
+ loop {
+ self.authorize(&backend, &user)?;
+ let page = tokio::select! {
+ biased;
+ _ = self.pending.cancelled() => return Err(CANCELLED.into()),
+ page = query.fetch(&backend, &user, wire_cursor.clone()) => page?,
+ };
+ self.authorize(&backend, &user)?;
+ if page.tasks.is_empty() && page.next_cursor.is_some() {
+ return Err("Sidebar summary paging did not advance".into());
+ }
+ for task in page.tasks {
+ if let Some(rows) = &mut inventory {
+ let charge = charged_bytes(&task)?;
+ if let Some((previous, previous_bytes)) = rows.get(&task.uuid) {
+ if previous.updated_ms <= task.updated_ms {
+ bytes = bytes.saturating_sub(*previous_bytes).saturating_add(charge);
+ rows.insert(task.uuid.clone(), (task.clone(), charge));
+ }
+ } else {
+ bytes = bytes.saturating_add(charge);
+ rows.insert(task.uuid.clone(), (task.clone(), charge));
+ }
+ if rows.len() > MAX_INVENTORY_ROWS || bytes > MAX_INVENTORY_BYTES {
+ inventory = None;
+ }
+ }
+ let position = ranks.position(&task);
+ if after.as_ref().is_none_or(|after| position > *after) {
+ candidates.offer(Candidate { position, task });
+ }
+ }
+ let Some(next) = page.next_cursor else {
+ break;
+ };
+ if next.len() > MAX_WIRE_CURSOR_BYTES
+ || wire_cursor.as_ref() == Some(&next)
+ || checkpoint.as_ref() == Some(&next)
+ {
+ return Err("Sidebar summary paging did not advance".into());
+ }
+ distance = distance.saturating_add(1);
+ if distance == power {
+ checkpoint = Some(next.clone());
+ power = power.saturating_mul(2);
+ distance = 0;
+ }
+ wire_cursor = Some(next);
+ tokio::task::yield_now().await;
+ }
+ self.authorize(&backend, &user)?;
+ if let Some(inventory) = inventory {
+ self.install(
+ &backend,
+ inventory_scope,
+ inventory.into_values().map(|(task, _)| task).collect(),
+ bytes,
+ );
+ }
+ candidates.finish(scope, after, limit)
+ }
+}
+
+#[cfg(test)]
+mod cancellation_tests {
+ use super::*;
+
+ #[tokio::test]
+ async fn cancelling_a_reload_releases_queued_scans_before_a_slot_opens() {
+ let catalog = Catalog::default();
+ let first = catalog.reader().scan_slot().await.unwrap();
+ let second = catalog.reader().scan_slot().await.unwrap();
+ let queued_reader = catalog.reader();
+ let mut queued = Box::pin(queued_reader.scan_slot());
+ let pending = std::future::poll_fn(|cx| {
+ std::task::Poll::Ready(std::future::Future::poll(queued.as_mut(), cx).is_pending())
+ })
+ .await;
+ assert!(pending, "both scan slots are occupied");
+ catalog.cancel_pending();
+ let result = tokio::time::timeout(std::time::Duration::from_secs(1), queued)
+ .await
+ .expect("cancelled queued scan must not wait for an old slot");
+ assert!(matches!(result, Err(message) if message == CANCELLED));
+ drop((first, second));
+ assert!(catalog.reader().scan_slot().await.is_ok());
+ }
+
+ #[test]
+ fn replacing_a_reload_cancels_active_and_queued_readers() {
+ let catalog = Catalog::default();
+ let active = catalog.reader();
+ let queued = catalog.reader();
+ catalog.cancel_pending();
+ catalog.invalidate();
+ assert!(matches!(active.owner(), Err(message) if message == CANCELLED));
+ assert!(matches!(queued.owner(), Err(message) if message == CANCELLED));
+ assert!(catalog.reader().owner().is_ok());
+ }
+}
diff --git a/apps/maple-agent/app/src/ui/chat/sidebar_computers.rs b/apps/maple-agent/app/src/ui/chat/sidebar_computers.rs
index 7e0077475..642f8f31c 100644
--- a/apps/maple-agent/app/src/ui/chat/sidebar_computers.rs
+++ b/apps/maple-agent/app/src/ui/chat/sidebar_computers.rs
@@ -1,5 +1,5 @@
-//! The normal sidebar list, grouped by computer and folder when paired hosts
-//! exist. This is a summary projection, never a second task store.
+//! The sidebar's bounded projection across execution computers. Organization
+//! changes presentation only; every project and task keeps its owning host.
use super::*;
use crate::backend::ProjectPageRequest;
use crate::ui::chat::computers::{Computer, Destination, Navigate};
@@ -18,9 +18,45 @@ pub(super) struct ComputerPages {
scope: Option<(String, Option, bool)>,
hosts: HashMap, ComputerHostPage>,
more: Vec,
+ revalidation_pending: bool,
}
impl ComputerPages {
+ /// Manual order starts from every loaded summary, including folded groups.
+ pub(super) fn task_order_seeds(&self) -> Vec<(SidebarItemKey, i64, i64, bool)> {
+ self.hosts
+ .iter()
+ .flat_map(|(computer, page)| {
+ page.groups
+ .iter()
+ .flat_map(|group| group.tasks.iter())
+ .chain(page.active.iter())
+ .chain(page.settled.iter())
+ .chain(page.search.iter())
+ .chain(page.archived.iter())
+ .map(|task| {
+ (
+ SidebarItemKey {
+ computer: computer.clone(),
+ id: task.uuid.clone(),
+ },
+ task.created_ms,
+ task.updated_ms,
+ task.pinned_ms.is_some(),
+ )
+ })
+ })
+ .collect()
+ }
+
+ fn manual_reads_pending(&self) -> bool {
+ self.hosts.values().any(|page| {
+ page.loading
+ .iter()
+ .any(|key| key != "archive-count" && key != "projects")
+ })
+ }
+
pub(super) fn project_summaries(&self, computer: &Option) -> Option<&[ProjectSummary]> {
self.hosts
.get(computer)
@@ -38,6 +74,8 @@ impl ComputerPages {
page.groups
.iter()
.flat_map(|group| group.tasks.iter())
+ .chain(page.active.iter())
+ .chain(page.settled.iter())
.chain(page.search.iter())
.chain(page.archived.iter())
.map(|task| task.uuid.clone())
@@ -49,9 +87,13 @@ impl ComputerPages {
struct ComputerHostPage {
projects: Vec,
groups: Vec,
+ active: Vec,
+ settled: Vec,
search: Vec,
archived: Vec,
next_groups: Option,
+ next_active: Option,
+ next_settled: Option,
next_search: Option,
next_archived: Option,
next_projects: Option,
@@ -61,6 +103,7 @@ struct ComputerHostPage {
loading: HashSet,
errors: HashMap,
loaded: HashSet,
+ retained_heads: HashSet,
}
impl ComputerHostPage {
@@ -68,6 +111,8 @@ impl ComputerHostPage {
/// never use continuation cursors from before the refresh.
fn invalidate(&mut self) {
self.next_groups = None;
+ self.next_active = None;
+ self.next_settled = None;
self.next_search = None;
self.next_archived = None;
self.next_projects = None;
@@ -77,12 +122,16 @@ impl ComputerHostPage {
self.loading.clear();
self.loaded.clear();
self.errors.clear();
+ self.retained_heads.clear();
}
fn cursor_is_current(&self, kind: &ComputerPageKind, cursor: &Option) -> bool {
let expected = match kind {
+ ComputerPageKind::ArchiveCount => None,
ComputerPageKind::Projects => self.next_projects.as_ref(),
ComputerPageKind::Groups => self.next_groups.as_ref(),
+ ComputerPageKind::Tasks { settled: false } => self.next_active.as_ref(),
+ ComputerPageKind::Tasks { settled: true } => self.next_settled.as_ref(),
ComputerPageKind::Search => self.next_search.as_ref(),
ComputerPageKind::Archived => self.next_archived.as_ref(),
ComputerPageKind::Project { root, settled } => self
@@ -113,8 +162,10 @@ struct ComputerMore {
#[derive(Clone)]
enum ComputerPageKind {
+ ArchiveCount,
Projects,
Groups,
+ Tasks { settled: bool },
Search,
Project { root: String, settled: bool },
Archived,
@@ -123,8 +174,10 @@ enum ComputerPageKind {
impl ComputerPageKind {
fn key(&self) -> String {
match self {
+ Self::ArchiveCount => "archive-count".into(),
Self::Projects => "projects".into(),
Self::Groups => "groups".into(),
+ Self::Tasks { settled } => format!("tasks:{settled}"),
Self::Search => "search".into(),
Self::Project { root, settled } => format!("project:{settled}:{root}"),
Self::Archived => "archived".into(),
@@ -133,11 +186,104 @@ impl ComputerPageKind {
}
enum ComputerPageReply {
+ ArchiveCount(u64),
Projects(NavigationProjectPage),
Groups(NavigationGroupPage),
Tasks(NavigationTaskPage),
}
+async fn computer_task_page(
+ reader: catalog::Reader,
+ backend: Arc,
+ user: String,
+ query: catalog::TaskQuery,
+ manual: Option,
+) -> Result {
+ if let Some(order) = manual {
+ return reader.page(backend, user, query, order).await;
+ }
+ match query {
+ catalog::TaskQuery::Tasks(query) => backend.list_tasks(&user, query).await,
+ catalog::TaskQuery::Search(query) => backend.search_tasks(&user, query).await,
+ catalog::TaskQuery::Pinned(query) => backend.pinned_tasks(&user, query).await,
+ }
+}
+
+/// Project headers keep their host cursor. Task prefixes and their independent
+/// section continuations are projected from the desktop's complete inventory.
+async fn manual_computer_groups(
+ reader: catalog::Reader,
+ backend: Arc,
+ user: String,
+ mut page: NavigationGroupPage,
+ order: catalog::ManualOrder,
+) -> Result {
+ let mut remaining = 200usize;
+ for group in &mut page.groups {
+ let budget = remaining.min(20) as u16;
+ let active_query = NavigationTaskQuery {
+ section: TaskSection::State(TaskState::Active),
+ project: Some(group.project.root.clone()),
+ pins: PinFilter::Ignore,
+ cursor: None,
+ limit: budget,
+ };
+ let settled_query = NavigationTaskQuery {
+ section: TaskSection::State(TaskState::Settled),
+ ..active_query.clone()
+ };
+ // At most two scans run concurrently for this execution computer.
+ let (active, settled) = tokio::try_join!(
+ reader.clone().page(
+ backend.clone(),
+ user.clone(),
+ catalog::TaskQuery::Tasks(active_query.clone()),
+ order.clone(),
+ ),
+ reader.clone().page(
+ backend.clone(),
+ user.clone(),
+ catalog::TaskQuery::Tasks(settled_query.clone()),
+ order.clone(),
+ ),
+ )?;
+ let mut candidates = active
+ .tasks
+ .iter()
+ .chain(settled.tasks.iter())
+ .cloned()
+ .collect::>();
+ order.sort(&mut candidates);
+ candidates.truncate(usize::from(budget));
+ let settled_count = candidates
+ .iter()
+ .filter(|task| task.state == "settled")
+ .count();
+ let active_count = candidates.len() - settled_count;
+ group.tasks = candidates;
+ remaining -= group.tasks.len();
+ // Derive each continuation from this exact candidate snapshot. A
+ // section contributing no rows keeps a local start cursor when needed.
+ group.more.active = reader.prefix_cursor(
+ &backend,
+ &user,
+ &catalog::TaskQuery::Tasks(active_query),
+ &order,
+ &active,
+ active_count,
+ )?;
+ group.more.settled = reader.prefix_cursor(
+ &backend,
+ &user,
+ &catalog::TaskQuery::Tasks(settled_query),
+ &order,
+ &settled,
+ settled_count,
+ )?;
+ }
+ Ok(page)
+}
+
/// The bounded visible projection travels with the desktop's browse state.
/// Exact backend handles and the account fence it from a retired attachment.
pub(super) struct ComputerBrowseState {
@@ -161,6 +307,7 @@ fn computer_revision(computers: &[Computer]) -> u64 {
computer.host_epoch.hash(&mut hash);
computer.loading.hash(&mut hash);
computer.error.hash(&mut hash);
+ computer.pinned.hash(&mut hash);
// Loading an older page adds summaries to the snapshot. Only a new
// head or an update to the head invalidates these paging cursors.
let newest = computer.sessions.iter().map(|task| task.updated_ms).max();
@@ -229,6 +376,16 @@ fn snapshot_page(computer: &Computer, query: &str, archived_expanded: bool) -> C
.collect(),
..ComputerHostPage::default()
};
+ page.groups = page
+ .projects
+ .iter()
+ .cloned()
+ .map(|project| NavigationProjectGroup {
+ project,
+ tasks: Vec::new(),
+ more: Default::default(),
+ })
+ .collect();
for session in &computer.sessions {
if session.message_count == 0 && !computer.running.contains(&session.id) {
continue;
@@ -266,6 +423,10 @@ fn snapshot_page(computer: &Computer, query: &str, archived_expanded: bool) -> C
if archived_expanded {
page.archived.push(task.clone());
}
+ } else if state == "settled" {
+ page.settled.push(task.clone());
+ } else {
+ page.active.push(task.clone());
}
if !query.is_empty() {
if session.title.to_lowercase().contains(query)
@@ -305,29 +466,194 @@ fn snapshot_page(computer: &Computer, query: &str, archived_expanded: bool) -> C
page
}
-pub(super) struct ProjectHeading {
- request: Navigate,
- id: SharedString,
- label: SharedString,
- remote: bool,
-}
pub(super) struct OtherTask {
pub(super) request: Navigate,
pub(super) archived: bool,
+ pub(super) session: AgentSessionSummary,
+ pub(super) metadata: SharedString,
id: SharedString,
title: SharedString,
activity: Option,
- pinned: bool,
+ pub(super) pinned: bool,
}
impl Sidebar {
+ /// View fixtures supply bounded, verified owner snapshots rather than
+ /// asynchronous pages from the fixtures' deliberately empty stores.
+ #[cfg(test)]
+ pub(crate) fn seed_computer_snapshot_pages_for_test(&mut self) {
+ self.group_pages.generation = self.group_pages.generation.wrapping_add(1);
+ self.manual_catalog.cancel_pending();
+ self.group_pages.scope = Some((
+ self.filter.clone(),
+ self.project_filter.clone(),
+ self.archived_expanded,
+ ));
+ self.group_pages.hosts = self
+ .computers
+ .iter()
+ .map(|computer| {
+ assert!(computer.backend.is_some(), "fixture needs a verified owner");
+ let mut page = snapshot_page(computer, &self.filter, self.archived_expanded);
+ page.loaded.extend(
+ [
+ "archive-count",
+ "projects",
+ "groups",
+ "tasks:false",
+ "tasks:true",
+ "search",
+ "archived",
+ ]
+ .into_iter()
+ .map(str::to_owned),
+ );
+ (computer.key.clone(), page)
+ })
+ .collect();
+ self.rebuild_sections();
+ }
+
+ fn computer_task_pin(&self, computer: &Computer, task: &TaskSummary) -> Option {
+ if computer.key.is_none() {
+ return task.pinned_ms;
+ }
+ // Remote pins belong to the viewer, independently of pins in the
+ // execution computer's store. Prefer this view's immediate edits.
+ let pins = if computer.key.as_deref() == self.backend.remote_host() {
+ &self.pinned_tasks
+ } else {
+ &computer.pinned
+ };
+ pins.iter()
+ .position(|id| id == &task.uuid)
+ .map(|rank| i64::MAX - i64::try_from(rank).unwrap_or(i64::MAX))
+ }
+
+ /// Saved pins are already hydrated by the owning sidebar's bounded GetTasks
+ /// batches. Keep those verified summaries visible beyond the first page.
+ fn computer_pinned_summaries(&self, computer: &Computer) -> Vec {
+ let own = computer.key.as_deref() == self.backend.remote_host();
+ let pins = if own {
+ &self.pinned_tasks
+ } else {
+ &computer.pinned
+ };
+ let ranks = pins
+ .iter()
+ .enumerate()
+ .map(|(rank, id)| (id.as_str(), rank))
+ .collect::>();
+ let mut tasks = HashMap::::new();
+ for session in computer
+ .sessions
+ .iter()
+ .chain(self.sessions.iter().filter(|_| own))
+ {
+ if self
+ .project_filter
+ .as_ref()
+ .is_some_and(|root| !own || root != &session.project_root)
+ || (own && self.removed_projects.contains(&session.project_root))
+ {
+ continue;
+ }
+ let Some(rank) = ranks.get(session.id.as_str()) else {
+ continue;
+ };
+ if tasks
+ .get(&session.id)
+ .is_some_and(|task| task.updated_ms >= session.updated_ms)
+ {
+ continue;
+ }
+ let project = computer
+ .projects
+ .iter()
+ .find(|project| project.path == session.project_root);
+ let task = TaskSummary {
+ uuid: session.id.clone(),
+ title: session.title.clone(),
+ project_root: session.project_root.clone(),
+ project_display_name: project.map(|project| project.label.to_string()),
+ state: match session.state {
+ AgentTaskState::Active => "active",
+ AgentTaskState::Settled => "settled",
+ AgentTaskState::Archived => "archived",
+ }
+ .into(),
+ kind: if session.acp { "acp" } else { "desktop" }.into(),
+ pinned_ms: Some(i64::MAX - i64::try_from(*rank).unwrap_or(i64::MAX)),
+ web_enabled: session.web_enabled,
+ model: session.model.clone(),
+ message_count: u64::try_from(session.message_count).unwrap_or(u64::MAX),
+ created_ms: session.created_ms,
+ updated_ms: session.updated_ms,
+ truncated: false,
+ };
+ let task = self.current_computer_task(computer, &task);
+ if task.state != "archived"
+ && (task.message_count > 0
+ || computer.running.contains(&task.uuid)
+ || (own && self.running.contains(&task.uuid)))
+ {
+ tasks.insert(task.uuid.clone(), task);
+ }
+ }
+ tasks
+ .into_values()
+ .filter(|task| self.computer_task_matches(computer, task))
+ .collect()
+ }
+
+ fn computer_task_matches(&self, computer: &Computer, task: &TaskSummary) -> bool {
+ self.filter.is_empty()
+ || task.title.to_lowercase().contains(&self.filter)
+ || computer.label.to_lowercase().contains(&self.filter)
+ || self
+ .computer_project_name(
+ computer,
+ &ProjectSummary {
+ root: task.project_root.clone(),
+ display_name: task.project_display_name.clone(),
+ position: None,
+ last_used_ms: task.updated_ms,
+ name_revision: 0,
+ is_default_workspace: false,
+ truncated: false,
+ },
+ )
+ .to_lowercase()
+ .contains(&self.filter)
+ }
+
+ pub(super) fn has_added_computer(&self) -> bool {
+ self.computers.iter().any(|computer| computer.key.is_some())
+ }
+
+ pub(super) fn uses_computer_projection(&self) -> bool {
+ // Project navigation reads the owning host's scoped task pages. The
+ // cross-computer pages represent the unfiltered sidebar instead.
+ self.project_filter.is_none() && self.has_added_computer()
+ }
+
pub(in crate::ui::chat) fn set_computers(
&mut self,
computers: Arc>,
cx: &mut Context,
) {
+ let scope_changed = self.has_added_computer()
+ && !computers.iter().any(|computer| computer.key.is_some())
+ && self.project_filter.take().is_some();
let changed = computer_revision(&self.computers) != computer_revision(&computers)
|| existing_snapshot_changed(&self.computers, &computers);
+ let owners_changed = self.computers.len() != computers.len()
+ || self.computers.iter().any(|old| {
+ computers
+ .iter()
+ .find(|new| old.key == new.key)
+ .is_none_or(|new| !same_computer_owner(old, new))
+ });
if changed {
self.group_pages.hosts.retain(|key, _| {
self.computers
@@ -338,13 +664,25 @@ impl Sidebar {
});
}
self.computers = computers;
- if changed {
- self.revalidate_computer_pages(cx);
+ if self.view.group == SidebarGroup::Connection && !self.connection_grouping_available() {
+ self.view.group = SidebarGroup::Project;
+ let view = self.view;
+ crate::settings::update_settings_in_background(move |settings| {
+ settings.sidebar_layout = view;
+ });
+ }
+ if scope_changed && self.pages.enabled {
+ self.refresh_pages(cx);
+ } else if changed {
+ if owners_changed {
+ self.start_computer_revalidation(cx);
+ } else {
+ self.revalidate_computer_pages(cx);
+ }
} else {
self.ensure_computer_pages(cx);
}
- self.rebuild_computer_switcher_roots();
- self.rebuild_entries();
+ self.rebuild_sections();
self.list.remeasure_items(0..self.entries.len());
cx.notify();
}
@@ -373,6 +711,7 @@ impl Sidebar {
// Pending callbacks belong to the previous Sidebar entity. Fence this
// entity's earlier requests, and restart any inherited initial reads.
self.group_pages.generation = self.group_pages.generation.wrapping_add(1);
+ let mut inventory_changed = false;
state.pages.hosts.retain(|key, page| {
let owners = state
.computers
@@ -380,6 +719,7 @@ impl Sidebar {
.find(|computer| &computer.key == key)
.zip(self.computers.iter().find(|computer| &computer.key == key));
let Some((old, new)) = owners.filter(|(old, new)| same_computer_owner(old, new)) else {
+ inventory_changed = true;
return false;
};
let refreshing = self
@@ -393,10 +733,16 @@ impl Sidebar {
!= computer_revision(std::slice::from_ref(new))
|| existing_snapshot_changed(std::slice::from_ref(old), std::slice::from_ref(new))
{
+ inventory_changed = true;
page.invalidate();
}
true
});
+ self.manual_catalog.cancel_pending();
+ if inventory_changed {
+ self.manual_catalog.invalidate();
+ }
+ self.group_pages.revalidation_pending = false;
self.group_pages.hosts = state.pages.hosts;
self.group_pages.scope = Some(scope);
self.group_pages.more.clear();
@@ -410,6 +756,8 @@ impl Sidebar {
page.groups
.iter()
.flat_map(|group| group.tasks.iter())
+ .chain(page.active.iter())
+ .chain(page.settled.iter())
.chain(page.search.iter())
.chain(page.archived.iter())
.map(|task| {
@@ -435,10 +783,30 @@ impl Sidebar {
.unwrap_or_default();
self.merge_page_sessions(own_tasks);
self.ensure_computer_pages(cx);
- self.rebuild_computer_switcher_roots();
+ self.rebuild_computer_project_roots();
}
pub(super) fn revalidate_computer_pages(&mut self, cx: &mut Context) {
+ // Let the current Manual snapshot finish. Repeated activity only asks
+ // for one fresh trailing snapshot, rather than repeatedly cancelling
+ // useful work or filling the catalog's two scan slots with stale work.
+ if self.view.sort == SidebarSort::Manual && self.group_pages.manual_reads_pending() {
+ self.group_pages.revalidation_pending = true;
+ return;
+ }
+ self.start_computer_revalidation(cx);
+ }
+
+ fn finish_computer_revalidation(&mut self, cx: &mut Context) {
+ if self.group_pages.revalidation_pending && !self.group_pages.manual_reads_pending() {
+ self.start_computer_revalidation(cx);
+ }
+ }
+
+ fn start_computer_revalidation(&mut self, cx: &mut Context) {
+ self.group_pages.revalidation_pending = false;
+ self.manual_catalog.cancel_pending();
+ self.manual_catalog.invalidate();
self.group_pages.generation = self.group_pages.generation.wrapping_add(1);
for page in self.group_pages.hosts.values_mut() {
page.invalidate();
@@ -447,15 +815,23 @@ impl Sidebar {
}
pub(super) fn refresh_computer_pages(&mut self, cx: &mut Context) {
+ self.manual_catalog.cancel_pending();
+ self.group_pages.revalidation_pending = false;
self.group_pages.generation = self.group_pages.generation.wrapping_add(1);
- self.group_pages.hosts.clear();
+ // Ordering edits invalidate cursors, not the summaries already loaded
+ // beyond page one. A scope/owner change still discards them separately.
+ for page in self.group_pages.hosts.values_mut() {
+ let mut retained = page.retained_heads.clone();
+ retained.extend(page.loaded.iter().cloned());
+ page.invalidate();
+ page.retained_heads = retained;
+ }
self.group_pages.more.clear();
- self.group_pages.scope = None;
self.ensure_computer_pages(cx);
}
pub(super) fn ensure_computer_pages(&mut self, cx: &mut Context) {
- if self.computers.len() <= 1 {
+ if !self.uses_computer_projection() {
return;
}
let scope = (
@@ -464,6 +840,8 @@ impl Sidebar {
self.archived_expanded,
);
if self.group_pages.scope.as_ref() != Some(&scope) {
+ self.manual_catalog.cancel_pending();
+ self.group_pages.revalidation_pending = false;
self.group_pages.generation = self.group_pages.generation.wrapping_add(1);
self.group_pages.hosts.clear();
self.group_pages.scope = Some(scope);
@@ -482,48 +860,72 @@ impl Sidebar {
.collect::>();
for computer in hosts {
let page = self.group_pages.hosts.entry(computer.clone()).or_default();
- if !page.loaded.contains("projects")
- && !page.loading.contains("projects")
- && !page.errors.contains_key("projects")
+ if !page.loaded.contains("archive-count")
+ && !page.loading.contains("archive-count")
+ && !page.errors.contains_key("archive-count")
{
self.load_computer_page(
ComputerMore {
computer: computer.clone(),
generation: self.group_pages.generation,
- kind: ComputerPageKind::Projects,
+ kind: ComputerPageKind::ArchiveCount,
cursor: None,
- label: "Loading projects…".into(),
+ label: "Loading archived task count…".into(),
loading: false,
},
cx,
);
}
- if self.project_filter.is_some() {
- continue;
- }
let page = self.group_pages.hosts.entry(computer.clone()).or_default();
- let kind = if self.filter.is_empty() {
- ComputerPageKind::Groups
- } else {
- ComputerPageKind::Search
- };
- let key = kind.key();
- if !page.loaded.contains(&key)
- && !page.loading.contains(&key)
- && !page.errors.contains_key(&key)
+ if !page.loaded.contains("projects")
+ && !page.loading.contains("projects")
+ && !page.errors.contains_key("projects")
{
self.load_computer_page(
ComputerMore {
computer: computer.clone(),
generation: self.group_pages.generation,
- kind,
+ kind: ComputerPageKind::Projects,
cursor: None,
- label: "Loading tasks…".into(),
+ label: "Loading projects…".into(),
loading: false,
},
cx,
);
}
+ if self.project_filter.is_some() {
+ continue;
+ }
+ let kinds = if !self.filter.is_empty() {
+ vec![ComputerPageKind::Search]
+ } else if matches!(self.view.group, SidebarGroup::Status | SidebarGroup::List) {
+ vec![
+ ComputerPageKind::Tasks { settled: false },
+ ComputerPageKind::Tasks { settled: true },
+ ]
+ } else {
+ vec![ComputerPageKind::Groups]
+ };
+ for kind in kinds {
+ let page = self.group_pages.hosts.entry(computer.clone()).or_default();
+ let key = kind.key();
+ if !page.loaded.contains(&key)
+ && !page.loading.contains(&key)
+ && !page.errors.contains_key(&key)
+ {
+ self.load_computer_page(
+ ComputerMore {
+ computer: computer.clone(),
+ generation: self.group_pages.generation,
+ kind,
+ cursor: None,
+ label: "Loading tasks…".into(),
+ loading: false,
+ },
+ cx,
+ );
+ }
+ }
if self.archived_expanded && self.filter.is_empty() {
let page = self.group_pages.hosts.entry(computer.clone()).or_default();
if !page.loaded.contains("archived")
@@ -547,6 +949,10 @@ impl Sidebar {
}
fn load_computer_page(&mut self, action: ComputerMore, cx: &mut Context) {
+ if self.order_query_dirty {
+ self.refresh_task_order(cx);
+ return;
+ }
if action.generation != self.group_pages.generation {
return;
}
@@ -556,6 +962,8 @@ impl Sidebar {
let Some(backend) = computer.backend.clone() else {
return;
};
+ let manual = self.local_manual_order(&action.computer);
+ let reader = self.manual_catalog.reader();
let key = action.kind.key();
let page = self
.group_pages
@@ -599,70 +1007,98 @@ impl Sidebar {
self.call(
async move {
match &request.kind {
- ComputerPageKind::Projects => backend
- .list_projects(
- &user,
- ProjectPageRequest {
- cursor: request.cursor.clone(),
- limit: 50,
- },
- )
- .await
- .map(ComputerPageReply::Projects),
- ComputerPageKind::Groups => backend
+ ComputerPageKind::ArchiveCount => backend
.list_project_groups(
&user,
NavigationGroupQuery {
- limit_groups: 20,
- per_project: 20,
- cursor: request.cursor.clone(),
- },
- )
- .await
- .map(ComputerPageReply::Groups),
- ComputerPageKind::Search => backend
- .search_tasks(
- &user,
- NavigationSearchQuery {
- text: search_text,
- project,
- project_roots: matched_roots,
- cursor: request.cursor.clone(),
- limit: 100,
+ limit_groups: 1,
+ per_project: 1,
+ cursor: None,
},
)
.await
- .map(ComputerPageReply::Tasks),
- ComputerPageKind::Project { root, settled } => backend
- .list_tasks(
+ .map(|page| ComputerPageReply::ArchiveCount(page.archived_count)),
+ ComputerPageKind::Projects => backend
+ .list_projects(
&user,
- NavigationTaskQuery {
- section: TaskSection::State(if *settled {
- TaskState::Settled
- } else {
- TaskState::Active
- }),
- project: Some(root.clone()),
- pins: PinFilter::Ignore,
+ ProjectPageRequest {
cursor: request.cursor.clone(),
limit: 50,
},
)
.await
- .map(ComputerPageReply::Tasks),
- ComputerPageKind::Archived => backend
- .list_tasks(
- &user,
- NavigationTaskQuery {
- section: TaskSection::State(TaskState::Archived),
- project,
- pins: PinFilter::Ignore,
- cursor: request.cursor.clone(),
- limit: 50,
+ .map(ComputerPageReply::Projects),
+ ComputerPageKind::Groups => {
+ let groups = backend
+ .list_project_groups(
+ &user,
+ NavigationGroupQuery {
+ limit_groups: 20,
+ per_project: 20,
+ cursor: request.cursor.clone(),
+ },
+ )
+ .await?;
+ let groups = if let Some(order) = manual {
+ manual_computer_groups(reader, backend, user, groups, order).await?
+ } else {
+ groups
+ };
+ Ok(ComputerPageReply::Groups(groups))
+ }
+ ComputerPageKind::Search => computer_task_page(
+ reader,
+ backend,
+ user,
+ catalog::TaskQuery::Search(NavigationSearchQuery {
+ text: search_text,
+ project,
+ project_roots: matched_roots,
+ cursor: request.cursor.clone(),
+ limit: 100,
+ }),
+ manual,
+ )
+ .await
+ .map(ComputerPageReply::Tasks),
+ ComputerPageKind::Tasks { settled }
+ | ComputerPageKind::Project { settled, .. } => computer_task_page(
+ reader,
+ backend,
+ user,
+ catalog::TaskQuery::Tasks(NavigationTaskQuery {
+ section: TaskSection::State(if *settled {
+ TaskState::Settled
+ } else {
+ TaskState::Active
+ }),
+ project: match &request.kind {
+ ComputerPageKind::Project { root, .. } => Some(root.clone()),
+ _ => project,
},
- )
- .await
- .map(ComputerPageReply::Tasks),
+ pins: PinFilter::Ignore,
+ cursor: request.cursor.clone(),
+ limit: 50,
+ }),
+ manual,
+ )
+ .await
+ .map(ComputerPageReply::Tasks),
+ ComputerPageKind::Archived => computer_task_page(
+ reader,
+ backend,
+ user,
+ catalog::TaskQuery::Tasks(NavigationTaskQuery {
+ section: TaskSection::State(TaskState::Archived),
+ project,
+ pins: PinFilter::Ignore,
+ cursor: request.cursor.clone(),
+ limit: 50,
+ }),
+ manual,
+ )
+ .await
+ .map(ComputerPageReply::Tasks),
}
},
cx,
@@ -691,19 +1127,26 @@ impl Sidebar {
page.loading.remove(&key);
let result = match result {
Ok(reply) => reply,
+ Err(error) if error == catalog::CANCELLED => {
+ self.load_computer_page(action, cx);
+ return;
+ }
Err(error) => {
page.errors.insert(key, error);
+ self.finish_computer_revalidation(cx);
self.rebuild_entries();
cx.notify();
return;
}
};
+ let retain_head = action.cursor.is_none() && page.retained_heads.remove(&key);
page.loaded.insert(key);
let mut own_tasks = Vec::new();
let mut own_labels = Vec::new();
match result {
+ ComputerPageReply::ArchiveCount(count) => page.archived_count = count,
ComputerPageReply::Projects(reply) => {
- if action.cursor.is_none() {
+ if action.cursor.is_none() && !retain_head {
page.projects.clear();
}
page.next_projects = reply.next_cursor;
@@ -718,12 +1161,28 @@ impl Sidebar {
}
}
ComputerPageReply::Groups(reply) => {
- if action.cursor.is_none() {
+ if action.cursor.is_none() && !retain_head {
page.groups.clear();
}
- page.archived_count = reply.archived_count;
+ if !page.loaded.contains("archive-count") {
+ page.archived_count = reply.archived_count;
+ }
page.next_groups = reply.next_cursor;
for group in reply.groups {
+ // Group replies are authoritative project metadata too.
+ // Install it before the independent metadata page arrives
+ // so every visible header immediately has its actions.
+ if let Some(existing) = page
+ .projects
+ .iter_mut()
+ .find(|project| project.root == group.project.root)
+ {
+ if existing.name_revision <= group.project.name_revision {
+ *existing = group.project.clone();
+ }
+ } else {
+ page.projects.push(group.project.clone());
+ }
if own {
own_tasks.extend(group.tasks.iter().map(session_from_summary));
own_labels.extend(group.tasks.iter().map(|task| {
@@ -751,15 +1210,27 @@ impl Sidebar {
}));
}
match action.kind {
+ ComputerPageKind::Tasks { settled } => {
+ let (tasks, next) = if settled {
+ (&mut page.settled, &mut page.next_settled)
+ } else {
+ (&mut page.active, &mut page.next_active)
+ };
+ if action.cursor.is_none() && !retain_head {
+ tasks.clear();
+ }
+ *next = reply.next_cursor;
+ merge_tasks(tasks, reply.tasks);
+ }
ComputerPageKind::Search => {
- if action.cursor.is_none() {
+ if action.cursor.is_none() && !retain_head {
page.search.clear();
}
page.next_search = reply.next_cursor;
merge_tasks(&mut page.search, reply.tasks);
}
ComputerPageKind::Archived => {
- if action.cursor.is_none() {
+ if action.cursor.is_none() && !retain_head {
page.archived.clear();
}
page.next_archived = reply.next_cursor;
@@ -779,7 +1250,9 @@ impl Sidebar {
merge_tasks(&mut group.tasks, reply.tasks);
}
}
- ComputerPageKind::Groups | ComputerPageKind::Projects => {}
+ ComputerPageKind::ArchiveCount
+ | ComputerPageKind::Groups
+ | ComputerPageKind::Projects => {}
}
}
}
@@ -787,7 +1260,9 @@ impl Sidebar {
self.remember_task_project_labels(own_labels);
self.merge_page_sessions(own_tasks);
}
- self.rebuild_computer_switcher_roots();
+ self.load_missing_group_states(cx);
+ self.finish_computer_revalidation(cx);
+ self.rebuild_computer_project_roots();
self.rebuild_entries();
self.list.remeasure_items(0..self.entries.len());
cx.notify();
@@ -828,194 +1303,709 @@ impl Sidebar {
entries.push(SidebarEntry::ComputerMore(index));
}
- pub(super) fn computer_entries(&mut self) -> Vec {
- self.computer_projects.clear();
- self.other_tasks.clear();
- self.group_pages.more.clear();
- self.computer_archived_count = 0;
- let mut entries = vec![
- SidebarEntry::NewTask,
- SidebarEntry::Search,
- SidebarEntry::ProjectsHeader,
- ];
- let mut archived_entries = Vec::new();
- // These small clones let rendering append row projections without
- // borrowing the per-host paging cache for the whole rebuild.
- let computers = self.computers.clone();
- for (computer_index, computer) in computers.iter().enumerate() {
- let own = computer.key.as_deref() == self.backend.remote_host();
- if self.project_filter.is_some() && !own {
- continue;
- }
- let Some(page) = self.group_pages.hosts.get(&computer.key) else {
- entries.push(SidebarEntry::Computer(computer_index));
- continue;
- };
- self.computer_archived_count = self
- .computer_archived_count
- .saturating_add(usize::try_from(page.archived_count).unwrap_or(usize::MAX));
- let searching = !self.filter.is_empty();
- let mut groups = page.groups.clone();
- let search = page.search.clone();
- let archived = page.archived.clone();
- let next = if searching {
- page.next_search.clone()
- } else {
- page.next_groups.clone()
- };
- let next_archived = page.next_archived.clone();
- if searching {
- groups.clear();
- for task in search {
- if task.state == "archived" && !self.archived_expanded {
- continue;
- }
- if let Some(group) = groups
- .iter_mut()
- .find(|g| g.project.root == task.project_root)
- {
- group.tasks.push(task);
- } else {
- let project = computer
- .projects
- .iter()
- .find(|p| p.path == task.project_root);
- groups.push(NavigationProjectGroup {
- project: maple_agent::store::ProjectSummary {
- root: task.project_root.clone(),
- display_name: computer
- .project_names
- .get(&task.project_root)
- .cloned()
- .or_else(|| task.project_display_name.clone())
- .or_else(|| project.map(|p| p.label.to_string())),
- position: None,
- last_used_ms: task.updated_ms,
- name_revision: 0,
- is_default_workspace: false,
- truncated: false,
- },
- tasks: vec![task],
- more: Default::default(),
- });
- }
- }
+ /// Resolve a summary against a newer verified live snapshot before it
+ /// participates in ordering or status grouping.
+ fn current_computer_task(&self, computer: &Computer, task: &TaskSummary) -> TaskSummary {
+ let own = computer.key.as_deref() == self.backend.remote_host();
+ let latest = computer
+ .sessions
+ .iter()
+ .chain(self.sessions.iter().filter(|_| own))
+ .filter(|session| session.id == task.uuid && session.updated_ms >= task.updated_ms)
+ .max_by_key(|session| session.updated_ms);
+ let mut task = task.clone();
+ if let Some(session) = latest {
+ task.title.clone_from(&session.title);
+ task.created_ms = session.created_ms;
+ task.updated_ms = session.updated_ms;
+ task.message_count = u64::try_from(session.message_count).unwrap_or(u64::MAX);
+ task.state = match session.state {
+ AgentTaskState::Active => "active",
+ AgentTaskState::Settled => "settled",
+ AgentTaskState::Archived => "archived",
}
- if groups.is_empty() && (computer.backend.is_none() || computer.error.is_some()) {
- entries.push(SidebarEntry::Computer(computer_index));
+ .into();
+ }
+ if computer.running.contains(&task.uuid) || (own && self.running.contains(&task.uuid)) {
+ task.state = "active".into();
+ }
+ task.pinned_ms = self.computer_task_pin(computer, &task);
+ task
+ }
+
+ fn computer_project_groups(
+ &self,
+ computer: &Computer,
+ page: &ComputerHostPage,
+ ) -> Vec {
+ let searching = !self.filter.is_empty();
+ let own = computer.key.as_deref() == self.backend.remote_host();
+ let mut groups = if searching {
+ Vec::new()
+ } else {
+ page.groups.clone()
+ };
+ // Project metadata is independent of tasks. Keep empty projects visible
+ // even when their task page has not arrived, without claiming it empty.
+ for project in &page.projects {
+ let matches = !searching
+ || computer.label.to_lowercase().contains(&self.filter)
+ || self
+ .computer_project_name(computer, project)
+ .to_lowercase()
+ .contains(&self.filter);
+ if matches
+ && !groups
+ .iter()
+ .any(|group| group.project.root == project.root)
+ {
+ groups.push(NavigationProjectGroup {
+ project: project.clone(),
+ tasks: Vec::new(),
+ more: Default::default(),
+ });
}
- for mut group in groups {
- if own
- && self
- .project_filter
- .as_ref()
- .is_some_and(|root| root != &group.project.root)
- {
+ }
+ if searching {
+ for summary in &page.search {
+ let task = self.current_computer_task(computer, summary);
+ if task.state == "archived" {
continue;
}
- let root = group.project.root.clone();
- self.push_computer_heading(&mut entries, computer_index, computer, &group.project);
- group.tasks.sort_by_key(|task| {
- (
- task.state == "archived",
- task.state == "settled",
- task.pinned_ms.is_none(),
- std::cmp::Reverse(task.pinned_ms),
- std::cmp::Reverse(task.updated_ms),
- )
- });
- for task in &group.tasks {
- self.push_computer_task(&mut entries, computer_index, computer, task);
- }
- if !searching {
- self.computer_more_entry(
- &mut entries,
- &computer.key,
- ComputerPageKind::Project {
- root: root.clone(),
- settled: false,
- },
- group.more.active,
- "more active tasks",
- );
- self.computer_more_entry(
- &mut entries,
- &computer.key,
- ComputerPageKind::Project {
- root,
- settled: true,
+ if let Some(group) = groups
+ .iter_mut()
+ .find(|group| group.project.root == task.project_root)
+ {
+ group.tasks.push(task);
+ } else {
+ groups.push(NavigationProjectGroup {
+ project: ProjectSummary {
+ root: task.project_root.clone(),
+ display_name: task.project_display_name.clone(),
+ position: None,
+ last_used_ms: task.updated_ms,
+ name_revision: 0,
+ is_default_workspace: false,
+ truncated: false,
},
- group.more.settled,
- "more settled tasks",
- );
+ tasks: vec![task],
+ more: Default::default(),
+ });
}
}
- self.computer_more_entry(
- &mut entries,
- &computer.key,
- if searching {
- ComputerPageKind::Search
- } else {
- ComputerPageKind::Groups
- },
- next,
- if searching {
- "more matching tasks"
- } else {
- "more projects"
- },
- );
- if self.archived_expanded && !searching {
- let mut archived_groups: Vec<(ProjectSummary, Vec<&TaskSummary>)> = Vec::new();
- for task in &archived {
- if let Some((_, tasks)) = archived_groups
- .iter_mut()
- .find(|(project, _)| project.root == task.project_root)
- {
- tasks.push(task);
- } else {
- archived_groups.push((
- ProjectSummary {
- root: task.project_root.clone(),
- display_name: task.project_display_name.clone(),
- position: None,
- last_used_ms: task.updated_ms,
- name_revision: 0,
- is_default_workspace: false,
- truncated: false,
- },
- vec![task],
- ));
- }
+ } else {
+ for group in &mut groups {
+ group.tasks = group
+ .tasks
+ .iter()
+ .map(|task| self.current_computer_task(computer, task))
+ .filter(|task| task.state != "archived")
+ .collect();
+ }
+ }
+ for task in self.computer_pinned_summaries(computer) {
+ if let Some(group) = groups
+ .iter_mut()
+ .find(|group| group.project.root == task.project_root)
+ {
+ if !group
+ .tasks
+ .iter()
+ .any(|existing| existing.uuid == task.uuid)
+ {
+ group.tasks.push(task);
}
- for (project, tasks) in archived_groups {
- self.push_computer_heading(
- &mut archived_entries,
- computer_index,
- computer,
- &project,
- );
- for task in tasks {
- self.push_computer_task(
- &mut archived_entries,
- computer_index,
- computer,
- task,
- );
+ } else {
+ groups.push(NavigationProjectGroup {
+ project: page
+ .projects
+ .iter()
+ .find(|project| project.root == task.project_root)
+ .cloned()
+ .unwrap_or_else(|| ProjectSummary {
+ root: task.project_root.clone(),
+ display_name: task.project_display_name.clone(),
+ position: None,
+ last_used_ms: task.updated_ms,
+ name_revision: 0,
+ is_default_workspace: false,
+ truncated: false,
+ }),
+ tasks: vec![task],
+ more: Default::default(),
+ });
+ }
+ }
+ groups.retain(|group| {
+ (!own || !self.removed_projects.contains(&group.project.root))
+ && self
+ .project_filter
+ .as_ref()
+ .is_none_or(|root| own && root == &group.project.root)
+ });
+ groups
+ }
+
+ fn compare_computer_tasks(
+ &self,
+ left: &Option,
+ a: &TaskSummary,
+ right: &Option,
+ b: &TaskSummary,
+ ) -> std::cmp::Ordering {
+ let key = |computer, task: &TaskSummary| {
+ if task.state != "archived" && task.pinned_ms.is_some() {
+ self.pinned_task_order_key(computer, &task.uuid, task.created_ms, task.updated_ms)
+ } else {
+ self.task_order_key(computer, &task.uuid, task.created_ms, task.updated_ms)
+ }
+ };
+ key(left, a)
+ .cmp(&key(right, b))
+ .then_with(|| left.cmp(right))
+ .then_with(|| a.uuid.cmp(&b.uuid))
+ }
+
+ fn sort_computer_tasks(&self, tasks: &mut [(usize, TaskSummary)]) {
+ tasks.sort_by(|(left, a), (right, b)| {
+ self.compare_computer_tasks(
+ &self.computers[*left].key,
+ a,
+ &self.computers[*right].key,
+ b,
+ )
+ });
+ }
+
+ fn computer_group_prefix(
+ &self,
+ computer: &Computer,
+ group: &NavigationProjectGroup,
+ ) -> prefix::Prefix {
+ let page = self.group_pages.hosts.get(&computer.key);
+ // The continuation belongs to the received snapshot, before live state
+ // changes or Pinned extraction alter its presentation.
+ let source = page
+ .and_then(|page| {
+ page.groups
+ .iter()
+ .find(|stored| stored.project.root == group.project.root)
+ })
+ .map_or(group.tasks.as_slice(), |stored| stored.tasks.as_slice());
+ prefix::Prefix::new(
+ [false, true].map(|settled| {
+ let key = ComputerPageKind::Project {
+ root: group.project.root.clone(),
+ settled,
+ }
+ .key();
+ prefix::Stream {
+ source: settled,
+ end: source
+ .iter()
+ .filter(|task| (task.state == "settled") == settled)
+ .map(|task| {
+ self.task_prefix_position(
+ &computer.key,
+ &task.uuid,
+ task.created_ms,
+ task.updated_ms,
+ )
+ })
+ .max(),
+ complete: (if settled {
+ group.more.settled.is_none()
+ } else {
+ group.more.active.is_none()
+ }) && page.is_none_or(|page| {
+ !page.loading.contains(&key) && !page.errors.contains_key(&key)
+ }),
+ }
+ }),
+ self.view.sort == SidebarSort::Manual,
+ )
+ }
+
+ fn computer_flat_prefix(
+ &self,
+ hosts: &[usize],
+ state: Option,
+ ) -> prefix::Prefix<(usize, bool)> {
+ let streams = hosts.iter().flat_map(|&index| {
+ let computer = &self.computers[index];
+ let page = self.group_pages.hosts.get(&computer.key);
+ [false, true]
+ .into_iter()
+ .filter(move |settled| {
+ state.is_none_or(|state| state == *settled) && computer.backend.is_some()
+ })
+ .map(move |settled| {
+ let kind = ComputerPageKind::Tasks { settled };
+ let key = kind.key();
+ let tasks = page.map(|page| if settled { &page.settled } else { &page.active });
+ prefix::Stream {
+ source: (index, settled),
+ end: tasks
+ .into_iter()
+ .flatten()
+ .map(|task| {
+ self.task_prefix_position(
+ &computer.key,
+ &task.uuid,
+ task.created_ms,
+ task.updated_ms,
+ )
+ })
+ .max(),
+ complete: page.is_some_and(|page| {
+ !page.loading.contains(&key)
+ && !page.errors.contains_key(&key)
+ && if settled {
+ page.next_settled.is_none()
+ } else {
+ page.next_active.is_none()
+ }
+ }),
+ }
+ })
+ });
+ prefix::Prefix::new(streams, self.view.sort == SidebarSort::Manual)
+ }
+
+ fn prefix_exempt_task(&self, computer: &Computer, task: &TaskSummary) -> bool {
+ task.pinned_ms.is_some()
+ || computer.running.contains(&task.uuid)
+ || (computer.key.as_deref() == self.backend.remote_host()
+ && (self.selected.as_ref() == Some(&task.uuid)
+ || self.running.contains(&task.uuid)
+ || self.pages.is_live(&task.uuid)))
+ }
+
+ /// A group first page can spend its budget on just Active tasks. Read the
+ /// missing Settled prefix before presenting a merged list; zero-budget
+ /// groups retain their explicit More action instead of causing background
+ /// scans of projects past the visible row budget.
+ fn load_missing_group_states(&mut self, cx: &mut Context) {
+ if !self.filter.is_empty()
+ || matches!(self.view.group, SidebarGroup::Status | SidebarGroup::List)
+ {
+ return;
+ }
+ let mut actions = Vec::new();
+ for computer in self
+ .computers
+ .iter()
+ .filter(|computer| computer.backend.is_some())
+ {
+ let Some(page) = self.group_pages.hosts.get(&computer.key) else {
+ continue;
+ };
+ for group in page.groups.iter().filter(|group| !group.tasks.is_empty()) {
+ for settled in [false, true] {
+ let cursor = if settled {
+ &group.more.settled
+ } else {
+ &group.more.active
+ };
+ let kind = ComputerPageKind::Project {
+ root: group.project.root.clone(),
+ settled,
+ };
+ if cursor.is_some()
+ && !page.loading.contains(&kind.key())
+ && !page.errors.contains_key(&kind.key())
+ && !group
+ .tasks
+ .iter()
+ .any(|task| (task.state == "settled") == settled)
+ {
+ actions.push(ComputerMore {
+ computer: computer.key.clone(),
+ generation: self.group_pages.generation,
+ kind,
+ cursor: cursor.clone(),
+ label: "Loading tasks…".into(),
+ loading: false,
+ });
}
}
+ }
+ }
+ for action in actions {
+ self.load_computer_page(action, cx);
+ }
+ }
+
+ fn push_computer_group(
+ &mut self,
+ entries: &mut Vec,
+ computer: &Computer,
+ mut group: NavigationProjectGroup,
+ ) {
+ let target = ProjectTarget {
+ computer: computer.key.clone(),
+ path: group.project.root.clone(),
+ };
+ self.push_computer_heading(entries, computer, &group.project);
+ if self.collapsed_projects.contains(&target) {
+ return;
+ }
+ let prefix = self.computer_group_prefix(computer, &group);
+ if self.filter.is_empty() {
+ group.tasks.retain(|task| {
+ self.prefix_exempt_task(computer, task)
+ || prefix.allows(&self.task_prefix_position(
+ &computer.key,
+ &task.uuid,
+ task.created_ms,
+ task.updated_ms,
+ ))
+ });
+ }
+ group
+ .tasks
+ .sort_by(|a, b| self.compare_computer_tasks(&computer.key, a, &computer.key, b));
+ for task in &group.tasks {
+ self.push_computer_task(entries, computer, task);
+ }
+ if self.filter.is_empty() {
+ for (settled, cursor) in [(false, group.more.active), (true, group.more.settled)] {
+ if prefix.next.first() != Some(&settled) {
+ continue;
+ }
self.computer_more_entry(
- &mut archived_entries,
+ entries,
&computer.key,
- ComputerPageKind::Archived,
- next_archived,
- "more archived tasks",
+ ComputerPageKind::Project {
+ root: target.path.clone(),
+ settled,
+ },
+ cursor,
+ "more tasks",
);
}
}
- if self.computer_archived_count > 0 || !self.filter.is_empty() {
+ }
+
+ fn push_computer_flat_more(
+ &mut self,
+ entries: &mut Vec,
+ computer_index: usize,
+ settled: Option,
+ ) {
+ let computer = self.computers[computer_index].clone();
+ let Some(page) = self.group_pages.hosts.get(&computer.key) else {
+ return;
+ };
+ let (kind, cursor) = if !self.filter.is_empty() {
+ (ComputerPageKind::Search, page.next_search.clone())
+ } else if let Some(settled) = settled {
+ (
+ ComputerPageKind::Tasks { settled },
+ if settled {
+ page.next_settled.clone()
+ } else {
+ page.next_active.clone()
+ },
+ )
+ } else {
+ (ComputerPageKind::Groups, page.next_groups.clone())
+ };
+ self.computer_more_entry(
+ entries,
+ &computer.key,
+ kind,
+ cursor,
+ &format!("more from {}", computer.label),
+ );
+ }
+
+ pub(super) fn computer_entries(&mut self) -> Vec {
+ self.computer_projects.clear();
+ self.other_tasks.clear();
+ self.group_pages.more.clear();
+ self.computer_archived_count = 0;
+ let mut entries = vec![SidebarEntry::NewTask, SidebarEntry::Search];
+ // A mounted view projects only bounded, owner-fenced summary pages.
+ // Drafts, transcripts and execution remain in their owning ChatScreen.
+ let computers = self.computers.clone();
+ let mut hosts = (0..computers.len())
+ .filter(|&index| {
+ self.project_filter.is_none()
+ || computers[index].key.as_deref() == self.backend.remote_host()
+ })
+ .collect::>();
+ hosts.sort_by_cached_key(|&index| {
+ let computer = &computers[index].key;
+ (
+ self.order
+ .connections
+ .iter()
+ .position(|saved| saved == computer)
+ .unwrap_or(usize::MAX),
+ computer.clone(),
+ )
+ });
+ let mut groups = Vec::new();
+ let mut tasks = Vec::new();
+ let mut archived = Vec::new();
+ let mut unavailable = Vec::new();
+ let searching = !self.filter.is_empty();
+ let flat = matches!(self.view.group, SidebarGroup::Status | SidebarGroup::List);
+ for &index in &hosts {
+ let computer = &computers[index];
+ let Some(page) = self.group_pages.hosts.get(&computer.key) else {
+ unavailable.push(index);
+ continue;
+ };
+ if computer.backend.is_none() || computer.error.is_some() {
+ unavailable.push(index);
+ }
+ self.computer_archived_count = self
+ .computer_archived_count
+ .saturating_add(usize::try_from(page.archived_count).unwrap_or(usize::MAX));
+ // A disconnected attachment has no verified owner handle. Do not
+ // promote its snapshot into actionable task/project rows.
+ if computer.backend.is_none() {
+ continue;
+ }
+ if flat {
+ let pins = self.computer_pinned_summaries(computer);
+ let source = if searching {
+ page.search.iter().chain(pins.iter()).collect::>()
+ } else {
+ page.active
+ .iter()
+ .chain(&page.settled)
+ .chain(pins.iter())
+ .collect::>()
+ };
+ let mut seen = HashSet::new();
+ for summary in source {
+ let task = self.current_computer_task(computer, summary);
+ if task.state != "archived" && seen.insert(task.uuid.clone()) {
+ tasks.push((index, task));
+ }
+ }
+ } else {
+ groups.extend(
+ self.computer_project_groups(computer, page)
+ .into_iter()
+ .map(|group| (index, group)),
+ );
+ }
+ if self.archived_expanded {
+ let source = if searching {
+ &page.search
+ } else {
+ &page.archived
+ };
+ for summary in source {
+ let task = self.current_computer_task(computer, summary);
+ if task.state == "archived" {
+ archived.push((index, task));
+ }
+ }
+ }
+ }
+ let flat_prefix = self.computer_flat_prefix(&hosts, None);
+ let active_prefix = self.computer_flat_prefix(&hosts, Some(false));
+ let settled_prefix = self.computer_flat_prefix(&hosts, Some(true));
+ if flat && !searching {
+ tasks.retain(|(index, task)| {
+ let computer = &computers[*index];
+ let prefix = if self.view.group == SidebarGroup::Status {
+ if task.state == "settled" {
+ &settled_prefix
+ } else {
+ &active_prefix
+ }
+ } else {
+ &flat_prefix
+ };
+ self.prefix_exempt_task(computer, task)
+ || prefix.allows(&self.task_prefix_position(
+ &computer.key,
+ &task.uuid,
+ task.created_ms,
+ task.updated_ms,
+ ))
+ });
+ }
+ // Pins are a desktop view across computers, above every grouping.
+ // Keep the task's original project and saved order for unpinning.
+ let mut pinned = Vec::new();
+ let mut seen_pins = HashSet::new();
+ let mut take_pin = |index: usize, task: &TaskSummary| {
+ if task.pinned_ms.is_none() {
+ return true;
+ }
+ if seen_pins.insert((index, task.uuid.clone())) {
+ pinned.push((index, task.clone()));
+ }
+ false
+ };
+ for (index, group) in &mut groups {
+ group.tasks.retain(|task| take_pin(*index, task));
+ }
+ tasks.retain(|(index, task)| take_pin(*index, task));
+ self.sort_computer_tasks(&mut pinned);
+ let has_pins = !pinned.is_empty();
+ if has_pins {
+ entries.push(SidebarEntry::SectionLabel(SidebarSection::Pinned));
+ if self.section_expanded(SidebarSection::Pinned) {
+ for (index, task) in &pinned {
+ self.push_computer_task(&mut entries, &computers[*index], task);
+ }
+ }
+ }
+ entries.push(SidebarEntry::ProjectsHeader);
+ let group_start = entries.len();
+ groups.sort_by_cached_key(|(index, group)| {
+ let target = ProjectTarget {
+ computer: computers[*index].key.clone(),
+ path: group.project.root.clone(),
+ };
+ (
+ self.project_order_rank(&target),
+ target.computer,
+ group.project.position.unwrap_or(i64::MAX),
+ target.path,
+ )
+ });
+ self.sort_computer_tasks(&mut tasks);
+ self.sort_computer_tasks(&mut archived);
+ if self.projects_expanded {
+ match self.view.group {
+ SidebarGroup::Project => {
+ for (index, group) in groups {
+ self.push_computer_group(&mut entries, &computers[index], group);
+ }
+ for &index in &hosts {
+ self.push_computer_flat_more(&mut entries, index, None);
+ }
+ entries.extend(unavailable.iter().copied().map(SidebarEntry::Computer));
+ }
+ SidebarGroup::Connection => {
+ for &index in &hosts {
+ entries.push(SidebarEntry::Computer(index));
+ if self.collapsed_computers.contains(&computers[index].key) {
+ continue;
+ }
+ for (owner, group) in groups.iter().filter(|(owner, _)| *owner == index) {
+ self.push_computer_group(
+ &mut entries,
+ &computers[*owner],
+ group.clone(),
+ );
+ }
+ self.push_computer_flat_more(&mut entries, index, None);
+ }
+ }
+ SidebarGroup::Status => {
+ for (section, settled) in [
+ (SidebarSection::Active, false),
+ (SidebarSection::Settled, true),
+ ] {
+ let visible = tasks
+ .iter()
+ .filter(|(_, task)| (task.state == "settled") == settled);
+ if visible.clone().next().is_some() {
+ entries.push(SidebarEntry::SectionLabel(section));
+ }
+ if !self.section_expanded(section) {
+ continue;
+ }
+ for (index, task) in visible {
+ self.push_computer_task(&mut entries, &computers[*index], task);
+ }
+ if !searching {
+ let prefix = if settled {
+ &settled_prefix
+ } else {
+ &active_prefix
+ };
+ if let Some(&(index, state)) = prefix.next.first() {
+ self.push_computer_flat_more(&mut entries, index, Some(state));
+ }
+ }
+ }
+ if searching {
+ for &index in &hosts {
+ self.push_computer_flat_more(&mut entries, index, None);
+ }
+ }
+ entries.extend(unavailable.iter().copied().map(SidebarEntry::Computer));
+ }
+ SidebarGroup::List => {
+ for (index, task) in &tasks {
+ self.push_computer_task(&mut entries, &computers[*index], task);
+ }
+ if searching {
+ for &index in &hosts {
+ self.push_computer_flat_more(&mut entries, index, None);
+ }
+ } else if let Some(&(index, state)) = flat_prefix.next.first() {
+ self.push_computer_flat_more(&mut entries, index, Some(state));
+ }
+ entries.extend(unavailable.iter().copied().map(SidebarEntry::Computer));
+ }
+ }
+ }
+ let count_failed = hosts.iter().any(|index| {
+ self.group_pages
+ .hosts
+ .get(&computers[*index].key)
+ .is_some_and(|page| page.errors.contains_key("archive-count"))
+ });
+ if self.computer_archived_count > 0 || !archived.is_empty() || count_failed {
entries.push(SidebarEntry::ArchivedHeader);
- entries.extend(archived_entries);
+ for &index in &hosts {
+ let computer = &computers[index];
+ if self
+ .group_pages
+ .hosts
+ .get(&computer.key)
+ .is_some_and(|page| page.errors.contains_key("archive-count"))
+ {
+ self.computer_more_entry(
+ &mut entries,
+ &computer.key,
+ ComputerPageKind::ArchiveCount,
+ None,
+ &format!("archived task count from {}", computer.label),
+ );
+ }
+ }
+ if self.archived_expanded {
+ for (index, task) in archived {
+ self.push_computer_task(&mut entries, &computers[index], &task);
+ }
+ if !searching {
+ for &index in &hosts {
+ let computer = &computers[index];
+ let next = self
+ .group_pages
+ .hosts
+ .get(&computer.key)
+ .and_then(|page| page.next_archived.clone());
+ self.computer_more_entry(
+ &mut entries,
+ &computer.key,
+ ComputerPageKind::Archived,
+ next,
+ &format!("more archived tasks from {}", computer.label),
+ );
+ }
+ }
+ }
+ }
+ if entries.len() == group_start && !has_pins && self.projects_expanded {
+ entries.push(SidebarEntry::Empty(if searching {
+ SidebarEmpty::NoMatches
+ } else {
+ SidebarEmpty::NoTasks
+ }));
}
entries
}
@@ -1023,22 +2013,18 @@ impl Sidebar {
fn push_computer_heading(
&mut self,
entries: &mut Vec,
- computer_index: usize,
computer: &Computer,
project: &ProjectSummary,
) {
let heading = self.computer_projects.len();
let root = &project.root;
let label = self.computer_project_name(computer, project);
- self.computer_projects.push(ProjectHeading {
- request: Navigate {
- computer: computer.key.clone(),
- destination: Destination::Project(root.clone()),
- },
- id: format!("computer-{computer_index}-folder-{heading}").into(),
- label: format!("{} · {}", computer.label, label).into(),
- remote: computer.key.is_some(),
- });
+ let target = ProjectTarget {
+ computer: computer.key.clone(),
+ path: root.clone(),
+ };
+ self.computer_projects
+ .push(ProjectRow::new(target, label.into()));
entries.push(SidebarEntry::ComputerProject(heading));
}
@@ -1075,7 +2061,6 @@ impl Sidebar {
fn push_computer_task(
&mut self,
entries: &mut Vec,
- computer_index: usize,
computer: &Computer,
task: &TaskSummary,
) {
@@ -1088,8 +2073,8 @@ impl Sidebar {
}
entries.push(SidebarEntry::Task(SidebarTaskEntry {
session: index,
- pinned: task.pinned_ms.is_some(),
- settled: state == AgentTaskState::Settled,
+ pinned: self.computer_task_pin(computer, task).is_some(),
+ settled: state == AgentTaskState::Settled && !self.running.contains(&task.uuid),
archived: state == AgentTaskState::Archived,
}));
}
@@ -1106,17 +2091,42 @@ impl Sidebar {
return;
}
let index = self.other_tasks.len();
+ let session = session_from_summary(task);
+ let pinned = self.computer_task_pin(computer, task).is_some();
+ let metadata = if self.show_task_metadata(pinned, archived) {
+ format!(
+ "{} · {}",
+ self.computer_project_name(
+ computer,
+ &ProjectSummary {
+ root: task.project_root.clone(),
+ display_name: task.project_display_name.clone(),
+ position: None,
+ last_used_ms: task.updated_ms,
+ name_revision: 0,
+ is_default_workspace: false,
+ truncated: false,
+ }
+ ),
+ computer.label,
+ )
+ .into()
+ } else {
+ SharedString::default()
+ };
self.other_tasks.push(OtherTask {
archived,
+ session,
+ metadata,
request: Navigate {
computer: computer.key.clone(),
destination: Destination::Task(task.uuid.clone()),
},
- id: format!("computer-{computer_index}-task-{}", task.uuid).into(),
+ id: format!("computer-task-{:?}-{}", computer.key, task.uuid).into(),
title: latest
.map_or_else(|| task.title.clone(), |session| session.title.clone())
.into(),
- pinned: task.pinned_ms.is_some(),
+ pinned,
activity: if computer.running.contains(&task.uuid) {
Some(SessionActivity::Running)
} else if computer.unread.contains(&task.uuid) {
@@ -1138,7 +2148,11 @@ impl Sidebar {
}
let request = match entry {
SidebarEntry::ComputerProject(index) => {
- self.computer_projects.get(index)?.request.clone()
+ let target = &self.computer_projects.get(index)?.target;
+ Navigate {
+ computer: target.computer.clone(),
+ destination: Destination::Project(target.path.clone()),
+ }
}
SidebarEntry::OtherTask(index) => self.other_tasks.get(index)?.request.clone(),
SidebarEntry::Computer(index) => Navigate {
@@ -1150,6 +2164,18 @@ impl Sidebar {
Some(SidebarTarget::Computer(request))
}
+ pub(super) fn computer_more_scope(
+ &self,
+ index: usize,
+ ) -> Option<(Option, Option)> {
+ let action = self.group_pages.more.get(index)?;
+ let project = match &action.kind {
+ ComputerPageKind::Project { root, .. } => Some(root.clone()),
+ _ => None,
+ };
+ Some((action.computer.clone(), project))
+ }
+
pub(super) fn computer_more_id(&self, index: usize) -> String {
let action = &self.group_pages.more[index];
format!(
@@ -1177,10 +2203,38 @@ impl Sidebar {
true
}
+ pub(in crate::ui::chat) fn toggle_computer_group(
+ &mut self,
+ request: &Navigate,
+ cx: &mut Context,
+ ) -> bool {
+ match &request.destination {
+ Destination::Project(path) => {
+ let target = ProjectTarget {
+ computer: request.computer.clone(),
+ path: path.clone(),
+ };
+ if !self.collapsed_projects.remove(&target) {
+ self.collapsed_projects.insert(target);
+ }
+ }
+ Destination::Overview if self.view.group == SidebarGroup::Connection => {
+ if !self.collapsed_computers.remove(&request.computer) {
+ self.collapsed_computers.insert(request.computer.clone());
+ }
+ }
+ _ => return false,
+ }
+ self.rebuild_entries();
+ cx.notify();
+ true
+ }
+
pub(super) fn render_computer_entry(
&self,
entry: SidebarEntry,
selected: bool,
+ window: &mut Window,
cx: &mut Context,
) -> AnyElement {
let hover_bg = if selected {
@@ -1188,6 +2242,7 @@ impl Sidebar {
} else {
theme::bg_sidebar_row_hover()
};
+ let dragging = cx.has_active_drag();
match entry {
SidebarEntry::ComputerMore(index) => {
let action = self.group_pages.more[index].clone();
@@ -1220,44 +2275,7 @@ impl Sidebar {
.into_any_element()
}
SidebarEntry::ComputerProject(index) => {
- let project = &self.computer_projects[index];
- let request = project.request.clone();
- div()
- .id(project.id.clone())
- .role(gpui::Role::Button)
- .aria_label(project.label.clone())
- .mx_2()
- .my(px(1.))
- .mt_3()
- .px_2()
- .py_1p5()
- .rounded(ROW_RADIUS)
- .flex()
- .gap_2()
- .items_center()
- .text_xs()
- .text_color(gpui::rgb(theme::text_secondary()))
- .when(selected, |row| {
- row.aria_active_descendant()
- .bg(gpui::rgb(theme::bg_sidebar_row_hover()))
- })
- .hover(|s| s.bg(gpui::rgb(hover_bg)).cursor_pointer())
- .on_click(cx.listener(move |_, _, _, cx| {
- cx.emit(SidebarEvent::Navigate(request.clone()))
- }))
- .child(icon(
- if project.remote { "globe" } else { "folder" },
- px(14.),
- theme::text_muted(),
- ))
- .child(
- div()
- .flex_1()
- .min_w_0()
- .truncate()
- .child(project.label.clone()),
- )
- .into_any_element()
+ self.render_project_header(&self.computer_projects[index], window, cx)
}
SidebarEntry::OtherTask(index) => {
let task = &self.other_tasks[index];
@@ -1269,11 +2287,11 @@ impl Sidebar {
.aria_selected(false)
.mx_2()
.my(px(1.))
- .pl_6()
+ .pl(task_row_padding(window))
.pr_4()
.py_1()
.flex()
- .gap_2()
+ .gap_1p5()
.items_center()
.rounded(ROW_RADIUS)
.text_sm()
@@ -1282,7 +2300,13 @@ impl Sidebar {
row.aria_active_descendant()
.bg(gpui::rgb(theme::bg_sidebar_row_hover()))
})
- .hover(|s| s.bg(gpui::rgb(hover_bg)).cursor_pointer())
+ .hover(move |s| {
+ if dragging {
+ s
+ } else {
+ s.bg(gpui::rgb(hover_bg)).cursor_pointer()
+ }
+ })
.on_click(cx.listener(move |_, _, _, cx| {
cx.emit(SidebarEvent::Navigate(request.clone()))
}))
@@ -1290,9 +2314,24 @@ impl Sidebar {
div()
.flex_1()
.min_w_0()
- .line_clamp(1)
- .text_ellipsis()
- .child(task.title.clone()),
+ .flex()
+ .flex_col()
+ .child(
+ div()
+ .line_clamp(1)
+ .text_ellipsis()
+ .child(task.title.clone()),
+ )
+ .when(!task.metadata.is_empty(), |column| {
+ column.child(
+ div()
+ .text_xs()
+ .text_color(gpui::rgb(theme::text_secondary()))
+ .line_clamp(1)
+ .text_ellipsis()
+ .child(task.metadata.clone()),
+ )
+ }),
)
.when_some(task.activity, |row, activity| {
row.child(activity_indicator(&task.id, activity))
@@ -1304,18 +2343,42 @@ impl Sidebar {
}
SidebarEntry::Computer(index) => {
let computer = &self.computers[index];
+ let collapsible = self.view.group == SidebarGroup::Connection;
+ let expanded = !self.collapsed_computers.contains(&computer.key);
+ let status = computer.error.clone().or_else(|| {
+ if computer.loading {
+ Some("Connecting…".into())
+ } else if computer.backend.is_none() {
+ Some("Offline".into())
+ } else if computer.projects.is_empty() {
+ Some("No projects yet".into())
+ } else {
+ None
+ }
+ });
let request = Navigate {
computer: computer.key.clone(),
destination: Destination::Overview,
};
+ let disclosure_request = request.clone();
+ let action_group: SharedString =
+ format!("computer-header-actions-{:?}", computer.key).into();
+ let new_project = Navigate {
+ computer: computer.key.clone(),
+ destination: Destination::NewProject,
+ };
+ let new_project_label: SharedString =
+ format!("New project on {}", computer.label).into();
div()
- .id(SharedString::from(format!("computer-{index}")))
+ .id(SharedString::from(format!("computer-{:?}", computer.key)))
+ .group(action_group.clone())
.role(gpui::Role::Button)
.aria_label(computer.label.clone())
+ .when(collapsible, |row| row.aria_expanded(expanded))
.mx_2()
.my(px(1.))
.mt_3()
- .px_2()
+ .px(FOLDER_HEADER_PADDING - gpui::rems(0.5))
.py_2()
.rounded(ROW_RADIUS)
.flex()
@@ -1323,127 +2386,117 @@ impl Sidebar {
.gap_1()
.text_xs()
.text_color(gpui::rgb(theme::text_secondary()))
- .hover(|s| s.bg(gpui::rgb(hover_bg)).cursor_pointer())
- .on_click(cx.listener(move |_, _, _, cx| {
- cx.emit(SidebarEvent::Navigate(request.clone()))
- }))
- .child(computer.label.clone())
- .child(computer.error.clone().unwrap_or_else(|| {
- if computer.loading {
- "Connecting…"
+ .hover(move |s| {
+ if dragging {
+ s
} else {
- "No projects yet"
+ s.bg(gpui::rgb(hover_bg)).cursor_pointer()
+ }
+ })
+ .on_click(cx.listener(move |this, _, _, cx| {
+ if !this.toggle_computer_group(&request, cx) {
+ cx.emit(SidebarEvent::Navigate(request.clone()));
}
- .into()
}))
+ .child(
+ div()
+ .w_full()
+ .flex()
+ .items_center()
+ .gap(FOLDER_HEADER_GAP)
+ .child(
+ div()
+ .flex_none()
+ .relative()
+ .w(FOLDER_ICON_SIZE)
+ .h(FOLDER_ICON_SIZE)
+ .flex()
+ .items_center()
+ .justify_center()
+ .child(icon("monitor", FOLDER_ICON_SIZE, theme::text_muted()))
+ .when(collapsible, |slot| {
+ slot.child(
+ div()
+ .id("computer-disclosure")
+ .role(gpui::Role::Button)
+ .aria_label(if expanded {
+ "Collapse connection"
+ } else {
+ "Expand connection"
+ })
+ .aria_expanded(expanded)
+ .absolute()
+ .top_0()
+ .right(FOLDER_ICON_SIZE + px(3.))
+ .w(FOLDER_HEADER_PADDING - gpui::rems(0.5))
+ .h(FOLDER_ICON_SIZE)
+ .flex()
+ .items_center()
+ .justify_center()
+ .on_click(cx.listener(move |this, _, _, cx| {
+ cx.stop_propagation();
+ this.toggle_computer_group(
+ &disclosure_request,
+ cx,
+ );
+ }))
+ .child(icon(
+ if expanded {
+ "chevron-down"
+ } else {
+ "chevron-right"
+ },
+ px(12.),
+ theme::text_muted(),
+ )),
+ )
+ }),
+ )
+ .child(
+ div()
+ .flex_1()
+ .min_w_0()
+ .truncate()
+ .child(computer.label.clone()),
+ )
+ .when(
+ collapsible && !dragging && !self.sidebar_menu_open(),
+ |row| {
+ row.child(
+ div()
+ .flex_none()
+ .on_mouse_down(gpui::MouseButton::Left, |_, _, cx| {
+ cx.stop_propagation();
+ })
+ .child(
+ header_button(
+ "connection-new-project",
+ "folder-plus",
+ "New project",
+ false,
+ )
+ .aria_label(new_project_label)
+ .opacity(0.)
+ .group_hover(action_group, |style| {
+ style.opacity(1.)
+ })
+ .on_click(cx.listener(move |_, _, _, cx| {
+ cx.stop_propagation();
+ cx.emit(SidebarEvent::Navigate(
+ new_project.clone(),
+ ));
+ })),
+ ),
+ )
+ },
+ ),
+ )
+ .when_some(status, |row, status| row.child(status))
.into_any_element()
}
_ => div().into_any_element(),
}
}
-
- pub(super) fn computer_switcher_menu(
- &self,
- window: &mut Window,
- cx: &mut Context