agentroam 0.2.0-preview.25 → 0.2.0-preview.27

package/dist/args.test.js

@@ -1,84 +0,0 @@
-import { resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-import { parseArgs } from "./args.js";
-describe("parseArgs", () => {
-    it("uses auto relay and the current directory by default", () => {
-        const value = parseArgs([]);
-        expect(value.command).toBe("start");
-        expect(value.serviceAction).toBeNull();
-        expect(value.unlockServiceAction).toBeNull();
-        expect(value.roots).toEqual([process.cwd()]);
-        expect(value.relay).toBe("auto");
-    });
-    it("parses Windows unlock service actions", () => {
-        for (const action of ["install", "uninstall", "status"]) {
-            expect(parseArgs(["unlock-service", action])).toMatchObject({ command: "unlock-service", unlockServiceAction: action });
-        }
-        expect(() => parseArgs(["unlock-service"])).toThrow("requires install");
-        expect(() => parseArgs(["unlock-service", "restart"])).toThrow("requires install");
-        expect(() => parseArgs(["unlock-service", "status", "--data-dir", "/tmp/x"])).toThrow("accepts no options");
-    });
-    it("parses every supported relay", () => {
-        expect(parseArgs(["--relay", "cloudflare"]).relay).toBe("cloudflare");
-        expect(parseArgs(["--relay", "pinggy"]).relay).toBe("pinggy");
-        expect(parseArgs(["--relay", "custom", "--tunnel-command", "relay {port}"]).relay).toBe("custom");
-    });
-    it("parses repeatable roots and custom relay options", () => {
-        const value = parseArgs([
-            "start", "--root", ".", "--root", "..", "--relay", "custom", "--tunnel-command", "relay {port}", "--no-qr",
-        ]);
-        expect(value.roots).toHaveLength(2);
-        expect(value.tunnelCommand).toContain("{port}");
-        expect(value.qr).toBe(false);
-    });
-    it("rejects invalid ports and relay names", () => {
-        expect(() => parseArgs(["--port", "70000"])).toThrow();
-        expect(() => parseArgs(["--relay", "unknown"])).toThrow("relay must be auto");
-    });
-    it("parses every service action", () => {
-        for (const action of ["install", "start", "stop", "status", "url", "logs", "restart", "uninstall"]) {
-            const value = parseArgs(["service", action]);
-            expect(value.command).toBe("service");
-            expect(value.serviceAction).toBe(action);
-        }
-    });
-    it("parses service install using the existing start options", () => {
-        const value = parseArgs([
-            "service", "install", "--root", ".", "--root", "..", "--port", "3210", "--relay", "cloudflare",
-            "--data-dir", "./service-data", "--no-qr",
-        ]);
-        expect(value.roots).toHaveLength(2);
-        expect(value.port).toBe(3210);
-        expect(value.relay).toBe("cloudflare");
-        expect(value.dataDir).toBe(resolve(process.cwd(), "service-data"));
-        expect(value.qr).toBe(false);
-    });
-    it("rejects missing service actions and options on non-install actions", () => {
-        expect(() => parseArgs(["service"])).toThrow("service requires");
-        expect(() => parseArgs(["service", "unknown"])).toThrow("service requires");
-        expect(() => parseArgs(["service", "status", "--root", "."])).toThrow("does not accept options");
-        expect(() => parseArgs(["service", "start", "--port", "3000"])).toThrow("does not accept options");
-        expect(() => parseArgs(["service", "stop", "--local-only"])).toThrow("does not accept options");
-    });
-    it("parses update with an optional exact stable version", () => {
-        expect(parseArgs(["update"]).updateVersion).toBeNull();
-        expect(parseArgs(["update", "1.2.3", "--data-dir", "./data"])).toMatchObject({ command: "update", updateVersion: "1.2.3" });
-        expect(() => parseArgs(["update", "1.2.3-preview.1"])).toThrow("exact stable");
-    });
-});
-describe("device authorization commands", () => {
-    it("parses pairing, listing and individual/all revocation", () => {
-        expect(parseArgs(["pair"]).command).toBe("pair");
-        expect(parseArgs(["devices"]).command).toBe("devices");
-        expect(parseArgs(["revoke", "--all"]).revokeAll).toBe(true);
-        expect(parseArgs(["revoke", "12345678-1234-1234-1234-123456789abc"]).revokeDeviceId).toBe("12345678-1234-1234-1234-123456789abc");
-        expect(() => parseArgs(["revoke"])).toThrow();
-        expect(parseArgs(["pair", "--data-dir", "/tmp/device-test"]).dataDir).toBe("/tmp/device-test");
-    });
-});
-it("restricts no-pairing test mode to explicit local foreground starts", () => {
-    expect(parseArgs(["start", "--local-only", "--test-no-pairing"]).testNoPairing).toBe(true);
-    expect(parseArgs([]).testNoPairing).toBeUndefined();
-    for (const args of [["--test-no-pairing"], ["service", "install", "--local-only", "--test-no-pairing"], ["start", "--local-only", "--test-no-pairing", "--relay", "pinggy"]])
-        expect(() => parseArgs(args)).toThrow();
-});

package/dist/cloudflared/bundled-asset.test.js

@@ -1,91 +0,0 @@
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-import { PLATFORM_DEPENDENCY_VERSIONS } from "../platform-packages.js";
-import { resolveBundledCloudflared } from "./bundled-asset.js";
-describe("resolveBundledCloudflared", () => {
-    it("resolves a valid platform package manifest and archive", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-bundled-resolver-"));
-        const manifestPath = resolve(root, "manifest.json");
-        const archivePath = resolve(root, "cloudflared.tgz");
-        await writeFile(archivePath, "archive");
-        await writeFile(manifestPath, JSON.stringify({
-            packageVersion: PLATFORM_DEPENDENCY_VERSIONS["agentroam-cloudflared-darwin-arm64"],
-            upstreamVersion: "2026.8.2",
-            target: "darwin-arm64",
-            assetFormat: "tgz",
-            fileName: "cloudflared",
-            size: 7,
-            sha256: "a".repeat(64),
-        }));
-        const asset = await resolveBundledCloudflared("darwin-arm64", fakeRequire(manifestPath, archivePath));
-        expect(asset).toEqual({
-            assetPath: archivePath,
-            assetFormat: "tgz",
-            version: "2026.8.2",
-            fileName: "cloudflared",
-            size: 7,
-            sha256: "a".repeat(64),
-        });
-    });
-    it("rejects a mismatched platform package version", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-bundled-version-"));
-        const manifestPath = resolve(root, "manifest.json");
-        const archivePath = resolve(root, "cloudflared.tgz");
-        await writeFile(archivePath, "archive");
-        await writeFile(manifestPath, JSON.stringify({
-            packageVersion: "0.2.0-preview.2",
-            upstreamVersion: "2026.8.2",
-            target: "darwin-arm64",
-            assetFormat: "tgz",
-            fileName: "cloudflared",
-            size: 7,
-            sha256: "a".repeat(64),
-        }));
-        await expect(resolveBundledCloudflared("darwin-arm64", fakeRequire(manifestPath, archivePath)))
-            .rejects.toThrow("invalid cloudflared platform manifest");
-    });
-    it("checks Windows against its own pin when platform versions differ", async () => {
-        const key = "agentroam-cloudflared-win32-x64";
-        const previous = PLATFORM_DEPENDENCY_VERSIONS[key];
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-mixed-cloudflared-"));
-        const manifestPath = resolve(root, "manifest.json");
-        try {
-            PLATFORM_DEPENDENCY_VERSIONS[key] = "0.2.0-preview.1";
-            await writeFile(manifestPath, JSON.stringify({ packageVersion: "0.2.0-preview.1", upstreamVersion: "2026.8.2", target: "windows-amd64", assetFormat: "executable", fileName: "cloudflared.exe", size: 6, sha256: "b".repeat(64) }));
-            await expect(resolveBundledCloudflared("windows-amd64", fakeRequire(manifestPath, "binary"))).resolves.toMatchObject({ assetPath: "binary" });
-        }
-        finally {
-            PLATFORM_DEPENDENCY_VERSIONS[key] = previous;
-        }
-    });
-    it("resolves a Windows executable asset", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-bundled-windows-"));
-        const manifestPath = resolve(root, "manifest.json");
-        const assetPath = resolve(root, "cloudflared.exe");
-        await writeFile(assetPath, "binary");
-        await writeFile(manifestPath, JSON.stringify({
-            packageVersion: PLATFORM_DEPENDENCY_VERSIONS["agentroam-cloudflared-win32-x64"],
-            upstreamVersion: "2026.8.2",
-            target: "windows-amd64",
-            assetFormat: "executable",
-            fileName: "cloudflared.exe",
-            size: 6,
-            sha256: "b".repeat(64),
-        }));
-        await expect(resolveBundledCloudflared("windows-amd64", fakeRequire(manifestPath, assetPath))).resolves.toEqual({
-            assetPath,
-            assetFormat: "executable",
-            version: "2026.8.2",
-            fileName: "cloudflared.exe",
-            size: 6,
-            sha256: "b".repeat(64),
-        });
-    });
-});
-function fakeRequire(manifestPath, archivePath) {
-    return {
-        resolve: (id) => id.endsWith("/manifest.json") ? manifestPath : archivePath,
-    };
-}

