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

package/dist/node-runtime-manager.test.js

@@ -1,184 +0,0 @@
-import { mkdir, mkdtemp, readFile, readdir, rm, utimes, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, resolve } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { MANAGED_NODE_VERSION, NODE_RUNTIME_ASSETS, detectNodeRuntimeTarget, ensureManagedNode, managedNodeExecutable, managedNodeNpmCli, } from "./node-runtime-manager.js";
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })));
-});
-describe("managed Node.js runtime", () => {
-    it("uses the exact official manifest", () => {
-        expect(MANAGED_NODE_VERSION).toBe("22.22.0");
-        expect(NODE_RUNTIME_ASSETS["darwin-arm64"]).toEqual({
-            archive: "node-v22.22.0-darwin-arm64.tar.xz",
-            sha256: "2bd596bbfc4a275ceb8721a5954ee97daea5ebe673e96a185ebd732f6fb023ac",
-            archiveRoot: "node-v22.22.0-darwin-arm64",
-        });
-        expect(NODE_RUNTIME_ASSETS["windows-amd64"].archive).toBe("node-v22.22.0-win-x64.zip");
-    });
-    it("selects only supported managed targets", () => {
-        expect(detectNodeRuntimeTarget("darwin", "arm64")).toBe("darwin-arm64");
-        expect(detectNodeRuntimeTarget("win32", "x64")).toBe("windows-amd64");
-        expect(() => detectNodeRuntimeTarget("darwin", "x64")).toThrow("unsupported");
-        expect(() => detectNodeRuntimeTarget("linux", "x64")).toThrow("unsupported");
-    });
-    it("reuses a validated cached runtime", async () => {
-        const dataDir = await temporaryRoot();
-        await fakeRuntime(dataDir, "darwin-arm64");
-        const download = vi.fn();
-        const resolution = await ensureManagedNode({
-            dataDir,
-            target: "darwin-arm64",
-            dependencies: { download, run: versionRunner() },
-        });
-        expect(resolution.executable).toBe(managedNodeExecutable(dataDir, "darwin-arm64"));
-        expect(resolution.npmCli).toBe(managedNodeNpmCli(dataDir, "darwin-arm64"));
-        expect(download).not.toHaveBeenCalled();
-    });
-    it("downloads, extracts, validates, and atomically activates a runtime", async () => {
-        const dataDir = await temporaryRoot();
-        const download = vi.fn(async (_url, destination) => writeFile(destination, "archive"));
-        const run = extractionRunner("darwin-arm64");
-        const resolution = await ensureManagedNode({
-            dataDir,
-            target: "darwin-arm64",
-            dependencies: {
-                download,
-                sha256: async () => NODE_RUNTIME_ASSETS["darwin-arm64"].sha256,
-                run,
-            },
-        });
-        expect(download).toHaveBeenCalledWith("https://nodejs.org/dist/v22.22.0/node-v22.22.0-darwin-arm64.tar.xz", expect.any(String), 10 * 60_000);
-        expect(resolution.version).toBe(MANAGED_NODE_VERSION);
-        expect(await readFile(resolution.npmCli, "utf8")).toBe("npm");
-    });
-    it("rejects a checksum mismatch and cleans temporary state", async () => {
-        const dataDir = await temporaryRoot();
-        await expect(ensureManagedNode({
-            dataDir,
-            target: "darwin-arm64",
-            dependencies: {
-                download: async (_url, destination) => writeFile(destination, "bad"),
-                sha256: async () => "bad-checksum",
-            },
-        })).rejects.toThrow("checksum mismatch");
-        expect(await readdir(resolve(dataDir, "runtimes", "node"))).toEqual([]);
-    });
-    it("rejects an unexpected archive root", async () => {
-        const dataDir = await temporaryRoot();
-        await expect(ensureManagedNode({
-            dataDir,
-            target: "darwin-arm64",
-            dependencies: {
-                download: async (_url, destination) => writeFile(destination, "archive"),
-                sha256: async () => NODE_RUNTIME_ASSETS["darwin-arm64"].sha256,
-                run: async (command, args) => {
-                    if (command === "/usr/bin/tar")
-                        await mkdir(resolve(args[args.indexOf("-C") + 1], "wrong-root"));
-                    return { stdout: "", stderr: "" };
-                },
-            },
-        })).rejects.toThrow("unexpected Node.js archive root");
-    });
-    it("rejects a runtime that reports the wrong version", async () => {
-        const dataDir = await temporaryRoot();
-        const run = extractionRunner("darwin-arm64", "v22.21.0");
-        await expect(ensureManagedNode({
-            dataDir,
-            target: "darwin-arm64",
-            dependencies: {
-                download: async (_url, destination) => writeFile(destination, "archive"),
-                sha256: async () => NODE_RUNTIME_ASSETS["darwin-arm64"].sha256,
-                run,
-            },
-        })).rejects.toThrow("validation failed");
-    });
-    it("serializes concurrent installs", async () => {
-        const dataDir = await temporaryRoot();
-        let downloads = 0;
-        const dependencies = {
-            download: async (_url, destination) => {
-                downloads += 1;
-                await new Promise((resolveDelay) => setTimeout(resolveDelay, 30));
-                await writeFile(destination, "archive");
-            },
-            sha256: async () => NODE_RUNTIME_ASSETS["darwin-arm64"].sha256,
-            run: extractionRunner("darwin-arm64"),
-        };
-        const [first, second] = await Promise.all([
-            ensureManagedNode({ dataDir, target: "darwin-arm64", dependencies }),
-            ensureManagedNode({ dataDir, target: "darwin-arm64", dependencies }),
-        ]);
-        expect(downloads).toBe(1);
-        expect(second.executable).toBe(first.executable);
-    });
-    it("recovers a stale lock", async () => {
-        const dataDir = await temporaryRoot();
-        const lockPath = resolve(dataDir, "runtimes", "node", `${MANAGED_NODE_VERSION}.lock`);
-        await mkdir(dirname(lockPath), { recursive: true });
-        await writeFile(lockPath, "stale");
-        await utimes(lockPath, new Date(0), new Date(0));
-        const resolution = await ensureManagedNode({
-            dataDir,
-            target: "darwin-arm64",
-            staleLockMs: 1,
-            dependencies: {
-                download: async (_url, destination) => writeFile(destination, "archive"),
-                sha256: async () => NODE_RUNTIME_ASSETS["darwin-arm64"].sha256,
-                run: extractionRunner("darwin-arm64"),
-            },
-        });
-        expect(resolution.version).toBe(MANAGED_NODE_VERSION);
-    });
-    it("uses the Windows executable and npm layout", async () => {
-        const dataDir = await temporaryRoot();
-        await fakeRuntime(dataDir, "windows-amd64");
-        await expect(ensureManagedNode({
-            dataDir,
-            target: "windows-amd64",
-            dependencies: { run: versionRunner() },
-        })).resolves.toMatchObject({
-            executable: managedNodeExecutable(dataDir, "windows-amd64"),
-            npmCli: managedNodeNpmCli(dataDir, "windows-amd64"),
-        });
-    });
-});
-async function temporaryRoot() {
-    const root = await mkdtemp(resolve(tmpdir(), "agentroam-node-runtime-"));
-    temporaryDirectories.push(root);
-    return root;
-}
-async function fakeRuntime(dataDir, target) {
-    const executable = managedNodeExecutable(dataDir, target);
-    const npmCli = managedNodeNpmCli(dataDir, target);
-    await mkdir(dirname(executable), { recursive: true });
-    await mkdir(dirname(npmCli), { recursive: true });
-    await writeFile(executable, "node");
-    await writeFile(npmCli, "npm");
-}
-function versionRunner(version = `v${MANAGED_NODE_VERSION}`) {
-    return async () => ({ stdout: `${version}\n`, stderr: "" });
-}
-function extractionRunner(target, version = `v${MANAGED_NODE_VERSION}`) {
-    return vi.fn(async (command, args) => {
-        if (command === "/usr/bin/tar" || command === "powershell.exe") {
-            const extractRoot = command === "/usr/bin/tar"
-                ? args[args.indexOf("-C") + 1]
-                : args.at(-1);
-            const archiveRoot = resolve(extractRoot, NODE_RUNTIME_ASSETS[target].archiveRoot);
-            const executable = target === "windows-amd64"
-                ? resolve(archiveRoot, "node.exe")
-                : resolve(archiveRoot, "bin", "node");
-            const npmCli = target === "windows-amd64"
-                ? resolve(archiveRoot, "node_modules", "npm", "bin", "npm-cli.js")
-                : resolve(archiveRoot, "lib", "node_modules", "npm", "bin", "npm-cli.js");
-            await mkdir(dirname(executable), { recursive: true });
-            await mkdir(dirname(npmCli), { recursive: true });
-            await writeFile(executable, "node");
-            await writeFile(npmCli, "npm");
-            return { stdout: "", stderr: "" };
-        }
-        return { stdout: `${version}\n`, stderr: "" };
-    });
-}

