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

package/dist/service/service-files.test.js

@@ -1,48 +0,0 @@
-import { mkdtemp, readFile, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-import { ensurePrivateFile, readServiceConfig, resolveServicePaths, writePrivateJson, writePrivateText, } from "./service-files.js";
-describe("service files", () => {
-    it("resolves control files under the home directory and runtime files under data-dir", async () => {
-        const home = await mkdtemp(resolve(tmpdir(), "agentroam-service-home-"));
-        const data = resolve(home, "custom-data");
-        const paths = resolveServicePaths(home, data);
-        expect(paths.plistPath).toBe(resolve(home, "Library/LaunchAgents/com.agentroam.service.plist"));
-        expect(paths.configPath).toBe(resolve(home, ".agentroam/service/config.json"));
-        expect(paths.statePath).toBe(resolve(home, ".agentroam/service/state.json"));
-        expect(paths.urlPath).toBe(resolve(data, "tunnel.url"));
-        expect(paths.stdoutPath).toBe(resolve(data, "logs/service.stdout.log"));
-    });
-    it("atomically replaces private JSON and text files", async () => {
-        const home = await mkdtemp(resolve(tmpdir(), "agentroam-service-private-"));
-        const paths = resolveServicePaths(home);
-        const first = config(paths.dataDir, "first");
-        const second = config(paths.dataDir, "second");
-        await writePrivateJson(paths.configPath, first);
-        await writePrivateJson(paths.configPath, second);
-        await writePrivateText(paths.urlPath, "https://example.trycloudflare.com/web\n");
-        await ensurePrivateFile(paths.stdoutPath);
-        expect(await readServiceConfig(paths)).toEqual(second);
-        expect(await readFile(paths.urlPath, "utf8")).toContain("trycloudflare.com");
-        for (const path of [paths.configPath, paths.urlPath, paths.stdoutPath]) {
-            expect((await stat(path)).mode & 0o777).toBe(0o600);
-        }
-        expect((await stat(paths.controlDir)).mode & 0o777).toBe(0o700);
-        expect((await stat(paths.logsDir)).mode & 0o777).toBe(0o700);
-    });
-});
-function config(dataDir, version) {
-    return {
-        version,
-        nodePath: "/node",
-        cliPath: "/agentroam.mjs",
-        roots: ["/workspace"],
-        port: null,
-        relay: "auto",
-        tunnelCommand: null,
-        localOnly: false,
-        dataDir,
-        installedAt: "2026-09-03T00:00:00.000Z",
-    };
-}

package/dist/service/windows-service-host.test.js

@@ -1,52 +0,0 @@
-import { EventEmitter } from "node:events";
-import { mkdtemp, mkdir } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { writePrivateJson } from "./service-files.js";
-import { runWindowsServiceHost } from "./windows-service-host.js";
-describe("Windows service host", () => {
-    it("starts the configured CLI in service mode with private log descriptors", async () => {
-        const root = await mkdtemp(resolve(tmpdir(), "agentroam-windows-host-"));
-        const workspace = resolve(root, "workspace with spaces");
-        const configPath = resolve(root, "service/config.json");
-        await mkdir(workspace, { recursive: true });
-        const config = {
-            version: "0.2.0-preview.9",
-            nodePath: "C:\\Node Runtime\\node.exe",
-            cliPath: "C:\\AgentRoam\\bin\\agentroam.mjs",
-            environmentPath: "C:\\Node Runtime;C:\\Windows\\System32",
-            codexPath: "C:\\Users\\test\\.nvm\\v22.22.2\\codex.exe",
-            codexHome: "C:\\Users\\test\\.codex",
-            roots: [workspace],
-            port: 3010,
-            relay: "cloudflare",
-            tunnelCommand: null,
-            localOnly: false,
-            dataDir: resolve(root, "data"),
-            installedAt: "2026-09-04T00:00:00.000Z",
-        };
-        await writePrivateJson(configPath, config);
-        const child = new EventEmitter();
-        Object.assign(child, { kill: vi.fn(() => true) });
-        const spawnProcess = vi.fn(() => {
-            queueMicrotask(() => child.emit("exit", 0, null));
-            return child;
-        });
-        await expect(runWindowsServiceHost(configPath, { spawnProcess: spawnProcess })).resolves.toBe(0);
-        const calls = spawnProcess.mock.calls;
-        const [command, args, options] = calls[0];
-        expect(command).toBe(config.nodePath);
-        expect(args).toEqual([
-            config.cliPath, "start", "--root", workspace, "--port", "3010", "--relay", "cloudflare",
-            "--data-dir", config.dataDir, "--no-qr",
-        ]);
-        expect(options).toMatchObject({ cwd: workspace, windowsHide: true });
-        expect(options.env.AGENTROAM_SERVICE).toBe("1");
-        expect(options.env.PATH).toBe(config.environmentPath);
-        expect(options.env.AGENT_CODEX_BIN).toBe(config.codexPath);
-        expect(options.env.CODEX_HOME).toBe(config.codexHome);
-        expect(typeof options.stdio[1]).toBe("number");
-        expect(typeof options.stdio[2]).toBe("number");
-    });
-});

package/dist/service/windows-task-service.test.js

@@ -1,230 +0,0 @@
-import { mkdtemp, mkdir, readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import { resolveServicePaths, writePrivateText } from "./service-files.js";
-import { WindowsTaskService, buildRegisterTaskScript, quoteWindowsCommandLineArgument, resolveWindowsServiceHost, } from "./windows-task-service.js";
-describe("WindowsTaskService", () => {
-    it("registers, stops, starts, and uninstalls a current-user task", async () => {
-        const home = await mkdtemp(resolve(tmpdir(), "agentroam-windows-task-"));
-        const paths = resolveServicePaths(home, resolve(home, "data"));
-        const value = config(home, paths.dataDir);
-        await mkdir(value.roots[0], { recursive: true });
-        let installed = false;
-        let running = false;
-        let processRunning = false;
-        let pid = 800;
-        const scripts = [];
-        const runner = async (command, args) => {
-            expect(command).toBe("powershell.exe");
-            const script = Buffer.from(args.at(-1), "base64").toString("utf16le");
-            scripts.push(script);
-            if (script.includes("Register-ScheduledTask"))
-                installed = true;
-            if (script.includes("Start-ScheduledTask")) {
-                running = true;
-                processRunning = true;
-                pid++;
-                await writePrivateText(paths.statePath, JSON.stringify({
-                    status: "ready", pid, version: value.version, startedAt: "x", updatedAt: "x",
-                    accessUrl: "https://ready.example/web",
-                }));
-                await writePrivateText(paths.urlPath, "https://ready.example/web\n");
-            }
-            if (script.includes("Stop-ScheduledTask")) {
-                running = false;
-                processRunning = false;
-            }
-            if (script.includes("Unregister-ScheduledTask"))
-                installed = false;
-            if (script.includes("Get-ScheduledTask")) {
-                return { code: 0, stdout: JSON.stringify({ installed, running }), stderr: "" };
-            }
-            return { code: 0, stdout: "", stderr: "" };
-        };
-        const service = new WindowsTaskService({
-            homeDir: home,
-            runner,
-            processExists: () => processRunning,
-            validateConfig: async () => undefined,
-            readyTimeoutMs: 50,
-            stopTimeoutMs: 50,
-            pollIntervalMs: 1,
-        });
-        const installedResult = await service.install(value);
-        expect(installedResult.state).toMatchObject({ status: "ready", pid: 801 });
-        expect(installedResult.definition).toBe("AgentRoam");
-        expect(await service.url()).toBe("https://ready.example/web");
-        await service.stop();
-        expect((await service.status()).running).toBe(false);
-        await service.start();
-        expect((await service.status()).running).toBe(true);
-        await writePrivateText(resolve(paths.dataDir, "data/keep.txt"), "keep");
-        await writePrivateText(paths.stdoutPath, "keep logs");
-        const result = await service.uninstall();
-        expect(result).toEqual({ removed: true, preservedDataDir: paths.dataDir });
-        expect(await readFile(resolve(paths.dataDir, "data/keep.txt"), "utf8")).toBe("keep");
-        expect(await readFile(paths.stdoutPath, "utf8")).toBe("keep logs");
-        expect(scripts.some((script) => script.includes("New-ScheduledTaskPrincipal") && script.includes("RunLevel Limited"))).toBe(true);
-        expect(scripts.some((script) => script.includes("cmd.exe") || script.includes("ES_DISPLAY_REQUIRED"))).toBe(false);
-    });
-    it("stops and unregisters a running task before installing its replacement", async () => {
-        const home = await mkdtemp(resolve(tmpdir(), "agentroam-windows-task-reinstall-"));
-        const paths = resolveServicePaths(home, resolve(home, "data"));
-        const value = config(home, paths.dataDir);
-        await mkdir(value.roots[0], { recursive: true });
-        await writePrivateText(paths.configPath, JSON.stringify({ ...value, version: "0.2.0-preview.8" }));
-        await writePrivateText(paths.statePath, JSON.stringify({
-            status: "ready", pid: 800, version: "0.2.0-preview.8", startedAt: "x", updatedAt: "x",
-        }));
-        await writePrivateText(resolve(paths.dataDir, "data/keep.txt"), "keep");
-        await writePrivateText(paths.stdoutPath, "keep logs");
-        let installed = true;
-        let running = true;
-        let processChecks = 0;
-        const lifecycle = [];
-        const runner = async (_command, args) => {
-            const script = Buffer.from(args.at(-1), "base64").toString("utf16le");
-            if (script.includes("Get-ScheduledTask")) {
-                return { code: 0, stdout: JSON.stringify({ installed, running }), stderr: "" };
-            }
-            if (script.includes("Stop-ScheduledTask")) {
-                lifecycle.push("stop");
-                running = false;
-            }
-            if (script.includes("Unregister-ScheduledTask")) {
-                lifecycle.push("unregister");
-                installed = false;
-            }
-            if (script.includes("Register-ScheduledTask")) {
-                lifecycle.push("register");
-                installed = true;
-            }
-            if (script.includes("Start-ScheduledTask")) {
-                lifecycle.push("start");
-                running = true;
-                await writePrivateText(paths.statePath, JSON.stringify({
-                    status: "ready", pid: 801, version: value.version, startedAt: "y", updatedAt: "y",
-                }));
-            }
-            return { code: 0, stdout: "", stderr: "" };
-        };
-        const processExists = vi.fn(() => {
-            processChecks++;
-            if (processChecks === 1)
-                return true;
-            lifecycle.push("process-exit");
-            return false;
-        });
-        const result = await new WindowsTaskService({
-            homeDir: home,
-            runner,
-            processExists,
-            validateConfig: async () => undefined,
-            readyTimeoutMs: 20,
-            stopTimeoutMs: 50,
-            pollIntervalMs: 1,
-        }).install(value);
-        expect(result.state).toMatchObject({ status: "ready", pid: 801 });
-        expect(lifecycle).toEqual(["stop", "process-exit", "unregister", "register", "start"]);
-        expect(processExists).toHaveBeenCalledWith(800);
-        expect(await readFile(resolve(paths.dataDir, "data/keep.txt"), "utf8")).toBe("keep");
-        expect(await readFile(paths.stdoutPath, "utf8")).toBe("keep logs");
-    });
-    it("replaces an installed stopped task without stopping a process", async () => {
-        const home = await mkdtemp(resolve(tmpdir(), "agentroam-windows-task-reinstall-stopped-"));
-        const paths = resolveServicePaths(home, resolve(home, "data"));
-        const value = config(home, paths.dataDir);
-        await mkdir(value.roots[0], { recursive: true });
-        const lifecycle = [];
-        let installed = true;
-        const runner = async (_command, args) => {
-            const script = Buffer.from(args.at(-1), "base64").toString("utf16le");
-            if (script.includes("Get-ScheduledTask")) {
-                return { code: 0, stdout: JSON.stringify({ installed, running: false }), stderr: "" };
-            }
-            if (script.includes("Stop-ScheduledTask"))
-                lifecycle.push("stop");
-            if (script.includes("Unregister-ScheduledTask")) {
-                lifecycle.push("unregister");
-                installed = false;
-            }
-            if (script.includes("Register-ScheduledTask")) {
-                lifecycle.push("register");
-                installed = true;
-            }
-            if (script.includes("Start-ScheduledTask")) {
-                lifecycle.push("start");
-                await writePrivateText(paths.statePath, JSON.stringify({
-                    status: "ready", pid: 801, version: value.version, startedAt: "y", updatedAt: "y",
-                }));
-            }
-            return { code: 0, stdout: "", stderr: "" };
-        };
-        await new WindowsTaskService({
-            homeDir: home,
-            runner,
-            processExists: vi.fn(() => false),
-            validateConfig: async () => undefined,
-            readyTimeoutMs: 20,
-            pollIntervalMs: 1,
-        }).install(value);
-        expect(lifecycle).toEqual(["unregister", "register", "start"]);
-    });
-    it("does not replace a running task while its previous process is still alive", async () => {
-        const home = await mkdtemp(resolve(tmpdir(), "agentroam-windows-task-reinstall-timeout-"));
-        const paths = resolveServicePaths(home, resolve(home, "data"));
-        const value = config(home, paths.dataDir);
-        await mkdir(value.roots[0], { recursive: true });
-        await writePrivateText(paths.statePath, JSON.stringify({
-            status: "ready", pid: 800, version: "0.2.0-preview.8", startedAt: "x", updatedAt: "x",
-        }));
-        const lifecycle = [];
-        const runner = async (_command, args) => {
-            const script = Buffer.from(args.at(-1), "base64").toString("utf16le");
-            if (script.includes("Get-ScheduledTask")) {
-                return { code: 0, stdout: JSON.stringify({ installed: true, running: true }), stderr: "" };
-            }
-            if (script.includes("Stop-ScheduledTask"))
-                lifecycle.push("stop");
-            if (script.includes("Unregister-ScheduledTask"))
-                lifecycle.push("unregister");
-            if (script.includes("Register-ScheduledTask"))
-                lifecycle.push("register");
-            return { code: 0, stdout: "", stderr: "" };
-        };
-        await expect(new WindowsTaskService({
-            homeDir: home,
-            runner,
-            processExists: () => true,
-            validateConfig: async () => undefined,
-            stopTimeoutMs: 0,
-            pollIntervalMs: 1,
-        }).install(value)).rejects.toThrow("did not stop after task termination");
-        expect(lifecycle).toEqual(["stop"]);
-    });
-    it("builds a safely quoted task action for paths with spaces and apostrophes", () => {
-        const value = config("C:\\Users\\O'Brien", "C:\\Users\\O'Brien\\.agentroam");
-        const host = resolveWindowsServiceHost(value.cliPath);
-        const script = buildRegisterTaskScript(value, host, "C:\\Users\\O'Brien\\config.json");
-        expect(host).toBe("C:\\Agent Roam\\node_modules\\agentroam\\dist\\service\\windows-service-host.js");
-        expect(script).toContain("O''Brien");
-        expect(script).toContain("New-ScheduledTaskAction");
-        expect(script).toContain("RestartCount 999");
-        expect(quoteWindowsCommandLineArgument("C:\\path with spaces\\")).toBe('"C:\\path with spaces\\\\"');
-    });
-});
-function config(home, dataDir) {
-    return {
-        version: "0.2.0-preview.9",
-        nodePath: "C:\\Node Runtime\\node.exe",
-        cliPath: "C:\\Agent Roam\\node_modules\\agentroam\\bin\\agentroam.mjs",
-        roots: [resolve(home, "workspace")],
-        port: null,
-        relay: "auto",
-        tunnelCommand: null,
-        localOnly: false,
-        dataDir,
-        installedAt: "2026-09-04T00:00:00.000Z",
-    };
-}

package/dist/tunnel/cloudflare-provider.test.js

@@ -1,45 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-import { buildCloudflaredArguments, waitForConnectedUrl } from "./cloudflare-provider.js";
-describe("buildCloudflaredArguments", () => {
-    it("uses HTTP/2 so launchd tunnels do not depend on outbound UDP", () => {
-        expect(buildCloudflaredArguments("http://127.0.0.1:3000")).toEqual([
-            "tunnel",
-            "--no-autoupdate",
-            "--protocol",
-            "http2",
-            "--url",
-            "http://127.0.0.1:3000",
-        ]);
-    });
-});
-describe("waitForConnectedUrl", () => {
-    it("waits for both the public URL and a registered tunnel connection", async () => {
-        const { child, stderr } = fakeChild();
-        let resolved = false;
-        const ready = waitForConnectedUrl(child, vi.fn(), 100).then((url) => {
-            resolved = true;
-            return url;
-        });
-        stderr.write("https://ready.trycloudflare.com\n");
-        await new Promise((resolvePromise) => setImmediate(resolvePromise));
-        expect(resolved).toBe(false);
-        stderr.write("INF Registered tunnel ");
-        stderr.write("connection connIndex=0 protocol=quic\n");
-        await expect(ready).resolves.toBe("https://ready.trycloudflare.com");
-    });
-    it("supports registration output arriving before the URL", async () => {
-        const { child, stdout, stderr } = fakeChild();
-        const ready = waitForConnectedUrl(child, vi.fn(), 100);
-        stdout.write("INF Registered tunnel connection connIndex=0 protocol=http2\n");
-        stderr.write("Visit https://later.trycloudflare.com when ready\n");
-        await expect(ready).resolves.toBe("https://later.trycloudflare.com");
-    });
-});
-function fakeChild() {
-    const stdout = new PassThrough();
-    const stderr = new PassThrough();
-    const child = Object.assign(new EventEmitter(), { stdout, stderr });
-    return { child, stdout, stderr };
-}

package/dist/tunnel/pinggy-provider.test.js

@@ -1,40 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-import { PinggyTunnelProvider, parsePinggyUrl } from "./pinggy-provider.js";
-describe("parsePinggyUrl", () => {
-    it("accepts only Pinggy free HTTPS URLs", () => {
-        expect(parsePinggyUrl("open https://abc-123.run.pinggy-free.link now")).toBe("https://abc-123.run.pinggy-free.link");
-        expect(parsePinggyUrl("https://example.com")).toBeNull();
-        expect(parsePinggyUrl("http://abc.run.pinggy-free.link")).toBeNull();
-    });
-});
-describe("PinggyTunnelProvider", () => {
-    it("starts SSH on port 443 with persistent host-key checking", async () => {
-        const child = fakeChild();
-        const spawnImpl = vi.fn((_command, _args) => child);
-        const provider = new PinggyTunnelProvider(43210, "/tmp/agentroam-test", spawnImpl);
-        const started = provider.start({ localUrl: "http://127.0.0.1:43210", signal: new AbortController().signal, log: vi.fn() });
-        queueMicrotask(() => child.stderr.write("https://sample.run.pinggy-free.link\n"));
-        const handle = await started;
-        expect(handle.publicUrl).toBe("https://sample.run.pinggy-free.link");
-        const args = spawnImpl.mock.calls[0][1];
-        expect(args).toContain("443");
-        expect(args).toContain("StrictHostKeyChecking=accept-new");
-        expect(args).toContain("0:localhost:43210");
-        expect(args.some((value) => value.startsWith("UserKnownHostsFile="))).toBe(true);
-    });
-});
-function fakeChild() {
-    const child = new EventEmitter();
-    child.stdout = new PassThrough();
-    child.stderr = new PassThrough();
-    Object.defineProperty(child, "exitCode", { value: null, writable: true });
-    Object.defineProperty(child, "pid", { value: undefined, writable: true });
-    child.kill = vi.fn(() => {
-        child.exitCode = 0;
-        child.emit("exit", 0, null);
-        return true;
-    });
-    return child;
-}

package/dist/tunnel/proxy-settings.test.js

@@ -1,111 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { parseMacSystemProxy, resolveProxyForUrl } from "./proxy-settings.js";
-const target = new URL("https://api.example.test/status");
-describe("resolveProxyForUrl", () => {
-    it("prefers the lowercase HTTPS proxy and normalizes an omitted scheme", async () => {
-        await expect(resolveProxyForUrl(target, {
-            env: {
-                https_proxy: "127.0.0.1:7897",
-                HTTPS_PROXY: "http://uppercase.test:8080",
-                HTTP_PROXY: "http://http.test:8080",
-            },
-            platform: "linux",
-        })).resolves.toBe("http://127.0.0.1:7897/");
-    });
-    it("uses HTTP_PROXY as the HTTPS fallback and ALL_PROXY for HTTP", async () => {
-        await expect(resolveProxyForUrl(target, { env: { HTTP_PROXY: "http://http.test:8080" }, platform: "linux" })).resolves.toBe("http://http.test:8080/");
-        await expect(resolveProxyForUrl(new URL("http://example.test"), {
-            env: { ALL_PROXY: "https://all.test:8443" },
-            platform: "linux",
-        })).resolves.toBe("https://all.test:8443/");
-    });
-    it.each([
-        ["*", "https://api.example.test/status"],
-        ["api.example.test", "https://api.example.test/status"],
-        [".example.test", "https://api.example.test/status"],
-        ["example.test", "https://api.example.test/status"],
-        ["api.example.test:443", "https://api.example.test/status"],
-        ["api.example.test:8443", "https://api.example.test:8443/status"],
-    ])("bypasses the proxy for NO_PROXY=%s", async (noProxy, url) => {
-        await expect(resolveProxyForUrl(new URL(url), {
-            env: { HTTPS_PROXY: "http://proxy.test:8080", NO_PROXY: noProxy },
-            platform: "darwin",
-            readMacSystemProxy: vi.fn(async () => macProxyOutput()),
-        })).resolves.toBeNull();
-    });
-    it("does not bypass a suffix lookalike or a rule with a different port", async () => {
-        await expect(resolveProxyForUrl(target, {
-            env: { HTTPS_PROXY: "http://proxy.test:8080", no_proxy: "notexample.test,api.example.test:8443" },
-            platform: "linux",
-        })).resolves.toBe("http://proxy.test:8080/");
-    });
-    it("falls back to uppercase NO_PROXY when the lowercase value is empty", async () => {
-        await expect(resolveProxyForUrl(target, {
-            env: { HTTPS_PROXY: "http://proxy.test:8080", no_proxy: "", NO_PROXY: "example.test" },
-            platform: "linux",
-        })).resolves.toBeNull();
-    });
-    it("falls back to the enabled macOS HTTPS proxy", async () => {
-        await expect(resolveProxyForUrl(target, {
-            env: {},
-            platform: "darwin",
-            readMacSystemProxy: async () => macProxyOutput(),
-        })).resolves.toBe("http://127.0.0.1:7897/");
-    });
-    it("uses the macOS HTTP proxy when HTTPS proxying is disabled", async () => {
-        await expect(resolveProxyForUrl(target, {
-            env: {},
-            platform: "darwin",
-            readMacSystemProxy: async () => macProxyOutput({ httpsEnabled: false }),
-        })).resolves.toBe("http://127.0.0.1:7898/");
-    });
-    it("returns direct mode for command failures and non-macOS platforms", async () => {
-        await expect(resolveProxyForUrl(target, {
-            env: {},
-            platform: "darwin",
-            readMacSystemProxy: async () => {
-                throw new Error("scutil failed");
-            },
-        })).resolves.toBeNull();
-        const reader = vi.fn(async () => macProxyOutput());
-        await expect(resolveProxyForUrl(target, { env: {}, platform: "linux", readMacSystemProxy: reader })).resolves.toBeNull();
-        expect(reader).not.toHaveBeenCalled();
-    });
-});
-describe("parseMacSystemProxy", () => {
-    it("parses enabled HTTP and HTTPS settings", () => {
-        expect(parseMacSystemProxy(macProxyOutput())).toEqual({
-            httpProxy: "http://127.0.0.1:7898/",
-            httpsProxy: "http://127.0.0.1:7897/",
-        });
-    });
-    it("ignores disabled and malformed settings", () => {
-        expect(parseMacSystemProxy(`
-        HTTPEnable : 0
-        HTTPProxy : 127.0.0.1
-        HTTPPort : 7898
-        HTTPSEnable : 1
-        HTTPSProxy : 127.0.0.1
-        HTTPSPort : not-a-port
-      `)).toEqual({ httpProxy: null, httpsProxy: null });
-        expect(parseMacSystemProxy("HTTPSEnable : 1\nHTTPSProxy : 127.0.0.1\nHTTPSPort : 70000")).toEqual({
-            httpProxy: null,
-            httpsProxy: null,
-        });
-        expect(parseMacSystemProxy("HTTPSEnable : 1\nHTTPSProxy : proxy.test/path\nHTTPSPort : 7897")).toEqual({
-            httpProxy: null,
-            httpsProxy: null,
-        });
-    });
-});
-function macProxyOutput({ httpsEnabled = true } = {}) {
-    return `
-<dictionary> {
-  HTTPEnable : 1
-  HTTPPort : 7898
-  HTTPProxy : 127.0.0.1
-  HTTPSEnable : ${httpsEnabled ? "1" : "0"}
-  HTTPSPort : 7897
-  HTTPSProxy : 127.0.0.1
-}`;
-}

package/dist/tunnel/public-readiness.test.js

@@ -1,104 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { waitForPublicReadiness } from "./public-readiness.js";
-describe("waitForPublicReadiness", () => {
-    it("retries a transient 530 and accepts the expected auth status", async () => {
-        const fetchImpl = vi
-            .fn()
-            .mockResolvedValueOnce(new Response("unavailable", { status: 530 }))
-            .mockResolvedValueOnce(Response.json({ authenticated: false, needsSetup: true }, { status: 200 }));
-        await waitForPublicReadiness("https://example.test", {
-            fetchImpl,
-            intervalMs: 1,
-            timeoutMs: 100,
-        });
-        expect(fetchImpl).toHaveBeenCalledTimes(2);
-    });
-    it("rejects an invalid HTTP 200 payload", async () => {
-        const fetchImpl = vi.fn().mockResolvedValue(Response.json({ ok: true }));
-        await expect(waitForPublicReadiness("https://example.test", { fetchImpl, intervalMs: 1, timeoutMs: 5 })).rejects.toThrow("invalid auth status JSON");
-    });
-    it("includes the last HTTP status in timeout diagnostics", async () => {
-        const fetchImpl = vi.fn().mockResolvedValue(new Response("bad gateway", { status: 502 }));
-        await expect(waitForPublicReadiness("https://example.test", { fetchImpl, intervalMs: 1, timeoutMs: 5 })).rejects.toThrow("HTTP 502");
-    });
-    it("reuses one proxy handle across retries and closes it after success", async () => {
-        const close = vi.fn(async () => { });
-        const proxiedFetch = vi
-            .fn()
-            .mockResolvedValueOnce(new Response("unavailable", { status: 530 }))
-            .mockResolvedValueOnce(Response.json({ authenticated: false, needsSetup: true }, { status: 200 }));
-        const proxyFetchFactory = vi.fn(() => ({ fetch: proxiedFetch, close }));
-        await waitForPublicReadiness("https://example.test", {
-            intervalMs: 1,
-            timeoutMs: 100,
-            proxyResolver: async () => "http://127.0.0.1:7897/",
-            proxyFetchFactory,
-        });
-        expect(proxyFetchFactory).toHaveBeenCalledOnce();
-        expect(proxiedFetch).toHaveBeenCalledTimes(2);
-        expect(close).toHaveBeenCalledOnce();
-    });
-    it.each([
-        {
-            name: "a fatal response",
-            fetchImpl: vi.fn().mockResolvedValue(new Response("forbidden", { status: 403 })),
-            timeoutMs: 100,
-            expected: "HTTP 403",
-        },
-        {
-            name: "a timeout",
-            fetchImpl: vi.fn().mockResolvedValue(new Response("unavailable", { status: 530 })),
-            timeoutMs: 2,
-            expected: "HTTP 530",
-        },
-    ])("closes the proxy handle after $name", async ({ fetchImpl, timeoutMs, expected }) => {
-        const close = vi.fn(async () => { });
-        await expect(waitForPublicReadiness("https://example.test", {
-            intervalMs: 1,
-            timeoutMs,
-            proxyResolver: async () => "http://127.0.0.1:7897/",
-            proxyFetchFactory: () => ({ fetch: fetchImpl, close }),
-        })).rejects.toThrow(expected);
-        expect(close).toHaveBeenCalledOnce();
-    });
-    it("closes the proxy handle when readiness is aborted", async () => {
-        const controller = new AbortController();
-        const close = vi.fn(async () => { });
-        const proxiedFetch = vi.fn().mockImplementation(async () => {
-            controller.abort();
-            throw new Error("request aborted");
-        });
-        await expect(waitForPublicReadiness("https://example.test", {
-            signal: controller.signal,
-            proxyResolver: async () => "http://127.0.0.1:7897/",
-            proxyFetchFactory: () => ({ fetch: proxiedFetch, close }),
-        })).rejects.toThrow("public tunnel readiness aborted");
-        expect(close).toHaveBeenCalledOnce();
-    });
-    it("does not create a proxy handle in direct mode", async () => {
-        const proxyFetchFactory = vi.fn();
-        const directFetch = vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(Response.json({ authenticated: false, needsSetup: true }));
-        try {
-            await waitForPublicReadiness("https://example.test", {
-                proxyResolver: async () => null,
-                proxyFetchFactory,
-            });
-        }
-        finally {
-            directFetch.mockRestore();
-        }
-        expect(proxyFetchFactory).not.toHaveBeenCalled();
-    });
-    it("skips proxy discovery when a fetch implementation is injected", async () => {
-        const proxyResolver = vi.fn(async () => "http://127.0.0.1:7897/");
-        const proxyFetchFactory = vi.fn();
-        const fetchImpl = vi.fn().mockResolvedValue(Response.json({ authenticated: false, needsSetup: true }));
-        await waitForPublicReadiness("https://example.test", {
-            fetchImpl,
-            proxyResolver,
-            proxyFetchFactory,
-        });
-        expect(proxyResolver).not.toHaveBeenCalled();
-        expect(proxyFetchFactory).not.toHaveBeenCalled();
-    });
-});