package/dist/cloudflared/installer.test.js

@@ -1,95 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { constants } from "node:fs";
-import { access, chmod, mkdtemp, mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { ensureCloudflared, findSystemCloudflared } from "./installer.js";
-describe("ensureCloudflared", () => {
-    it("extracts a verified bundled archive and repairs executable permissions", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-cloudflared-bundle-"));
-        const asset = await createArchive(root, "#!/bin/sh\necho bundled\n");
-        const executable = await ensureCloudflared("darwin-arm64", resolve(root, "data"), {
-            resolveBundled: async () => asset,
-            findSystem: async () => null,
-        });
-        expect(await readFile(executable, "utf8")).toContain("bundled");
-        await access(executable, constants.X_OK);
-        expect(await readFile(`${executable}.source.sha256`, "utf8")).toBe(`${asset.sha256}\n`);
-    });
-    it("reuses the verified cache", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-cloudflared-cache-"));
-        const asset = await createArchive(root, "#!/bin/sh\n");
-        const resolver = vi.fn(async () => asset);
-        const options = { resolveBundled: resolver, findSystem: async () => null };
-        const first = await ensureCloudflared("darwin-arm64", resolve(root, "data"), options);
-        const second = await ensureCloudflared("darwin-arm64", resolve(root, "data"), options);
-        expect(second).toBe(first);
-        expect(resolver).toHaveBeenCalledTimes(2);
-    });
-    it("copies a verified Windows executable without tar", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-cloudflared-windows-"));
-        const assetPath = resolve(root, "source.exe");
-        const bytes = Buffer.from("MZ-test-windows-binary");
-        await writeFile(assetPath, bytes);
-        const asset = {
-            assetPath,
-            assetFormat: "executable",
-            sha256: createHash("sha256").update(bytes).digest("hex"),
-            size: bytes.length,
-            fileName: "cloudflared.exe",
-            version: "test",
-        };
-        const executable = await ensureCloudflared("windows-amd64", resolve(root, "data"), {
-            resolveBundled: async () => asset,
-            findSystem: async () => null,
-        });
-        expect(executable).toBe(resolve(root, "data/bin/cloudflared.exe"));
-        expect(await readFile(executable)).toEqual(bytes);
-    });
-    it("falls back to PATH when the bundled checksum is invalid", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-cloudflared-fallback-"));
-        const asset = await createArchive(root, "#!/bin/sh\n");
-        const system = resolve(root, "system-cloudflared");
-        await writeFile(system, "#!/bin/sh\n", { mode: 0o755 });
-        const result = await ensureCloudflared("darwin-arm64", resolve(root, "data"), {
-            resolveBundled: async () => ({ ...asset, sha256: "0".repeat(64) }),
-            findSystem: async () => system,
-        });
-        expect(result).toBe(system);
-    });
-    it("reports package and PATH failures without downloading", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-cloudflared-missing-"));
-        await expect(ensureCloudflared("darwin-arm64", resolve(root, "data"), {
-            resolveBundled: async () => null,
-            findSystem: async () => null,
-        })).rejects.toThrow("platform package missing for darwin-arm64; no executable on PATH");
-    });
-});
-describe("findSystemCloudflared", () => {
-    it("reuses an executable cloudflared already installed on PATH", async () => {
-        const directory = await mkdtemp(resolve(tmpdir(), "agentroam-cloudflared-path-"));
-        const executable = resolve(directory, "cloudflared");
-        await writeFile(executable, "#!/bin/sh\n", { mode: 0o644 });
-        expect(await findSystemCloudflared(directory, "darwin")).toBeNull();
-        await chmod(executable, 0o755);
-        expect(await findSystemCloudflared(directory, "darwin")).toBe(executable);
-    });
-});
-async function createArchive(root, content) {
-    const source = resolve(root, "source");
-    await mkdir(source, { recursive: true });
-    await writeFile(resolve(source, "cloudflared"), content, { mode: 0o644 });
-    const archivePath = resolve(root, "cloudflared.tgz");
-    execFileSync("tar", ["-czf", archivePath, "-C", source, "cloudflared"]);
-    const bytes = await readFile(archivePath);
-    return {
-        assetPath: archivePath,
-        assetFormat: "tgz",
-        sha256: createHash("sha256").update(bytes).digest("hex"),
-        size: (await stat(archivePath)).size,
-        fileName: "cloudflared",
-        version: "test",
-    };
-}

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

