@rynx-ai/daemon 0.1.0

package/dist/session-log-store.js

@@ -0,0 +1,91 @@
+import { db } from "./db.js";
+function toItem(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        position: row.position,
+        responseId: row.response_id,
+        status: row.status,
+        createdAt: row.created_at,
+        ...(row.created_by ? { createdBy: row.created_by } : {}),
+        type: row.type,
+        data: JSON.parse(row.data),
+    };
+}
+export class SqliteSessionLogStore {
+    async append(sessionId, items) {
+        if (items.length === 0)
+            return [];
+        const conn = db();
+        const insert = conn.prepare(`INSERT INTO session_items
+         (id, session_id, position, response_id, type, status, data, created_by, created_at)
+       VALUES (@id, @session_id, @position, @response_id, @type, @status, @data, @created_by, @created_at)`);
+        const maxStmt = conn.prepare("SELECT MAX(position) AS max FROM session_items WHERE session_id = ?");
+        const tx = conn.transaction((batch) => {
+            const { max } = maxStmt.get(sessionId);
+            let next = (max ?? -1) + 1;
+            return batch.map((item) => {
+                const stored = { ...item, sessionId, position: next++ };
+                insert.run({
+                    id: stored.id,
+                    session_id: sessionId,
+                    position: stored.position,
+                    response_id: stored.responseId,
+                    type: stored.type,
+                    status: stored.status,
+                    data: JSON.stringify(stored.data),
+                    created_by: stored.createdBy ?? null,
+                    created_at: stored.createdAt,
+                });
+                return stored;
+            });
+        });
+        return tx(items);
+    }
+    async list(sessionId, opts = {}) {
+        const conn = db();
+        let afterPosition = -1;
+        if (opts.afterId) {
+            const cursor = conn
+                .prepare("SELECT position FROM session_items WHERE id = ?")
+                .get(opts.afterId);
+            // Unknown cursor ⇒ empty page (rather than silently returning everything).
+            if (!cursor)
+                return [];
+            afterPosition = cursor.position;
+        }
+        const limit = opts.limit ?? -1; // SQLite treats LIMIT -1 as "no limit"
+        const rows = conn
+            .prepare(`SELECT * FROM session_items
+          WHERE session_id = ? AND position > ?
+          ORDER BY position ASC
+          LIMIT ?`)
+            .all(sessionId, afterPosition, limit);
+        return rows.map(toItem);
+    }
+    async snapshot(sessionId) {
+        const rows = db()
+            .prepare("SELECT * FROM session_items WHERE session_id = ? ORDER BY position ASC")
+            .all(sessionId);
+        return rows.map(toItem);
+    }
+    async listSessions(opts = {}) {
+        const limit = opts.limit ?? 200;
+        const rows = db()
+            .prepare(`SELECT session_id, MIN(created_at) AS first_at, MAX(created_at) AS last_at, COUNT(*) AS cnt
+           FROM session_items
+          GROUP BY session_id
+          ORDER BY last_at DESC
+          LIMIT ?`)
+            .all(limit);
+        return rows.map((r) => ({
+            sessionId: r.session_id,
+            createdAt: r.first_at,
+            updatedAt: r.last_at,
+            itemCount: r.cnt,
+        }));
+    }
+    async deleteSession(sessionId) {
+        db().prepare("DELETE FROM session_items WHERE session_id = ?").run(sessionId);
+    }
+}

package/dist/session-meta-store.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The unified machine-session record (SQLite) — one row per session regardless
+ * of origin (the web console AND every channel). Holds identity/meta (source /
+ * agent / inline config / model / title / …) so the **session list survives a
+ * daemon restart**; the transcript lives in `session_items` (see
+ * {@link import("./session-log-store.js")}). Runtime `status` is intentionally
+ * not stored — it is reconstructed as `idle` after a restart.
+ *
+ * Exposes both the standalone functions the control-plane deps wire in and a
+ * {@link SessionRegistry} adapter ({@link sessionRegistry}) injected into channels
+ * via the `ChannelContext`, so a channel registers its sessions the same way the
+ * console does.
+ */
+import type { MachineSessionRecord, SessionRegistry } from "@rynx-ai/core";
+/** Back-compat alias for the unified record. */
+export type StoredSessionMeta = MachineSessionRecord;
+export declare function listSessionMetas(): StoredSessionMeta[];
+export declare function getSessionMeta(id: string): StoredSessionMeta | undefined;
+export declare function createSessionMeta(meta: StoredSessionMeta): void;
+export declare function setSessionTitle(id: string, title: string): void;
+export declare function removeSessionMeta(id: string): void;
+/** {@link SessionRegistry} over the same `sessions` table — the form channels
+ *  receive through their `ChannelContext`. */
+export declare const sessionRegistry: SessionRegistry;