package/dist/opencode-runtime-manager.test.js

@@ -1,111 +0,0 @@
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { OPENCODE_RUNTIME_VERSION, OPENCODE_MINIMUM_VERSION, managedOpenCodeBinaryCandidates, parseOpenCodeVersion, resolveOpenCodeRuntime, } from "./opencode-runtime-manager.js";
-const roots = [];
-afterEach(async () => {
-    await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
-async function executable(name = "opencode") {
-    const root = await mkdtemp(join(tmpdir(), "agentroam-opencode-"));
-    roots.push(root);
-    const path = join(root, name);
-    await writeFile(path, "#!/bin/sh\nexit 0\n");
-    await chmod(path, 0o755);
-    return { root, path };
-}
-describe("resolveOpenCodeRuntime", () => {
-    it("prefers a compatible absolute override", async () => {
-        const binary = await executable();
-        const run = vi.fn(async (_command, args) => ({
-            stdout: args[0] === "--version" ? `opencode ${OPENCODE_RUNTIME_VERSION}` : "help",
-            stderr: "",
-        }));
-        await expect(resolveOpenCodeRuntime({
-            dataDir: binary.root,
-            target: "darwin-arm64",
-            environment: { AGENT_OPENCODE_BIN: binary.path, PATH: "" },
-            platform: "darwin",
-            dependencies: { run },
-        })).resolves.toEqual({ executable: binary.path, version: OPENCODE_RUNTIME_VERSION, source: "explicit" });
-        expect(run).toHaveBeenCalledWith(binary.path, ["serve", "--help"], 5_000);
-    });
-    it.each([OPENCODE_MINIMUM_VERSION, "1.18.30", "1.18.100", "1.19.0", "2.0.0"])("reuses PATH version %s without installation", async (version) => {
-        const binary = await executable();
-        const run = vi.fn(async (_command, args) => ({
-            stdout: args[0] === "--version" ? version : "serve help", stderr: "",
-        }));
-        await expect(resolveOpenCodeRuntime({
-            dataDir: binary.root, target: "darwin-arm64", platform: "darwin",
-            environment: { PATH: binary.root }, dependencies: { run },
-        })).resolves.toEqual({ executable: binary.path, version, source: "global" });
-        expect(run.mock.calls.map(([, args]) => args)).toEqual([["--version"], ["serve", "--help"]]);
-    });
-    it.each(["1.18.26", "1.18.9", "1.17.99", "0.99.99", "dev", "1.19.0-beta.1", "01.19.0"])("rejects unsupported explicit version %s", async (version) => {
-        const binary = await executable();
-        const run = vi.fn(async () => ({ stdout: version, stderr: "" }));
-        await expect(resolveOpenCodeRuntime({
-            dataDir: binary.root, target: "darwin-arm64", platform: "darwin",
-            environment: { AGENT_OPENCODE_BIN: binary.path, PATH: "" }, dependencies: { run },
-        })).rejects.toThrow(/requires >=|Unable to parse OpenCode version/);
-        expect(run).toHaveBeenCalledTimes(1);
-    });
-    it("rejects a newer executable without serve support", async () => {
-        const binary = await executable();
-        await expect(resolveOpenCodeRuntime({
-            dataDir: binary.root, target: "darwin-arm64", platform: "darwin",
-            environment: { AGENT_OPENCODE_BIN: binary.path, PATH: "" },
-            dependencies: { run: async (_command, args) => {
-                    if (args[0] === "serve")
-                        throw new Error("serve unavailable");
-                    return { stdout: "1.18.30", stderr: "" };
-                } },
-        })).rejects.toThrow("serve unavailable");
-    });
-    it("rejects relative explicit overrides", async () => {
-        await expect(resolveOpenCodeRuntime({
-            dataDir: "/data",
-            target: "darwin-arm64",
-            environment: { AGENT_OPENCODE_BIN: "opencode", PATH: "" },
-            platform: "darwin",
-        })).rejects.toThrow("absolute path");
-    });
-    it("uses a compatible PATH executable", async () => {
-        const binary = await executable();
-        await expect(resolveOpenCodeRuntime({
-            dataDir: join(binary.root, "data"),
-            target: "darwin-arm64",
-            environment: { PATH: binary.root },
-            platform: "darwin",
-            dependencies: { run: async () => ({ stdout: OPENCODE_RUNTIME_VERSION, stderr: "" }) },
-        })).resolves.toMatchObject({ executable: binary.path, source: "global" });
-    });
-    it("reuses a validated managed installation", async () => {
-        const root = await mkdtemp(join(tmpdir(), "agentroam-opencode-managed-"));
-        roots.push(root);
-        const managedRoot = join(root, "runtimes", "opencode", OPENCODE_RUNTIME_VERSION);
-        const candidate = managedOpenCodeBinaryCandidates(managedRoot, "darwin")[0];
-        await mkdir(join(candidate, ".."), { recursive: true });
-        await writeFile(candidate, "#!/bin/sh\nexit 0\n");
-        await chmod(candidate, 0o755);
-        await expect(resolveOpenCodeRuntime({
-            dataDir: root,
-            target: "darwin-arm64",
-            environment: { PATH: "" },
-            platform: "darwin",
-            dependencies: { run: async () => ({ stdout: OPENCODE_RUNTIME_VERSION, stderr: "" }) },
-        })).resolves.toEqual({ executable: candidate, version: OPENCODE_RUNTIME_VERSION, source: "managed" });
-    });
-});
-describe("OpenCode runtime helpers", () => {
-    it("parses only semantic versions", () => {
-        expect(parseOpenCodeVersion("opencode 1.18.27")).toBe("1.18.27");
-        expect(parseOpenCodeVersion("dev")).toBeNull();
-    });
-    it("keeps managed binary candidates under the runtime root", () => {
-        expect(managedOpenCodeBinaryCandidates("/data/runtime", "darwin")[0])
-            .toBe("/data/runtime/node_modules/opencode-ai/bin/opencode.exe");
-        expect(managedOpenCodeBinaryCandidates("C:\\runtime", "win32").some((path) => path.endsWith("opencode.cmd"))).toBe(true);
-    });
-});

package/dist/pairing.js

@@ -1,2 +0,0 @@
-import { createHash, randomBytes } from "node:crypto";
-export function createPairingSecret(now = Date.now()) { const token = randomBytes(32).toString("base64url"); return { token, hashHex: createHash("sha256").update(token).digest("hex"), expiresAt: new Date(now + 5 * 60 * 1000).toISOString() }; }

package/dist/platform-packages.test.js

@@ -1,86 +0,0 @@
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-import { PLATFORM_DEPENDENCY_VERSIONS, requirePlatformPackages, resolvePlatformRuntime, resolvePlatformTui, } from "./platform-packages.js";
-describe("platform packages", () => {
-    it("maps macOS arm64 and Windows x64 package names", () => {
-        expect(requirePlatformPackages("darwin-arm64")).toEqual({
-            runtime: "agentroam-runtime-darwin-arm64",
-            cloudflared: "agentroam-cloudflared-darwin-arm64",
-            tui: "agentroam-tui-darwin-arm64",
-        });
-        expect(requirePlatformPackages("windows-amd64")).toEqual({
-            runtime: "agentroam-runtime-win32-x64",
-            cloudflared: "agentroam-cloudflared-win32-x64",
-            tui: "@caoqu/agentroam-tui-win32-x64",
-        });
-    });
-    it("rejects targets without a published package set", () => {
-        expect(() => requirePlatformPackages("darwin-amd64")).toThrow("unavailable for darwin-amd64");
-    });
-    it("resolves a matching runtime manifest", () => {
-        const root = mkdtempSync(resolve(tmpdir(), "agentroam-runtime-resolver-"));
-        const manifestPath = resolve(root, "manifest.json");
-        const runtimePackageJson = resolve(root, "runtime/package.json");
-        mkdirSync(dirname(runtimePackageJson), { recursive: true });
-        writeFileSync(runtimePackageJson, "{}");
-        writeFileSync(manifestPath, JSON.stringify({
-            packageVersion: PLATFORM_DEPENDENCY_VERSIONS["agentroam-runtime-win32-x64"],
-            target: "windows-amd64",
-            schemaVersion: 2,
-            minimumNodeVersion: "22.22.0",
-            nativeFiles: { "node_modules/example.node": "a".repeat(64) },
-        }));
-        const resolved = resolvePlatformRuntime("windows-amd64", fakeRequire({
-            "/manifest.json": manifestPath,
-            "/runtime": runtimePackageJson,
-        }));
-        expect(resolved.runtimeRoot).toBe(dirname(runtimePackageJson));
-        expect(resolved.manifest.target).toBe("windows-amd64");
-    });
-    it("rejects mismatched runtime versions and targets", () => {
-        const root = mkdtempSync(resolve(tmpdir(), "agentroam-runtime-invalid-"));
-        const manifestPath = resolve(root, "manifest.json");
-        const runtimePackageJson = resolve(root, "runtime/package.json");
-        mkdirSync(dirname(runtimePackageJson), { recursive: true });
-        writeFileSync(runtimePackageJson, "{}");
-        writeFileSync(manifestPath, JSON.stringify({
-            packageVersion: "0.0.0",
-            target: "darwin-arm64",
-            schemaVersion: 2,
-            minimumNodeVersion: "22.22.0",
-            nativeFiles: {},
-        }));
-        expect(() => resolvePlatformRuntime("windows-amd64", fakeRequire({
-            "/manifest.json": manifestPath,
-            "/runtime": runtimePackageJson,
-        }))).toThrow("invalid AgentRoam runtime manifest");
-    });
-    it("resolves the target TUI entry", () => {
-        const entry = resolvePlatformTui("windows-amd64", fakeRequire({ "/entry": "C:\\agentroam\\agent-tui.js" }));
-        expect(entry).toBe("C:\\agentroam\\agent-tui.js");
-    });
-    it("rejects legacy ABI manifests even when their release version matches", () => {
-        const root = mkdtempSync(resolve(tmpdir(), "agentroam-runtime-legacy-"));
-        const manifestPath = resolve(root, "manifest.json");
-        writeFileSync(manifestPath, JSON.stringify({
-            packageVersion: PLATFORM_DEPENDENCY_VERSIONS["agentroam-runtime-darwin-arm64"], target: "darwin-arm64",
-            nodeMajor: 22, nodeModuleAbi: 127, nativeFiles: {},
-        }));
-        expect(() => resolvePlatformRuntime("darwin-arm64", fakeRequire({
-            "/manifest.json": manifestPath, "/runtime": resolve(root, "runtime/package.json"),
-        }))).toThrow("invalid AgentRoam runtime manifest");
-    });
-});
-function fakeRequire(suffixes) {
-    return {
-        resolve(id) {
-            for (const [suffix, value] of Object.entries(suffixes)) {
-                if (id.endsWith(suffix))
-                    return value;
-            }
-            throw Object.assign(new Error(`missing ${id}`), { code: "MODULE_NOT_FOUND" });
-        },
-    };
-}

package/dist/platform.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectPlatform, detectPlatformTarget } from "./platform.js";
-describe("detectPlatform", () => {
-    it("maps supported targets", () => {
-        expect(detectPlatform("darwin", "arm64", "22.22.0")).toBe("darwin-arm64");
-        expect(detectPlatform("win32", "x64", "25.8.0")).toBe("windows-amd64");
-    });
-    it("detects a target before Node version validation", () => {
-        expect(detectPlatformTarget("darwin", "arm64")).toBe("darwin-arm64");
-        expect(detectPlatformTarget("win32", "x64")).toBe("windows-amd64");
-    });
-    it("rejects unsupported versions", () => {
-        expect(() => detectPlatform("darwin", "arm64", "22.21.9")).toThrow("Node.js >=22.22.0");
-    });
-    it("rejects unsupported platforms", () => {
-        expect(() => detectPlatformTarget("linux", "x64")).toThrow("unsupported platform");
-    });
-});

package/dist/port.test.js

@@ -1,3 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findAvailablePort } from "./port.js";
-describe("ports", () => { it("asks the OS for a free port", async () => expect(await findAvailablePort(null)).toBeGreaterThan(0)); });

