@rynx-ai/daemon 0.1.11-beta.14 → 0.1.11-beta.16

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

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

package/dist/lifecycle.d.ts

@@ -4,6 +4,7 @@ export interface StandaloneDaemonLaunchContext {
     builtinSkillsDir: string;
     cliVersion: string;
     productVersion: string;
+    tmuxBin?: string;
 }
 export declare function startDaemon(options: {
     force: boolean;

package/dist/lifecycle.js

@@ -11,6 +11,7 @@ export function startDaemon(options) {
             RYNX_DISTRIBUTION: "standalone",
             RYNX_PRODUCT_VERSION: options.context.productVersion,
             RYNX_DAEMON_LIFECYCLE: "standalone",
+            ...(options.context.tmuxBin ? { RYNX_TMUX_BIN: options.context.tmuxBin } : {}),
         },
     });
 }

package/dist/plugin-cli.d.ts

@@ -20,6 +20,16 @@ export interface PluginCliCommandResult {
         stderrTruncated: boolean;
     };
 }
+export interface InstalledPluginListItem {
+    id: string;
+    version: string;
+    source: "local" | "git";
+    state: "enabled" | "disabled";
+}
+/** Read the durable installed-plugin inventory without contacting the daemon. */
+export declare function listInstalledPlugins(): InstalledPluginListItem[];
+/** Render manifest-declared command help without executing plugin code. */
+export declare function installedPluginCommandUsage(pluginId: string): string;
 /** Execute one statically declared, language-neutral plugin command. */
 export declare function runPluginCliCommand(pluginId: string, args: readonly string[], options?: RunPluginCliOptions): Promise<PluginCliCommandResult>;
 export declare function pluginCommandUsage(record: RunnablePluginRecord): string;

package/dist/plugin-cli.js

@@ -6,10 +6,26 @@ import { db } from "./db.js";
 import { transaction } from "./sqlite.js";
 import { pluginDataDir, pluginRuntimeCacheDir } from "./plugin-installer.js";
 import { validatePluginPackageSnapshot } from "./plugin-package.js";
-import { getPlugin } from "./plugin-store.js";
+import { getPlugin, listPlugins, } from "./plugin-store.js";
 import { loadOrCreateDaemonInstallationIdentitySync } from "./installation-id.js";
 const DEFAULT_TERMINATION_GRACE_MS = 2_000;
 const MAX_TERMINATION_GRACE_MS = 30_000;
+/** Read the durable installed-plugin inventory without contacting the daemon. */
+export function listInstalledPlugins() {
+    return listPlugins().map((record) => ({
+        id: record.canonicalId,
+        version: record.version,
+        source: record.source,
+        state: record.enabled ? "enabled" : "disabled",
+    }));
+}
+/** Render manifest-declared command help without executing plugin code. */
+export function installedPluginCommandUsage(pluginId) {
+    const record = getPlugin(pluginId);
+    if (!record)
+        throw new Error(`plugin "${pluginId}" is not installed`);
+    return pluginCommandUsage(record);
+}
 /** Execute one statically declared, language-neutral plugin command. */
 export async function runPluginCliCommand(pluginId, args, options = {}) {
     const hostEnv = options.env ?? process.env;

package/dist/setup-service.d.ts

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

package/dist/setup-service.js

@@ -4,7 +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 { inspectSystemDependencies, verifySystemDependencies, } from "./system-dependencies.js";
 export async function prepareBundledPlugins() {
     return ensureBundledOfficialPlugins();
 }

package/dist/system-dependencies.d.ts

@@ -16,11 +16,9 @@ export interface SystemDependencyCommandOptions {
 }
 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;
+    tmuxBin?: string;
 }
