@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/migrations/cleanup-legacy-sessions.js

@@ -2,29 +2,24 @@
  * Self-healing cleanup of legacy, origin-encoded sessions.
  *
  * Sessions now carry an opaque `sess_<uuid>` id. Any session keyed by a legacy id
- * (`session_<uuid>` console, `lark:…:session:<uuid>` / `lark:…` channel) is simply
- * discarded — not migrated — so the system stays clean and every channel re-mints
- * a fresh `sess_` session on its next message.
+ * is discarded rather than migrated.
  *
  * Deletes:
  *   - canonical-log rows (`session_items`) and identity rows (`sessions`) whose
  *     id is not an opaque `sess_` id,
- *   - the runtime thread→rollout bindings `.codex-proxy/sessions.json` and the
- *     channel routing maps `.codex-proxy/lark-sessions*.json` entries that point
- *     at a legacy id (the externalKey KEYS go too, so the next message bootstraps
- *     a fresh session).
+ *   - the daemon-owned runtime thread→rollout bindings in
+ *     `.codex-proxy/sessions.json` that use a legacy id.
  *
  * Runs on every daemon boot (not marker-gated): on a healthy system it deletes
  * nothing and writes nothing, so it is cheap; if a legacy session ever appears
- * (e.g. an old channel plugin produced one), the next boot removes it. The
- * `sess_` filter means it can never touch a current session.
+ * the next boot removes it. The `sess_` filter means it can never touch a
+ * current session. Plugin-private routing stores are deliberately not read.
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { isMachineSessionId } from "@rynx-ai/core";
 import { db } from "../db.js";
-/** Mirrors the channel stores' own resolution (`<cwd>/.codex-proxy`). Kept local
- *  so the daemon needn't depend on `@rynx-ai/runtime` / the lark plugin. */
+/** Mirrors the daemon runtime store's default resolution. */
 function defaultProxyDir() {
     return path.join(process.cwd(), ".codex-proxy");
 }
@@ -37,13 +32,10 @@ export function cleanupLegacySessions(opts = {}) {
     const dryRun = Boolean(opts.dryRun);
     const conn = db();
     const codexStorePath = opts.codexStorePath ?? path.join(defaultProxyDir(), "sessions.json");
-    const channelStoreDir = opts.channelStoreDir ?? defaultProxyDir();
-    const larkFiles = listLarkStoreFiles(channelStoreDir);
     if (dryRun) {
         const deletedLogRows = countRows(conn, `SELECT COUNT(*) AS n FROM session_items WHERE ${LEGACY_LOG}`);
         const deletedSessions = countRows(conn, `SELECT COUNT(*) AS n FROM sessions WHERE ${LEGACY_META}`);
-        const prunedStoreEntries = countLegacyStoreEntries(readJsonStore(codexStorePath), (key) => key) +
-            larkFiles.reduce((sum, file) => sum + countLegacyStoreEntries(readJsonStore(file), (_k, rec) => rec.sessionId), 0);
+        const prunedStoreEntries = countLegacyStoreEntries(readJsonStore(codexStorePath), (key) => key);
         log({ event: "cleanup.dry_run", deletedLogRows, deletedSessions, prunedStoreEntries });
         return { dryRun: true, deletedLogRows, deletedSessions, prunedStoreEntries };
     }
@@ -54,12 +46,9 @@ export function cleanupLegacySessions(opts = {}) {
         deletedLogRows = conn.prepare(`DELETE FROM session_items WHERE ${LEGACY_LOG}`).run().changes;
         deletedSessions = conn.prepare(`DELETE FROM sessions WHERE ${LEGACY_META}`).run().changes;
     })();
-    // Prune the JSON stores: a codex entry keyed by a legacy id, or a routing entry
-    // whose value points at one. Removing the routing entry makes the next message
-    // bootstrap a fresh `sess_` session for that conversation.
+    // The runtime store is daemon-owned. Plugin routing stores remain private to
+    // their plugins and are never inspected by this migration.
     prunedStoreEntries += pruneStore(codexStorePath, (key) => key);
