@rynx-ai/daemon 0.1.0 → 0.1.10-beta.2

package/dist/cli.js

@@ -3,7 +3,8 @@
  * `rynx` — the daemon CLI.
  *
  *   rynx start | stop | restart | status | logs   process lifecycle (pm2)
- *   rynx plugin add <spec> | ls | rm <name> | enable <name> | disable <name>
+ *   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
@@ -19,14 +20,22 @@ 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 { getPlugin, listPlugins, setPluginEnabled } from "./plugin-store.js";
-import { startDaemon, statusDaemon, stopDaemon, streamLogs } from "./pm2.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:
@@ -41,15 +50,15 @@ Lifecycle:
   logs               tail the server logs
   update [version]   upgrade @rynx-ai/daemon (npm) + restart  (--check: report only)
 
-Plugins (~/.rynx/rynx.db · channel plugins):
-  plugin ls              list installed plugins
-  plugin add <spec> [--force]
-                         install from an npm spec or a local directory
-                         (local is copied into ~/.rynx/plugins; --force overwrites a same-named plugin)
-  plugin rm <name>       uninstall a plugin
-  plugin enable <name>   enable / disable an installed plugin
-  plugin disable <name>
-                         (plugin changes apply on \`rynx restart\`)
+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])
@@ -67,7 +76,44 @@ Maintenance:
 
 Emulator:
   emulator <args…>       passthrough to the bundled \`rynx-emulator\` CLI
-                         (same commands/flags; run \`rynx emulator\` for its help)
+                         (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).
@@ -76,9 +122,8 @@ function fail(message) {
     console.error(message);
     process.exit(2);
 }
-async function pluginCommand(sub, arg) {
+async function pluginManageCommand(sub, arg) {
     switch (sub) {
-        case "ls":
         case "list": {
             const plugins = listPlugins();
             console.log(`Plugins (db: ${dbPath()})`);
@@ -87,24 +132,32 @@ async function pluginCommand(sub, arg) {
                 return;
             }
             for (const p of plugins) {
-                const state = p.enabled ? "enabled" : "disabled";
+                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 "add":
         case "install": {
             if (!arg)
-                fail("plugin add: missing spec (an npm package or a local directory)");
+                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 rm ${existing.name}\` first.`);
+                            `Re-run with --force, or \`rynx plugin manage uninstall ${existing.name}\` first.`);
                     }
                     const yes = await confirm({
                         message: `插件 "${existing.name}" 已存在(${desc}),覆盖吗?`,
@@ -112,20 +165,54 @@ async function pluginCommand(sub, arg) {
                     });
                     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. Run \`rynx restart\` to apply.`);
+                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 "rm":
-        case "remove":
+        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 rm: missing plugin name");
+                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.`);
@@ -134,9 +221,12 @@ async function pluginCommand(sub, arg) {
         case "enable":
         case "disable": {
             if (!arg)
-                fail(`plugin ${sub}: missing plugin name`);
-            if (!getPlugin(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;
@@ -145,6 +235,69 @@ async function pluginCommand(sub, arg) {
             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": {
@@ -219,6 +372,298 @@ function emulatorPassthrough(args) {
         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) {
@@ -230,14 +675,11 @@ async function main() {
             break;
         case "update": {
             const rest = process.argv.slice(3);
-            const resultIdx = rest.indexOf("--result-file");
-            const resultFile = resultIdx >= 0 ? rest[resultIdx + 1] : undefined;
-            const version = rest.find((a) => !a.startsWith("--") && a !== resultFile);
+            const version = rest.find((a) => !a.startsWith("--"));
             process.exit(await runUpdate({
                 check: rest.includes("--check"),
                 json: rest.includes("--json"),
                 version,
-                resultFile,
             }));
             break;
         }
@@ -257,7 +699,7 @@ async function main() {
             streamLogs();
             break;
         case "plugin":
-            await pluginCommand(sub, arg);
+            await pluginCommand(process.argv.slice(3));
             break;
         case "agent":
             await agentCommand(sub, arg);
@@ -268,6 +710,12 @@ async function main() {
         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":