@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/plugin-store.js

@@ -1,56 +1,121 @@
 /**
- * CRUD over the `plugins` table — the registry of installed plugins the loader
- * imports at boot. A plugin is installed either from npm (`source: "npm"`, into
- * `~/.rynx/plugins`) or from a local directory (`source: "local"`, loaded in
- * place). The daemon ships with none; channel plugins are installed by the user.
+ * Durable inventory of installed plugin packages.
+ *
+ * The registry stores only static, validated manifest data and a host-owned
+ * installation path. Runtime modules are never imported while reading this
+ * table. Rows from the pre-v1 executable-manifest format remain visible to the
+ * CLI, but are not runnable and must be reinstalled.
  */
+import { parsePluginManifest, } from "@rynx-ai/plugin-sdk";
 import { db } from "./db.js";
 function toRecord(row) {
+    const manifest = parseStoredManifest(row.manifest);
     return {
         name: row.name,
         spec: row.spec,
-        source: row.source,
+        source: parseSource(row.source),
         version: row.version ?? undefined,
         enabled: row.enabled !== 0,
         installedAt: row.installed_at,
+        updatedAt: row.updated_at ?? row.installed_at,
+        installPath: row.install_path ?? undefined,
+        manifest,
+        integrity: row.integrity ?? undefined,
+        grants: parseStoredGrants(row.grants, manifest),
     };
 }
-/** All installed plugins, enabled or not. */
+/** All installed plugins, including incompatible legacy rows. */
 export function listPlugins() {
     const rows = db().prepare("SELECT * FROM plugins ORDER BY name").all();
     return rows.map(toRecord);
 }
-/** Only enabled plugins — the set the loader imports. */
+/** Enabled v1 installations that are safe for the runner to consider. */
 export function listEnabledPlugins() {
-    return listPlugins().filter((p) => p.enabled);
+    return listPlugins().filter(isRunnablePluginRecord).filter((plugin) => plugin.enabled);
 }
 export function getPlugin(name) {
     const row = db().prepare("SELECT * FROM plugins WHERE name = ?").get(name);
     return row ? toRecord(row) : undefined;
 }
-/** Insert or replace a plugin record (idempotent install). */
+/** Atomically point a plugin id at a completely materialized installation. */
 export function upsertPlugin(rec) {
+    if (rec.name !== rec.manifest.id) {
+        throw new Error(`plugin registry id mismatch: ${rec.name} != ${rec.manifest.id}`);
+    }
+    const requested = new Set(rec.manifest.requestedCapabilities);
+    for (const grant of rec.grants) {
+        if (!requested.has(grant))
+            throw new Error(`plugin grant was not requested: ${grant}`);
+    }
+    const now = new Date().toISOString();
     db()
-        .prepare(`INSERT INTO plugins (name, spec, source, version, enabled, installed_at)
-       VALUES (@name, @spec, @source, @version, @enabled, @installedAt)
+        .prepare(`INSERT INTO plugins (
+         name, spec, source, version, enabled, installed_at, updated_at,
+         install_path, manifest, integrity, grants
+       ) VALUES (
+         @name, @spec, @source, @version, @enabled, @now, @now,
+         @installPath, @manifest, @integrity, @grants
+       )
        ON CONFLICT(name) DO UPDATE SET
          spec = excluded.spec,
          source = excluded.source,
          version = excluded.version,
-         enabled = excluded.enabled`)
+         enabled = excluded.enabled,
+         installed_at = excluded.installed_at,
+         updated_at = excluded.updated_at,
+         install_path = excluded.install_path,
+         manifest = excluded.manifest,
+         integrity = excluded.integrity,
+         grants = excluded.grants`)
         .run({
         name: rec.name,
         spec: rec.spec,
         source: rec.source,
         version: rec.version ?? null,
         enabled: rec.enabled === false ? 0 : 1,
-        installedAt: new Date().toISOString(),
+        now,
+        installPath: rec.installPath,
+        manifest: JSON.stringify(rec.manifest),
+        integrity: rec.integrity,
+        grants: JSON.stringify([...rec.grants]),
     });
 }
 export function setPluginEnabled(name, enabled) {
-    db().prepare("UPDATE plugins SET enabled = ? WHERE name = ?").run(enabled ? 1 : 0, name);
+    db()
+        .prepare("UPDATE plugins SET enabled = ?, updated_at = ? WHERE name = ?")
+        .run(enabled ? 1 : 0, new Date().toISOString(), name);
 }