-    for (const file of larkFiles)
-        prunedStoreEntries += pruneStore(file, (_k, rec) => rec.sessionId);
     if (deletedLogRows || deletedSessions || prunedStoreEntries) {
         log({ event: "cleanup.done", deletedLogRows, deletedSessions, prunedStoreEntries });
     }
@@ -99,13 +88,6 @@ function pruneStore(file, idOf) {
     }
     return pruned;
 }
-function listLarkStoreFiles(dir) {
-    if (!existsSync(dir))
-        return [];
-    return readdirSync(dir)
-        .filter((name) => /^lark-sessions.*\.json$/.test(name))
-        .map((name) => path.join(dir, name));
-}
 function readJsonStore(file) {
     try {
         const parsed = JSON.parse(readFileSync(file, "utf8"));

package/dist/plugin-cli.d.ts

@@ -0,0 +1,30 @@
+import { type PluginCliHostEffect } from "@rynx-ai/plugin-sdk";
+import { type RunnablePluginRecord } from "./plugin-store.js";
+export interface RunPluginCliOptions {
+    stdio?: "inherit" | "pipe";
+    env?: NodeJS.ProcessEnv;
+    /** Text piped to the child without ever being logged or copied to its argv. */
+    stdin?: string;
+    /** Capture at most this many bytes from each output stream; excess is drained. */
+    captureOutputBytes?: number;
+    /** Abort the child command; the host escalates from SIGTERM to SIGKILL. */
+    signal?: AbortSignal;
+    /** Test seam for the bounded SIGTERM grace period. */
+    terminationGraceMs?: number;
+}
+export interface PluginCliCommandResult {
+    code: number;
+    effects: PluginCliHostEffect[];
+    output?: {
+        stdout: string;
+        stderr: string;
+        stdoutTruncated: boolean;
+        stderrTruncated: boolean;
+    };
+}
+/** Execute one statically declared plugin command in a separate Node process. */
+export declare function runPluginCliCommand(pluginId: string, args: readonly string[], options?: RunPluginCliOptions): Promise<PluginCliCommandResult>;
+export declare function pluginCommandUsage(record: RunnablePluginRecord): string;
+export declare class PluginCliUsageError extends Error {
+    constructor(message: string);
+}

package/dist/plugin-cli.js

@@ -0,0 +1,270 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import { createPluginCliInvocationLeaseId, parsePluginCliHostEffect, removePluginRuntimeLease, writePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
+import { db } from "./db.js";
+import { getPlugin, isRunnablePluginRecord } from "./plugin-store.js";
+import { loadOrCreateDaemonInstallationIdentitySync } from "./installation-id.js";
+const DEFAULT_TERMINATION_GRACE_MS = 2_000;
+const MAX_TERMINATION_GRACE_MS = 30_000;
+/** Execute one statically declared plugin command in a separate Node process. */
+export async function runPluginCliCommand(pluginId, args, options = {}) {
+    const hostEnv = options.env ?? process.env;
+    const terminationGraceMs = options.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS;
+    let child;
+    let completion;
+    let dataDir;
+    let leaseId;
+    let stdout;
+    let stderr;
+    let terminationReason;
+    let forceKillTimer;
+    let abortListener;
+    const effects = new Map();
+    if (options.stdin !== undefined && options.stdio !== "pipe") {
+        throw new Error("plugin CLI stdin requires piped stdio");
+    }
+    if (options.captureOutputBytes !== undefined &&
+        (!Number.isSafeInteger(options.captureOutputBytes) || options.captureOutputBytes < 0)) {
+        throw new Error("plugin CLI output limit must be a non-negative safe integer");
+    }
+    if (!Number.isSafeInteger(terminationGraceMs) ||
+        terminationGraceMs < 0 ||
+        terminationGraceMs > MAX_TERMINATION_GRACE_MS) {
+        throw new Error(`plugin CLI termination grace must be between 0 and ${MAX_TERMINATION_GRACE_MS}ms`);
+    }
+    if (options.signal?.aborted)
+        throw pluginCliAbortError(options.signal.reason);
+    const installationIdentity = loadOrCreateDaemonInstallationIdentitySync(hostEnv);
+    const clearForceKill = () => {
+        if (forceKillTimer)
+            clearTimeout(forceKillTimer);
+        forceKillTimer = undefined;
+    };
+    const childIsRunning = () => Boolean(child && typeof child.pid === "number" && child.exitCode === null && child.signalCode === null);
+    const terminateChild = (reason) => {
+        terminationReason ??= reason;
+        if (!childIsRunning())
+            return;
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // The close/error event remains authoritative for cleanup.
+        }
+        if (forceKillTimer)
+            return;
+        forceKillTimer = setTimeout(() => {
+            forceKillTimer = undefined;
+            if (!childIsRunning())
+                return;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Completion still waits for close/error; no lease is removed early.
+            }
+        }, terminationGraceMs);
+        forceKillTimer.unref?.();
+    };
+    const cleanup = () => {
+        clearForceKill();
+        if (abortListener)
+            options.signal?.removeEventListener("abort", abortListener);
+        abortListener = undefined;
+        if (dataDir && leaseId)
+            removePluginRuntimeLease(dataDir, leaseId);
+    };
+    try {
+        db().transaction(() => {
+            const record = getPlugin(pluginId);
+            if (!record)
+                throw new Error(`plugin "${pluginId}" is not installed`);
+            if (!isRunnablePluginRecord(record)) {
+                throw new Error(`plugin "${pluginId}" uses the removed legacy format; reinstall it`);
+            }
+            // `enabled` controls daemon runtime contributions, not explicit CLI calls.
+            // Keeping commands available lets a user stop/status a managed service before
+            // uninstalling a disabled plugin.
+            const command = args[0];
+            const declared = record.manifest.contributions?.commands?.find((entry) => entry.id === command);
+            if (!command ||
+                command === "--help" ||
+                command === "-h" ||
+                (command === "help" && !declared)) {
+                throw new PluginCliUsageError(pluginCommandUsage(record));
+            }
+            if (!declared) {
+                throw new PluginCliUsageError(`plugin "${pluginId}" does not declare command "${command}"\n\n${pluginCommandUsage(record)}`);
+            }
+            if (!record.manifest.cliEntry) {
+                throw new Error(`plugin "${pluginId}" declares commands but has no cliEntry`);
+            }
+            const packageRoot = realpathSync(record.installPath);
+            const cliEntry = realpathSync(path.resolve(packageRoot, record.manifest.cliEntry));
+            if (!isPathInside(packageRoot, cliEntry) || !statSync(cliEntry).isFile()) {
+                throw new Error(`plugin "${pluginId}" cliEntry resolves outside its package`);
+            }
+            dataDir = path.join(rynxHome(), "plugin-data", record.name);
+            mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+            child = spawn(process.execPath, [cliEntry, ...args], {
+                cwd: dataDir,
+                env: {
+                    ...hostEnv,
+                    RYNX_HOST_INSTALLATION_ID: installationIdentity.installationId,
+                    RYNX_HOST_INSTALLATION_PROOF_ALGORITHM: installationIdentity.algorithm,
+                    RYNX_HOST_INSTALLATION_PUBLIC_KEY: installationIdentity.publicKey,
+                    RYNX_PLUGIN_ID: record.name,
+                    RYNX_PLUGIN_PACKAGE_ROOT: packageRoot,
+                    RYNX_PLUGIN_DATA_DIR: dataDir,
+                },
+                stdio: options.stdio === "pipe"
+                    ? ["pipe", "pipe", "pipe", "ipc"]
+                    : ["inherit", "inherit", "inherit", "ipc"],
+            });
+            completion = new Promise((resolve, reject) => {
+                child.on("message", (message) => {
+                    try {
+                        const effect = parsePluginCliHostEffect(message);
+                        effects.set(effect.effect, effect);
+                    }
+                    catch (error) {
+                        terminateChild(error instanceof Error ? error : new Error(String(error)));
+                    }
+                });
+                child.once("error", (error) => {
+                    if (!childIsRunning()) {
+                        reject(error);
+                        return;
+                    }
+                    terminateChild(error);
+                });
+                child.once("close", (code, signal) => {
+                    clearForceKill();
+                    if (terminationReason) {
+                        reject(terminationReason);
+                        return;
+                    }
+                    if (signal) {
+                        reject(new Error(`plugin command terminated by ${signal}`));
+                        return;
+                    }
+                    resolve(code ?? 1);
+                });
+            });
+            if (options.stdio === "pipe") {
+                stdout = captureStream(child.stdout, options.captureOutputBytes);
+                stderr = captureStream(child.stderr, options.captureOutputBytes);
+                child.stdin.on("error", () => {
+                    // A command may intentionally exit without reading all input. The
+                    // exit status remains the authoritative invocation result.
+                });
+                child.stdin.end(options.stdin ?? "", "utf8");
+            }
+            if (options.signal) {
+                abortListener = () => terminateChild(pluginCliAbortError(options.signal.reason));
+                if (options.signal.aborted)
+                    abortListener();
+                else
+                    options.signal.addEventListener("abort", abortListener, { once: true });
+            }
+            leaseId = createPluginCliInvocationLeaseId(child.pid ?? process.pid);
+            writePluginRuntimeLease({
+                dataDir,
+                pluginId: record.name,
+                leaseId,
+                installPath: packageRoot,
+            });
+        }).immediate();
+    }
+    catch (error) {
+        if (completion && childIsRunning()) {
+            terminateChild(error instanceof Error ? error : new Error(String(error)));
+            await completion.catch(() => undefined);
+        }
+        else if (completion) {
+            await completion.catch(() => undefined);
+        }
+        cleanup();
+        throw error;
+    }
+    try {
+        const code = await completion;
+        return {
+            code,
+            effects: code === 0 ? [...effects.values()] : [],
+            ...(options.captureOutputBytes !== undefined && stdout && stderr
+                ? {
+                    output: {
+                        stdout: stdout.text(),
+                        stderr: stderr.text(),
+                        stdoutTruncated: stdout.truncated(),
+                        stderrTruncated: stderr.truncated(),
+                    },
+                }
+                : {}),
+        };
+    }
+    finally {
+        cleanup();
+    }
+}
+function pluginCliAbortError(reason) {
+    const error = new Error(reason instanceof Error && reason.message ? reason.message : "plugin CLI command aborted");
+    error.name = reason instanceof Error && reason.name === "TimeoutError"
+        ? "TimeoutError"
+        : "AbortError";
+    return error;
+}
+function captureStream(stream, limit) {
+    const chunks = [];
+    let captured = 0;
+    let dropped = false;
+    stream.on("data", (chunk) => {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        if (limit === undefined)
+            return;
+        const remaining = limit - captured;
+        if (remaining <= 0) {
+            if (data.byteLength > 0)
+                dropped = true;
+            return;
+        }
+        if (data.byteLength <= remaining) {
+            chunks.push(data);
+            captured += data.byteLength;
+            return;
+        }
+        chunks.push(data.subarray(0, remaining));
+        captured += remaining;
+        dropped = true;
+    });
+    return {
+        text: () => Buffer.concat(chunks, captured).toString("utf8"),
+        truncated: () => dropped,
+    };
+}
+export function pluginCommandUsage(record) {
+    const commands = record.manifest.contributions?.commands ?? [];
+    const lines = [`Usage: rynx plugin ${record.name} <command> [args...]`];
+    if (commands.length === 0)
+        return [...lines, "", "This plugin declares no CLI commands."].join("\n");
+    lines.push("", "Commands:");
+    for (const command of commands) {
+        lines.push(`  ${command.id.padEnd(16)} ${command.description}`);
+        if (command.usage)
+            lines.push(`  ${"".padEnd(16)} ${command.usage}`);
+    }
+    return lines.join("\n");
+}
+export class PluginCliUsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PluginCliUsageError";
+    }
+}
+function isPathInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}

