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

package/dist/skills-catalog.js

@@ -4,13 +4,19 @@
  * env-build share one implementation; this module is the daemon-facing wrapper
  * plus the read-only detail/file helpers the Skills page uses.
  */
-import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { cp, mkdir, mkdtemp, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
-import { extractSkillFrontmatter, installIntoCatalog, rynxSkillsDir, scanSkillsDir, readSkillMeta, } from "@rynx-ai/core";
-/** Catalog skill ids are kebab-case (matches the SKILL.md `name` convention). */
-const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+import extractZipArchive from "extract-zip";
+import { extractSkillFrontmatter, assertSkillPathComponent, installIntoCatalog, collectLocalSkillBundlesInWorker, collectSkillBundlesFromDirectory, scanLocalSkillCandidatesInWorker, rynxSkillsDir, rynxSkillArtifactDir, rynxSkillArtifactsDir, scanSkillsDir, readSkillMeta, writeSkillInstallInfo, } from "@rynx-ai/core";
 /** A single file's contents are capped to keep responses small. */
 const MAX_SKILL_FILE_BYTES = 256 * 1024;
+const MAX_ARCHIVE_ENTRIES = 1_000;
+const MAX_ARCHIVE_EXTRACTED_BYTES = 24 * 1024 * 1024;
+/** Concurrent Control API requests for the same Skill are serialized so the
+ * catalog's backup/swap transaction cannot interleave. */
+const localRegistrationTails = new Map();
 export function listCatalogSkills() {
     return listMergedSkills();
 }
@@ -22,10 +28,91 @@ export async function installCatalogSkill(recipe) {
     await installIntoCatalog(recipe, rynxSkillsDir());
     return listMergedSkills();
 }
+export function scanLocalCatalogSkillCandidates(runtime) {
+    return scanLocalSkillCandidatesInWorker(runtime);
+}
+/**
+ * Register complete local runtime Skill bundles into the owner catalog. Every
+ * content hash gets a durable immutable artifact; the mutable catalog entry's
+ * receipt points at that artifact so old Agent specs keep their exact bytes
+ * after a later catalog update.
+ */
+export async function importLocalCatalogSkills(runtime, keys) {
+    const collected = await collectLocalSkillBundlesInWorker(runtime, keys);
+    return registerCollectedBundles(collected);
+}
+export async function importCatalogSkillsFromArchive(filename, contentBase64) {
+    if (!filename.toLowerCase().endsWith(".zip"))
+        throw new Error("archive must be a .zip file");
+    const content = Buffer.from(contentBase64, "base64");
+    if (content.byteLength === 0)
+        throw new Error("archive is empty");
+    if (content.byteLength > 20 * 1024 * 1024)
+        throw new Error("archive exceeds the 20 MB limit");
+    const staging = await mkdtemp(path.join(tmpdir(), "rynx-skill-archive-"));
+    const archive = path.join(staging, "upload.zip");
+    const extracted = path.join(staging, "extracted");
+    try {
+        await writeFile(archive, content);
+        await mkdir(extracted, { recursive: true });
+        let entryCount = 0;
+        let extractedBytes = 0;
+        await extractZipArchive(archive, {
+            dir: extracted,
+            onEntry: (entry) => {
+                entryCount += 1;
+                extractedBytes += entry.uncompressedSize;
+                if (entryCount > MAX_ARCHIVE_ENTRIES) {
+                    throw new Error(`archive exceeds the ${MAX_ARCHIVE_ENTRIES}-entry limit`);
+                }
+                if (extractedBytes > MAX_ARCHIVE_EXTRACTED_BYTES) {
+                    throw new Error("archive exceeds the 24 MB extracted-size limit");
+                }
+            },
+        });
+        const collected = collectSkillBundlesFromDirectory(extracted);
+        if (collected.bundles.length === 0 && collected.failures.length === 0) {
+            return [{
+                    status: "failed",
+                    name: path.basename(filename, path.extname(filename)),
+                    sourcePath: filename,
+                    message: "No valid Skill bundle was found in the archive.",
+                }];
+        }
+        return registerCollectedBundles({
+            bundles: collected.bundles.map((bundle) => ({ ...bundle, sourcePath: filename })),
+            failures: collected.failures.map((failure) => ({ ...failure, sourcePath: filename })),
+        });
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+async function registerCollectedBundles(collected) {
+    const results = collected.failures.map((failure) => ({
+        status: "failed",
+        name: failure.name,
+        ...(failure.sourcePath ? { sourcePath: failure.sourcePath } : {}),
+        message: failure.message,
+    }));
+    for (const bundle of collected.bundles) {
+        try {
+            results.push(await registerLocalBundle(bundle));
+        }
+        catch (error) {
+            results.push({
+                status: "failed",
+                name: bundle.name,
+                sourcePath: bundle.sourcePath,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
 /** Detail for one catalog skill: its metadata + the file tree under its dir. */
 export async function getCatalogSkill(name) {
-    if (!SKILL_NAME_PATTERN.test(name))
-        throw new Error(`invalid skill name: ${name}`);
+    assertSkillPathComponent(name);
     const dir = path.join(rynxSkillsDir(), name);
     const meta = await readSkillMeta(dir);
     if (!meta)
@@ -62,8 +149,7 @@ async function walkSkillFiles(root, dir) {
 /** Read one text file inside a catalog skill. Path-confined to the skill dir,
  *  size-capped, and binary files are rejected. */
 export async function readCatalogSkillFile(name, relPath) {
-    if (!SKILL_NAME_PATTERN.test(name))
-        throw new Error(`invalid skill name: ${name}`);
+    assertSkillPathComponent(name);
     const dir = path.resolve(path.join(rynxSkillsDir(), name));
     const target = path.resolve(dir, relPath);
     if (target !== dir && !target.startsWith(dir + path.sep)) {
@@ -82,10 +168,221 @@ export async function readCatalogSkillFile(name, relPath) {
 async function listMergedSkills() {
     return (await scanSkillsDir(rynxSkillsDir())).sort((a, b) => a.name.localeCompare(b.name));
 }
+async function registerLocalBundle(bundle) {
+    const previous = localRegistrationTails.get(bundle.name) ?? Promise.resolve();
+    const pending = previous.catch(() => undefined).then(() => registerLocalBundleUnlocked(bundle));
+    localRegistrationTails.set(bundle.name, pending);
+    try {
+        return await pending;
+    }
+    finally {
+        if (localRegistrationTails.get(bundle.name) === pending) {
+            localRegistrationTails.delete(bundle.name);
+        }
+    }
+}
+async function registerLocalBundleUnlocked(bundle) {
+    const catalogRoot = rynxSkillsDir();
+    const currentDir = path.join(catalogRoot, bundle.name);
+    const existing = await readSkillMeta(currentDir);
+    if (existing?.ref && !isManagedLocalArtifact(existing.ref.install)) {
+        return {
+            status: "conflict",
+            name: bundle.name,
+            sourcePath: bundle.sourcePath,
+            skill: toSummary(existing),
+            message: "A Skill with this name is registered from another source.",
+        };
+    }
+    if (existing?.ref?.contentHash === bundle.contentHash) {
+        return {
+            status: "skipped",
+            name: bundle.name,
+            sourcePath: bundle.sourcePath,
+            skill: toSummary(existing),
+            message: "Skill is already up to date.",
+        };
+    }
+    if (await pathExists(currentDir) && !existing) {
+        return {
+            status: "conflict",
+            name: bundle.name,
+            sourcePath: bundle.sourcePath,
+            message: "A receipt-less Skill with this name already exists. Remove it before importing.",
+        };
+    }
+    const artifactDir = rynxSkillArtifactDir(bundle.name, bundle.contentHash);
+    await materializeArtifact(bundle, artifactDir);
+    const ref = {
+        name: bundle.name,
+        install: { tool: "skills-cli", source: artifactDir },
+        contentHash: bundle.contentHash,
+    };
+    await mkdir(catalogRoot, { recursive: true });
+    const stagingRoot = await mkdtemp(path.join(catalogRoot, `.import-${bundle.name}-`));
+    const stagedDir = path.join(stagingRoot, bundle.name);
+    const backupDir = path.join(catalogRoot, `.backup-${bundle.name}-${process.pid}-${randomUUID()}`);
+    let backedUp = false;
+    try {
+        await cp(artifactDir, stagedDir, { recursive: true });
+        await writeSkillInstallInfo(stagedDir, ref);
+        if (await pathExists(currentDir)) {
+            await rename(currentDir, backupDir);
+            backedUp = true;
+        }
+        try {
+            await rename(stagedDir, currentDir);
+        }
+        catch (error) {
+            if (backedUp) {
+                await rename(backupDir, currentDir);
+                backedUp = false;
+            }
+            throw error;
+        }
+        if (backedUp) {
+            await rm(backupDir, { recursive: true, force: true });
+            backedUp = false;
+        }
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+        if (backedUp && !(await pathExists(currentDir))) {
+            await rename(backupDir, currentDir);
+        }
+    }
+    const meta = await readSkillMeta(currentDir);
+    if (!meta)
+        throw new Error("Imported Skill failed catalog validation");
+    return {
+        status: existing ? "updated" : "created",
+        name: meta.name,
+        sourcePath: bundle.sourcePath,
+        skill: toSummary(meta),
+    };
+}
+async function materializeArtifact(bundle, artifactDir) {
+    if (await pathExists(artifactDir)) {
+        if (await artifactMatchesBundle(bundle, artifactDir))
+            return;
+        throw new Error("Immutable Skill artifact already exists but does not match its content hash");
+    }
+    const artifactsRoot = rynxSkillArtifactsDir();
+    await mkdir(artifactsRoot, { recursive: true });
+    const stagingRoot = await mkdtemp(path.join(artifactsRoot, `.artifact-${bundle.name}-`));
+    const stagedDir = path.join(stagingRoot, bundle.name);
+    try {
+        await mkdir(stagedDir, { recursive: true });
+        const aggregate = createHash("sha256");
+        for (const file of [...bundle.files].sort((left, right) => left.path.localeCompare(right.path))) {
+            const relative = normalizeBundlePath(file.path);
+            const content = Buffer.from(file.contentBase64, "base64");
+            if (content.byteLength !== file.sizeBytes)
+                throw new Error(`Skill file size mismatch: ${relative}`);
+            const sha256 = createHash("sha256").update(content).digest("hex");
+            if (sha256 !== file.sha256)
+                throw new Error(`Skill file hash mismatch: ${relative}`);
+            aggregate.update(relative);
+            aggregate.update("\0");
+            aggregate.update(sha256);
+            aggregate.update("\0");
+            aggregate.update(String(content.byteLength));
+            aggregate.update("\0");
+            const target = path.join(stagedDir, ...relative.split("/"));
+            await mkdir(path.dirname(target), { recursive: true });
+            await writeFile(target, content);
+        }
+        if (aggregate.digest("hex") !== bundle.contentHash)
+            throw new Error("Skill bundle hash mismatch");
+        const parent = path.dirname(artifactDir);
+        await mkdir(parent, { recursive: true });
+        try {
+            await rename(stagedDir, artifactDir);
+        }
+        catch (error) {
+            if (await artifactMatchesBundle(bundle, artifactDir))
+                return;
+            throw error;
+        }
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+    }
+}
+async function artifactMatchesBundle(bundle, artifactDir) {
+    try {
+        const actualFiles = await walkArtifactFiles(artifactDir, artifactDir);
+        const expectedFiles = [...bundle.files].sort((left, right) => left.path.localeCompare(right.path));
+        if (!actualFiles || actualFiles.length !== expectedFiles.length)
+            return false;
+        for (let index = 0; index < expectedFiles.length; index += 1) {
+            const expected = expectedFiles[index];
+            if (actualFiles[index] !== expected.path)
+                return false;
+            const content = await readFile(path.join(artifactDir, ...expected.path.split("/")));
+            if (content.byteLength !== expected.sizeBytes)
+                return false;
+            if (createHash("sha256").update(content).digest("hex") !== expected.sha256)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function walkArtifactFiles(root, dir) {
+    const files = [];
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        if (entry.isSymbolicLink())
+            return null;
+        const absolute = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await walkArtifactFiles(root, absolute);
+            if (!nested)
+                return null;
+            files.push(...nested);
+        }
+        else if (entry.isFile()) {
+            files.push(normalizeBundlePath(path.relative(root, absolute)));
+        }
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+function normalizeBundlePath(value) {
+    const parts = value.replace(/\\/g, "/").split("/");
+    if (parts.some((part) => !part || part === "." || part === "..")) {
+        throw new Error(`Invalid Skill file path: ${value}`);
+    }
+    return parts.join("/");
+}
+function isManagedLocalArtifact(recipe) {
+    if (recipe.tool !== "skills-cli" || !path.isAbsolute(recipe.source))
+        return false;
+    const root = path.resolve(rynxSkillArtifactsDir());
+    const source = path.resolve(recipe.source);
+    const relative = path.relative(root, source);
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function toSummary(meta) {
+    return {
+        name: meta.name,
+        description: meta.description,
+        ...(meta.ref ? { ref: meta.ref } : {}),
+    };
+}
+async function pathExists(value) {
+    try {
+        await stat(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** Remove a catalog skill by name. Returns false if it wasn't present. */
 export async function removeCatalogSkill(name) {
-    if (!SKILL_NAME_PATTERN.test(name))
-        throw new Error(`invalid skill name: ${name}`);
+    assertSkillPathComponent(name);
     const dir = path.join(rynxSkillsDir(), name);
     try {
         await stat(dir);

package/dist/sqlite.d.ts

@@ -0,0 +1,22 @@
+import { type DatabaseSync, type StatementSync } from "node:sqlite";
+type SQLiteInput = null | number | bigint | string | NodeJS.ArrayBufferView;
+type SQLiteParameter = SQLiteInput | Record<string, SQLiteInput>;
+type SQLiteOutput = null | number | bigint | string | Uint8Array;
+export type SQLiteTransaction<Args extends unknown[], Result> = ((...args: Args) => Result) & {
+    deferred: (...args: Args) => Result;
+    immediate: (...args: Args) => Result;
+    exclusive: (...args: Args) => Result;
+};
+/** Wrap a synchronous operation in a SQLite transaction. Nested calls use savepoints. */
+export declare function transaction<Args extends unknown[], Result>(connection: DatabaseSync, operation: (...args: Args) => Result): SQLiteTransaction<Args, Result>;
+/** Return only the first column from a native statement, matching scalar-query intent. */
+export declare function scalar(statement: StatementSync): {
+    get(...parameters: SQLiteParameter[]): SQLiteOutput | undefined;
+    all(...parameters: SQLiteParameter[]): SQLiteOutput[];
+};
+/** Match a primary SQLite result code, including extended result codes. */
+export declare function hasSqlitePrimaryCode(error: unknown, primaryCode: number): boolean;
+export declare const SQLITE_BUSY = 5;
+export declare const SQLITE_LOCKED = 6;
+export declare const SQLITE_CONSTRAINT = 19;
+export {};

package/dist/sqlite.js

@@ -0,0 +1,57 @@
+let nextSavepointId = 0;
+/** Wrap a synchronous operation in a SQLite transaction. Nested calls use savepoints. */
+export function transaction(connection, operation) {
+    const run = (mode, args) => {
+        if (connection.isTransaction) {
+            const savepoint = `rynx_transaction_${++nextSavepointId}`;
+            connection.exec(`SAVEPOINT ${savepoint}`);
+            try {
+                const result = operation(...args);
+                connection.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                return result;
+            }
+            catch (error) {
+                if (connection.isTransaction) {
+                    connection.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+                    connection.exec(`RELEASE SAVEPOINT ${savepoint}`);
+                }
+                throw error;
+            }
+        }
+        connection.exec(`BEGIN ${mode}`);
+        try {
+            const result = operation(...args);
+            connection.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            if (connection.isTransaction)
+                connection.exec("ROLLBACK");
+            throw error;
+        }
+    };
+    const wrapped = ((...args) => run("DEFERRED", args));
+    wrapped.deferred = (...args) => run("DEFERRED", args);
+    wrapped.immediate = (...args) => run("IMMEDIATE", args);
+    wrapped.exclusive = (...args) => run("EXCLUSIVE", args);
+    return wrapped;
+}
+/** Return only the first column from a native statement, matching scalar-query intent. */
+export function scalar(statement) {
+    statement.setReturnArrays(true);
+    const arrayStatement = statement;
+    return {
+        get: (...parameters) => arrayStatement.get(...parameters)?.[0],
+        all: (...parameters) => arrayStatement.all(...parameters).map((row) => row[0]),
+    };
+}
+/** Match a primary SQLite result code, including extended result codes. */
+export function hasSqlitePrimaryCode(error, primaryCode) {
+    if (!error || typeof error !== "object" || !("errcode" in error))
+        return false;
+    const errcode = error.errcode;
+    return typeof errcode === "number" && (errcode & 0xff) === primaryCode;
+}
+export const SQLITE_BUSY = 5;
+export const SQLITE_LOCKED = 6;
+export const SQLITE_CONSTRAINT = 19;

package/dist/system-dependencies.d.ts

@@ -0,0 +1,22 @@
+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 {
+    runCommand?: SystemDependencyCommandRunner;
+    tmuxBin: string;
+}
+export declare function inspectSystemDependencies(options: SystemDependencyOptions): Promise<SystemDependencySnapshot>;

package/dist/system-dependencies.js

@@ -0,0 +1,79 @@
+import { execFile } from "node:child_process";
+const PROBE_TIMEOUT_MS = 10_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, options.tmuxBin);
+    return {
+        tmux: probe.installed
+            ? { installed: true }
+            : { installed: false, detail: probe.detail },
+    };
+}
+/**
+ * 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, tmuxBin) {
+    const version = await runCommand(tmuxBin, ["-V"], { timeoutMs: PROBE_TIMEOUT_MS });
+    if (version.exitCode !== 0) {
+        return {
+            installed: false,
+            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(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,
+            detail: `${version.stdout.trim() || "tmux"} is installed but cannot start a server: ` +
+                commandFailure(functional),
+        };
+    }
+    return { installed: true };
+}
+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) => {
+        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,13 +1,16 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.2",
+  "version": "0.1.11-beta.21",
   "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.16"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -16,38 +19,51 @@
     "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"
+    },
+    "./plugin-cli": {
+      "types": "./dist/plugin-cli.d.ts",
+      "default": "./dist/plugin-cli.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.21",
+    "@rynx-ai/emulator": "0.1.11-beta.21",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.21",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.21",
+    "@rynx-ai/protocol": "0.1.11-beta.21",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.21",
+    "@rynx-ai/server": "0.1.11-beta.21"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11"
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.21"
   },
   "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"
   }
 }