@rynx-ai/daemon 0.1.10 → 0.1.11-beta.10

package/dist/system-dependencies.js

@@ -0,0 +1,149 @@
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+const PROBE_TIMEOUT_MS = 10_000;
+const INSTALL_TIMEOUT_MS = 5 * 60_000;
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+export async function inspectSystemDependencies(options = {}) {
+    const runCommand = options.runCommand ?? runSystemDependencyCommand;
+    const probe = await probeTmux(runCommand);
+    return {
+        tmux: probe.installed
+            ? { installed: true }
+            : { installed: false, detail: probe.detail },
+    };
+}
+export async function ensureSystemDependencies(options = {}) {
+    const runCommand = options.runCommand ?? runSystemDependencyCommand;
+    const before = await probeTmux(runCommand);
+    if (before.installed)
+        return { tmux: { installed: true } };
+    if (before.binaryPresent) {
+        throw new Error(before.detail);
+    }
+    const platform = options.platform ?? process.platform;
+    const findSystemExecutable = options.findSystemExecutable ?? findSystemCommand;
+    const manager = await resolvePackageManager(platform, findSystemExecutable);
+    if (!manager) {
+        throw new Error(platform === "darwin"
+            ? "tmux is required for live Sessions, but Homebrew is unavailable; install tmux and retry"
+            : "tmux is required for live Sessions, but no supported package manager (apt-get, dnf, or yum) is available");
+    }
+    const installArgs = manager.family === "apt"
+        ? ["install", "-y", "--no-install-recommends", "tmux"]
+        : manager.family === "brew"
+            ? ["install", "tmux"]
+            : ["install", "-y", "tmux"];
+    let command = manager.path;
+    let args = installArgs;
+    if (manager.family !== "brew") {
+        const getuid = options.getuid ?? (() => process.getuid?.());
+        if (getuid() !== 0) {
+            const sudo = await findSystemExecutable("sudo");
+            const sudoReady = sudo
+                ? await runCommand(sudo, ["-n", "true"], { timeoutMs: PROBE_TIMEOUT_MS })
+                : undefined;
+            if (!sudo || sudoReady?.exitCode !== 0) {
+                throw new Error(`tmux is required for live Sessions; install it as an administrator and retry: ` +
+                    `${manager.commandForHumans} install -y tmux`);
+            }
+            command = sudo;
+            args = ["-n", manager.path, ...installArgs];
+        }
+    }
+    options.onProgress?.("installing required system dependency: tmux");
+    const installed = await runCommand(command, args, { timeoutMs: INSTALL_TIMEOUT_MS });
+    if (installed.exitCode !== 0) {
+        throw new Error(`failed to install required system dependency tmux: ${commandFailure(installed)}`);
+    }
+    const after = await inspectSystemDependencies({ runCommand });
+    if (!after.tmux.installed) {
+        throw new Error(`tmux installation completed but tmux is still unavailable: ${after.tmux.detail}`);
+    }
+    options.onProgress?.("verified required system dependency: tmux");
+    return after;
+}
+/**
+ * A version probe only proves the binary can start. Live Sessions need tmux to
+ * create a server and socket, so exercise that path with a private probe server
+ * that cannot interfere with a user's existing tmux sessions.
+ */
+async function probeTmux(runCommand) {
+    const version = await runCommand("tmux", ["-V"], { timeoutMs: PROBE_TIMEOUT_MS });
+    if (version.exitCode !== 0) {
+        return {
+            installed: false,
+            binaryPresent: version.errorCode !== "ENOENT",
+            detail: `tmux -V failed: ${commandFailure(version)}`,
+        };
+    }
+    const socketName = `rynx-setup-probe-${process.pid}-${Date.now()}`;
+    const functional = await runCommand("tmux", ["-L", socketName, "new-session", "-d", "-s", "probe", "true"], { timeoutMs: PROBE_TIMEOUT_MS });
+    await runCommand("tmux", ["-L", socketName, "kill-server"], {
+        timeoutMs: PROBE_TIMEOUT_MS,
+    });
+    if (functional.exitCode !== 0) {
+        return {
+            installed: false,
+            binaryPresent: true,
+            detail: `${version.stdout.trim() || "tmux"} is installed but cannot start a server: ` +
+                commandFailure(functional),
+        };
+    }
+    return { installed: true, binaryPresent: true };
+}
+async function resolvePackageManager(platform, findExecutable) {
+    if (platform === "darwin") {
+        const brew = await findExecutable("brew");
+        return brew ? { family: "brew", path: brew, commandForHumans: "brew" } : undefined;
+    }
+    if (platform !== "linux")
+        return undefined;
+    const apt = await findExecutable("apt-get");
+    if (apt)
+        return { family: "apt", path: apt, commandForHumans: "apt-get" };
+    const dnf = await findExecutable("dnf");
+    if (dnf)
+        return { family: "rpm", path: dnf, commandForHumans: "dnf" };
+    const yum = await findExecutable("yum");
+    return yum ? { family: "rpm", path: yum, commandForHumans: "yum" } : undefined;
+}
+async function findSystemCommand(name) {
+    const directories = name === "brew"
+        ? ["/opt/homebrew/bin", "/usr/local/bin"]
+        : ["/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+    for (const directory of directories) {
+        const candidate = `${directory}/${name}`;
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try the next standard system directory.
+        }
+    }
+    return undefined;
+}
+function runSystemDependencyCommand(command, args, options) {
+    return new Promise((resolveResult) => {
+        execFile(command, [...args], {
+            encoding: "utf8",
+            env: { ...process.env, DEBIAN_FRONTEND: "noninteractive", LC_ALL: "C" },
+            maxBuffer: MAX_OUTPUT_BYTES,
+            timeout: options.timeoutMs,
+        }, (error, stdout, stderr) => {
+            resolveResult({
+                exitCode: error
+                    ? typeof error.code === "number" ? error.code : null
+                    : 0,
+                stdout,
+                stderr,
+                ...(error && typeof error.code === "string" ? { errorCode: error.code } : {}),
+            });
+        });
+    });
+}
+function commandFailure(result) {
+    const detail = result.stderr.trim() || result.stdout.trim() || result.errorCode;
+    return detail ? detail.slice(0, 2_000) : `exit code ${result.exitCode ?? "unknown"}`;
+}

