@rynx-ai/cli 0.1.11-beta.5 → 0.1.11-beta.51

package/dist/commands/autostart.js

@@ -0,0 +1,58 @@
+import { autostartPlatformLabel, disableAutostart, enableAutostart, inspectAutostart, } from "../autostart.js";
+import { fail } from "./errors.js";
+export async function runAutostartCommand(args) {
+    if (process.env.RYNX_DISTRIBUTION === "app") {
+        fail("Rynx App manages startup. Use the App's launch-at-login setting.");
+    }
+    const [action, ...rest] = args;
+    if (rest.length > 0)
+        fail(`autostart: unexpected argument ${rest[0]}`);
+    if (action === "enable") {
+        const state = enableAutostart();
+        console.log(`Rynx autostart enabled with ${autostartPlatformLabel() ?? state.manager}.`);
+        if (state.registrationPath)
+            console.log(`Registration: ${state.registrationPath}`);
+        console.log("Rynx will start at the next login. Start it now with `rynx start`.");
+        printLingerWarning(state);
+        return 0;
+    }
+    if (action === "disable") {
+        const state = disableAutostart();
+        console.log("Rynx autostart disabled.");
+        console.log("The running daemon was not stopped; use `rynx stop` if needed.");
+        if (state.registered) {
+            console.warn("An autostart registration is still present; run `rynx autostart status`.");
+            return 1;
+        }
+        return 0;
+    }
+    if (action === "status") {
+        printAutostartState(inspectAutostart());
+        return 0;
+    }
+    fail("Usage: rynx autostart <enable|disable|status>");
+}
+function printAutostartState(state) {
+    console.log(`manager: ${state.manager}`);
+    console.log(`supported: ${state.supported ? "yes" : "no"}`);
+    console.log(`registered: ${state.registered ? "yes" : "no"}`);
+    if (state.active !== undefined) {
+        console.log(`active: ${state.active ? "yes" : "no"}`);
+    }
+    if (state.lingerEnabled !== undefined) {
+        console.log(`linger: ${state.lingerEnabled ? "yes" : "no"}`);
+    }
+    if (state.registrationPath) {
+        console.log(`registration: ${state.registrationPath}`);
+    }
+    if (state.detail)
+        console.log(`detail: ${state.detail}`);
+}
+function printLingerWarning(state) {
+    if (state.manager !== "systemd-user" || state.lingerEnabled !== false)
+        return;
+    console.warn("Linger is disabled; Rynx stops when this user logs out.");
+    if (state.lingerEnableCommand) {
+        console.warn(`To keep it running across logout and start it before login, run manually: ${state.lingerEnableCommand}`);
+    }
+}

package/dist/commands/browser.d.ts

@@ -1 +1,5 @@
+import type { RuntimeBrowserRequestHeadersPolicy } from "@rynx-ai/protocol/runtime-browser";
 export declare function runBrowserCommand(args: readonly string[]): Promise<number>;
+export declare function projectRequestHeadersPolicyForOutput(policy: RuntimeBrowserRequestHeadersPolicy, showValues: boolean): RuntimeBrowserRequestHeadersPolicy & {
+    valuesRedacted: boolean;
+};

package/dist/commands/browser.js

@@ -1,9 +1,6 @@
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { connectBrowserAutomation, } from "@rynx-ai/browser-cdp";
-import WebSocket from "ws";
 import { parseBrowserCliArgs, resolveBrowserCliTarget, } from "../browser-cli-args.js";
