@rynx-ai/cli 0.1.11-beta.32 → 0.1.11-beta.34

package/dist/autostart.d.ts

@@ -0,0 +1,26 @@
+export { renderSystemdUnit } from "./systemd-service.js";
+export type AutostartManager = "launchd" | "systemd-user" | "unsupported";
+export interface AutostartState {
+    supported: boolean;
+    registered: boolean;
+    active?: boolean;
+    lingerEnabled?: boolean;
+    lingerEnableCommand?: string;
+    manager: AutostartManager;
+    registrationPath?: string;
+    detail?: string;
+}
+export interface AutostartRenderInput {
+    cliPath: string;
+    dataDir: string;
+    logDir: string;
+    nodePath: string;
+    pathEnv: string;
+}
+export declare function autostartPlatformLabel(platform?: NodeJS.Platform): string | undefined;
+export declare function inspectAutostart(): AutostartState;
+export declare function enableAutostart(): AutostartState;
+export declare function disableAutostart(): AutostartState;
+/** Refresh paths in an existing registration without enabling a new one. */
+export declare function refreshAutostart(): boolean;
+export declare function renderLaunchAgent(input: AutostartRenderInput): string;

package/dist/autostart.js

@@ -0,0 +1,229 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { rynxHome } from "@rynx-ai/core";
+import { disableLinuxAutostart, enableLinuxAutostart, inspectLinuxAutostart, refreshLinuxServiceIfPresent, } from "./systemd-service.js";
+export { renderSystemdUnit } from "./systemd-service.js";
+const LAUNCHD_LABEL = "ai.rynx.daemon";
+const COMMAND_TIMEOUT_MS = 5_000;
+export function autostartPlatformLabel(platform = process.platform) {
+    if (platform === "darwin")
+        return "macOS LaunchAgent";
+    if (platform === "linux")
+        return "Linux user systemd";
+    return undefined;
+}
+export function inspectAutostart() {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        return unsupportedState();
+    }
+    const context = currentContext();
+    return process.platform === "darwin" ? inspectMac(context) : inspectLinuxAutostart();
+}
+export function enableAutostart() {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        throw new Error(`Rynx autostart is not supported on ${process.platform}`);
+    }
+    const context = currentContext();
+    if (process.platform === "darwin")
+        enableMac(context);
+    else
+        enableLinuxAutostart();
+    return inspectAutostart();
+}
+export function disableAutostart() {
+    if (process.platform !== "darwin" && process.platform !== "linux") {
+        throw new Error(`Rynx autostart is not supported on ${process.platform}`);
+    }
+    const context = currentContext();
+    if (process.platform === "darwin")
+        disableMac(context);
+    else
+        disableLinuxAutostart();
+    return inspectAutostart();
+}
+/** Refresh paths in an existing registration without enabling a new one. */
+export function refreshAutostart() {
+    if (process.platform === "darwin") {
+        const context = currentContext();
+        const registrationPath = launchAgentPath(context);
+        if (!existsSync(registrationPath))
+            return false;
+        return syncMacRegistration(context);
+    }
+    if (process.platform === "linux")
+        return refreshLinuxServiceIfPresent();
+    return false;
+}
+function unsupportedState() {
+    return {
+        supported: false,
+        registered: false,
+        manager: "unsupported",
+        detail: `Rynx autostart is not supported on ${process.platform}`,
+    };
+}
+export function renderLaunchAgent(input) {
+    const outLog = path.join(input.logDir, "autostart-out.log");
+    const errLog = path.join(input.logDir, "autostart-err.log");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(LAUNCHD_LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(input.nodePath)}</string>
+    <string>${escapeXml(input.cliPath)}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(input.dataDir)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(input.pathEnv)}</string>
+    <key>RYNX_HOME</key>
+    <string>${escapeXml(input.dataDir)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(outLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(errLog)}</string>
+</dict>
+</plist>
+`;
+}
+function currentContext() {
+    const dataDir = rynxHome();
+    const homeDir = homedir();
+    return {
+        homeDir,
+        dataDir,
+        logDir: path.join(dataDir, "logs"),
+        cliPath: fileURLToPath(new URL("./cli.js", import.meta.url)),
+        nodePath: process.execPath,
+        pathEnv: process.env.PATH || defaultPath(),
+    };
+}
+function defaultPath() {
+    if (process.platform === "darwin") {
+        return "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+    }
+    return "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+}
+function launchAgentPath(context) {
+    return path.join(context.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function inspectMac(context) {
+    const registrationPath = launchAgentPath(context);
+    return {
+        supported: true,
+        registered: existsSync(registrationPath),
+        active: launchctlLoaded(),
+        manager: "launchd",
+        registrationPath,
+    };
+}
+function enableMac(context) {
+    mkdirSync(context.logDir, { recursive: true, mode: 0o700 });
+    syncMacRegistration(context);
+}
+function syncMacRegistration(context) {
+    const registrationPath = launchAgentPath(context);
+    const previous = existsSync(registrationPath)
+        ? readFileSync(registrationPath, "utf8")
+        : undefined;
+    const content = renderLaunchAgent(context);
+    if (previous === content)
+        return false;
+    const wasLoaded = launchctlLoaded();
+    replaceFileAtomically(registrationPath, content);
+    if (!wasLoaded)
+        return true;
+    if (!launchctlBootout(registrationPath)) {
+        restoreRegistrationFile(registrationPath, previous);
+        throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}; the previous file was restored`);
+    }
+    if (launchctlBootstrap(registrationPath))
+        return true;
+    restoreRegistrationFile(registrationPath, previous);
+    if (previous !== undefined && launchctlBootstrap(registrationPath)) {
+        throw new Error(`launchctl could not load the updated registration; the previous job was restored`);
+    }
+    throw new Error(`launchctl could not load the updated registration and could not restore the previous job`);
+}
+function disableMac(context) {
+    const registrationPath = launchAgentPath(context);
+    if (launchctlLoaded() && !launchctlBootout(registrationPath)) {
+        throw new Error(`launchctl could not unload ${LAUNCHD_LABEL}`);
+    }
+    rmSync(registrationPath, { force: true });
+}
+function launchctlLoaded() {
+    const uid = userInfo().uid;
+    return run("launchctl", ["print", `gui/${uid}/${LAUNCHD_LABEL}`]).status === 0;
+}
+function launchctlBootstrap(registrationPath) {
+    const uid = userInfo().uid;
+    const modern = run("launchctl", [
+        "bootstrap",
+        `gui/${uid}`,
+        registrationPath,
+    ]);
+    if (modern.status === 0)
+        return true;
+    return run("launchctl", ["load", "-w", registrationPath]).status === 0;
+}
+function launchctlBootout(registrationPath) {
+    const uid = userInfo().uid;
+    const modern = run("launchctl", [
+        "bootout",
+        `gui/${uid}/${LAUNCHD_LABEL}`,
+    ]);
+    if (modern.status === 0)
+        return true;
+    return run("launchctl", ["unload", "-w", registrationPath]).status === 0;
+}
+function run(command, args) {
+    return spawnSync(command, [...args], {
+        encoding: "utf8",
+        stdio: "pipe",
+        timeout: COMMAND_TIMEOUT_MS,
+        killSignal: "SIGTERM",
+    });
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function replaceFileAtomically(file, content) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        writeFileSync(temporary, content, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o644,
+        });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function restoreRegistrationFile(file, previous) {
+    if (previous === undefined)
+        rmSync(file, { force: true });
+    else
+        replaceFileAtomically(file, previous);
+}