package/package.json

@@ -1,50 +1,66 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.10",
+  "version": "0.1.11-beta.10",
   "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"
   },
   "files": [
-    "dist"
+    "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/emulator": "0.1.10",
-    "@rynx-ai/plugin-runner": "0.1.10",
-    "@rynx-ai/core": "0.1.10",
-    "@rynx-ai/protocol": "0.1.10",
-    "@rynx-ai/remote-runtime-client": "0.1.10",
-    "@rynx-ai/plugin-sdk": "0.1.10",
-    "@rynx-ai/server": "0.1.10"
+    "@rynx-ai/core": "0.1.11-beta.10",
+    "@rynx-ai/emulator": "0.1.11-beta.10",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.10",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.10",
+    "@rynx-ai/protocol": "0.1.11-beta.10",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.10",
+    "@rynx-ai/server": "0.1.11-beta.10"
   },
   "devDependencies": {
-    "@types/ws": "^8.18.1"
+    "@types/ws": "^8.18.1",
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.10"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/cli.js dist/index-daemon.js",
+    "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/channel-store.d.ts

@@ -1,22 +0,0 @@
-export interface ChannelConfig {
-    /** Stable system-assigned id (never changes). */
-    id: string;
-    /** Human-visible, unique, editable label. */
-    name: string;
-    /** Channel type (which plugin-contributed factory). */
-    type: string;
-    options?: Record<string, unknown>;
-}
-export declare function listChannels(): ChannelConfig[];
-export declare function getChannel(id: string): ChannelConfig | undefined;
-/** Create a channel with a system-assigned id and a unique `name` label. */
-export declare function createChannel(input: {
-    name: string;
-    type: string;
-    options?: Record<string, unknown>;
-}): ChannelConfig;
-export declare function renameChannel(id: string, name: string): void;
-/** Merge credentials/options into a channel (e.g. the result of an authorize flow). */
-export declare function setChannelOptions(id: string, options: Record<string, unknown>): void;
-/** Remove a channel; its bound instance (if any) cascades away (FK ON DELETE CASCADE). */
-export declare function removeChannel(id: string): void;

package/dist/channel-store.js

@@ -1,65 +0,0 @@
-/**
- * `channels` table CRUD — a channel is a plugin type + its config/credentials
- * (`options`), configured and authorized on its own. No agent binding here;
- * that lives on an {@link import("./instance-store.js")} instance.
- *
- * Credentials stay in each channel's `options` and are sent only to that
- * plugin runner instance; they are never copied into the daemon environment.
- */
-import { randomUUID } from "node:crypto";
-import { db } from "./db.js";
-function parseOptions(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function toConfig(row) {
-    return { id: row.id, name: row.name, type: row.type, options: parseOptions(row.options) };
-}
-export function listChannels() {
-    const rows = db().prepare("SELECT * FROM channels ORDER BY name").all();
-    return rows.map(toConfig);
-}
-export function getChannel(id) {
-    const row = db().prepare("SELECT * FROM channels WHERE id = ?").get(id);
-    return row ? toConfig(row) : undefined;
-}
-/** Create a channel with a system-assigned id and a unique `name` label. */
-export function createChannel(input) {
-    const id = randomUUID();
-    const now = new Date().toISOString();
-    db()
-        .prepare(`INSERT INTO channels (id, name, type, options, created_at, updated_at)
-       VALUES (@id, @name, @type, @options, @now, @now)`)
-        .run({
-        id,
-        name: input.name,
-        type: input.type,
-        options: input.options ? JSON.stringify(input.options) : null,
-        now,
-    });
-    return getChannel(id);
-}
-export function renameChannel(id, name) {
-    db().prepare("UPDATE channels SET name = ?, updated_at = ? WHERE id = ?").run(name, new Date().toISOString(), id);
-}
-/** Merge credentials/options into a channel (e.g. the result of an authorize flow). */
-export function setChannelOptions(id, options) {
-    const current = getChannel(id);
-    if (!current)
-        return;
-    const merged = { ...(current.options ?? {}), ...options };
-    db()
-        .prepare("UPDATE channels SET options = ?, updated_at = ? WHERE id = ?")
-        .run(JSON.stringify(merged), new Date().toISOString(), id);
-}
-/** Remove a channel; its bound instance (if any) cascades away (FK ON DELETE CASCADE). */
-export function removeChannel(id) {
-    db().prepare("DELETE FROM channels WHERE id = ?").run(id);
-}

package/dist/cli.d.ts

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