package/dist/session-meta-store.js

@@ -0,0 +1,59 @@
+import { db } from "./db.js";
+const COLS = "id, agent, config, model, reasoning_effort, title, source, created_at, updated_at";
+export function listSessionMetas() {
+    return db()
+        .prepare(`SELECT ${COLS} FROM sessions ORDER BY created_at`)
+        .all()
+        .map((row) => rowToMeta(row));
+}
+export function getSessionMeta(id) {
+    const row = db().prepare(`SELECT ${COLS} FROM sessions WHERE id = ?`).get(id);
+    return row ? rowToMeta(row) : undefined;
+}
+export function createSessionMeta(meta) {
+    db()
+        .prepare(`INSERT OR IGNORE INTO sessions
+         (id, agent, config, model, reasoning_effort, title, source, created_at, updated_at)
+       VALUES (@id, @agent, @config, @model, @reasoning_effort, @title, @source, @created_at, @updated_at)`)
+        .run({
+        id: meta.id,
+        agent: meta.agent ?? null,
+        config: meta.config ? JSON.stringify(meta.config) : null,
+        model: meta.model ?? null,
+        reasoning_effort: meta.reasoningEffort ?? null,
+        title: meta.title ?? null,
+        source: meta.source,
+        created_at: meta.createdAt,
+        updated_at: meta.updatedAt ?? meta.createdAt,
+    });
+}
+export function setSessionTitle(id, title) {
+    db()
+        .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?")
+        .run(title, new Date().toISOString(), id);
+}
+export function removeSessionMeta(id) {
+    db().prepare("DELETE FROM sessions WHERE id = ?").run(id);
+}
+/** {@link SessionRegistry} over the same `sessions` table — the form channels
+ *  receive through their `ChannelContext`. */
+export const sessionRegistry = {
+    create: createSessionMeta,
+    get: getSessionMeta,
+    list: listSessionMetas,
+    setTitle: setSessionTitle,
+    remove: removeSessionMeta,
+};
+function rowToMeta(row) {
+    return {
+        id: row.id,
+        agent: row.agent ?? undefined,
+        config: row.config ? JSON.parse(row.config) : undefined,
+        model: row.model ?? undefined,
+        reasoningEffort: (row.reasoning_effort ?? undefined),
+        title: row.title ?? undefined,
+        source: row.source ?? "console",
+        createdAt: row.created_at,
+        updatedAt: row.updated_at ?? row.created_at,
+    };
+}

package/dist/setup.d.ts

@@ -0,0 +1,4 @@
+/** Walk the user through config.json step by step. Returns a process exit code. */
+export declare function runSetup(): Promise<number>;
+/** Read-only diagnostics. Returns a process exit code (0 ok, 1 on any failure). */
+export declare function runDoctor(): Promise<number>;

package/dist/setup.js

