From d87475f50ab978cb1f239eebf6735086b861777f Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 16:28:59 -0500 Subject: [PATCH 1/9] fix: keep simulator shutdown queries off the streaming event loop --- packages/serve-sim/README.md | 2 + .../shutdown-watch-responsive.test.ts | 116 ++++++++++++++++++ packages/serve-sim/src/index.ts | 17 +-- 3 files changed, 127 insertions(+), 8 deletions(-) create mode 100644 packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts diff --git a/packages/serve-sim/README.md b/packages/serve-sim/README.md index 54722bc25..04fe702a1 100644 --- a/packages/serve-sim/README.md +++ b/packages/serve-sim/README.md @@ -202,6 +202,8 @@ serve-sim camera --stop-webcam Multiple booted simulators are supported — pass several device names, or leave it empty to attach to all of them. +Helpers started by `--detach` or `--no-preview` exit after their target simulators remain shut down beyond the grace period. Boot-state checks run asynchronously so a slow `simctl` query does not pause streaming. A failed check keeps the helper alive. + ### Remote access (`--auth-token`) Requests that don't come straight from this machine — LAN clients, tunnels, reverse proxies — are refused unless the server is started with `--auth-token ` (or `SERVE_SIM_AUTH_TOKEN`). CLI and scripted clients send `Authorization: Bearer `. To share the preview with a browser, send the link with the token in the URL fragment: diff --git a/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts b/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts new file mode 100644 index 000000000..fc74fa4df --- /dev/null +++ b/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts @@ -0,0 +1,116 @@ +import { expect, test } from "bun:test"; +import { spawn } from "child_process"; +import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs"; +import { createServer } from "net"; +import { tmpdir } from "os"; +import { delimiter, join } from "path"; + +const udid = "00000000-0000-4000-8000-000000000102"; +function delay(ms: number) { + const { promise, resolve } = Promise.withResolvers(); + setTimeout(resolve, ms); + return promise; +} + +async function waitFor(check: () => boolean, timeoutMs: number): Promise { + const started = Date.now(); + while (!check()) { + if (Date.now() - started >= timeoutMs) throw new Error("Watchdog fixture did not reach its barrier"); + await delay(20); + } +} + +async function freePort(): Promise { + const server = createServer(); + const ready = Promise.withResolvers(); + server.once("error", ready.reject); + server.listen(0, "127.0.0.1", ready.resolve); + await ready.promise; + const address = server.address(); + if (!address || typeof address === "string") throw new Error("No test port"); + const closed = Promise.withResolvers(); + server.close((error) => error ? closed.reject(error) : closed.resolve()); + await closed.promise; + return address.port; +} + +// The real CLI subprocess's watchdog cannot use the test process's fake clock. +test.skipIf(process.platform === "win32")("serves HTTP while the shutdown boot-state query is pending", async () => { + const root = mkdtempSync(join(tmpdir(), "serve-sim-shutdown-watch-")); + const bin = join(root, "bin"); + mkdirSync(bin); + const started = join(root, "query-started"); + const finished = join(root, "query-finished"); + const release = join(root, "release-query"); + const fixture = join(root, "xcrun.ts"); + writeFileSync(fixture, ` +import { existsSync, writeFileSync } from "fs"; +const args = process.argv.slice(2).join(" "); +const devices = { devices: { test: [{ udid: ${JSON.stringify(udid)}, state: "Booted" }] } }; +if (args === "simctl list devices booted -j") { + writeFileSync(${JSON.stringify(started)}, "started"); + while (!existsSync(${JSON.stringify(release)})) await Bun.sleep(20); + writeFileSync(${JSON.stringify(finished)}, "finished"); +} else if (args !== "simctl list devices -j") { + throw new Error("Refusing unexpected simulator command: " + args); +} +console.log(JSON.stringify(devices)); +`); + const quote = (value: string) => "'" + value.replaceAll("'", "'\\''") + "'"; + writeFileSync(join(bin, "xcrun"), `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(fixture)} "$@"\n`, { mode: 0o700 }); + writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); + const env: NodeJS.ProcessEnv = { ...process.env, PATH: `${bin}${delimiter}${process.env.PATH ?? ""}`, TMPDIR: root, TMP: root, TEMP: root }; + for (const key of Object.keys(env)) { + if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; + } + const port = await freePort(); + const child = spawn(process.execPath, [join(import.meta.dir, "../index.ts"), udid, + "--port", String(port), "--host", "127.0.0.1", "--exit-on-simulator-shutdown"], { + env, stdio: ["ignore", "ignore", "pipe"], + }); + let stderr = ""; + child.stderr?.on("data", (data) => { stderr += data; }); + let exited = false; + const { promise: closed, resolve: resolveClosed } = Promise.withResolvers(); + child.once("close", () => { exited = true; resolveClosed(); }); + child.once("error", () => { exited = true; resolveClosed(); }); + const waitClosed = async (ms: number) => { + const timeout = Promise.withResolvers(); + const timer = setTimeout(timeout.resolve, ms); + try { + await Promise.race([closed, timeout.promise]); + } finally { + clearTimeout(timer); + } + }; + try { + const stateFile = join(root, "serve-sim", `server-${udid}.json`); + await waitFor(() => { + if (exited) throw new Error("CLI exited before readiness: " + stderr); + return existsSync(stateFile); + }, 10_000); + const state = JSON.parse(readFileSync(stateFile, "utf8")); + expect(state.pid).toBe(child.pid); + expect(state.port).toBe(port); + await waitFor(() => { + if (exited) throw new Error("CLI exited before its boot query: " + stderr); + return existsSync(started); + }, 10_000); + expect(existsSync(finished)).toBe(false); + const response = await fetch(`http://127.0.0.1:${port}/__shutdown_watch_probe__`, { signal: AbortSignal.timeout(1_500) }); + await response.arrayBuffer(); + expect(response.status).toBe(404); + expect(existsSync(finished)).toBe(false); + } finally { + writeFileSync(release, "release"); + try { + if (existsSync(started) && !exited) await waitFor(() => existsSync(finished), 3_500); + } finally { + if (!exited) child.kill("SIGTERM"); + await waitClosed(2_000); + if (!exited) child.kill("SIGKILL"); + await closed; + rmSync(root, { recursive: true, force: true }); + } + } +}, 20_000); diff --git a/packages/serve-sim/src/index.ts b/packages/serve-sim/src/index.ts index 4e4345e0b..dc004be14 100755 --- a/packages/serve-sim/src/index.ts +++ b/packages/serve-sim/src/index.ts @@ -1,11 +1,12 @@ #!/usr/bin/env node import WebSocket from "ws"; import { Command, InvalidArgumentError } from "commander"; -import { execFileSync, execSync, spawn as nodeSpawn, type ChildProcess } from "child_process"; +import { execFile, execFileSync, execSync, spawn as nodeSpawn, type ChildProcess } from "child_process"; import { existsSync, mkdirSync, openSync, closeSync, readSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs"; import { createHash, randomBytes } from "crypto"; import { networkInterfaces } from "os"; import { dirname, join, resolve } from "path"; +import { promisify } from "util"; import { STATE_DIR, stateFileForDevice, @@ -93,6 +94,7 @@ import { redactHome } from "./diagnostics-redact"; // `import.meta.dir` is Bun-only; resolve once via fileURLToPath so the bundled // CLI works under plain `node` too. const __dirname = dirnameOf(import.meta.url); +const execFileAsync = promisify(execFile); // Stamped in at build time (see build.ts), mirroring __PREVIEW_HTML_B64__. In // the un-bundled dev run the define is absent, so fall back to reading the @@ -138,15 +140,14 @@ function readState(udid?: string): ServerState | null { * Cached for 1 second so a flurry of lookups shares one `simctl` call. */ let bootedSnapshot: { at: number; booted: Set | null } = { at: 0, booted: null }; -function getBootedUdids(): Set | null { +async function getBootedUdids(): Promise | null> { const now = Date.now(); if (bootedSnapshot.booted && now - bootedSnapshot.at < 1000) { return bootedSnapshot.booted; } try { - const output = execSync("xcrun simctl list devices booted -j", { + const { stdout: output } = await execFileAsync("xcrun", ["simctl", "list", "devices", "booted", "-j"], { encoding: "utf-8", - stdio: ["ignore", "pipe", "pipe"], timeout: 3_000, }); const data = JSON.parse(output) as { @@ -202,10 +203,10 @@ function readStateFile(file: string): ServerState | null { * different `--auth-token` (or none), or a different `--allow-exec` opt-in, * is never reused: that is an error. */ -function readReusableState(udid: string, allowExec: boolean): ServerState | null { +async function readReusableState(udid: string, allowExec: boolean): Promise { const state = readState(udid); if (!state) return null; - const action = classifyStaleState(state, getBootedUdids(), process.pid); + const action = classifyStaleState(state, await getBootedUdids(), process.pid); if (action === "keep") { const mismatch = reuseAuthMismatch(state, resolveAuthToken(undefined)) ?? reuseExecMismatch(state, allowExec); @@ -477,7 +478,7 @@ async function follow(devices: string[], startPort: number, quiet: boolean, allo for (const udid of udids) { // Return existing server if already running (and still bound to a booted sim) - const existing = readReusableState(udid, allowExec); + const existing = await readReusableState(udid, allowExec); if (existing) { if (!quiet) { const name = getDeviceName(udid) ?? udid; @@ -594,7 +595,7 @@ async function detach(devices: string[], startPort: number, allowExec: boolean): let port = startPort; for (const udid of udids) { - const existing = readReusableState(udid, allowExec); + const existing = await readReusableState(udid, allowExec); if (existing) { states.push(existing); continue; From 7c008c9f02abd2d6dd8f0ed27adbb9315a81d0b6 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:36:00 -0500 Subject: [PATCH 2/9] fix: share pending boot queries and simplify watchdog regression --- packages/serve-sim/README.md | 2 +- .../src/__tests__/devtools-proxy.test.ts | 19 +-- .../src/__tests__/duo-preview-stream.test.ts | 9 +- .../fixtures/shutdown-watch-xcrun.sh | 19 +++ .../src/__tests__/server-test-support.ts | 24 ++++ .../shutdown-watch-responsive.test.ts | 110 +++++++----------- packages/serve-sim/src/index.ts | 37 ++++-- 7 files changed, 112 insertions(+), 108 deletions(-) create mode 100755 packages/serve-sim/src/__tests__/fixtures/shutdown-watch-xcrun.sh create mode 100644 packages/serve-sim/src/__tests__/server-test-support.ts diff --git a/packages/serve-sim/README.md b/packages/serve-sim/README.md index 04fe702a1..f47d061ca 100644 --- a/packages/serve-sim/README.md +++ b/packages/serve-sim/README.md @@ -202,7 +202,7 @@ serve-sim camera --stop-webcam Multiple booted simulators are supported — pass several device names, or leave it empty to attach to all of them. -Helpers started by `--detach` or `--no-preview` exit after their target simulators remain shut down beyond the grace period. Boot-state checks run asynchronously so a slow `simctl` query does not pause streaming. A failed check keeps the helper alive. +Helpers started by `--detach` or `--no-preview` exit after their target simulators remain shut down beyond the grace period. A failed check keeps the helper alive. ### Remote access (`--auth-token`) diff --git a/packages/serve-sim/src/__tests__/devtools-proxy.test.ts b/packages/serve-sim/src/__tests__/devtools-proxy.test.ts index 9205ba18c..4589543c6 100644 --- a/packages/serve-sim/src/__tests__/devtools-proxy.test.ts +++ b/packages/serve-sim/src/__tests__/devtools-proxy.test.ts @@ -1,27 +1,10 @@ import { afterEach, describe, expect, test } from "bun:test"; import { mkdirSync, rmSync, writeFileSync } from "fs"; -import { createServer as createNetServer } from "net"; import { spawn, type ChildProcess } from "child_process"; import { simMiddleware, type ServeSimState, type WebKitBridge } from "../middleware"; import { servePreview, type PreviewServer } from "../runtime"; import { STATE_DIR, stateFileForDevice } from "../state"; - -async function freePort(): Promise { - return new Promise((resolve, reject) => { - const server = createNetServer(); - server.once("error", reject); - server.listen(0, "127.0.0.1", () => { - const addr = server.address(); - if (!addr || typeof addr === "string") { - server.close(); - reject(new Error("failed to allocate port")); - return; - } - const port = addr.port; - server.close(() => resolve(port)); - }); - }); -} +import { freePort } from "./server-test-support"; describe("devtools proxy", () => { const udid = "DEVTOOLS-PROXY-DEVICE"; diff --git a/packages/serve-sim/src/__tests__/duo-preview-stream.test.ts b/packages/serve-sim/src/__tests__/duo-preview-stream.test.ts index 9285deddc..34fe12492 100644 --- a/packages/serve-sim/src/__tests__/duo-preview-stream.test.ts +++ b/packages/serve-sim/src/__tests__/duo-preview-stream.test.ts @@ -4,6 +4,7 @@ import type { ServerResponse } from "http"; import { join } from "node:path"; import { DuoPreview, DUO_SETTLE_MS } from "../duo-preview"; import type { DuoProjection } from "../duo-renderer"; +import { waitFor } from "./server-test-support"; class FakeResponse { writableLength = 0; @@ -42,14 +43,6 @@ function harness() { return { preview, calls }; } -async function waitFor(predicate: () => boolean): Promise { - const deadline = Date.now() + 1_000; - while (!predicate()) { - if (Date.now() >= deadline) throw new Error("condition not reached"); - await new Promise((resolve) => setTimeout(resolve, 5)); - } -} - describe("Duo live preview stream", () => { test("motion uses the fast target and sharpens once after settle", async () => { const { preview, calls } = harness(); diff --git a/packages/serve-sim/src/__tests__/fixtures/shutdown-watch-xcrun.sh b/packages/serve-sim/src/__tests__/fixtures/shutdown-watch-xcrun.sh new file mode 100755 index 000000000..f5cb235d4 --- /dev/null +++ b/packages/serve-sim/src/__tests__/fixtures/shutdown-watch-xcrun.sh @@ -0,0 +1,19 @@ +#!/bin/sh +set -eu + +case "$*" in + "simctl list devices booted -j") + printf started > "$SERVE_SIM_TEST_QUERY_DIR/query-started" + while [ ! -e "$SERVE_SIM_TEST_QUERY_DIR/release-query" ]; do + sleep 0.02 + done + printf finished > "$SERVE_SIM_TEST_QUERY_DIR/query-finished" + ;; + "simctl list devices -j") ;; + *) + printf 'Refusing unexpected simulator command: %s\n' "$*" >&2 + exit 88 + ;; +esac + +printf '{"devices":{"test":[{"udid":"%s","state":"Booted"}]}}\n' "$SERVE_SIM_TEST_UDID" diff --git a/packages/serve-sim/src/__tests__/server-test-support.ts b/packages/serve-sim/src/__tests__/server-test-support.ts new file mode 100644 index 000000000..89d922713 --- /dev/null +++ b/packages/serve-sim/src/__tests__/server-test-support.ts @@ -0,0 +1,24 @@ +import { createServer } from "net"; +import { setTimeout as delay } from "timers/promises"; + +export async function freePort(): Promise { + const server = createServer(); + const ready = Promise.withResolvers(); + server.once("error", ready.reject); + server.listen(0, "127.0.0.1", ready.resolve); + await ready.promise; + const address = server.address(); + const closed = Promise.withResolvers(); + server.close((error) => error ? closed.reject(error) : closed.resolve()); + await closed.promise; + if (!address || typeof address === "string") throw new Error("failed to allocate port"); + return address.port; +} + +export async function waitFor(predicate: () => boolean, timeoutMs = 1_000, intervalMs = 5): Promise { + const deadline = Date.now() + timeoutMs; + while (!predicate()) { + if (Date.now() >= deadline) throw new Error("condition not reached"); + await delay(intervalMs); + } +} diff --git a/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts b/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts index fc74fa4df..01ce232e9 100644 --- a/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts +++ b/packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts @@ -1,79 +1,23 @@ import { expect, test } from "bun:test"; -import { spawn } from "child_process"; -import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs"; -import { createServer } from "net"; +import { spawn, type ChildProcess } from "child_process"; +import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs"; import { tmpdir } from "os"; import { delimiter, join } from "path"; +import { freePort, waitFor } from "./server-test-support"; const udid = "00000000-0000-4000-8000-000000000102"; -function delay(ms: number) { - const { promise, resolve } = Promise.withResolvers(); - setTimeout(resolve, ms); - return promise; -} - -async function waitFor(check: () => boolean, timeoutMs: number): Promise { - const started = Date.now(); - while (!check()) { - if (Date.now() - started >= timeoutMs) throw new Error("Watchdog fixture did not reach its barrier"); - await delay(20); - } -} - -async function freePort(): Promise { - const server = createServer(); - const ready = Promise.withResolvers(); - server.once("error", ready.reject); - server.listen(0, "127.0.0.1", ready.resolve); - await ready.promise; - const address = server.address(); - if (!address || typeof address === "string") throw new Error("No test port"); - const closed = Promise.withResolvers(); - server.close((error) => error ? closed.reject(error) : closed.resolve()); - await closed.promise; - return address.port; -} // The real CLI subprocess's watchdog cannot use the test process's fake clock. test.skipIf(process.platform === "win32")("serves HTTP while the shutdown boot-state query is pending", async () => { const root = mkdtempSync(join(tmpdir(), "serve-sim-shutdown-watch-")); const bin = join(root, "bin"); - mkdirSync(bin); const started = join(root, "query-started"); const finished = join(root, "query-finished"); const release = join(root, "release-query"); - const fixture = join(root, "xcrun.ts"); - writeFileSync(fixture, ` -import { existsSync, writeFileSync } from "fs"; -const args = process.argv.slice(2).join(" "); -const devices = { devices: { test: [{ udid: ${JSON.stringify(udid)}, state: "Booted" }] } }; -if (args === "simctl list devices booted -j") { - writeFileSync(${JSON.stringify(started)}, "started"); - while (!existsSync(${JSON.stringify(release)})) await Bun.sleep(20); - writeFileSync(${JSON.stringify(finished)}, "finished"); -} else if (args !== "simctl list devices -j") { - throw new Error("Refusing unexpected simulator command: " + args); -} -console.log(JSON.stringify(devices)); -`); - const quote = (value: string) => "'" + value.replaceAll("'", "'\\''") + "'"; - writeFileSync(join(bin, "xcrun"), `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(fixture)} "$@"\n`, { mode: 0o700 }); - writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); - const env: NodeJS.ProcessEnv = { ...process.env, PATH: `${bin}${delimiter}${process.env.PATH ?? ""}`, TMPDIR: root, TMP: root, TEMP: root }; - for (const key of Object.keys(env)) { - if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; - } - const port = await freePort(); - const child = spawn(process.execPath, [join(import.meta.dir, "../index.ts"), udid, - "--port", String(port), "--host", "127.0.0.1", "--exit-on-simulator-shutdown"], { - env, stdio: ["ignore", "ignore", "pipe"], - }); + let child: ChildProcess | undefined; let stderr = ""; - child.stderr?.on("data", (data) => { stderr += data; }); let exited = false; const { promise: closed, resolve: resolveClosed } = Promise.withResolvers(); - child.once("close", () => { exited = true; resolveClosed(); }); - child.once("error", () => { exited = true; resolveClosed(); }); const waitClosed = async (ms: number) => { const timeout = Promise.withResolvers(); const timer = setTimeout(timeout.resolve, ms); @@ -84,33 +28,61 @@ console.log(JSON.stringify(devices)); } }; try { + mkdirSync(bin); + const xcrun = join(bin, "xcrun"); + copyFileSync(join(import.meta.dir, "fixtures/shutdown-watch-xcrun.sh"), xcrun); + chmodSync(xcrun, 0o700); + writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); + const env: NodeJS.ProcessEnv = { ...process.env, PATH: `${bin}${delimiter}${process.env.PATH ?? ""}`, TMPDIR: root, TMP: root, TEMP: root }; + for (const key of Object.keys(env)) { + if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; + } + env.SERVE_SIM_TEST_QUERY_DIR = root; + env.SERVE_SIM_TEST_UDID = udid; + const port = await freePort(); + child = spawn(process.execPath, [join(import.meta.dir, "../index.ts"), udid, + "--port", String(port), "--host", "127.0.0.1", "--exit-on-simulator-shutdown"], { + env, stdio: ["ignore", "ignore", "pipe"], + }); + child.stderr?.on("data", (data) => { stderr += data; }); + child.once("close", () => { exited = true; resolveClosed(); }); + child.once("error", () => { exited = true; resolveClosed(); }); const stateFile = join(root, "serve-sim", `server-${udid}.json`); await waitFor(() => { if (exited) throw new Error("CLI exited before readiness: " + stderr); return existsSync(stateFile); - }, 10_000); + }, 10_000, 20); const state = JSON.parse(readFileSync(stateFile, "utf8")); expect(state.pid).toBe(child.pid); expect(state.port).toBe(port); await waitFor(() => { if (exited) throw new Error("CLI exited before its boot query: " + stderr); return existsSync(started); - }, 10_000); + }, 10_000, 20); expect(existsSync(finished)).toBe(false); const response = await fetch(`http://127.0.0.1:${port}/__shutdown_watch_probe__`, { signal: AbortSignal.timeout(1_500) }); await response.arrayBuffer(); expect(response.status).toBe(404); expect(existsSync(finished)).toBe(false); + } catch (error) { + throw new Error("CLI shutdown-watch probe failed: " + stderr, { cause: error }); } finally { - writeFileSync(release, "release"); try { - if (existsSync(started) && !exited) await waitFor(() => existsSync(finished), 3_500); + if (child) { + writeFileSync(release, "release"); + if (existsSync(started) && !exited) await waitFor(() => existsSync(finished), 3_500, 20); + } } finally { - if (!exited) child.kill("SIGTERM"); - await waitClosed(2_000); - if (!exited) child.kill("SIGKILL"); - await closed; - rmSync(root, { recursive: true, force: true }); + try { + if (child) { + if (!exited) child.kill("SIGTERM"); + await waitClosed(2_000); + if (!exited) child.kill("SIGKILL"); + await closed; + } + } finally { + rmSync(root, { recursive: true, force: true }); + } } } }, 20_000); diff --git a/packages/serve-sim/src/index.ts b/packages/serve-sim/src/index.ts index dc004be14..391226ece 100755 --- a/packages/serve-sim/src/index.ts +++ b/packages/serve-sim/src/index.ts @@ -137,14 +137,8 @@ function readState(udid?: string): ServerState | null { /** * Snapshot simctl's boot state for `--detach` reuse and the shutdown watch. - * Cached for 1 second so a flurry of lookups shares one `simctl` call. */ -let bootedSnapshot: { at: number; booted: Set | null } = { at: 0, booted: null }; -async function getBootedUdids(): Promise | null> { - const now = Date.now(); - if (bootedSnapshot.booted && now - bootedSnapshot.at < 1000) { - return bootedSnapshot.booted; - } +async function queryBootedUdids(): Promise | null> { try { const { stdout: output } = await execFileAsync("xcrun", ["simctl", "list", "devices", "booted", "-j"], { encoding: "utf-8", @@ -159,7 +153,6 @@ async function getBootedUdids(): Promise | null> { if (device.state === "Booted") booted.add(device.udid); } } - bootedSnapshot = { at: now, booted }; return booted; } catch { // simctl lookup failed (Xcode offline, etc.) — we can't prove the device @@ -169,6 +162,29 @@ async function getBootedUdids(): Promise | null> { } } +let bootedSnapshot: Promise | null> | null = null; +let bootedSnapshotAt: number | null = null; + +/** Share in-flight lookups, then cache successful snapshots for 1 second. */ +function getBootedUdids(): Promise | null> { + if ( + bootedSnapshot && + (bootedSnapshotAt === null || Date.now() - bootedSnapshotAt < 1000) + ) { + return bootedSnapshot; + } + bootedSnapshotAt = null; + bootedSnapshot = queryBootedUdids().then((booted) => { + if (booted) { + bootedSnapshotAt = Date.now(); + } else { + bootedSnapshot = null; + } + return booted; + }); + return bootedSnapshot; +} + function readStateFile(file: string): ServerState | null { try { if (!existsSync(file)) { @@ -2092,10 +2108,7 @@ async function serve( // grid can boot another device without tearing down the HTTP server. if (exitOnSimulatorShutdown) { startSimulatorShutdownWatch(targetDevices, { - checkBooted: async () => { - bootedSnapshot = { at: 0, booted: null }; - return getBootedUdids(); - }, + checkBooted: queryBootedUdids, onExit: () => { const label = targetDevices.join(", "); console.error( From 2db967b4cbba00045e1d42ad712abfc77fa70f1f Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:49:10 -0500 Subject: [PATCH 3/9] ci: repeat shutdown-watch responsiveness regression on Linux --- .github/workflows/serve-sim-unit.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/serve-sim-unit.yml b/.github/workflows/serve-sim-unit.yml index dde7f9145..e770353e6 100644 --- a/.github/workflows/serve-sim-unit.yml +++ b/.github/workflows/serve-sim-unit.yml @@ -35,3 +35,5 @@ jobs: # (no xcrun / no Darwin dylibs); they run serially on macOS in sim-test.yml. - name: serve-sim unit tests run: bun test packages/serve-sim/src/__tests__/ + - name: Repeat shutdown-watch responsiveness regression + run: bun test --rerun-each 3 packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts From 4bae63c40dbb126d27ee6e0627c193fece0520c1 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 18:09:02 -0500 Subject: [PATCH 4/9] fix: revalidate helper identity after boot-state await --- packages/serve-sim/src/index.ts | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/packages/serve-sim/src/index.ts b/packages/serve-sim/src/index.ts index 391226ece..2f5c14320 100755 --- a/packages/serve-sim/src/index.ts +++ b/packages/serve-sim/src/index.ts @@ -220,9 +220,12 @@ function readStateFile(file: string): ServerState | null { * is never reused: that is an error. */ async function readReusableState(udid: string, allowExec: boolean): Promise { + const previous = readState(udid); + if (!previous) return null; + const booted = await getBootedUdids(); const state = readState(udid); - if (!state) return null; - const action = classifyStaleState(state, await getBootedUdids(), process.pid); + if (!state || state.pid !== previous.pid || state.port !== previous.port) return null; + const action = classifyStaleState(state, booted, process.pid); if (action === "keep") { const mismatch = reuseAuthMismatch(state, resolveAuthToken(undefined)) ?? reuseExecMismatch(state, allowExec); From 9768d5709e90c9ea8298fe51907ccadd259a7e36 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 18:40:00 -0500 Subject: [PATCH 5/9] fix: reuse validated helper state after boot query --- .../src/__tests__/exec-reuse.test.ts | 137 +++++++++++++++++- packages/serve-sim/src/index.ts | 5 +- 2 files changed, 138 insertions(+), 4 deletions(-) diff --git a/packages/serve-sim/src/__tests__/exec-reuse.test.ts b/packages/serve-sim/src/__tests__/exec-reuse.test.ts index dc5690bba..8d4fdb390 100644 --- a/packages/serve-sim/src/__tests__/exec-reuse.test.ts +++ b/packages/serve-sim/src/__tests__/exec-reuse.test.ts @@ -1,6 +1,13 @@ import { afterAll, describe, expect, test } from "bun:test"; +import { spawn, type ChildProcess } from "child_process"; import { createHash } from "crypto"; -import { statSync } from "fs"; +import { + chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, + renameSync, rmSync, statSync, symlinkSync, writeFileSync, +} from "fs"; +import { tmpdir } from "os"; +import { join } from "path"; +import { setTimeout as delay } from "timers/promises"; import { authTokenFingerprint, parseDeviceState, @@ -15,6 +22,7 @@ import { removeExecTokenFile, writeExecTokenFile, } from "../state"; +import { freePort, waitFor } from "./server-test-support"; const UDID = "11111111-2222-3333-4444-555555555555"; @@ -120,3 +128,130 @@ describe("exec token file", () => { expect(readExecTokenFile(PORT)).toBeNull(); }); }); + +test.skipIf(process.platform === "win32")("follow reuses a live replacement registered during its boot query", async () => { + const udid = "00000000-0000-4000-8000-000000000103"; + const root = mkdtempSync(join(tmpdir(), "serve-sim-reuse-")); + const bin = join(root, "bin"); + const stateDir = join(root, "serve-sim"); + const stateFile = join(stateDir, `server-${udid}.json`); + const release = join(root, "release-query"); + const children: { child: ChildProcess; closed: Promise }[] = []; + const env: NodeJS.ProcessEnv = { ...process.env, PATH: bin, TMPDIR: root, TMP: root, TEMP: root }; + for (const key of Object.keys(env)) { + if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; + } + env.SERVE_SIM_TEST_QUERY_DIR = root; + env.SERVE_SIM_TEST_UDID = udid; + + const launch = (args: string[]) => { + // Follow's fallback helper inherits this private group, even before it writes state. + const child = spawn(process.execPath, args, { env, detached: true, stdio: ["ignore", "pipe", "pipe"] }); + const { promise: closed, resolve: resolveClosed } = Promise.withResolvers(); + const output: { + child: ChildProcess; + stdout: string; + stderr: string; + exited: boolean; + error: Error | null; + } = { child, stdout: "", stderr: "", exited: false, error: null }; + child.stdout?.on("data", (data) => { output.stdout += data; }); + child.stderr?.on("data", (data) => { output.stderr += data; }); + child.once("error", (error) => { output.error = error; }); + child.once("close", () => { output.exited = true; resolveClosed(); }); + children.push({ child, closed }); + return output; + }; + const startListener = async () => { + const listener = launch(["--eval", ` + const server = Bun.serve({ + hostname: "127.0.0.1", port: 0, + fetch: () => new Response("owned reuse helper"), + }); + console.log(JSON.stringify({ pid: process.pid, port: server.port })); + `]); + await waitFor(() => { + if (listener.error || listener.exited) throw new Error("Listener failed: " + (listener.error ?? listener.stderr)); + return listener.stdout.includes("\n"); + }, 5_000, 20); + const { pid, port } = JSON.parse(listener.stdout); + expect(pid).toBe(listener.child.pid); + return { ...inProcessServeSimState(udid, port), pid }; + }; + const readRecord = () => { + try { return parseDeviceState(readFileSync(stateFile, "utf8")); } catch { return null; } + }; + + try { + mkdirSync(bin, { mode: 0o700 }); + mkdirSync(stateDir, { mode: 0o700 }); + const xcrun = join(bin, "xcrun"); + copyFileSync(join(import.meta.dir, "fixtures/shutdown-watch-xcrun.sh"), xcrun); + chmodSync(xcrun, 0o700); + symlinkSync("/bin/sleep", join(bin, "sleep")); + writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); + + const original = await startListener(); + const replacement = await startListener(); + writeFileSync(stateFile, JSON.stringify(original), { mode: 0o600 }); + const caller = launch([join(import.meta.dir, "../index.ts"), udid, + "--no-preview", "--quiet", "--port", String(await freePort())]); + await waitFor(() => { + if (caller.error || caller.exited) throw new Error("Follow exited before its boot query: " + (caller.error ?? caller.stderr)); + return existsSync(join(root, "query-started")); + }, 10_000, 20); + expect(existsSync(join(root, "query-finished"))).toBe(false); + expect(readRecord()).toEqual(original); + + const nextStateFile = `${stateFile}.replacement`; + writeFileSync(nextStateFile, JSON.stringify(replacement), { mode: 0o600 }); + renameSync(nextStateFile, stateFile); + writeFileSync(release, "release"); + + await waitFor(() => { + if (caller.error) throw caller.error; + const current = readRecord(); + return caller.stdout.includes("\n") || caller.exited || + !current || current.pid !== replacement.pid || current.port !== replacement.port; + }, 10_000, 20); + // A rejected replacement must not be cleared or overwritten by a new helper. + expect(readRecord()).toEqual(replacement); + await waitFor(() => caller.exited, 5_000, 20); + expect(caller.child.exitCode).toBe(0); + expect(JSON.parse(caller.stdout)).toEqual({ + url: replacement.url, + streamUrl: replacement.streamUrl, + wsUrl: replacement.wsUrl, + port: replacement.port, + device: udid, + }); + expect(caller.stdout).not.toContain(`:${original.port}`); + expect(caller.stdout).not.toContain(original.url); + expect(readRecord()).toEqual(replacement); + const response = await fetch(replacement.url, { signal: AbortSignal.timeout(1_500) }); + expect(await response.text()).toBe("owned reuse helper"); + expect(response.status).toBe(200); + } finally { + try { + writeFileSync(release, "release"); + const signalGroups = (signal: NodeJS.Signals) => { + for (const { child } of children) { + if (!child.pid) continue; + try { process.kill(-child.pid, signal); } catch (error: unknown) { + if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") throw error; + } + } + }; + const closed = Promise.all(children.map(({ closed }) => closed)); + signalGroups("SIGTERM"); + await Promise.race([closed, delay(1_000, undefined, { ref: false })]); + // The caller may have exited before an unwanted fallback helper did. + signalGroups("SIGKILL"); + await Promise.race([closed, delay(2_000, undefined, { ref: false }).then(() => { + throw new Error("Owned reuse subprocesses did not close"); + })]); + } finally { + rmSync(root, { recursive: true, force: true }); + } + } +}, 45_000); diff --git a/packages/serve-sim/src/index.ts b/packages/serve-sim/src/index.ts index 2f5c14320..6a19200f8 100755 --- a/packages/serve-sim/src/index.ts +++ b/packages/serve-sim/src/index.ts @@ -220,11 +220,10 @@ function readStateFile(file: string): ServerState | null { * is never reused: that is an error. */ async function readReusableState(udid: string, allowExec: boolean): Promise { - const previous = readState(udid); - if (!previous) return null; + if (!readState(udid)) return null; const booted = await getBootedUdids(); const state = readState(udid); - if (!state || state.pid !== previous.pid || state.port !== previous.port) return null; + if (!state) return null; const action = classifyStaleState(state, booted, process.pid); if (action === "keep") { const mismatch = From 12a6410df16d0b3ccf1b6e4c100f3dfa222ab7a7 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:53:57 -0500 Subject: [PATCH 6/9] fix: confirm stale boot snapshots before recycling helpers --- .../src/__tests__/exec-reuse.test.ts | 340 ++++++++++++++++++ packages/serve-sim/src/index.ts | 23 +- 2 files changed, 360 insertions(+), 3 deletions(-) diff --git a/packages/serve-sim/src/__tests__/exec-reuse.test.ts b/packages/serve-sim/src/__tests__/exec-reuse.test.ts index 8d4fdb390..ae4211c01 100644 --- a/packages/serve-sim/src/__tests__/exec-reuse.test.ts +++ b/packages/serve-sim/src/__tests__/exec-reuse.test.ts @@ -21,6 +21,7 @@ import { readExecTokenFile, removeExecTokenFile, writeExecTokenFile, + type ServeSimDeviceState, } from "../state"; import { freePort, waitFor } from "./server-test-support"; @@ -255,3 +256,342 @@ test.skipIf(process.platform === "win32")("follow reuses a live replacement regi } } }, 45_000); + +type ReuseCliProcess = { + child: ChildProcess; + stdout: string; + stderr: string; + exited: boolean; + error: Error | null; + closed: Promise; +}; + +function reuseConfirmationHarness(udid: string, snapshots: (readonly string[] | null)[]) { + const root = mkdtempSync(join(tmpdir(), "serve-sim-confirm-reuse-")); + const bin = join(root, "bin"); + const stateDir = join(root, "serve-sim"); + const children: ReuseCliProcess[] = []; + const stateFile = (device = udid) => join(stateDir, `server-${device}.json`); + const startupLog = (device = udid) => join(stateDir, `server-${device}.log`); + const queryDir = (query: number) => join(root, `query-${query}`); + const env: NodeJS.ProcessEnv = { ...process.env, PATH: bin, TMPDIR: root, TMP: root, TEMP: root }; + for (const key of Object.keys(env)) { + if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; + } + env.SERVE_SIM_TEST_QUERY_DIR = root; + env.SERVE_SIM_TEST_UDID = udid; + + try { + mkdirSync(bin, { mode: 0o700 }); + mkdirSync(stateDir, { mode: 0o700 }); + const fixture = join(root, "xcrun-fixture"); + copyFileSync(join(import.meta.dir, "fixtures/shutdown-watch-xcrun.sh"), fixture); + chmodSync(fixture, 0o700); + for (const [index, snapshot] of snapshots.entries()) { + const dir = queryDir(index + 1); + mkdirSync(dir, { mode: 0o700 }); + if (snapshot !== null) { + writeFileSync(join(dir, "response.json"), JSON.stringify({ + devices: snapshot.length ? { test: snapshot.map((device) => ({ udid: device, state: "Booted" })) } : {}, + }), { mode: 0o600 }); + } + } + // Only this private wrapper opts into sequenced snapshots. Each query still + // uses the unchanged producer's own started/release/finished barriers. + writeFileSync(join(bin, "xcrun"), `#!/bin/sh +set -eu +root=$SERVE_SIM_TEST_QUERY_DIR +if [ "$#" -ne 5 ] || [ "$1" != simctl ] || [ "$2" != list ] || [ "$3" != devices ] || [ "$4" != booted ] || [ "$5" != -j ]; then + printf 'Refusing unexpected simulator command: %s\\n' "$*" >&2 + exit 88 +fi +for query in ${snapshots.map((_, index) => index + 1).join(" ")}; do + dir="$root/query-$query" + if /bin/mkdir "$dir/claimed" 2>/dev/null; then + export SERVE_SIM_TEST_QUERY_DIR="$dir" + if [ -e "$dir/response.json" ]; then + "$root/xcrun-fixture" "$@" > /dev/null + exec /bin/cat "$dir/response.json" + fi + exec "$root/xcrun-fixture" "$@" + fi +done +printf unexpected > "$root/unexpected-query" +printf 'Refusing an extra boot query\\n' >&2 +exit 88 +`, { mode: 0o700 }); + symlinkSync("/bin/sleep", join(bin, "sleep")); + writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); + // No real xcrun, lsof, or open is reachable. A fallback child's full-device + // lookup and boot are refused before it can reach native preview startup. + } catch (error) { + rmSync(root, { recursive: true, force: true }); + throw error; + } + + const launch = (args: string[]) => { + const child = spawn(process.execPath, args, { env, detached: true, stdio: ["ignore", "pipe", "pipe"] }); + const { promise: closed, resolve: resolveClosed } = Promise.withResolvers(); + const output: ReuseCliProcess = { child, stdout: "", stderr: "", exited: false, error: null, closed }; + children.push(output); + child.stdout?.on("data", (data) => { output.stdout += data; }); + child.stderr?.on("data", (data) => { output.stderr += data; }); + child.once("error", (error) => { output.error = error; }); + child.once("close", () => { output.exited = true; resolveClosed(); }); + return output; + }; + const readRecord = (device = udid) => { + try { return parseDeviceState(readFileSync(stateFile(device), "utf8")); } catch { return null; } + }; + const publish = (record: ServeSimDeviceState) => { + const file = stateFile(record.device); + const next = `${file}.replacement`; + writeFileSync(next, JSON.stringify(record), { mode: 0o600 }); + renameSync(next, file); + }; + const queryStarted = (query: number) => existsSync(join(queryDir(query), "query-started")); + const queryFinished = (query: number) => existsSync(join(queryDir(query), "query-finished")); + const releaseQuery = (query: number) => writeFileSync(join(queryDir(query), "release-query"), "release"); + const hasStartup = (device = udid) => existsSync(startupLog(device)); + const waitForQuery = async (caller: ReuseCliProcess, query: number) => { + await waitFor(() => { + if (caller.error || caller.exited) { + throw new Error(`Follow exited before boot query ${query}: ${caller.error ?? caller.stderr}`); + } + if (queryStarted(query)) return true; + if (hasStartup()) throw new Error(`Follow entered fallback startup before boot query ${query}`); + return false; + }, 10_000, 20); + expect(queryFinished(query)).toBe(false); + }; + const waitForOutcome = async (caller: ReuseCliProcess, records: ServeSimDeviceState[]) => { + await waitFor(() => { + if (caller.error) throw caller.error; + return caller.exited || caller.stdout.includes("\n") || records.some((record) => { + const current = readRecord(record.device); + return hasStartup(record.device) || !current || current.pid !== record.pid || current.port !== record.port; + }); + }, 10_000, 20); + for (const record of records) { + expect(readRecord(record.device)).toEqual(record); + expect(hasStartup(record.device)).toBe(false); + } + await waitFor(() => { + if (caller.error) throw caller.error; + return caller.exited; + }, 5_000, 20); + expect(existsSync(join(root, "unexpected-query"))).toBe(false); + }; + const expectLive = async (record: ServeSimDeviceState) => { + const response = await fetch(record.url, { signal: AbortSignal.timeout(1_500) }); + expect(response.status).toBe(200); + expect(await response.text()).toBe("owned reuse helper"); + }; + const expectReuse = async (caller: ReuseCliProcess, records: ServeSimDeviceState[]) => { + await waitForOutcome(caller, records); + expect(caller.child.exitCode).toBe(0); + const payload = records.map(({ url, streamUrl, wsUrl, port, device }) => ({ url, streamUrl, wsUrl, port, device })); + expect(JSON.parse(caller.stdout)).toEqual(payload.length === 1 ? payload[0] : { devices: payload }); + for (const record of records) { + expect(readRecord(record.device)).toEqual(record); + expect(hasStartup(record.device)).toBe(false); + await expectLive(record); + } + }; + const waitForFallback = async (caller: ReuseCliProcess) => { + await waitFor(() => { + if (caller.error) throw caller.error; + return hasStartup() || caller.exited || caller.stdout.includes("\n"); + }, 10_000, 20); + expect(hasStartup()).toBe(true); + expect(caller.stdout).toBe(""); + expect(readRecord()).toBeNull(); + expect(existsSync(join(root, "unexpected-query"))).toBe(false); + }; + + return { + readRecord, publish, queryStarted, queryFinished, releaseQuery, hasStartup, + waitForQuery, waitForOutcome, expectLive, expectReuse, waitForFallback, + removeRecord: () => rmSync(stateFile()), + follow: async (devices = [udid]) => launch([ + join(import.meta.dir, "../index.ts"), ...devices, + "--no-preview", "--quiet", "--port", String(await freePort()), + ]), + startListener: async (device = udid) => { + const listener = launch(["--eval", ` + const server = Bun.serve({ + hostname: "127.0.0.1", port: 0, + fetch: () => new Response("owned reuse helper"), + }); + console.log(JSON.stringify({ pid: process.pid, port: server.port })); + `]); + await waitFor(() => { + if (listener.error || listener.exited) throw new Error("Listener failed: " + (listener.error ?? listener.stderr)); + return listener.stdout.includes("\n"); + }, 5_000, 20); + const { pid, port } = JSON.parse(listener.stdout); + expect(pid).toBe(listener.child.pid); + return { record: { ...inProcessServeSimState(device, port), pid }, listener }; + }, + cleanup: async () => { + const errors: unknown[] = []; + const isGroupAlive = (pid: number) => { + try { process.kill(-pid, 0); return true; } catch (error: unknown) { + if (error instanceof Error && "code" in error && error.code === "ESRCH") return false; + throw error; + } + }; + const signalGroups = (signal: NodeJS.Signals) => { + for (const { child } of children) { + if (!child.pid) continue; + try { process.kill(-child.pid, signal); } catch (error: unknown) { + if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") errors.push(error); + } + } + }; + try { + for (let query = 1; query <= snapshots.length; query++) { + try { releaseQuery(query); } catch (error) { errors.push(error); } + } + const closed = Promise.all(children.map(({ closed }) => closed)); + signalGroups("SIGTERM"); + await Promise.race([closed, delay(1_000, undefined, { ref: false })]); + // Signal even closed leaders: their attached fallback/query descendants + // remain in the caller's owned group until they have also exited. + signalGroups("SIGKILL"); + try { + await waitFor(() => children.every(({ child, exited, error }) => + (exited || error !== null) && (!child.pid || !isGroupAlive(child.pid))), 2_000, 20); + } catch (error) { + errors.push(error); + } + } finally { + rmSync(root, { recursive: true, force: true }); + } + if (errors.length) throw new AggregateError(errors, "Owned reuse subprocess cleanup failed"); + }, + }; +} + +test.skipIf(process.platform === "win32")("follow preserves a replacement after a stale unbooted snapshot", async () => { + const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000104", [[], null]); + try { + const original = await h.startListener(); + const replacement = await h.startListener(); + h.publish(original.record); + const caller = await h.follow(); + await h.waitForQuery(caller, 1); + expect(h.readRecord()).toEqual(original.record); + h.publish(replacement.record); + h.releaseQuery(1); + await h.waitForQuery(caller, 2); + expect(h.queryFinished(1)).toBe(true); + expect(h.readRecord()).toEqual(replacement.record); + expect(h.hasStartup()).toBe(false); + h.releaseQuery(2); + await h.expectReuse(caller, [replacement.record]); + expect(caller.stdout).not.toContain(original.record.url); + expect(caller.stdout).not.toContain(`:${original.record.port}`); + } finally { + await h.cleanup(); + } +}, 45_000); + +test.skipIf(process.platform === "win32")("follow recycles an unchanged helper after a fresh unbooted confirmation", async () => { + const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000105", [[], []]); + try { + const original = await h.startListener(); + h.publish(original.record); + const caller = await h.follow(); + await h.waitForQuery(caller, 1); + h.releaseQuery(1); + await h.waitForQuery(caller, 2); + expect(h.queryFinished(1)).toBe(true); + expect(h.readRecord()).toEqual(original.record); + expect(original.listener.exited).toBe(false); + expect(h.hasStartup()).toBe(false); + h.releaseQuery(2); + await h.waitForFallback(caller); + expect(h.queryFinished(2)).toBe(true); + await waitFor(() => original.listener.exited, 5_000, 20); + expect(caller.stdout).not.toContain(original.record.url); + expect(caller.stdout).not.toContain(`:${original.record.port}`); + } finally { + await h.cleanup(); + } +}, 45_000); + +test.skipIf(process.platform === "win32")("follow does not report a helper removed during its boot query", async () => { + const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000106", [null]); + try { + const original = await h.startListener(); + h.publish(original.record); + const caller = await h.follow(); + await h.waitForQuery(caller, 1); + h.removeRecord(); + h.releaseQuery(1); + await h.waitForFallback(caller); + expect(h.queryFinished(1)).toBe(true); + expect(caller.stdout).not.toContain(original.record.url); + expect(caller.stdout).not.toContain(`:${original.record.port}`); + await h.expectLive(original.record); + } finally { + await h.cleanup(); + } +}, 45_000); + +test.skipIf(process.platform === "win32")("follow preserves the latest registration when negative confirmation overlaps another replacement", async () => { + const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000107", [[], []]); + try { + const original = await h.startListener(); + const replacement = await h.startListener(); + const latest = await h.startListener(); + h.publish(original.record); + const caller = await h.follow(); + await h.waitForQuery(caller, 1); + h.publish(replacement.record); + h.releaseQuery(1); + await h.waitForQuery(caller, 2); + expect(h.readRecord()).toEqual(replacement.record); + expect(h.hasStartup()).toBe(false); + h.publish(latest.record); + h.releaseQuery(2); + await h.waitForOutcome(caller, [latest.record]); + expect(caller.child.exitCode).toBe(1); + expect(caller.stderr).toMatch(/changed|replaced/i); + expect(caller.stderr).toMatch(/retry|try again|run (?:this|the) command again/i); + expect(caller.stdout).toBe(""); + expect(h.queryFinished(2)).toBe(true); + expect(h.readRecord()).toEqual(latest.record); + expect(h.hasStartup()).toBe(false); + await h.expectLive(latest.record); + } finally { + await h.cleanup(); + } +}, 45_000); + +test.skipIf(process.platform === "win32")("follow confirms an unchanged helper omitted from a cached booted snapshot", async () => { + const udid = "00000000-0000-4000-8000-000000000108"; + const primerUdid = "00000000-0000-4000-8000-000000000109"; + const h = reuseConfirmationHarness(udid, [[primerUdid], null]); + try { + const primer = await h.startListener(primerUdid); + const original = await h.startListener(); + h.publish(primer.record); + h.publish(original.record); + // Reusing the primer fills the same CLI's snapshot cache with a set that + // omits the unchanged second candidate. Only its confirmation includes it. + const caller = await h.follow([primerUdid, udid]); + await h.waitForQuery(caller, 1); + h.releaseQuery(1); + await h.waitForQuery(caller, 2); + expect(h.queryFinished(1)).toBe(true); + expect(h.readRecord(primerUdid)).toEqual(primer.record); + expect(h.readRecord()).toEqual(original.record); + expect(h.hasStartup()).toBe(false); + h.releaseQuery(2); + await h.expectReuse(caller, [primer.record, original.record]); + } finally { + await h.cleanup(); + } +}, 45_000); diff --git a/packages/serve-sim/src/index.ts b/packages/serve-sim/src/index.ts index 6a19200f8..5250fe6b4 100755 --- a/packages/serve-sim/src/index.ts +++ b/packages/serve-sim/src/index.ts @@ -218,13 +218,30 @@ function readStateFile(file: string): ServerState | null { * instead of being treated as a working stream. A live server started with a * different `--auth-token` (or none), or a different `--allow-exec` opt-in, * is never reused: that is an error. + * Confirm obsolete boot observations once; repeated replacement fails without cleanup. */ async function readReusableState(udid: string, allowExec: boolean): Promise { - if (!readState(udid)) return null; + const previous = readState(udid); + if (!previous) return null; const booted = await getBootedUdids(); - const state = readState(udid); + let state = readState(udid); if (!state) return null; - const action = classifyStaleState(state, booted, process.pid); + let action = classifyStaleState(state, booted, process.pid); + if ( + previous.pid !== state.pid || + previous.port !== state.port || + action !== "keep" + ) { + const confirmedBooted = await queryBootedUdids(); + const confirmed = readState(udid); + if (!confirmed) return null; + if (confirmed.pid !== state.pid || confirmed.port !== state.port) { + console.error(`Helper for ${udid} changed again while checking boot state; retry the command.`); + process.exit(1); + } + state = confirmed; + action = classifyStaleState(state, confirmedBooted, process.pid); + } if (action === "keep") { const mismatch = reuseAuthMismatch(state, resolveAuthToken(undefined)) ?? reuseExecMismatch(state, allowExec); From 156609729270e92614795474acc8e53522330271 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 20:55:50 -0500 Subject: [PATCH 7/9] docs: explain reuse confirmation retry errors --- packages/serve-sim/README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/packages/serve-sim/README.md b/packages/serve-sim/README.md index f47d061ca..de082fa6b 100644 --- a/packages/serve-sim/README.md +++ b/packages/serve-sim/README.md @@ -220,6 +220,8 @@ The host shell — `POST /exec`, `{command}` frames on the `/exec-ws` control ch `--detach` and `--no-preview` reuse a running server only when it was started with the same `--auth-token` (or with none on both sides) and the same `--allow-exec` setting (on or off on both sides); otherwise they exit with an error — stop the old server with `serve-sim -k ` first. +If a helper is replaced again while its boot state is being confirmed, the command exits with a retry message and leaves the newest helper and registration untouched. Rerun the command once startup settles. + ### Camera `serve-sim camera ` replaces the simulator's camera feed for a single app. A small host-side helper writes BGRA frames into a POSIX shared-memory region; an injected dylib (`DYLD_INSERT_LIBRARIES`) swizzles AVFoundation inside the simulator process so the app reads from that region instead of the simulator's stub camera. From b87552eaa1bd66836b362a9db478b0107423eaa5 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Sun, 1 Nov 2026 22:41:32 -0500 Subject: [PATCH 8/9] test: cover helper removal during boot confirmation --- .../src/__tests__/exec-reuse.test.ts | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/packages/serve-sim/src/__tests__/exec-reuse.test.ts b/packages/serve-sim/src/__tests__/exec-reuse.test.ts index ae4211c01..1d1034b0a 100644 --- a/packages/serve-sim/src/__tests__/exec-reuse.test.ts +++ b/packages/serve-sim/src/__tests__/exec-reuse.test.ts @@ -540,6 +540,28 @@ test.skipIf(process.platform === "win32")("follow does not report a helper remov } }, 45_000); +test.skipIf(process.platform === "win32")("follow does not reuse a helper removed during its confirmation query", async () => { + const udid = "00000000-0000-4000-8000-000000000110"; + const h = reuseConfirmationHarness(udid, [[], [udid]]); + try { + const original = await h.startListener(); + h.publish(original.record); + const caller = await h.follow(); + await h.waitForQuery(caller, 1); + h.releaseQuery(1); + await h.waitForQuery(caller, 2); + h.removeRecord(); + h.releaseQuery(2); + await h.waitForFallback(caller); + expect(h.queryFinished(2)).toBe(true); + expect(caller.stdout).not.toContain(original.record.url); + expect(caller.stdout).not.toContain(`:${original.record.port}`); + await h.expectLive(original.record); + } finally { + await h.cleanup(); + } +}, 45_000); + test.skipIf(process.platform === "win32")("follow preserves the latest registration when negative confirmation overlaps another replacement", async () => { const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000107", [[], []]); try { From a54e76187495e6d24dc8ad94fa5d359e663fed53 Mon Sep 17 00:00:00 2001 From: Kien Le <122910950+kien-ship-it@users.noreply.github.com> Date: Mon, 2 Nov 2026 22:03:45 -0500 Subject: [PATCH 9/9] fix: restore maintainer-requested scope for PR #187 --- .github/workflows/serve-sim-unit.yml | 2 - packages/serve-sim/README.md | 2 - .../src/__tests__/exec-reuse.test.ts | 499 +----------------- packages/serve-sim/src/index.ts | 23 +- 4 files changed, 3 insertions(+), 523 deletions(-) diff --git a/.github/workflows/serve-sim-unit.yml b/.github/workflows/serve-sim-unit.yml index e770353e6..dde7f9145 100644 --- a/.github/workflows/serve-sim-unit.yml +++ b/.github/workflows/serve-sim-unit.yml @@ -35,5 +35,3 @@ jobs: # (no xcrun / no Darwin dylibs); they run serially on macOS in sim-test.yml. - name: serve-sim unit tests run: bun test packages/serve-sim/src/__tests__/ - - name: Repeat shutdown-watch responsiveness regression - run: bun test --rerun-each 3 packages/serve-sim/src/__tests__/shutdown-watch-responsive.test.ts diff --git a/packages/serve-sim/README.md b/packages/serve-sim/README.md index de082fa6b..f47d061ca 100644 --- a/packages/serve-sim/README.md +++ b/packages/serve-sim/README.md @@ -220,8 +220,6 @@ The host shell — `POST /exec`, `{command}` frames on the `/exec-ws` control ch `--detach` and `--no-preview` reuse a running server only when it was started with the same `--auth-token` (or with none on both sides) and the same `--allow-exec` setting (on or off on both sides); otherwise they exit with an error — stop the old server with `serve-sim -k ` first. -If a helper is replaced again while its boot state is being confirmed, the command exits with a retry message and leaves the newest helper and registration untouched. Rerun the command once startup settles. - ### Camera `serve-sim camera ` replaces the simulator's camera feed for a single app. A small host-side helper writes BGRA frames into a POSIX shared-memory region; an injected dylib (`DYLD_INSERT_LIBRARIES`) swizzles AVFoundation inside the simulator process so the app reads from that region instead of the simulator's stub camera. diff --git a/packages/serve-sim/src/__tests__/exec-reuse.test.ts b/packages/serve-sim/src/__tests__/exec-reuse.test.ts index 1d1034b0a..dc5690bba 100644 --- a/packages/serve-sim/src/__tests__/exec-reuse.test.ts +++ b/packages/serve-sim/src/__tests__/exec-reuse.test.ts @@ -1,13 +1,6 @@ import { afterAll, describe, expect, test } from "bun:test"; -import { spawn, type ChildProcess } from "child_process"; import { createHash } from "crypto"; -import { - chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, - renameSync, rmSync, statSync, symlinkSync, writeFileSync, -} from "fs"; -import { tmpdir } from "os"; -import { join } from "path"; -import { setTimeout as delay } from "timers/promises"; +import { statSync } from "fs"; import { authTokenFingerprint, parseDeviceState, @@ -21,9 +14,7 @@ import { readExecTokenFile, removeExecTokenFile, writeExecTokenFile, - type ServeSimDeviceState, } from "../state"; -import { freePort, waitFor } from "./server-test-support"; const UDID = "11111111-2222-3333-4444-555555555555"; @@ -129,491 +120,3 @@ describe("exec token file", () => { expect(readExecTokenFile(PORT)).toBeNull(); }); }); - -test.skipIf(process.platform === "win32")("follow reuses a live replacement registered during its boot query", async () => { - const udid = "00000000-0000-4000-8000-000000000103"; - const root = mkdtempSync(join(tmpdir(), "serve-sim-reuse-")); - const bin = join(root, "bin"); - const stateDir = join(root, "serve-sim"); - const stateFile = join(stateDir, `server-${udid}.json`); - const release = join(root, "release-query"); - const children: { child: ChildProcess; closed: Promise }[] = []; - const env: NodeJS.ProcessEnv = { ...process.env, PATH: bin, TMPDIR: root, TMP: root, TEMP: root }; - for (const key of Object.keys(env)) { - if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; - } - env.SERVE_SIM_TEST_QUERY_DIR = root; - env.SERVE_SIM_TEST_UDID = udid; - - const launch = (args: string[]) => { - // Follow's fallback helper inherits this private group, even before it writes state. - const child = spawn(process.execPath, args, { env, detached: true, stdio: ["ignore", "pipe", "pipe"] }); - const { promise: closed, resolve: resolveClosed } = Promise.withResolvers(); - const output: { - child: ChildProcess; - stdout: string; - stderr: string; - exited: boolean; - error: Error | null; - } = { child, stdout: "", stderr: "", exited: false, error: null }; - child.stdout?.on("data", (data) => { output.stdout += data; }); - child.stderr?.on("data", (data) => { output.stderr += data; }); - child.once("error", (error) => { output.error = error; }); - child.once("close", () => { output.exited = true; resolveClosed(); }); - children.push({ child, closed }); - return output; - }; - const startListener = async () => { - const listener = launch(["--eval", ` - const server = Bun.serve({ - hostname: "127.0.0.1", port: 0, - fetch: () => new Response("owned reuse helper"), - }); - console.log(JSON.stringify({ pid: process.pid, port: server.port })); - `]); - await waitFor(() => { - if (listener.error || listener.exited) throw new Error("Listener failed: " + (listener.error ?? listener.stderr)); - return listener.stdout.includes("\n"); - }, 5_000, 20); - const { pid, port } = JSON.parse(listener.stdout); - expect(pid).toBe(listener.child.pid); - return { ...inProcessServeSimState(udid, port), pid }; - }; - const readRecord = () => { - try { return parseDeviceState(readFileSync(stateFile, "utf8")); } catch { return null; } - }; - - try { - mkdirSync(bin, { mode: 0o700 }); - mkdirSync(stateDir, { mode: 0o700 }); - const xcrun = join(bin, "xcrun"); - copyFileSync(join(import.meta.dir, "fixtures/shutdown-watch-xcrun.sh"), xcrun); - chmodSync(xcrun, 0o700); - symlinkSync("/bin/sleep", join(bin, "sleep")); - writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); - - const original = await startListener(); - const replacement = await startListener(); - writeFileSync(stateFile, JSON.stringify(original), { mode: 0o600 }); - const caller = launch([join(import.meta.dir, "../index.ts"), udid, - "--no-preview", "--quiet", "--port", String(await freePort())]); - await waitFor(() => { - if (caller.error || caller.exited) throw new Error("Follow exited before its boot query: " + (caller.error ?? caller.stderr)); - return existsSync(join(root, "query-started")); - }, 10_000, 20); - expect(existsSync(join(root, "query-finished"))).toBe(false); - expect(readRecord()).toEqual(original); - - const nextStateFile = `${stateFile}.replacement`; - writeFileSync(nextStateFile, JSON.stringify(replacement), { mode: 0o600 }); - renameSync(nextStateFile, stateFile); - writeFileSync(release, "release"); - - await waitFor(() => { - if (caller.error) throw caller.error; - const current = readRecord(); - return caller.stdout.includes("\n") || caller.exited || - !current || current.pid !== replacement.pid || current.port !== replacement.port; - }, 10_000, 20); - // A rejected replacement must not be cleared or overwritten by a new helper. - expect(readRecord()).toEqual(replacement); - await waitFor(() => caller.exited, 5_000, 20); - expect(caller.child.exitCode).toBe(0); - expect(JSON.parse(caller.stdout)).toEqual({ - url: replacement.url, - streamUrl: replacement.streamUrl, - wsUrl: replacement.wsUrl, - port: replacement.port, - device: udid, - }); - expect(caller.stdout).not.toContain(`:${original.port}`); - expect(caller.stdout).not.toContain(original.url); - expect(readRecord()).toEqual(replacement); - const response = await fetch(replacement.url, { signal: AbortSignal.timeout(1_500) }); - expect(await response.text()).toBe("owned reuse helper"); - expect(response.status).toBe(200); - } finally { - try { - writeFileSync(release, "release"); - const signalGroups = (signal: NodeJS.Signals) => { - for (const { child } of children) { - if (!child.pid) continue; - try { process.kill(-child.pid, signal); } catch (error: unknown) { - if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") throw error; - } - } - }; - const closed = Promise.all(children.map(({ closed }) => closed)); - signalGroups("SIGTERM"); - await Promise.race([closed, delay(1_000, undefined, { ref: false })]); - // The caller may have exited before an unwanted fallback helper did. - signalGroups("SIGKILL"); - await Promise.race([closed, delay(2_000, undefined, { ref: false }).then(() => { - throw new Error("Owned reuse subprocesses did not close"); - })]); - } finally { - rmSync(root, { recursive: true, force: true }); - } - } -}, 45_000); - -type ReuseCliProcess = { - child: ChildProcess; - stdout: string; - stderr: string; - exited: boolean; - error: Error | null; - closed: Promise; -}; - -function reuseConfirmationHarness(udid: string, snapshots: (readonly string[] | null)[]) { - const root = mkdtempSync(join(tmpdir(), "serve-sim-confirm-reuse-")); - const bin = join(root, "bin"); - const stateDir = join(root, "serve-sim"); - const children: ReuseCliProcess[] = []; - const stateFile = (device = udid) => join(stateDir, `server-${device}.json`); - const startupLog = (device = udid) => join(stateDir, `server-${device}.log`); - const queryDir = (query: number) => join(root, `query-${query}`); - const env: NodeJS.ProcessEnv = { ...process.env, PATH: bin, TMPDIR: root, TMP: root, TEMP: root }; - for (const key of Object.keys(env)) { - if (key.startsWith("SERVE_SIM_") || ["NODE_OPTIONS", "NODE_PATH", "DEBUG"].includes(key)) delete env[key]; - } - env.SERVE_SIM_TEST_QUERY_DIR = root; - env.SERVE_SIM_TEST_UDID = udid; - - try { - mkdirSync(bin, { mode: 0o700 }); - mkdirSync(stateDir, { mode: 0o700 }); - const fixture = join(root, "xcrun-fixture"); - copyFileSync(join(import.meta.dir, "fixtures/shutdown-watch-xcrun.sh"), fixture); - chmodSync(fixture, 0o700); - for (const [index, snapshot] of snapshots.entries()) { - const dir = queryDir(index + 1); - mkdirSync(dir, { mode: 0o700 }); - if (snapshot !== null) { - writeFileSync(join(dir, "response.json"), JSON.stringify({ - devices: snapshot.length ? { test: snapshot.map((device) => ({ udid: device, state: "Booted" })) } : {}, - }), { mode: 0o600 }); - } - } - // Only this private wrapper opts into sequenced snapshots. Each query still - // uses the unchanged producer's own started/release/finished barriers. - writeFileSync(join(bin, "xcrun"), `#!/bin/sh -set -eu -root=$SERVE_SIM_TEST_QUERY_DIR -if [ "$#" -ne 5 ] || [ "$1" != simctl ] || [ "$2" != list ] || [ "$3" != devices ] || [ "$4" != booted ] || [ "$5" != -j ]; then - printf 'Refusing unexpected simulator command: %s\\n' "$*" >&2 - exit 88 -fi -for query in ${snapshots.map((_, index) => index + 1).join(" ")}; do - dir="$root/query-$query" - if /bin/mkdir "$dir/claimed" 2>/dev/null; then - export SERVE_SIM_TEST_QUERY_DIR="$dir" - if [ -e "$dir/response.json" ]; then - "$root/xcrun-fixture" "$@" > /dev/null - exec /bin/cat "$dir/response.json" - fi - exec "$root/xcrun-fixture" "$@" - fi -done -printf unexpected > "$root/unexpected-query" -printf 'Refusing an extra boot query\\n' >&2 -exit 88 -`, { mode: 0o700 }); - symlinkSync("/bin/sleep", join(bin, "sleep")); - writeFileSync(join(bin, "open"), "#!/bin/sh\nexit 88\n", { mode: 0o700 }); - // No real xcrun, lsof, or open is reachable. A fallback child's full-device - // lookup and boot are refused before it can reach native preview startup. - } catch (error) { - rmSync(root, { recursive: true, force: true }); - throw error; - } - - const launch = (args: string[]) => { - const child = spawn(process.execPath, args, { env, detached: true, stdio: ["ignore", "pipe", "pipe"] }); - const { promise: closed, resolve: resolveClosed } = Promise.withResolvers(); - const output: ReuseCliProcess = { child, stdout: "", stderr: "", exited: false, error: null, closed }; - children.push(output); - child.stdout?.on("data", (data) => { output.stdout += data; }); - child.stderr?.on("data", (data) => { output.stderr += data; }); - child.once("error", (error) => { output.error = error; }); - child.once("close", () => { output.exited = true; resolveClosed(); }); - return output; - }; - const readRecord = (device = udid) => { - try { return parseDeviceState(readFileSync(stateFile(device), "utf8")); } catch { return null; } - }; - const publish = (record: ServeSimDeviceState) => { - const file = stateFile(record.device); - const next = `${file}.replacement`; - writeFileSync(next, JSON.stringify(record), { mode: 0o600 }); - renameSync(next, file); - }; - const queryStarted = (query: number) => existsSync(join(queryDir(query), "query-started")); - const queryFinished = (query: number) => existsSync(join(queryDir(query), "query-finished")); - const releaseQuery = (query: number) => writeFileSync(join(queryDir(query), "release-query"), "release"); - const hasStartup = (device = udid) => existsSync(startupLog(device)); - const waitForQuery = async (caller: ReuseCliProcess, query: number) => { - await waitFor(() => { - if (caller.error || caller.exited) { - throw new Error(`Follow exited before boot query ${query}: ${caller.error ?? caller.stderr}`); - } - if (queryStarted(query)) return true; - if (hasStartup()) throw new Error(`Follow entered fallback startup before boot query ${query}`); - return false; - }, 10_000, 20); - expect(queryFinished(query)).toBe(false); - }; - const waitForOutcome = async (caller: ReuseCliProcess, records: ServeSimDeviceState[]) => { - await waitFor(() => { - if (caller.error) throw caller.error; - return caller.exited || caller.stdout.includes("\n") || records.some((record) => { - const current = readRecord(record.device); - return hasStartup(record.device) || !current || current.pid !== record.pid || current.port !== record.port; - }); - }, 10_000, 20); - for (const record of records) { - expect(readRecord(record.device)).toEqual(record); - expect(hasStartup(record.device)).toBe(false); - } - await waitFor(() => { - if (caller.error) throw caller.error; - return caller.exited; - }, 5_000, 20); - expect(existsSync(join(root, "unexpected-query"))).toBe(false); - }; - const expectLive = async (record: ServeSimDeviceState) => { - const response = await fetch(record.url, { signal: AbortSignal.timeout(1_500) }); - expect(response.status).toBe(200); - expect(await response.text()).toBe("owned reuse helper"); - }; - const expectReuse = async (caller: ReuseCliProcess, records: ServeSimDeviceState[]) => { - await waitForOutcome(caller, records); - expect(caller.child.exitCode).toBe(0); - const payload = records.map(({ url, streamUrl, wsUrl, port, device }) => ({ url, streamUrl, wsUrl, port, device })); - expect(JSON.parse(caller.stdout)).toEqual(payload.length === 1 ? payload[0] : { devices: payload }); - for (const record of records) { - expect(readRecord(record.device)).toEqual(record); - expect(hasStartup(record.device)).toBe(false); - await expectLive(record); - } - }; - const waitForFallback = async (caller: ReuseCliProcess) => { - await waitFor(() => { - if (caller.error) throw caller.error; - return hasStartup() || caller.exited || caller.stdout.includes("\n"); - }, 10_000, 20); - expect(hasStartup()).toBe(true); - expect(caller.stdout).toBe(""); - expect(readRecord()).toBeNull(); - expect(existsSync(join(root, "unexpected-query"))).toBe(false); - }; - - return { - readRecord, publish, queryStarted, queryFinished, releaseQuery, hasStartup, - waitForQuery, waitForOutcome, expectLive, expectReuse, waitForFallback, - removeRecord: () => rmSync(stateFile()), - follow: async (devices = [udid]) => launch([ - join(import.meta.dir, "../index.ts"), ...devices, - "--no-preview", "--quiet", "--port", String(await freePort()), - ]), - startListener: async (device = udid) => { - const listener = launch(["--eval", ` - const server = Bun.serve({ - hostname: "127.0.0.1", port: 0, - fetch: () => new Response("owned reuse helper"), - }); - console.log(JSON.stringify({ pid: process.pid, port: server.port })); - `]); - await waitFor(() => { - if (listener.error || listener.exited) throw new Error("Listener failed: " + (listener.error ?? listener.stderr)); - return listener.stdout.includes("\n"); - }, 5_000, 20); - const { pid, port } = JSON.parse(listener.stdout); - expect(pid).toBe(listener.child.pid); - return { record: { ...inProcessServeSimState(device, port), pid }, listener }; - }, - cleanup: async () => { - const errors: unknown[] = []; - const isGroupAlive = (pid: number) => { - try { process.kill(-pid, 0); return true; } catch (error: unknown) { - if (error instanceof Error && "code" in error && error.code === "ESRCH") return false; - throw error; - } - }; - const signalGroups = (signal: NodeJS.Signals) => { - for (const { child } of children) { - if (!child.pid) continue; - try { process.kill(-child.pid, signal); } catch (error: unknown) { - if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH") errors.push(error); - } - } - }; - try { - for (let query = 1; query <= snapshots.length; query++) { - try { releaseQuery(query); } catch (error) { errors.push(error); } - } - const closed = Promise.all(children.map(({ closed }) => closed)); - signalGroups("SIGTERM"); - await Promise.race([closed, delay(1_000, undefined, { ref: false })]); - // Signal even closed leaders: their attached fallback/query descendants - // remain in the caller's owned group until they have also exited. - signalGroups("SIGKILL"); - try { - await waitFor(() => children.every(({ child, exited, error }) => - (exited || error !== null) && (!child.pid || !isGroupAlive(child.pid))), 2_000, 20); - } catch (error) { - errors.push(error); - } - } finally { - rmSync(root, { recursive: true, force: true }); - } - if (errors.length) throw new AggregateError(errors, "Owned reuse subprocess cleanup failed"); - }, - }; -} - -test.skipIf(process.platform === "win32")("follow preserves a replacement after a stale unbooted snapshot", async () => { - const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000104", [[], null]); - try { - const original = await h.startListener(); - const replacement = await h.startListener(); - h.publish(original.record); - const caller = await h.follow(); - await h.waitForQuery(caller, 1); - expect(h.readRecord()).toEqual(original.record); - h.publish(replacement.record); - h.releaseQuery(1); - await h.waitForQuery(caller, 2); - expect(h.queryFinished(1)).toBe(true); - expect(h.readRecord()).toEqual(replacement.record); - expect(h.hasStartup()).toBe(false); - h.releaseQuery(2); - await h.expectReuse(caller, [replacement.record]); - expect(caller.stdout).not.toContain(original.record.url); - expect(caller.stdout).not.toContain(`:${original.record.port}`); - } finally { - await h.cleanup(); - } -}, 45_000); - -test.skipIf(process.platform === "win32")("follow recycles an unchanged helper after a fresh unbooted confirmation", async () => { - const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000105", [[], []]); - try { - const original = await h.startListener(); - h.publish(original.record); - const caller = await h.follow(); - await h.waitForQuery(caller, 1); - h.releaseQuery(1); - await h.waitForQuery(caller, 2); - expect(h.queryFinished(1)).toBe(true); - expect(h.readRecord()).toEqual(original.record); - expect(original.listener.exited).toBe(false); - expect(h.hasStartup()).toBe(false); - h.releaseQuery(2); - await h.waitForFallback(caller); - expect(h.queryFinished(2)).toBe(true); - await waitFor(() => original.listener.exited, 5_000, 20); - expect(caller.stdout).not.toContain(original.record.url); - expect(caller.stdout).not.toContain(`:${original.record.port}`); - } finally { - await h.cleanup(); - } -}, 45_000); - -test.skipIf(process.platform === "win32")("follow does not report a helper removed during its boot query", async () => { - const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000106", [null]); - try { - const original = await h.startListener(); - h.publish(original.record); - const caller = await h.follow(); - await h.waitForQuery(caller, 1); - h.removeRecord(); - h.releaseQuery(1); - await h.waitForFallback(caller); - expect(h.queryFinished(1)).toBe(true); - expect(caller.stdout).not.toContain(original.record.url); - expect(caller.stdout).not.toContain(`:${original.record.port}`); - await h.expectLive(original.record); - } finally { - await h.cleanup(); - } -}, 45_000); - -test.skipIf(process.platform === "win32")("follow does not reuse a helper removed during its confirmation query", async () => { - const udid = "00000000-0000-4000-8000-000000000110"; - const h = reuseConfirmationHarness(udid, [[], [udid]]); - try { - const original = await h.startListener(); - h.publish(original.record); - const caller = await h.follow(); - await h.waitForQuery(caller, 1); - h.releaseQuery(1); - await h.waitForQuery(caller, 2); - h.removeRecord(); - h.releaseQuery(2); - await h.waitForFallback(caller); - expect(h.queryFinished(2)).toBe(true); - expect(caller.stdout).not.toContain(original.record.url); - expect(caller.stdout).not.toContain(`:${original.record.port}`); - await h.expectLive(original.record); - } finally { - await h.cleanup(); - } -}, 45_000); - -test.skipIf(process.platform === "win32")("follow preserves the latest registration when negative confirmation overlaps another replacement", async () => { - const h = reuseConfirmationHarness("00000000-0000-4000-8000-000000000107", [[], []]); - try { - const original = await h.startListener(); - const replacement = await h.startListener(); - const latest = await h.startListener(); - h.publish(original.record); - const caller = await h.follow(); - await h.waitForQuery(caller, 1); - h.publish(replacement.record); - h.releaseQuery(1); - await h.waitForQuery(caller, 2); - expect(h.readRecord()).toEqual(replacement.record); - expect(h.hasStartup()).toBe(false); - h.publish(latest.record); - h.releaseQuery(2); - await h.waitForOutcome(caller, [latest.record]); - expect(caller.child.exitCode).toBe(1); - expect(caller.stderr).toMatch(/changed|replaced/i); - expect(caller.stderr).toMatch(/retry|try again|run (?:this|the) command again/i); - expect(caller.stdout).toBe(""); - expect(h.queryFinished(2)).toBe(true); - expect(h.readRecord()).toEqual(latest.record); - expect(h.hasStartup()).toBe(false); - await h.expectLive(latest.record); - } finally { - await h.cleanup(); - } -}, 45_000); - -test.skipIf(process.platform === "win32")("follow confirms an unchanged helper omitted from a cached booted snapshot", async () => { - const udid = "00000000-0000-4000-8000-000000000108"; - const primerUdid = "00000000-0000-4000-8000-000000000109"; - const h = reuseConfirmationHarness(udid, [[primerUdid], null]); - try { - const primer = await h.startListener(primerUdid); - const original = await h.startListener(); - h.publish(primer.record); - h.publish(original.record); - // Reusing the primer fills the same CLI's snapshot cache with a set that - // omits the unchanged second candidate. Only its confirmation includes it. - const caller = await h.follow([primerUdid, udid]); - await h.waitForQuery(caller, 1); - h.releaseQuery(1); - await h.waitForQuery(caller, 2); - expect(h.queryFinished(1)).toBe(true); - expect(h.readRecord(primerUdid)).toEqual(primer.record); - expect(h.readRecord()).toEqual(original.record); - expect(h.hasStartup()).toBe(false); - h.releaseQuery(2); - await h.expectReuse(caller, [primer.record, original.record]); - } finally { - await h.cleanup(); - } -}, 45_000); diff --git a/packages/serve-sim/src/index.ts b/packages/serve-sim/src/index.ts index 5250fe6b4..391226ece 100755 --- a/packages/serve-sim/src/index.ts +++ b/packages/serve-sim/src/index.ts @@ -218,30 +218,11 @@ function readStateFile(file: string): ServerState | null { * instead of being treated as a working stream. A live server started with a * different `--auth-token` (or none), or a different `--allow-exec` opt-in, * is never reused: that is an error. - * Confirm obsolete boot observations once; repeated replacement fails without cleanup. */ async function readReusableState(udid: string, allowExec: boolean): Promise { - const previous = readState(udid); - if (!previous) return null; - const booted = await getBootedUdids(); - let state = readState(udid); + const state = readState(udid); if (!state) return null; - let action = classifyStaleState(state, booted, process.pid); - if ( - previous.pid !== state.pid || - previous.port !== state.port || - action !== "keep" - ) { - const confirmedBooted = await queryBootedUdids(); - const confirmed = readState(udid); - if (!confirmed) return null; - if (confirmed.pid !== state.pid || confirmed.port !== state.port) { - console.error(`Helper for ${udid} changed again while checking boot state; retry the command.`); - process.exit(1); - } - state = confirmed; - action = classifyStaleState(state, confirmedBooted, process.pid); - } + const action = classifyStaleState(state, await getBootedUdids(), process.pid); if (action === "keep") { const mismatch = reuseAuthMismatch(state, resolveAuthToken(undefined)) ?? reuseExecMismatch(state, allowExec);