@rynx-ai/daemon 0.1.11-beta.2 → 0.1.11-beta.3

package/dist/pm2.js

@@ -10,14 +10,18 @@
 import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { userInfo } from "node:os";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { loadConfig, rynxHome } from "@rynx-ai/core";
 import { daemonEntryRestartRequired } from "./daemon-build-status.js";
+import { resolveDaemonEntry } from "./entry-path.js";
 const require = createRequire(import.meta.url);
 /** pm2 app name — single resident daemon per machine. */
 const APP_NAME = "rynx";
 const PM2_COMMAND_TIMEOUT_MS = 5_000;
+const LOGIN_SHELL_PATH_TIMEOUT_MS = 5_000;
+const LOGIN_SHELL_PATH_MAX_BYTES = 256 * 1024;
+const REFRESH_LOGIN_SHELL_PATH_ENV = "RYNX_REFRESH_LOGIN_SHELL_PATH";
 const DAEMON_PACKAGE_VERSION = require("../package.json").version;
 /**
  * Build a dialable control-console URL from the daemon's bind host/port. Bind-all
@@ -49,10 +53,6 @@ function pm2Bin() {
     // pm2 ships its CLI at bin/pm2; run it with our own node.
     return require.resolve("pm2/bin/pm2");
 }
-/** `index-daemon.js` sits next to this file in `dist/`. */
-function daemonEntryPath() {
-    return join(dirname(fileURLToPath(import.meta.url)), "index-daemon.js");
-}
 function logsDir() {
     const dir = join(rynxHome(), "logs");
     mkdirSync(dir, { recursive: true });
@@ -71,11 +71,58 @@ function nodeRuntimeEnv() {
             : {}),
     };
 }