@@ -0,0 +1,235 @@
+/**
+ * `rynx setup` / `rynx doctor` — bootstrap + health check for the daemon home
+ * (`~/.rynx`). Replaces the old repo-bound `scripts/setup.sh`: config lives in
+ * `{RYNX_HOME}/config.json` and the CLI ships as a global binary, so this belongs
+ * here where it can also read the SQLite store directly. The interactive UI is
+ * rendered with `@clack/prompts`.
+ *
+ *   rynx setup    interactive, step-by-step wizard that writes ~/.rynx/config.json
+ *                 (falls back to writing defaults when stdin isn't a TTY)
+ *   rynx doctor   read-only diagnostics (creates nothing; non-zero exit on failure)
+ */
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import { AGENT_RUNTIME_IDS, getRuntimeProfile, listAgentSpecs, loadConfig, resolveRuntimeHome, rynxAgentsDir, rynxConfigFile, rynxHome, } from "@rynx-ai/core";
+import { listChannels } from "./channel-store.js";
+import { dbPath } from "./db.js";
+import { listInstances } from "./instance-store.js";
+import { listPlugins } from "./plugin-store.js";
+import { formatControlUrl } from "./pm2.js";
+const MIN_NODE_MAJOR = 20;
+// ── rynx setup — interactive wizard ─────────────────────────────────────────
+/** Walk the user through config.json step by step. Returns a process exit code. */
+export async function runSetup() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        // Non-interactive (CI / piped): never block on a prompt — just ensure defaults.
+        if (!existsSync(rynxConfigFile()))
+            writeConfig({ HOST: "0.0.0.0", PORT: 3000, LOG_LEVEL: "info" });
+        console.log(`非交互环境:已确保 ${rynxConfigFile()} 存在(默认值)。` +
+            "在终端(TTY)下重跑 `rynx setup` 可分步配置,或直接编辑该文件。");
+        return 0;
+    }
+    p.intro("rynx setup · 配置 ~/.rynx");
+    const cfg = readConfig();
+    // Runtimes: show status, offer login for any logged-out codex/traex, pick default.
+    let states = AGENT_RUNTIME_IDS.map(runtimeState);
+    p.note(states.map((s) => `${statusGlyph(s)}  ${s.id.padEnd(7)} ${runtimeHint(s)}`).join("\n"), "运行时");
+    for (const s of states) {
+        if (s.installed && s.login === "logged-out" && s.id !== "claude") {
+            const yes = await p.confirm({ message: `现在登录 ${s.id}(${s.profile.loginCommand})?`, initialValue: false });
+            if (p.isCancel(yes))
+                return bail();
+            if (yes)
+                spawnSync(s.bin, ["login"], { stdio: "inherit" });
+        }
+    }
+    const claude = states.find((s) => s.id === "claude");
+    if (claude?.installed && claude.login === "logged-out") {
+        p.log.info("claude 登录:运行 `claude /login`,或设置 ANTHROPIC_API_KEY 后重来");
+    }
+    states = AGENT_RUNTIME_IDS.map(runtimeState); // re-probe after any login
+    const installed = states.filter((s) => s.installed);
+    if (installed.length === 0) {
+        p.log.warn("没有检测到运行时;装好 codex / traex / claude 之一后可设默认。");
+    }
+    else {
+        const current = typeof cfg.AGENT_RUNTIME === "string" ? cfg.AGENT_RUNTIME : undefined;
+        const initial = current ?? installed.find((s) => s.login === "logged-in")?.id ?? installed[0].id;
+        const runtime = await p.select({
+            message: "默认运行时 AGENT_RUNTIME",
+            initialValue: initial,
+            options: installed.map((s) => ({ value: s.id, label: s.id, hint: runtimeHint(s) })),
+        });
+        if (p.isCancel(runtime))
+            return bail();
+        cfg.AGENT_RUNTIME = runtime;
+    }
+    // HTTP port.
+    const port = await p.text({
+        message: "HTTP 端口 PORT",
+        placeholder: "3000",
+        initialValue: String(cfg.PORT ?? 3000),
+        validate: (v) => {
+            const n = Number(v);
+            if (!Number.isInteger(n) || n <= 0 || n > 65535)
+                return "请输入 1–65535 之间的端口";
+            return undefined;
+        },
+    });
+    if (p.isCancel(port))
+        return bail();
+    cfg.PORT = Number(port);
+    cfg.HOST = cfg.HOST ?? "0.0.0.0";
+    cfg.LOG_LEVEL = cfg.LOG_LEVEL ?? "info";
+    writeConfig(cfg);
+    p.log.success(`已写入 ${rynxConfigFile()}(chmod 600)`);
+    p.log.message(`HOST=${cfg.HOST}  PORT=${cfg.PORT}  AGENT_RUNTIME=${cfg.AGENT_RUNTIME ?? "(默认)"}`);
+    const url = formatControlUrl(String(cfg.HOST ?? "0.0.0.0"), Number(cfg.PORT ?? 3000));
+    p.note([
+        `启动常驻服务   rynx start`,
+        `打开控制台     ${url}`,
+        `新建 agent     rynx agent add <id>`,
+        `随时体检       rynx doctor`,
+    ].join("\n"), "下一步");
+    p.outro("配置完成 🎉");
+    return 0;
+}
+// ── rynx doctor — read-only health check ────────────────────────────────────
+/** Read-only diagnostics. Returns a process exit code (0 ok, 1 on any failure). */
+export async function runDoctor() {
+    let warn = 0;
+    let fail = 0;
+    const home = rynxHome();
+    p.intro("rynx doctor · 只读体检");
+    p.note([
+        `RYNX_HOME  ${home}`,
+        `config     ${rynxConfigFile()}`,
+        `db         ${dbPath()}`,
+        `agents     ${rynxAgentsDir()}`,
+        `logs       ${join(home, "logs")}`,
+    ].join("\n"), "路径");
+    const major = Number(process.versions.node.split(".")[0]);
+    if (major >= MIN_NODE_MAJOR)
+        p.log.success(`Node.js v${process.versions.node}(要求 ≥ ${MIN_NODE_MAJOR})`);
+    else
+        (p.log.error(`Node.js v${process.versions.node} 过低,要求 ≥ ${MIN_NODE_MAJOR}`), fail++);
+    if (existsSync(rynxConfigFile()))
+        p.log.success(`config.json 已存在`);
+    else
+        (p.log.warn("缺少 config.json —— 运行 `rynx setup` 生成"), warn++);
+    try {
+        const config = loadConfig();
+        p.log.info(`HOST=${config.HOST}  PORT=${config.PORT}  LOG_LEVEL=${config.LOG_LEVEL}  AGENT_RUNTIME=${config.AGENT_RUNTIME}`);
+    }
+    catch (error) {
+        p.log.error(`配置解析失败:${error.message}`);
+        fail++;
+    }
+    let anyReady = false;
+    for (const s of AGENT_RUNTIME_IDS.map(runtimeState)) {
+        if (!s.installed)
+            p.log.info(`${s.id}:未安装(${s.bin} 不在 PATH)`);
+        else if (s.login === "logged-in")
+            (p.log.success(`${s.id}:已登录`), (anyReady = true));
+        else if (s.login === "logged-out")
+            (p.log.warn(`${s.id}:未登录 —— 运行 \`${s.profile.loginCommand}\``), warn++);
+        else
+            (p.log.warn(`${s.id}:已安装,登录状态待确认(若报鉴权错误,执行 \`${s.profile.loginCommand}\`)`), (anyReady = true));
+    }
+    if (!anyReady)
+        (p.log.error("没有就绪的运行时 —— 至少登录一个:codex login / traex login / claude /login"), fail++);
+    if (!existsSync(dbPath())) {
+        p.log.info("rynx.db 尚未创建(首次 `rynx start` 时生成)");
+    }
+    else {
+        const plugins = listPlugins();
+        p.log.info(`插件:${plugins.length} 个${plugins.length ? `(${plugins.map((pl) => pl.name).join(", ")})` : ""}`);
+        const channels = listChannels();
+        const configured = channels.filter((c) => c.options && Object.keys(c.options).length > 0).length;
+        p.log.info(`channel:${channels.length} 个(${configured} 已配置凭据)  ·  instance:${listInstances().length} 个`);
+        if (channels.length === 0)
+            (p.log.warn("还没有 channel —— 在 Web 控制台新建并授权"), warn++);
+    }
+    p.log.info(`agent:${(await listAgentSpecs()).length} 个(${rynxAgentsDir()})`);
+    if (fail > 0) {
+        p.outro(`体检发现 ${fail} 个失败项(警告 ${warn})—— 处理后重跑 rynx doctor`);
+        return 1;
+    }
+    p.outro(warn > 0 ? `基本就绪,有 ${warn} 个警告` : "全部通过 ✓");
+    return 0;
+}
+function runtimeState(id) {
+    const profile = getRuntimeProfile(id);
+    const installed = onPath(profile.defaultBinary);
+    const login = !installed
+        ? "logged-out"
+        : id === "claude"
+            ? claudeAuthState(profile)
+            : cliLoginState(profile.defaultBinary);
+    return { id, bin: profile.defaultBinary, profile, installed, login };
+}
+function statusGlyph(s) {
+    if (!s.installed)
+        return "○";
+    return s.login === "logged-in" ? "●" : "◍";
+}
+function runtimeHint(s) {
+    if (!s.installed)
+        return `未安装(${s.bin} 不在 PATH)`;
+    if (s.login === "logged-in")
+        return "已登录";
+    if (s.login === "logged-out")
+        return "已安装,未登录";
+    return "已安装,状态待确认";
+}
+/** Is `bin` runnable on PATH? Probe with `--version` (ENOENT ⇒ not installed). */
+function onPath(bin) {
+    const result = spawnSync(bin, ["--version"], { stdio: "ignore", timeout: 8000 });
+    return !result.error && result.status === 0;
+}
+/** Parse `<bin> login status` (codex/traex) into a tri-state. */
+function cliLoginState(bin) {
+    const result = spawnSync(bin, ["login", "status"], { encoding: "utf8", timeout: 12000 });
+    const out = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    if (/Logged in using/i.test(out))
+        return "logged-in";
+    if (/not logged in|logged out/i.test(out))
+        return "logged-out";
+    return "unknown";
+}
+/** Claude has no `login status`; auth is an API-key env var or the `~/.claude` config dir. */
+function claudeAuthState(profile) {
+    if (process.env.ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_AUTH_TOKEN?.trim())
+        return "logged-in";
+    return existsSync(resolveRuntimeHome(profile)) ? "unknown" : "logged-out";
+}
+function readConfig() {
+    const file = rynxConfigFile();
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfig(cfg) {
+    const file = rynxConfigFile();
+    mkdirSync(rynxHome(), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(cfg, null, 2)}\n`);
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        /* best-effort on platforms without POSIX modes */
+    }
+}
+/** User pressed Ctrl-C mid-wizard: print a cancel note and exit cleanly. */
+function bail() {
+    p.cancel("已取消,未保存改动。");
+    return 0;
+}

package/dist/skills-catalog.d.ts

@@ -0,0 +1,18 @@
+import { type SkillInstallRecipe, type SkillMeta } from "@rynx-ai/core";
+import type { SkillDetail } from "@rynx-ai/protocol/control";
+export declare function listCatalogSkills(): Promise<SkillMeta[]>;
+/** Install a skill (or a repo's skills) into the catalog per a full install
+ *  recipe; delegates to the core catalog layer (which also writes each skill's
+ *  `.rynx-skill.json` install-info file — a catalog-only artifact). Returns
+ *  the refreshed catalog. */
+export declare function installCatalogSkill(recipe: SkillInstallRecipe): Promise<SkillMeta[]>;
+/** Detail for one catalog skill: its metadata + the file tree under its dir. */
+export declare function getCatalogSkill(name: string): Promise<SkillDetail | null>;
+/** Read one text file inside a catalog skill. Path-confined to the skill dir,
+ *  size-capped, and binary files are rejected. */
+export declare function readCatalogSkillFile(name: string, relPath: string): Promise<{
+    path: string;
+    content: string;
+}>;
+/** Remove a catalog skill by name. Returns false if it wasn't present. */
+export declare function removeCatalogSkill(name: string): Promise<boolean>;

package/dist/skills-catalog.js

@@ -0,0 +1,94 @@
+/**
+ * The daemon's global skill catalog at `~/.rynx/skills`. Install + provenance
+ * live in `@rynx-ai/core` (`skills-install.ts`) so the daemon API and the runtime
+ * 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 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}$/;
+/** A single file's contents are capped to keep responses small. */
+const MAX_SKILL_FILE_BYTES = 256 * 1024;
+export function listCatalogSkills() {
+    return scanSkillsDir(rynxSkillsDir());
+}
+/** Install a skill (or a repo's skills) into the catalog per a full install
+ *  recipe; delegates to the core catalog layer (which also writes each skill's
+ *  `.rynx-skill.json` install-info file — a catalog-only artifact). Returns
+ *  the refreshed catalog. */
+export async function installCatalogSkill(recipe) {
+    await installIntoCatalog(recipe, rynxSkillsDir());
+    return scanSkillsDir(rynxSkillsDir());
+}
+/** 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}`);
+    const dir = path.join(rynxSkillsDir(), name);
+    const meta = await readSkillMeta(dir);
+    if (!meta)
+        return null;
+    const files = await walkSkillFiles(dir, dir);
+    let frontmatter;
+    try {
+        frontmatter = extractSkillFrontmatter(await readFile(path.join(dir, "SKILL.md"), "utf8")) ?? undefined;
+    }
+    catch {
+        /* SKILL.md unreadable — leave frontmatter undefined */
+    }
+    return {
+        name: meta.name,
+        description: meta.description,
+        ...(meta.ref ? { ref: meta.ref } : {}),
+        frontmatter,
+        totalSize: files.reduce((sum, f) => sum + f.size, 0),
+        files,
+    };
+}
+async function walkSkillFiles(root, dir) {
+    const out = [];
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...(await walkSkillFiles(root, full)));
+        else if (entry.isFile())
+            out.push({ path: path.relative(root, full), size: (await stat(full)).size });
+    }
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+/** 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}`);
+    const dir = path.resolve(rynxSkillsDir(), name);
+    const target = path.resolve(dir, relPath);
+    if (target !== dir && !target.startsWith(dir + path.sep)) {
+        throw new Error("path escapes the skill directory");
+    }
+    const s = await stat(target).catch(() => null);
+    if (!s || !s.isFile())
+        throw new Error("file not found");
+    if (s.size > MAX_SKILL_FILE_BYTES)
+        throw new Error(`file too large (${s.size} bytes)`);
+    const buf = await readFile(target);
+    if (buf.includes(0))
+        throw new Error("binary file — not viewable");
+    return { path: relPath, content: buf.toString("utf8") };
+}
+/** 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}`);
+    const dir = path.join(rynxSkillsDir(), name);
+    try {
+        await stat(dir);
+    }
+    catch {
+        return false;
+    }
+    await rm(dir, { recursive: true, force: true });
+    return true;
+}

package/dist/stdio-epipe-guard.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Under pm2 the daemon's stdout/stderr are pipes to the pm2 God daemon. A
+ * broken pipe (a `pm2 logs` stream detaching, or a pm2 restart) would otherwise
+ * surface as an unhandled `'error'` on the stream and crash a daemon that has
+ * no uncaughtException trap. Swallow EPIPE on the std streams; re-throw anything
+ * else. (Borrowed from botmux's daemon bootstrap.)
+ */
+export declare function installStdioEpipeGuard(): void;