package/dist/plugin-host-rpc.d.ts

@@ -0,0 +1,85 @@
+import { type AgentCapabilities, type AgentSessionStore, type ConversationRuntime, type SessionRegistry } from "@rynx-ai/core";
+import { type PluginAgentSummary, type PluginCapability, type PluginHostEvent, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
+import type { SessionInteractionResolution } from "@rynx-ai/protocol";
+import { PluginRunnerError } from "@rynx-ai/plugin-runner";
+/** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
+export declare const MAX_PLUGIN_HOST_EVENT_BYTES: number;
+export interface PluginAgentCatalogHost {
+    list(): Promise<PluginAgentSummary[]>;
+    get(id: string): Promise<PluginAgentSummary | null>;
+    resolveExecution(input: {
+        defaultAgent?: string;
+        session: PluginSessionExecutionSnapshot;
+    }): Promise<PluginResolvedSessionExecution>;
+}
+export interface PluginHostServices {
+    installationId: string;
+    installationProof: {
+        algorithm: "Ed25519";
+        publicKey: string;
+        sign(pluginId: string, challenge: string): string;
+    };
+    conversationRuntime: ConversationRuntime;
+    capabilities: AgentCapabilities;
+    sessionStore: AgentSessionStore;
+    sessionRegistry: SessionRegistry;
+    agentCatalog: PluginAgentCatalogHost;
+    interruptSession?(sessionId: string): Promise<boolean>;
+    resolveSessionInteraction?(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
+        disposition: PluginSessionInteractionResolveDisposition;
+    }>;
+}
+export interface PluginHostRpcOptions {
+    pluginId: string;
+    daemonInstanceId: string;
+    grants: readonly PluginCapability[];
+    services: PluginHostServices;
+    /** Resolving this promise is the stream's backpressure acknowledgement. */
+    emit(event: PluginHostEvent): void | Promise<void>;
+}
+/**
+ * One authenticated plugin's capability-gated Host RPC surface.
+ *
+ * This adapter is deliberately the only place that maps public string methods
+ * to trusted runtime objects. The runner receives neither this class nor its
+ * dependencies; it receives JSON responses and canonical session events.
+ */
+export declare class PluginHostRpc {
+    private readonly pluginId;
+    private readonly daemonInstanceId;
+    private readonly grants;
+    private readonly services;
+    private readonly emit;
+    private readonly activeRuns;
+    private readonly activeSessionRuns;
+    private readonly activeRunsByOperation;
+    private disposed;
+    constructor(options: PluginHostRpcOptions);
+    call(method: string, params: unknown): Promise<unknown>;
+    dispose(): Promise<void>;
+    private ensureSession;
+    private runSession;
+    private pumpRun;
+    private releaseRun;
+    private steerSession;
+    private interruptRun;
+    private interruptWon;
+    private activeRun;
+    private activeRunByIdentity;
+    private getBinding;
+    private listBindings;
+    private findBinding;
+    private withOwnedSession;
+    private resolveSessionInteraction;
+    private forkSession;
+    private setSessionTitle;
+    private resolveAgentExecution;
+    private issueControlLink;
+    private ownedSession;
+    private isOwned;
+}
+export declare class PluginHostCallError extends PluginRunnerError {
+    readonly retryable: boolean;
+    readonly data?: unknown | undefined;
+    constructor(code: string, message: string, retryable?: boolean, data?: unknown | undefined);
+}