+/**
+ * A detached plugin updater intentionally receives a reduced environment and
+ * therefore has no SHELL. Starting the replacement daemon with that reduced
+ * PATH would make user-installed runtimes (for example an fnm-managed Codex)
+ * disappear after every upgrade. Recover the user's login-shell PATH only at
+ * this boundary; normal interactive starts keep their exact caller environment.
+ */
+function daemonStartEnv() {
+    const env = nodeRuntimeEnv();
+    const refreshLoginPath = env[REFRESH_LOGIN_SHELL_PATH_ENV] === "1";
+    delete env[REFRESH_LOGIN_SHELL_PATH_ENV];
+    if (!refreshLoginPath)
+        return env;
+    const shell = userInfo().shell?.trim();
+    if (!shell) {
+        throw new Error("cannot refresh daemon PATH: the user login shell is unavailable");
+    }
+    const result = spawnSync(shell, ["-lic", `printf '\\036%s\\037' "$PATH"`], {
+        encoding: "utf8",
+        // Do not feed an fnm/nvm "multishell" directory inherited from the old
+        // daemon back into the next login shell. Version managers prepend a new
+        // directory on every shell startup, so reusing the old PATH would grow
+        // it indefinitely across upgrades.
+        env: { ...env, SHELL: shell, PATH: loginShellBaselinePath() },
+        timeout: LOGIN_SHELL_PATH_TIMEOUT_MS,
+        killSignal: "SIGTERM",
+        maxBuffer: LOGIN_SHELL_PATH_MAX_BYTES,
+    });
+    if (result.error) {
+        throw new Error(`cannot refresh daemon PATH: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`cannot refresh daemon PATH: login shell exited ${result.status ?? "without status"}`);
+    }
+    const path = extractFramedPath(result.stdout);
+    if (!path) {
+        throw new Error("cannot refresh daemon PATH: login shell returned no framed PATH");
+    }
+    const npmPrefix = env.NPM_CONFIG_PREFIX?.trim();
+    const npmBin = npmPrefix && isAbsolute(npmPrefix)
+        ? join(npmPrefix, "bin")
+        : "";
+    const refreshedPath = npmBin === ""
+        ? path
+        : [npmBin, ...path.split(delimiter).filter((entry) => entry !== npmBin)].join(delimiter);
+    return { ...env, PATH: refreshedPath, SHELL: shell };
+}
 /** Run a pm2 command inheriting stdio; returns its exit code. */
-function runPm2(args, quiet = false) {
+function runPm2(args, quiet = false, env = nodeRuntimeEnv()) {
     const res = spawnSync(process.execPath, [pm2Bin(), ...args], {
         stdio: quiet ? "ignore" : "inherit",
-        env: nodeRuntimeEnv(),
+        env,
         timeout: PM2_COMMAND_TIMEOUT_MS,
         killSignal: "SIGTERM",
     });
@@ -117,7 +164,7 @@ function pm2ErrorMessage(error) {
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export function startDaemon({ force, quiet = false }) {
+export function startDaemon({ force, quiet = false, launchEnvironment, }) {
     let existing;
     try {
         existing = describe();
@@ -139,6 +186,20 @@ export function startDaemon({ force, quiet = false }) {
     if (staleBuild && !quiet) {
         console.log("A newer daemon build is present on disk; restarting Rynx.");
     }
+    let startEnv;
+    try {
+        // Resolve the replacement environment before deleting an existing app.
+        // A broken/hung login shell must leave the known-good daemon untouched.
+        startEnv = {
+            ...daemonStartEnv(),
+            ...launchEnvironment,
+        };
+    }
+    catch (error) {
+        if (!quiet)
+            console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
     const dir = logsDir();
     if (existing) {
         const removed = runPm2(["delete", APP_NAME], quiet);
@@ -147,7 +208,7 @@ export function startDaemon({ force, quiet = false }) {
     }
     const status = runPm2([
         "start",
-        daemonEntryPath(),
+        resolveDaemonEntry(),
         "--name",
         APP_NAME,
         // App and CLI share one daemon-owned state/workspace root.
@@ -163,7 +224,7 @@ export function startDaemon({ force, quiet = false }) {
         join(dir, "err.log"),
         "--merge-logs",
         "--time",
-    ], quiet);
+    ], quiet, startEnv);
     if (status === 0 && !quiet) {
         console.log(`rynx ${force ? "restarted" : "started"} (pm2 app "${APP_NAME}", logs: ${dir}).`);
         console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
@@ -173,16 +234,35 @@ export function startDaemon({ force, quiet = false }) {
 export function isPm2DaemonOnline() {
     return describe()?.pm2_env?.status === "online";
 }
-/** Stop and remove the daemon from pm2's process list. */
+/**
+ * Stop the daemon and terminate its dedicated pm2 supervisor.
+ *
+ * PM2_HOME lives below RYNX_HOME, so this supervisor cannot own unrelated
+ * applications. Leaving it alive across an npm replacement is unsafe: the
+ * daemon process container path is resolved inside the old pm2 package. Once
+ * npm swaps @rynx-ai/daemon, that cached path may no longer exist and every
+ * subsequent `rynx start` enters a restart loop before our code can run.
+ */
 export function stopDaemon() {
-    if (!describe()) {
+    const existing = describe();
+    if (!existing) {
+        // Even an empty process list can belong to a resident PM2 daemon whose
+        // module path is about to be replaced. `pm2 kill` is idempotent and is
+        // the only reliable package-upgrade boundary.
+        const killed = runPm2(["kill"], true);
+        if (killed !== 0)
+            return killed;
         console.log("rynx is not running.");
         return 0;
     }
-    const status = runPm2(["delete", APP_NAME]);
-    if (status === 0)
-        console.log("rynx stopped.");
-    return status;
+    const removed = runPm2(["delete", APP_NAME]);
+    if (removed !== 0)
+        return removed;
+    const killed = runPm2(["kill"]);
+    if (killed !== 0)
+        return killed;
+    console.log("rynx stopped.");
+    return 0;
 }
 /** Print a one-line status; exit 0 only when online. */
 export function statusDaemon() {
@@ -209,7 +289,7 @@ export function streamLogs() {
 }
 function residentBuildRestartRequired(app) {
     const runningEntry = app.pm2_env?.pm_exec_path;
-    if (runningEntry && !sameEntryPath(runningEntry, daemonEntryPath()))
+    if (runningEntry && !sameEntryPath(runningEntry, resolveDaemonEntry()))
         return true;
     const runningVersion = app.pm2_env?.version;
     if (runningVersion &&
@@ -220,7 +300,7 @@ function residentBuildRestartRequired(app) {
     const startedAt = app.pm2_env?.pm_uptime;
     return typeof startedAt === "number" &&
         Number.isFinite(startedAt) &&
-        daemonEntryRestartRequired(daemonEntryPath(), startedAt);
+        daemonEntryRestartRequired(resolveDaemonEntry(), startedAt);
 }
 function sameEntryPath(left, right) {
     try {
@@ -230,3 +310,20 @@ function sameEntryPath(left, right) {
         return resolve(left) === resolve(right);
     }
 }
+function extractFramedPath(stdout) {
+    if (!stdout)
+        return undefined;
+    const start = stdout.lastIndexOf("\x1e");
+    if (start < 0)
+        return undefined;
+    const end = stdout.indexOf("\x1f", start + 1);
+    if (end < 0)
+        return undefined;
+    const value = stdout.slice(start + 1, end);
+    return value.trim() ? value : undefined;
+}
+function loginShellBaselinePath() {
+    return process.platform === "darwin"
+        ? "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+        : "/usr/local/bin:/usr/bin:/bin";
+}

package/dist/process.d.ts

@@ -0,0 +1,12 @@
+interface SupervisorProcess {
+    connected?: boolean;
+    disconnect?: () => void;
+}
+/** Release a parent/supervisor IPC handle after graceful daemon shutdown. */
+export declare function disconnectSupervisorIpc(target?: SupervisorProcess): void;
+/**
+ * Run the daemon in the current process. Process ownership and executable
+ * selection belong to the caller (CLI standalone lifecycle or App lifecycle).
+ */
+export declare function runDaemonProcess(): Promise<void>;
+export {};

package/dist/process.js

@@ -0,0 +1,91 @@
+import { startRynxDaemonServer } from "./daemon-server.js";
+import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
+import { installStdioEpipeGuard } from "./stdio-epipe-guard.js";
+/** Release a parent/supervisor IPC handle after graceful daemon shutdown. */
+export function disconnectSupervisorIpc(target = process) {
+    if (target.connected && typeof target.disconnect === "function") {
+        target.disconnect();
+    }
+}
+/**
+ * Run the daemon in the current process. Process ownership and executable
+ * selection belong to the caller (CLI standalone lifecycle or App lifecycle).
+ */
+export async function runDaemonProcess() {
+    installStdioEpipeGuard();
+    const followsApp = process.env.RYNX_DAEMON_LIFECYCLE === "follow-app";
+    let parentDisconnected = followsApp && !process.connected;
+    const recordParentDisconnect = () => {
+        parentDisconnected = true;
+    };
+    if (followsApp)
+        process.once("disconnect", recordParentDisconnect);
+    const preparePlugins = async () => {
+        try {
+            const bundled = await ensureBundledOfficialPlugins({ reclaimHostLeases: true });
+            if (bundled.status === "ready") {
+                console.log(JSON.stringify({
+                    level: "info",
+                    type: "bundled_plugins_ready",
+                    installed: bundled.installed,
+                    updated: bundled.updated,
+                }));
+            }
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                level: "error",
+                type: "bundled_plugins_failed",
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    };
+    let server;
+    try {
+        server = await startRynxDaemonServer({
+            preparePlugins,
+            onShutdownComplete: () => disconnectSupervisorIpc(),
+        });
+    }
+    catch (error) {
+        process.off("disconnect", recordParentDisconnect);
+        throw error;
+    }
+    let shutdownPromise;
+    const shutdown = (signal) => {
+        if (shutdownPromise)
+            return shutdownPromise;
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+        process.off("disconnect", onDisconnect);
+        shutdownPromise = (async () => {
+            console.log(JSON.stringify({ level: "info", type: "shutdown", signal }));
+            await server.shutdown();
+        })();
+        shutdownPromise.catch((error) => {
+            process.exitCode = 1;
+            console.error(`Shutdown failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+        });
+        return shutdownPromise;
+    };
+    const onSigint = () => {
+        void shutdown("SIGINT");
+    };
+    const onSigterm = () => {
+        void shutdown("SIGTERM");
+    };
+    const onDisconnect = () => {
+        if (process.env.RYNX_DAEMON_LIFECYCLE === "follow-app") {
+            void shutdown("APP_DISCONNECT");
+        }
+    };
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    if (followsApp) {
+        process.once("disconnect", onDisconnect);
+        process.off("disconnect", recordParentDisconnect);
+        if (parentDisconnected || !process.connected) {
+            void shutdown("APP_DISCONNECT");
+        }
+    }
+}