@@ -1,275 +0,0 @@
-import { chmod, mkdtemp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, resolve, win32 } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { CODEX_INSTALL_STALE_LOCK_MS, CODEX_INSTALL_TIMEOUT_MS, CODEX_MINIMUM_VERSION, CODEX_RUNTIME_VERSION, isCodexVersionAtLeast, managedCodexBinaryCandidates, parseCodexVersion, resolveCodexRuntime, resolveNpmExecutor, } from "./codex-runtime-manager.js";
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })));
-});
-describe("managed Codex runtime", () => {
-    it("parses the official version output", () => {
-        expect(parseCodexVersion("codex-cli 0.153.5")).toBe("0.153.5");
-        expect(parseCodexVersion("codex-cli next")).toBeNull();
-    });
-    it("compares versions numerically instead of lexicographically", () => {
-        // Samples stay below the current pin: pins only move forward, so these
-        // literals can never collide with the upgrade script's version replacement.
-        expect(isCodexVersionAtLeast("0.140.12", "0.140.3")).toBe(true);
-        expect(isCodexVersionAtLeast("0.140.3", "0.140.12")).toBe(false);
-        expect(isCodexVersionAtLeast(CODEX_MINIMUM_VERSION, CODEX_MINIMUM_VERSION)).toBe(true);
-        expect(isCodexVersionAtLeast("0.139.9", CODEX_MINIMUM_VERSION)).toBe(false);
-        expect(isCodexVersionAtLeast("0.152.0", "0.140.0")).toBe(true);
-        expect(isCodexVersionAtLeast("1.0.0", "0.140.0")).toBe(true);
-    });
-    it("uses a compatible explicit absolute executable first", async () => {
-        const root = await temporaryRoot();
-        const executable = await fakeExecutable(resolve(root, "codex"));
-        const run = vi.fn(async (_command, args) => ({
-            stdout: args[0] === "--version" ? `codex-cli ${CODEX_RUNTIME_VERSION}\n` : "app-server help\n",
-            stderr: "",
-        }));
-        await expect(resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { AGENT_CODEX_BIN: executable, PATH: "" },
-            platform: "darwin",
-            dependencies: { run },
-        })).resolves.toEqual({
-            executable,
-            version: CODEX_RUNTIME_VERSION,
-            source: "explicit",
-        });
-        expect(run.mock.calls.map((call) => call[1])).toEqual([["--version"], ["app-server", "--help"]]);
-    });
-    it("accepts explicit executables at or above the minimum stable version", async () => {
-        const outputs = [
-            `codex-cli ${CODEX_MINIMUM_VERSION}\n`,
-            `codex-cli ${CODEX_RUNTIME_VERSION}\n`,
-        ];
-        for (const output of outputs) {
-            const root = await temporaryRoot();
-            const executable = await fakeExecutable(resolve(root, "codex"));
-            await expect(resolveCodexRuntime({
-                dataDir: resolve(root, "data"),
-                target: "darwin-arm64",
-                environment: { AGENT_CODEX_BIN: executable, PATH: "" },
-                platform: "darwin",
-                dependencies: {
-                    run: async (_command, args) => ({
-                        stdout: args[0] === "--version" ? output : "app-server help\n",
-                        stderr: "",
-                    }),
-                },
-            })).resolves.toMatchObject({ executable, source: "explicit" });
-        }
-    });
-    it("rejects an explicit executable below the minimum instead of silently replacing it", async () => {
-        const root = await temporaryRoot();
-        const executable = await fakeExecutable(resolve(root, "codex"));
-        await expect(resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { AGENT_CODEX_BIN: executable, PATH: "" },
-            platform: "darwin",
-            dependencies: {
-                run: async () => ({ stdout: "codex-cli 0.152.9\n", stderr: "" }),
-            },
-        })).rejects.toThrow(`requires >=${CODEX_MINIMUM_VERSION}`);
-    });
-    it("rejects prerelease or otherwise unparseable version output", async () => {
-        const root = await temporaryRoot();
-        const executable = await fakeExecutable(resolve(root, "codex"));
-        await expect(resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { AGENT_CODEX_BIN: executable, PATH: "" },
-            platform: "darwin",
-            dependencies: {
-                run: async () => ({ stdout: "codex-cli 0.150.0-alpha.1\n", stderr: "" }),
-            },
-        })).rejects.toThrow("Unable to parse a supported stable Codex version");
-    });
-    it("skips an incompatible PATH executable and reuses the managed runtime", async () => {
-        const root = await temporaryRoot();
-        const global = await fakeExecutable(resolve(root, "bin", "codex"));
-        const managedRoot = resolve(root, "data", "runtimes", "codex", CODEX_RUNTIME_VERSION);
-        const managed = await fakeExecutable(managedCodexBinaryCandidates(managedRoot, "darwin-arm64")[0]);
-        const run = vi.fn(async (command, args) => ({
-            stdout: args[0] === "--version"
-                ? command === global ? "codex-cli 0.152.0\n" : `codex-cli ${CODEX_RUNTIME_VERSION}\n`
-                : "help\n",
-            stderr: "",
-        }));
-        await expect(resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { PATH: resolve(root, "bin") },
-            platform: "darwin",
-            dependencies: { run },
-        })).resolves.toEqual({ executable: managed, version: CODEX_RUNTIME_VERSION, source: "managed" });
-        expect(run.mock.calls.some((call) => call[1].includes("install"))).toBe(false);
-    });
-    it("reuses a qualified PATH executable without installing", async () => {
-        const root = await temporaryRoot();
-        const global = await fakeExecutable(resolve(root, "bin", "codex"));
-        const run = vi.fn(async (_command, args) => ({
-            stdout: args[0] === "--version" ? `codex-cli ${CODEX_RUNTIME_VERSION}\n` : "help\n",
-            stderr: "",
-        }));
-        await expect(resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { PATH: resolve(root, "bin") },
-            platform: "darwin",
-            dependencies: { run },
-        })).resolves.toEqual({ executable: global, version: CODEX_RUNTIME_VERSION, source: "global" });
-        expect(run.mock.calls.some((call) => call[1].includes("install"))).toBe(false);
-    });
-    it("installs the locked official package into a versioned runtime directory", async () => {
-        const root = await temporaryRoot();
-        const npmExecPath = await fakeExecutable(resolve(root, "npm-cli.js"));
-        let installs = 0;
-        const run = vi.fn(async (command, args, timeoutMs) => {
-            if (command === "/test/node" && args.includes("install")) {
-                installs += 1;
-                const prefix = args[args.indexOf("--prefix") + 1];
-                await fakeExecutable(managedCodexBinaryCandidates(prefix, "darwin-arm64")[0]);
-                expect(args).toContain("@openai/codex@0.153.0");
-                expect(args).toContain("--registry=https://registry.npmjs.org");
-                expect(timeoutMs).toBe(60 * 60_000);
-                return { stdout: "installed", stderr: "" };
-            }
-            return {
-                stdout: args[0] === "--version" ? `codex-cli ${CODEX_RUNTIME_VERSION}\n` : "help\n",
-                stderr: "",
-            };
-        });
-        const resolution = await resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { PATH: "", npm_execpath: npmExecPath },
-            platform: "darwin",
-            nodeExecutable: "/test/node",
-            dependencies: { run },
-        });
-        expect(installs).toBe(1);
-        expect(CODEX_INSTALL_STALE_LOCK_MS).toBeGreaterThan(CODEX_INSTALL_TIMEOUT_MS);
-        expect(resolution.executable).toContain(`/runtimes/codex/${CODEX_RUNTIME_VERSION}/`);
-        expect(resolution.source).toBe("managed");
-    });
-    it("serializes concurrent first-start installs", async () => {
-        const root = await temporaryRoot();
-        const npmExecPath = await fakeExecutable(resolve(root, "npm-cli.js"));
-        let installs = 0;
-        const run = async (command, args) => {
-            if (command === "/test/node" && args.includes("install")) {
-                installs += 1;
-                await new Promise((resolveDelay) => setTimeout(resolveDelay, 30));
-                const prefix = args[args.indexOf("--prefix") + 1];
-                await fakeExecutable(managedCodexBinaryCandidates(prefix, "darwin-arm64")[0]);
-                return { stdout: "installed", stderr: "" };
-            }
-            return {
-                stdout: args[0] === "--version" ? `codex-cli ${CODEX_RUNTIME_VERSION}\n` : "help\n",
-                stderr: "",
-            };
-        };
-        const options = {
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { PATH: "", npm_execpath: npmExecPath },
-            platform: "darwin",
-            nodeExecutable: "/test/node",
-            dependencies: { run },
-        };
-        const [first, second] = await Promise.all([
-            resolveCodexRuntime(options),
-            resolveCodexRuntime(options),
-        ]);
-        expect(installs).toBe(1);
-        expect(second.executable).toBe(first.executable);
-    });
-    it("cleans temporary installs and the lock after npm failure", async () => {
-        const root = await temporaryRoot();
-        const npmExecPath = await fakeExecutable(resolve(root, "npm-cli.js"));
-        await expect(resolveCodexRuntime({
-            dataDir: resolve(root, "data"),
-            target: "darwin-arm64",
-            environment: { PATH: "", npm_execpath: npmExecPath },
-            platform: "darwin",
-            nodeExecutable: "/test/node",
-            dependencies: {
-                run: async () => { throw new Error("network unavailable"); },
-            },
-        })).rejects.toThrow("network unavailable");
-        expect(await readdir(resolve(root, "data", "runtimes", "codex"))).toEqual([]);
-    });
-});
-describe("Codex npm executor", () => {
-    it("runs npm_execpath through the current Node executable", async () => {
-        await expect(resolveNpmExecutor({
-            environment: { npm_execpath: "/tools/npm-cli.js", PATH: "" },
-            nodeExecutable: "/runtime/node",
-            canAccess: async (path) => path === "/tools/npm-cli.js",
-        })).resolves.toEqual({ command: "/runtime/node", argsPrefix: ["/tools/npm-cli.js"] });
-    });
-    it("finds a directly executable npm.exe on Windows PATH", async () => {
-        const expected = win32.resolve("C:\\tools", "npm.exe");
-        await expect(resolveNpmExecutor({
-            environment: { PATH: ["C:\\missing", "C:\\tools"].join(";") },
-            platform: "win32",
-            canAccess: async (path) => path === expected,
-        })).resolves.toEqual({ command: expected, argsPrefix: [] });
-    });
-    it("finds npm-cli.js beside an NVM Node without relying on PATH", async () => {
-        const nodeExecutable = "/Users/test/.nvm/versions/node/v22.22.2/bin/node";
-        const npmCli = "/Users/test/.nvm/versions/node/v22.22.2/lib/node_modules/npm/bin/npm-cli.js";
-        await expect(resolveNpmExecutor({
-            environment: { PATH: "" },
-            platform: "darwin",
-            nodeExecutable,
-            canAccess: async (path) => path === npmCli,
-        })).resolves.toEqual({ command: nodeExecutable, argsPrefix: [npmCli] });
-    });
-    it("finds npm-cli.js beside an nvm-windows Node without relying on PATH", async () => {
-        const nodeExecutable = "C:\\Users\\test\\AppData\\Roaming\\nvm\\v22.22.2\\node.exe";
-        const npmCli = "C:\\Users\\test\\AppData\\Roaming\\nvm\\v22.22.2\\node_modules\\npm\\bin\\npm-cli.js";
-        await expect(resolveNpmExecutor({
-            environment: { PATH: "" },
-            platform: "win32",
-            nodeExecutable,
-            canAccess: async (path) => path === npmCli,
-        })).resolves.toEqual({ command: nodeExecutable, argsPrefix: [npmCli] });
-    });
-    it("runs a standard Windows npm.cmd installation through npm-cli.js", async () => {
-        const npmCmd = win32.resolve("C:\\Program Files\\nodejs", "npm.cmd");
-        const npmCli = win32.resolve("C:\\Program Files\\nodejs", "node_modules", "npm", "bin", "npm-cli.js");
-        await expect(resolveNpmExecutor({
-            environment: { PATH: "C:\\Program Files\\nodejs" },
-            platform: "win32",
-            nodeExecutable: "C:\\Program Files\\nodejs\\node.exe",
-            canAccess: async (path) => path === npmCmd || path === npmCli,
-        })).resolves.toEqual({
-            command: "C:\\Program Files\\nodejs\\node.exe",
-            argsPrefix: [npmCli],
-        });
-    });
-    it("maps official macOS and Windows optional-package binaries", () => {
-        expect(managedCodexBinaryCandidates("/runtime", "darwin-arm64")[0])
-            .toContain("codex-darwin-arm64/vendor/aarch64-apple-darwin/bin/codex");
-        expect(managedCodexBinaryCandidates("/runtime", "windows-amd64")[0])
-            .toContain("codex-win32-x64/vendor/x86_64-pc-windows-msvc/bin/codex.exe");
-    });
-});
-async function temporaryRoot() {
-    const root = await mkdtemp(resolve(tmpdir(), "agentroam-codex-runtime-"));
-    temporaryDirectories.push(root);
-    return root;
-}
-async function fakeExecutable(path) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, "fake\n");
-    await chmod(path, 0o755);
-    return path;
-}

