Simplify workspace reconnect gating

2026-05-03 13:50:20 +07:00
parent b2247450f9
commit fa20f313d3
9 changed files with 1310 additions and 333 deletions
@@ -68,6 +68,22 @@ terminalPerfDescribe("Terminal keystroke stress", () => {
    expect(appBaselineReport.outputFramePayloadBytes).toBeGreaterThanOrEqual(INPUT_TEXT.length);
    expect(appBaselineReport.keydownToXtermCommitMs?.count ?? 0).toBeGreaterThan(0);

+    const appObserveNodeBurstReport = await measureAppObservingNodeBurstEcho({
+      page,
+      harness,
+      terminalName: "app-observe-node-burst",
+    });
+    await attachJson(testInfo, "app-observe-node-burst", appObserveNodeBurstReport);
+    console.log(
+      "[terminal-stress-app-observe-node-burst]",
+      JSON.stringify(appObserveNodeBurstReport),
+    );
+
+    expect(appObserveNodeBurstReport.outputFramePayloadBytes).toBeGreaterThanOrEqual(
+      INPUT_TEXT.length,
+    );
+    expect(appObserveNodeBurstReport.xtermWriteCount).toBeGreaterThan(0);
+
    const appSmallChunksReport = await measureAppBurstEcho({
      page,
      harness,
@@ -172,6 +188,34 @@ async function measureAppBurstEcho(input: {
  }
 }

+async function measureAppObservingNodeBurstEcho(input: {
+  page: Page;
+  harness: TerminalE2EHarness;
+  terminalName: string;
+}) {
+  const appTerminal = await input.harness.createTerminal({ name: input.terminalName });
+  try {
+    await input.harness.openTerminal(input.page, { terminalId: appTerminal.id });
+    await input.harness.setupPrompt(input.page);
+
+    await resetTerminalKeystrokeStressProbe(input.page);
+
+    for (const char of INPUT_TEXT) {
+      input.harness.client.sendTerminalInput(appTerminal.id, {
+        type: "input",
+        data: char,
+      });
+    }
+
+    await waitForAppStressEcho(input.page, INPUT_TEXT);
+    await waitForAppProbePayload(input.page, INPUT_TEXT.length);
+
+    return readTerminalKeystrokeStressReport(input.page, INPUT_TEXT);
+  } finally {
+    await input.harness.killTerminal(appTerminal.id);
+  }
+}
+
 async function emitRapidAgentStreamUpdates(
  harness: TerminalE2EHarness,
  input: { agentId: string; count: number },
@@ -1,5 +1,6 @@
 import { buildHostWorkspaceRoute } from "@/utils/host-routes";
-import { expect, test } from "./fixtures";
+import type { WebSocketRoute } from "@playwright/test";
+import { expect, test, type Page } from "./fixtures";
 import { gotoAppShell } from "./helpers/app";
 import {
  archiveAgentFromDaemon,
@@ -27,9 +28,203 @@ import {
  waitForSidebarHydration,
 } from "./helpers/workspace-ui";

+const LOADING_WORKSPACE_TEXT_PATTERN = /Loading workspace/i;
+
+function escapeRegex(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+async function expectNoLoadingWorkspacePane(
+  page: Page,
+  input: { label: string; durationMs?: number },
+): Promise<void> {
+  const durationMs = input.durationMs ?? 2000;
+  const startedAt = Date.now();
+  const samples: string[] = [];
+
+  while (Date.now() - startedAt < durationMs) {
+    const url = page.url();
+    const text = await page
+      .locator("body")
+      .innerText({ timeout: 250 })
+      .catch((error) => `[body unavailable: ${error instanceof Error ? error.message : error}]`);
+    samples.push(`${Date.now() - startedAt}ms ${url}\n${text.slice(0, 1000)}`);
+
+    if (LOADING_WORKSPACE_TEXT_PATTERN.test(text)) {
+      throw new Error(
+        `${input.label}: loading workspace pane appeared during reconnect window.\n\n${samples.join(
+          "\n\n---\n\n",
+        )}`,
+      );
+    }
+
+    await page.waitForTimeout(100);
+  }
+}
+
+async function installDaemonWebSocketGate(page: Page, daemonPort: string) {
+  let acceptingConnections = true;
+  const activeSockets = new Set<WebSocketRoute>();
+
+  await page.routeWebSocket(new RegExp(`:${escapeRegex(daemonPort)}\\b`), (ws) => {
+    if (!acceptingConnections) {
+      void ws.close({ code: 1008, reason: "Blocked by workspace reconnect regression test." });
+      return;
+    }
+
+    activeSockets.add(ws);
+    const server = ws.connectToServer();
+
+    ws.onMessage((message) => {
+      if (!acceptingConnections) {
+        return;
+      }
+      try {
+        server.send(message);
+      } catch {
+        activeSockets.delete(ws);
+      }
+    });
+
+    server.onMessage((message) => {
+      if (!acceptingConnections) {
+        return;
+      }
+      try {
+        ws.send(message);
+      } catch {
+        activeSockets.delete(ws);
+      }
+    });
+  });
+
+  return {
+    async drop(): Promise<void> {
+      acceptingConnections = false;
+      const sockets = Array.from(activeSockets);
+      activeSockets.clear();
+      await Promise.all(
+        sockets.map((ws) =>
+          ws
+            .close({ code: 1008, reason: "Dropped by workspace reconnect regression test." })
+            .catch(() => undefined),
+        ),
+      );
+    },
+    restore(): void {
+      acceptingConnections = true;
+    },
+  };
+}
+
 test.describe("Workspace navigation regression", () => {
  test.describe.configure({ timeout: 240_000 });

+  test("keeps the workspace rendered while reconnecting to the host", async ({ page }) => {
+    const serverId = process.env.E2E_SERVER_ID;
+    const daemonPort = process.env.E2E_DAEMON_PORT;
+    if (!serverId) {
+      throw new Error("E2E_SERVER_ID is not set.");
+    }
+    if (!daemonPort) {
+      throw new Error("E2E_DAEMON_PORT is not set.");
+    }
+
+    const daemonGate = await installDaemonWebSocketGate(page, daemonPort);
+
+    const workspaceClient = await connectNewWorkspaceDaemonClient();
+    const workspaceIds = new Set<string>();
+    const repo = await createTempGitRepo("workspace-reconnect-");
+
+    try {
+      const workspace = await openProjectViaDaemon(workspaceClient, repo.path);
+      workspaceIds.add(workspace.workspaceId);
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await switchWorkspaceViaSidebar({
+        page,
+        serverId,
+        targetWorkspacePath: workspace.workspaceId,
+      });
+      await expectWorkspaceHeader(page, {
+        title: workspace.workspaceName,
+        subtitle: workspace.projectDisplayName,
+      });
+      await expect(page.getByTestId("workspace-tabs-row")).toBeVisible({ timeout: 30_000 });
+      await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeVisible({
+        timeout: 30_000,
+      });
+
+      await daemonGate.drop();
+      await expect(page.getByTestId("workspace-reconnect-banner")).toBeVisible({
+        timeout: 30_000,
+      });
+      await expectWorkspaceHeader(page, {
+        title: workspace.workspaceName,
+        subtitle: workspace.projectDisplayName,
+      });
+      await expect(page.getByTestId("workspace-tabs-row")).toBeVisible();
+      await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeVisible();
+      await expect(page.getByText(LOADING_WORKSPACE_TEXT_PATTERN)).toHaveCount(0);
+
+      const monitorReconnect = expectNoLoadingWorkspacePane(page, {
+        label: "host reconnect",
+      });
+      daemonGate.restore();
+      await expect(page.getByTestId("workspace-reconnect-banner")).toHaveCount(0, {
+        timeout: 30_000,
+      });
+      await monitorReconnect;
+      await expectWorkspaceHeader(page, {
+        title: workspace.workspaceName,
+        subtitle: workspace.projectDisplayName,
+      });
+      await expect(page.getByTestId("workspace-tabs-row")).toBeVisible();
+      await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeVisible();
+    } finally {
+      daemonGate.restore();
+      for (const workspaceId of workspaceIds) {
+        await archiveLocalWorkspaceFromDaemon(workspaceClient, workspaceId).catch(() => undefined);
+      }
+      await workspaceClient.close().catch(() => undefined);
+      await repo.cleanup();
+    }
+  });
+
+  test("cold offline workspace route gates the screen interior but keeps settings reachable", async ({
+    page,
+  }) => {
+    const serverId = process.env.E2E_SERVER_ID;
+    const daemonPort = process.env.E2E_DAEMON_PORT;
+    if (!serverId) {
+      throw new Error("E2E_SERVER_ID is not set.");
+    }
+    if (!daemonPort) {
+      throw new Error("E2E_DAEMON_PORT is not set.");
+    }
+
+    await page.routeWebSocket(new RegExp(`:${escapeRegex(daemonPort)}\\b`), async (ws) => {
+      await ws.close({ code: 1008, reason: "Blocked cold offline workspace route test." });
+    });
+
+    await page.goto(
+      `/h/${encodeURIComponent(serverId)}/workspace/${encodeURIComponent("/tmp/paseo-missing-workspace")}`,
+    );
+
+    await expect(
+      page.getByText(/Connecting to localhost|localhost is offline|Cannot reach localhost/i),
+    ).toBeVisible({ timeout: 30_000 });
+    await expect(page.getByTestId("menu-button")).toBeVisible();
+    await expect(page.getByTestId("workspace-header-title")).toHaveCount(0);
+    await expect(page.getByTestId("workspace-tabs-row")).toHaveCount(0);
+
+    const settingsButton = page.locator('[data-testid="sidebar-settings"]:visible').first();
+    await expect(settingsButton).toBeVisible({ timeout: 30_000 });
+    await settingsButton.click();
+    await expect(page).toHaveURL(/\/settings\/general$/);
+  });
+
  test("sidebar navigation and reload keep workspace selection and tabs aligned", async ({
    page,
  }) => {