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

package/dist/app-runtime.d.ts

@@ -0,0 +1,10 @@
+export interface CliDependencyVersions {
+    cliVersion: string;
+    daemonVersion: string;
+}
+/** Read the versions in the dependency closure owned by this CLI installation. */
+export declare function resolveCliDependencyVersions(): CliDependencyVersions;
+/** Resolve the CLI-owned process entry used exclusively by Rynx App. */
+export declare function resolveCliAppRuntimeEntry(moduleUrl?: string): string;
+/** Run the App-owned daemon in this dedicated CLI App Runtime process. */
+export declare function runAppRuntimeProcess(): Promise<void>;

package/dist/app-runtime.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { installedDaemonVersion } from "@rynx-ai/daemon/entry-path";
+import { installedVersion } from "./version.js";
+/** Read the versions in the dependency closure owned by this CLI installation. */
+export function resolveCliDependencyVersions() {
+    return {
+        cliVersion: installedVersion(),
+        daemonVersion: installedDaemonVersion(),
+    };
+}
+/** Resolve the CLI-owned process entry used exclusively by Rynx App. */
+export function resolveCliAppRuntimeEntry(moduleUrl = import.meta.url) {
+    return fileURLToPath(moduleUrl);
+}
+/** Run the App-owned daemon in this dedicated CLI App Runtime process. */
+export async function runAppRuntimeProcess() {
+    if (process.env.RYNX_DISTRIBUTION !== "app") {
+        throw new Error("CLI App Runtime requires RYNX_DISTRIBUTION=app");
+    }
+    if (process.env.RYNX_DAEMON_LIFECYCLE !== "follow-app" &&
+        process.env.RYNX_DAEMON_LIFECYCLE !== "resident") {
+        throw new Error("CLI App Runtime requires an App daemon lifecycle");
+    }
+    const { runDaemonProcess } = await import("@rynx-ai/daemon/internal/process");
+    await runDaemonProcess();
+}
+if (process.argv[1] &&
+    path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
+    runAppRuntimeProcess().catch((error) => {
+        console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-export { callManagedRuntimeBrowser, callResidentRuntime, cancelResidentPluginInstallation, commitResidentPluginInstallation, cleanResidentBrowserArtifacts, cleanupResidentSessions, createResidentRemoteRuntimePairingOffer, ensureResidentDaemon, forgetResidentRuntimeTarget, getResidentChromeInspectionStatus, getResidentDaemonIdentity, getResidentDaemonRuntimeStatus, getResidentBrowserArtifactVersion, getResidentRuntimeLocalBrowserEndpoint, invokeResidentPluginCommand, installResidentBrowserArtifact, listResidentPlugins, listResidentRemoteRuntimeClients, listResidentRuntimeTargets, pairResidentRuntimeTarget, prepareResidentPluginInstallation, readManagedRuntimeBrowserCredential, readOptionalManagedRuntimeBrowserCredential, revokeResidentRemoteRuntimeClient, setResidentPluginEnabled, shutdownResidentDaemonIfIdle, configureResidentChromeInspection, testResidentRuntimeTarget, uninstallResidentPlugin, updateResidentBrowserArtifact, connectResidentDesktopBrowserHost, ResidentRuntimeCallError, type InvokeResidentPluginCommandOptions, type ResidentDaemon, type ResidentDaemonIdentity, type ResidentDesktopBrowserHostCommandRequest, type ResidentDesktopBrowserHostConnectOptions, type ResidentDesktopBrowserHostConnection, type ResidentDesktopBrowserHostFailure, type ResidentPluginCommandResult, type ResidentPluginManagementItem, type ResidentPluginManagementState, type ResidentRemoteRuntimeClientGrant, type ResidentRuntimeCallErrorCode, type ResidentRuntimeCallOutcome, type ResidentRuntimeTargetTestResult, type ResidentRuntimeTargetView, } from "./control-client.js";
+export { callManagedRuntimeBrowser, callResidentRuntime, cancelResidentPluginInstallation, commitResidentPluginInstallation, cleanupResidentSessions, createResidentRemoteRuntimePairingOffer, forgetResidentRuntimeTarget, getResidentChromeInspectionStatus, getResidentDaemonIdentity, getResidentDaemonRuntimeStatus, getResidentRuntimeLocalBrowserEndpoint, invokeResidentPluginCommand, listResidentPlugins, listResidentRemoteRuntimeClients, listResidentRuntimeTargets, pairResidentRuntimeTarget, prepareResidentPluginInstallation, readManagedRuntimeBrowserCredential, readOptionalManagedRuntimeBrowserCredential, revokeResidentRemoteRuntimeClient, setResidentPluginEnabled, shutdownResidentDaemonIfIdle, configureResidentChromeInspection, testResidentRuntimeTarget, uninstallResidentPlugin, connectResidentDesktopBrowserHost, ResidentRuntimeCallError, type InvokeResidentPluginCommandOptions, type ResidentDaemonIdentity, type ResidentDesktopBrowserHostCommandRequest, type ResidentDesktopBrowserHostConnectOptions, type ResidentDesktopBrowserHostConnection, type ResidentDesktopBrowserHostFailure, type ResidentPluginCommandResult, type ResidentPluginManagementItem, type ResidentPluginManagementState, type ResidentRemoteRuntimeClientGrant, type ResidentRuntimeCallErrorCode, type ResidentRuntimeCallOutcome, type ResidentRuntimeTargetTestResult, type ResidentRuntimeTargetView, } from "./control-client.js";
 export type { DaemonChromeInspectionConfigureInput, DaemonChromeInspectionStatus, } from "@rynx-ai/protocol/control";
 export type { PluginInstallCommitInput, PluginInstallCommitResult, PluginInstallPreparation, PluginInstallPrepareInput, } from "@rynx-ai/protocol/plugin-management";
 export { ensureDaemonControlEndpoint, resolveDaemonControlEndpoint, type DaemonControlEndpoint, type ResolveDaemonControlEndpointOptions, } from "./control-endpoint.js";

package/dist/client.js

@@ -1,2 +1,2 @@
-export { callManagedRuntimeBrowser, callResidentRuntime, cancelResidentPluginInstallation, commitResidentPluginInstallation, cleanResidentBrowserArtifacts, cleanupResidentSessions, createResidentRemoteRuntimePairingOffer, ensureResidentDaemon, forgetResidentRuntimeTarget, getResidentChromeInspectionStatus, getResidentDaemonIdentity, getResidentDaemonRuntimeStatus, getResidentBrowserArtifactVersion, getResidentRuntimeLocalBrowserEndpoint, invokeResidentPluginCommand, installResidentBrowserArtifact, listResidentPlugins, listResidentRemoteRuntimeClients, listResidentRuntimeTargets, pairResidentRuntimeTarget, prepareResidentPluginInstallation, readManagedRuntimeBrowserCredential, readOptionalManagedRuntimeBrowserCredential, revokeResidentRemoteRuntimeClient, setResidentPluginEnabled, shutdownResidentDaemonIfIdle, configureResidentChromeInspection, testResidentRuntimeTarget, uninstallResidentPlugin, updateResidentBrowserArtifact, connectResidentDesktopBrowserHost, ResidentRuntimeCallError, } from "./control-client.js";
+export { callManagedRuntimeBrowser, callResidentRuntime, cancelResidentPluginInstallation, commitResidentPluginInstallation, cleanupResidentSessions, createResidentRemoteRuntimePairingOffer, forgetResidentRuntimeTarget, getResidentChromeInspectionStatus, getResidentDaemonIdentity, getResidentDaemonRuntimeStatus, getResidentRuntimeLocalBrowserEndpoint, invokeResidentPluginCommand, listResidentPlugins, listResidentRemoteRuntimeClients, listResidentRuntimeTargets, pairResidentRuntimeTarget, prepareResidentPluginInstallation, readManagedRuntimeBrowserCredential, readOptionalManagedRuntimeBrowserCredential, revokeResidentRemoteRuntimeClient, setResidentPluginEnabled, shutdownResidentDaemonIfIdle, configureResidentChromeInspection, testResidentRuntimeTarget, uninstallResidentPlugin, connectResidentDesktopBrowserHost, ResidentRuntimeCallError, } from "./control-client.js";
 export { ensureDaemonControlEndpoint, resolveDaemonControlEndpoint, } from "./control-endpoint.js";

package/dist/commands/app-distribution.d.ts

@@ -1,6 +1,6 @@
 export declare function shouldUseAppDistributionCommand(command: string | undefined, env?: NodeJS.ProcessEnv): boolean;
 /**
- * Prevent the App launcher from falling through to the compatibility daemon
- * CLI and accidentally creating or inspecting a PM2-owned second lifecycle.
+ * Prevent the App launcher from falling through to standalone lifecycle
+ * commands and accidentally creating or inspecting a PM2-owned second owner.
  */
 export declare function runAppDistributionCommand(command: string, args: readonly string[]): Promise<number>;

package/dist/commands/app-distribution.js

@@ -4,7 +4,6 @@ import { rynxHome } from "@rynx-ai/core";
 import { resolveDaemonControlEndpoint } from "../control-endpoint.js";
 import { fail } from "./errors.js";
 const APP_ONLY_COMMANDS = new Set([
-    "setup",
     "update",
     "start",
     "restart",
@@ -19,8 +18,8 @@ export function shouldUseAppDistributionCommand(command, env = process.env) {
         && env.RYNX_DISTRIBUTION === "app";
 }
 /**
- * Prevent the App launcher from falling through to the compatibility daemon
- * CLI and accidentally creating or inspecting a PM2-owned second lifecycle.
+ * Prevent the App launcher from falling through to standalone lifecycle
+ * commands and accidentally creating or inspecting a PM2-owned second owner.
  */
 export async function runAppDistributionCommand(command, args) {
     const json = args.includes("--json");
@@ -44,9 +43,6 @@ export async function runAppDistributionCommand(command, args) {
         printRecentDaemonLogs();
         return 0;
     }
-    if (command === "setup") {
-        fail("Rynx App setup is completed in its onboarding and Desktop Settings.");
-    }
     if (command === "update") {
         fail("Rynx App updates are managed from Rynx > Check for Updates.");
     }

package/dist/commands/browser.js

@@ -3,7 +3,7 @@ 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, cleanResidentBrowserArtifacts, getResidentBrowserArtifactVersion, getResidentRuntimeLocalBrowserAutomationAccess, getResidentRuntimeLocalBrowserEndpoint, installResidentBrowserArtifact, readOptionalManagedRuntimeBrowserCredential, updateResidentBrowserArtifact, } from "../control-client.js";
+import { callManagedRuntimeBrowser, callResidentRuntime, getResidentRuntimeLocalBrowserAutomationAccess, getResidentRuntimeLocalBrowserEndpoint, readOptionalManagedRuntimeBrowserCredential, } from "../control-client.js";
 import { fail } from "./errors.js";
 export async function runBrowserCommand(args) {
     let parsed;
@@ -18,9 +18,11 @@ export async function runBrowserCommand(args) {
             fail("browser install: choose either --version or --channel");
         }
         const channel = browserReleaseChannel(parsed.channel);
+        const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
+        const artifacts = createBrowserArtifactManagementService();
         const result = parsed.subcommand === "install"
-            ? await installResidentBrowserArtifact(parsed.version ? { version: parsed.version } : { channel })
-            : await updateResidentBrowserArtifact({ channel });
+            ? 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) });
         if (parsed.json) {
             console.log(JSON.stringify({
                 resolved: result.resolved,
@@ -35,7 +37,8 @@ export async function runBrowserCommand(args) {
         return 0;
     }
     if (parsed.subcommand === "version") {
-        const { installed } = await getResidentBrowserArtifactVersion();
+        const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
+        const { installed } = createBrowserArtifactManagementService().version();
         if (parsed.json)
             console.log(JSON.stringify({ installed }, null, 2));
         else if (installed) {
@@ -47,7 +50,8 @@ export async function runBrowserCommand(args) {
         return 0;
     }
     if (parsed.subcommand === "clean") {
-        const result = await cleanResidentBrowserArtifacts();
+        const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
+        const result = createBrowserArtifactManagementService().clean();
         if (parsed.json)
             console.log(JSON.stringify(result, null, 2));
         else if (result.removedBuilds.length === 0) {

package/dist/commands/lifecycle.d.ts

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

package/dist/commands/lifecycle.js

@@ -0,0 +1,21 @@
+import { startStandaloneDaemon, statusStandaloneDaemon, stopStandaloneDaemon, streamStandaloneDaemonLogs, } from "../standalone.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":
+            return startStandaloneDaemon();
+        case "restart":
+            return startStandaloneDaemon({ restart: true });
+        case "stop":
+            return stopStandaloneDaemon();
+        case "status":
+            return statusStandaloneDaemon();
+        case "logs":
+            await streamStandaloneDaemonLogs();
+            return 0;
+        default:
+            fail(`unknown lifecycle command: ${command}`);
+    }
+}

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,314 @@
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+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 { fail } from "./errors.js";
+export async function runSetupCommand(args) {
+    const options = parseSetupOptions(args);
+    const interactive = !options.nonInteractive &&
+        !options.hasConfigurationArguments &&
+        Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const existing = readRawConfig();
+    const created = !existsSync(rynxConfigFile());
+    const defaults = loadConfig({});
+    const next = {
+        ...existing,
+        HOST: existing.HOST ?? defaults.HOST,
+        PORT: existing.PORT ?? defaults.PORT,
+        LOG_LEVEL: existing.LOG_LEVEL ?? defaults.LOG_LEVEL,
+        DEFAULT_RUNTIME: existing.DEFAULT_RUNTIME ?? defaults.DEFAULT_RUNTIME,
+    };
+    if (interactive) {
+        if (!await collectInteractiveSetup(next))
+            return 0;
+    }
+    else {
+        if (options.defaultRuntime !== undefined)
+            next.DEFAULT_RUNTIME = options.defaultRuntime;
+        if (options.host !== undefined)
+            next.HOST = options.host;
+        if (options.port !== undefined)
+            next.PORT = options.port;
+        if (options.logLevel !== undefined)
+            next.LOG_LEVEL = options.logLevel;
+    }
+    validateSetupConfig(next);
+    const updated = ["HOST", "PORT", "LOG_LEVEL", "DEFAULT_RUNTIME"].filter((key) => existing[key] !== next[key]);
+    writeConfigAtomically(next);
+    const result = {
+        configPath: rynxConfigFile(),
+        created,
+        updated,
+        browser: {
+            action: options.browser,
+            status: "skipped",
+        },
+        plugins: {
+            status: "ready",
+        },
+    };
+    let failed = false;
+    try {
+        const plugins = await prepareBundledPlugins();
+        result.plugins = {
+            status: plugins.status,
+            changed: [...plugins.installed, ...plugins.updated],
+        };
+    }
+    catch (error) {
+        failed = true;
+        result.plugins = {
+            status: "error",
+            detail: errorMessage(error),
+        };
+    }
+    const diagnostics = await inspectDaemonDiagnostics();
+    if (!diagnostics.browser.supported) {
+        result.browser = { action: options.browser, status: "unsupported" };
+    }
+    else if (diagnostics.browser.installedVersion) {
+        result.browser = {
+            action: options.browser,
+            status: "ready",
+            version: diagnostics.browser.installedVersion,
+        };
+    }
+    else if (options.browser !== "skip") {
+        try {
+            const { createBrowserArtifactManagementService } = await import("@rynx-ai/daemon/browser-artifacts");
+            const installed = await createBrowserArtifactManagementService().install({ channel: "stable" }, options.json
+                ? {}
+                : { onProgress: (message) => console.error(message) });
+            result.browser = {
+                action: options.browser,
+                status: "ready",
+                version: installed.installed.version,
+            };
+        }
+        catch (error) {
+            failed = true;
+            result.browser = {
+                action: options.browser,
+                status: "error",
+                detail: errorMessage(error),
+            };
+        }
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (interactive) {
+        prompts.log.success(`已写入 ${result.configPath}`);
+        prompts.log.info(`HOST=${next.HOST} PORT=${next.PORT} DEFAULT_RUNTIME=${next.DEFAULT_RUNTIME}`);
+        if (result.browser.status === "ready") {
+            prompts.log.success(`Session Browser ${result.browser.version ?? "ready"}`);
+        }
+        else if (result.browser.status === "error") {
+            prompts.log.warn(`Session Browser: ${result.browser.detail}`);
+        }
+        prompts.outro(failed ? "初始化完成，但存在失败项" : "配置完成");
+    }
+    else {
+        console.log(`Initialized ${result.configPath}`);
+        if (result.browser.status === "ready") {
+            console.log(`Browser ready${result.browser.version ? `: ${result.browser.version}` : ""}`);
+        }
+    }
+    return failed ? 1 : 0;
+}
+export async function runDoctorCommand(args) {
+    const json = args.includes("--json");
+    if (args.some((arg) => arg !== "--json")) {
+        fail(`doctor: unexpected argument ${args.find((arg) => arg !== "--json")}`);
+    }
+    let config;
+    let configError;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        configError = errorMessage(error);
+    }
+    const runtimes = AGENT_RUNTIME_IDS.map((id) => {
+        const binary = getRuntimeProfile(id).defaultBinary;
+        const probe = spawnSync(binary, ["--version"], {
+            stdio: "ignore",
+            timeout: 8_000,
+        });
+        return { id, installed: !probe.error && probe.status === 0 };
+    });
+    const daemon = await inspectDaemonDiagnostics();
+    const result = {
+        ok: configError === undefined && runtimes.some((runtime) => runtime.installed),
+        configPath: rynxConfigFile(),
+        config,
+        configError,
+        runtimes,
+        daemon,
+    };
+    if (json)
+        console.log(JSON.stringify(result, null, 2));
+    else {
+        console.log(`config: ${result.configPath}`);
+        if (configError)
+            console.error(`config: ${configError}`);
+        else
+            console.log(`default runtime: ${config.DEFAULT_RUNTIME}`);
+        for (const runtime of runtimes) {
+            console.log(`${runtime.id}: ${runtime.installed ? "installed" : "not installed"}`);
+        }
+        if (daemon.browser.supported) {
+            console.log(`browser: ${daemon.browser.installedVersion ?? daemon.browser.error ?? "not installed"}`);
+        }
+        else {
+            console.log("browser: unsupported");
+        }
+    }
+    return result.ok ? 0 : 1;
+}
+function parseSetupOptions(args) {
+    const options = {
+        nonInteractive: false,
+        json: false,
+        browser: "auto",
+        hasConfigurationArguments: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--non-interactive") {
+            options.nonInteractive = true;
+            continue;
+        }
+        if (arg === "--json") {
+            options.json = true;
+            options.nonInteractive = true;
+            continue;
+        }
+        if (arg === "--install-browser" || arg === "--skip-browser") {
+            if (options.browser !== "auto")
+                fail("setup: choose only one Browser action");
+            options.browser = arg === "--install-browser" ? "install" : "skip";
+            options.hasConfigurationArguments = true;
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            fail(`setup: ${arg} requires a value`);
+        index += 1;
+        options.hasConfigurationArguments = true;
+        if (arg === "--default-runtime") {
+            if (!AGENT_RUNTIME_IDS.includes(value)) {
+                fail("setup: --default-runtime must be codex, traex, or claude");
+            }
+            options.defaultRuntime = value;
+        }
+        else if (arg === "--host") {
+            if (!value.trim() || value.length > 255)
+                fail("setup: --host is invalid");
+            options.host = value;
+        }
+        else if (arg === "--port") {
+            const port = Number(value);
+            if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+                fail("setup: --port must be an integer from 1 to 65535");
+            }
+            options.port = port;
+        }
+        else if (arg === "--log-level") {
+            if (!value.trim() || value.length > 32)
+                fail("setup: --log-level is invalid");
+            options.logLevel = value;
+        }
+        else {
+            fail(`setup: unknown option ${arg}`);
+        }
+    }
+    return options;
+}
+async function collectInteractiveSetup(config) {
+    prompts.intro("rynx setup");
+    const runtime = await prompts.select({
+        message: "Default runtime",
+        initialValue: config.DEFAULT_RUNTIME,
+        options: AGENT_RUNTIME_IDS.map((id) => ({ value: id, label: id })),
+    });
+    if (prompts.isCancel(runtime))
+        return cancelled();
+    config.DEFAULT_RUNTIME = runtime;
+    const port = await prompts.text({
+        message: "HTTP port",
+        initialValue: String(config.PORT),
+        validate: (value) => {
+            const parsed = Number(value);
+            return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535
+                ? undefined
+                : "Enter a port from 1 to 65535";
+        },
+    });
+    if (prompts.isCancel(port))
+        return cancelled();
+    config.PORT = Number(port);
+    const host = await prompts.text({
+        message: "Bind host",
+        initialValue: String(config.HOST),
+    });
+    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;
+}
+function validateSetupConfig(config) {
+    loadConfig({
+        HOST: String(config.HOST),
+        PORT: String(config.PORT),
+        LOG_LEVEL: String(config.LOG_LEVEL),
+        DEFAULT_RUNTIME: String(config.DEFAULT_RUNTIME),
+    });
+}
+function readRawConfig() {
+    try {
+        const parsed = JSON.parse(readFileSync(rynxConfigFile(), "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfigAtomically(config) {
+    const file = rynxConfigFile();
+    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");
+        closeSync(descriptor);
+        descriptor = undefined;
+        renameSync(temporary, file);
+        chmodSync(file, 0o600);
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+        rmSync(temporary, { force: true });
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,20 @@
+export interface UpdateOptions {
+    check?: boolean;
+    json?: boolean;
+    version?: string;
+}
+export type UpdateCheck = {
+    status: "up_to_date";
+    current: string;
+} | {
+    status: "behind";
+    current: string;
+    latest: string;
+} | {
+    status: "error";
+    detail: string;
+};
+export declare function isNewer(latest: string, current: string): boolean;
+export declare function buildUpdateCheck(current: string, latest: string | null): UpdateCheck;
+export declare function checkStatusLine(current: string, latest: string | null): string;
+export declare function runUpdate(options: UpdateOptions): Promise<number>;

package/dist/commands/update.js

@@ -0,0 +1,234 @@
+import { spawnSync } from "node:child_process";
+import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, sep } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import { stopStandaloneDaemon } from "../standalone.js";
+function selfPackage() {
+    const require = createRequire(import.meta.url);
+    const manifest = require("../../package.json");
+    return {
+        name: manifest.name ?? "@rynx-ai/cli",
+        version: manifest.version ?? "0.0.0",
+    };
+}
+function packageRoot() {
+    const require = createRequire(import.meta.url);
+    return dirname(require.resolve("../../package.json"));
+}
+function isLocalDevInstall() {
+    return !packageRoot().split(sep).includes("node_modules");
+}
+function latestVersion(name, current) {
+    const tag = current.includes("-") ? "next" : "latest";
+    const result = spawnSync("npm", ["view", `${name}@${tag}`, "version"], {
+        encoding: "utf8",
+        timeout: 60_000,
+    });
+    if (result.error || result.status !== 0)
+        return null;
+    return result.stdout.trim() || null;
+}
+export function isNewer(latest, current) {
+    return compareSemver(latest, current) > 0;
+}
+export function buildUpdateCheck(current, latest) {
+    if (!latest)
+        return { status: "error", detail: "could not resolve latest version" };
+    return isNewer(latest, current)
+        ? { status: "behind", current, latest }
+        : { status: "up_to_date", current };
+}
+export function checkStatusLine(current, latest) {
+    const check = buildUpdateCheck(current, latest);
+    if (check.status === "behind")
+        return `behind ${check.current} ${check.latest}`;
+    if (check.status === "up_to_date")
+        return `up_to_date ${check.current}`;
+    return `error ${check.detail}`;
+}
+export async function runUpdate(options) {
+    const { name, version: current } = selfPackage();
+    const latest = latestVersion(name, current);
+    if (options.check) {
+        const result = buildUpdateCheck(current, latest);
+        console.log(options.json ? JSON.stringify(result) : checkStatusLine(current, latest));
+        return result.status === "error" ? 1 : 0;
+    }
+    if (isLocalDevInstall()) {
+        console.error(`update: ${name} is a local development install`);
+        return 1;
+    }
+    const target = options.version ?? latest;
+    if (!target) {
+        console.error(`update: could not resolve a target version for ${name}`);
+        return 1;
+    }
+    if (!options.version && !isNewer(target, current)) {
+        console.log(`Already on the latest ${name}@${current}.`);
+        return 0;
+    }
+    const releaseLock = acquireUpdateLock();
+    if (!releaseLock)
+        return 1;
+    try {
+        if (await stopStandaloneDaemon() !== 0) {
+            console.error("update: could not stop the standalone daemon");
+            return 1;
+        }
+        if (!npmInstallGlobal(name, target)) {
+            console.error("update: npm install failed");
+            startFreshCli();
+            return 1;
+        }
+        if (!freshRuntimeMatches(target) || !startFreshCli()) {
+            console.error(`update: ${name}@${target} failed verification; rolling back to ${current}`);
+            if (!npmInstallGlobal(name, current)) {
+                console.error(`update: rollback to ${name}@${current} failed`);
+                return 1;
+            }
+            if (!freshRuntimeMatches(current) || !startFreshCli()) {
+                console.error(`update: ${name}@${current} was restored but failed to start`);
+            }
+            return 1;
+        }
+        console.log(`Updated ${name} to ${target}.`);
+        return 0;
+    }
+    finally {
+        releaseLock();
+    }
+}
+function compareSemver(left, right) {
+    const parse = (value) => {
+        const [core, prerelease] = value.split("-", 2);
+        const parts = core.split(".").map((part) => Number(part));
+        return { parts, prerelease: prerelease?.split(".") ?? [] };
+    };
+    const a = parse(left);
+    const b = parse(right);
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (a.parts[index] ?? 0) - (b.parts[index] ?? 0);
+        if (difference !== 0)
+            return Math.sign(difference);
+    }
+    if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+        return a.prerelease.length === b.prerelease.length
+            ? 0
+            : a.prerelease.length === 0 ? 1 : -1;
+    }
+    const length = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = a.prerelease[index];
+        const rightPart = b.prerelease[index];
+        if (leftPart === undefined || rightPart === undefined) {
+            return leftPart === rightPart ? 0 : leftPart === undefined ? -1 : 1;
+        }
+        if (leftPart === rightPart)
+            continue;
+        const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : undefined;
+        const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : undefined;
+        if (leftNumber !== undefined && rightNumber !== undefined) {
+            return Math.sign(leftNumber - rightNumber);
+        }
+        if (leftNumber !== undefined)
+            return -1;
+        if (rightNumber !== undefined)
+            return 1;
+        return leftPart.localeCompare(rightPart);
+    }
+    return 0;
+}
+function npmInstallGlobal(name, version) {
+    const installed = spawnSync("npm", ["install", "-g", `${name}@${version}`, "--no-audit", "--no-fund"], { stdio: "inherit", timeout: 600_000 });
+    return !installed.error && installed.status === 0;
+}
+function freshRuntimeMatches(version) {
+    const probe = spawnSync("rynx", ["version", "--json"], {
+        encoding: "utf8",
+        timeout: 60_000,
+    });
+    if (probe.error || probe.status !== 0)
+        return false;
+    try {
+        const runtime = JSON.parse(probe.stdout);
+        return runtime.cliVersion === version && runtime.daemonVersion === version;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run lifecycle through the newly installed bin. Calling an imported lifecycle
+ * module after npm replaces the package graph would execute stale code.
+ */
+function startFreshCli() {
+    const restarted = spawnSync("rynx", ["start"], {
+        stdio: "inherit",
+        timeout: 60_000,
+    });
+    return !restarted.error && restarted.status === 0;
+}
+function acquireUpdateLock() {
+    const directory = join(rynxHome(), "state");
+    const file = join(directory, "update.lock");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    let descriptor;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            descriptor = openSync(file, "wx", 0o600);
+            writeFileSync(descriptor, `${process.pid}\n`, "utf8");
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const owner = readLockOwner(file);
+            if (owner !== undefined && processIsAlive(owner)) {
+                console.error(`update: another update is running (pid ${owner})`);
+                return null;
+            }
+            try {
+                unlinkSync(file);
+            }
+            catch (unlinkError) {
+                if (unlinkError.code !== "ENOENT") {
+                    console.error("update: could not clear a stale update lock");
+                    return null;
+                }
+            }
+        }
+    }
+    if (descriptor === undefined) {
+        console.error("update: could not acquire the update lock");
+        return null;
+    }
+    return () => {
+        closeSync(descriptor);
+        try {
+            if (readLockOwner(file) === process.pid)
+                unlinkSync(file);
+        }
+        catch {
+            // The update already completed; a stale lock is recoverable next run.
+        }
+    };
+}
+function readLockOwner(file) {
+    try {
+        const value = Number(readFileSync(file, "utf8").trim());
+        return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}

package/dist/control-client.d.ts

@@ -1,13 +1,10 @@
 import { type DaemonStatus } from "@rynx-ai/protocol/remote-runtime";
-import { type DaemonBrowserArtifactCleanResult, type DaemonBrowserArtifactInstallInput, type DaemonBrowserArtifactInstallResult, type DaemonBrowserArtifactUpdateInput, type DaemonBrowserArtifactVersionResult, type DaemonCleanupSessionsInput, type DaemonCleanupSessionsResult, type DaemonChromeInspectionConfigureInput, type DaemonChromeInspectionStatus, type DaemonShutdownIfIdleResult } from "@rynx-ai/protocol/control";
+import { type DaemonCleanupSessionsInput, type DaemonCleanupSessionsResult, type DaemonChromeInspectionConfigureInput, type DaemonChromeInspectionStatus, type DaemonShutdownIfIdleResult } from "@rynx-ai/protocol/control";
 import { type RemoteRuntimeRpcMethod, type RemoteRuntimeRpcParams, type RemoteRuntimeRpcResultFor } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { type PairingOffer } from "@rynx-ai/protocol/direct-runtime";
 import { type RuntimeBrowserBootstrapCredential, type RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
 import { type PluginInstallCommitInput, type PluginInstallCommitResult, type PluginInstallPreparation, type PluginInstallPrepareInput, type PluginManagementItem, type PluginManagementState, type PluginMarketplaceAddInput, type PluginMarketplaceItem } from "@rynx-ai/protocol/plugin-management";
 export { connectResidentDesktopBrowserHost, type ResidentDesktopBrowserHostConnection, type ResidentDesktopBrowserHostCommandRequest, type ResidentDesktopBrowserHostConnectOptions, type ResidentDesktopBrowserHostFailure, } from "./desktop-browser-host-client.js";
-export interface ResidentDaemon {
-    origin: string;
-}
 export interface ResidentDaemonIdentity {
     installationId: string;
     algorithm: "Ed25519";
@@ -59,8 +56,6 @@ export declare class ResidentRuntimeCallError extends Error {
         outcome?: ResidentRuntimeCallOutcome;
     });
 }
-/** Connect to the resident daemon already owned by the App or standalone supervisor. */
-export declare function ensureResidentDaemon(): Promise<ResidentDaemon>;
 /** Read the stable public identity of the single resident daemon. */
 export declare function getResidentDaemonIdentity(): Promise<ResidentDaemonIdentity>;
 /** Read the transport-independent status of the resident daemon process. */
@@ -73,10 +68,6 @@ export declare function getResidentDaemonRuntimeStatus(): Promise<DaemonStatus>;
 export declare function shutdownResidentDaemonIfIdle(): Promise<DaemonShutdownIfIdleResult>;
 export declare function getResidentChromeInspectionStatus(): Promise<DaemonChromeInspectionStatus>;
 export declare function configureResidentChromeInspection(input: DaemonChromeInspectionConfigureInput): Promise<DaemonChromeInspectionStatus>;
-export declare function installResidentBrowserArtifact(input: DaemonBrowserArtifactInstallInput): Promise<DaemonBrowserArtifactInstallResult>;
-export declare function updateResidentBrowserArtifact(input: DaemonBrowserArtifactUpdateInput): Promise<DaemonBrowserArtifactInstallResult>;
-export declare function getResidentBrowserArtifactVersion(): Promise<DaemonBrowserArtifactVersionResult>;
-export declare function cleanResidentBrowserArtifacts(): Promise<DaemonBrowserArtifactCleanResult>;
 export declare function cleanupResidentSessions(input?: DaemonCleanupSessionsInput): Promise<DaemonCleanupSessionsResult>;
 /** Create one pairing offer on the resident daemon for a selected reachable route. */
 export declare function createResidentRemoteRuntimePairingOffer(input?: {

package/dist/control-client.js

@@ -1,7 +1,7 @@
 import { open } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { isDaemonCoreCompatible, parseDaemonStatus, } from "@rynx-ai/protocol/remote-runtime";
-import { DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, DAEMON_BROWSER_ARTIFACT_VERSION_PATH, DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonBrowserArtifactCleanResult, parseDaemonBrowserArtifactInstallResult, parseDaemonBrowserArtifactVersionResult, parseDaemonCleanupSessionsResult, parseDaemonChromeInspectionConfigureInput, parseDaemonChromeInspectionStatus, parseDaemonShutdownIfIdleResult, } from "@rynx-ai/protocol/control";
+import { DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonCleanupSessionsResult, parseDaemonChromeInspectionConfigureInput, parseDaemonChromeInspectionStatus, parseDaemonShutdownIfIdleResult, } from "@rynx-ai/protocol/control";
 import { parseRemoteRuntimeRpcRequest, parseRemoteRuntimeRpcResponseForMethod, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { parsePairingOffer, } from "@rynx-ai/protocol/direct-runtime";
 import { RUNTIME_BROWSER_BOOTSTRAP_PATH, RUNTIME_BROWSER_CAPABILITY_ENV, RUNTIME_BROWSER_CAPABILITY_HEADER, RUNTIME_BROWSER_CONTEXT_FILE_ENV, RUNTIME_BROWSER_MANAGEMENT_PATH_PREFIX, RUNTIME_BROWSER_RPC_PATH, RUNTIME_BROWSER_SESSION_ID_ENV, RUNTIME_BROWSER_SESSION_ID_HEADER, parseRuntimeBrowserBootstrapCredential, parseRuntimeBrowserEndpointDescriptor, } from "@rynx-ai/protocol/runtime-browser-bootstrap";
@@ -35,8 +35,6 @@ const PLUGIN_CLI_RESPONSE_MAX_BYTES = 4 * 1024 * 1024;
 const PLUGIN_MANAGEMENT_TIMEOUT_MS = 30_000;
 const PLUGIN_INSTALL_OPERATION_TIMEOUT_MS = 15 * 60_000;
 const PLUGIN_MANAGEMENT_RESPONSE_MAX_BYTES = 256 * 1024;
-const BROWSER_ARTIFACT_OPERATION_TIMEOUT_MS = 15 * 60_000;
-const BROWSER_ARTIFACT_RESPONSE_MAX_BYTES = 4 * 1024 * 1024;
 const MAINTENANCE_TIMEOUT_MS = 30_000;
 const MAINTENANCE_RESPONSE_MAX_BYTES = 64 * 1024;
 const CHROME_INSPECTION_TIMEOUT_MS = 30_000;
@@ -56,11 +54,6 @@ export class ResidentRuntimeCallError extends Error {
         this.outcome = options?.outcome;
     }
 }
-/** Connect to the resident daemon already owned by the App or standalone supervisor. */
-export async function ensureResidentDaemon() {
-    const endpoint = await ensureDaemonControlEndpoint();
-    return { origin: endpoint.origin };
-}
 /** Read the stable public identity of the single resident daemon. */
 export async function getResidentDaemonIdentity() {
     const endpoint = await ensureDaemonControlEndpoint();
@@ -160,44 +153,6 @@ export async function configureResidentChromeInspection(input) {
     });
     return parseDaemonChromeInspectionStatus(result);
 }
-export async function installResidentBrowserArtifact(input) {
-    const result = await localManagementJsonRequest(DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, {
-        method: "POST",
-        body: input,
-        timeoutMs: BROWSER_ARTIFACT_OPERATION_TIMEOUT_MS,
-        maxResponseBytes: BROWSER_ARTIFACT_RESPONSE_MAX_BYTES,
-        operation: "Browser artifact install",
-    });
-    return parseDaemonBrowserArtifactInstallResult(result);
-}
-export async function updateResidentBrowserArtifact(input) {
-    const result = await localManagementJsonRequest(DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, {
-        method: "POST",
-        body: input,
-        timeoutMs: BROWSER_ARTIFACT_OPERATION_TIMEOUT_MS,
-        maxResponseBytes: BROWSER_ARTIFACT_RESPONSE_MAX_BYTES,
-        operation: "Browser artifact update",
-    });
-    return parseDaemonBrowserArtifactInstallResult(result);
-}
-export async function getResidentBrowserArtifactVersion() {
-    const result = await localManagementJsonRequest(DAEMON_BROWSER_ARTIFACT_VERSION_PATH, {
-        method: "GET",
-        timeoutMs: MAINTENANCE_TIMEOUT_MS,
-        maxResponseBytes: BROWSER_ARTIFACT_RESPONSE_MAX_BYTES,
-        operation: "Browser artifact version",
-    });
-    return parseDaemonBrowserArtifactVersionResult(result);
-}
-export async function cleanResidentBrowserArtifacts() {
-    const result = await localManagementJsonRequest(DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, {
-        method: "POST",
-        timeoutMs: MAINTENANCE_TIMEOUT_MS,
-        maxResponseBytes: BROWSER_ARTIFACT_RESPONSE_MAX_BYTES,
-        operation: "Browser artifact clean",
-    });
-    return parseDaemonBrowserArtifactCleanResult(result);
-}
 export async function cleanupResidentSessions(input = {}) {
     const result = await localManagementJsonRequest(DAEMON_CLEANUP_SESSIONS_PATH, {
         method: "POST",

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { runCli } from "./run-cli.js";
 export { USAGE } from "./usage.js";
+export { installedVersion } from "./version.js";

package/dist/index.js

@@ -1,2 +1,3 @@
 export { runCli } from "./run-cli.js";
 export { USAGE } from "./usage.js";
+export { installedVersion } from "./version.js";

package/dist/run-cli.js

@@ -9,13 +9,9 @@ import { runPluginCommand, } from "./commands/plugin.js";
 import { runRuntimeCommand } from "./commands/runtime.js";
 import { runSessionCommand } from "./commands/session.js";
 import { runSkillsCommand } from "./commands/skills.js";
-import { runLegacyDaemonCli } from "./legacy-adapter.js";
 import { USAGE } from "./usage.js";
 import { installedVersion } from "./version.js";
-const LEGACY_TOP_LEVEL_COMMANDS = new Set([
-    "setup",
-    "doctor",
-    "update",
+const LIFECYCLE_COMMANDS = new Set([
     "start",
     "restart",
     "stop",
@@ -27,12 +23,25 @@ export async function runCli(argv) {
     if (shouldUseAppDistributionCommand(command)) {
         return runAppDistributionCommand(command, argv.slice(1));
     }
-    if (command && LEGACY_TOP_LEVEL_COMMANDS.has(command)) {
-        return runLegacyDaemonCli(argv);
+    if (command && LIFECYCLE_COMMANDS.has(command)) {
+        const { runLifecycleCommand } = await import("./commands/lifecycle.js");
+        return runLifecycleCommand(command, argv.slice(1));
     }
     switch (command) {
-        case "version":
+        case "version": {
+            if (argv.length === 2 && argv[1] === "--json") {
+                const { resolveCliDependencyVersions } = await import("./app-runtime.js");
+                console.log(JSON.stringify(resolveCliDependencyVersions()));
+                return 0;
+            }
+            if (argv.length > 1)
+                fail(`version: unexpected argument ${argv[1]}`);
+            console.log(installedVersion());
+            return 0;
+        }
         case "--version":
+            if (argv.length > 1)
+                fail(`--version: unexpected argument ${argv[1]}`);
             console.log(installedVersion());
             return 0;
         case "plugin":
@@ -53,6 +62,23 @@ export async function runCli(argv) {
             return runBrowserCommand(argv.slice(1));
         case "cleanup":
             return runCleanupCommand(argv.slice(1));
+        case "setup": {
+            const { runSetupCommand } = await import("./commands/setup.js");
+            return runSetupCommand(argv.slice(1));
+        }
+        case "doctor": {
+            const { runDoctorCommand } = await import("./commands/setup.js");
+            return runDoctorCommand(argv.slice(1));
+        }
+        case "update": {
+            const { runUpdate } = await import("./commands/update.js");
+            const rest = argv.slice(1);
+            return runUpdate({
+                check: rest.includes("--check"),
+                json: rest.includes("--json"),
+                version: rest.find((argument) => !argument.startsWith("--")),
+            });
+        }
         case undefined:
         case "help":
         case "-h":

package/dist/standalone.d.ts

@@ -0,0 +1,13 @@
+/** Resolve the canonical Builtin Skill directory shipped by this exact CLI. */
+export declare function standaloneBuiltinSkillsDirectory(moduleUrl?: string): string;
+export declare function startStandaloneDaemon(options?: {
+    restart?: boolean;
+    quiet?: boolean;
+}): Promise<number>;
+/** Reuse any healthy owner; otherwise explicitly start the standalone owner. */
+export declare function ensureStandaloneDaemon(): Promise<{
+    origin: string;
+}>;
+export declare function stopStandaloneDaemon(): Promise<number>;
+export declare function statusStandaloneDaemon(): Promise<number>;
+export declare function streamStandaloneDaemonLogs(): Promise<void>;

package/dist/standalone.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { installedVersion } from "./version.js";
+import { ensureDaemonControlEndpoint, resolveDaemonControlEndpoint, } from "./control-endpoint.js";
+/** Resolve the canonical Builtin Skill directory shipped by this exact CLI. */
+export function standaloneBuiltinSkillsDirectory(moduleUrl = import.meta.url) {
+    return path.resolve(fileURLToPath(new URL("../skills/", moduleUrl)));
+}
+export async function startStandaloneDaemon(options = {}) {
+    const cliVersion = installedVersion();
+    const { startDaemon } = await import("@rynx-ai/daemon/lifecycle");
+    return startDaemon({
+        force: options.restart ?? false,
+        quiet: options.quiet,
+        context: {
+            builtinSkillsDir: standaloneBuiltinSkillsDirectory(),
+            cliVersion,
+            productVersion: cliVersion,
+        },
+    });
+}
+/** Reuse any healthy owner; otherwise explicitly start the standalone owner. */
+export async function ensureStandaloneDaemon() {
+    const current = await resolveDaemonControlEndpoint();
+    if (current)
+        return { origin: current.origin };
+    const status = await startStandaloneDaemon({ quiet: true });
+    if (status !== 0)
+        throw new Error("failed to start the standalone daemon");
+    const deadline = Date.now() + 20_000;
+    while (Date.now() < deadline) {
+        try {
+            const endpoint = await ensureDaemonControlEndpoint();
+            return { origin: endpoint.origin };
+        }
+        catch {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    const endpoint = await ensureDaemonControlEndpoint();
+    return { origin: endpoint.origin };
+}
+export async function stopStandaloneDaemon() {
+    const { stopDaemon } = await import("@rynx-ai/daemon/lifecycle");
+    return stopDaemon();
+}
+export async function statusStandaloneDaemon() {
+    const { statusDaemon } = await import("@rynx-ai/daemon/lifecycle");
+    return statusDaemon();
+}
+export async function streamStandaloneDaemonLogs() {
+    const { streamLogs } = await import("@rynx-ai/daemon/lifecycle");
+    streamLogs();
+}

package/dist/usage.d.ts

@@ -1 +1 @@
-export declare const USAGE = "Usage: rynx <command>\n\nGeneral:\n  version | --version  print the installed Rynx version\n\nSetup:\n  setup              interactive configuration wizard\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]\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";

package/dist/usage.js

@@ -1,10 +1,14 @@
 export const USAGE = `Usage: rynx <command>
 
 General:
-  version | --version  print the installed Rynx version
+  version [--json] | --version
+                     print the installed Rynx version
 
 Setup:
-  setup              interactive configuration wizard
+  setup [--non-interactive] [--default-runtime <codex|traex|claude>]
+        [--host <host>] [--port <port>] [--log-level <level>]
+        [--install-browser|--skip-browser] [--json]
+                     initialize configuration and local dependencies
   doctor             read-only health check
 
 Lifecycle:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/cli",
-  "version": "0.1.11-beta.2",
+  "version": "0.1.11-beta.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -9,6 +9,9 @@
   "description": "Rynx command-line client and local control-plane management surface.",
   "license": "MIT",
   "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -35,14 +38,24 @@
     "./commands": {
       "types": "./dist/commands/index.d.ts",
       "default": "./dist/commands/index.js"
+    },
+    "./standalone": {
+      "types": "./dist/standalone.d.ts",
+      "default": "./dist/standalone.js"
+    },
+    "./app-runtime": {
+      "types": "./dist/app-runtime.d.ts",
+      "default": "./dist/app-runtime.js"
     }
   },
   "dependencies": {
+    "@clack/prompts": "^1.6.0",
     "ws": "^8.21.0",
-    "@rynx-ai/browser-cdp": "0.1.11-beta.2",
-    "@rynx-ai/core": "0.1.11-beta.2",
-    "@rynx-ai/emulator": "0.1.11-beta.2",
-    "@rynx-ai/protocol": "0.1.11-beta.2"
+    "@rynx-ai/browser-cdp": "0.1.11-beta.4",
+    "@rynx-ai/core": "0.1.11-beta.4",
+    "@rynx-ai/daemon": "0.1.11-beta.4",
+    "@rynx-ai/emulator": "0.1.11-beta.4",
+    "@rynx-ai/protocol": "0.1.11-beta.4"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"

package/dist/legacy-adapter.d.ts

@@ -1,7 +0,0 @@
-/**
- * Temporary bridge for commands whose daemon-owned mutation has no management
- * RPC yet. It crosses the package boundary as a subprocess, never by importing
- * daemon implementation modules into the CLI process.
- */
-export declare function runLegacyDaemonCli(args: readonly string[]): Promise<number>;
-export declare function resolveLegacyDaemonCli(env?: NodeJS.ProcessEnv, moduleUrl?: string): string | null;

package/dist/legacy-adapter.js

@@ -1,63 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-const LEGACY_CLI_ENV = "RYNX_LEGACY_CLI_PATH";
-/**
- * Temporary bridge for commands whose daemon-owned mutation has no management
- * RPC yet. It crosses the package boundary as a subprocess, never by importing
- * daemon implementation modules into the CLI process.
- */
-export async function runLegacyDaemonCli(args) {
-    const cliPath = resolveLegacyDaemonCli();
-    if (!cliPath) {
-        throw new Error("This command still requires the legacy daemon CLI, but it is not installed. " +
-            `Set ${LEGACY_CLI_ENV} to its absolute cli.js path or use the bundled Rynx App.`);
-    }
-    return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [cliPath, ...args], {
-            stdio: "inherit",
-            env: process.env,
-        });
-        child.once("error", (error) => {
-            reject(new Error(`failed to launch legacy daemon CLI: ${error.message}`));
-        });
-        child.once("exit", (code, signal) => {
-            if (signal) {
-                reject(new Error(`legacy daemon CLI exited with signal ${signal}`));
-                return;
-            }
-            resolve(code ?? 1);
-        });
-    });
-}
-export function resolveLegacyDaemonCli(env = process.env, moduleUrl = import.meta.url) {
-    const configured = env[LEGACY_CLI_ENV];
-    if (configured !== undefined) {
-        if (!path.isAbsolute(configured)) {
-            throw new Error(`${LEGACY_CLI_ENV} must be an absolute path`);
-        }
-        return validateCliFile(configured);
-    }
-    // Works both in the workspace and when @rynx-ai/cli and @rynx-ai/daemon are
-    // siblings under node_modules/@rynx-ai.
-    const sibling = fileURLToPath(new URL("../../daemon/dist/cli.js", moduleUrl));
-    return validateCliFile(sibling);
-}
-function validateCliFile(candidate) {
-    try {
-        if (!existsSync(candidate) || !statSync(candidate).isFile())
-            return null;
-        const resolved = realpathSync(candidate);
-        const current = process.argv[1];
-        if (current &&
-            existsSync(current) &&
-            realpathSync(current) === resolved) {
-            return null;
-        }
-        return resolved;
-    }
-    catch {
-        return null;
-    }
-}