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

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 });
-        }
-    });
-});

package/dist/device-pairing.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { parseArgs } from "./args.js";
-import { pairingQrPayload, watchPairingApproval } from "./device-pairing.js";
-describe("local approval commands", () => {
-    it("encodes a separate QR invitation and validates the server URL", () => {
-        expect(parseArgs(["pair", "--url", "https://phone.example/web"]).pairingUrl).toBe("https://phone.example/web");
-        const link = new URL(pairingQrPayload("https://phone.example/web", "a".repeat(43)));
-        expect(link.origin + link.pathname).toBe("https://phone.example/pair");
-        expect(link.search).toBe("");
-        expect(link.hash).toBe(`#pair=${"a".repeat(43)}`);
-        expect(() => pairingQrPayload("https://user:password@phone.example", "a".repeat(43))).toThrow();
-    });
-    const id = "12345678-1234-1234-1234-123456789abc";
-    it("requires a request ID and matching phrase for explicit approval", () => {
-        expect(() => parseArgs(["approve", id])).toThrow(/phrase/);
-        expect(parseArgs(["approve", id, "--phrase", "松林·月光·1234"])).toMatchObject({ approvalRequestId: id, approvalPhrase: "松林·月光·1234" });
-        for (const command of ["lock", "unlock", "audit", "approvals"])
-            expect(parseArgs([command]).command).toBe(command);
-        expect(parseArgs(["deny", id]).approvalRequestId).toBe(id);
-    });
-    it.each([true, false])("displays the phrase and sends only the local user's %s decision", async (approve) => {
-        const now = Date.now();
-        const request = { id, name: "Phone\u001b[31m", phrase: "松林·月光·1234", created: now, expires: now + 300_000, status: "waiting" };
-        const admin = vi.fn().mockResolvedValueOnce({ requests: [request], locked: false }).mockResolvedValueOnce({ status: approve ? "approved" : "denied" });
-        const log = vi.fn();
-        const confirm = vi.fn(async () => approve);
-        await watchPairingApproval("/tmp/unused", now + 300_000, { admin: admin, log, confirm });
-        expect(log).toHaveBeenCalledWith(`核对短语：${request.phrase}`);
-        expect(confirm).toHaveBeenCalledWith(request, undefined);
-        expect(admin).toHaveBeenLastCalledWith("/tmp/unused", approve ? "approve" : "deny", { id, ...(approve ? { phrase: request.phrase } : {}) });
-        expect(log.mock.calls.flat().join("\n")).not.toContain("\u001b");
-    });
-});