Make workspace IDs opaque, independent of the filesystem path (#1503)

* Make workspace IDs opaque, independent of the filesystem path Workspace IDs were the resolved checkout/worktree path, so code could treat an ID as a path: prefix matching, deriving directories from it, falling back to a path when a lookup missed. IDs are now opaque - compared only by exact equality and never used as a path. Anything path-shaped resolves the workspace record first and reads its cwd. New workspaces get a generated `wks_` ID; existing path-shaped IDs are read from disk and never regenerated, so there is no migration and no change to the wire or persisted schemas. Groundwork for running multiple workspaces in a single directory. * Keep attachment scope key stable and align refetch test The attachment scope key keeps `workspace=` instead of `wsid=` so existing persisted drafts are not orphaned; the rename was cosmetic. The SDK refetch test no longer asserts a filter, matching refetch fetching one page and selecting by id client-side. * Fix live agent updates in directories without a registered workspace The opaque-ID work removed buildProjectPlacementForCwd's directory fallback, so an agent running in a folder with no registered workspace (e.g. a fresh non-git dir) produced a null placement. forwardAgentUpdate then threw "Workspace not found", the error was swallowed by its catch, and no agent_update was emitted — live model/thinking switches and status updates silently stopped. Caught by the live-preferences e2e suite. The fallback builds a directory-scoped project placement keyed by the path. That key is a project grouping key (non-git projects group by path), not a workspace id, so it stays within the opaque-id rule. * Always run server worktree archive, even without a resolved workspace Archiving bailed out entirely when the workspace was not found in the client store, so a race or stale state could make "archive" do nothing server-side with only a console.warn. The server archive is keyed by worktreePath, which is always available, so it now runs regardless; only the optimistic client-side updates (keyed by workspace id) are gated on the workspace being resolved. * Expect a directory-scoped placement for unregistered agent dirs This unit test asserted the no-placement behavior reverted in the live agent-update fix, which had broken live model/thinking switching. Update it to expect the directory-scoped placement now emitted for an agent in a directory with no registered workspace. * Fix opaque workspace routing in app E2E * Preserve workspace IDs during partial bootstrap * Fix archive flows for opaque workspace IDs * Stop treating opaque workspace IDs as filesystem paths Workspace IDs are opaque (wks_<hex>), but several call sites still passed the id where a directory was expected, which broke those flows for opaque IDs. The branch switcher sent the id as a cwd to branch/stash/checkout git operations, and server archive/reconcile cleanup keyed git-watch and subscription teardown by id, leaking that state. Git and filesystem operations now take the workspace directory; the opaque id is used only for identity and cache keys. Archive/reconcile cleanup routes through a single teardownArchivedWorkspace helper that keeps the key split explicit: runtime store by id, git watch and subscription by cwd. Path-derived grouping keys are renamed to directory keys, and the helpers are split into workspace-identity and workspace-directory so the id-vs-path boundary is obvious.
2026-06-14 22:03:27 +08:00
parent f352072dac
commit 21deb08673
105 changed files with 1530 additions and 1045 deletions
@@ -14,6 +14,7 @@ export interface ArchiveTabAgent {
  id: string;
  title: string;
  cwd: string;
+  workspaceId: string;
 }

 function buildSeededStoragePayload() {
@@ -34,6 +35,10 @@ function buildSeededStoragePayload() {
 * idle agent from the same client it uses for everything else.
 */
 export interface IdleAgentSeedClient {
+  openProject(cwd: string): Promise<{
+    workspace: { id: string } | null;
+    error: string | null;
+  }>;
  createAgent(options: {
    provider: string;
    model: string;
@@ -52,6 +57,10 @@ export async function createIdleAgent(
  client: IdleAgentSeedClient,
  input: { cwd: string; title: string },
 ): Promise<ArchiveTabAgent> {
+  const opened = await client.openProject(input.cwd);
+  if (!opened.workspace) {
+    throw new Error(opened.error ?? `Failed to open project ${input.cwd}`);
+  }
  const created = await client.createAgent({
    provider: "opencode",
    model: "opencode/gpt-5-nano",
@@ -71,6 +80,7 @@ export async function createIdleAgent(
    id: created.id,
    title: input.title,
    cwd: input.cwd,
+    workspaceId: opened.workspace.id,
  };
 }

@@ -133,7 +143,7 @@ export async function openWorkspaceWithAgents(
 ): Promise<void> {
  const serverId = getServerId();
  for (const agent of agents) {
-    await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.cwd));
+    await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.workspaceId));

    // The workspace layout consumes `?open=agent:xxx`, returns null during the effect,
    // then replaces the URL with the clean workspace route after preparing the tab.
@@ -0,0 +1,40 @@
+import { expect, type Page } from "@playwright/test";
+import { escapeRegex } from "./regex";
+
+// The header branch switcher renders as a button whose accessible name carries the
+// current branch ("Current branch: <name>. Press to switch branch."). Matching on the
+// accessible name keeps these helpers tied to what a screen reader user hears, and it
+// proves the header resolved a real checkout directory from the opaque workspace id.
+function branchSwitcherTrigger(page: Page, branchName: string) {
+  return page
+    .getByRole("button", { name: new RegExp(`Current branch: ${escapeRegex(branchName)}\\b`) })
+    .filter({ visible: true })
+    .first();
+}
+
+export async function expectWorkspaceBranch(page: Page, branchName: string): Promise<void> {
+  await expect(branchSwitcherTrigger(page, branchName)).toBeVisible({ timeout: 30_000 });
+}
+
+export async function switchBranchFromHeader(
+  page: Page,
+  input: { from: string; to: string },
+): Promise<void> {
+  await branchSwitcherTrigger(page, input.from).click();
+
+  const picker = page.getByTestId("combobox-desktop-container");
+  await expect(picker).toBeVisible({ timeout: 30_000 });
+
+  // The branch switcher combobox renders its options as plain text rows with no ARIA
+  // role, so filter by the visible branch name and click the matching row. Filtering
+  // first guarantees a single, unambiguous match.
+  const search = page.getByPlaceholder("Filter branches...");
+  await expect(search).toBeVisible({ timeout: 30_000 });
+  await search.fill(input.to);
+
+  const option = picker.getByText(input.to, { exact: true });
+  await expect(option).toBeVisible({ timeout: 30_000 });
+  await option.click();
+
+  await expect(picker).not.toBeVisible({ timeout: 30_000 });
+}
@@ -166,7 +166,7 @@ export async function startRunningMockAgent(
    cwd: repo.path,
    model: opts.model,
  });
-  const agentUrl = `${buildHostWorkspaceRoute(serverId, repo.path)}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
+  const agentUrl = `${buildHostWorkspaceRoute(serverId, opened.workspace.id)}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
  await page.goto(agentUrl);
  await expectComposerVisible(page);
  await client.sendAgentMessage(agent.id, opts.prompt);
@@ -6,8 +6,8 @@ import { getServerId } from "./server-id";
 // ─── Navigation ────────────────────────────────────────────────────────────

 /** Navigate to a workspace and wait for the tab bar to appear. */
-export async function gotoWorkspace(page: Page, cwd: string): Promise<void> {
-  const route = buildHostWorkspaceRoute(getServerId(), cwd);
+export async function gotoWorkspace(page: Page, workspaceId: string): Promise<void> {
+  const route = buildHostWorkspaceRoute(getServerId(), workspaceId);
  await page.goto(route);
  await waitForTabBar(page);
 }
@@ -5,6 +5,7 @@ import { getServerId } from "./server-id";

 export interface MockAgentWorkspace {
  agentId: string;
+  workspaceId: string;
  cwd: string;
  client: SeedDaemonClient;
  cleanup(): Promise<void>;
@@ -40,6 +41,7 @@ export async function seedMockAgentWorkspace(
    });
    return {
      agentId: agent.id,
+      workspaceId: workspace.workspaceId,
      cwd: workspace.repoPath,
      client: workspace.client,
      cleanup: workspace.cleanup,
@@ -50,8 +52,8 @@ export async function seedMockAgentWorkspace(
  }
 }

-export function buildAgentRoute(cwd: string, agentId: string): string {
-  return `${buildHostWorkspaceRoute(getServerId(), cwd)}?open=${encodeURIComponent(
+export function buildAgentRoute(workspaceId: string, agentId: string): string {
+  return `${buildHostWorkspaceRoute(getServerId(), workspaceId)}?open=${encodeURIComponent(
    `agent:${agentId}`,
  )}`;
 }
@@ -59,9 +61,9 @@ export function buildAgentRoute(cwd: string, agentId: string): string {
 /** Boots the app directly at the agent's workspace route and waits for the open intent to settle. */
 export async function openAgentRoute(
  page: Page,
-  input: { cwd: string; agentId: string },
+  input: { workspaceId: string; agentId: string },
 ): Promise<void> {
-  await page.goto(buildAgentRoute(input.cwd, input.agentId));
+  await page.goto(buildAgentRoute(input.workspaceId, input.agentId));
  await page.waitForURL(
    (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
    { timeout: 60_000 },
@@ -3,7 +3,7 @@ import type { DaemonClient as InternalDaemonClient } from "@getpaseo/client/inte
 import { decodeWorkspaceIdFromPathSegment } from "@/utils/host-routes";
 import { connectDaemonClient } from "./daemon-client-loader";
 import { daemonWsRoutePattern } from "./daemon-port";
-import { expectWorkspaceHeader, workspaceLabelFromPath } from "./workspace-ui";
+import { expectWorkspaceHeader } from "./workspace-ui";

 type NewWorkspaceDaemonClient = Pick<
  InternalDaemonClient,
@@ -12,17 +12,20 @@ type NewWorkspaceDaemonClient = Pick<
  | "close"
  | "connect"
  | "createPaseoWorktree"
+  | "fetchWorkspaces"
  | "openProject"
 >;

 type OpenProjectPayload = Awaited<ReturnType<NewWorkspaceDaemonClient["openProject"]>>;
 type WorkspacePayload = Pick<OpenProjectPayload, "error" | "workspace">;
+type WorkspaceDescriptor = NonNullable<OpenProjectPayload["workspace"]>;

 export interface OpenedProject {
  workspaceId: string;
  projectKey: string;
  projectDisplayName: string;
  workspaceName: string;
+  workspaceDirectory: string;
 }

 function requireWorkspace(payload: WorkspacePayload) {
@@ -35,6 +38,39 @@ function requireWorkspace(payload: WorkspacePayload) {
  return payload.workspace;
 }

+function openedProjectFromWorkspace(workspace: WorkspaceDescriptor): OpenedProject {
+  return {
+    workspaceId: workspace.id,
+    projectKey: workspace.projectId,
+    projectDisplayName: workspace.projectDisplayName,
+    workspaceName: workspace.name,
+    workspaceDirectory: workspace.workspaceDirectory,
+  };
+}
+
+async function fetchWorkspaceById(
+  client: NewWorkspaceDaemonClient,
+  workspaceId: string,
+): Promise<WorkspaceDescriptor | null> {
+  const payload = await client.fetchWorkspaces();
+  return payload.entries.find((entry) => entry.id === workspaceId) ?? null;
+}
+
+async function waitForWorkspaceDescriptor(
+  client: NewWorkspaceDaemonClient,
+  workspaceId: string,
+): Promise<WorkspaceDescriptor> {
+  const deadline = Date.now() + 30_000;
+  while (Date.now() < deadline) {
+    const workspace = await fetchWorkspaceById(client, workspaceId);
+    if (workspace) {
+      return workspace;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(`Workspace descriptor not found: ${workspaceId}`);
+}
+
 function parseWorkspaceIdFromPageUrl(page: Page, serverId: string): string | null {
  const pathname = new URL(page.url()).pathname;
  const match = pathname.match(
@@ -57,24 +93,19 @@ export async function openProjectViaDaemon(
  repoPath: string,
 ): Promise<OpenedProject> {
  const workspace = requireWorkspace(await client.openProject(repoPath));
-  return {
-    workspaceId: workspace.id,
-    projectKey: workspace.projectId,
-    projectDisplayName: workspace.projectDisplayName,
-    workspaceName: workspace.name,
-  };
+  return openedProjectFromWorkspace(workspace);
 }

 export async function archiveWorkspaceFromDaemon(
  client: NewWorkspaceDaemonClient,
-  workspaceId: string,
+  workspaceDirectory: string,
 ): Promise<void> {
-  const payload = await client.archivePaseoWorktree({ worktreePath: workspaceId });
+  const payload = await client.archivePaseoWorktree({ worktreePath: workspaceDirectory });
  if (payload.error) {
    throw new Error(payload.error.message);
  }
  if (!payload.success) {
-    throw new Error(`Failed to archive workspace: ${workspaceId}`);
+    throw new Error(`Failed to archive workspace: ${workspaceDirectory}`);
  }
 }

@@ -100,12 +131,7 @@ export async function createWorktreeViaDaemon(
    worktreeSlug: input.slug,
  });
  const workspace = requireWorkspace(payload);
-  return {
-    workspaceId: workspace.id,
-    projectKey: workspace.projectId,
-    projectDisplayName: workspace.projectDisplayName,
-    workspaceName: workspace.name,
-  };
+  return openedProjectFromWorkspace(workspace);
 }

 export async function openNewWorkspaceComposer(
@@ -241,12 +267,13 @@ export async function assertNewWorkspaceSidebarAndHeader(
  page: Page,
  input: {
    serverId: string;
+    client: NewWorkspaceDaemonClient;
    previousWorkspaceId: string;
    projectDisplayName: string;
    assertSidebarRow?: boolean;
    assertHeader?: boolean;
  },
-): Promise<{ workspaceId: string }> {
+): Promise<{ workspaceId: string; workspaceName: string; workspaceDirectory: string }> {
  // Wait for URL to redirect to the newly created workspace.
  // Uses URL as source of truth to avoid picking up sidebar rows from concurrent tests.
  let workspaceId: string | null = null;
@@ -263,21 +290,27 @@ export async function assertNewWorkspaceSidebarAndHeader(
    throw new Error(`Expected URL to redirect to a new workspace.\nCurrent URL: ${page.url()}`);
  }

+  const workspace = await waitForWorkspaceDescriptor(input.client, workspaceId);
+
  if (input.assertSidebarRow !== false) {
    const createdWorkspaceRow = page.getByTestId(
-      `sidebar-workspace-row-${input.serverId}:${workspaceId}`,
+      `sidebar-workspace-row-${input.serverId}:${workspace.id}`,
    );
    await expect(createdWorkspaceRow.first()).toBeVisible({ timeout: 30_000 });
  }

  if (input.assertHeader !== false) {
    await expectWorkspaceHeader(page, {
-      title: workspaceLabelFromPath(workspaceId),
+      title: workspace.name,
      subtitle: input.projectDisplayName,
    });
  }

-  return { workspaceId };
+  return {
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
+    workspaceDirectory: workspace.workspaceDirectory,
+  };
 }

 type WebSocketMessage = string | Buffer;
@@ -14,6 +14,7 @@ export interface AgentHandle {
  page: Page;
  client: SeedDaemonClient;
  agentId: string;
+  workspaceId: string;
  cwd: string;
  provider: RewindFlowProvider;
 }
@@ -61,14 +62,17 @@ function fullAccessConfig(provider: RewindFlowProvider): ProviderLaunchConfig {
  }
 }

-function agentRoute(cwd: string, agentId: string): string {
-  return `${buildHostWorkspaceRoute(getServerId(), cwd)}?open=${encodeURIComponent(
+function agentRoute(workspaceId: string, agentId: string): string {
+  return `${buildHostWorkspaceRoute(getServerId(), workspaceId)}?open=${encodeURIComponent(
    `agent:${agentId}`,
  )}`;
 }

-async function openAgent(page: Page, input: { cwd: string; agentId: string }): Promise<void> {
-  await page.goto(agentRoute(input.cwd, input.agentId));
+async function openAgent(
+  page: Page,
+  input: { workspaceId: string; agentId: string },
+): Promise<void> {
+  await page.goto(agentRoute(input.workspaceId, input.agentId));
  await page.waitForURL(
    (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
    { timeout: 60_000 },
@@ -180,10 +184,11 @@ export async function launchAgent(input: {
    page: input.page,
    client,
    agentId: agent.id,
+    workspaceId: opened.workspace.id,
    cwd: input.cwd,
    provider: input.provider,
  };
-  await openAgent(input.page, { cwd: input.cwd, agentId: agent.id });
+  await openAgent(input.page, { workspaceId: opened.workspace.id, agentId: agent.id });
  return handle;
 }

@@ -13,6 +13,38 @@ export async function expectWorkspaceListed(page: Page, name: string): Promise<v
  ).toBeVisible({ timeout: 30_000 });
 }

+// The workspace row kebab and its menu items carry no web ARIA role, so the sidebar
+// suite addresses them by the stable test ids the app assigns per workspace — the same
+// convention the rename flow uses. The kebab only reveals on hover.
+export async function archiveWorktreeFromSidebar(page: Page, workspaceId: string): Promise<void> {
+  const serverId = getServerId();
+  const row = page.getByTestId(`sidebar-workspace-row-${serverId}:${workspaceId}`);
+  await expect(row).toBeVisible({ timeout: 30_000 });
+  await row.hover();
+
+  const kebab = page.getByTestId(`sidebar-workspace-kebab-${serverId}:${workspaceId}`);
+  await expect(kebab).toBeVisible({ timeout: 10_000 });
+  await kebab.click();
+
+  // A clean worktree archives with no prompt; if the host reports unsynced work the app
+  // raises a browser confirm. Accept it so the user-confirmed archive stays deterministic
+  // either way.
+  page.once("dialog", (dialog) => void dialog.accept());
+
+  const archiveItem = page.getByTestId(`sidebar-workspace-menu-archive-${serverId}:${workspaceId}`);
+  await expect(archiveItem).toBeVisible({ timeout: 10_000 });
+  await archiveItem.click();
+}
+
+export async function expectWorkspaceAbsentFromSidebar(
+  page: Page,
+  workspaceId: string,
+): Promise<void> {
+  await expect(
+    page.getByTestId(`sidebar-workspace-row-${getServerId()}:${workspaceId}`),
+  ).toHaveCount(0, { timeout: 30_000 });
+}
+
 export async function openMobileAgentSidebar(page: Page): Promise<void> {
  await page.getByRole("button", { name: "Open menu" }).click();
 }
@@ -38,7 +38,7 @@ export async function seedLongMockAgentTimeline(
 }

 export async function openAgentTimeline(page: Page, agent: LongTimelineAgent): Promise<void> {
-  await page.goto(buildAgentRoute(agent.cwd, agent.agentId));
+  await page.goto(buildAgentRoute(agent.workspaceId, agent.agentId));
  await page.waitForURL(
    (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
    { timeout: 60_000 },
@@ -261,7 +261,7 @@ export async function navigateToWorkspaceViaSidebar(
  await switchWorkspaceViaSidebar({
    page,
    serverId: getServerId(),
-    targetWorkspacePath: workspaceId,
+    workspaceId,
  });
 }

@@ -18,29 +18,8 @@ export async function waitForSidebarHydration(page: Page, timeout = 60_000): Pro
    .waitFor({ state: "visible", timeout });
 }

-export function workspaceLabelFromPath(value: string): string {
-  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
-  const parts = normalized.split("/").filter(Boolean);
-  return parts[parts.length - 1] ?? normalized;
-}
-
-function candidateWorkspaceIds(inputPath: string): string[] {
-  const trimmed = inputPath.replace(/\/+$/, "");
-  const candidates = new Set<string>([trimmed]);
-  if (trimmed.startsWith("/var/")) {
-    candidates.add(`/private${trimmed}`);
-  }
-  if (trimmed.startsWith("/private/var/")) {
-    candidates.add(trimmed.replace(/^\/private/, ""));
-  }
-  return Array.from(candidates);
-}
-
-function workspaceRowLocator(page: Page, serverId: string, workspacePath: string) {
-  const ids = candidateWorkspaceIds(workspacePath).map(
-    (id) => `[data-testid="sidebar-workspace-row-${serverId}:${id}"]`,
-  );
-  return page.locator(ids.join(",")).first();
+function workspaceRowLocator(page: Page, serverId: string, workspaceId: string) {
+  return page.getByTestId(`sidebar-workspace-row-${serverId}:${workspaceId}`).first();
 }

 export async function expectSidebarWorkspaceSelected(input: {
@@ -69,13 +48,13 @@ export async function expectSidebarWorkspaceSelected(input: {
 export async function switchWorkspaceViaSidebar(input: {
  page: Page;
  serverId: string;
-  targetWorkspacePath: string;
+  workspaceId: string;
 }): Promise<void> {
-  const row = workspaceRowLocator(input.page, input.serverId, input.targetWorkspacePath);
+  const row = workspaceRowLocator(input.page, input.serverId, input.workspaceId);
  await expect(row).toBeVisible({ timeout: 30_000 });
  await row.click();

-  const targetWorkspaceRoute = buildHostWorkspaceRoute(input.serverId, input.targetWorkspacePath);
+  const targetWorkspaceRoute = buildHostWorkspaceRoute(input.serverId, input.workspaceId);
  await expect(input.page).toHaveURL(new RegExp(escapeRegex(targetWorkspaceRoute)), {
    timeout: 30_000,
  });
@@ -89,11 +68,10 @@ export async function waitForWorkspaceInSidebar(
  page: Page,
  input: { serverId: string; workspaceId: string },
 ): Promise<void> {
-  const candidates = candidateWorkspaceIds(input.workspaceId);
-  const selector = candidates
-    .map((id) => `[data-testid="sidebar-workspace-row-${input.serverId}:${id}"]`)
-    .join(",");
-  await page.locator(selector).first().waitFor({ state: "visible", timeout: 60_000 });
+  await workspaceRowLocator(page, input.serverId, input.workspaceId).waitFor({
+    state: "visible",
+    timeout: 60_000,
+  });
 }

 export async function expectWorkspaceHeader(