Fix History restore and diff truncation edge cases

2026-06-18 20:44:57 +07:00
parent b3f81c0bf4
commit 00c57617d5
25 changed files with 717 additions and 127 deletions
@@ -0,0 +1,157 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+
+import { getE2EDaemonPort } from "./daemon-port";
+
+/**
+ * Restarts the isolated E2E daemon against the SAME PASEO_HOME and SAME port so
+ * persisted state reloads and existing clients can reconnect. This exercises the
+ * post-restart rehydration path (the daemon rebuilding workspace/agent links
+ * from disk), which is where the worktree-branch regression lives.
+ *
+ * The daemon is owned by Playwright's `globalSetup`, which keeps its child
+ * handle in module scope we can't reach from a spec. Instead we drive it the
+ * same way an operator would: read the supervisor PID from
+ * `$PASEO_HOME/paseo.pid`, SIGTERM it (the supervisor forwards the signal to its
+ * worker and releases the lock), wait for the port to free, then re-spawn the
+ * supervisor with the identical environment globalSetup used. The relay and
+ * Metro processes are untouched, so we reuse their already-published ports.
+ *
+ * This NEVER targets the developer daemon: the port comes from
+ * `getE2EDaemonPort()`, which refuses 6767, and PASEO_HOME is the isolated E2E
+ * home globalSetup created.
+ */
+
+function getEnvOrThrow(name: string): string {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`${name} is not set (expected from Playwright globalSetup).`);
+  }
+  return value;
+}
+
+async function readSupervisorPid(paseoHome: string): Promise<number> {
+  const pidPath = path.join(paseoHome, "paseo.pid");
+  const content = await readFile(pidPath, "utf8");
+  const parsed = JSON.parse(content) as { pid?: unknown };
+  if (typeof parsed.pid !== "number") {
+    throw new Error(`Malformed PID lock at ${pidPath}: ${content}`);
+  }
+  return parsed.pid;
+}
+
+function isPidRunning(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isPortListening(port: number, host = "127.0.0.1"): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = net.connect(port, host, () => {
+      socket.end();
+      resolve(true);
+    });
+    socket.setTimeout(1000, () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.on("error", () => resolve(false));
+  });
+}
+
+async function waitUntil(
+  predicate: () => Promise<boolean> | boolean,
+  options: { timeoutMs: number; label: string },
+): Promise<void> {
+  const deadline = Date.now() + options.timeoutMs;
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Timed out after ${options.timeoutMs}ms waiting for ${options.label}.`);
+}
+
+function spawnSupervisor(args: {
+  paseoHome: string;
+  port: string;
+  relayPort: string;
+  metroPort: string;
+  editorRecordPath: string;
+}): ChildProcess {
+  const serverDir = path.resolve(__dirname, "../../../..", "packages/server");
+  // Run the supervisor through the resolved tsx CLI under the current node
+  // binary. Spawning the `node_modules/.bin/tsx` shim directly is unreliable
+  // inside the Playwright worker (the shim is a .mjs symlink, not an executable),
+  // so resolve the CLI module and load it with node.
+  const tsxCli = createRequire(path.join(serverDir, "package.json")).resolve("tsx/cli");
+
+  const child = spawn(process.execPath, [tsxCli, "scripts/supervisor-entrypoint.ts", "--dev"], {
+    cwd: serverDir,
+    env: {
+      ...process.env,
+      PASEO_HOME: args.paseoHome,
+      PASEO_E2E_EDITOR_RECORD_PATH: args.editorRecordPath,
+      PASEO_SERVER_ID: "srv_e2e_test_daemon",
+      PASEO_LISTEN: `0.0.0.0:${args.port}`,
+      PASEO_RELAY_ENDPOINT: `127.0.0.1:${args.relayPort}`,
+      PASEO_CORS_ORIGINS: `http://localhost:${args.metroPort}`,
+      PASEO_NODE_ENV: "development",
+      NODE_ENV: "development",
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false,
+  });
+
+  child.stdout?.on("data", (data: Buffer) => {
+    for (const line of data.toString().split("\n")) {
+      if (line.trim()) console.log(`[daemon:restart] ${line.trim()}`);
+    }
+  });
+  child.stderr?.on("data", (data: Buffer) => {
+    for (const line of data.toString().split("\n")) {
+      if (line.trim()) console.error(`[daemon:restart] ${line.trim()}`);
+    }
+  });
+
+  // Detach our handles so the spawned supervisor outlives this spec process and
+  // is reaped by globalSetup's cleanup (the original process tree), not us.
+  child.unref();
+  return child;
+}
+
+export async function restartTestDaemon(): Promise<void> {
+  const port = getE2EDaemonPort();
+  const paseoHome = getEnvOrThrow("E2E_PASEO_HOME");
+  const relayPort = getEnvOrThrow("E2E_RELAY_PORT");
+  const metroPort = getEnvOrThrow("E2E_METRO_PORT");
+  const editorRecordPath =
+    process.env.E2E_EDITOR_RECORD_PATH ?? path.join(paseoHome, "editor-open-records.jsonl");
+
+  const pid = await readSupervisorPid(paseoHome);
+  process.kill(pid, "SIGTERM");
+
+  await waitUntil(() => !isPidRunning(pid), {
+    timeoutMs: 15_000,
+    label: `supervisor PID ${pid} to exit`,
+  });
+  await waitUntil(async () => !(await isPortListening(Number(port))), {
+    timeoutMs: 15_000,
+    label: `port ${port} to free`,
+  });
+
+  spawnSupervisor({ paseoHome, port, relayPort, metroPort, editorRecordPath });
+
+  await waitUntil(async () => isPortListening(Number(port)), {
+    timeoutMs: 30_000,
+    label: `restarted daemon to listen on port ${port}`,
+  });
+}