@rynx-ai/daemon 0.1.10 → 0.1.11-beta.10

package/dist/cli.js

@@ -1,732 +0,0 @@
-#!/usr/bin/env node
-/**
- * `rynx` — the daemon CLI.
- *
- *   rynx start | stop | restart | status | logs   process lifecycle (pm2)
- *   rynx plugin manage install|list|uninstall|enable|disable ...
- *   rynx plugin <plugin-id> <plugin-command> ...
- *   rynx agent list | show <name> | add <name> | rm <name>
- *
- * The CLI owns process lifecycle, plugin install/registry, and the file-based
- * declarative agent specs. Channel instances (a channel + an agent) are
- * configured in the web control console (`rynx start`, then open it).
- *
- * Hand-rolled arg dispatch (no arg-parser dep) to match the repo's zero-dep CLI
- * style.
- */
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { confirm, isCancel } from "@clack/prompts";
-import { listAgentSpecs, loadAgentSpec, loadConfig, rynxAgentsDir } from "@rynx-ai/core";
-import { encodePairingCode } from "@rynx-ai/protocol/direct-runtime";
-import { agentSpecPath, removeAgentSpec, scaffoldAgentSpec } from "./agent-file.js";
-import { parseBrowserCliArgs, resolveBrowserCliTarget, } from "./browser-cli-args.js";
-import { resolveChromeForTestingRelease } from "./chrome-for-testing-release-resolver.js";
-import { createChromeForTestingArtifactStore } from "./chrome-for-testing-store.js";
-import { dbPath } from "./db.js";
-import { cleanupLegacySessions } from "./migrations/cleanup-legacy-sessions.js";
-import { PluginCliUsageError, runPluginCliCommand } from "./plugin-cli.js";
-import { installPlugin, uninstallPlugin } from "./plugin-installer.js";
-import { restartAfterPluginInstall } from "./plugin-install-restart.js";
-import { getPlugin, isRunnablePluginRecord, listPlugins, setPluginEnabled } from "./plugin-store.js";
-import { ensureResidentPluginRuntime, reloadResidentPluginRuntime, } from "./plugin-runtime-control.js";
-import { isPm2DaemonOnline, startDaemon, statusDaemon, stopDaemon, streamLogs } from "./pm2.js";
-import { runDoctor, runSetup } from "./setup.js";
-import { runUpdate } from "./update.js";
-import { createResidentRemoteRuntimePairingOffer, callManagedRuntimeBrowser, callResidentRuntime, forgetResidentRuntimeTarget, getResidentRuntimeLocalBrowserEndpoint, listResidentRemoteRuntimeClients, listResidentRuntimeTargets, pairResidentRuntimeTarget, revokeResidentRemoteRuntimeClient, readOptionalManagedRuntimeBrowserCredential, testResidentRuntimeTarget, } from "./control-client.js";
-const USAGE = `Usage: rynx <command>
-
-Setup:
-  setup              interactive wizard — configure ~/.rynx/config.json step by step
-  doctor             read-only health check (creates nothing; non-zero on failure)
-
-Lifecycle:
-  start              start the resident server (pm2-supervised)
-  restart            reload the running server
-  stop               stop and remove the server
-  status             print whether the server is running
-  logs               tail the server logs
-  update [version]   upgrade @rynx-ai/daemon (npm) + restart  (--check: report only)
-
-Plugins (static manifest + isolated runner):
-  plugin manage list
-  plugin manage install <npm|path|git|url> [...] [--expect-digest <sha256-...>]
-  plugin manage update <id> [...] [--expect-digest <sha256-...>]
-  plugin manage uninstall <id>
-  plugin manage enable|disable <id>
-                         manage arbitrary installed plugins
-  plugin <id> <command>  run a command declared by that plugin
-                         (\`manage\` is a reserved plugin id)
-
-Agents (~/.rynx/agents/<id>/agent.json — dir name is the id):
-  agent list             list agents (id · runtime · model · [display name])
-  agent show <id>        print a parsed + validated agent spec
-  agent add <id>         scaffold an agent dir + starter spec, then edit it
-  agent rm <id>          remove an agent (its whole config dir)
-                         (select an agent in a chat with \`/agent <id>\`;
-                          set a fleet default via the RYNX_DEFAULT_AGENT env var)
-
-Maintenance:
-  cleanup sessions [--dry-run]
-                         delete legacy (pre-uuid) sessions so the system starts
-                         clean on opaque ids (runs once at boot too). Stop the
-                         daemon before running manually.
-
-Emulator:
-  emulator <args…>       passthrough to the bundled \`rynx-emulator\` CLI
-                         (use --runtime <local|daemon-id> for bounded unary
-                          remote control; run \`rynx emulator\` for its help)
-
-Remote Runtime:
-  runtime share --address <host|ws-url> [--label <label>] [--json]
-                         on the remote host, print one revocable pairing link
-  runtime pair [...]     compatibility alias for runtime share
-  runtime add --pairing-code <rynx://...> [--name <name>]
-                         pair, verify and save a remote daemon
-                         (stdin remains supported for scripts)
-  runtime list [--json]  list the synthetic local target and paired daemons
-  runtime test <local|daemon-id> [--json]
-                         authenticate and read the selected daemon status
-  runtime forget <daemon-id>
-                         remove one local target and its client credential
-  runtime clients list [--json]
-  runtime clients revoke <grant-id>
-                         inspect/revoke clients authorized by this daemon
-
-Browser (one Browser per Runtime Session):
-  browser install [--channel <stable|beta|dev|canary> | --version <x.x.x.x>] [--json]
-                         install and activate managed Chrome for Testing
-  browser update [--channel <stable|beta|dev|canary>] [--json]
-                         resolve and activate the current channel build
-  browser version [--json]
-                         show the active managed Browser engine
-  browser clean [--json] remove inactive managed builds while retaining active,
-                         rollback, and live Headless Browser builds
-  browser open [url] [--session <id>] [--runtime <local|daemon-id>] [--json]
-                         open the selected Runtime Session's managed Browser
-  browser status [--session <id>] [--runtime <local|daemon-id>] [--json]
-                         show Browser generation, state and active Page
-  browser pages [--session <id>] [--runtime <local|daemon-id>] [--json]
-                         list the Browser's opaque Pages
-  browser endpoint [--ensure] [--session <local-id>] [--json]
-                         print Runtime-local CDP; --ensure opens it when absent
-  browser close [--session <id>] [--runtime <local|daemon-id>] [--json]
-                         close the current Browser generation
-
-Channel instances (a channel + an agent) are configured in the web control
-console (run \`rynx start\`, then open the printed URL).
-`;
-function fail(message) {
-    console.error(message);
-    process.exit(2);
-}
-async function pluginManageCommand(sub, arg) {
-    switch (sub) {
-        case "list": {
-            const plugins = listPlugins();
-            console.log(`Plugins (db: ${dbPath()})`);
-            if (plugins.length === 0) {
-                console.log("  (none)");
-                return;
-            }
-            for (const p of plugins) {
-                const state = !isRunnablePluginRecord(p)
-                    ? "reinstall-required"
-                    : p.enabled
-                        ? "enabled"
-                        : "disabled";
-                console.log(`  ${p.name.padEnd(16)} ${(p.version ?? "-").padEnd(10)} ${p.source.padEnd(6)} ${state}`);
-            }
-            return;
-        }
-        case "install": {
-            if (!arg)
-                fail("plugin manage install: missing npm/path/git/url source");
-            const force = process.argv.includes("--force");
-            const grantAll = process.argv.includes("--grant-all");
-            const allowScripts = process.argv.includes("--allow-scripts");
-            const expectedDigest = digestOption(process.argv);
-            const result = await installPlugin(arg, (line) => console.log(line), {
-                allowScripts,
-                ...(expectedDigest ? { expectedDigest } : {}),
-                onConflict: async (existing) => {
-                    if (force)
-                        return true;
-                    const desc = `${existing.source}${existing.version ? ` @${existing.version}` : ""}`;
-                    if (!process.stdin.isTTY) {
-                        fail(`plugin "${existing.name}" already installed (${desc}). ` +
-                            `Re-run with --force, or \`rynx plugin manage uninstall ${existing.name}\` first.`);
-                    }
-                    const yes = await confirm({
-                        message: `插件 "${existing.name}" 已存在(${desc}),覆盖吗?`,
-                        initialValue: false,
-                    });
-                    return !isCancel(yes) && yes === true;
-                },
-                approveCapabilities: (manifest, existing) => approvePluginCapabilities(manifest, existing?.grants ?? [], grantAll),
-            });
-            if (result.skipped) {
-                console.log(`已取消,保留现有插件 "${result.name}"。`);
-            }
-            else {
-                console.log(`Plugin "${result.name}" (${result.source}${result.version ? ` @${result.version}` : ""}) installed.`);
-                await restartAfterPluginInstall({
-                    restart: process.argv.includes("--restart"),
-                    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
-                }, {
-                    isDaemonOnline: isPm2DaemonOnline,
-                    confirmRestart: async () => {
-                        const answer = await confirm({
-                            message: "Restart Rynx now to apply the plugin?",
-                            initialValue: true,
-                        });
-                        return !isCancel(answer) && answer === true;
-                    },
-                    restartDaemon: () => startDaemon({ force: true }),
-                    log: (message) => console.log(message),
-                });
-            }
-            return;
-        }
-        case "update": {
-            if (!arg)
-                fail("plugin manage update: missing plugin id");
-            const existing = getPlugin(arg);
-            if (!existing)
-                fail(`plugin "${arg}" not found`);
-            if (!isRunnablePluginRecord(existing)) {
-                fail(`plugin "${arg}" uses the removed legacy format; reinstall it from an explicit source`);
-            }
-            const expectedDigest = digestOption(process.argv);
-            const result = await installPlugin(existing.spec, (line) => console.log(line), {
-                expectedId: existing.name,
-                allowScripts: process.argv.includes("--allow-scripts"),
-                ...(expectedDigest ? { expectedDigest } : {}),
-                onConflict: () => true,
-                approveCapabilities: (manifest, current) => approvePluginCapabilities(manifest, current?.grants ?? [], process.argv.includes("--grant-all")),
-            });
-            console.log(`Plugin "${result.name}" updated${result.version ? ` to ${result.version}` : ""}. Run \`rynx restart\` to apply.`);
-            return;
-        }
-        case "uninstall": {
-            if (!arg)
-                fail("plugin manage uninstall: missing plugin id");
-            if (!(await uninstallPlugin(arg, (line) => console.log(line))))
-                fail(`plugin "${arg}" not found`);
-            console.log(`Plugin "${arg}" uninstalled. Run \`rynx restart\` to apply.`);
-            return;
-        }
-        case "enable":
-        case "disable": {
-            if (!arg)
-                fail(`plugin manage ${sub}: missing plugin id`);
-            const plugin = getPlugin(arg);
-            if (!plugin)
-                fail(`plugin "${arg}" not found`);
-            if (!isRunnablePluginRecord(plugin))
-                fail(`plugin "${arg}" must be reinstalled before it can be enabled`);
-            setPluginEnabled(arg, sub === "enable");
-            console.log(`Plugin "${arg}" ${sub}d. Run \`rynx restart\` to apply.`);
-            return;
-        }
-        default:
-            fail(USAGE);
-    }
-}
-async function pluginCommand(args) {
-    const [pluginId, command] = args;
-    if (pluginId === "manage") {
-        await pluginManageCommand(command, args[2]);
-        return;
-    }
-    if (!pluginId)
-        fail(USAGE);
-    try {
-        const result = await runPluginCliCommand(pluginId, args.slice(1));
-        if (result.code !== 0) {
-            process.exitCode = result.code;
-            return;
-        }
-        const reload = result.effects.some((effect) => effect.effect === "runtime.reload");
-        const ensure = result.effects.some((effect) => effect.effect === "runtime.ensure");
-        if (reload || ensure) {
-            try {
-                if (reload)
-                    await reloadResidentPluginRuntime(pluginId);
-                else
-                    await ensureResidentPluginRuntime(pluginId);
-            }
-            catch (error) {
-                const detail = error instanceof Error ? error.message : String(error);
-                throw new Error(reload
-                    ? `Plugin "${pluginId}" configuration was saved, but its runtime did not become ready: ${detail}`
-                    : `Plugin "${pluginId}" runtime did not become ready: ${detail}`);
-            }
-            if (!args.includes("--json"))
-                console.log(`Plugin "${pluginId}" runtime is ready.`);
-        }
-    }
-    catch (error) {
-        if (error instanceof PluginCliUsageError) {
-            console.log(error.message);
-            return;
-        }
-        throw error;
-    }
-}
-async function approvePluginCapabilities(manifest, existing, grantAll) {
-    const requested = manifest.requestedCapabilities;
-    const existingSet = new Set(existing);
-    const newCapabilities = requested.filter((capability) => !existingSet.has(capability));
-    if (newCapabilities.length === 0)
-        return requested.filter((capability) => existingSet.has(capability));
-    if (grantAll)
-        return requested;
-    console.log(`Plugin "${manifest.id}" requests host capabilities:`);
-    for (const capability of newCapabilities)
-        console.log(`  - ${capability}`);
-    if (!process.stdin.isTTY) {
-        throw new Error("capability approval required; inspect the list and re-run with --grant-all");
-    }
-    const approved = await confirm({
-        message: `Grant these ${newCapabilities.length} capability/capabilities to "${manifest.id}"?`,
-        initialValue: false,
-    });
-    if (isCancel(approved) || approved !== true)
-        throw new Error("plugin installation cancelled");
-    return requested;
-}
-async function agentCommand(sub, name) {
-    switch (sub) {
-        case "list": {
-            const specs = await listAgentSpecs();
-            console.log(`Agents (dir: ${rynxAgentsDir()})`);
-            if (specs.length === 0) {
-                console.log("  (none)");
-                return;
-            }
-            for (const spec of specs) {
-                const runtime = spec.executor?.runtime ?? "(default)";
-                const model = spec.executor?.model ?? "(default)";
-                const display = spec.name && spec.name !== spec.id ? `  (${spec.name})` : "";
-                console.log(`  ${spec.id.padEnd(16)} ${runtime.padEnd(8)} ${model}${display}`);
-            }
-            return;
-        }
-        case "show": {
-            if (!name)
-                fail("agent show: missing agent name");
-            const spec = await loadAgentSpec(name);
-            if (!spec)
-                fail(`agent "${name}" not found at ${agentSpecPath(name)}`);
-            console.log(JSON.stringify(spec, null, 2));
-            return;
-        }
-        case "add": {
-            if (!name)
-                fail("agent add: missing agent name");
-            if (existsSync(agentSpecPath(name)))
-                fail(`agent "${name}" already exists at ${agentSpecPath(name)}`);
-            scaffoldAgentSpec(name);
-            console.log(`Agent "${name}" created at ${agentSpecPath(name)}. Edit it, then select it in a chat with \`/agent ${name}\`.`);
-            return;
-        }
-        case "rm":
-        case "remove": {
-            if (!name)
-                fail("agent rm: missing agent name");
-            if (!removeAgentSpec(name))
-                fail(`agent "${name}" not found`);
-            console.log(`Agent "${name}" removed.`);
-            return;
-        }
-        default:
-            fail(USAGE);
-    }
-}
-async function cleanupCommand(sub) {
-    if (sub !== "sessions")
-        fail("cleanup: only `cleanup sessions` is supported");
-    const dryRun = process.argv.includes("--dry-run");
-    const result = cleanupLegacySessions({
-        codexStorePath: loadConfig().AGENT_SESSION_STORE_PATH,
-        dryRun,
-        log: (entry) => console.log(JSON.stringify(entry)),
-    });
-    const summary = `${result.deletedSessions} session(s), ${result.deletedLogRows} log row(s), ${result.prunedStoreEntries} store entr(ies)`;
-    console.log(dryRun ? `Dry run: would delete ${summary}.` : `Deleted ${summary}.`);
-}
-/** Pass `rynx emulator <args…>` through to the dependency's own CLI, verbatim.
- *  Resolved from @rynx-ai/emulator (dist/cli.js sits beside the main entry), so it
- *  runs the exact locked version — no PATH or npx involved. Stdio is inherited
- *  so interactive flows (the skill install agent picker) work. */
-function emulatorPassthrough(args) {
-    const require = createRequire(import.meta.url);
-    const cliPath = path.join(path.dirname(require.resolve("@rynx-ai/emulator")), "cli.js");
-    const child = spawn(process.execPath, [cliPath, ...args], { stdio: "inherit" });
-    child.on("exit", (code) => process.exit(code ?? 1));
-    child.on("error", (error) => {
-        console.error(`rynx emulator: failed to launch the bundled CLI: ${error.message}`);
-        process.exit(1);
-    });
-}
-async function runtimeCommand(args) {
-    const [sub, arg] = args;
-    const json = args.includes("--json");
-    switch (sub) {
-        case "share":
-        case "pair": {
-            const label = optionValue(args, "--label");
-            const address = optionValue(args, "--address");
-            if (!address) {
-                fail("runtime share: pass --address with a host or ws(s) URL reachable by the other device");
-            }
-            const offer = await createResidentRemoteRuntimePairingOffer({
-                ...(label ? { clientLabel: label } : {}),
-                address,
-            });
-            console.log(json ? JSON.stringify(offer, null, 2) : encodePairingCode(offer));
-            return;
-        }
-        case "add": {
-            const name = optionValue(args, "--name");
-            const code = optionValue(args, "--pairing-code");
-            if (code === undefined && process.stdin.isTTY) {
-                fail("runtime add: pass --pairing-code or pipe a pairing link on stdin");
-            }
-            const raw = code ?? await readStdinBounded(64 * 1024);
-            if (!raw.trim()) {
-                fail("runtime add: pass --pairing-code or pipe a pairing link on stdin");
-            }
-            let offer = raw.trim();
-            if (raw.trim().startsWith("{")) {
-                try {
-                    offer = JSON.parse(raw);
-                }
-                catch {
-                    fail("runtime add: stdin is not valid pairing JSON");
-                }
-            }
-            const result = await pairResidentRuntimeTarget(offer, name);
-            if (json)
-                console.log(JSON.stringify(result, null, 2));
-            else {
-                console.log(`Paired ${result.target.displayName} (${result.target.daemonId}) via ${result.target.endpoint}.`);
-                console.log(`Remote instance: ${result.status.daemonInstanceId}`);
-            }
-            return;
-        }
-        case "list": {
-            const targets = await listResidentRuntimeTargets();
-            if (json) {
-                console.log(JSON.stringify({ runtimes: targets }, null, 2));
-                return;
-            }
-            console.log("Runtime targets");
-            for (const target of targets) {
-                const route = target.binding === "local" ? "local" : target.endpoint;
-                console.log(`  ${target.selector.padEnd(38)} ${target.displayName}  ${route}`);
-            }
-            return;
-        }
-        case "test": {
-            if (!arg || arg.startsWith("--"))
-                fail("runtime test: missing local or daemon id");
-            const result = await testResidentRuntimeTarget(arg);
-            if (json)
-                console.log(JSON.stringify(result, null, 2));
-            else {
-                console.log(`${result.target.displayName}: connected to ${result.status.daemonId} ` +
-                    `(instance ${result.status.daemonInstanceId})`);
-            }
-            return;
-        }
-        case "forget": {
-            if (!arg || arg.startsWith("--"))
-                fail("runtime forget: missing daemon id");
-            await forgetResidentRuntimeTarget(arg);
-            console.log(`Forgot Runtime target ${arg}.`);
-            return;
-        }
-        case "clients": {
-            const action = arg;
-            if (action === "list") {
-                const clients = await listResidentRemoteRuntimeClients();
-                if (json) {
-                    console.log(JSON.stringify({ clients }, null, 2));
-                    return;
-                }
-                console.log("Remote Runtime clients");
-                if (clients.length === 0)
-                    console.log("  (none)");
-                for (const client of clients) {
-                    const state = client.revokedAt ? "revoked" : "active";
-                    console.log(`  ${client.grantId.padEnd(38)} ${client.clientLabel ?? client.clientId}  ${state}`);
-                }
-                return;
-            }
-            if (action === "revoke") {
-                const grantId = args[2];
-                if (!grantId || grantId.startsWith("--")) {
-                    fail("runtime clients revoke: missing grant id");
-                }
-                const result = await revokeResidentRemoteRuntimeClient(grantId);
-                console.log(`Revoked ${grantId}; closed ${result.closedConnections} active connection(s).`);
-                return;
-            }
-            fail("runtime clients: expected list or revoke <grant-id>");
-        }
-        default:
-            fail(USAGE);
-    }
-}
-async function browserCommand(args) {
-    let parsed;
-    try {
-        parsed = parseBrowserCliArgs(args);
-    }
-    catch (error) {
-        fail(error instanceof Error ? error.message : String(error));
-    }
-    const sub = parsed.subcommand;
-    const json = parsed.json;
-    if (sub === "install" || sub === "update") {
-        const version = parsed.version;
-        const channelValue = parsed.channel;
-        if (version && channelValue) {
-            fail("browser install: choose either --version or --channel");
-        }
-        if (sub === "update" && version) {
-            fail("browser update: use --channel, or browser install --version for a pinned build");
-        }
-        const selector = version
-            ? { kind: "version", version }
-            : { kind: "channel", channel: browserReleaseChannel(channelValue) };
-        const resolved = await resolveChromeForTestingRelease(selector);
-        const installed = await createChromeForTestingArtifactStore().installResolved(resolved, {
-            ...(json ? {} : { onProgress: (message) => console.log(message) }),
-        });
-        if (json)
-            console.log(JSON.stringify({ resolved, installed }, null, 2));
-        else
-            console.log(`Active Browser engine: Chrome for Testing ${installed.version}.`);
-        return;
-    }
-    if (sub === "version") {
-        const installed = createChromeForTestingArtifactStore().readActive();
-        if (json)
-            console.log(JSON.stringify({ installed: installed ?? null }, null, 2));
-        else if (installed) {
-            console.log(`Chrome for Testing ${installed.version} · ${installed.hostPlatform} · ${installed.sha256}`);
-        }
-        else {
-            console.log("No managed Chrome for Testing build is installed.");
-        }
-        return;
-    }
-    if (sub === "clean") {
-        const result = createChromeForTestingArtifactStore().pruneBuilds();
-        if (json)
-            console.log(JSON.stringify(result, null, 2));
-        else if (result.removedBuilds.length === 0) {
-            console.log("No inactive Chrome for Testing builds were eligible for removal.");
-        }
-        else {
-            console.log(`Removed ${result.removedBuilds.length} inactive Chrome for Testing build(s).`);
-        }
-        return;
-    }
-    if (sub === "endpoint") {
-        const target = await resolveBrowserTarget(parsed);
-        if (parsed.ensure) {
-            await callBrowserRuntime(target, "browser.open", { sessionId: target.sessionId });
-        }
-        const descriptor = await getResidentRuntimeLocalBrowserEndpoint({
-            ...(target.credential ? {} : { sessionId: target.sessionId }),
-        });
-        console.log(json ? JSON.stringify(descriptor, null, 2) : descriptor.endpoint);
-        return;
-    }
-    const target = await resolveBrowserTarget(parsed);
-    const sessionId = target.sessionId;
-    if (sub === "open") {
-        const state = await callBrowserRuntime(target, "browser.open", {
-            sessionId,
-            ...(parsed.url ? { url: parsed.url } : {}),
-        });
-        printBrowserState(state, json);
-        return;
-    }
-    const state = await callBrowserRuntime(target, "browser.state.get", { sessionId });
-    if (sub === "status") {
-        printBrowserState(state, json);
-        return;
-    }
-    if (sub === "pages") {
-        if (json)
-            console.log(JSON.stringify({ pages: state?.pages ?? [] }, null, 2));
-        else
-            printBrowserPages(state);
-        return;
-    }
-    if (!state) {
-        if (json)
-            console.log(JSON.stringify({ closed: false, browser: null }, null, 2));
-        else
-            console.log(`No Browser is open for Session ${sessionId}.`);
-        return;
-    }
-    const result = await callBrowserRuntime(target, "browser.close", {
-        sessionId,
-        browserGeneration: state.browserGeneration,
-    });
-    console.log(json
-        ? JSON.stringify(result, null, 2)
-        : `Closed Browser generation ${result.browserGeneration} for Session ${sessionId}.`);
-}
-function browserReleaseChannel(value) {
-    const normalized = value === undefined
-        ? "Stable"
-        : `${value.slice(0, 1).toUpperCase()}${value.slice(1).toLowerCase()}`;
-    if (normalized !== "Stable" &&
-        normalized !== "Beta" &&
-        normalized !== "Dev" &&
-        normalized !== "Canary") {
-        fail("browser: --channel must be stable, beta, dev, or canary");
-    }
-    return normalized;
-}
-async function resolveBrowserTarget(args) {
-    const credential = await readOptionalManagedRuntimeBrowserCredential();
-    try {
-        return resolveBrowserCliTarget(args, credential);
-    }
-    catch (error) {
-        fail(error instanceof Error ? error.message : String(error));
-    }
-}
-async function callBrowserRuntime(target, method, params) {
-    if (target.credential) {
-        return callManagedRuntimeBrowser(target.credential, method, params);
-    }
-    return callResidentRuntime(target.runtimeSelector, method, params);
-}
-function printBrowserState(state, json) {
-    if (json) {
-        console.log(JSON.stringify({ browser: state }, null, 2));
-        return;
-    }
-    if (!state) {
-        console.log("No Browser is open for this Session.");
-        return;
-    }
-    console.log(`Browser ${state.status} · ${state.executionBackend} · generation ${state.browserGeneration}`);
-    printBrowserPages(state);
-}
-function printBrowserPages(state) {
-    if (!state || state.pages.length === 0) {
-        console.log("  (no Pages)");
-        return;
-    }
-    for (const page of state.pages) {
-        const marker = page.pageId === state.activePageId ? "*" : " ";
-        const title = page.title ? `  ${page.title}` : "";
-        console.log(`${marker} ${page.pageId}  ${page.url}${title}`);
-    }
-}
-function optionValue(args, option) {
-    const index = args.indexOf(option);
-    if (index < 0)
-        return undefined;
-    const value = args[index + 1];
-    if (!value || value.startsWith("--"))
-        fail(`${option}: missing value`);
-    return value;
-}
-function digestOption(args) {
-    const expected = optionValue(args, "--expect-digest");
-    const legacyAlias = optionValue(args, "--expected-digest");
-    if (expected && legacyAlias)
-        fail("pass only one digest expectation option");
-    return expected ?? legacyAlias;
-}
-async function readStdinBounded(maxBytes) {
-    const chunks = [];
-    let bytes = 0;
-    for await (const chunk of process.stdin) {
-        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        bytes += value.byteLength;
-        if (bytes > maxBytes)
-            fail(`stdin exceeds ${maxBytes} bytes`);
-        chunks.push(value);
-    }
-    return Buffer.concat(chunks, bytes).toString("utf8");
-}
-async function main() {
-    const [command, sub, arg] = process.argv.slice(2);
-    switch (command) {
-        case "setup":
-            process.exit(await runSetup());
-            break;
-        case "doctor":
-            process.exit(await runDoctor());
-            break;
-        case "update": {
-            const rest = process.argv.slice(3);
-            const version = rest.find((a) => !a.startsWith("--"));
-            process.exit(await runUpdate({
-                check: rest.includes("--check"),
-                json: rest.includes("--json"),
-                version,
-            }));
-            break;
-        }
-        case "start":
-            process.exit(startDaemon({ force: false }));
-            break;
-        case "restart":
-            process.exit(startDaemon({ force: true }));
-            break;
-        case "stop":
-            process.exit(stopDaemon());
-            break;
-        case "status":
-            process.exit(statusDaemon());
-            break;
-        case "logs":
-            streamLogs();
-            break;
-        case "plugin":
-            await pluginCommand(process.argv.slice(3));
-            break;
-        case "agent":
-            await agentCommand(sub, arg);
-            break;
-        case "cleanup":
-            await cleanupCommand(sub);
-            break;
-        case "emulator":
-            emulatorPassthrough(process.argv.slice(3));
-            break;
-        case "runtime":
-            await runtimeCommand(process.argv.slice(3));
-            break;
-        case "browser":
-            await browserCommand(process.argv.slice(3));
-            break;
-        case undefined:
-        case "help":
-        case "-h":
-        case "--help":
-            console.log(USAGE);
-            break;
-        default:
-            fail(`Unknown command: ${command}\n\n${USAGE}`);
-    }
-}
-main().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});