WIP: workspace execution refactor + notification routing + setup store updates

packages/app/e2e/helpers/workspace-setup.ts

@@ -2,6 +2,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { pathToFileURL } from "node:url";
 import { expect, type Page } from "@playwright/test";
+import { parseHostWorkspaceRouteFromPathname } from "../../src/utils/host-routes";
 import { gotoAppShell } from "./app";
 
 type WorkspaceSetupProgressPayload = {
@@ -20,10 +21,52 @@ type WorkspaceSetupDaemonClient = {
   close(): Promise<void>;
   openProject(
     cwd: string,
-  ): Promise<{ workspace: { id: string; name: string } | null; error: string | null }>;
+  ): Promise<{
+    workspace: {
+      id: number;
+      name: string;
+      workspaceDirectory: string;
+      projectRootPath: string;
+    } | null;
+    error: string | null;
+  }>;
   createPaseoWorktree(
     input: { cwd: string; worktreeSlug?: string },
-  ): Promise<{ workspace: { id: string; name: string } | null; error: string | null }>;
+  ): Promise<{
+    workspace: {
+      id: number;
+      name: string;
+      workspaceDirectory: string;
+      projectRootPath: string;
+    } | null;
+    error: string | null;
+  }>;
+  fetchWorkspaces(): Promise<{
+    entries: Array<{
+      id: number;
+      name: string;
+      workspaceDirectory: string;
+      projectRootPath: string;
+    }>;
+  }>;
+  fetchAgents(): Promise<{
+    entries: Array<{
+      agent: { id: string; cwd: string; workspaceId?: string | null };
+    }>;
+  }>;
+  fetchAgent(
+    agentId: string,
+  ): Promise<{
+    agent: { id: string; cwd: string } | null;
+    project: unknown | null;
+  } | null>;
+  listTerminals(
+    cwd: string,
+  ): Promise<{
+    cwd?: string;
+    terminals: Array<{ id: string; cwd: string; name: string }>;
+    error?: string | null;
+  }>;
   subscribeRawMessages(handler: (message: WorkspaceSetupRawMessage) => void): () => void;
 };
 export type { WorkspaceSetupDaemonClient, WorkspaceSetupProgressPayload };
