@rynx-ai/daemon 0.1.0

package/dist/agent-file.d.ts

@@ -0,0 +1,13 @@
+import { type LoadedAgentSpec } from "@rynx-ai/core";
+/** Absolute path to an agent's spec file. */
+export declare function agentSpecPath(id: string): string;
+/**
+ * Validate + atomically write a spec into the agent's config directory. The id
+ * is the directory name and is never persisted inside the file (any `id` in the
+ * input is dropped by the schema). Throws on a schema violation.
+ */
+export declare function writeAgentSpec(id: string, spec: Record<string, unknown>): LoadedAgentSpec;
+/** Remove an agent (its whole config directory). Returns false if it didn't exist. */
+export declare function removeAgentSpec(id: string): boolean;
+/** Write a minimal, valid starter spec for `rynx agent add`. */
+export declare function scaffoldAgentSpec(id: string): LoadedAgentSpec;

package/dist/agent-file.js

@@ -0,0 +1,61 @@
+/**
+ * `~/.rynx/agents/<id>/agent.json` — CLI/web-managed declarative agents. Each
+ * agent is a directory whose **name is the agent id**; the spec lives at
+ * `agent.json` inside it (alongside any instruction markdown the spec references).
+ *
+ * Reading + validation live in `@rynx-ai/core` (`loadAgentSpec` / `listAgentSpecs`);
+ * this module owns the write/remove side (atomic tmp+rename for the spec file).
+ */
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { agentSpecSchema, assertValidAgentId, rynxAgentDir, rynxAgentSpecFile, } from "@rynx-ai/core";
+/** Absolute path to an agent's spec file. */
+export function agentSpecPath(id) {
+    return rynxAgentSpecFile(id);
+}
+/**
+ * Validate + atomically write a spec into the agent's config directory. The id
+ * is the directory name and is never persisted inside the file (any `id` in the
+ * input is dropped by the schema). Throws on a schema violation.
+ */
+export function writeAgentSpec(id, spec) {
+    assertValidAgentId(id); // id is a directory name — reject path-escaping / unsafe ids
+    const parsed = agentSpecSchema.parse(spec); // unknown keys (incl. `id`) are stripped
+    mkdirSync(rynxAgentDir(id), { recursive: true });
+    const path = rynxAgentSpecFile(id);
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+    renameSync(tmp, path);
+    return { ...parsed, id };
+}
+/** Remove an agent (its whole config directory). Returns false if it didn't exist. */
+export function removeAgentSpec(id) {
+    assertValidAgentId(id); // guard rmSync against `..`/path-escaping ids
+    const dir = rynxAgentDir(id);
+    if (!existsSync(dir)) {
+        return false;
+    }
+    rmSync(dir, { recursive: true, force: true });
+    return true;
+}
+/** Write a minimal, valid starter spec for `rynx agent add`. */
+export function scaffoldAgentSpec(id) {
+    return writeAgentSpec(id, {
+        specVersion: 1,
+        name: id,
+        description: "A rynx agent.",
+        instructions: "You are a helpful agent.",
+        executor: {
+            runtime: "claude",
+            model: "claude-sonnet-4-6",
+            reasoningEffort: "medium",
+            // Runtime budget (edit/remove as needed): timeout is enforced on every
+            // runtime; retry maps to per-runtime env. maxIterations (claude only) and
+            // contextWindow (codex only) are also accepted.
+            timeout: 1800,
+            retry: { maxRetries: 2 },
+        },
+        osEnv: { sandbox: "danger-full-access", approvalPolicy: "never" },
+        tools: { allowed: [], disallowed: [], mcp: [] },
+        params: {},
+    });
+}

package/dist/channel-store.d.ts

@@ -0,0 +1,28 @@
+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;
+/**
+ * Bridge each channel's stored `options` into `process.env`, so a channel reads
+ * its credentials from the environment as usual. Existing env (including `.env`)
+ * wins — only undefined keys are filled.
+ */
+export declare function applyChannelEnv(): void;

package/dist/channel-store.js

