test(e2e): verify isolated server ports

docs/testing.md

@@ -167,6 +167,7 @@ Test suites in this repo are heavy. Running them in bulk freezes the machine, es
 - Never run the full Playwright E2E suite locally — defer whole-suite verification to CI. Targeted Playwright specs are allowed when you changed or need to prove that specific flow.
 - App Playwright specs share one isolated daemon per run. Helpers that create projects or workspaces must remove the daemon project record during cleanup, not only delete the temp directory. Agent helpers must pass the intended `workspaceId` through to agent creation; never infer ownership from `cwd`.
 - CI can shard app Playwright across multiple jobs; each shard still owns a full isolated daemon/relay/Metro stack from global setup. Helpers that restart the daemon must preserve the global setup environment, including disabled speech/local-model settings, so a restart does not change the tested surface or start background downloads.
+- Global setup starts Metro before Wrangler, assigns Wrangler explicit distinct relay and inspector ports, and accepts Metro as ready only when `/status` returns `packager-status:running`. A generic TCP listener is not sufficient readiness evidence.
 
 ## Agent authentication in tests
 

packages/app/e2e/global-setup.ts

@@ -14,7 +14,7 @@ import { withDisabledE2ESpeechEnv } from "./helpers/speech-env";
 
 const wranglerCliPath = path.resolve(__dirname, "../node_modules/wrangler/bin/wrangler.js");
 
-interface WaitForServerOptions {
+export interface WaitForServerOptions {
   host?: string;
   timeoutMs?: number;
   label: string;
@@ -22,6 +22,8 @@ interface WaitForServerOptions {
   getRecentOutput?: () => string;
 }
 
+type ServerProbe = (host: string, port: number) => Promise<void>;
+
 async function getAvailablePort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const server = net.createServer();
@@ -75,7 +77,25 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-async function waitForServer(port: number, options: WaitForServerOptions): Promise<void> {
+async function connectToServer(host: string, port: number): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const socket = net.connect(port, host, () => {
+      socket.end();
+      resolve();
+    });
+    socket.setTimeout(1000, () => {
+      socket.destroy();
+      reject(new Error(`Connection timed out to ${host}:${port}`));
+    });
+    socket.on("error", reject);
+  });
+}
+
+async function waitForServer(
+  port: number,
+  options: WaitForServerOptions,
+  probe: ServerProbe = connectToServer,
+): Promise<void> {
   const { host = "127.0.0.1", timeoutMs = 15000, label, childProcess, getRecentOutput } = options;
   const start = Date.now();
   let lastConnectionError: unknown = null;
@@ -89,17 +109,7 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
     }
 
     try {
-      await new Promise<void>((resolve, reject) => {
-        const socket = net.connect(port, host, () => {
-          socket.end();
-          resolve();
-        });
-        socket.setTimeout(1000, () => {
-          socket.destroy();
-          reject(new Error(`Connection timed out to ${host}:${port}`));
-        });
-        socket.on("error", reject);
-      });
+      await probe(host, port);
       return;
     } catch (error) {
       lastConnectionError = error;
@@ -116,6 +126,22 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
   );
 }
 
+async function probeMetro(host: string, port: number): Promise<void> {
+  const response = await fetch(`http://${host}:${port}/status`, {
+    signal: AbortSignal.timeout(1000),
+  });
+  const body = (await response.text()).trim();
+  if (response.status !== 200 || body !== "packager-status:running") {
+    throw new Error(
+      `Expected Metro status on ${host}:${port}, received HTTP ${response.status}: ${JSON.stringify(body.slice(0, 200))}`,
+    );
+  }
+}
+
+export async function waitForMetro(port: number, options: WaitForServerOptions): Promise<void> {
+  await waitForServer(port, options, probeMetro);
+}
+
 function parseRelayStartupFailure(line: string): string | null {
   const clean = stripAnsi(line);
   if (/Address already in use/i.test(clean)) {
@@ -556,13 +582,19 @@ async function getAvailablePortExcluding(excludedPorts: Set<number>): Promise<nu
   }
 }
 
