@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/control-deps.js

@@ -9,12 +9,14 @@ 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 { normalizePluginConfig } from "@rynx-ai/plugin-sdk";
 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 { createChannel, getChannel, 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";
+import { consumeControlLink } from "./control-link-store.js";
 export function buildControlDeps() {
     return {
         // ── channel types (from loaded plugins) ──────────────────────────────
@@ -25,22 +27,43 @@ export function buildControlDeps() {
         })),
         // ── channels (config + credentials) ──────────────────────────────────
         listChannels: () => listChannels(),
-        createChannel: (input) => ({ id: createChannel(input).id }),
+        createChannel: (input) => {
+            if (!getChannelType(input.type))
+                throw new Error(`unknown chat channel type: ${input.type}`);
+            return {
+                id: createChannel({
+                    ...input,
+                    ...(input.options !== undefined
+                        ? { options: normalizeChannelOptions(input.type, input.options) }
+                        : {}),
+                }).id,
+            };
+        },
         setChannel: (id, patch) => {
+            let normalizedOptions;
+            if (patch.options !== undefined) {
+                const current = getChannel(id);
+                if (!current)
+                    throw new Error(`channel not found: ${id}`);
+                normalizedOptions = normalizeChannelOptions(current.type, {
+                    ...(current.options ?? {}),
+                    ...patch.options,
+                });
+            }
             if (patch.name !== undefined)
                 renameChannel(id, patch.name);
-            if (patch.options !== undefined)
-                setChannelOptions(id, patch.options);
+            if (normalizedOptions !== undefined)
+                setChannelOptions(id, normalizedOptions);
         },
         removeChannel: (id) => {
             removeChannel(id);
         },
-        authorizeChannel: (type, emit, signal) => {
+        authorizeChannel: (type, context, emit, signal) => {
             const descriptor = getChannelType(type);
             if (!descriptor?.authorize) {
                 throw new Error(`channel type "${type}" has no authorize flow`);
             }
-            return descriptor.authorize(emit, signal);
+            return descriptor.authorize(emit, signal, context);
         },
         // ── instances (channel + agent binding) ──────────────────────────────
         listInstancesConfig: () => listInstances().map((i) => ({
@@ -87,9 +110,17 @@ export function buildControlDeps() {
         createSessionMeta: (meta) => createSessionMeta(meta),
         setSessionTitle: (id, title) => setSessionTitle(id, title),
         removeSessionMeta: (id) => removeSessionMeta(id),
+        consumeControlLink: (token) => consumeControlLink(token),
         tailLogs: (instanceId, lines) => tailLogs(instanceId, lines),
     };
 }
+function normalizeChannelOptions(type, options) {
+    const descriptor = getChannelType(type);
+    if (!descriptor)
+        throw new Error(`unknown chat channel type: ${type}`);
+    const schema = descriptor.configSchema ?? [];
+    return schema.length > 0 ? normalizePluginConfig(schema, options) : { ...options };
+}
 /** Tail the daemon's merged pm2 logs, best-effort filtered by instance id. */
 async function tailLogs(instanceId, lines) {
     const dir = join(rynxHome(), "logs");

package/dist/control-endpoint.d.ts

@@ -0,0 +1,14 @@
+export interface DaemonControlEndpoint {
+    origin: string;
+    pid: number;
+    managementToken: string;
+}
+/**
+ * Resolve the single resident daemon advertised by RYNX_HOME. If no live owner
+ * exists, start the pm2-supervised daemon and wait for it to publish its
+ * endpoint. This deliberately never guesses another port or starts an
+ * app-owned daemon.
+ */
+export declare function ensureDaemonControlEndpoint(options?: {
+    signal?: AbortSignal;
+}): Promise<DaemonControlEndpoint>;

package/dist/control-endpoint.js

@@ -0,0 +1,124 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import { isPm2DaemonOnline, startDaemon } from "./pm2.js";
+const STARTUP_TIMEOUT_MS = 20_000;
+const PROBE_TIMEOUT_MS = 1_000;
+/**
+ * Resolve the single resident daemon advertised by RYNX_HOME. If no live owner
+ * exists, start the pm2-supervised daemon and wait for it to publish its
+ * endpoint. This deliberately never guesses another port or starts an
+ * app-owned daemon.
+ */
+export async function ensureDaemonControlEndpoint(options = {}) {
+    const { signal } = options;
+    signal?.throwIfAborted();
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    const current = await readControlEndpoint();
+    if (current && isProcessAlive(current.pid)) {
+        const recovered = await waitForOwnedEndpoint(current, deadline, signal);
+        if (recovered)
+            return recovered;
+        if (isProcessAlive(current.pid)) {
+            throw new Error(`Rynx daemon process ${current.pid} is alive but its control endpoint did not become healthy`);
+        }
+    }
+    if (Date.now() >= deadline) {
+        throw new Error("Rynx daemon stopped before its control endpoint became healthy");
+    }
+    const force = isPm2DaemonOnline();
+    const status = startDaemon({ force, quiet: true });
+    if (status !== 0)
+        throw new Error("failed to start the Rynx daemon");
+    while (Date.now() < deadline) {
+        signal?.throwIfAborted();
+        const endpoint = await readControlEndpoint();
+        if (endpoint && isProcessAlive(endpoint.pid) && await isHealthy(endpoint.origin, signal))
+            return endpoint;
+        await abortableDelay(100, signal);
+    }
+    throw new Error("Rynx daemon did not publish a ready control endpoint");
+}
+async function waitForOwnedEndpoint(endpoint, deadline, signal) {
+    while (Date.now() < deadline && isProcessAlive(endpoint.pid)) {
+        signal?.throwIfAborted();
+        if (await isHealthy(endpoint.origin, signal))
+            return endpoint;
+        await abortableDelay(100, signal);
+    }
+    return null;
+}
+async function readControlEndpoint() {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(rynxHome(), "control.json"), "utf8"));
+        if (typeof parsed.origin !== "string" ||
+            typeof parsed.pid !== "number" ||
+            !Number.isInteger(parsed.pid) ||
+            parsed.pid <= 0 ||
+            typeof parsed.managementToken !== "string" ||
+            parsed.managementToken.length < 32 ||
+            parsed.managementToken.length > 256) {
+            return null;
+        }
+        const origin = new URL(parsed.origin);
+        if ((origin.protocol !== "http:" && origin.protocol !== "https:") ||
+            origin.username ||
+            origin.password ||
+            origin.search ||
+            origin.hash) {
+            return null;
+        }
+        return {
+            origin: origin.toString().replace(/\/$/, ""),
+            pid: parsed.pid,
+            managementToken: parsed.managementToken,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function isHealthy(origin, signal) {
+    try {
+        const response = await fetch(`${origin}/health`, {
+            signal: signal
+                ? AbortSignal.any([signal, AbortSignal.timeout(PROBE_TIMEOUT_MS)])
+                : AbortSignal.timeout(PROBE_TIMEOUT_MS),
+        });
+        return response.ok;
+    }
+    catch {
+        signal?.throwIfAborted();
+        return false;
+    }
+}
+async function abortableDelay(ms, signal) {
+    signal?.throwIfAborted();
+    if (!signal) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        return;
+    }
+    const activeSignal = signal;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(done, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            activeSignal.removeEventListener("abort", abort);
+            reject(activeSignal.reason);
+        };
+        function done() {
+            activeSignal.removeEventListener("abort", abort);
+            resolve();
+        }
+        activeSignal.addEventListener("abort", abort, { once: true });
+    });
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/control-link-store.d.ts

@@ -0,0 +1,16 @@
+export interface ControlLink {
+    token: string;
+    path: string;
+    expiresAt: string;
+}
+/** Create a short-lived, one-use link into the generic session console. */
+export declare function createControlLink(input: {
+    pluginId: string;
+    sessionId: string;
+    ttlMs?: number;
+}): ControlLink;
+/** Atomically consume a control link. Expired and replayed links are rejected. */
+export declare function consumeControlLink(tokenInput: string): {
+    sessionId: string;
+} | null;
+export declare function pruneControlLinks(now?: string): number;

package/dist/control-link-store.js

@@ -0,0 +1,53 @@
+import { randomBytes } from "node:crypto";
+import { db } from "./db.js";
+const DEFAULT_TTL_MS = 5 * 60_000;
+const MAX_TTL_MS = 15 * 60_000;
+/** Create a short-lived, one-use link into the generic session console. */
+export function createControlLink(input) {
+    const pluginId = required(input.pluginId, "pluginId");
+    const sessionId = required(input.sessionId, "sessionId");
+    const ttlMs = Math.min(MAX_TTL_MS, Math.max(1_000, input.ttlMs ?? DEFAULT_TTL_MS));
+    const token = randomBytes(32).toString("base64url");
+    const createdAt = new Date();
+    const expiresAt = new Date(createdAt.getTime() + ttlMs).toISOString();
+    db()
+        .prepare(`INSERT INTO control_links
+         (token, plugin_id, session_id, created_at, expires_at, used_at)
+       VALUES (?, ?, ?, ?, ?, NULL)`)
+        .run(token, pluginId, sessionId, createdAt.toISOString(), expiresAt);
+    return { token, path: `/control/link?token=${encodeURIComponent(token)}`, expiresAt };
+}
+/** Atomically consume a control link. Expired and replayed links are rejected. */
+export function consumeControlLink(tokenInput) {
+    const token = tokenInput.trim();
+    if (!token || token.length > 512)
+        return null;
+    const now = new Date().toISOString();
+    const consume = db().transaction(() => {
+        const row = db()
+            .prepare(`SELECT session_id
+         FROM control_links
+         WHERE token = ? AND used_at IS NULL AND expires_at > ?`)
+            .get(token, now);
+        if (!row)
+            return null;
+        const updated = db()
+            .prepare("UPDATE control_links SET used_at = ? WHERE token = ? AND used_at IS NULL")
+            .run(now, token);
+        return updated.changes === 1 ? { sessionId: row.session_id } : null;
+    });
+    return consume.immediate();
+}
+export function pruneControlLinks(now = new Date().toISOString()) {
+    return db()
+        .prepare("DELETE FROM control_links WHERE expires_at <= ? OR used_at IS NOT NULL")
+        .run(now).changes;
+}
+function required(value, label) {
+    const normalized = value?.trim();
+    if (!normalized)
+        throw new Error(`${label} is required`);
+    if (normalized.length > 512)
+        throw new Error(`${label} is too long`);
+    return normalized;
+}

package/dist/daemon-owner.d.ts

@@ -0,0 +1,14 @@
+export interface DaemonOwnerLease {
+    readonly pid: number;
+    readonly lockPath: string;
+    release(): Promise<void>;
+}
+/**
+ * Claim the one daemon owner slot for this RYNX_HOME.
+ *
+ * A dedicated SQLite exclusive transaction is the lease. It is backed by the
+ * operating system's file lock and is therefore released automatically when a
+ * process exits, without a PID-check/removal race between competing starters.
+ * The adjacent JSON file is diagnostics only and never decides ownership.
+ */
+export declare function acquireDaemonOwner(env?: NodeJS.ProcessEnv): Promise<DaemonOwnerLease>;

package/dist/daemon-owner.js

@@ -0,0 +1,104 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import Database from "better-sqlite3";
+const LOCK_FILE = "daemon-owner.sqlite";
+const OWNER_FILE = "daemon-owner.json";
+/**
+ * Claim the one daemon owner slot for this RYNX_HOME.
+ *
+ * A dedicated SQLite exclusive transaction is the lease. It is backed by the
+ * operating system's file lock and is therefore released automatically when a
+ * process exits, without a PID-check/removal race between competing starters.
+ * The adjacent JSON file is diagnostics only and never decides ownership.
+ */
+export async function acquireDaemonOwner(env = process.env) {
+    const home = rynxHome(env);
+    const lockPath = path.join(home, LOCK_FILE);
+    const ownerFile = path.join(home, OWNER_FILE);
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    const connection = new Database(lockPath, { timeout: 0 });
+    try {
+        connection.pragma("busy_timeout = 0");
+        connection.exec("BEGIN EXCLUSIVE");
+        // Force this transaction to hold a write lock even on a brand-new file.
+        connection.exec("CREATE TABLE IF NOT EXISTS daemon_owner_guard (id INTEGER PRIMARY KEY)");
+    }
+    catch (error) {
+        connection.close();
+        if (hasCode(error, "SQLITE_BUSY") || hasCode(error, "SQLITE_LOCKED")) {
+            throw await ownerConflictError(home, ownerFile);
+        }
+        throw error;
+    }
+    try {
+        await chmod(lockPath, 0o600);
+    }
+    catch {
+        // Best effort on filesystems without POSIX permissions.
+    }
+    const nonce = randomUUID();
+    try {
+        await publishOwner(ownerFile, nonce);
+    }
+    catch (error) {
+        rollbackAndClose(connection);
+        throw error;
+    }
+    let released = false;
+    return {
+        pid: process.pid,
+        lockPath,
+        async release() {
+            if (released)
+                return;
+            released = true;
+            await removeOwnedMetadata(ownerFile, nonce);
+            rollbackAndClose(connection);
+        },
+    };
+}
+async function publishOwner(ownerFile, nonce) {
+    const temporary = `${ownerFile}.tmp-${process.pid}-${nonce}`;
+    try {
+        await writeFile(temporary, `${JSON.stringify({ pid: process.pid, nonce, startedAt: new Date().toISOString() })}\n`, { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, ownerFile);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+async function removeOwnedMetadata(ownerFile, nonce) {
+    try {
+        const current = JSON.parse(await readFile(ownerFile, "utf8"));
+        if (current.nonce === nonce)
+            await rm(ownerFile, { force: true });
+    }
+    catch {
+        // Metadata is diagnostic only. Never let it prevent releasing the OS lock.
+    }
+}
+async function ownerConflictError(home, ownerFile) {
+    try {
+        const current = JSON.parse(await readFile(ownerFile, "utf8"));
+        if (typeof current.pid === "number" && Number.isSafeInteger(current.pid) && current.pid > 0) {
+            return new Error(`Rynx daemon already owns ${home} (pid ${current.pid})`);
+        }
+    }
+    catch {
+        // The SQLite lease is authoritative even when diagnostics are unavailable.
+    }
+    return new Error(`Rynx daemon already owns ${home}`);
+}
+function rollbackAndClose(connection) {
+    try {
+        connection.exec("ROLLBACK");
+    }
+    finally {
+        connection.close();
+    }
+}
+function hasCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/dist/daemon-server.d.ts

@@ -1,7 +1,17 @@
 import { type AppConfig } from "@rynx-ai/core";
-import { startServer } from "@rynx-ai/server";
+import { startServer, startDirectRuntimeServer } from "@rynx-ai/server";
+import { type DaemonOwnerLease } from "./daemon-owner.js";
+import { type DirectRuntimeConfig } from "./direct-runtime-config.js";
 export interface StartRynxDaemonServerOptions {
     config?: AppConfig;
     warn?: (message: string) => void;
+    /** Test/deployment seam; failures roll back the already-listening server. */
+    writeEndpoint?: (config: AppConfig, managementToken: string) => Promise<void>;
+    /** Test seam for owner-lock failure injection. Production always uses the RYNX_HOME lease. */
+    acquireOwner?: () => Promise<DaemonOwnerLease>;
+    /** Test/deployment seam for the always-available Direct Runtime socket. */
+    loadDirectConfig?: () => Promise<DirectRuntimeConfig>;
+    /** Test seam for listener lifecycle and bind failures. */
+    startDirectServer?: typeof startDirectRuntimeServer;
 }
-export declare function startRynxDaemonServer({ config, warn, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;
+export declare function startRynxDaemonServer({ config, warn, writeEndpoint, acquireOwner, loadDirectConfig, startDirectServer, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;