agentroam 0.2.0-preview.26 → 0.2.0-preview.27

package/dist/install-script-contract.test.js

@@ -1,176 +0,0 @@
-import { chmod, copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { execFileSync, spawnSync } from "node:child_process";
-import { describe, expect, it } from "vitest";
-import { MANAGED_NODE_VERSION, NODE_RUNTIME_ASSETS } from "./node-runtime-manager.js";
-import { MINIMUM_NODE_VERSION, isSupportedNodeVersion } from "../bin/runtime-policy.mjs";
-const installRoot = resolve(import.meta.dirname, "../install");
-describe("standalone installer contracts", () => {
-    it.skipIf(process.platform === "win32")("continues after failed diagnostics but stops when service registration fails", async () => {
-        const root = await mkdtemp(resolve(process.env.TMPDIR || "/tmp", "agentroam-install-diagnostics-"));
-        try {
-            const script = await readFile(resolve(installRoot, "install-agentroam.sh"), "utf8");
-            // Execute the actual post-install flow with a fake CLI, without touching launchd.
-            const start = script.indexOf('if ! "$NODE_BIN" "$entry" doctor');
-            expect(start).toBeGreaterThan(0);
-            const node = resolve(root, "node");
-            const calls = resolve(root, "calls");
-            await writeFile(node, `#!/bin/sh\nprintf '%s\\n' "$2" >> "$TEST_CALLS"\ncase "$2" in\n doctor) exit 1 ;;\n service) exit "$TEST_SERVICE_EXIT" ;;\nesac\n`);
-            await chmod(node, 0o755);
-            for (const serviceExit of [0, 1]) {
-                await writeFile(calls, "");
-                const result = spawnSync("/bin/sh", ["-c", `set -eu\n${script.slice(start)}`], {
-                    encoding: "utf8",
-                    env: { ...process.env, NODE_BIN: node, entry: "fake-cli", DATA_DIR: root, SERVICE_ROOT: root,
-                        WRAPPER_PATH: "agentroam", WRAPPER_DIR: root, AGENTROAM_VERSION: "test",
-                        AGENTROAM_INSTALL_SKIP_SERVICE: "0", AGENTROAM_INSTALL_DESKTOP: "no",
-                        TEST_CALLS: calls, TEST_SERVICE_EXIT: String(serviceExit) },
-                });
-                expect(await readFile(calls, "utf8")).toBe("doctor\nservice\n");
-                expect(result.stderr).toContain("some component checks failed");
-                expect(result.status).toBe(serviceExit);
-                if (serviceExit === 0)
-                    expect(result.stdout).toContain("installed:");
-                else
-                    expect(result.stdout).not.toContain("installed:");
-            }
-        }
-        finally {
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it.skipIf(process.platform !== "darwin" || process.arch !== "arm64")("allows installation from home and keeps a compatible active Node", async () => {
-        const root = await mkdtemp(resolve(process.env.TMPDIR || "/tmp", "agentroam-active-node-"));
-        try {
-            const homeDir = resolve(root, "home");
-            const workspace = resolve(root, "workspace");
-            const activeBin = resolve(root, "active bin");
-            const nvmRoot = resolve(root, "nvm");
-            await Promise.all([mkdir(homeDir), mkdir(workspace), mkdir(activeBin), mkdir(nvmRoot)]);
-            const expected = await fakeNode(resolve(activeBin, "node"), "24.13.0");
-            await fakeNode(resolve(nvmRoot, "versions/node/v26.0.0/bin/node"), "26.0.0");
-            const output = execFileSync("/bin/sh", [resolve(installRoot, "install-agentroam.sh")], {
-                cwd: homeDir, encoding: "utf8",
-                env: { ...process.env, HOME: homeDir, NVM_DIR: nvmRoot, PATH: `${activeBin}:/usr/bin:/bin`,
-                    AGENTROAM_BOOTSTRAP_TEST: "1", AGENTROAM_BOOTSTRAP_NODE_DISCOVERY_ONLY: "1" },
-            });
-            expect(output.trim()).toBe(expected);
-        }
-        finally {
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it("keeps the macOS installer aligned with the runtime manifest", async () => {
-        const scriptPath = resolve(installRoot, "install-agentroam.sh");
-        const script = await readFile(scriptPath, "utf8");
-        expect(script).toContain(`NODE_VERSION="${MANAGED_NODE_VERSION}"`);
-        expect(script).toContain(`MINIMUM_NODE_VERSION="${MINIMUM_NODE_VERSION}"`);
-        expect(script).toContain('AGENTROAM_VERSION_REQUEST="${AGENTROAM_VERSION:-preview}"');
-        expect(script).toContain(NODE_RUNTIME_ASSETS["darwin-arm64"].archive);
-        expect(script).toContain(NODE_RUNTIME_ASSETS["darwin-arm64"].sha256);
-        expect(script).toContain("https://registry.npmjs.org");
-        expect(script).toContain("$HOME/.agentroam");
-        expect(script).toContain("$HOME/.local/bin");
-        expect(script).toContain('AGENTROAM_ROOT');
-        expect(script).toContain('AGENTROAM_INSTALL_SKIP_SERVICE');
-        expect(script).toContain('service install --root "$SERVICE_ROOT" --data-dir "$DATA_DIR"');
-        expect(script).toContain('SERVICE_ROOT="$PWD"');
-        expect(script).toContain("find_nvm_node");
-        expect(script).toContain('${NVM_DIR:-}');
-        expect(script).not.toMatch(/\b(?:brew|sudo|fnm|volta)\b/);
-        execFileSync("sh", ["-n", scriptPath]);
-    });
-    it("keeps the Windows installer aligned with the runtime manifest", async () => {
-        const script = await readFile(resolve(installRoot, "install-agentroam.ps1"), "utf8");
-        expect(script).toContain(`$NodeVersion = "${MANAGED_NODE_VERSION}"`);
-        expect(script).toContain(`$MinimumNodeVersion = "${MINIMUM_NODE_VERSION}"`);
-        expect(script).toContain('$AgentRoamVersionRequest = if ($env:AGENTROAM_VERSION) { $env:AGENTROAM_VERSION } else { "preview" }');
-        expect(script).toContain(NODE_RUNTIME_ASSETS["windows-amd64"].archive);
-        expect(script).toContain(NODE_RUNTIME_ASSETS["windows-amd64"].sha256);
-        expect(script).toContain("https://registry.npmjs.org");
-        expect(script).toContain(".agentroam\\bin");
-        expect(script).toContain('[Environment]::SetEnvironmentVariable("Path", $UpdatedPath, "User")');
-        expect(script).toContain("$env:AGENTROAM_ROOT");
-        expect(script).toContain("$env:AGENTROAM_INSTALL_SKIP_SERVICE");
-        expect(script).toContain("service install --root $ServiceRoot --data-dir $DataDir");
-        expect(script).toContain("(Get-Location).Path");
-        expect(script).toContain("Find-NvmNode");
-        expect(script).toContain("$env:NVM_HOME");
-        expect(script).not.toMatch(/\b(?:winget|choco|scoop|Start-Process\s+.*RunAs)\b/i);
-    });
-    it.skipIf(process.platform !== "darwin" || process.arch !== "arm64")("selects the highest compatible NVM Node without changing the active version", async () => {
-        const root = await mkdtemp(resolve(process.env.TMPDIR || "/tmp", "agentroam-nvm-discovery-"));
-        try {
-            const home = resolve(root, "home");
-            const workspace = resolve(root, "workspace");
-            const activeBin = resolve(root, "active-bin");
-            const nvmRoot = resolve(root, "nvm root with spaces");
-            await Promise.all([mkdir(home), mkdir(workspace), mkdir(activeBin), mkdir(nvmRoot)]);
-            await fakeNode(resolve(activeBin, "node"), "20.19.0");
-            await fakeNode(resolve(nvmRoot, "versions/node/v22.3.0/bin/node"), "22.3.0");
-            await fakeNode(resolve(nvmRoot, "versions/node/v22.22.2/bin/node"), "22.22.2");
-            const expected = await fakeNode(resolve(nvmRoot, "versions/node/v25.8.0/bin/node"), "25.8.0");
-            await fakeNode(resolve(nvmRoot, "versions/node/v22.99.0/bin/node"), "21.99.0");
-            const output = execFileSync("/bin/sh", [resolve(installRoot, "install-agentroam.sh")], {
-                cwd: workspace,
-                encoding: "utf8",
-                env: {
-                    ...process.env,
-                    HOME: home,
-                    NVM_DIR: nvmRoot,
-                    PATH: `${activeBin}:/usr/bin:/bin`,
-                    AGENTROAM_BOOTSTRAP_TEST: "1",
-                    AGENTROAM_BOOTSTRAP_NODE_DISCOVERY_ONLY: "1",
-                },
-            });
-            expect(output.trim().split("\n").at(-1)).toBe(expected);
-            expect(output).toContain("Using Node.js v25.8.0 from NVM");
-        }
-        finally {
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-    it.skipIf(process.platform !== "win32" || !isSupportedNodeVersion(process.versions.node))("selects a compatible nvm-windows Node when the active PATH has no Node", async () => {
-        const root = await mkdtemp(resolve(process.env.TEMP || process.env.TMP || "C:\\Windows\\Temp", "agentroam-nvm-windows-"));
-        try {
-            const home = resolve(root, "home");
-            const workspace = resolve(root, "workspace");
-            const nvmRoot = resolve(root, "nvm root with spaces");
-            const expected = resolve(nvmRoot, `v${process.versions.node}`, "node.exe");
-            await Promise.all([
-                mkdir(home),
-                mkdir(workspace),
-                mkdir(resolve(expected, ".."), { recursive: true }),
-            ]);
-            await copyFile(process.execPath, expected);
-            const output = execFileSync("powershell.exe", [
-                "-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass",
-                "-File", resolve(installRoot, "install-agentroam.ps1"),
-            ], {
-                cwd: workspace,
-                encoding: "utf8",
-                env: {
-                    ...process.env,
-                    HOME: home,
-                    USERPROFILE: home,
-                    APPDATA: resolve(root, "appdata"),
-                    NVM_HOME: nvmRoot,
-                    PATH: `${process.env.SystemRoot || "C:\\Windows"}\\System32`,
-                    AGENTROAM_BOOTSTRAP_TEST: "1",
-                    AGENTROAM_BOOTSTRAP_NODE_DISCOVERY_ONLY: "1",
-                },
-            });
-            expect(output.trim().split(/\r?\n/).at(-1)).toBe(expected);
-            expect(output).toContain(`Using Node.js v${process.versions.node} from NVM`);
-        }
-        finally {
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-});
-async function fakeNode(path, version) {
-    await mkdir(resolve(path, ".."), { recursive: true });
-    await writeFile(path, `#!/bin/sh\ncase "$1" in\n  -p) printf '%s\\n' '${version}' ;;\n  --version) printf '%s\\n' 'v${version}' ;;\nesac\n`);
-    await chmod(path, 0o755);
-    return path;
-}

package/dist/instance-takeover.test.js

@@ -1,121 +0,0 @@
-import { once } from "node:events";
-import { afterEach, expect, it, vi } from "vitest";
-import { mkdtemp, mkdir, writeFile, rm, realpath } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { lockInstanceStartup, stopPreviousInstances } from "./instance-takeover.js";
-const temporary = [];
-afterEach(async () => { await Promise.all(temporary.splice(0).map(path => rm(path, { recursive: true, force: true }))); });
-async function fixture() {
-    const root = await realpath(await mkdtemp(join(tmpdir(), "cli-takeover-")));
-    temporary.push(root);
-    const registry = join(root, "registry");
-    const dataDir = join(root, "data-dir");
-    await mkdir(registry);
-    await mkdir(join(dataDir, "data"), { recursive: true });
-    const descriptor = { protocol: 1, instanceId: "test-instance", pid: 200, url: "http://127.0.0.1:12345", dataDir: join(dataDir, "data"), token: "a".repeat(64) };
-    const save = () => writeFile(join(registry, "test.json"), JSON.stringify(descriptor));
-    await save();
-    const rows = [{ pid: 200, ppid: 100, command: "/node /runtime/ws-server.mjs" }, { pid: 100, ppid: 1, command: "/node /cache/node_modules/agentroam/bin/agentroam.mjs" }];
-    const stop = vi.fn(async () => { });
-    const deps = { registry, request: vi.fn(async () => Response.json(descriptor)), processes: vi.fn(async () => rows), stop, alive: () => false, timeoutMs: 1 };
-    return { descriptor, save, deps, stop, dataDir, rows };
-}
-it("authenticates the same data directory and stops the CLI parent before proceeding", async () => {
-    const f = await fixture();
-    await stopPreviousInstances(f.dataDir, () => { }, f.deps);
-    expect(f.stop).toHaveBeenCalledTimes(1);
-    expect(f.stop).toHaveBeenCalledWith(100);
-    expect(f.deps.processes).toHaveBeenCalledTimes(2);
-});
-it("leaves a different data directory untouched without making an authenticated request", async () => {
-    const f = await fixture();
-    f.descriptor.dataDir = tmpdir();
-    await f.save();
-    await stopPreviousInstances(f.dataDir, () => { }, f.deps);
-    expect(f.deps.request).not.toHaveBeenCalled();
-    expect(f.stop).not.toHaveBeenCalled();
-});
-it("does not send the private token to non-loopback addresses", async () => {
-    const f = await fixture();
-    f.descriptor.url = "https://example.com";
-    await f.save();
-    await stopPreviousInstances(f.dataDir, () => { }, f.deps);
-    expect(f.deps.request).not.toHaveBeenCalled();
-    expect(f.stop).not.toHaveBeenCalled();
-});
-it("rejects a matching live server with a non-CLI parent", async () => {
-    const f = await fixture();
-    f.rows[1].command = "/Applications/Other.app/server";
-    await expect(stopPreviousInstances(f.dataDir, () => { }, f.deps)).rejects.toThrow("无法确认");
-    expect(f.stop).not.toHaveBeenCalled();
-});
-it("does not signal a reused PID", async () => {
-    const f = await fixture();
-    f.deps.processes.mockResolvedValueOnce(f.rows).mockResolvedValueOnce([{ ...f.rows[0], ppid: 300 }, f.rows[1]]);
-    await expect(stopPreviousInstances(f.dataDir, () => { }, f.deps)).rejects.toThrow("身份已变化");
-    expect(f.stop).not.toHaveBeenCalled();
-});
-it("refuses to launch while the previous process still runs", async () => {
-    const f = await fixture();
-    f.deps.alive = () => true;
-    await expect(stopPreviousInstances(f.dataDir, () => { }, f.deps)).rejects.toThrow("尚未退出");
-});
-it("ignores stale dead descriptors but blocks unreachable live instances", async () => {
-    const f = await fixture();
-    f.deps.request = vi.fn(async () => { throw new Error("offline"); });
-    await stopPreviousInstances(f.dataDir, () => { }, f.deps);
-    expect(f.stop).not.toHaveBeenCalled();
-    f.deps.alive = () => true;
-    await expect(stopPreviousInstances(f.dataDir, () => { }, f.deps)).rejects.toThrow("无法核验");
-});
-it("serializes startup and releases the lock for the next launch", async () => {
-    const f = await fixture();
-    const release = await lockInstanceStartup(f.dataDir);
-    await expect(lockInstanceStartup(f.dataDir)).rejects.toThrow("正在启动");
-    await release();
-    await release();
-    await (await lockInstanceStartup(f.dataDir))();
-});
-it.skipIf(process.platform === "win32")("stops an authenticated real CLI parent and waits for its server child to exit", async () => {
-    const { spawn } = await import("node:child_process");
-    const f = await fixture();
-    const cli = join(f.dataDir, "node_modules/agentroam/bin/agentroam.mjs");
-    const server = join(f.dataDir, "runtime/ws-server.mjs");
-    await mkdir(join(f.dataDir, "node_modules/agentroam/bin"), { recursive: true });
-    await mkdir(join(f.dataDir, "runtime"));
-    await writeFile(server, `import http from 'node:http';\nimport {writeFileSync} from 'node:fs';\nconst d=JSON.parse(process.env.DESCRIPTOR);d.pid=process.pid;\nconst s=http.createServer((req,res)=>{if(req.headers['x-agentroam-desktop-token']!==d.token){res.writeHead(401).end();return;}res.setHeader('content-type','application/json');res.end(JSON.stringify(d));});\ns.listen(0,'127.0.0.1',()=>{d.url='http://127.0.0.1:'+s.address().port;writeFileSync(process.env.RECORD,JSON.stringify(d));console.log('ready');});`);
-    await writeFile(cli, `import {spawn} from 'node:child_process';\nimport {writeFileSync} from 'node:fs';\nconst child=spawn(process.execPath,[process.env.SERVER],{stdio:['ignore','inherit','inherit']});\nprocess.on('SIGTERM',()=>{writeFileSync(process.env.MARKER,'graceful');child.kill('SIGTERM');});\nchild.on('exit',()=>process.exit(0));`);
-    const marker = join(f.dataDir, "stopped");
-    const child = spawn(process.execPath, [cli], { env: { ...process.env, SERVER: server, RECORD: join(f.deps.registry, "test.json"), DESCRIPTOR: JSON.stringify(f.descriptor), MARKER: marker }, stdio: ["ignore", "pipe", "pipe"] });
-    const exited = once(child, "exit");
-    try {
-        await once(child.stdout, "data");
-        await stopPreviousInstances(f.dataDir, () => { }, { registry: f.deps.registry, stop: async (pid) => { expect(pid).toBe(child.pid); process.kill(pid, "SIGTERM"); } });
-        await exited;
-        const { readFile } = await import("node:fs/promises");
-        expect(await readFile(marker, "utf8")).toBe("graceful");
-    }
-    finally {
-        if (child.exitCode === null) {
-            child.kill("SIGTERM");
-            await exited;
-        }
-    }
-});
-it("stops an authenticated orphan only when its executable belongs to a runtime package", async () => {
-    const f = await fixture();
-    const pkg = join(f.dataDir, "launcher/0.2.0-preview.18/node_modules/agentroam-runtime-darwin-arm64");
-    await mkdir(join(pkg, "runtime"), { recursive: true });
-    await writeFile(join(pkg, "package.json"), JSON.stringify({ name: "agentroam-runtime-darwin-arm64" }));
-    await writeFile(join(pkg, "runtime/ws-server.mjs"), "// fixture");
-    f.rows.splice(0, f.rows.length, { pid: 200, ppid: 1, command: `/node ${join(pkg, "runtime/ws-server.mjs")}` });
-    await stopPreviousInstances(f.dataDir, () => { }, f.deps);
-    expect(f.stop).toHaveBeenCalledWith(200);
-});
-it("does not stop an orphan merely because its script is named ws-server.mjs", async () => {
-    const f = await fixture();
-    f.rows.splice(0, f.rows.length, { pid: 200, ppid: 1, command: "/node /unrelated/ws-server.mjs" });
-    await expect(stopPreviousInstances(f.dataDir, () => { }, f.deps)).rejects.toThrow("无法确认");
-    expect(f.stop).not.toHaveBeenCalled();
-});

package/dist/native-runtime.test.js

@@ -1,40 +0,0 @@
-import { mkdtemp, mkdir, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { probeSQLiteRuntime, probeTerminalRuntime, repairNativeRuntimePermissions } from "./native-runtime.js";
-describe("native runtime health", () => {
-    it("detects lazy SQLite binding failures after require succeeds", () => {
-        const requireRuntime = (() => class Database {
-            constructor() { throw new Error("native binding unavailable"); }
-        });
-        expect(() => probeSQLiteRuntime(requireRuntime)).toThrow("native binding unavailable");
-    });
-    it("closes SQLite when its query fails", () => {
-        const close = vi.fn();
-        const requireRuntime = (() => class Database {
-            exec() { throw new Error("database failed"); }
-            close = close;
-        });
-        expect(() => probeSQLiteRuntime(requireRuntime)).toThrow("database failed");
-        expect(close).toHaveBeenCalledOnce();
-    });
-    it("detects PTY spawn failures after require succeeds", async () => {
-        const requireRuntime = (() => ({ spawn() { throw new Error("spawn-helper unavailable"); } }));
-        await expect(probeTerminalRuntime(requireRuntime)).rejects.toThrow("spawn-helper unavailable");
-    });
-});
-describe("repairNativeRuntimePermissions", () => {
-    it("restores the node-pty helper execute bits stripped by npm pack", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-native-"));
-        const helper = resolve(root, "node_modules/node-pty/prebuilds/darwin-arm64/spawn-helper");
-        await mkdir(resolve(helper, ".."), { recursive: true });
-        await writeFile(helper, "helper", { mode: 0o644 });
-        await repairNativeRuntimePermissions(root, "darwin", "arm64");
-        expect((await stat(helper)).mode & 0o111).toBe(0o111);
-    });
-    it("fails before gateway startup when the helper is missing", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-native-missing-"));
-        await expect(repairNativeRuntimePermissions(root, "darwin", "arm64")).rejects.toThrow("spawn-helper missing");
-    });
-});

package/dist/network.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findLanUrl } from "./network.js";
-describe("findLanUrl", () => {
-    it("prefers an RFC1918 address over VPN and public interfaces", () => {
-        expect(findLanUrl(52032, {
-            utun7: [{ address: "100.121.10.115", netmask: "255.255.255.255", family: "IPv4", mac: "", internal: false, cidr: null }],
-            en0: [{ address: "10.22.34.143", netmask: "255.255.252.0", family: "IPv4", mac: "", internal: false, cidr: null }],
-        })).toBe("http://10.22.34.143:52032");
-    });
-    it("falls back to the first external IPv4 address", () => {
-        expect(findLanUrl(4100, {
-            utun7: [{ address: "100.121.10.115", netmask: "255.255.255.255", family: "IPv4", mac: "", internal: false, cidr: null }],
-        })).toBe("http://100.121.10.115:4100");
-    });
-    it("returns null when only loopback is available", () => {
-        expect(findLanUrl(4100, {
-            lo0: [{ address: "127.0.0.1", netmask: "255.0.0.0", family: "IPv4", mac: "", internal: true, cidr: null }],
-        })).toBeNull();
-    });
-});

package/dist/node-preflight.test.js

@@ -1,136 +0,0 @@
-import { EventEmitter } from "node:events";
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-// @ts-expect-error The preflight intentionally remains plain ESM for Node 18 bootstrap.
-import { findNvmNode, parsePreflightDataDir, runNodePreflight } from "../bin/node-preflight.mjs";
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })));
-});
-describe("Node launcher preflight", () => {
-    it.each(["22.22.0", "22.23.0", "24.0.0", "25.8.0", "26.0.0", "100.0.0"])("passes through Node %s without installing or switching", async (nodeVersion) => {
-        const ensureNode = vi.fn();
-        const findSystemNode = vi.fn();
-        const spawnChild = vi.fn();
-        await expect(runNodePreflight({ nodeVersion, ensureNode, findSystemNode, spawnChild, environment: { AGENTROAM_MANAGED_NODE: "/older/node" } })).resolves.toEqual({ handled: false });
-        expect(ensureNode).not.toHaveBeenCalled();
-        expect(findSystemNode).not.toHaveBeenCalled();
-        expect(spawnChild).not.toHaveBeenCalled();
-    });
-    it.each(["18.20.0", "20.18.0", "22.1.0", "22.21.9"])("re-executes Node %s through the managed runtime", async (nodeVersion) => {
-        const child = fakeChild(0, null);
-        const ensureNode = vi.fn(async () => ({ executable: "/managed/node", version: "22.22.0" }));
-        const spawnChild = vi.fn((_executable, _args, _options) => child);
-        const result = await runNodePreflight({
-            argv: ["doctor", "--data-dir", "./custom"],
-            nodeVersion,
-            platform: "darwin",
-            arch: "arm64",
-            launcherPath: "/launcher/agentroam.mjs",
-            environment: { PATH: "" },
-            ensureNode,
-            findSystemNode: async () => null,
-            spawnChild,
-            processHost: fakeProcessHost(),
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0, signal: null });
-        expect(ensureNode).toHaveBeenCalledWith(expect.objectContaining({
-            dataDir: resolve("./custom"),
-            target: "darwin-arm64",
-        }));
-        expect(spawnChild).toHaveBeenCalledWith("/managed/node", ["/launcher/agentroam.mjs", "doctor", "--data-dir", "./custom"], expect.objectContaining({
-            stdio: "inherit",
-            env: expect.objectContaining({ AGENTROAM_MANAGED_NODE: "/managed/node" }),
-        }));
-    });
-    it("reuses another visible compatible system Node", async () => {
-        const ensureNode = vi.fn();
-        const spawnChild = vi.fn((_executable, _args, _options) => fakeChild(7, null));
-        await expect(runNodePreflight({
-            argv: ["version"],
-            nodeVersion: "20.0.0",
-            platform: "win32",
-            arch: "x64",
-            environment: { PATH: "" },
-            findSystemNode: async () => "C:\\Node25\\node.exe",
-            ensureNode,
-            spawnChild,
-            processHost: fakeProcessHost(),
-        })).resolves.toMatchObject({ handled: true, exitCode: 7 });
-        expect(ensureNode).not.toHaveBeenCalled();
-        expect(spawnChild.mock.calls[0][0]).toBe("C:\\Node25\\node.exe");
-    });
-    it.skipIf(process.platform === "win32")("selects the highest compatible inactive NVM Node", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-preflight-nvm-"));
-        temporaryDirectories.push(root);
-        await fakeNodeExecutable(resolve(root, "versions/node/v22.3.0/bin/node"), "22.3.0");
-        await fakeNodeExecutable(resolve(root, "versions/node/v22.22.2/bin/node"), "22.22.2");
-        await fakeNodeExecutable(resolve(root, "versions/node/v23.1.0/bin/node"), "23.1.0");
-        const expected = await fakeNodeExecutable(resolve(root, "versions/node/v25.8.0/bin/node"), "25.8.0");
-        await fakeNodeExecutable(resolve(root, "versions/node/v26.0.0-rc.1/bin/node"), "26.0.0-rc.1");
-        await expect(findNvmNode({ NVM_DIR: root, HOME: resolve(root, "home") }, "darwin"))
-            .resolves.toBe(expected);
-    });
-    it("rejects a failed managed re-entry instead of looping", async () => {
-        await expect(runNodePreflight({
-            nodeVersion: "22.21.9",
-            environment: { AGENTROAM_MANAGED_NODE: "22.22.0" },
-        })).rejects.toMatchObject({ message: expect.stringContaining("re-entry failed"), exitCode: 2 });
-    });
-    it("directs old Node versions to the standalone installer", async () => {
-        await expect(runNodePreflight({
-            nodeVersion: "16.20.0",
-            platform: "darwin",
-            environment: {},
-        })).rejects.toThrow("install-agentroam.sh");
-        await expect(runNodePreflight({
-            nodeVersion: "12.0.0",
-            platform: "win32",
-            environment: {},
-        })).rejects.toThrow("install-agentroam.ps1");
-    });
-    it("forwards termination signals and propagates a child signal", async () => {
-        const processHost = fakeProcessHost();
-        const child = new EventEmitter();
-        child.kill = vi.fn();
-        const running = runNodePreflight({
-            nodeVersion: "20.0.0",
-            platform: "darwin",
-            arch: "arm64",
-            environment: { PATH: "" },
-            findSystemNode: async () => "/compatible-node",
-            spawnChild: () => child,
-            processHost,
-        });
-        await new Promise((resolveTurn) => setImmediate(resolveTurn));
-        processHost.emit("SIGTERM");
-        expect(child.kill).toHaveBeenCalledWith("SIGTERM");
-        child.emit("exit", null, "SIGTERM");
-        await expect(running).resolves.toEqual({ handled: true, exitCode: null, signal: "SIGTERM" });
-    });
-    it("parses data directory overrides before the CLI import", () => {
-        expect(parsePreflightDataDir(["start", "--data-dir", "./data"], {}, "/home/me")).toBe(resolve("./data"));
-        expect(parsePreflightDataDir([], { AGENTROAM_DATA_DIR: "/custom" }, "/home/me")).toBe("/custom");
-        expect(parsePreflightDataDir([], {}, "/home/me")).toBe(resolve("/home/me", ".agentroam"));
-        expect(() => parsePreflightDataDir(["--data-dir"], {}, "/home/me")).toThrow("missing value");
-    });
-});
-function fakeChild(exitCode, signal) {
-    const child = new EventEmitter();
-    child.kill = vi.fn();
-    setImmediate(() => child.emit("exit", exitCode, signal));
-    return child;
-}
-function fakeProcessHost() {
-    const host = new EventEmitter();
-    host.stderr = { write: vi.fn() };
-    return host;
-}
-async function fakeNodeExecutable(path, version) {
-    await mkdir(resolve(path, ".."), { recursive: true });
-    await writeFile(path, `#!/bin/sh\nprintf '%s\\n' '${version}'\n`);
-    await chmod(path, 0o755);
-    return path;
-}