-import { callManagedRuntimeBrowser, callResidentRuntime, getResidentRuntimeLocalBrowserAutomationAccess, getResidentRuntimeLocalBrowserEndpoint, readOptionalManagedRuntimeBrowserCredential, } from "../control-client.js";
+import { callManagedRuntimeBrowser, callResidentRuntime, executeResidentBrowserCommand, ResidentBrowserCommandError, getResidentRuntimeLocalBrowserEndpoint, readOptionalManagedRuntimeBrowserCredential, } from "../control-client.js";
+import { createProgressDisplay } from "../progress-display.js";
 import { fail } from "./errors.js";
 export async function runBrowserCommand(args) {
     let parsed;
@@ -20,9 +17,18 @@ export async function runBrowserCommand(args) {
         const channel = browserReleaseChannel(parsed.channel);
         const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
         const artifacts = createBrowserArtifactManagementService();
-        const result = parsed.subcommand === "install"
-            ? await artifacts.install(parsed.version ? { version: parsed.version } : { channel }, parsed.json ? {} : { onProgress: (message) => console.error(message) })
-            : await artifacts.update({ channel }, parsed.json ? {} : { onProgress: (message) => console.error(message) });
+        const progress = parsed.json ? undefined : createProgressDisplay();
+        progress?.start(parsed.subcommand === "install" ? "正在安装 Rynx Browser" : "正在更新 Rynx Browser");
+        let result;
+        try {
+            result = parsed.subcommand === "install"
+                ? await artifacts.install(parsed.version ? { version: parsed.version } : { channel }, progress ? { onProgress: (message) => progress.update(message) } : {})
+                : await artifacts.update({ channel }, progress ? { onProgress: (message) => progress.update(message) } : {});
+        }
+        catch (error) {
+            progress?.clear();
+            throw error;
+        }
         if (parsed.json) {
             console.log(JSON.stringify({
                 resolved: result.resolved,
@@ -30,9 +36,7 @@ export async function runBrowserCommand(args) {
             }, null, 2));
         }
         else {
-            for (const message of result.messages)
-                console.log(message);
-            console.log(`Active Browser engine: Chrome for Testing ${result.installed.version}.`);
+            progress.succeed(`Rynx Browser 已就绪：Chrome for Testing ${result.installed.version}`);
         }
         return 0;
     }
@@ -75,8 +79,47 @@ export async function runBrowserCommand(args) {
         return 0;
     }
     const target = await resolveBrowserTarget(parsed);
-    if (isAutomationCommand(parsed.subcommand)) {
-        return runBrowserAutomation(parsed, target);
+    if (parsed.subcommand === "headers") {
+        const current = await callBrowserRuntime(target, "browser.request-headers.get", {
+            sessionId: target.sessionId,
+        });
+        if (parsed.headersAction === "get") {
+            if (parsed.showHeaderValues && target.credential) {
+                fail("browser headers get: --show-values is unavailable inside a managed Session; " +
+                    "use the Session settings UI");
+            }
+            printRequestHeadersPolicy(current, parsed.json, parsed.showHeaderValues === true);
+            return 0;
+        }
+        const headers = parsed.clearHeaders
+            ? []
+            : parsed.headers?.map(parseCliRequestHeader) ?? current.headers;
+        const updated = await callBrowserRuntime(target, "browser.request-headers.set", {
+            sessionId: target.sessionId,
+            expectedRevision: parsed.expectedRevision ?? current.revision,
+            enabled: parsed.headersEnabled ?? current.enabled,
+            headers,
+        });
+        printRequestHeadersPolicy(updated, parsed.json, false);
+        return 0;
+    }
+    if (parsed.subcommand === "exec") {
+        try {
+            const result = await executeResidentBrowserCommand({ argv: parsed.argv, ...(parsed.page ? { pageId: parsed.page } : {}) }, { sessionId: target.sessionId, credential: target.credential });
+            if (!parsed.json && typeof result.data?.help === "string")
+                console.log(result.data.help);
+            else if (!parsed.json && typeof result.data.snapshot === "string")
+                console.log(result.data.snapshot);
+            else
+                console.log(JSON.stringify(result, null, 2));
+            return 0;
+        }
+        catch (error) {
+            if (!(error instanceof ResidentBrowserCommandError))
+                throw error;
+            console.error(parsed.json ? JSON.stringify({ ...error.details, status: error.status }) : error.message);
+            return 1;
+        }
     }
     const sessionId = target.sessionId;
     if (parsed.subcommand === "open") {
@@ -125,86 +168,6 @@ function browserReleaseChannel(value) {
     }
     return normalized;
 }
-async function runBrowserAutomation(parsed, target) {
-    if (target.runtimeSelector !== "local") {
-        fail(`browser ${parsed.subcommand}: automation is available only on the local Runtime`);
-    }
-    const automationAccess = await getResidentRuntimeLocalBrowserAutomationAccess({
-        ...(target.credential ? {} : { sessionId: target.sessionId }),
-    });
-    const descriptor = automationAccess.descriptor;
-    let client;
-    try {
-        client = await connectBrowserAutomation({
-            endpoint: descriptor.endpoint,
-            ...(descriptor.pageTargetId ? { pageTargetId: descriptor.pageTargetId } : {}),
-            referenceKey: automationAccess.referenceKey,
-            createWebSocket: (endpoint) => new WebSocket(endpoint),
-        });
-        if (parsed.subcommand === "snapshot") {
-            const snapshot = await client.snapshot();
-            if (parsed.json) {
-                console.log(JSON.stringify({
-                    sessionId: descriptor.sessionId,
-                    browserGeneration: descriptor.browserGeneration,
-                    snapshot,
-                }, null, 2));
-            }
-            else {
-                printAutomationSnapshot(snapshot.nodes);
-            }
-            return 0;
-        }
-        if (parsed.subcommand === "navigate") {
-            const navigation = await client.navigate(parsed.url);
-            printAutomationResult(parsed, descriptor.browserGeneration, navigation);
-            return 0;
-        }
-        if (parsed.subcommand === "click") {
-            const clickTarget = parsed.ref !== undefined
-                ? { ref: parsed.ref }
-                : parsed.selector !== undefined
-                    ? { selector: parsed.selector }
-                    : { x: parsed.x, y: parsed.y };
-            await client.click(clickTarget);
-            printAutomationResult(parsed, descriptor.browserGeneration);
-            return 0;
-        }
-        if (parsed.subcommand === "type") {
-            const typeTarget = parsed.ref !== undefined
-                ? { ref: parsed.ref }
-                : { selector: parsed.selector };
-            await client.type(typeTarget, parsed.text);
-            printAutomationResult(parsed, descriptor.browserGeneration);
-            return 0;
-        }
-        const screenshot = await client.screenshot({
-            ...(parsed.format ? { format: parsed.format } : {}),
-            ...(parsed.quality !== undefined ? { quality: parsed.quality } : {}),
-        });
-        const output = path.resolve(parsed.output);
-        if (!path.isAbsolute(parsed.output)) {
-            fail("browser screenshot: --output must be an absolute path");
-        }
-        await writeFile(output, Buffer.from(screenshot.data, "base64"), { mode: 0o600 });
-        if (parsed.json) {
-            console.log(JSON.stringify({
-                completed: true,
-                browserGeneration: descriptor.browserGeneration,
-                output,
-                format: screenshot.format,
-                mimeType: screenshot.mimeType,
-            }, null, 2));
-        }
-        else {
-            console.log(output);
-        }
-        return 0;
-    }
-    finally {
-        client?.close();
-    }
-}
 async function resolveBrowserTarget(args) {
     const credential = await readOptionalManagedRuntimeBrowserCredential();
     try {
@@ -244,34 +207,40 @@ function printBrowserPages(state) {
         console.log(`${marker} ${page.pageId}  ${page.url}${title}`);
     }
 }
-function isAutomationCommand(subcommand) {
-    return subcommand === "snapshot"
-        || subcommand === "navigate"
-        || subcommand === "click"
-        || subcommand === "type"
-        || subcommand === "screenshot";
+function parseCliRequestHeader(value) {
+    const separator = value.indexOf(":");
+    if (separator <= 0) {
+        fail("browser headers set: --header must use 'Name: value'");
+    }
+    const name = value.slice(0, separator).trim();
+    const rawValue = value.slice(separator + 1);
+    return {
+        name,
+        value: rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue,
+    };
 }
-function printAutomationResult(parsed, browserGeneration, result = {}) {
-    if (parsed.json) {
-        console.log(JSON.stringify({
-            completed: true,
-            browserGeneration,
-            ...result,
-        }, null, 2));
-    }
-    else {
-        console.log(`Browser ${parsed.subcommand} completed.`);
-    }
-}
-function printAutomationSnapshot(nodes) {
-    if (nodes.length === 0) {
-        console.log("(empty accessibility tree)");
+function printRequestHeadersPolicy(policy, json, showValues) {
+    const output = projectRequestHeadersPolicyForOutput(policy, showValues);
+    if (json) {
+        console.log(JSON.stringify(output, null, 2));
         return;
     }
-    for (const node of nodes) {
-        const name = node.name ? ` ${JSON.stringify(node.name)}` : "";
-        const value = node.value ? ` value=${JSON.stringify(node.value)}` : "";
-        const ref = node.ref ? ` ref=${node.ref}` : "";
-        console.log(`${node.role}${name}${value}${ref}`);
+    console.log(`Browser request headers ${output.enabled ? "enabled" : "disabled"} · revision ${output.revision}`);
+    if (output.headers.length === 0) {
+        console.log("  (no configured headers)");
+        return;
     }
+    for (const header of output.headers)
+        console.log(`  ${header.name}: ${header.value}`);
+}
+export function projectRequestHeadersPolicyForOutput(policy, showValues) {
+    return {
+        enabled: policy.enabled,
+        revision: policy.revision,
+        valuesRedacted: !showValues,
+        headers: policy.headers.map((header) => ({
+            name: header.name,
+            value: showValues ? header.value : "[redacted]",
+        })),
+    };
 }

package/dist/commands/lifecycle.d.ts

@@ -1 +1,3 @@
-export declare function runLifecycleCommand(command: string, args: readonly string[]): Promise<number>;
+export declare function runLifecycleCommand(command: string, args: readonly string[], options?: {
+    quiet?: boolean;
+}): Promise<number>;

package/dist/commands/lifecycle.js

@@ -1,17 +1,77 @@
 import { startStandaloneDaemon, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.js";
+import { shutdownResidentDaemonIfIdle, waitForResidentDaemonExit, } from "../control-client.js";
+import { resolveDaemonControlEndpoint } from "../control-endpoint.js";
+import { assertMacLaunchdInvocation, refreshAutostart } from "../autostart.js";
+import { assertLinuxSystemdInvocation } from "../systemd-service.js";
+import { clearLegacyMaintenanceState } from "../legacy-maintenance.js";
 import { fail } from "./errors.js";
-export async function runLifecycleCommand(command, args) {
-    if (args.length > 0)
-        fail(`${command}: unexpected argument ${args[0]}`);
-    switch (command) {
-        case "start":
+const SYSTEMD_SERVICE_FLAG = "--systemd-service";
+const LAUNCHD_SERVICE_FLAG = "--launchd-service";
+const IF_IDLE_FLAG = "--if-idle";
+export async function runLifecycleCommand(command, args, options = {}) {
+    if (args.length === 1 && args[0] === SYSTEMD_SERVICE_FLAG) {
+        assertLinuxSystemdInvocation();
+        if (command === "start")
             return startStandaloneDaemon();
-        case "restart":
-            return startStandaloneDaemon({ restart: true });
-        case "stop":
+        if (command === "stop")
             return stopStandaloneDaemon();
+        fail(`${SYSTEMD_SERVICE_FLAG} is only valid for start and stop`);
+    }
+    if (args.length === 1 && args[0] === LAUNCHD_SERVICE_FLAG) {
+        assertMacLaunchdInvocation();
+        if (command === "start")
+            return startStandaloneDaemon();
+        fail(`${LAUNCHD_SERVICE_FLAG} is only valid for start`);
+    }
+    const stopIfIdle = command === "stop" && args.length === 1 && args[0] === IF_IDLE_FLAG;
+    const statusJson = command === "status" && args.length === 1 && args[0] === "--json";
+    if (args.length > 0 && !stopIfIdle && !statusJson) {
+        fail(`${command}: unexpected argument ${args[0]}`);
+    }
+    switch (command) {
+        case "start": {
+            refreshAutostart();
+            return startStandaloneDaemon(options.quiet ? { quiet: true } : undefined);
+        }
+        case "restart": {
+            refreshAutostart();
+            return startStandaloneDaemon({ restart: true, quiet: options.quiet });
+        }
+        case "stop": {
+            const endpoint = await resolveDaemonControlEndpoint();
+            if (endpoint &&
+                (endpoint.distribution !== "standalone" || endpoint.daemonLifecycle !== "standalone")) {
+                throw new Error("rynx stop supports only the standalone daemon; use the owning App lifecycle");
+            }
+            if (stopIfIdle && !endpoint) {
+                console.error("cannot verify whole-host idle because the standalone daemon is unavailable");
+                return 3;
+            }
+            if (stopIfIdle) {
+                let result;
+                try {
+                    result = await shutdownResidentDaemonIfIdle(endpoint);
+                }
+                catch (error) {
+                    console.error("cannot complete whole-host idle check: " +
+                        (error instanceof Error ? error.message : String(error)));
+                    return 3;
+                }
+                if (result.outcome === "busy") {
+                    console.error("rynx is busy: " +
+                        `runningTurns=${result.activity.runningTurns} ` +
+                        `pendingInteractions=${result.activity.pendingInteractions}`);
+                    return 2;
+                }
+                if (!await waitForResidentDaemonExit(endpoint.pid)) {
+                    console.error("rynx accepted whole-host idle shutdown but the daemon did not exit within 120 seconds; supervisor was left untouched");
+                    return 5;
+                }
+            }
+            return stopStandaloneAndThenClearLegacyMaintenance();
+        }
         case "status":
-            return statusStandaloneDaemon();
+            return statusStandaloneDaemon(statusJson ? { json: true } : undefined);
         case "logs":
             await streamStandaloneDaemonLogs();
             return 0;
@@ -19,3 +79,19 @@ export async function runLifecycleCommand(command, args) {
             fail(`unknown lifecycle command: ${command}`);
     }
 }
+async function stopStandaloneAndThenClearLegacyMaintenance() {
+    const status = await stopStandaloneDaemon();
+    if (status !== 0)
+        return 1;
+    clearLegacyMaintenanceAfterStop();
+    return 0;
+}
+function clearLegacyMaintenanceAfterStop() {
+    try {
+        clearLegacyMaintenanceState();
+    }
+    catch (error) {
+        console.warn("rynx lifecycle stopped but retired maintenance state could not be removed: " +
+            (error instanceof Error ? error.message : String(error)));
+    }
+}

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