package/dist/desktop-download.test.js

@@ -1,83 +0,0 @@
-import { createHash } from 'node:crypto';
-import { mkdtemp, readFile, readdir, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it, vi } from 'vitest';
-// @ts-expect-error Standalone bootstrap helper ships as JavaScript.
-import { desktopAsset, downloadDesktop } from '../bin/desktop-download.mjs';
-const version = '0.2.0-preview.17';
-const body = Buffer.from('desktop test artifact');
-function manifest() {
-    return { schemaVersion: 2, version, channel: 'preview', installers: { desktop: {
-                'darwin-arm64': { fileName: `AgentRoam-${version}-arm64.dmg`, sha256: createHash('sha256').update(body).digest('hex'), size: body.length, signed: false },
-                'windows-amd64': { fileName: `AgentRoam-Setup-${version}-x64.exe`, sha256: createHash('sha256').update(body).digest('hex'), signed: false },
-            } } };
-}
-describe('optional desktop installer download', () => {
-    it('selects the versioned Windows asset and rejects wrong versions and filenames', () => {
-        expect(desktopAsset(manifest(), version, 'win32', 'x64').fileName).toMatch(/\.exe$/);
-        expect(() => desktopAsset(manifest(), '0.2.0-preview.18', 'darwin', 'arm64')).toThrow();
-        const invalid = manifest();
-        invalid.installers.desktop['darwin-arm64'].fileName = '../unsafe.dmg';
-        expect(() => desktopAsset(invalid, version, 'darwin', 'arm64')).toThrow();
-    });
-    it('downloads and verifies into unique directories without overwriting previous installs', async () => {
-        const directory = await mkdtemp(join(tmpdir(), 'desktop-download-'));
-        const fetchImpl = vi.fn(async (url) => url.endsWith('.json') ? Response.json(manifest()) : new Response(body));
-        try {
-            const first = await downloadDesktop(version, { directory, platform: 'darwin', arch: 'arm64', fetchImpl });
-            const second = await downloadDesktop(version, { directory, platform: 'darwin', arch: 'arm64', fetchImpl });
-            expect(await readFile(first)).toEqual(body);
-            expect(second).not.toBe(first);
-            expect(fetchImpl.mock.calls[1][0]).toContain(`/v${version}/AgentRoam-${version}-arm64.dmg`);
-        }
-        finally {
-            await rm(directory, { recursive: true, force: true });
-        }
-    });
-    it('cleans up partial files on checksum mismatch', async () => {
-        const directory = await mkdtemp(join(tmpdir(), 'desktop-download-'));
-        const fetchImpl = vi.fn(async (url) => url.endsWith('.json') ? Response.json(manifest()) : new Response('corrupted'));
-        try {
-            await expect(downloadDesktop(version, { directory, platform: 'darwin', arch: 'arm64', fetchImpl })).rejects.toThrow('checksum');
-            expect(await readdir(directory)).toEqual([]);
-        }
-        finally {
-            await rm(directory, { recursive: true, force: true });
-        }
-    });
-    it('rejects missing platform artifacts before downloading binaries', async () => {
-        const fetchImpl = vi.fn(async () => Response.json({ ...manifest(), installers: {} }));
-        await expect(downloadDesktop(version, { platform: 'darwin', arch: 'arm64', fetchImpl })).rejects.toThrow('no valid');
-        expect(fetchImpl).toHaveBeenCalledTimes(1);
-    });
-});
-// Exercise the actual installer tail with an isolated launcher. Nothing installs
-// on the machine; the helper records whether the optional branch ran.
-describe.skipIf(process.platform === 'win32')('Shell desktop choice after CLI installation', () => {
-    it.each(['no', 'yes', undefined])('handles choice %s without reading piped script input', async (choice) => {
-        const { execFileSync } = await import('node:child_process');
-        const { mkdir, writeFile } = await import('node:fs/promises');
-        const root = await mkdtemp(join(tmpdir(), 'desktop-choice-'));
-        try {
-            const bin = join(root, 'node_modules/agentroam/bin');
-            await mkdir(bin, { recursive: true });
-            const marker = join(root, 'selected');
-            await writeFile(join(bin, 'desktop-download.mjs'), `import { writeFileSync } from 'node:fs'; writeFileSync(process.env.CHOICE_MARKER, process.argv[2]);`);
-            const installer = await readFile(new URL('../install/install-agentroam.sh', import.meta.url), 'utf8');
-            const section = installer.slice(installer.indexOf('# stdin is the script itself'));
-            const env = { ...process.env, LAUNCHER_ROOT: root, NODE_BIN: process.execPath, AGENTROAM_VERSION: version, CHOICE_MARKER: marker };
-            delete env.AGENTROAM_INSTALL_DESKTOP;
-            if (choice)
-                Object.assign(env, { AGENTROAM_INSTALL_DESKTOP: choice });
-            execFileSync('/bin/sh', ['-c', section], { env, input: 'yes\n' });
-            if (choice === 'yes')
-                expect(await readFile(marker, 'utf8')).toBe(version);
-            else
-                expect(await readdir(root)).not.toContain('selected');
-        }
-        finally {
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-});