-async function startRelay(excludedPorts: Set<number>): Promise<number> {
+interface RelayPorts {
+  relayPort: number;
+  inspectorPort: number;
+}
+
+async function startRelay(excludedPorts: Set<number>): Promise<RelayPorts> {
   const relayDir = path.resolve(__dirname, "..", "..", "relay");
   const maxRelayStartupAttempts = 5;
   let lastRelayStartupError: unknown = null;
 
   for (let attempt = 1; attempt <= maxRelayStartupAttempts; attempt += 1) {
     const relayPort = await getAvailablePortExcluding(excludedPorts);
+    const inspectorPort = await getAvailablePortExcluding(new Set([...excludedPorts, relayPort]));
     const buffer = createLineBuffer();
     const state: RelayStreamState = { failureLine: null, readyForSelectedPort: false };
 
@@ -576,6 +608,10 @@ async function startRelay(excludedPorts: Set<number>): Promise<number> {
         "127.0.0.1",
         "--port",
         String(relayPort),
+        "--inspector-ip",
+        "127.0.0.1",
+        "--inspector-port",
+        String(inspectorPort),
         "--live-reload=false",
         "--show-interactive-dev-session=false",
       ],
@@ -590,7 +626,7 @@ async function startRelay(excludedPorts: Set<number>): Promise<number> {
 
     try {
       await awaitRelayReady(relayProcess, relayPort, state, buffer);
-      return relayPort;
+      return { relayPort, inspectorPort };
     } catch (error) {
       lastRelayStartupError = error;
       await stopProcess(relayProcess);
@@ -767,12 +803,19 @@ export default async function globalSetup() {
   await logSpeechHarnessConfig();
 
   try {
-    const relayPort = await startRelay(new Set([port, metroPort]));
     metroProcess = startMetro({
       metroPort,
       daemonPort: port,
       buffer: metroLineBuffer,
     });
+    await waitForMetro(metroPort, {
+      label: "Metro web server",
+      timeoutMs: 120000,
+      childProcess: metroProcess,
+      getRecentOutput: metroLineBuffer.dump,
+    });
+
+    const { relayPort, inspectorPort } = await startRelay(new Set([port, metroPort]));
     daemonProcess = startDaemon({
       port,
       relayPort,
@@ -783,19 +826,11 @@ export default async function globalSetup() {
       buffer: daemonLineBuffer,
     });
 
-    await Promise.all([
-      waitForServer(port, {
-        label: "Paseo daemon",
-        childProcess: daemonProcess,
-        getRecentOutput: daemonLineBuffer.dump,
-      }),
-      waitForServer(metroPort, {
-        label: "Metro web server",
-        timeoutMs: 120000,
-        childProcess: metroProcess,
-        getRecentOutput: metroLineBuffer.dump,
-      }),
-    ]);
+    await waitForServer(port, {
+      label: "Paseo daemon",
+      childProcess: daemonProcess,
+      getRecentOutput: daemonLineBuffer.dump,
+    });
 
     const offer = await waitForPairingOfferFromDaemon({
       port,
@@ -809,7 +844,7 @@ export default async function globalSetup() {
     process.env.E2E_PASEO_HOME = paseoHome;
     process.env.E2E_EDITOR_RECORD_PATH = editorRecordPath;
     console.log(
-      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, home: ${paseoHome}`,
+      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, relay on port ${relayPort}, relay inspector on port ${inspectorPort}, home: ${paseoHome}`,
     );
 
     return async () => {

packages/app/src/e2e-metro-readiness.test.ts

@@ -0,0 +1,65 @@
+import { createServer, type Server } from "node:http";
+import { afterEach, expect, test } from "vitest";
+
+import { waitForMetro } from "../e2e/global-setup";
+
+class MetroPort {
+  private response = { status: 500, body: "fallback" };
+
+  private constructor(
+    readonly port: number,
+    private readonly server: Server,
+  ) {}
+
+  static async listen(): Promise<MetroPort> {
+    let endpoint!: MetroPort;
+    const server = createServer((_request, response) => {
+      response.writeHead(endpoint.response.status, { "content-type": "text/plain" });
+      response.end(endpoint.response.body);
+    });
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      server.close();
+      throw new Error("Failed to listen for Metro readiness test");
+    }
+    endpoint = new MetroPort(address.port, server);
+    return endpoint;
+  }
+
+  serveMetro(): void {
+    this.response = { status: 200, body: "packager-status:running" };
+  }
+
+  async close(): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      this.server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+}
+
+let endpoint: MetroPort | null = null;
+
+afterEach(async () => {
+  await endpoint?.close();
+  endpoint = null;
+});
+
+test("Metro readiness rejects another HTTP listener on the selected port", async () => {
+  endpoint = await MetroPort.listen();
+
+  await expect(waitForMetro(endpoint.port, { label: "Metro", timeoutMs: 150 })).rejects.toThrow(
+    "Expected Metro status",
+  );
+
+  endpoint.serveMetro();
+  await expect(waitForMetro(endpoint.port, { label: "Metro", timeoutMs: 150 })).resolves.toBe(
+    undefined,
+  );
+});