package/dist/stdio-epipe-guard.js

@@ -0,0 +1,16 @@
+/**
+ * Under pm2 the daemon's stdout/stderr are pipes to the pm2 God daemon. A
+ * broken pipe (a `pm2 logs` stream detaching, or a pm2 restart) would otherwise
+ * surface as an unhandled `'error'` on the stream and crash a daemon that has
+ * no uncaughtException trap. Swallow EPIPE on the std streams; re-throw anything
+ * else. (Borrowed from botmux's daemon bootstrap.)
+ */
+export function installStdioEpipeGuard() {
+    for (const stream of [process.stdout, process.stderr]) {
+        stream.on("error", (err) => {
+            if (err.code === "EPIPE")
+                return;
+            throw err;
+        });
+    }
+}

package/dist/update.d.ts

@@ -0,0 +1,16 @@
+import { type UpdateCheck } from "@rynx-ai/core";
+export interface UpdateOptions {
+    check?: boolean;
+    /** With `check`, emit a typed {@link UpdateCheck} as JSON instead of a human line. */
+    json?: boolean;
+    version?: string;
+    resultFile?: string;
+}
+/** Is `latest` a newer release than `current`? Numeric major.minor.patch (prerelease ignored). */
+export declare function isNewer(latest: string, current: string): boolean;
+/** Typed `--check` result a channel consumes via `--check --json`. */
+export declare function buildUpdateCheck(current: string, latest: string | null): UpdateCheck;
+/** Format the one-line, human-readable status emitted by a bare `--check`. */
+export declare function checkStatusLine(current: string, latest: string | null): string;
+/** Run `rynx update`. Returns a process exit code. */
+export declare function runUpdate(opts: UpdateOptions): Promise<number>;