package/dist/power/sleep-inhibitor.test.js

@@ -1,104 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-import { acquireSleepInhibitor, buildWindowsSleepInhibitorScript } from "./sleep-inhibitor.js";
-function fakeChild(withPipes = false) {
-    const child = new EventEmitter();
-    Object.assign(child, {
-        pid: 9001,
-        exitCode: null,
-        signalCode: null,
-        stdout: withPipes ? new PassThrough() : null,
-        stderr: withPipes ? new PassThrough() : null,
-        kill: vi.fn((signal) => {
-            Object.assign(child, { signalCode: signal });
-            queueMicrotask(() => child.emit("exit", null, signal));
-            return true;
-        }),
-    });
-    return child;
-}
-describe("sleep inhibitor", () => {
-    it("uses caffeinate to prevent idle sleep without preventing display sleep", async () => {
-        const child = fakeChild();
-        const spawnProcess = vi.fn(() => {
-            queueMicrotask(() => child.emit("spawn"));
-            return child;
-        });
-        const inhibitor = await acquireSleepInhibitor({
-            platform: "darwin",
-            pid: 4321,
-            spawnProcess: spawnProcess,
-            readyTimeoutMs: 50,
-            stopTimeoutMs: 50,
-        });
-        expect(spawnProcess).toHaveBeenCalledWith("/usr/bin/caffeinate", ["-i", "-w", "4321"], {
-            stdio: "ignore",
-            windowsHide: true,
-        });
-        const calls = spawnProcess.mock.calls;
-        expect(calls[0][1]).not.toContain("-d");
-        await inhibitor.release();
-        await inhibitor.release();
-        expect(child.kill).toHaveBeenCalledTimes(1);
-    });
-    it("uses only the Windows system-required execution state", async () => {
-        const child = fakeChild(true);
-        const spawnProcess = vi.fn(() => {
-            queueMicrotask(() => {
-                child.emit("spawn");
-                child.stdout.write("AGENTROAM_SLEEP_INHIBITOR_READY\n");
-            });
-            return child;
-        });
-        const inhibitor = await acquireSleepInhibitor({
-            platform: "win32",
-            pid: 7654,
-            spawnProcess: spawnProcess,
-            readyTimeoutMs: 50,
-            stopTimeoutMs: 50,
-        });
-        const calls = spawnProcess.mock.calls;
-        const args = calls[0][1];
-        const script = Buffer.from(args[args.indexOf("-EncodedCommand") + 1], "base64").toString("utf16le");
-        expect(script).toContain("SetThreadExecutionState");
-        expect(script).toContain("$systemRequired = [uint32]1");
-        expect(script).toContain("Wait-Process -Id 7654");
-        expect(script).not.toContain("ES_DISPLAY_REQUIRED");
-        await inhibitor.release();
-    });
-    it("reports a helper that stops after acquisition", async () => {
-        const child = fakeChild();
-        const spawnProcess = vi.fn(() => {
-            queueMicrotask(() => child.emit("spawn"));
-            return child;
-        });
-        const inhibitor = await acquireSleepInhibitor({
-            platform: "darwin",
-            spawnProcess: spawnProcess,
-            readyTimeoutMs: 50,
-        });
-        Object.assign(child, { exitCode: 3 });
-        child.emit("exit", 3, null);
-        await expect(inhibitor.lost).resolves.toMatchObject({ message: expect.stringContaining("stopped unexpectedly") });
-    });
-    it("rejects unsupported platforms and early helper failures", async () => {
-        await expect(acquireSleepInhibitor({ platform: "linux" })).rejects.toThrow("unsupported on linux");
-        const child = fakeChild();
-        const spawnProcess = vi.fn(() => {
-            queueMicrotask(() => child.emit("error", new Error("missing caffeinate")));
-            return child;
-        });
-        await expect(acquireSleepInhibitor({
-            platform: "darwin",
-            spawnProcess: spawnProcess,
-            readyTimeoutMs: 50,
-        })).rejects.toThrow("missing caffeinate");
-    });
-    it("builds a Windows helper that clears its assertion in finally", () => {
-        const script = buildWindowsSleepInhibitorScript(123);
-        expect(script).toContain("$continuous -bor $systemRequired");
-        expect(script).toContain("finally");
-        expect(script).toContain("SetThreadExecutionState($continuous)");
-    });
-});