-export declare function inspectSystemDependencies(options?: Pick<SystemDependencyOptions, "runCommand">): Promise<SystemDependencySnapshot>;
-export declare function ensureSystemDependencies(options?: SystemDependencyOptions): Promise<SystemDependencySnapshot>;
+export declare function inspectSystemDependencies(options?: Pick<SystemDependencyOptions, "runCommand" | "tmuxBin">): Promise<SystemDependencySnapshot>;
+/** Validate the selected executable without installing or changing the host. */
+export declare function verifySystemDependencies(options?: SystemDependencyOptions): Promise<SystemDependencySnapshot>;

package/dist/system-dependencies.js

@@ -1,128 +1,65 @@
 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;
+const MINIMUM_TMUX_VERSION = { major: 3, minor: 4 };
 export async function inspectSystemDependencies(options = {}) {
     const runCommand = options.runCommand ?? runSystemDependencyCommand;
-    const probe = await probeTmux(runCommand);
+    const probe = await probeTmux(runCommand, options.tmuxBin ?? "tmux");
     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?.("正在安装系统依赖 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?.("tmux 安装并验证完成");
-    return after;
+/** Validate the selected executable without installing or changing the host. */
+export async function verifySystemDependencies(options = {}) {
+    const snapshot = await inspectSystemDependencies(options);
+    if (!snapshot.tmux.installed)
+        throw new Error(snapshot.tmux.detail);
+    return snapshot;
 }
 /**
  * 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 });
+async function probeTmux(runCommand, tmuxBin) {
+    const version = await runCommand(tmuxBin, ["-V"], { timeoutMs: PROBE_TIMEOUT_MS });
     if (version.exitCode !== 0) {
         return {
             installed: false,
-            binaryPresent: version.errorCode !== "ENOENT",
             detail: `tmux -V failed: ${commandFailure(version)}`,
         };
     }
+    if (!isSupportedTmuxVersion(version.stdout)) {
+        return {
+            installed: false,
+            detail: `${version.stdout.trim() || tmuxBin} is too old; ` +
+                `Rynx requires tmux ${MINIMUM_TMUX_VERSION.major}.${MINIMUM_TMUX_VERSION.minor} or newer`,
+        };
+    }
     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"], {
+    const functional = await runCommand(tmuxBin, ["-L", socketName, "new-session", "-d", "-s", "probe", "true"], { timeoutMs: PROBE_TIMEOUT_MS });
+    await runCommand(tmuxBin, ["-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 };
+    return { installed: 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 isSupportedTmuxVersion(stdout) {
+    const match = /^tmux\s+(\d+)\.(\d+)/i.exec(stdout.trim());
+    if (!match)
+        return false;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    return major > MINIMUM_TMUX_VERSION.major ||
+        (major === MINIMUM_TMUX_VERSION.major && minor >= MINIMUM_TMUX_VERSION.minor);
 }
 function runSystemDependencyCommand(command, args, options) {
     return new Promise((resolveResult) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.14",
+  "version": "0.1.11-beta.16",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -36,6 +36,10 @@
       "types": "./dist/setup-service.d.ts",
       "default": "./dist/setup-service.js"
     },
+    "./plugin-cli": {
+      "types": "./dist/plugin-cli.d.ts",
+      "default": "./dist/plugin-cli.js"
+    },
     "./internal/process": {
       "types": "./dist/process.d.ts",
       "default": "./dist/process.js"
@@ -46,17 +50,17 @@
     "pm2": "^6.0.0",
     "tar": "^7.5.19",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.14",
-    "@rynx-ai/emulator": "0.1.11-beta.14",
-    "@rynx-ai/plugin-runner": "0.1.11-beta.14",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.14",
-    "@rynx-ai/protocol": "0.1.11-beta.14",
-    "@rynx-ai/remote-runtime-client": "0.1.11-beta.14",
-    "@rynx-ai/server": "0.1.11-beta.14"
+    "@rynx-ai/core": "0.1.11-beta.16",
+    "@rynx-ai/emulator": "0.1.11-beta.16",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.16",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.16",
+    "@rynx-ai/protocol": "0.1.11-beta.16",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.16",
+    "@rynx-ai/server": "0.1.11-beta.16"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.14"
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.16"
   },
   "scripts": {
     "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",