@@ -0,0 +1,81 @@
+/**
+ * `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 `.env`); {@link applyChannelEnv}
+ * bridges them into `process.env` at boot, with explicit env always winning.
+ */
+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);
+}
+/**
+ * Bridge each channel's stored `options` into `process.env`, so a channel reads
+ * its credentials from the environment as usual. Existing env (including `.env`)
+ * wins — only undefined keys are filled.
+ */
+export function applyChannelEnv() {
+    for (const channel of listChannels()) {
+        if (!channel.options)
+            continue;
+        for (const [key, value] of Object.entries(channel.options)) {
+            if (typeof value === "string" && process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+    }
+}

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * `rynx` — the daemon CLI.
+ *
+ *   rynx start | stop | restart | status | logs   process lifecycle (pm2)
+ *   rynx plugin add <spec> | ls | rm <name> | enable <name> | disable <name>
+ *   rynx agent list | show <name> | add <name> | rm <name>
+ *
+ * The CLI owns process lifecycle, plugin install/registry, and the file-based
+ * declarative agent specs. Channel instances (a channel + an agent) are
+ * configured in the web control console (`rynx start`, then open it).
+ *
+ * Hand-rolled arg dispatch (no arg-parser dep) to match the repo's zero-dep CLI
+ * style.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+import { listAgentSpecs, loadAgentSpec, loadConfig, rynxAgentsDir } from "@rynx-ai/core";
+import { agentSpecPath, removeAgentSpec, scaffoldAgentSpec } from "./agent-file.js";
+import { dbPath } from "./db.js";
+import { cleanupLegacySessions } from "./migrations/cleanup-legacy-sessions.js";
+import { installPlugin, uninstallPlugin } from "./plugin-installer.js";
+import { getPlugin, listPlugins, setPluginEnabled } from "./plugin-store.js";
+import { startDaemon, statusDaemon, stopDaemon, streamLogs } from "./pm2.js";
+import { runDoctor, runSetup } from "./setup.js";
+import { runUpdate } from "./update.js";
+const USAGE = `Usage: rynx <command>
+
+Setup:
+  setup              interactive wizard — configure ~/.rynx/config.json step by step
+  doctor             read-only health check (creates nothing; non-zero on failure)
+
+Lifecycle:
+  start              start the resident server (pm2-supervised)
+  restart            reload the running server
+  stop               stop and remove the server
+  status             print whether the server is running
+  logs               tail the server logs
+  update [version]   upgrade @rynx-ai/daemon (npm) + restart  (--check: report only)
+
+Plugins (~/.rynx/rynx.db · channel plugins):
+  plugin ls              list installed plugins
+  plugin add <spec> [--force]
+                         install from an npm spec or a local directory
+                         (local is copied into ~/.rynx/plugins; --force overwrites a same-named plugin)
+  plugin rm <name>       uninstall a plugin
+  plugin enable <name>   enable / disable an installed plugin
+  plugin disable <name>
+                         (plugin changes apply on \`rynx restart\`)
+
+Agents (~/.rynx/agents/<id>/agent.json — dir name is the id):
+  agent list             list agents (id · runtime · model · [display name])
+  agent show <id>        print a parsed + validated agent spec
+  agent add <id>         scaffold an agent dir + starter spec, then edit it
+  agent rm <id>          remove an agent (its whole config dir)
+                         (select an agent in a chat with \`/agent <id>\`;
+                          set a fleet default via the RYNX_DEFAULT_AGENT env var)
+
+Maintenance:
+  cleanup sessions [--dry-run]
+                         delete legacy (pre-uuid) sessions so the system starts
+                         clean on opaque ids (runs once at boot too). Stop the
+                         daemon before running manually.
+
+Emulator:
+  emulator <args…>       passthrough to the bundled \`rynx-emulator\` CLI
+                         (same commands/flags; run \`rynx emulator\` for its help)
+
+Channel instances (a channel + an agent) are configured in the web control
+console (run \`rynx start\`, then open the printed URL).
+`;
+function fail(message) {
+    console.error(message);
+    process.exit(2);
+}
+async function pluginCommand(sub, arg) {
+    switch (sub) {
+        case "ls":
+        case "list": {
+            const plugins = listPlugins();
+            console.log(`Plugins (db: ${dbPath()})`);
+            if (plugins.length === 0) {
+                console.log("  (none)");
+                return;
+            }
+            for (const p of plugins) {
+                const state = p.enabled ? "enabled" : "disabled";
+                console.log(`  ${p.name.padEnd(16)} ${(p.version ?? "-").padEnd(10)} ${p.source.padEnd(6)} ${state}`);
+            }
+            return;
+        }
+        case "add":
+        case "install": {
+            if (!arg)
+                fail("plugin add: missing spec (an npm package or a local directory)");
+            const force = process.argv.includes("--force");
+            const result = await installPlugin(arg, (line) => console.log(line), {
+                onConflict: async (existing) => {
+                    if (force)
+                        return true;
+                    const desc = `${existing.source}${existing.version ? ` @${existing.version}` : ""}`;
+                    if (!process.stdin.isTTY) {
+                        fail(`plugin "${existing.name}" already installed (${desc}). ` +
+                            `Re-run with --force, or \`rynx plugin rm ${existing.name}\` first.`);
+                    }
+                    const yes = await confirm({
+                        message: `插件 "${existing.name}" 已存在(${desc}),覆盖吗?`,
+                        initialValue: false,
+                    });
+                    return !isCancel(yes) && yes === true;
+                },
+            });
+            if (result.skipped) {
+                console.log(`已取消,保留现有插件 "${result.name}"。`);
+            }
+            else {
+                console.log(`Plugin "${result.name}" (${result.source}${result.version ? ` @${result.version}` : ""}) installed. Run \`rynx restart\` to apply.`);
+            }
+            return;
+        }
+        case "rm":
+        case "remove":
+        case "uninstall": {
+            if (!arg)
+                fail("plugin rm: missing plugin name");
+            if (!(await uninstallPlugin(arg, (line) => console.log(line))))
+                fail(`plugin "${arg}" not found`);
+            console.log(`Plugin "${arg}" uninstalled. Run \`rynx restart\` to apply.`);
+            return;
+        }
+        case "enable":
+        case "disable": {
+            if (!arg)
+                fail(`plugin ${sub}: missing plugin name`);
+            if (!getPlugin(arg))
+                fail(`plugin "${arg}" not found`);
+            setPluginEnabled(arg, sub === "enable");
+            console.log(`Plugin "${arg}" ${sub}d. Run \`rynx restart\` to apply.`);
+            return;
+        }
+        default:
+            fail(USAGE);
+    }
+}
+async function agentCommand(sub, name) {
+    switch (sub) {
+        case "list": {
+            const specs = await listAgentSpecs();
+            console.log(`Agents (dir: ${rynxAgentsDir()})`);
+            if (specs.length === 0) {
+                console.log("  (none)");
+                return;
+            }
+            for (const spec of specs) {
+                const runtime = spec.executor?.runtime ?? "(default)";
+                const model = spec.executor?.model ?? "(default)";
+                const display = spec.name && spec.name !== spec.id ? `  (${spec.name})` : "";
+                console.log(`  ${spec.id.padEnd(16)} ${runtime.padEnd(8)} ${model}${display}`);
+            }
+            return;
+        }
+        case "show": {
+            if (!name)
+                fail("agent show: missing agent name");
+            const spec = await loadAgentSpec(name);
+            if (!spec)
+                fail(`agent "${name}" not found at ${agentSpecPath(name)}`);
+            console.log(JSON.stringify(spec, null, 2));
+            return;
+        }
+        case "add": {
+            if (!name)
+                fail("agent add: missing agent name");
+            if (existsSync(agentSpecPath(name)))
+                fail(`agent "${name}" already exists at ${agentSpecPath(name)}`);
+            scaffoldAgentSpec(name);
+            console.log(`Agent "${name}" created at ${agentSpecPath(name)}. Edit it, then select it in a chat with \`/agent ${name}\`.`);
+            return;
+        }
+        case "rm":
+        case "remove": {
+            if (!name)
+                fail("agent rm: missing agent name");
+            if (!removeAgentSpec(name))
+                fail(`agent "${name}" not found`);
+            console.log(`Agent "${name}" removed.`);
+            return;
+        }
+        default:
+            fail(USAGE);
+    }
+}
+async function cleanupCommand(sub) {
+    if (sub !== "sessions")
+        fail("cleanup: only `cleanup sessions` is supported");
+    const dryRun = process.argv.includes("--dry-run");
+    const result = cleanupLegacySessions({
+        codexStorePath: loadConfig().AGENT_SESSION_STORE_PATH,
+        dryRun,
+        log: (entry) => console.log(JSON.stringify(entry)),
+    });
+    const summary = `${result.deletedSessions} session(s), ${result.deletedLogRows} log row(s), ${result.prunedStoreEntries} store entr(ies)`;
+    console.log(dryRun ? `Dry run: would delete ${summary}.` : `Deleted ${summary}.`);
+}
+/** Pass `rynx emulator <args…>` through to the dependency's own CLI, verbatim.
+ *  Resolved from @rynx-ai/emulator (dist/cli.js sits beside the main entry), so it
+ *  runs the exact locked version — no PATH or npx involved. Stdio is inherited
+ *  so interactive flows (the skill install agent picker) work. */
+function emulatorPassthrough(args) {
+    const require = createRequire(import.meta.url);
+    const cliPath = path.join(path.dirname(require.resolve("@rynx-ai/emulator")), "cli.js");
+    const child = spawn(process.execPath, [cliPath, ...args], { stdio: "inherit" });
+    child.on("exit", (code) => process.exit(code ?? 1));
+    child.on("error", (error) => {
+        console.error(`rynx emulator: failed to launch the bundled CLI: ${error.message}`);
+        process.exit(1);
+    });
+}
+async function main() {
+    const [command, sub, arg] = process.argv.slice(2);
+    switch (command) {
+        case "setup":
+            process.exit(await runSetup());
+            break;
+        case "doctor":
+            process.exit(await runDoctor());
+            break;
+        case "update": {
+            const rest = process.argv.slice(3);
+            const resultIdx = rest.indexOf("--result-file");
+            const resultFile = resultIdx >= 0 ? rest[resultIdx + 1] : undefined;
+            const version = rest.find((a) => !a.startsWith("--") && a !== resultFile);
+            process.exit(await runUpdate({
+                check: rest.includes("--check"),
+                json: rest.includes("--json"),
+                version,
+                resultFile,
+            }));
+            break;
+        }
+        case "start":
+            process.exit(startDaemon({ force: false }));
+            break;
+        case "restart":
+            process.exit(startDaemon({ force: true }));
+            break;
+        case "stop":
+            process.exit(stopDaemon());
+            break;
+        case "status":
+            process.exit(statusDaemon());
+            break;
+        case "logs":
+            streamLogs();
+            break;
+        case "plugin":
+            await pluginCommand(sub, arg);
+            break;
+        case "agent":
+            await agentCommand(sub, arg);
+            break;
+        case "cleanup":
+            await cleanupCommand(sub);
+            break;
+        case "emulator":
+            emulatorPassthrough(process.argv.slice(3));
+            break;
+        case undefined:
+        case "help":
+        case "-h":
+        case "--help":
+            console.log(USAGE);
+            break;
+        default:
+            fail(`Unknown command: ${command}\n\n${USAGE}`);
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/control-deps.d.ts

@@ -0,0 +1,2 @@
+import type { ControlPlaneDeps } from "@rynx-ai/server";
+export declare function buildControlDeps(): ControlPlaneDeps;

package/dist/control-deps.js

@@ -0,0 +1,115 @@
+/**
+ * Assemble the daemon-side {@link ControlPlaneDeps} the server needs to serve
+ * the control console: db-backed channel + instance mutators, file-backed agent
+ * specs, channel-type info from the loaded plugins, and a log tail. Plugins are
+ * managed via the CLI, not here. Keeps `~/.rynx` knowledge in the daemon (the
+ * composition root); the server stays storage-agnostic.
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { listAgentSpecs, loadAgentSpec, rynxHome } from "@rynx-ai/core";
+import { createEmulatorControlDeps } from "@rynx-ai/emulator";
+import { removeAgentSpec, writeAgentSpec } from "./agent-file.js";
+import { getCatalogSkill, installCatalogSkill, listCatalogSkills, readCatalogSkillFile, removeCatalogSkill, } from "./skills-catalog.js";
+import { createChannel, listChannels, removeChannel, renameChannel, setChannelOptions, } from "./channel-store.js";
+import { createInstance, listInstances, removeInstance, setInstanceAgent, setInstanceEnabled, } from "./instance-store.js";
+import { getChannelType, listChannelTypes } from "./registry.js";
+import { createSessionMeta, getSessionMeta, listSessionMetas, removeSessionMeta, setSessionTitle, } from "./session-meta-store.js";
+export function buildControlDeps() {
+    return {
+        // ── channel types (from loaded plugins) ──────────────────────────────
+        listChannelTypes: () => listChannelTypes().map((descriptor) => ({
+            type: descriptor.type,
+            configSchema: descriptor.configSchema,
+            authorize: Boolean(descriptor.authorize),
+        })),
+        // ── channels (config + credentials) ──────────────────────────────────
+        listChannels: () => listChannels(),
+        createChannel: (input) => ({ id: createChannel(input).id }),
+        setChannel: (id, patch) => {
+            if (patch.name !== undefined)
+                renameChannel(id, patch.name);
+            if (patch.options !== undefined)
+                setChannelOptions(id, patch.options);
+        },
+        removeChannel: (id) => {
+            removeChannel(id);
+        },
+        authorizeChannel: (type, emit, signal) => {
+            const descriptor = getChannelType(type);
+            if (!descriptor?.authorize) {
+                throw new Error(`channel type "${type}" has no authorize flow`);
+            }
+            return descriptor.authorize(emit, signal);
+        },
+        // ── instances (channel + agent binding) ──────────────────────────────
+        listInstancesConfig: () => listInstances().map((i) => ({
+            id: i.id,
+            channelId: i.channelId,
+            channelName: i.channelName,
+            type: i.type,
+            agent: i.agent,
+            enabled: i.enabled,
+        })),
+        createInstance: (input) => ({ id: createInstance(input).id }),
+        setInstance: (id, patch) => {
+            if (patch.agent !== undefined)
+                setInstanceAgent(id, patch.agent);
+            if (patch.enabled !== undefined)
+                setInstanceEnabled(id, patch.enabled);
+        },
+        removeInstance: (id) => {
+            removeInstance(id);
+        },
+        // ── declarative agents ───────────────────────────────────────────────
+        listAgents: async () => (await listAgentSpecs()).map((spec) => ({
+            id: spec.id,
+            name: spec.name,
+            runtime: spec.executor?.runtime,
+            model: spec.executor?.model,
+        })),
+        getAgent: (id) => loadAgentSpec(id),
+        writeAgent: (id, spec) => {
+            writeAgentSpec(id, spec);
+        },
+        removeAgent: (id) => removeAgentSpec(id),
+        // ── skills catalog ───────────────────────────────────────────────────
+        listSkills: () => listCatalogSkills(),
+        getSkill: (name) => getCatalogSkill(name),
+        readSkillFile: (name, file) => readCatalogSkillFile(name, file),
+        installSkill: (recipe) => installCatalogSkill(recipe),
+        removeSkill: (name) => removeCatalogSkill(name),
+        // ── emulator proxy (single seam: the emulator package owns the surface) ─
+        emulator: createEmulatorControlDeps(),
+        // ── control-plane sessions (meta persisted; status held by the server) ─
+        listSessionMetas: () => listSessionMetas(),
+        getSessionMeta: (id) => getSessionMeta(id),
+        createSessionMeta: (meta) => createSessionMeta(meta),
+        setSessionTitle: (id, title) => setSessionTitle(id, title),
+        removeSessionMeta: (id) => removeSessionMeta(id),
+        tailLogs: (instanceId, lines) => tailLogs(instanceId, lines),
+    };
+}
+/** Tail the daemon's merged pm2 logs, best-effort filtered by instance id. */
+async function tailLogs(instanceId, lines) {
+    const dir = join(rynxHome(), "logs");
+    const files = await Promise.all(["out.log", "err.log"].map(async (name) => {
+        try {
+            return await readFile(join(dir, name), "utf8");
+        }
+        catch {
+            return "";
+        }
+    }));
+    let all = files.join("\n").split(/\r?\n/).filter(Boolean);
+    if (instanceId) {
+        all = all.filter((line) => line.includes(instanceId));
+    }
+    // out.log + err.log are two separate pm2 streams; a plain concat shows all of
+    // stdout then all of stderr, scrambling the timeline. Merge by the leading
+    // `YYYY-MM-DDTHH:MM:SS` timestamp pm2 prefixes each line with, so lines read in
+    // time order (stable sort keeps same-second lines in their per-stream order).
+    const tsOf = (line) => line.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)?.[0] ?? "";
+    all.sort((a, b) => tsOf(a).localeCompare(tsOf(b)));
+    return all.slice(-Math.max(1, lines)).join("\n");
+}

package/dist/daemon-server.d.ts

@@ -0,0 +1,7 @@
+import { type AppConfig } from "@rynx-ai/core";
+import { startServer } from "@rynx-ai/server";
+export interface StartRynxDaemonServerOptions {
+    config?: AppConfig;
+    warn?: (message: string) => void;
+}
+export declare function startRynxDaemonServer({ config, warn, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;