@rynx-ai/cli 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/commands/plugin.js

@@ -1,14 +1,25 @@
 import { createInterface } from "node:readline/promises";
-import { cancelResidentPluginInstallation, commitResidentPluginInstallation, invokeResidentPluginCommand, listResidentPlugins, prepareResidentPluginInstallation, setResidentPluginEnabled, uninstallResidentPlugin, } from "../control-client.js";
+import { cancelResidentPluginInstallation, commitResidentPluginInstallation, prepareResidentPluginInstallation, setResidentPluginEnabled, uninstallResidentPlugin, } from "../control-client.js";
 import { fail } from "./errors.js";
-const PLUGIN_STDIN_MAX_BYTES = 256 * 1024;
 const PLUGIN_DIGEST_PATTERN = /^sha256-[A-Za-z0-9+/]{43}={0,2}$/;
 const CANONICAL_PLUGIN_ID_PATTERN = /^[a-z][a-z0-9-]{0,62}@[a-z0-9][a-z0-9-]{0,62}(?:\/[a-z0-9][a-z0-9._-]{0,99})?$/;
+const PLUGIN_USAGE = `Usage: rynx plugin <command|plugin-id>
+
+Management:
+  list
+  install <source|plugin@market> [--force] [--expect-digest <sha256-...>]
+  update <plugin@market> [--expect-digest <sha256-...>]
+  enable|disable|uninstall <plugin@market>
+
+Plugin commands:
+  <plugin-id> <command> [args...]
+  <plugin-id> --help`;
 export async function runPluginManageCommand(args, options = {}) {
     const [subcommand, pluginId] = args;
     switch (subcommand) {
         case "list": {
-            const plugins = await listResidentPlugins();
+            const { listInstalledPlugins } = await import("@rynx-ai/daemon/plugin-cli");
+            const plugins = listInstalledPlugins();
             console.log("Plugins");
             if (plugins.length === 0) {
                 console.log("  (none)");
@@ -126,23 +137,50 @@ export async function runPluginCommand(args) {
     const [pluginId, command] = args;
     if (!pluginId)
         fail("plugin: missing plugin id");
+    if (pluginId === "--help" || pluginId === "-h" || pluginId === "help") {
+        console.log(PLUGIN_USAGE);
+        return 0;
+    }
     if (["list", "install", "update", "uninstall", "enable", "disable"].includes(pluginId)) {
         return runPluginManageCommand(args);
     }
     if (!command)
         fail(`plugin ${pluginId}: missing command`);
-    const stdin = process.stdin.isTTY
-        ? undefined
-        : await readStdinBounded(PLUGIN_STDIN_MAX_BYTES);
-    const result = await invokeResidentPluginCommand(pluginId, args.slice(1), stdin === undefined ? {} : { stdin });
-    if (result.stdout)
-        process.stdout.write(result.stdout);
-    if (result.stderr)
-        process.stderr.write(result.stderr);
-    if (result.truncated) {
-        process.stderr.write("rynx: plugin command output was truncated by the daemon\n");
+    const pluginCli = await import("@rynx-ai/daemon/plugin-cli");
+    if (command === "--help" || command === "-h") {
+        console.log(pluginCli.installedPluginCommandUsage(pluginId));
+        return 0;
+    }
+    return runPluginCliWithForwardedSignals((signal) => pluginCli.runPluginCliCommand(pluginId, args.slice(1), {
+        stdio: "inherit",
+        signal,
+    }));
+}
+async function runPluginCliWithForwardedSignals(run) {
+    const controller = new AbortController();
+    let interruptedBy;
+    const interrupt = (signal) => {
+        interruptedBy ??= signal;
+        if (!controller.signal.aborted) {
+            controller.abort(new Error(`plugin command interrupted by ${signal}`));
+        }
+    };
+    const onSigint = () => interrupt("SIGINT");
+    const onSigterm = () => interrupt("SIGTERM");
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    try {
+        return (await run(controller.signal)).code;
+    }
+    catch (error) {
+        if (interruptedBy)
+            return interruptedBy === "SIGINT" ? 130 : 143;
+        throw error;
+    }
+    finally {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
     }
-    return result.code;
 }
 function parseInstallationArgs(operation, args) {
     const target = args[0];
@@ -219,15 +257,3 @@ async function confirmInTerminal(message) {
         prompt.close();
     }
 }
-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(`plugin stdin exceeds ${maxBytes} bytes`);
-        chunks.push(value);
-    }
-    return Buffer.concat(chunks, bytes).toString("utf8");
-}

package/dist/commands/setup.js

@@ -3,10 +3,15 @@ import { chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, re
 import path from "node:path";
 import * as prompts from "@clack/prompts";
 import { AGENT_RUNTIME_IDS, getRuntimeProfile, loadConfig, rynxConfigFile, } from "@rynx-ai/core";
-import { inspectDaemonDiagnostics, prepareBundledPlugins, } from "@rynx-ai/daemon/setup-service";
+import { inspectDaemonDiagnostics, inspectSystemDependencies, prepareBundledPlugins, } from "@rynx-ai/daemon/setup-service";
+import { BUNDLED_TMUX_UNAVAILABLE_MESSAGE, resolveBundledTmux, } from "@rynx-ai/tmux";
+import { enableAutostart, inspectAutostart, } from "../autostart.js";
+import { createProgressDisplay } from "../progress-display.js";
 import { fail } from "./errors.js";
+import { runLifecycleCommand } from "./lifecycle.js";
 export async function runSetupCommand(args) {
     const options = parseSetupOptions(args);
+    const progress = options.json ? undefined : createProgressDisplay();
     const interactive = !options.nonInteractive &&
         !options.hasConfigurationArguments &&
         Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -50,23 +55,30 @@ export async function runSetupCommand(args) {
         },
     };
     let failed = false;
+    progress?.start("正在准备 Rynx 内置插件");
     try {
         const plugins = await prepareBundledPlugins();
         result.plugins = {
             status: plugins.status,
             changed: [...plugins.installed, ...plugins.updated],
         };
+        progress?.succeed("Rynx 内置插件已就绪");
     }
     catch (error) {
         failed = true;
+        progress?.clear();
+        const detail = errorMessage(error);
         result.plugins = {
             status: "error",
-            detail: errorMessage(error),
+            detail,
         };
+        console.error(`Rynx 内置插件准备失败：${detail}`);
     }
+    progress?.start("正在检查 Rynx Browser");
     const diagnostics = await inspectDaemonDiagnostics();
     if (!diagnostics.browser.supported) {
         result.browser = { action: options.browser, status: "unsupported" };
+        progress?.succeed("当前平台不支持 Rynx Browser");
     }
     else if (diagnostics.browser.installedVersion) {
         result.browser = {
@@ -74,29 +86,42 @@ export async function runSetupCommand(args) {
             status: "ready",
             version: diagnostics.browser.installedVersion,
         };
+        progress?.succeed(`Rynx Browser 已就绪：${diagnostics.browser.installedVersion}`);
     }
     else if (options.browser !== "skip") {
+        progress?.update("正在安装 Rynx Browser");
         try {
             const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
-            const installed = await createBrowserArtifactManagementService().install({ channel: "stable" }, options.json
-                ? {}
-                : { onProgress: (message) => console.error(message) });
+            const installed = await createBrowserArtifactManagementService().install({ channel: "stable" }, progress ? { onProgress: (message) => progress.update(message) } : {});
             result.browser = {
                 action: options.browser,
                 status: "ready",
                 version: installed.installed.version,
             };
+            progress?.succeed(`Rynx Browser 已就绪：${installed.installed.version}`);
         }
         catch (error) {
             failed = true;
+            progress?.clear();
+            const detail = errorMessage(error);
             result.browser = {
                 action: options.browser,
                 status: "error",
-                detail: errorMessage(error),
+                detail,
             };
+            console.error(`Rynx Browser 安装失败：${detail}`);
         }
     }
-    if (options.json) {
+    else {
+        progress?.succeed("已跳过 Rynx Browser 安装");
+    }
+    if (interactive && process.env.RYNX_DISTRIBUTION !== "app") {
+        failed = await offerBackgroundServiceSetup() || failed;
+    }
+    if (options.resultFile) {
+        writeJsonAtomically(options.resultFile, result);
+    }
+    else if (options.json) {
         console.log(JSON.stringify(result, null, 2));
     }
     else if (interactive) {
@@ -140,13 +165,25 @@ export async function runDoctorCommand(args) {
         return { id, installed: !probe.error && probe.status === 0 };
     });
     const daemon = await inspectDaemonDiagnostics();
+    const tmuxBin = resolveBundledTmux();
+    const systemDependencies = tmuxBin
+        ? await inspectSystemDependencies({ tmuxBin })
+        : {
+            tmux: {
+                installed: false,
+                detail: BUNDLED_TMUX_UNAVAILABLE_MESSAGE,
+            },
+        };
     const result = {
-        ok: configError === undefined && runtimes.some((runtime) => runtime.installed),
+        ok: configError === undefined &&
+            runtimes.some((runtime) => runtime.installed) &&
+            systemDependencies.tmux.installed,
         configPath: rynxConfigFile(),
         config,
         configError,
         runtimes,
         daemon,
+        systemDependencies,
     };
     if (json)
         console.log(JSON.stringify(result, null, 2));
@@ -159,6 +196,7 @@ export async function runDoctorCommand(args) {
         for (const runtime of runtimes) {
             console.log(`${runtime.id}: ${runtime.installed ? "installed" : "not installed"}`);
         }
+        console.log(`tmux: ${systemDependencies.tmux.installed ? "installed" : "not installed"}`);
         if (daemon.browser.supported) {
             console.log(`browser: ${daemon.browser.installedVersion ?? daemon.browser.error ?? "not installed"}`);
         }
@@ -186,6 +224,17 @@ function parseSetupOptions(args) {
             options.nonInteractive = true;
             continue;
         }
+        if (arg === "--result-file") {
+            if (options.resultFile !== undefined)
+                fail("setup: duplicate option --result-file");
+            const value = args[index + 1];
+            if (!value || value.startsWith("--"))
+                fail("setup: --result-file requires a value");
+            options.resultFile = path.resolve(value);
+            options.nonInteractive = true;
+            index += 1;
+            continue;
+        }
         if (arg === "--install-browser" || arg === "--skip-browser") {
             if (options.browser !== "auto")
                 fail("setup: choose only one Browser action");
@@ -225,6 +274,9 @@ function parseSetupOptions(args) {
             fail(`setup: unknown option ${arg}`);
         }
     }
+    if (options.json && options.resultFile) {
+        fail("setup: choose either --json or --result-file");
+    }
     return options;
 }
 async function collectInteractiveSetup(config) {
@@ -257,19 +309,55 @@ async function collectInteractiveSetup(config) {
     if (prompts.isCancel(host))
         return cancelled();
     config.HOST = host;
-    const logLevel = await prompts.text({
-        message: "Log level",
-        initialValue: String(config.LOG_LEVEL),
-    });
-    if (prompts.isCancel(logLevel))
-        return cancelled();
-    config.LOG_LEVEL = logLevel;
     return true;
 }
 function cancelled() {
     prompts.cancel("Cancelled");
     return false;
 }
+async function offerBackgroundServiceSetup() {
+    const state = inspectAutostart();
+    if (!state.supported) {
+        prompts.log.warn(`Background service setup is unavailable${state.detail ? `: ${state.detail}` : ""}`);
+        return false;
+    }
+    const confirmed = await prompts.confirm({
+        message: state.registered
+            ? "Start the Rynx background service now? (Autostart is already enabled)"
+            : "Start Rynx now and automatically at login?",
+        initialValue: true,
+    });
+    if (prompts.isCancel(confirmed) || !confirmed) {
+        prompts.log.info("Skipped background service setup");
+        return false;
+    }
+    let failed = false;
+    if (!state.registered) {
+        try {
+            const enabled = enableAutostart();
+            prompts.log.success(`Autostart enabled${enabled.registrationPath ? `: ${enabled.registrationPath}` : ""}`);
+            if (enabled.manager === "systemd-user" && enabled.lingerEnabled === false) {
+                prompts.log.warn("Linger is disabled; Rynx stops when this user logs out");
+                if (enabled.lingerEnableCommand) {
+                    prompts.log.info(`Optional, requires sudo and is never run by setup: ${enabled.lingerEnableCommand}`);
+                }
+            }
+        }
+        catch (error) {
+            failed = true;
+            prompts.log.warn(`Could not enable autostart: ${errorMessage(error)}`);
+        }
+    }
+    const startStatus = await runLifecycleCommand("start", [], { quiet: true });
+    if (startStatus === 0) {
+        prompts.log.success("Rynx background service is running");
+    }
+    else {
+        failed = true;
+        prompts.log.warn("Rynx background service failed to start; run `rynx start` for details");
+    }
+    return failed;
+}
 function validateSetupConfig(config) {
     loadConfig({
         HOST: String(config.HOST),
@@ -290,14 +378,16 @@ function readRawConfig() {
     }
 }
 function writeConfigAtomically(config) {
-    const file = rynxConfigFile();
+    writeJsonAtomically(rynxConfigFile(), config);
+}
+function writeJsonAtomically(file, value) {
     const directory = path.dirname(file);
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     const temporary = path.join(directory, `.${path.basename(file)}.${process.pid}.tmp`);
     let descriptor;
     try {
         descriptor = openSync(temporary, "wx", 0o600);
-        writeFileSync(descriptor, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+        writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}\n`, "utf8");
         closeSync(descriptor);
         descriptor = undefined;
         renameSync(temporary, file);

package/dist/commands/skills.js

@@ -1,8 +1,8 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { isSkillPathComponent } from "@rynx-ai/core";
 import { fail } from "./errors.js";
-const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const MAX_SKILL_BYTES = 256 * 1024;
 const BUILTIN_SKILL_NAMES = ["browser", "emulator"];
 export async function runSkillsCommand(args) {
@@ -55,7 +55,7 @@ export async function listBuiltinSkills() {
     return guides.filter((guide) => guide !== null);
 }
 export async function readBuiltinSkill(name, full = false) {
-    if (!SKILL_NAME_PATTERN.test(name))
+    if (!isSkillPathComponent(name))
         return null;
     if (!BUILTIN_SKILL_NAMES.includes(name))
         return null;

package/dist/commands/update.js

@@ -3,7 +3,7 @@ import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync
 import { createRequire } from "node:module";
 import { dirname, join, sep } from "node:path";
 import { rynxHome } from "@rynx-ai/core";
-import { stopStandaloneDaemon } from "../standalone.js";
+import { runLifecycleCommand } from "./lifecycle.js";
 function selfPackage() {
     const require = createRequire(import.meta.url);
     const manifest = require("../../package.json");
@@ -72,7 +72,7 @@ export async function runUpdate(options) {
     if (!releaseLock)
         return 1;
     try {
-        if (await stopStandaloneDaemon() !== 0) {
+        if (await runLifecycleCommand("stop", []) !== 0) {
             console.error("update: could not stop the standalone daemon");
             return 1;
         }

package/dist/control-client.js

@@ -437,6 +437,8 @@ const MANAGED_BROWSER_RPC_METHODS = new Set([
     "browser.page.back",
     "browser.page.forward",
     "browser.page.reload",
+    "browser.request-headers.get",
+    "browser.request-headers.set",
 ]);
 /**
  * Invoke Browser control for the caller's own managed Session. Unlike the

package/dist/desktop-browser-host-client.js

@@ -1,14 +1,36 @@
-import { DESKTOP_BROWSER_HOST_MAX_BINARY_FRAME_BYTES, DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES, DESKTOP_BROWSER_HOST_MAX_PENDING_COMMANDS, DESKTOP_BROWSER_HOST_PATH, DESKTOP_BROWSER_HOST_PROTOCOL_VERSION, encodeDesktopBrowserHostSurfaceFrame, parseDesktopBrowserHostClientFrame, parseDesktopBrowserHostServerFrame, } from "@rynx-ai/protocol/desktop-browser-host";
+import { DESKTOP_BROWSER_HOST_MAX_BINARY_FRAME_BYTES, DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES, DESKTOP_BROWSER_HOST_MAX_PENDING_COMMANDS, DESKTOP_BROWSER_HOST_MINIMUM_PROTOCOL_VERSION, DESKTOP_BROWSER_HOST_PATH, DESKTOP_BROWSER_HOST_PROTOCOL_VERSION, encodeDesktopBrowserHostSurfaceFrame, parseDesktopBrowserHostClientFrame, parseDesktopBrowserHostServerFrame, } from "@rynx-ai/protocol/desktop-browser-host";
 import { WebSocket } from "ws";
 import { ensureDaemonControlEndpoint } from "./control-endpoint.js";
 const CONNECT_TIMEOUT_MS = 5_000;
 const MAX_BUFFERED_BYTES = DESKTOP_BROWSER_HOST_MAX_BINARY_FRAME_BYTES + DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES;
 /** Open the sole resident daemon's authenticated loopback Desktop Host lease. */
 export async function connectResidentDesktopBrowserHost(options) {
+    options.signal?.throwIfAborted();
+    const endpoint = options.endpoint
+        ?? await ensureDaemonControlEndpoint({ signal: options.signal });
+    assertDesktopBrowserHostEndpoint(endpoint);
+    try {
+        return await connectResidentDesktopBrowserHostVersion(options, endpoint, DESKTOP_BROWSER_HOST_PROTOCOL_VERSION);
+    }
+    catch (error) {
+        options.signal?.throwIfAborted();
+        if (!isLegacyProtocolRejection(error))
+            throw error;
+        // V1 daemons reject a V2 hello before issuing a lease. Reconnect once
+        // with their protocol so App and daemon can roll independently. Any
+        // failure after a lease is returned stays on that negotiated connection.
+        return connectResidentDesktopBrowserHostVersion(options, endpoint, DESKTOP_BROWSER_HOST_MINIMUM_PROTOCOL_VERSION).catch((legacyError) => {
+            throw new Error("Desktop Browser Host could not negotiate with the daemon", {
+                cause: new AggregateError([error, legacyError]),
+            });
+        });
+    }
+}
+async function connectResidentDesktopBrowserHostVersion(options, endpoint, protocolVersion) {
     options.signal?.throwIfAborted();
     const hello = parseDesktopBrowserHostClientFrame({
         type: "desktop.browser.host.hello",
-        protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+        protocolVersion,
         hostInstanceId: options.hostInstanceId,
         capabilities: {
             semanticPageBinding: options.capabilities.semanticPageBinding,
@@ -19,9 +41,6 @@ export async function connectResidentDesktopBrowserHost(options) {
     if (hello.type !== "desktop.browser.host.hello") {
         throw new Error("Desktop Browser Host hello parser returned the wrong frame");
     }
-    const endpoint = options.endpoint
-        ?? await ensureDaemonControlEndpoint({ signal: options.signal });
-    assertDesktopBrowserHostEndpoint(endpoint);
     const url = new URL(DESKTOP_BROWSER_HOST_PATH, `${endpoint.origin}/`);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     const socket = new WebSocket(url, {
@@ -139,7 +158,7 @@ export async function connectResidentDesktopBrowserHost(options) {
     socket.once("close", (code, reason) => {
         options.signal?.removeEventListener("abort", onAbort);
         if (!terminalError && !closing) {
-            terminalError = new Error(`Desktop Browser Host lease closed (${code})${reason.length > 0 ? `: ${reason.toString("utf8")}` : ""}`);
+            terminalError = new DesktopBrowserHostLeaseClosedError(code, `Desktop Browser Host lease closed (${code})${reason.length > 0 ? `: ${reason.toString("utf8")}` : ""}`);
         }
         if (!lease && terminalError)
             leaseReject(terminalError);
@@ -224,7 +243,7 @@ export async function connectResidentDesktopBrowserHost(options) {
                     signal: controller.signal,
                     reply: (result) => settle(command, {
                         type: "desktop.browser.host.reply",
-                        protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+                        protocolVersion: activeLease.protocolVersion,
                         leaseId: activeLease.leaseId,
                         commandId: command.commandId,
                         ok: true,
@@ -232,7 +251,7 @@ export async function connectResidentDesktopBrowserHost(options) {
                     }),
                     reject: (failure) => settle(command, {
                         type: "desktop.browser.host.reply",
-                        protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+                        protocolVersion: activeLease.protocolVersion,
                         leaseId: activeLease.leaseId,
                         commandId: command.commandId,
                         ok: false,
@@ -250,7 +269,7 @@ export async function connectResidentDesktopBrowserHost(options) {
             const nextSequence = eventSequence + 1;
             const frame = parseDesktopBrowserHostClientFrame({
                 type: "desktop.browser.host.event",
-                protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+                protocolVersion: activeLease.protocolVersion,
                 leaseId: activeLease.leaseId,
                 eventSequence: nextSequence,
                 event,
@@ -268,7 +287,7 @@ export async function connectResidentDesktopBrowserHost(options) {
             const encoded = encodeDesktopBrowserHostSurfaceFrame({
                 ...frame,
                 leaseId: activeLease.leaseId,
-            });
+            }, activeLease.protocolVersion);
             await sendBinary(socket, encoded);
         }),
         close: async () => {
@@ -285,6 +304,20 @@ export async function connectResidentDesktopBrowserHost(options) {
         },
     };
 }
+class DesktopBrowserHostLeaseClosedError extends Error {
+    closeCode;
+    constructor(closeCode, message) {
+        super(message);
+        this.closeCode = closeCode;
+        this.name = "DesktopBrowserHostLeaseClosedError";
+    }
+}
+function isLegacyProtocolRejection(error) {
+    return error instanceof DesktopBrowserHostLeaseClosedError &&
+        // 4400 is the pre-V2 daemon's generic invalid-frame response. 1002 covers
+        // standards-based V1 peers; 4406 is the explicit unsupported-version code.
+        (error.closeCode === 1002 || error.closeCode === 4400 || error.closeCode === 4406);
+}
 async function sendBinary(socket, bytes) {
     if (socket.readyState !== WebSocket.OPEN)
         throw new Error("Desktop Browser Host lease is closed");

package/dist/progress-display.d.ts

@@ -0,0 +1,7 @@
+export interface ProgressDisplay {
+    start(message: string): void;
+    update(message: string): void;
+    succeed(message: string): void;
+    clear(): void;
+}
+export declare function createProgressDisplay(): ProgressDisplay;

package/dist/progress-display.js

@@ -0,0 +1,78 @@
+import * as prompts from "@clack/prompts";
+const DOWNLOAD_PERCENT_PATTERN = /下载进度：(\d{1,3})%$/u;
+export function createProgressDisplay() {
+    if (!prompts.isTTY(process.stdout) || prompts.isCI()) {
+        return {
+            start: (message) => console.log(message),
+            update: (message) => console.log(message),
+            succeed: (message) => console.log(message),
+            clear: () => undefined,
+        };
+    }
+    const spinner = prompts.spinner({ output: process.stdout });
+    const progress = prompts.progress({
+        output: process.stdout,
+        max: 100,
+        size: 28,
+        style: "block",
+    });
+    let spinnerActive = false;
+    let progressActive = false;
+    let completedPercent = 0;
+    const clear = () => {
+        if (progressActive)
+            progress.clear();
+        if (spinnerActive)
+            spinner.clear();
+        progressActive = false;
+        spinnerActive = false;
+        completedPercent = 0;
+    };
+    const finishDownload = () => {
+        if (!progressActive)
+            return;
+        progress.stop("Chrome for Testing 下载完成");
+        progressActive = false;
+        completedPercent = 0;
+    };
+    return {
+        start(message) {
+            clear();
+            spinner.start(message);
+            spinnerActive = true;
+        },
+        update(message) {
+            const match = DOWNLOAD_PERCENT_PATTERN.exec(message);
+            if (match) {
+                const percent = Math.min(100, Number(match[1]));
+                if (spinnerActive) {
+                    spinner.clear();
+                    spinnerActive = false;
+                }
+                if (!progressActive) {
+                    progress.start(message);
+                    progressActive = true;
+                }
+                progress.advance(percent - completedPercent, message);
+                completedPercent = percent;
+                return;
+            }
+            finishDownload();
+            if (spinnerActive)
+                spinner.message(message);
+            else {
+                spinner.start(message);
+                spinnerActive = true;
+            }
+        },
+        succeed(message) {
+            finishDownload();
+            if (spinnerActive)
+                spinner.stop(message);
+            else
+                prompts.log.success(message);
+            spinnerActive = false;
+        },
+        clear,
+    };
+}

package/dist/run-cli.js

@@ -62,6 +62,10 @@ export async function runCli(argv) {
             return runBrowserCommand(argv.slice(1));
         case "cleanup":
             return runCleanupCommand(argv.slice(1));
+        case "autostart": {
+            const { runAutostartCommand } = await import("./commands/autostart.js");
+            return runAutostartCommand(argv.slice(1));
+        }
         case "setup": {
             const { runSetupCommand } = await import("./commands/setup.js");
             return runSetupCommand(argv.slice(1));

package/dist/standalone.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveBundledTmux } from "@rynx-ai/tmux";
 import { installedVersion } from "./version.js";
 import { ensureDaemonControlEndpoint, resolveDaemonControlEndpoint, } from "./control-endpoint.js";
 /** Resolve the canonical Builtin Skill directory shipped by this exact CLI. */
@@ -8,6 +9,7 @@ export function standaloneBuiltinSkillsDirectory(moduleUrl = import.meta.url) {
 }
 export async function startStandaloneDaemon(options = {}) {
     const cliVersion = installedVersion();
+    const tmuxBin = resolveBundledTmux();
     const { startDaemon } = await import("@rynx-ai/daemon/lifecycle");
     return startDaemon({
         force: options.restart ?? false,
@@ -16,6 +18,7 @@ export async function startStandaloneDaemon(options = {}) {
             builtinSkillsDir: standaloneBuiltinSkillsDirectory(),
             cliVersion,
             productVersion: cliVersion,
+            ...(tmuxBin ? { tmuxBin } : {}),
         },
     });
 }