-/** Remove a plugin record. Returns false if it wasn't present. */
+/** Remove only the registry row. Package deletion is owned by the installer. */
 export function removePlugin(name) {
     return db().prepare("DELETE FROM plugins WHERE name = ?").run(name).changes > 0;
 }
+export function isRunnablePluginRecord(record) {
+    return Boolean(record.installPath && record.manifest && record.integrity);
+}
+function parseStoredManifest(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        return parsePluginManifest(JSON.parse(raw));
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseStoredGrants(raw, manifest) {
+    if (!raw || !manifest)
+        return [];
+    try {
+        const values = JSON.parse(raw);
+        if (!Array.isArray(values))
+            return [];
+        const requested = new Set(manifest.requestedCapabilities);
+        return values.filter((value) => typeof value === "string" && requested.has(value));
+    }
+    catch {
+        return [];
+    }
+}
+function parseSource(value) {
+    return value === "local" || value === "git" || value === "url" ? value : "npm";
+}

package/dist/plugin-supervisor.d.ts

@@ -0,0 +1,160 @@
+import { type ChannelTypeDescriptor } from "@rynx-ai/core";
+import { type SpawnPluginRunnerOptions } from "@rynx-ai/plugin-runner";
+import { type PluginAuthMaterial, type PluginContributionStatus, type PluginContributionTarget, type PluginJsonValue, type PluginRunnerHandshake, type PluginRuntimeStatus, type PluginStartContributionRequest } from "@rynx-ai/plugin-sdk";
+import { type PluginHostServices } from "./plugin-host-rpc.js";
+import type { RunnablePluginRecord } from "./plugin-store.js";
+export interface PluginRunnerClientHandle {
+    startContribution(request: PluginStartContributionRequest): Promise<void>;
+    stopContribution(target: PluginContributionTarget): Promise<void>;
+    status(target: PluginContributionTarget): Promise<PluginContributionStatus>;
+    runtimeStatus(): Promise<PluginRuntimeStatus>;
+    authorize(request: {
+        kind: "chat-channel";
+        contributionId: string;
+        instanceId?: string;
+        config: Readonly<Record<string, PluginJsonValue>>;
+    }, onMaterial: (material: PluginAuthMaterial) => void, options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<Record<string, PluginJsonValue>>;
+    emitHostEvent(event: string, payload?: unknown): Promise<void>;
+}
+/** The subset of a spawned runner the supervisor owns. Kept structural for tests. */
+export interface SupervisedPluginRunner {
+    readonly client: PluginRunnerClientHandle;
+    readonly handshake: PluginRunnerHandshake;
+    readonly completion: Promise<{
+        code: number | null;
+        signal: NodeJS.Signals | null;
+    }>;
+    close(): Promise<void>;
+}
+export type PluginRunnerSpawnFactory = (options: SpawnPluginRunnerOptions) => Promise<SupervisedPluginRunner>;
+export interface PluginSupervisorLogEntry {
+    level: "info" | "warn" | "error";
+    event: string;
+    pluginId: string;
+    message?: string;
+    delayMs?: number;
+    code?: number | null;
+    signal?: NodeJS.Signals | null;
+}
+export interface PluginSupervisorOptions {
+    /**
+     * Trusted daemon-owned services. May be bound later because the composition
+     * root needs the static channel catalog before startServer constructs them.
+     */
+    services?: PluginHostServices;
+    spawnRunner?: PluginRunnerSpawnFactory;
+    log?: (entry: PluginSupervisorLogEntry) => void;
+    /** Test knobs; production restart delay is always capped at 30 seconds. */
+    restartBaseMs?: number;
+    restartMaxMs?: number;
+    stableResetMs?: number;
+    /** Test override. Production generates one identity per supervisor process lifetime. */
+    daemonInstanceId?: string;
+}
+export interface PluginContributionRuntimeSnapshot {
+    key: string;
+    target: PluginContributionTarget;
+    desired: boolean;
+    generation?: number;
+    failureCount: number;
+    status: PluginContributionStatus;
+}
+export interface PluginRunnerRuntimeSnapshot {
+    state: "stopped" | "starting" | "running" | "backoff" | "failed";
+    generation: number;
+    failureCount: number;
+    lastError?: string;
+}
+export interface PluginRuntimeStatusSnapshot {
+    capturedAt: string;
+    plugins: Array<{
+        pluginId: string;
+        runner: PluginRunnerRuntimeSnapshot;
+        runtimeStatus: PluginRuntimeStatus;
+        contributions: PluginContributionRuntimeSnapshot[];
+    }>;
+}
+/**
+ * Owns isolated plugin child processes and projects their static chat-channel
+ * declarations onto trusted host-side ChannelManager handles.
+ *
+ * There is at most one resident child per enabled plugin. Chat-channel
+ * instances are independent desired-state entries inside that child, so
+ * stopping the final channel does not tear down the plugin runtime itself.
+ */
+export declare class PluginSupervisor {
+    private readonly states;
+    private services?;
+    private readonly spawnRunner;
+    private readonly logger?;
+    private readonly restartBaseMs;
+    private readonly restartMaxMs;
+    private readonly stableResetMs;
+    private readonly daemonInstanceId;
+    private readonly runtimeOperations;
+    private disposed;
+    constructor(plugins: readonly RunnablePluginRecord[], options: PluginSupervisorOptions);
+    /** Static channel catalog. Calling this never loads or executes plugin code. */
+    createChannelTypeDescriptors(): ChannelTypeDescriptor[];
+    /** Bind the trusted host once, after the server composition root constructs it. */
+    bindHostServices(services: PluginHostServices): this;
+    /** Cached, non-blocking runner/contribution health for the generic control API. */
+    statusSnapshot(): PluginRuntimeStatusSnapshot;
+    /** Start one resident runner for every enabled runtime plugin. */
+    startPluginRuntimes(): Promise<void>;
+    /**
+     * Atomically replace or add one plugin runtime, preserving its live chat
+     * desired state. Concurrent reloads of the same plugin are applied in call
+     * order; other plugins continue running independently.
+     */
+    reloadPluginRuntime(record: RunnablePluginRecord, { readyTimeoutMs }?: {
+        readyTimeoutMs?: number;
+    }): Promise<PluginRuntimeStatus>;
+    /**
+     * Make one enabled plugin runtime ready without replacing an already healthy
+     * runner. This is the idempotent operation plugin CLIs use when their durable
+     * configuration has not changed.
+     */
+    ensurePluginRuntime(record: RunnablePluginRecord, { readyTimeoutMs }?: {
+        readyTimeoutMs?: number;
+    }): Promise<PluginRuntimeStatus>;
+    private enqueueRuntimeOperation;
+    private performPluginRuntimeEnsure;
+    private performPluginRuntimeReload;
+    /** Permanently stop all children and cancel every pending automatic restart. */
+    dispose(): Promise<void>;
+    private channelDescriptor;
+    private createRemoteChannel;
+    private authorize;
+    private rememberDesired;
+    private ensureDesiredStarted;
+    private startDesiredOnRunner;
+    private stopDesired;
+    private refreshContributionStatus;
+    private refreshRuntimeStatus;
+    private waitForRuntimeReady;
+    private runtimeReadyTimeoutError;
+    private ensureRunner;
+    private spawnAndBind;
+    private trackRunnerExit;
+    private runnerExited;
+    private joinExitTransition;
+    private scheduleRestart;
+    private restart;
+    private restoreDesiredContributions;
+    private closeRunner;
+    private disposeState;
+    private cancelRestart;
+    private markRunnerUnavailable;
+    private markContributionFailed;
+    private stderrSink;
+    private writeLog;
+    private assertOpen;
+    private assertReady;
+    private requireHostServices;
+}
+/** Convenience export for composition roots that only need the static catalog. */
+export declare function createChannelTypeDescriptors(supervisor: PluginSupervisor): ChannelTypeDescriptor[];