@rynx-ai/daemon 0.1.11-beta.6 → 0.1.11-beta.8

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11-beta.6",
+  "version": "0.1.11-beta.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/setup-service.d.ts

@@ -1,3 +1,4 @@
+export { ensureSystemDependencies, inspectSystemDependencies, type SystemDependencySnapshot, } from "./system-dependencies.js";
 export interface DaemonDiagnosticSnapshot {
     databasePath: string;
     databaseExists: boolean;

package/dist/setup-service.js

@@ -4,6 +4,7 @@ import { createChromeForTestingArtifactStore, isChromeForTestingHostSupported }
 import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
 import { dbPath } from "./db.js";
 import { listPlugins } from "./plugin-store.js";
+export { ensureSystemDependencies, inspectSystemDependencies, } from "./system-dependencies.js";
 export async function prepareBundledPlugins() {
     return ensureBundledOfficialPlugins();
 }

package/dist/system-dependencies.d.ts

@@ -0,0 +1,26 @@
+export interface SystemDependencyStatus {
+    installed: boolean;
+    detail?: string;
+}
+export interface SystemDependencySnapshot {
+    tmux: SystemDependencyStatus;
+}
+export interface SystemDependencyCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    errorCode?: string;
+}
+export interface SystemDependencyCommandOptions {
+    timeoutMs: number;
+}
+export type SystemDependencyCommandRunner = (command: string, args: readonly string[], options: SystemDependencyCommandOptions) => Promise<SystemDependencyCommandResult>;
+export interface SystemDependencyOptions {
+    platform?: string;
+    getuid?: () => number | undefined;
+    findSystemExecutable?: (name: string) => Promise<string | undefined>;
+    runCommand?: SystemDependencyCommandRunner;
+    onProgress?: (message: string) => void;
+}
+export declare function inspectSystemDependencies(options?: Pick<SystemDependencyOptions, "runCommand">): Promise<SystemDependencySnapshot>;
+export declare function ensureSystemDependencies(options?: SystemDependencyOptions): Promise<SystemDependencySnapshot>;

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,6 +1,6 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.6",
+  "version": "0.1.11-beta.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -47,17 +47,17 @@
     "pm2": "^6.0.0",
     "tar": "^7.5.19",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.6",
-    "@rynx-ai/emulator": "0.1.11-beta.6",
-    "@rynx-ai/plugin-runner": "0.1.11-beta.6",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.6",
-    "@rynx-ai/protocol": "0.1.11-beta.6",
-    "@rynx-ai/remote-runtime-client": "0.1.11-beta.6",
-    "@rynx-ai/server": "0.1.11-beta.6"
+    "@rynx-ai/core": "0.1.11-beta.8",
+    "@rynx-ai/emulator": "0.1.11-beta.8",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.8",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.8",
+    "@rynx-ai/protocol": "0.1.11-beta.8",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.8",
+    "@rynx-ai/server": "0.1.11-beta.8"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.6"
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.8"
   },
   "scripts": {
     "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",