package/dist/commands/autostart.d.ts

@@ -0,0 +1 @@
+export declare function runAutostartCommand(args: readonly string[]): Promise<number>;

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/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,13 +1,40 @@
-import { startStandaloneDaemon, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.js";
+import { startStandaloneDaemon, standaloneDaemonRestartRequired, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.js";
+import { refreshAutostart } from "../autostart.js";
+import { assertLinuxSystemdInvocation, linuxUserSystemdAvailable, runLinuxSystemdLifecycle, } from "../systemd-service.js";
 import { fail } from "./errors.js";
-export async function runLifecycleCommand(command, args) {
+const SYSTEMD_SERVICE_FLAG = "--systemd-service";
+export async function runLifecycleCommand(command, args, options = {}) {
+    if (args.length === 1 && args[0] === SYSTEMD_SERVICE_FLAG) {
+        assertLinuxSystemdInvocation();
+        if (command === "start")
+            return startStandaloneDaemon();
+        if (command === "stop")
+            return stopStandaloneDaemon();
+        fail(`${SYSTEMD_SERVICE_FLAG} is only valid for start and stop`);
+    }
     if (args.length > 0)
         fail(`${command}: unexpected argument ${args[0]}`);
+    if (linuxUserSystemdAvailable() &&
+        (command === "start" ||
+            command === "restart" ||
+            command === "stop" ||
+            command === "status")) {
+        return runLinuxSystemdLifecycle(command, {
+            restartRequired: standaloneDaemonRestartRequired,
+            start: startStandaloneDaemon,
+            status: statusStandaloneDaemon,
+            stop: stopStandaloneDaemon,
+        }, options);
+    }
     switch (command) {
-        case "start":
-            return startStandaloneDaemon();
-        case "restart":
-            return startStandaloneDaemon({ restart: true });
+        case "start": {
+            refreshAutostart();
+            return startStandaloneDaemon(options.quiet ? { quiet: true } : undefined);
+        }
+        case "restart": {
+            refreshAutostart();
+            return startStandaloneDaemon({ restart: true, quiet: options.quiet });
+        }
         case "stop":
             return stopStandaloneDaemon();
         case "status":

package/dist/commands/setup.js

@@ -5,8 +5,10 @@ import * as prompts from "@clack/prompts";
 import { AGENT_RUNTIME_IDS, getRuntimeProfile, loadConfig, rynxConfigFile, } from "@rynx-ai/core";
 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();
@@ -113,6 +115,9 @@ export async function runSetupCommand(args) {
     else {
         progress?.succeed("已跳过 Rynx Browser 安装");
     }
+    if (interactive && process.env.RYNX_DISTRIBUTION !== "app") {
+        failed = await offerBackgroundServiceSetup() || failed;
+    }
     if (options.resultFile) {
         writeJsonAtomically(options.resultFile, result);
     }
@@ -304,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),

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/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.d.ts

@@ -4,6 +4,7 @@ export declare function startStandaloneDaemon(options?: {
     restart?: boolean;
     quiet?: boolean;
 }): Promise<number>;
+export declare function standaloneDaemonRestartRequired(): Promise<boolean>;
 /** Reuse any healthy owner; otherwise explicitly start the standalone owner. */
 export declare function ensureStandaloneDaemon(): Promise<{
     origin: string;

package/dist/standalone.js

@@ -22,6 +22,10 @@ export async function startStandaloneDaemon(options = {}) {
         },
     });
 }
+export async function standaloneDaemonRestartRequired() {
+    const { isDaemonStartRequired } = await import("@rynx-ai/daemon/lifecycle");
+    return isDaemonStartRequired();
+}
 /** Reuse any healthy owner; otherwise explicitly start the standalone owner. */
 export async function ensureStandaloneDaemon() {
     const current = await resolveDaemonControlEndpoint();

package/dist/systemd-service.d.ts

@@ -0,0 +1,64 @@
+import type { AutostartRenderInput, AutostartState } from "./autostart.js";
+export declare const RYNX_SYSTEMD_SERVICE = "rynx.service";
+export declare const RYNX_SYSTEMD_SERVICE_ENV = "RYNX_SYSTEMD_SERVICE";
+export interface LinuxSystemdServiceState {
+    loadState: string;
+    activeState: string;
+    subState: string;
+    type: string;
+    mainPid: number;
+    killMode: string;
+    killSignal: string;
+    restartKillSignal: string;
+    finalKillSignal: string;
+    sendSigkill: string;
+    workingDirectory: string;
+    pidFile: string;
+    environment: string;
+    execStart: string;
+    execStop: string;
+}
+export interface LinuxPm2GodProcess {
+    pid: number;
+    cgroup: string;
+    startIdentity: string;
+}
+export type LinuxPm2GodOwnership = {
+    kind: "absent";
+} | {
+    kind: "owned";
+    processes: LinuxPm2GodProcess[];
+} | {
+    kind: "external";
+    processes: LinuxPm2GodProcess[];
+};
+export interface LinuxPm2InspectionDeps {
+    procEntries?: () => string[];
+    readText?: (file: string) => string;
+    statUid?: (file: string) => number;
+    currentUid?: number;
+}
+export interface LinuxLifecycleActions {
+    restartRequired: () => Promise<boolean>;
+    start: (options?: {
+        restart?: boolean;
+        quiet?: boolean;
+    }) => Promise<number>;
+    status: () => Promise<number>;
+    stop: () => Promise<number>;
+}
+export declare function renderSystemdUnit(input: AutostartRenderInput): string;
+export declare function linuxUserSystemdAvailable(): boolean;
+export declare function inspectLinuxAutostart(): AutostartState;
+export declare function enableLinuxAutostart(): void;
+export declare function disableLinuxAutostart(): void;
+/** Refresh a registered or lifecycle-created unit without changing enablement. */
+export declare function refreshLinuxServiceIfPresent(): boolean;
+export declare function assertLinuxSystemdInvocation(): void;
+export declare function runLinuxSystemdLifecycle(command: "start" | "restart" | "stop" | "status", actions: LinuxLifecycleActions, options?: {
+    quiet?: boolean;
+}): Promise<number>;
+export declare function parseLinuxSystemdShow(output: string): LinuxSystemdServiceState;
+export declare function inspectLinuxPm2GodOwnership(home: string, deps?: LinuxPm2InspectionDeps): LinuxPm2GodOwnership;
+export declare function scanLinuxPm2GodPids(home: string, deps?: LinuxPm2InspectionDeps): number[];
+export declare function linuxSystemdCgroupForPid(pid: number, readText?: (file: string) => string): string;

package/dist/systemd-service.js

@@ -0,0 +1,608 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir, userInfo } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { rynxHome } from "@rynx-ai/core";
+export const RYNX_SYSTEMD_SERVICE = "rynx.service";
+export const RYNX_SYSTEMD_SERVICE_ENV = "RYNX_SYSTEMD_SERVICE";
+const COMMAND_TIMEOUT_MS = 5_000;
+const LIFECYCLE_TIMEOUT_MS = 60_000;
+export function renderSystemdUnit(input) {
+    const pidFile = path.join(input.dataDir, "pm2", "pm2.pid");
+    return `[Unit]
+Description=Rynx local control plane
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=forking
+PIDFile=${systemdPath(pidFile)}
+KillMode=process
+KillSignal=SIGCONT
+RestartKillSignal=SIGCONT
+FinalKillSignal=SIGCONT
+SendSIGKILL=no
+TimeoutStartSec=60
+TimeoutStopSec=45
+WorkingDirectory=${systemdPath(input.dataDir)}
+Environment=${systemdQuote(`PATH=${input.pathEnv}`)}
+Environment=${systemdQuote(`RYNX_HOME=${input.dataDir}`)}
+Environment=${systemdQuote(`${RYNX_SYSTEMD_SERVICE_ENV}=${RYNX_SYSTEMD_SERVICE}`)}
+ExecStart=${systemdQuote(input.nodePath)} ${systemdQuote(input.cliPath)} start --systemd-service
+ExecStop=${systemdQuote(input.nodePath)} ${systemdQuote(input.cliPath)} stop --systemd-service
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function linuxUserSystemdAvailable() {
+    return process.platform === "linux" &&
+        run("systemctl", ["--user", "show-environment"]).status === 0;
+}
+export function inspectLinuxAutostart() {
+    const context = currentContext();
+    if (!linuxUserSystemdAvailable()) {
+        return {
+            supported: false,
+            registered: existsSync(context.unitPath),
+            manager: "systemd-user",
+            registrationPath: context.unitPath,
+            detail: "user systemd is unavailable in this login session",
+        };
+    }
+    const lingerEnabled = inspectLinuxLinger();
+    const active = run("systemctl", ["--user", "is-active", RYNX_SYSTEMD_SERVICE]).status === 0;
+    let detail;
+    if (active) {
+        try {
+            assertRunningServiceOwnership(context);
+        }
+        catch (error) {
+            detail = errorMessage(error);
+        }
+    }
+    return {
+        supported: true,
+        registered: run("systemctl", ["--user", "is-enabled", RYNX_SYSTEMD_SERVICE]).status === 0,
+        active,
+        ...(lingerEnabled === undefined
+            ? {}
+            : {
+                lingerEnabled,
+                ...(!lingerEnabled
+                    ? { lingerEnableCommand: `sudo loginctl enable-linger ${userInfo().username}` }
+                    : {}),
+            }),
+        manager: "systemd-user",
+        registrationPath: context.unitPath,
+        ...(detail ? { detail } : {}),
+    };
+}
+export function enableLinuxAutostart() {
+    assertUserSystemdAvailable();
+    const context = currentContext();
+    syncLinuxService(context);
+    requireSuccess(run("systemctl", ["--user", "enable", RYNX_SYSTEMD_SERVICE]), "systemctl --user enable");
+}
+export function disableLinuxAutostart() {
+    assertUserSystemdAvailable();
+    const context = currentContext();
+    const disabled = run("systemctl", ["--user", "disable", RYNX_SYSTEMD_SERVICE]);
+    if (disabled.status !== 0 && existsSync(context.unitPath)) {
+        requireSuccess(disabled, "systemctl --user disable");
+    }
+    rmSync(context.unitPath, { force: true });
+    requireSuccess(run("systemctl", ["--user", "daemon-reload"]), "systemctl --user daemon-reload");
+}
+/** Refresh a registered or lifecycle-created unit without changing enablement. */
+export function refreshLinuxServiceIfPresent() {
+    if (process.platform !== "linux" || !linuxUserSystemdAvailable())
+        return false;
+    const context = currentContext();
+    if (!existsSync(context.unitPath))
+        return false;
+    return syncLinuxService(context);
+}
+export function assertLinuxSystemdInvocation() {
+    if (process.platform !== "linux") {
+        throw new Error("--systemd-service is only valid on Linux");
+    }
+    if (process.env[RYNX_SYSTEMD_SERVICE_ENV] !== RYNX_SYSTEMD_SERVICE) {
+        throw new Error("--systemd-service requires the Rynx systemd environment");
+    }
+    const cgroup = linuxSystemdCgroupForPid(process.pid);
+    if (!cgroupHasService(cgroup)) {
+        throw new Error(`--systemd-service requires the ${RYNX_SYSTEMD_SERVICE} cgroup`);
+    }
+}
+export async function runLinuxSystemdLifecycle(command, actions, options = {}) {
+    assertUserSystemdAvailable();
+    const context = currentContext();
+    if (command === "status") {
+        return statusLinuxLifecycle(context, actions);
+    }
+    if (command === "stop") {
+        return stopLinuxLifecycle(context, actions);
+    }
+    const unitChanged = syncLinuxService(context);
+    const before = inspectLinuxPm2GodOwnership(context.pm2Home);
+    assertSingleGod(before);
+    const serviceBefore = inspectLinuxSystemdService();
+    if (before.kind === "owned" && serviceOwnsGod(serviceBefore, before.processes[0])) {
+        if (command === "start") {
+            if (unitChanged || await actions.restartRequired()) {
+                systemctlUser(["restart", RYNX_SYSTEMD_SERVICE], LIFECYCLE_TIMEOUT_MS);
+                assertRunningServiceOwnership(context);
+                return options.quiet ? 0 : actions.status();
+            }
+            const result = await actions.start(options.quiet ? { quiet: true } : undefined);
+            if (result !== 0)
+                return result;
+            assertRunningServiceOwnership(context);
+            return 0;
+        }
+        const previous = before.processes[0];
+        systemctlUser(["restart", RYNX_SYSTEMD_SERVICE], LIFECYCLE_TIMEOUT_MS);
+        const current = assertRunningServiceOwnership(context);
+        if (current.pid === previous.pid &&
+            current.startIdentity === previous.startIdentity) {
+            throw new Error("systemd restart did not replace the PM2 supervisor generation");
+        }
+        return options.quiet ? 0 : actions.status();
+    }
+    if (before.kind !== "absent") {
+        assertMigratableOwnership(before);
+        const stopped = await actions.stop();
+        if (stopped !== 0)
+            return stopped;
+        const afterStop = inspectLinuxPm2GodOwnership(context.pm2Home);
+        if (afterStop.kind !== "absent") {
+            throw new Error("the previous PM2 supervisor is still running after shutdown");
+        }
+    }
+    if (serviceBefore.activeState !== "inactive") {
+        systemctlUser(["stop", RYNX_SYSTEMD_SERVICE], LIFECYCLE_TIMEOUT_MS);
+    }
+    run("systemctl", ["--user", "reset-failed", RYNX_SYSTEMD_SERVICE]);
+    systemctlUser(["start", RYNX_SYSTEMD_SERVICE], LIFECYCLE_TIMEOUT_MS);
+    assertRunningServiceOwnership(context);
+    return options.quiet ? 0 : actions.status();
+}
+export function parseLinuxSystemdShow(output) {
+    const values = new Map();
+    for (const line of output.split(/\r?\n/)) {
+        const separator = line.indexOf("=");
+        if (separator <= 0)
+            continue;
+        values.set(line.slice(0, separator), line.slice(separator + 1));
+    }
+    const parsedMainPid = Number.parseInt(values.get("MainPID") ?? "0", 10);
+    return {
+        loadState: values.get("LoadState") ?? "",
+        activeState: values.get("ActiveState") ?? "",
+        subState: values.get("SubState") ?? "",
+        type: values.get("Type") ?? "",
+        mainPid: Number.isSafeInteger(parsedMainPid) && parsedMainPid > 1
+            ? parsedMainPid
+            : 0,
+        killMode: values.get("KillMode") ?? "",
+        killSignal: values.get("KillSignal") ?? "",
+        restartKillSignal: values.get("RestartKillSignal") ?? "",
+        finalKillSignal: values.get("FinalKillSignal") ?? "",
+        sendSigkill: values.get("SendSIGKILL") ?? "",
+        workingDirectory: values.get("WorkingDirectory") ?? "",
+        pidFile: values.get("PIDFile") ?? "",
+        environment: values.get("Environment") ?? "",
+        execStart: values.get("ExecStart") ?? "",
+        execStop: values.get("ExecStop") ?? "",
+    };
+}
+export function inspectLinuxPm2GodOwnership(home, deps = {}) {
+    const readText = deps.readText ?? ((file) => readFileSync(file, "utf8"));
+    const entries = scanLinuxPm2GodPids(home, deps);
+    const processes = [];
+    for (const pid of entries) {
+        try {
+            const startBefore = linuxProcStartIdentity(readText(`/proc/${pid}/stat`));
+            const cmdline = readText(`/proc/${pid}/cmdline`).replaceAll("\u0000", " ").trim();
+            const cgroup = linuxSystemdCgroupForPid(pid, readText);
+            const startAfter = linuxProcStartIdentity(readText(`/proc/${pid}/stat`));
+            if (!startBefore || startBefore !== startAfter) {
+                throw new Error(`PM2 supervisor pid ${pid} changed during inspection`);
+            }
+            if (!isDedicatedPm2God(cmdline, home))
+                continue;
+            processes.push({ pid, cgroup, startIdentity: startBefore });
+        }
+        catch (error) {
+            if (!processDisappeared(error))
+                throw procReadError(`/proc/${pid}`, error);
+        }
+    }
+    if (processes.length === 0)
+        return { kind: "absent" };
+    const external = processes.filter((entry) => !cgroupHasService(entry.cgroup));
+    return external.length === 0
+        ? { kind: "owned", processes }
+        : { kind: "external", processes };
+}
+export function scanLinuxPm2GodPids(home, deps = {}) {
+    const procEntries = deps.procEntries ?? (() => readdirSync("/proc"));
+    const readText = deps.readText ?? ((file) => readFileSync(file, "utf8"));
+    const statUid = deps.statUid ?? ((file) => statSync(file).uid);
+    const currentUid = deps.currentUid ?? process.getuid?.();
+    let entries;
+    try {
+        entries = procEntries();
+    }
+    catch (error) {
+        throw new Error(`cannot inspect /proc: ${errorMessage(error)}`);
+    }
+    const pids = [];
+    for (const entry of entries) {
+        if (!/^\d+$/.test(entry))
+            continue;
+        const pid = Number(entry);
+        if (!Number.isSafeInteger(pid) || pid <= 1)
+            continue;
+        if (currentUid !== undefined) {
+            try {
+                if (statUid(`/proc/${pid}`) !== currentUid)
+                    continue;
+            }
+            catch (error) {
+                if (processDisappeared(error))
+                    continue;
+                throw procReadError(`/proc/${pid}`, error);
+            }
+        }
+        try {
+            const cmdline = readText(`/proc/${pid}/cmdline`).replaceAll("\u0000", " ").trim();
+            if (isDedicatedPm2God(cmdline, home))
+                pids.push(pid);
+        }
+        catch (error) {
+            if (!processDisappeared(error)) {
+                throw procReadError(`/proc/${pid}/cmdline`, error);
+            }
+        }
+    }
+    return [...new Set(pids)].sort((left, right) => left - right);
+}
+export function linuxSystemdCgroupForPid(pid, readText = (file) => readFileSync(file, "utf8")) {
+    return normalizedCgroupPath(readText(`/proc/${pid}/cgroup`)) ?? "(unreadable)";
+}
+function currentContext() {
+    const dataDir = rynxHome();
+    const homeDir = homedir();
+    const pm2Home = path.join(dataDir, "pm2");
+    return {
+        homeDir,
+        dataDir,
+        logDir: path.join(dataDir, "logs"),
+        cliPath: fileURLToPath(new URL("./cli.js", import.meta.url)),
+        nodePath: process.execPath,
+        pathEnv: process.env.PATH || defaultLinuxPath(),
+        pm2Home,
+        pidFile: path.join(pm2Home, "pm2.pid"),
+        unitPath: path.join(homeDir, ".config", "systemd", "user", RYNX_SYSTEMD_SERVICE),
+    };
+}
+function syncLinuxService(context) {
+    mkdirSync(context.dataDir, { recursive: true, mode: 0o700 });
+    mkdirSync(context.logDir, { recursive: true, mode: 0o700 });
+    const content = renderSystemdUnit(context);
+    const previous = existsSync(context.unitPath)
+        ? readFileSync(context.unitPath, "utf8")
+        : undefined;
+    const changed = previous !== content;
+    if (changed)
+        replaceFileAtomically(context.unitPath, content);
+    try {
+        requireSuccess(run("systemctl", ["--user", "daemon-reload"]), "systemctl --user daemon-reload");
+        assertStaticServiceDefinition(context, inspectLinuxSystemdService());
+        return changed;
+    }
+    catch (error) {
+        if (changed) {
+            if (previous === undefined)
+                rmSync(context.unitPath, { force: true });
+            else
+                replaceFileAtomically(context.unitPath, previous);
+            const rollback = run("systemctl", ["--user", "daemon-reload"]);
+            if (rollback.status !== 0) {
+                throw new AggregateError([error, new Error(`systemd rollback failed: ${commandDetail(rollback)}`)], "could not update or restore the Rynx systemd service");
+            }
+        }
+        throw error;
+    }
+}
+function inspectLinuxSystemdService() {
+    const output = systemctlUser([
+        "show",
+        RYNX_SYSTEMD_SERVICE,
+        "--property=LoadState",
+        "--property=ActiveState",
+        "--property=SubState",
+        "--property=Type",
+        "--property=MainPID",
+        "--property=KillMode",
+        "--property=KillSignal",
+        "--property=RestartKillSignal",
+        "--property=FinalKillSignal",
+        "--property=SendSIGKILL",
+        "--property=WorkingDirectory",
+        "--property=PIDFile",
+        "--property=Environment",
+        "--property=ExecStart",
+        "--property=ExecStop",
+    ]);
+    return parseLinuxSystemdShow(output);
+}
+function assertStaticServiceDefinition(context, state) {
+    const errors = [];
+    if (state.loadState !== "loaded")
+        errors.push(`LoadState=${state.loadState || "(empty)"}`);
+    if (state.type !== "forking")
+        errors.push(`Type=${state.type || "(empty)"}`);
+    if (state.pidFile !== context.pidFile)
+        errors.push(`PIDFile=${state.pidFile || "(empty)"}`);
+    if (state.workingDirectory !== context.dataDir) {
+        errors.push(`WorkingDirectory=${state.workingDirectory || "(empty)"}`);
+    }
+    if (state.killMode !== "process")
+        errors.push(`KillMode=${state.killMode || "(empty)"}`);
+    if (!signalMatches(state.killSignal, "18", "SIGCONT")) {
+        errors.push(`KillSignal=${state.killSignal || "(empty)"}`);
+    }
+    if (!signalMatches(state.restartKillSignal, "18", "SIGCONT")) {
+        errors.push(`RestartKillSignal=${state.restartKillSignal || "(empty)"}`);
+    }
+    if (!signalMatches(state.finalKillSignal, "18", "SIGCONT")) {
+        errors.push(`FinalKillSignal=${state.finalKillSignal || "(empty)"}`);
+    }
+    if (state.sendSigkill !== "no")
+        errors.push(`SendSIGKILL=${state.sendSigkill || "(empty)"}`);
+    for (const expected of [
+        `RYNX_HOME=${context.dataDir}`,
+        `${RYNX_SYSTEMD_SERVICE_ENV}=${RYNX_SYSTEMD_SERVICE}`,
+        `PATH=${context.pathEnv}`,
+    ]) {
+        if (!state.environment.includes(expected))
+            errors.push(`Environment missing ${expected}`);
+    }
+    for (const [name, value, action] of [
+        ["ExecStart", state.execStart, "start"],
+        ["ExecStop", state.execStop, "stop"],
+    ]) {
+        if (!value.includes(context.nodePath) ||
+            !value.includes(context.cliPath) ||
+            !value.includes(action) ||
+            !value.includes("--systemd-service")) {
+            errors.push(`${name}=${value || "(empty)"}`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`${RYNX_SYSTEMD_SERVICE} effective configuration is invalid: ${errors.join("; ")}`);
+    }
+}
+function assertRunningServiceOwnership(context) {
+    const ownership = inspectLinuxPm2GodOwnership(context.pm2Home);
+    assertSingleGod(ownership);
+    if (ownership.kind !== "owned") {
+        throw new Error(ownership.kind === "absent"
+            ? "systemd started without a PM2 supervisor"
+            : `PM2 supervisor is outside ${RYNX_SYSTEMD_SERVICE}: ${describeOwnership(ownership)}`);
+    }
+    const process = ownership.processes[0];
+    const state = inspectLinuxSystemdService();
+    assertStaticServiceDefinition(context, state);
+    if (state.activeState !== "active" ||
+        state.subState !== "running" ||
+        state.mainPid !== process.pid) {
+        throw new Error(`${RYNX_SYSTEMD_SERVICE} does not own the PM2 supervisor: ` +
+            `ActiveState=${state.activeState}, SubState=${state.subState}, ` +
+            `MainPID=${state.mainPid}, PM2=${process.pid}`);
+    }
+    return process;
+}
+async function statusLinuxLifecycle(context, actions) {
+    const ownership = inspectLinuxPm2GodOwnership(context.pm2Home);
+    if (ownership.kind === "absent") {
+        console.log("rynx: stopped (PM2 supervisor is absent)");
+        return 1;
+    }
+    assertSingleGod(ownership);
+    const directStatus = await actions.status();
+    if (ownership.kind !== "owned") {
+        console.error(`rynx: PM2 supervisor is not owned by ${RYNX_SYSTEMD_SERVICE}: ${describeOwnership(ownership)}`);
+        return 2;
+    }
+    try {
+        assertRunningServiceOwnership(context);
+    }
+    catch (error) {
+        console.error(`rynx: ${errorMessage(error)}`);
+        return 1;
+    }
+    return directStatus;
+}
+async function stopLinuxLifecycle(context, actions) {
+    const ownership = inspectLinuxPm2GodOwnership(context.pm2Home);
+    assertSingleGod(ownership);
+    if (ownership.kind === "owned") {
+        const state = inspectLinuxSystemdService();
+        if (serviceOwnsGod(state, ownership.processes[0])) {
+            systemctlUser(["stop", RYNX_SYSTEMD_SERVICE], LIFECYCLE_TIMEOUT_MS);
+            if (inspectLinuxPm2GodOwnership(context.pm2Home).kind !== "absent") {
+                throw new Error("PM2 supervisor survived systemd stop");
+            }
+            console.log("rynx stopped.");
+            return 0;
+        }
+    }
+    if (ownership.kind === "external")
+        assertMigratableOwnership(ownership);
+    return actions.stop();
+}
+function assertSingleGod(ownership) {
+    if (ownership.kind !== "absent" && ownership.processes.length !== 1) {
+        throw new Error(`multiple PM2 supervisors use this RYNX_HOME: ${describeOwnership(ownership)}`);
+    }
+}
+function assertMigratableOwnership(ownership) {
+    if (ownership.kind !== "external")
+        return;
+    const externalService = ownership.processes.find((entry) => serviceOwner(entry.cgroup)?.endsWith(".service"));
+    if (externalService) {
+        throw new Error(`refusing to replace a PM2 supervisor owned by ${serviceOwner(externalService.cgroup)}`);
+    }
+}
+function serviceOwnsGod(state, process) {
+    return state.activeState === "active" &&
+        state.subState === "running" &&
+        state.mainPid === process.pid &&
+        cgroupHasService(process.cgroup);
+}
+function describeOwnership(ownership) {
+    if (ownership.kind === "absent")
+        return "absent";
+    return ownership.processes
+        .map((entry) => `${entry.pid}@${entry.cgroup}`)
+        .join(", ");
+}
+function serviceOwner(cgroup) {
+    return cgroup.split("/").reverse().find((part) => part.endsWith(".service") || part.endsWith(".scope"));
+}
+function inspectLinuxLinger() {
+    const result = run("loginctl", [
+        "show-user",
+        userInfo().username,
+        "--property=Linger",
+    ]);
+    if (result.status !== 0)
+        return undefined;
+    const value = result.stdout?.trim();
+    if (value === "Linger=yes")
+        return true;
+    if (value === "Linger=no")
+        return false;
+    return undefined;
+}
+function normalizedCgroupPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith("/"))
+        return trimmed;
+    let unified;
+    for (const line of trimmed.split(/\r?\n/)) {
+        const first = line.indexOf(":");
+        const second = first < 0 ? -1 : line.indexOf(":", first + 1);
+        if (second < 0)
+            continue;
+        const hierarchy = line.slice(0, first);
+        const controllers = line.slice(first + 1, second);
+        const cgroup = line.slice(second + 1).trim();
+        if (!cgroup)
+            continue;
+        if (controllers.split(",").includes("name=systemd"))
+            return cgroup;
+        if (hierarchy === "0" && controllers === "")
+            unified = cgroup;
+    }
+    return unified;
+}
+function cgroupHasService(cgroup) {
+    return cgroup?.split("/").includes(RYNX_SYSTEMD_SERVICE) === true;
+}
+function linuxProcStartIdentity(raw) {
+    const closeParen = raw.lastIndexOf(")");
+    if (closeParen < 0)
+        return undefined;
+    return raw.slice(closeParen + 2).trim().split(/\s+/)[19];
+}
+function isDedicatedPm2God(cmdline, home) {
+    return cmdline.includes("PM2 v") && cmdline.includes(`God Daemon (${home})`);
+}
+function processDisappeared(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ESRCH" || code === "ENOTDIR";
+}
+function procReadError(file, error) {
+    return new Error(`cannot inspect ${file}: ${errorMessage(error)}`);
+}
+function assertUserSystemdAvailable() {
+    if (!linuxUserSystemdAvailable()) {
+        throw new Error("user systemd is unavailable in this login session");
+    }
+}
+function systemctlUser(args, timeout = COMMAND_TIMEOUT_MS) {
+    const result = run("systemctl", ["--user", ...args], timeout);
+    requireSuccess(result, `systemctl --user ${args.join(" ")}`);
+    return result.stdout ?? "";
+}
+function replaceFileAtomically(file, content) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        writeFileSync(temporary, content, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o644,
+        });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+function run(command, args, timeout = COMMAND_TIMEOUT_MS) {
+    return spawnSync(command, [...args], {
+        encoding: "utf8",
+        stdio: "pipe",
+        timeout,
+        killSignal: "SIGTERM",
+    });
+}
+function requireSuccess(result, description) {
+    if (result.status === 0)
+        return;
+    throw new Error(`${description} failed: ${commandDetail(result)}`);
+}
+function commandDetail(result) {
+    return result.error?.message
+        || result.stderr?.trim()
+        || result.stdout?.trim()
+        || `exit ${result.status ?? "unknown"}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function signalMatches(value, number, name) {
+    return value === number || value === name;
+}
+function defaultLinuxPath() {
+    return "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+}
+function systemdQuote(value) {
+    return `"${value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("\"", "\\\"")
+        .replaceAll("%", "%%")
+        .replaceAll("\t", "\\t")
+        .replaceAll("\n", "\\n")
+        .replaceAll("\r", "\\r")}"`;
+}
+function systemdPath(value) {
+    return value
+        .replaceAll("%", "%%")
+        .replaceAll("\\", "\\x5c")
+        .replaceAll(" ", "\\x20")
+        .replaceAll("\t", "\\t")
+        .replaceAll("\n", "\\n")
+        .replaceAll("\r", "\\r")
+        .replaceAll('"', "\\x22")
+        .replaceAll("'", "\\x27");
+}

package/dist/usage.d.ts

@@ -1 +1 @@
-export declare const USAGE = "Usage: rynx <command>\n\nGeneral:\n  version [--json] | --version\n                     print the installed Rynx version\n\nSetup:\n  setup [--non-interactive] [--default-runtime <codex|traex|claude>]\n        [--host <host>] [--port <port>] [--log-level <level>]\n        [--install-browser|--skip-browser] [--json|--result-file <path>]\n                     initialize configuration and local dependencies\n  doctor             read-only health check\n\nLifecycle:\n  start | restart | stop | status | logs\n  update [version] [--check] [--json]\n\nPlugins:\n  market list\n  market add <git-or-local-source> [--alias <id>]\n  market refresh [market-id]\n  market remove <market-id>\n  plugin list\n  plugin install <source|plugin@market> [--force] [--expect-digest <sha256-...>]\n  plugin update <plugin@market> [--expect-digest <sha256-...>]\n  plugin enable|disable|uninstall <plugin@market>\n  plugin <plugin@market> <command>  invoke a plugin-owned command\n\nAgents:\n  agent list\n  agent show <id>\n  agent add <id>\n  agent rm <id>\n\nBuiltin Skills:\n  skills list [--json]\n  skills get <browser|emulator> [--full] [--json]\n\nMaintenance:\n  cleanup sessions [--dry-run]\n\nEmulator:\n  emulator <args...>\n\nRemote Runtime:\n  runtime share --address <host|ws-url> [--label <label>] [--json]\n  runtime add --pairing-code <rynx://...> [--name <name>]\n  runtime list [--json]\n  runtime test <local|daemon-id> [--json]\n  runtime forget <daemon-id>\n  runtime clients list [--json]\n  runtime clients revoke <grant-id>\n\nSessions:\n  session fork <session-id> [--title <title>] [--json]\n\nBrowser:\n  browser install|update|version|clean [...]\n  browser open [url] [--session <id>] [--runtime <local|daemon-id>] [--json]\n  browser status|pages|close [--session <id>] [--runtime <local|daemon-id>] [--json]\n  browser endpoint [--ensure] [--session <local-id>] [--json]\n  browser snapshot [--session <local-id>] [--json]\n  browser navigate <url> [--session <local-id>] [--json]\n  browser click (--ref <ref>|--selector <css>|--x <n> --y <n>) [--session <local-id>] [--json]\n  browser type (--ref <ref>|--selector <css>) --text <text> [--session <local-id>] [--json]\n  browser screenshot --output <absolute-path> [--session <local-id>] [--json]\n";
+export declare const USAGE = "Usage: rynx <command>\n\nGeneral:\n  version [--json] | --version\n                     print the installed Rynx version\n\nSetup:\n  setup [--non-interactive] [--default-runtime <codex|traex|claude>]\n        [--host <host>] [--port <port>] [--log-level <level>]\n        [--install-browser|--skip-browser] [--json|--result-file <path>]\n                     initialize configuration and local dependencies\n  doctor             read-only health check\n\nLifecycle:\n  start | restart | stop | status | logs\n  autostart enable|disable|status\n  update [version] [--check] [--json]\n\nPlugins:\n  market list\n  market add <git-or-local-source> [--alias <id>]\n  market refresh [market-id]\n  market remove <market-id>\n  plugin list\n  plugin install <source|plugin@market> [--force] [--expect-digest <sha256-...>]\n  plugin update <plugin@market> [--expect-digest <sha256-...>]\n  plugin enable|disable|uninstall <plugin@market>\n  plugin <plugin@market> <command>  invoke a plugin-owned command\n\nAgents:\n  agent list\n  agent show <id>\n  agent add <id>\n  agent rm <id>\n\nBuiltin Skills:\n  skills list [--json]\n  skills get <browser|emulator> [--full] [--json]\n\nMaintenance:\n  cleanup sessions [--dry-run]\n\nEmulator:\n  emulator <args...>\n\nRemote Runtime:\n  runtime share --address <host|ws-url> [--label <label>] [--json]\n  runtime add --pairing-code <rynx://...> [--name <name>]\n  runtime list [--json]\n  runtime test <local|daemon-id> [--json]\n  runtime forget <daemon-id>\n  runtime clients list [--json]\n  runtime clients revoke <grant-id>\n\nSessions:\n  session fork <session-id> [--title <title>] [--json]\n\nBrowser:\n  browser install|update|version|clean [...]\n  browser open [url] [--session <id>] [--runtime <local|daemon-id>] [--json]\n  browser status|pages|close [--session <id>] [--runtime <local|daemon-id>] [--json]\n  browser endpoint [--ensure] [--session <local-id>] [--json]\n  browser snapshot [--session <local-id>] [--json]\n  browser navigate <url> [--session <local-id>] [--json]\n  browser click (--ref <ref>|--selector <css>|--x <n> --y <n>) [--session <local-id>] [--json]\n  browser type (--ref <ref>|--selector <css>) --text <text> [--session <local-id>] [--json]\n  browser screenshot --output <absolute-path> [--session <local-id>] [--json]\n";

package/dist/usage.js

@@ -13,6 +13,7 @@ Setup:
 
 Lifecycle:
   start | restart | stop | status | logs
+  autostart enable|disable|status
   update [version] [--check] [--json]
 
 Plugins:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/cli",
-  "version": "0.1.11-beta.32",
+  "version": "0.1.11-beta.34",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -51,12 +51,12 @@
   "dependencies": {
     "@clack/prompts": "^1.6.0",
     "ws": "^8.21.0",
-    "@rynx-ai/browser-cdp": "0.1.11-beta.32",
-    "@rynx-ai/core": "0.1.11-beta.32",
-    "@rynx-ai/daemon": "0.1.11-beta.32",
-    "@rynx-ai/emulator": "0.1.11-beta.32",
-    "@rynx-ai/protocol": "0.1.11-beta.32",
-    "@rynx-ai/tmux": "0.1.11-beta.32"
+    "@rynx-ai/core": "0.1.11-beta.34",
+    "@rynx-ai/browser-cdp": "0.1.11-beta.34",
+    "@rynx-ai/emulator": "0.1.11-beta.34",
+    "@rynx-ai/daemon": "0.1.11-beta.34",
+    "@rynx-ai/protocol": "0.1.11-beta.34",
+    "@rynx-ai/tmux": "0.1.11-beta.34"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"