Merge sidebar workspaces across all connected hosts (#1538)

* Merge workspaces across all hosts in the sidebar Replace per-host sidebar sections with a single merged project list. Projects that exist on multiple hosts (matched by projectKey) are collapsed into one row. Host identity is surfaced via: - A status-only footer pill showing online/offline host counts - Hover cards with a mandatory host row on every workspace entry - Subtitles showing the host name when a project spans >1 host - A host filter in the grouping dropdown (not a sidebar switcher) Order and group-mode stores migrated from per-server to global keys with zustand persist migrations. New-workspace screen now shows a merged project list with a host selector combobox. Key files: - workspace-structure.ts: merge algorithm by projectKey - sidebar-view-store.ts / sidebar-order-store.ts: global state - sidebar-workspace-list.tsx: context-based subtitle injection - new-workspace-screen.tsx: host selector in footer row * Add host filtering to the merged sidebar The sidebar now merges workspaces from every connected host, so a single global "active host" no longer fits. Host selection becomes explicit per action via a host chooser, and agent history pages across all hosts at once. Removes the active-host / active-server-id model and the all-agents-list hook that fed it. * Fix rebase fallout: translate archive host error, update stale workspace-key test archiveWorkspacesOptimistically used a raw "Host is not connected" string that the i18n completeness test forbids; route it through i18n.t with the existing hostDisconnected key. The selectors memoization test asserted un-prefixed workspace keys, but merged-sidebar keys are serverId-prefixed. * Fix sidebar review fallout * Address sidebar review followups * Fix sidebar workspace identity migration * Address sidebar review followups * Handle partial host history failures * Fix merged sidebar project removal and E2E drift * Restore history routes and project removal shape * Remove sidebar host context plumbing * Tighten sidebar status and host filter state * Keep new workspace project selection host-compatible * Migrate sidebar view storage * Streamline host selection flows * Update all-host history on archive * Fix empty project sidebar action Code regression: the main merge dropped the empty-project New workspace child row while keeping the empty project persistence contract. Restore the row using the project host target so the sidebar stays aligned with the no-host-selection model. * Fix Japanese shortcut translation key Stale-base integration: main added the Japanese locale after this branch added cycleAgentMode to the English shortcut help map. Merging main exposed the missing ja key in CI typecheck and resources.test. * Fix Playwright speech teardown race
2026-06-26 12:16:49 +08:00
parent 1109e453bc
commit a49c658d1f
103 changed files with 6856 additions and 2857 deletions
@@ -1,38 +1,44 @@
-import type { PrHint } from "@/git/use-pr-status-query";
-import {
-  canCreateWorktreeForProjectKind,
-  type HostProjectListItem,
-} from "@/projects/host-project-model";
-import type { WorkspaceDescriptor } from "@/stores/session-store";
-import type { WorkspaceStructureProject } from "@/projects/workspace-structure";
+import type { PrHint } from "@/git/pr-hint";
+import { selectPrHintFromStatus } from "@/git/pr-hint";
+import { type HostProjectListItem } from "@/projects/host-project-model";
+import type { PendingCreateAttempt } from "@/stores/create-flow-store";
+import type { Agent, WorkspaceDescriptor } from "@/stores/session-store";
+import type {
+  WorkspaceStructureHostPlacement,
+  WorkspaceStructureProject,
+} from "@/projects/workspace-structure";
+import { projectDisplayNameFromProjectId } from "@/utils/project-display-name";
+import { deriveSidebarStateBucket } from "@/utils/sidebar-agent-state";
+import { resolveWorkspaceMapKeyByIdentity } from "@/utils/workspace-identity";

 const EMPTY_PROJECTS: SidebarProjectEntry[] = [];

-function workspaceNameFromDirectory(directory: string): string {
-  const trimmed = directory.trim().replace(/[\\/]+$/g, "");
-  const separator = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
-  return separator >= 0 ? trimmed.slice(separator + 1) : trimmed;
-}
-
 export type SidebarStateBucket = WorkspaceDescriptor["status"];

-export interface SidebarWorkspaceEntry {
+export interface SidebarWorkspacePlacement {
  workspaceKey: string;
  serverId: string;
  workspaceId: string;
  projectKey: string;
+  projectName: string;
  projectRootPath?: string;
  workspaceDirectory?: string;
  projectKind: WorkspaceDescriptor["projectKind"];
  workspaceKind: WorkspaceDescriptor["workspaceKind"];
  name: string;
+}
+
+export interface SidebarStatusWorkspacePlacement extends SidebarWorkspacePlacement {
+  statusBucket: SidebarStateBucket;
+  statusEnteredAt: Date | null;
+}
+
+export interface SidebarWorkspaceEntry extends SidebarStatusWorkspacePlacement {
  // Raw user-set title (null when the name is derived from branch/directory).
  // Prefills the rename input and signals whether a reset is available.
  title: string | null;
  // Checkout branch (null when not a git checkout or detached HEAD).
  currentBranch: string | null;
-  statusBucket: SidebarStateBucket;
-  statusEnteredAt: Date | null;
  archivingAt: string | null;
  diffStat: { additions: number; deletions: number } | null;
  prHint: PrHint | null;
@@ -47,52 +53,278 @@ export interface SidebarProjectEntry {
  projectName: string;
  projectKind: WorkspaceDescriptor["projectKind"];
  iconWorkingDir: string;
-  canCreateWorktree: boolean;
-  workspaces: SidebarWorkspaceEntry[];
+  hosts: WorkspaceStructureHostPlacement[];
+  workspaces: SidebarWorkspacePlacement[];
+}
+
+export interface SidebarWorkspacePlacementModel {
+  workspaces: SidebarWorkspacePlacement[];
+  projects: SidebarProjectEntry[];
+  projectNamesByKey: Map<string, string>;
+}
+
+export interface SidebarStatusWorkspaceSession {
+  serverId: string;
+  workspaces: Map<string, WorkspaceDescriptor>;
+  agents?: Map<string, Agent>;
+}
+
+interface EffectiveWorkspaceStatus {
+  status: WorkspaceDescriptor["status"];
+  enteredAt: Date | null;
+}
+
+interface WorkspaceAgentActivity extends EffectiveWorkspaceStatus {}
+
+function projectNameForWorkspace(workspace: WorkspaceDescriptor, projectKey: string): string {
+  return (
+    workspace.projectCustomName ??
+    workspace.projectDisplayName ??
+    projectDisplayNameFromProjectId(projectKey)
+  );
+}
+
+function normalizeCurrentBranch(currentBranch: string | null | undefined): string | null {
+  if (!currentBranch) {
+    return null;
+  }
+  const trimmed = currentBranch.trim();
+  return trimmed.length === 0 || trimmed === "HEAD" ? null : trimmed;
+}
+
+export function createSidebarWorkspaceEntry(input: {
+  serverId: string;
+  workspace: WorkspaceDescriptor;
+  pendingCreateAttempts?: Record<string, PendingCreateAttempt>;
+  agents?: Map<string, Agent>;
+}): SidebarWorkspaceEntry {
+  const projectKey = input.workspace.project?.projectKey ?? input.workspace.projectId;
+  const effectiveStatus = deriveEffectiveWorkspaceStatus(input);
+  return {
+    workspaceKey: `${input.serverId}:${input.workspace.id}`,
+    serverId: input.serverId,
+    workspaceId: input.workspace.id,
+    projectKey,
+    projectName: projectNameForWorkspace(input.workspace, projectKey),
+    projectRootPath: input.workspace.projectRootPath,
+    workspaceDirectory: input.workspace.workspaceDirectory,
+    projectKind: input.workspace.projectKind,
+    workspaceKind: input.workspace.workspaceKind,
+    name: input.workspace.name,
+    title: input.workspace.title ?? null,
+    currentBranch: normalizeCurrentBranch(input.workspace.gitRuntime?.currentBranch),
+    statusBucket: effectiveStatus.status,
+    statusEnteredAt: effectiveStatus.enteredAt,
+    archivingAt: input.workspace.archivingAt,
+    diffStat: input.workspace.diffStat,
+    prHint: selectPrHintFromStatus(input.workspace.githubRuntime?.pullRequest),
+    archiveHasUncommittedChanges: input.workspace.gitRuntime?.isDirty ?? null,
+    archiveUnpushedCommitCount: input.workspace.gitRuntime?.aheadOfOrigin ?? null,
+    scripts: input.workspace.scripts,
+    hasRunningScripts: input.workspace.scripts.some((script) => script.lifecycle === "running"),
+  };
+}
+
+function deriveEffectiveWorkspaceStatus(input: {
+  serverId: string;
+  workspace: WorkspaceDescriptor;
+  pendingCreateAttempts?: Record<string, PendingCreateAttempt>;
+  agents?: Map<string, Agent>;
+}): EffectiveWorkspaceStatus {
+  if (input.workspace.status !== "done") {
+    return { status: input.workspace.status, enteredAt: input.workspace.statusEnteredAt };
+  }
+
+  const pendingStartedAt = getPendingInitialAgentCreateStartedAt({
+    serverId: input.serverId,
+    workspaceId: input.workspace.id,
+    pendingCreateAttempts: input.pendingCreateAttempts,
+  });
+  if (pendingStartedAt) {
+    return { status: "running", enteredAt: pendingStartedAt };
+  }
+
+  const rootAgentActivity = getRootAgentWorkspaceActivity({
+    workspace: input.workspace,
+    agents: input.agents,
+  });
+  if (rootAgentActivity && rootAgentActivity.status !== "done") {
+    return rootAgentActivity;
+  }
+
+  return { status: input.workspace.status, enteredAt: input.workspace.statusEnteredAt };
+}
+
+function getPendingInitialAgentCreateStartedAt(input: {
+  serverId: string;
+  workspaceId: string;
+  pendingCreateAttempts: Record<string, PendingCreateAttempt> | undefined;
+}): Date | null {
+  let latestStartedAt: Date | null = null;
+  for (const pending of Object.values(input.pendingCreateAttempts ?? {})) {
+    if (pending.serverId !== input.serverId) continue;
+    if (pending.workspaceId !== input.workspaceId) continue;
+    if (pending.lifecycle === "abandoned") continue;
+    const startedAt = new Date(pending.timestamp);
+    if (!latestStartedAt || startedAt > latestStartedAt) {
+      latestStartedAt = startedAt;
+    }
+  }
+  return latestStartedAt;
+}
+
+function getRootAgentWorkspaceActivity(input: {
+  workspace: WorkspaceDescriptor;
+  agents?: Map<string, Agent>;
+}): WorkspaceAgentActivity | null {
+  let latest: WorkspaceAgentActivity | null = null;
+  for (const agent of input.agents?.values() ?? []) {
+    if (agent.archivedAt || agent.parentAgentId) continue;
+    if (agent.workspaceId !== input.workspace.id) continue;
+    const status = deriveSidebarStateBucket({
+      status: agent.status,
+      pendingPermissionCount: agent.pendingPermissions.length,
+      requiresAttention: agent.requiresAttention,
+      attentionReason: agent.attentionReason,
+    });
+    const enteredAt = agent.attentionTimestamp ?? agent.updatedAt;
+    if (!latest || enteredAt > (latest.enteredAt ?? new Date(0))) {
+      latest = { status, enteredAt };
+    }
+  }
+  return latest;
+}
+
+export function buildSidebarWorkspacePlacementModel(input: {
+  projects: readonly HostProjectListItem[];
+}): SidebarWorkspacePlacementModel {
+  const projects = buildSidebarProjectsFromHostProjects({ projects: input.projects });
+  return {
+    projects,
+    workspaces: projects.flatMap((project) => project.workspaces),
+    projectNamesByKey: new Map(
+      projects.map((project) => [project.projectKey, project.projectName]),
+    ),
+  };
 }

 function createStructuralWorkspaceEntry(input: {
-  serverId: string;
  project: HostProjectListItem;
-  workspaceId: string;
-}): SidebarWorkspaceEntry {
+  workspaceKey: string;
+}): SidebarWorkspacePlacement {
+  const identity = resolveStructuralWorkspaceIdentity({
+    project: input.project,
+    workspaceKey: input.workspaceKey,
+  });
+
  return {
-    workspaceKey: `${input.serverId}:${input.workspaceId}`,
-    serverId: input.serverId,
-    workspaceId: input.workspaceId,
+    workspaceKey: identity.workspaceKey,
+    serverId: identity.serverId,
+    workspaceId: identity.workspaceId,
    projectKey: input.project.projectKey,
+    projectName: input.project.projectName,
    projectRootPath: input.project.iconWorkingDir,
    workspaceDirectory: undefined,
    projectKind: input.project.projectKind,
    workspaceKind: "checkout",
-    name: workspaceNameFromDirectory(input.project.iconWorkingDir) || input.workspaceId,
-    title: null,
-    currentBranch: null,
-    statusBucket: "done",
-    statusEnteredAt: null,
-    archivingAt: null,
-    diffStat: null,
-    prHint: null,
-    archiveHasUncommittedChanges: null,
-    archiveUnpushedCommitCount: null,
-    scripts: [],
-    hasRunningScripts: false,
+    name: identity.workspaceId,
  };
 }

-export function buildSidebarProjectsFromStructure(input: {
+function resolveStructuralWorkspaceIdentity(input: {
+  project: HostProjectListItem;
+  workspaceKey: string;
+}): {
+  workspaceKey: string;
  serverId: string;
+  workspaceId: string;
+} {
+  const hostsByLongestPrefix = [...input.project.hosts].sort(
+    (left, right) => right.serverId.length - left.serverId.length,
+  );
+
+  for (const host of hostsByLongestPrefix) {
+    const prefix = `${host.serverId}:`;
+    if (!input.workspaceKey.startsWith(prefix)) continue;
+    const workspaceId = input.workspaceKey.slice(prefix.length);
+    if (!workspaceId) continue;
+    return {
+      workspaceKey: input.workspaceKey,
+      serverId: host.serverId,
+      workspaceId,
+    };
+  }
+
+  const separatorIndex = input.workspaceKey.indexOf(":");
+  if (separatorIndex > 0) {
+    return {
+      workspaceKey: input.workspaceKey,
+      serverId: input.workspaceKey.slice(0, separatorIndex),
+      workspaceId: input.workspaceKey.slice(separatorIndex + 1),
+    };
+  }
+
+  const serverId = input.project.hosts[0]?.serverId ?? input.workspaceKey;
+  return {
+    workspaceKey: `${serverId}:${input.workspaceKey}`,
+    serverId,
+    workspaceId: input.workspaceKey,
+  };
+}
+
+export function buildSidebarStatusWorkspacePlacements(input: {
+  placements: readonly SidebarWorkspacePlacement[];
+  sessions: SidebarStatusWorkspaceSession[];
+  pendingCreateAttempts?: Record<string, PendingCreateAttempt>;
+}): SidebarStatusWorkspacePlacement[] {
+  if (input.placements.length === 0 || input.sessions.length === 0) {
+    return [];
+  }
+
+  const sessionByServerId = new Map(input.sessions.map((session) => [session.serverId, session]));
+  const rows: SidebarStatusWorkspacePlacement[] = [];
+
+  for (const placement of input.placements) {
+    const session = sessionByServerId.get(placement.serverId);
+    if (!session) continue;
+    const workspaceKey = resolveWorkspaceMapKeyByIdentity({
+      workspaces: session.workspaces,
+      workspaceId: placement.workspaceId,
+    });
+    const workspace = workspaceKey ? session.workspaces.get(workspaceKey) : null;
+    if (!workspace) continue;
+
+    const effectiveStatus = deriveEffectiveWorkspaceStatus({
+      serverId: placement.serverId,
+      workspace,
+      pendingCreateAttempts: input.pendingCreateAttempts,
+      agents: session.agents,
+    });
+
+    rows.push({
+      ...placement,
+      name: workspace.name,
+      workspaceDirectory: workspace.workspaceDirectory,
+      workspaceKind: workspace.workspaceKind,
+      statusBucket: effectiveStatus.status,
+      statusEnteredAt: effectiveStatus.enteredAt,
+    });
+  }
+
+  return rows;
+}
+
+export function buildSidebarProjectsFromStructure(input: {
  projects: WorkspaceStructureProject[];
 }): SidebarProjectEntry[] {
  return buildSidebarProjectsFromHostProjects({
    projects: input.projects.map((project) => ({
-      serverId: input.serverId,
      projectKey: project.projectKey,
      projectName: project.projectName,
      projectKind: project.projectKind,
      iconWorkingDir: project.iconWorkingDir,
+      hosts: project.hosts,
      workspaceKeys: project.workspaceKeys,
-      canCreateWorktree: canCreateWorktreeForProjectKind(project.projectKind),
    })),
  });
 }
@@ -109,12 +341,11 @@ export function buildSidebarProjectsFromHostProjects(input: {
    projectName: project.projectName,
    projectKind: project.projectKind,
    iconWorkingDir: project.iconWorkingDir,
-    canCreateWorktree: project.canCreateWorktree,
-    workspaces: project.workspaceKeys.map((workspaceId) =>
+    hosts: project.hosts,
+    workspaces: project.workspaceKeys.map((workspaceKey) =>
      createStructuralWorkspaceEntry({
-        serverId: project.serverId,
        project,
-        workspaceId,
+        workspaceKey,
      }),
    ),
  }));
@@ -227,11 +458,14 @@ export interface SidebarLoadingState {

 export function deriveSidebarLoadingState(input: {
  isActive: boolean;
-  serverId: string | null;
-  hasHydratedWorkspaces: boolean;
+  serverIds: string[];
+  hydratedServerIds: string[];
  hasProjects: boolean;
 }): SidebarLoadingState {
-  const isLoading = input.isActive && Boolean(input.serverId) && !input.hasHydratedWorkspaces;
+  const hasRegisteredHosts = input.serverIds.length > 0;
+  const allHydrated =
+    input.serverIds.length > 0 && input.serverIds.length === input.hydratedServerIds.length;
+  const isLoading = input.isActive && hasRegisteredHosts && !allHydrated;
  const isInitialLoad = isLoading && !input.hasProjects;
  return { isLoading, isInitialLoad, isRevalidating: false };
 }