package/dist/process-supervisor.test.js

@@ -1,42 +0,0 @@
-import { EventEmitter } from "node:events";
-import { describe, expect, it, vi } from "vitest";
-import { ProcessSupervisor } from "./process-supervisor.js";
-function fakeChild(pid = 42) {
-    const child = new EventEmitter();
-    Object.assign(child, { pid, exitCode: null, kill: vi.fn(() => true) });
-    return child;
-}
-describe("ProcessSupervisor", () => {
-    it("falls back to child.kill when taskkill cannot start", async () => {
-        const child = fakeChild();
-        const spawnProcess = vi.fn(() => {
-            const killer = new EventEmitter();
-            queueMicrotask(() => killer.emit("error", new Error("ENOENT")));
-            return killer;
-        });
-        const supervisor = new ProcessSupervisor("win32", spawnProcess);
-        const stopping = supervisor.stop(child, 20);
-        queueMicrotask(() => {
-            Object.assign(child, { exitCode: 0 });
-            child.emit("exit", 0, null);
-        });
-        await stopping;
-        expect(spawnProcess).toHaveBeenCalledWith("taskkill", ["/PID", "42", "/T", "/F"], { stdio: "ignore" });
-        expect(child.kill).toHaveBeenCalledWith("SIGTERM");
-    });
-    it("uses taskkill for a running Windows process tree", async () => {
-        const child = fakeChild();
-        const spawnProcess = vi.fn(() => {
-            const killer = new EventEmitter();
-            queueMicrotask(() => {
-                killer.emit("exit", 0, null);
-                Object.assign(child, { exitCode: 0 });
-                child.emit("exit", 0, null);
-            });
-            return killer;
-        });
-        const supervisor = new ProcessSupervisor("win32", spawnProcess);
-        await supervisor.stop(child, 20);
-        expect(child.kill).not.toHaveBeenCalled();
-    });
-});