@@ -80,7 +123,12 @@ export function projectNameFromPath(repoPath: string): string {
 
 export async function openHomeWithProject(page: Page, repoPath: string): Promise<void> {
   await gotoAppShell(page);
-  await expect(createWorkspaceButton(page, repoPath)).toBeVisible({ timeout: 30_000 });
+  await expect(
+    page
+      .locator('[data-testid^="sidebar-project-row-"]')
+      .filter({ hasText: projectNameFromPath(repoPath) })
+      .first(),
+  ).toBeVisible({ timeout: 30_000 });
 }
 
 function createWorkspaceButton(page: Page, repoPath: string) {
@@ -90,14 +138,98 @@ function createWorkspaceButton(page: Page, repoPath: string) {
 }
 
 async function revealWorkspaceButton(page: Page, repoPath: string): Promise<void> {
-  await page.getByTestId(`sidebar-project-row-${repoPath}`).hover();
+  await page
+    .locator('[data-testid^="sidebar-project-row-"]')
+    .filter({ hasText: projectNameFromPath(repoPath) })
+    .first()
+    .hover();
 }
 
 export async function createWorkspaceFromSidebar(page: Page, repoPath: string): Promise<void> {
+  const button = createWorkspaceButton(page, repoPath);
   await revealWorkspaceButton(page, repoPath);
-  await expect(createWorkspaceButton(page, repoPath)).toBeEnabled({ timeout: 30_000 });
-  await createWorkspaceButton(page, repoPath).click();
+  await expect(button).toBeVisible({ timeout: 30_000 });
+  await expect(button).toBeEnabled({ timeout: 30_000 });
+  await button.click();
   await expect(page).toHaveURL(/\/workspace\//, { timeout: 30_000 });
+  await expect(page.getByTestId("workspace-setup-dialog")).toBeVisible({ timeout: 30_000 });
+}
+
+export async function getCurrentWorkspaceIdFromRoute(page: Page): Promise<string> {
+  await expect
+    .poll(
+      () => parseHostWorkspaceRouteFromPathname(new URL(page.url()).pathname)?.workspaceId ?? null,
+      { timeout: 30_000 },
+    )
+    .not.toBeNull();
+
+  const workspaceId =
+    parseHostWorkspaceRouteFromPathname(new URL(page.url()).pathname)?.workspaceId ?? null;
+  if (!workspaceId) {
+    throw new Error(`Expected a workspace route but found ${page.url()}`);
+  }
+
+  return workspaceId;
+}
+
+function workspaceSetupDialog(page: Page) {
+  return page.getByTestId("workspace-setup-dialog");
+}
+
+export async function createChatAgentFromWorkspaceSetup(
+  page: Page,
+  input: { message: string },
+): Promise<void> {
+  const dialog = workspaceSetupDialog(page);
+  await dialog.getByRole("button", { name: /Chat Agent/i }).click();
+
+  const messageInput = dialog.getByRole("textbox", { name: "Message agent..." }).first();
+  await expect(messageInput).toBeVisible({ timeout: 15_000 });
+  await messageInput.fill(input.message);
+
+  await dialog.getByRole("button", { name: "Send message" }).click();
+}
+
+export async function createTerminalAgentFromWorkspaceSetup(
+  page: Page,
+  input: { providerLabel: string; prompt?: string },
+): Promise<void> {
+  const dialog = workspaceSetupDialog(page);
+  await dialog.getByRole("button", { name: /Terminal Agent/i }).click();
+
+  const providerButton = dialog.getByRole("button", { name: new RegExp(`^${input.providerLabel}$`, "i") }).first();
+  await expect(providerButton).toBeVisible({ timeout: 15_000 });
+  await providerButton.click();
+
+  if (input.prompt) {
+    const promptInput = dialog.getByPlaceholder("Optional").first();
+    await expect(promptInput).toBeVisible({ timeout: 15_000 });
+    await promptInput.fill(input.prompt);
+  }
+
+  await dialog.getByRole("button", { name: "Launch" }).click();
+}
+
+export async function createStandaloneTerminalFromWorkspaceSetup(page: Page): Promise<void> {
+  await workspaceSetupDialog(page)
+    .getByRole("button", { name: /^Terminal Create the workspace/i })
+    .click();
+}
+
+export async function waitForWorkspaceSetupDialogToClose(page: Page, timeoutMs = 45_000): Promise<void> {
+  const dialog = workspaceSetupDialog(page);
+
+  try {
+    await expect(dialog).toHaveCount(0, { timeout: timeoutMs });
+  } catch (error) {
+    const dialogText = (await dialog.textContent().catch(() => null))?.replace(/\s+/g, " ").trim();
+    throw new Error(
+      dialogText
+        ? `Workspace setup dialog stayed open. Visible text: ${dialogText}`
+        : `Workspace setup dialog did not close within ${timeoutMs}ms`,
+      { cause: error },
+    );
+  }
 }
 
 export async function expectSetupPanel(page: Page): Promise<void> {
@@ -133,7 +265,58 @@ export async function createWorkspaceThroughDaemon(
   if (!result.workspace || result.error) {
     throw new Error(result.error ?? `Failed to create workspace for ${input.cwd}`);
   }
-  return result.workspace;
+  return {
+    id: String(result.workspace.id),
+    name: result.workspace.name,
+  };
+}
+
+export async function findWorktreeWorkspaceForProject(
+  client: WorkspaceSetupDaemonClient,
+  repoPath: string,
+): Promise<{
+  id: string;
+  name: string;
+  projectRootPath: string;
+  workspaceDirectory: string;
+}> {
+  const payload = await client.fetchWorkspaces();
+  const workspace =
+    payload.entries.find(
+      (entry) =>
+        entry.projectRootPath === repoPath && entry.workspaceDirectory !== repoPath,
+    ) ?? null;
+  if (!workspace) {
+    throw new Error(`Failed to find created worktree workspace for ${repoPath}`);
+  }
+  return {
+    id: String(workspace.id),
+    name: workspace.name,
+    projectRootPath: workspace.projectRootPath,
+    workspaceDirectory: workspace.workspaceDirectory,
+  };
+}
+
+export async function fetchWorkspaceById(
+  client: WorkspaceSetupDaemonClient,
+  workspaceId: string,
+): Promise<{
+  id: number;
+  name: string;
+  workspaceDirectory: string;
+  projectRootPath: string;
+}> {
+  const parsedWorkspaceId = Number(workspaceId);
+  if (!Number.isInteger(parsedWorkspaceId)) {
+    throw new Error(`Workspace id is not numeric: ${workspaceId}`);
+  }
+
+  const payload = await client.fetchWorkspaces();
+  const workspace = payload.entries.find((entry) => entry.id === parsedWorkspaceId) ?? null;
+  if (!workspace) {
+    throw new Error(`Workspace not found: ${workspaceId}`);
+  }
+  return workspace;
 }
 
 export async function waitForWorkspaceSetupProgress(

packages/app/e2e/sidebar-workspace.spec.ts

@@ -50,7 +50,10 @@ async function openProjectViaDaemon(
   if (!result.workspace || result.error) {
     throw new Error(result.error ?? `Failed to open project ${cwd}`);
   }
-  return result.workspace;
+  return {
+    id: String(result.workspace.id),
+    name: result.workspace.name,
+  };
 }
 
 async function openWorkspaceFromSidebar(page: import("@playwright/test").Page, workspaceId: string) {

packages/app/e2e/workspace-setup-runtime.spec.ts

@@ -0,0 +1,171 @@
+import { existsSync } from "node:fs";
+import { expect, test } from "./fixtures";
+import { createTempGitRepo } from "./helpers/workspace";
+import {
+  connectWorkspaceSetupClient,
+  createChatAgentFromWorkspaceSetup,
+  createStandaloneTerminalFromWorkspaceSetup,
+  createTerminalAgentFromWorkspaceSetup,
+  createWorkspaceFromSidebar,
+  findWorktreeWorkspaceForProject,
+  openHomeWithProject,
+  type WorkspaceSetupDaemonClient,
+} from "./helpers/workspace-setup";
+
+async function openWorkspaceSetupDialogFromSidebar(
+  page: import("@playwright/test").Page,
+  repoPath: string,
+): Promise<void> {
+  await openHomeWithProject(page, repoPath);
+  await createWorkspaceFromSidebar(page, repoPath);
+}
+
+async function expectCreatedWorkspaceRoute(
+  client: WorkspaceSetupDaemonClient,
+  originalProjectPath: string,
+) {
+  await expect
+    .poll(
+      async () => {
+        try {
+          return await findWorktreeWorkspaceForProject(client, originalProjectPath);
+        } catch {
+          return null;
+        }
+      },
+      { timeout: 30_000 },
+    )
+    .not.toBeNull();
+
+  const workspace = await findWorktreeWorkspaceForProject(client, originalProjectPath);
+
+  expect(workspace.workspaceDirectory).not.toBe(originalProjectPath);
+  expect(existsSync(workspace.workspaceDirectory)).toBe(true);
+  return workspace;
+}
+
+async function waitForNewWorkspaceAgent(
+  client: WorkspaceSetupDaemonClient,
+  expectedWorkspaceDirectory: string,
+  agentIdsBefore: Set<string>,
+) {
+  await expect
+    .poll(
+      async () => {
+        const payload = await client.fetchAgents();
+        return (
+          payload.entries.find(
+            (entry) =>
+              !agentIdsBefore.has(entry.agent.id) &&
+              entry.agent.cwd === expectedWorkspaceDirectory,
+          )?.agent ?? null
+        );
+      },
+      { timeout: 30_000 },
+    )
+    .not.toBeNull();
+
+  const payload = await client.fetchAgents();
+  const agent =
+    payload.entries.find(
+      (entry) =>
+        !agentIdsBefore.has(entry.agent.id) && entry.agent.cwd === expectedWorkspaceDirectory,
+    )?.agent ?? null;
+  if (!agent) {
+    throw new Error(`Expected a new agent for workspace ${expectedWorkspaceDirectory}`);
+  }
+  return agent;
+}
+
+test.describe("Workspace setup runtime authority", () => {
+  test.describe.configure({ retries: 1 });
+
+  test("first chat agent attaches to the created workspace", async ({ page }) => {
+    test.setTimeout(90_000);
+
+    const client = await connectWorkspaceSetupClient();
+    const repo = await createTempGitRepo("workspace-setup-chat-");
+
+    try {
+      await client.openProject(repo.path);
+      await openWorkspaceSetupDialogFromSidebar(page, repo.path);
+      const agentIdsBefore = new Set((await client.fetchAgents()).entries.map((entry) => entry.agent.id));
+
+      await createChatAgentFromWorkspaceSetup(page, {
+        message: `workspace-setup-chat-${Date.now()}`,
+      });
+
+      const workspace = await expectCreatedWorkspaceRoute(client, repo.path);
+      const agent = await waitForNewWorkspaceAgent(
+        client,
+        workspace.workspaceDirectory,
+        agentIdsBefore,
+      );
+      expect(agent.cwd).toBe(workspace.workspaceDirectory);
+      expect(agent.cwd).not.toBe(repo.path);
+    } finally {
+      await client.close();
+      await repo.cleanup();
+    }
+  });
+
+  test("first terminal agent attaches to the created workspace", async ({ page }) => {
+    test.setTimeout(90_000);
+
+    const client = await connectWorkspaceSetupClient();
+    const repo = await createTempGitRepo("workspace-setup-terminal-agent-");
+
+    try {
+      await client.openProject(repo.path);
+      await openWorkspaceSetupDialogFromSidebar(page, repo.path);
+      const agentIdsBefore = new Set((await client.fetchAgents()).entries.map((entry) => entry.agent.id));
+
+      await createTerminalAgentFromWorkspaceSetup(page, {
+        providerLabel: "Claude",
+        prompt: `workspace-setup-terminal-agent-${Date.now()}`,
+      });
+
+      const workspace = await expectCreatedWorkspaceRoute(client, repo.path);
+      const agent = await waitForNewWorkspaceAgent(
+        client,
+        workspace.workspaceDirectory,
+        agentIdsBefore,
+      );
+      expect(agent.cwd).toBe(workspace.workspaceDirectory);
+      expect(agent.cwd).not.toBe(repo.path);
+    } finally {
+      await client.close();
+      await repo.cleanup();
+    }
+  });
+
+  test("first terminal attaches to the created workspace", async ({ page }) => {
+    test.setTimeout(90_000);
+
+    const client = await connectWorkspaceSetupClient();
+    const repo = await createTempGitRepo("workspace-setup-terminal-");
+
+    try {
+      await client.openProject(repo.path);
+      await openWorkspaceSetupDialogFromSidebar(page, repo.path);
+
+      await createStandaloneTerminalFromWorkspaceSetup(page);
+
+      const workspace = await expectCreatedWorkspaceRoute(client, repo.path);
+
+      await expect
+        .poll(
+          async () =>
+            (await client.listTerminals(workspace.workspaceDirectory)).terminals.length > 0,
+          { timeout: 30_000 },
+        )
+        .toBe(true);
+      expect(
+        (await client.listTerminals(repo.path)).terminals.length,
+      ).toBe(0);
+    } finally {
+      await client.close();
+      await repo.cleanup();
+    }
+  });
+});