package/dist/session-launch-operations.d.ts

@@ -9,13 +9,22 @@ export interface EnsurePluginSessionLaunchInput {
     operationId: string;
     /** SHA-256 of the host-normalized, execution-affecting launch request. */
     requestHash: string;
+    /** SHA-256 before mutable filesystem selectors are canonicalized. */
+    rawRequestHash?: string;
     session: PluginSessionLaunchMeta;
 }
 export interface EnsurePluginSessionLaunchResult {
     sessionId: string;
     disposition: "created" | "replayed";
 }
-export type ReplayPluginSessionLaunchInput = Omit<EnsurePluginSessionLaunchInput, "session">;
+export type ReplayPluginSessionLaunchInput = Omit<EnsurePluginSessionLaunchInput, "session"> & {
+    /**
+     * A caller doing a pre-canonicalization lookup may treat a hash mismatch as
+     * a cache miss, then retry with the canonical hash. The canonical lookup
+     * must keep the default strict conflict behavior.
+     */
+    allowRequestHashMismatch?: boolean;
+};
 export declare class SessionLaunchOperationConflictError extends Error {
     readonly pluginId: string;
     readonly scopeId: string;

package/dist/session-launch-operations.js

@@ -48,7 +48,10 @@ export function replayPluginSessionLaunch(input) {
     const existing = readOperation(pluginId, scopeId, operationId);
     if (!existing)
         return undefined;
-    if (existing.request_hash !== requestHash) {
+    if (existing.request_hash !== requestHash &&
+        existing.raw_request_hash !== requestHash) {
+        if (input.allowRequestHashMismatch)
+            return undefined;
         throw new SessionLaunchOperationConflictError(pluginId, scopeId, operationId);
     }
     if (existing.state === "deleted") {
@@ -75,10 +78,16 @@ export function ensurePluginSessionLaunch(input) {
     const scopeId = requiredId(input.scopeId, "scopeId");
     const operationId = requiredId(input.operationId, "operationId");
     const requestHash = requiredRequestHash(input.requestHash);
+    const rawRequestHash = input.rawRequestHash
+        ? requiredRequestHash(input.rawRequestHash)
+        : requestHash;
     const ensure = db().transaction(() => {
         const existing = readOperation(pluginId, scopeId, operationId);
         if (existing) {
-            if (existing.request_hash !== requestHash) {
+            if (existing.request_hash !== requestHash &&
+                existing.raw_request_hash !== requestHash &&
+                existing.request_hash !== rawRequestHash &&
+                existing.raw_request_hash !== rawRequestHash) {
                 throw new SessionLaunchOperationConflictError(pluginId, scopeId, operationId);
             }
             if (existing.state === "deleted") {
@@ -110,10 +119,10 @@ export function ensurePluginSessionLaunch(input) {
         }
         db()
             .prepare(`INSERT INTO plugin_session_launch_operations
-           (plugin_id, scope_id, operation_id, request_hash, session_id, state,
+           (plugin_id, scope_id, operation_id, request_hash, raw_request_hash, session_id, state,
             created_at, updated_at, deleted_at)
-         VALUES (?, ?, ?, ?, ?, 'active', ?, ?, NULL)`)
-            .run(pluginId, scopeId, operationId, requestHash, sessionId, now, now);
+         VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, NULL)`)
+            .run(pluginId, scopeId, operationId, requestHash, rawRequestHash, sessionId, now, now);
         return { disposition: "created", sessionId };
     });
     const result = ensure.immediate();
@@ -124,7 +133,7 @@ export function ensurePluginSessionLaunch(input) {
 }
 function readOperation(pluginId, scopeId, operationId) {
     return db()
-        .prepare(`SELECT request_hash, session_id, state
+        .prepare(`SELECT request_hash, raw_request_hash, session_id, state
        FROM plugin_session_launch_operations
        WHERE plugin_id = ? AND scope_id = ? AND operation_id = ?`)
         .get(pluginId, scopeId, operationId);

package/dist/setup-service.d.ts

@@ -0,0 +1,20 @@
+export interface DaemonDiagnosticSnapshot {
+    databasePath: string;
+    databaseExists: boolean;
+    pluginCount: number;
+    agentCount: number;
+    browser: {
+        supported: false;
+    } | {
+        supported: true;
+        installedVersion?: string;
+        error?: string;
+    };
+}
+export declare function prepareBundledPlugins(): Promise<{
+    status: "ready" | "unavailable";
+    installed: string[];
+    updated: string[];
+    unchanged: string[];
+}>;
+export declare function inspectDaemonDiagnostics(): Promise<DaemonDiagnosticSnapshot>;

package/dist/setup-service.js

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { listAgentSpecs } from "@rynx-ai/core";
+import { createChromeForTestingArtifactStore, isChromeForTestingHostSupported } from "./chrome-for-testing-store.js";
+import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
+import { dbPath } from "./db.js";
+import { listPlugins } from "./plugin-store.js";
+export async function prepareBundledPlugins() {
+    return ensureBundledOfficialPlugins();
+}
+export async function inspectDaemonDiagnostics() {
+    const databasePath = dbPath();
+    let browser;
+    if (!isChromeForTestingHostSupported()) {
+        browser = { supported: false };
+    }
+    else {
+        try {
+            const installed = createChromeForTestingArtifactStore().readActive();
+            browser = {
+                supported: true,
+                ...(installed ? { installedVersion: installed.version } : {}),
+            };
+        }
+        catch (error) {
+            browser = {
+                supported: true,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    return {
+        databasePath,
+        databaseExists: existsSync(databasePath),
+        pluginCount: existsSync(databasePath) ? listPlugins().length : 0,
+        agentCount: (await listAgentSpecs()).length,
+        browser,
+    };
+}

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.2",
+  "version": "0.1.11-beta.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
     "directory": "packages/daemon"
   },
-  "description": "Rynx daemon CLI: supervises the local agent control plane and isolated optional plugin runtimes.",
+  "description": "Rynx resident control-plane service and standalone lifecycle implementation.",
   "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -16,38 +19,48 @@
     "dist",
     "bundled-plugins"
   ],
-  "bin": {
-    "rynx": "./dist/cli.js"
-  },
-  "main": "./dist/index-daemon.js",
   "exports": {
-    "./client": {
-      "types": "./dist/control-client.d.ts",
-      "default": "./dist/control-client.js"
+    "./entry-path": {
+      "types": "./dist/entry-path.d.ts",
+      "default": "./dist/entry-path.js"
+    },
+    "./lifecycle": {
+      "types": "./dist/lifecycle.d.ts",
+      "default": "./dist/lifecycle.js"
+    },
+    "./browser-artifacts": {
+      "types": "./dist/browser-artifacts.d.ts",
+      "default": "./dist/browser-artifacts.js"
+    },
+    "./setup-service": {
+      "types": "./dist/setup-service.d.ts",
+      "default": "./dist/setup-service.js"
+    },
+    "./internal/process": {
+      "types": "./dist/process.d.ts",
+      "default": "./dist/process.js"
     }
   },
   "dependencies": {
-    "@clack/prompts": "^1.6.0",
     "better-sqlite3": "^12.11.1",
     "extract-zip": "2.0.1",
     "pm2": "^6.0.0",
     "tar": "^7.5.19",
     "ws": "^8.21.0",
-    "@rynx-ai/cli": "0.1.11-beta.2",
-    "@rynx-ai/core": "0.1.11-beta.2",
-    "@rynx-ai/emulator": "0.1.11-beta.2",
-    "@rynx-ai/plugin-runner": "0.1.11-beta.2",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.2",
-    "@rynx-ai/protocol": "0.1.11-beta.2",
-    "@rynx-ai/remote-runtime-client": "0.1.11-beta.2",
-    "@rynx-ai/server": "0.1.11-beta.2"
+    "@rynx-ai/core": "0.1.11-beta.3",
+    "@rynx-ai/emulator": "0.1.11-beta.3",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.3",
+    "@rynx-ai/protocol": "0.1.11-beta.3",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.3",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.3",
+    "@rynx-ai/server": "0.1.11-beta.3"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11"
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.3"
   },
   "scripts": {
-    "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/cli.js dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",
+    "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",
     "dev": "tsx watch --tsconfig ../../tsconfig.json src/index-daemon.ts"
   }
 }

package/dist/browser-cli-args.d.ts

@@ -1,20 +0,0 @@
-export type BrowserCliSubcommand = "install" | "update" | "version" | "clean" | "open" | "status" | "pages" | "endpoint" | "close";
-export interface BrowserCliArgs {
-    subcommand: BrowserCliSubcommand;
-    json: boolean;
-    ensure: boolean;
-    channel?: string;
-    version?: string;
-    runtime?: string;
-    session?: string;
-    url?: string;
-}
-export interface BrowserCliTarget {
-    runtimeSelector: string;
-    sessionId: string;
-    credential?: RuntimeBrowserBootstrapCredential;
-}
-export declare function parseBrowserCliArgs(args: readonly string[]): BrowserCliArgs;
-/** Resolve authority without ever turning a managed Session into an operator. */
-export declare function resolveBrowserCliTarget(args: BrowserCliArgs, managedCredential: RuntimeBrowserBootstrapCredential | undefined): BrowserCliTarget;
-import type { RuntimeBrowserBootstrapCredential } from "@rynx-ai/protocol/runtime-browser-bootstrap";

package/dist/browser-cli-args.js

@@ -1,100 +0,0 @@
-const SPECS = {
-    install: { values: ["--channel", "--version"], flags: ["--json"] },
-    update: { values: ["--channel"], flags: ["--json"] },
-    version: { values: [], flags: ["--json"] },
-    clean: { values: [], flags: ["--json"] },
-    open: {
-        values: ["--url", "--session", "--runtime"],
-        flags: ["--json"],
-        positionalUrl: true,
-    },
-    status: { values: ["--session", "--runtime"], flags: ["--json"] },
-    pages: { values: ["--session", "--runtime"], flags: ["--json"] },
-    endpoint: { values: ["--session"], flags: ["--ensure", "--json"] },
-    close: { values: ["--session", "--runtime"], flags: ["--json"] },
-};
-export function parseBrowserCliArgs(args) {
-    const subcommand = args[0];
-    if (!isBrowserSubcommand(subcommand)) {
-        throw new Error("browser: expected install, update, version, clean, open, status, pages, endpoint, or close");
-    }
-    const spec = SPECS[subcommand];
-    const values = new Map();
-    const flags = new Set();
-    const positionals = [];
-    for (let index = 1; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg.startsWith("--")) {
-            if (spec.flags.includes(arg)) {
-                if (flags.has(arg))
-                    throw new Error(`browser ${subcommand}: duplicate option ${arg}`);
-                flags.add(arg);
-                continue;
-            }
-            if (spec.values.includes(arg)) {
-                if (values.has(arg))
-                    throw new Error(`browser ${subcommand}: duplicate option ${arg}`);
-                const value = args[index + 1];
-                if (!value || value.startsWith("--")) {
-                    throw new Error(`browser ${subcommand}: ${arg} requires a value`);
-                }
-                values.set(arg, value);
-                index += 1;
-                continue;
-            }
-            throw new Error(`browser ${subcommand}: unknown option ${arg}`);
-        }
-        positionals.push(arg);
-    }
-    if (!spec.positionalUrl && positionals.length > 0) {
-        throw new Error(`browser ${subcommand}: unexpected argument ${positionals[0]}`);
-    }
-    if (positionals.length > 1) {
-        throw new Error(`browser ${subcommand}: unexpected extra argument ${positionals[1]}`);
-    }
-    if (positionals.length === 1 && values.has("--url")) {
-        throw new Error("browser open: pass the URL once, either positionally or with --url");
-    }
-    return {
-        subcommand,
-        json: flags.has("--json"),
-        ensure: flags.has("--ensure"),
-        ...(values.has("--channel") ? { channel: values.get("--channel") } : {}),
-        ...(values.has("--version") ? { version: values.get("--version") } : {}),
-        ...(values.has("--runtime") ? { runtime: values.get("--runtime") } : {}),
-        ...(values.has("--session") ? { session: values.get("--session") } : {}),
-        ...(values.has("--url") || positionals[0]
-            ? { url: values.get("--url") ?? positionals[0] }
-            : {}),
-    };
-}
-/** Resolve authority without ever turning a managed Session into an operator. */
-export function resolveBrowserCliTarget(args, managedCredential) {
-    const runtimeSelector = args.runtime ?? "local";
-    if (runtimeSelector !== "local") {
-        if (managedCredential) {
-            throw new Error("browser: a managed Session cannot select another Runtime");
-        }
-        if (!args.session) {
-            throw new Error("browser: --session is required when selecting a remote Runtime");
-        }
-        return { runtimeSelector, sessionId: args.session };
-    }
-    if (managedCredential) {
-        if (args.session && args.session !== managedCredential.sessionId) {
-            throw new Error("browser: a managed Session cannot control another Session with --session");
-        }
-        return {
-            runtimeSelector: "local",
-            sessionId: managedCredential.sessionId,
-            credential: managedCredential,
-        };
-    }
-    if (!args.session) {
-        throw new Error("browser: run inside a managed Rynx Session or pass --session for operator access");
-    }
-    return { runtimeSelector: "local", sessionId: args.session };
-}
-function isBrowserSubcommand(value) {
-    return value !== undefined && Object.hasOwn(SPECS, value);
-}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};