package/dist/runtime-manager.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { prepareCodexRuntimeEnvironment, prepareOpenCodeRuntimeEnvironment } from "./runtime-manager.js";
-describe("prepareCodexRuntimeEnvironment", () => {
-    it("injects the resolved absolute Codex executable", async () => {
-        const report = vi.fn();
-        const environment = await prepareCodexRuntimeEnvironment({ PATH: "/bin" }, { dataDir: "/data", target: "windows-amd64" }, async () => ({
-            executable: "D:\\AgentRoam\\codex.exe",
-            version: "0.153.0",
-            source: "managed",
-        }), report);
-        expect(environment.AGENT_CODEX_BIN).toBe("D:\\AgentRoam\\codex.exe");
-        expect(environment.AGENT_CODEX_RUNTIME_ERROR).toBeUndefined();
-        expect(report).toHaveBeenCalledWith(expect.stringContaining("managed"));
-    });
-    it("removes an unusable inherited override and keeps startup available", async () => {
-        const report = vi.fn();
-        const environment = await prepareCodexRuntimeEnvironment({ PATH: "/bin", AGENT_CODEX_BIN: "/missing/codex" }, { dataDir: "/data", target: "darwin-arm64" }, async () => { throw new Error("download failed"); }, report);
-        expect(environment.AGENT_CODEX_BIN).toBeUndefined();
-        expect(environment.AGENT_CODEX_RUNTIME_ERROR).toBe("download failed");
-        expect(environment.PATH).toBe("/bin");
-        expect(report).toHaveBeenLastCalledWith(expect.stringContaining("continue without Codex sessions"));
-    });
-});
-describe("prepareOpenCodeRuntimeEnvironment", () => {
-    it("injects OpenCode independently from Codex", async () => {
-        const environment = await prepareOpenCodeRuntimeEnvironment({ PATH: "/bin", AGENT_CODEX_BIN: "/managed/codex" }, { dataDir: "/data", target: "darwin-arm64" }, async () => ({ executable: "/managed/opencode", version: "1.18.27", source: "managed" }), vi.fn());
-        expect(environment).toMatchObject({
-            AGENT_CODEX_BIN: "/managed/codex",
-            AGENT_OPENCODE_BIN: "/managed/opencode",
-        });
-    });
-    it("records OpenCode failure without removing Codex", async () => {
-        const environment = await prepareOpenCodeRuntimeEnvironment({ AGENT_CODEX_BIN: "/managed/codex", AGENT_OPENCODE_BIN: "/bad/opencode" }, { dataDir: "/data", target: "darwin-arm64" }, async () => { throw new Error("OpenCode download failed"); }, vi.fn());
-        expect(environment.AGENT_CODEX_BIN).toBe("/managed/codex");
-        expect(environment.AGENT_OPENCODE_BIN).toBeUndefined();
-        expect(environment.AGENT_OPENCODE_RUNTIME_ERROR).toBe("OpenCode download failed");
-    });
-});