@rynx-ai/daemon 0.1.11-beta.2 → 0.1.11-beta.21

package/dist/db.js

@@ -1,9 +1,11 @@
 /**
  * `~/.rynx/rynx.db` — the daemon's SQLite store. Concerns kept apart:
- *  - `plugin_installations` — source-qualified manifests, capabilities, and immutable packages.
+ *  - `plugin_installations` — source-qualified manifests and immutable packages.
  *  - `plugin_marketplaces` — catalog registrations; catalog data is never executable.
  *  - `plugin_session_launch_operations` — durable idempotency/tombstones.
  *  - `control_links` — generic, one-use links to the local session console.
+ *  - `session_portal_tickets` / `session_portal_grants` — hashed, scoped,
+ *    browser Session Portal authorization.
  *  - `runtime_pairing_claims` / `runtime_client_grants` — one-use enrollment
  *    claims and the durable client identities they issue for direct runtimes.
  *  - `runtime_targets` / `runtime_direct_routes` / `runtime_pending_enrollments`
@@ -16,8 +18,9 @@
  */
 import { chmodSync, mkdirSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { rynxHome } from "@rynx-ai/core";
-import Database from "better-sqlite3";
+import { transaction } from "./sqlite.js";
 const connections = new Map();
 /** Absolute path to the SQLite file (override via `RYNX_DB`, else `~/.rynx/rynx.db`). */
 export function dbPath() {
@@ -34,9 +37,7 @@ export function db() {
     if (cached)
         return cached;
     mkdirSync(dirname(path), { recursive: true });
-    const conn = new Database(path);
-    conn.pragma("busy_timeout = 5000");
-    conn.pragma("foreign_keys = ON");
+    const conn = new DatabaseSync(path, { timeout: 5000, enableForeignKeyConstraints: true });
     migrate(conn);
     // Plugin state and daemon credentials are private.
     try {
@@ -86,7 +87,6 @@ function migrate(conn) {
       install_path   TEXT NOT NULL,
       manifest       TEXT NOT NULL,
       integrity      TEXT NOT NULL,
-      capabilities   TEXT NOT NULL,
       runtime_state  TEXT,
       runtime_error  TEXT,
       UNIQUE(marketplace_id, plugin_id)
@@ -195,6 +195,7 @@ function migrate(conn) {
       scope_id       TEXT NOT NULL,
       operation_id   TEXT NOT NULL,
       request_hash   TEXT NOT NULL,
+      raw_request_hash TEXT,
       session_id     TEXT NOT NULL,
       state          TEXT NOT NULL DEFAULT 'active' CHECK(state IN ('active', 'deleted')),
       created_at     TEXT NOT NULL,
@@ -244,6 +245,39 @@ function migrate(conn) {
     );
     CREATE INDEX IF NOT EXISTS idx_control_links_expires
       ON control_links(expires_at);
+    CREATE TABLE IF NOT EXISTS session_portal_tickets (
+      ticket_hash TEXT PRIMARY KEY,
+      plugin_id   TEXT NOT NULL,
+      scope       TEXT NOT NULL CHECK(scope IN ('plugin_sessions', 'single_session')),
+      access      TEXT NOT NULL CHECK(access IN ('read_only', 'read_write')),
+      session_id  TEXT,
+      created_at  TEXT NOT NULL,
+      expires_at  TEXT NOT NULL,
+      used_at     TEXT,
+      CHECK(
+        (scope = 'plugin_sessions' AND session_id IS NULL)
+        OR (scope = 'single_session' AND session_id IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_portal_tickets_expires
+      ON session_portal_tickets(expires_at);
+    CREATE TABLE IF NOT EXISTS session_portal_grants (
+      portal_id   TEXT PRIMARY KEY,
+      secret_hash TEXT NOT NULL,
+      plugin_id   TEXT NOT NULL,
+      scope       TEXT NOT NULL CHECK(scope IN ('plugin_sessions', 'single_session')),
+      access      TEXT NOT NULL CHECK(access IN ('read_only', 'read_write')),
+      session_id  TEXT,
+      created_at  TEXT NOT NULL,
+      expires_at  TEXT NOT NULL,
+      revoked_at  TEXT,
+      CHECK(
+        (scope = 'plugin_sessions' AND session_id IS NULL)
+        OR (scope = 'single_session' AND session_id IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_portal_grants_expires
+      ON session_portal_grants(expires_at);
     CREATE TABLE IF NOT EXISTS runtime_pairing_claims (
       claim_id                   TEXT PRIMARY KEY,
       secret_hash                TEXT NOT NULL,
@@ -307,7 +341,7 @@ function migrate(conn) {
     CREATE INDEX IF NOT EXISTS idx_runtime_pending_enrollments_expires
       ON runtime_pending_enrollments(expires_at);
   `);
-    migratePluginCapabilities(conn);
+    migratePluginCapabilityDeclarations(conn);
     migrateSessionSnapshots(conn);
     // Breaking plugin-runtime cutover: remove obsolete core-owned state.
     conn.exec(`
@@ -316,6 +350,19 @@ function migrate(conn) {
   `);
     addColumnIfMissing(conn, "plugin_marketplaces", "built_in", "INTEGER NOT NULL DEFAULT 0");
     addColumnIfMissing(conn, "sessions", "forked_from_session_id", "TEXT");
+    addColumnIfMissing(conn, "plugin_session_launch_operations", "raw_request_hash", "TEXT");
+}
+/** Remove the inert permission-declaration columns left by older installations. */
+function migratePluginCapabilityDeclarations(conn) {
+    const columns = conn
+        .prepare("PRAGMA table_info(plugin_installations)")
+        .all();
+    const names = new Set(columns.map((column) => column.name));
+    for (const legacyColumn of ["capabilities", "grants"]) {
+        if (names.has(legacyColumn)) {
+            conn.exec(`ALTER TABLE plugin_installations DROP COLUMN ${legacyColumn}`);
+        }
+    }
 }
 /**
  * Breaking Session cutover: the previous rows contain mutable Agent/Provider
@@ -328,7 +375,7 @@ function migrateSessionSnapshots(conn) {
     const names = new Set(columns.map((column) => column.name));
     if (names.has("workspace") && names.has("execution"))
         return;
-    conn.transaction(() => {
+    transaction(conn, () => {
         conn.exec(`
       INSERT OR IGNORE INTO session_snapshot_cleanup (session_id)
       SELECT id FROM sessions;
@@ -356,18 +403,6 @@ function migrateSessionSnapshots(conn) {
     `);
     }).immediate();
 }
-function migratePluginCapabilities(conn) {
-    const columns = conn
-        .prepare("PRAGMA table_info(plugin_installations)")
-        .all();
-    if (columns.some((column) => column.name === "capabilities"))
-        return;
-    if (columns.some((column) => column.name === "grants")) {
-        conn.exec("ALTER TABLE plugin_installations RENAME COLUMN grants TO capabilities");
-        return;
-    }
-    conn.exec("ALTER TABLE plugin_installations ADD COLUMN capabilities TEXT NOT NULL DEFAULT '[]'");
-}
 /** Idempotently add a column to an existing table (no-op if already present). */
 function addColumnIfMissing(conn, table, column, ddl) {
     const cols = conn.prepare(`PRAGMA table_info(${table})`).all();

package/dist/entry-path.d.ts

@@ -0,0 +1,3 @@
+/** Resolve the executable daemon module without importing its side-effectful entry. */
+export declare function resolveDaemonEntry(moduleUrl?: string): string;
+export declare function installedDaemonVersion(): string;

package/dist/entry-path.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+/** Resolve the executable daemon module without importing its side-effectful entry. */
+export function resolveDaemonEntry(moduleUrl = import.meta.url) {
+    return join(dirname(fileURLToPath(moduleUrl)), "index-daemon.js");
+}
+export function installedDaemonVersion() {
+    const manifest = require("../package.json");
+    return typeof manifest.version === "string" ? manifest.version : "0.0.0";
+}

package/dist/index-daemon.js

@@ -1,91 +1,7 @@
 #!/usr/bin/env node
-/**
- * The resident daemon entry — this is what pm2 keeps alive.
- *
- * Boot order matters: install the EPIPE guard first (we're a pm2 child).
- * The composition root reads static plugin manifests and supervises one runtime
- * process for each enabled runtime plugin. Installed plugin code is loaded only
- * in child processes; plugin-owned channel instances stay inside that process.
- */
-import { startRynxDaemonServer } from "./daemon-server.js";
-import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
-import { installStdioEpipeGuard } from "./stdio-epipe-guard.js";
-installStdioEpipeGuard();
-async function main() {
-    const followsApp = process.env.RYNX_DAEMON_LIFECYCLE === "follow-app";
-    let parentDisconnected = followsApp && !process.connected;
-    const recordParentDisconnect = () => {
-        parentDisconnected = true;
-    };
-    if (followsApp)
-        process.once("disconnect", recordParentDisconnect);
-    const preparePlugins = async () => {
-        try {
-            const bundled = await ensureBundledOfficialPlugins({ reclaimHostLeases: true });
-            if (bundled.status === "ready") {
-                console.log(JSON.stringify({
-                    level: "info",
-                    type: "bundled_plugins_ready",
-                    installed: bundled.installed,
-                    updated: bundled.updated,
-                }));
-            }
-        }
-        catch (error) {
-            console.error(JSON.stringify({
-                level: "error",
-                type: "bundled_plugins_failed",
-                error: error instanceof Error ? error.message : String(error),
-            }));
-        }
-    };
-    let server;
-    try {
-        server = await startRynxDaemonServer({ preparePlugins });
-    }
-    catch (error) {
-        process.off("disconnect", recordParentDisconnect);
-        throw error;
-    }
-    let shutdownPromise;
-    const shutdown = (signal) => {
-        if (shutdownPromise)
-            return shutdownPromise;
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
-        process.off("disconnect", onDisconnect);
-        shutdownPromise = (async () => {
-            console.log(JSON.stringify({ level: "info", type: "shutdown", signal }));
-            await server.shutdown();
-        })();
-        shutdownPromise.catch((error) => {
-            process.exitCode = 1;
-            console.error(`Shutdown failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-        });
-        return shutdownPromise;
-    };
-    const onSigint = () => {
-        void shutdown("SIGINT");
-    };
-    const onSigterm = () => {
-        void shutdown("SIGTERM");
-    };
-    const onDisconnect = () => {
-        if (process.env.RYNX_DAEMON_LIFECYCLE === "follow-app") {
-            void shutdown("APP_DISCONNECT");
-        }
-    };
-    process.once("SIGINT", onSigint);
-    process.once("SIGTERM", onSigterm);
-    if (followsApp) {
-        process.once("disconnect", onDisconnect);
-        process.off("disconnect", recordParentDisconnect);
-        if (parentDisconnected || !process.connected) {
-            void shutdown("APP_DISCONNECT");
-        }
-    }
-}
-main().catch((err) => {
+/** Direct daemon executable retained only for standalone PM2 supervision. */
+import { runDaemonProcess } from "./process.js";
+runDaemonProcess().catch((err) => {
     console.error(`Fatal error: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
     process.exit(1);
 });

package/dist/lifecycle.d.ts

@@ -0,0 +1,13 @@
+export { formatControlUrl, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
+export { resolveDaemonEntry } from "./entry-path.js";
+export interface StandaloneDaemonLaunchContext {
+    builtinSkillsDir: string;
+    cliVersion: string;
+    productVersion: string;
+    tmuxBin?: string;
+}
+export declare function startDaemon(options: {
+    force: boolean;
+    quiet?: boolean;
+    context: StandaloneDaemonLaunchContext;
+}): number;

package/dist/lifecycle.js

@@ -0,0 +1,19 @@
+import { startDaemon as startPm2Daemon, } from "./pm2.js";
+export { formatControlUrl, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
+export { resolveDaemonEntry } from "./entry-path.js";
+export function startDaemon(options) {
+    return startPm2Daemon({
+        force: options.force,
+        quiet: options.quiet,
+        launchEnvironment: {
+            RYNX_BUILTIN_SKILLS_DIR: options.context.builtinSkillsDir,
+            RYNX_CLI_VERSION: options.context.cliVersion,
+            RYNX_DISTRIBUTION: "standalone",
+            RYNX_PRODUCT_VERSION: options.context.productVersion,
+            RYNX_DAEMON_LIFECYCLE: "standalone",
+            // An empty value explicitly disables PATH fallback when the optional
+            // platform package is missing, while keeping the control plane runnable.
+            RYNX_TMUX_BIN: options.context.tmuxBin ?? "",
+        },
+    });
+}

package/dist/maintenance-lease.d.ts

@@ -0,0 +1,39 @@
+export type MaintenanceLeaseReleaseOutcome = "released" | "not_active" | "denied";
+export interface MaintenanceLeaseStoreOptions {
+    filePath?: string;
+    now?: () => number;
+    ttlMs?: number;
+    /** Test seam; production fsyncs the lease directory after rename/remove. */
+    syncDirectory?: (directory: string) => void;
+    /** Process-local recovery hook, invoked once when a live lease is observed expired. */
+    onExpired?: () => void;
+}
+export declare function maintenanceLeaseFile(env?: NodeJS.ProcessEnv): string;
+/**
+ * Cross-process admission fence used only during daemon replacement.
+ *
+ * The raw bearer token is never persisted. The bounded expiry means a crashed
+ * upgrader cannot leave the daemon permanently unavailable, while atomic rename
+ * ensures a replacement daemon sees either the complete lease or no lease.
+ */
+export declare class MaintenanceLeaseStore {
+    private readonly filePath;
+    private readonly now;
+    private readonly ttlMs;
+    private readonly syncDirectory;
+    private readonly onExpired;
+    private lease;
+    private expiryTimer;
+    constructor(options?: MaintenanceLeaseStoreOptions);
+    isActive(): boolean;
+    isHeldBy(token: string): boolean;
+    acquire(token: string): boolean;
+    release(token: string): MaintenanceLeaseReleaseOutcome;
+    private readPersistedLease;
+    private writePersistedLease;
+    private clear;
+    private clearFile;
+    private expire;
+    private scheduleExpiry;
+    private cancelExpiry;
+}

package/dist/maintenance-lease.js

@@ -0,0 +1,250 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+const LEASE_SCHEMA_VERSION = 1;
+// The detached updater can spend 24h waiting for idle before cutover begins.
+// Once accepted, retain a separate bounded recovery window long enough for the
+// package switch and rollback even if the updater is killed at its outer limit.
+const DEFAULT_LEASE_TTL_MS = 30 * 60 * 60 * 1_000;
+const EXPIRY_RETRY_MS = 1_000;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const LEASE_TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,256}$/;
+export function maintenanceLeaseFile(env = process.env) {
+    return join(rynxHome(env), "maintenance-lease.json");
+}
+/**
+ * Cross-process admission fence used only during daemon replacement.
+ *
+ * The raw bearer token is never persisted. The bounded expiry means a crashed
+ * upgrader cannot leave the daemon permanently unavailable, while atomic rename
+ * ensures a replacement daemon sees either the complete lease or no lease.
+ */
+export class MaintenanceLeaseStore {
+    filePath;
+    now;
+    ttlMs;
+    syncDirectory;
+    onExpired;
+    lease;
+    expiryTimer;
+    constructor(options = {}) {
+        this.filePath = options.filePath ?? maintenanceLeaseFile();
+        this.now = options.now ?? (() => Date.now());
+        this.ttlMs = options.ttlMs ?? DEFAULT_LEASE_TTL_MS;
+        this.syncDirectory = options.syncDirectory ?? fsyncDirectory;
+        this.onExpired = options.onExpired ?? (() => undefined);
+        if (!Number.isSafeInteger(this.ttlMs) || this.ttlMs <= 0) {
+            throw new Error("maintenance lease TTL must be a positive safe integer");
+        }
+        this.lease = this.readPersistedLease();
+        this.scheduleExpiry();
+    }
+    isActive() {
+        if (!this.lease)
+            return false;
+        if (this.lease.expiresAt > this.now())
+            return true;
+        this.expire();
+        return false;
+    }
+    isHeldBy(token) {
+        let tokenHash;
+        try {
+            tokenHash = hashLeaseToken(token);
+        }
+        catch {
+            return false;
+        }
+        return Boolean(this.isActive()
+            && this.lease
+            && hashesEqual(this.lease.tokenHash, tokenHash));
+    }
+    acquire(token) {
+        const tokenHash = hashLeaseToken(token);
+        if (this.isActive()) {
+            if (this.lease && hashesEqual(this.lease.tokenHash, tokenHash)) {
+                const createdAt = this.now();
+                const renewed = {
+                    schemaVersion: LEASE_SCHEMA_VERSION,
+                    tokenHash,
+                    createdAt,
+                    expiresAt: createdAt + this.ttlMs,
+                };
+                // Fail closed in memory if persistence reaches an indeterminate I/O
+                // outcome; the caller sees the error, but this process must not reopen
+                // admission around a lease file that may already have been renamed.
+                this.lease = renewed;
+                try {
+                    this.writePersistedLease(renewed);
+                }
+                finally {
+                    this.scheduleExpiry();
+                }
+                return false;
+            }
+            throw new Error("a different maintenance lease is already active");
+        }
+        const createdAt = this.now();
+        const lease = {
+            schemaVersion: LEASE_SCHEMA_VERSION,
+            tokenHash,
+            createdAt,
+            expiresAt: createdAt + this.ttlMs,
+        };
+        this.lease = lease;
+        try {
+            this.writePersistedLease(lease);
+        }
+        finally {
+            this.scheduleExpiry();
+        }
+        return true;
+    }
+    release(token) {
+        if (!this.isActive())
+            return "not_active";
+        const lease = this.lease;
+        if (!lease)
+            return "not_active";
+        let tokenHash;
+        try {
+            tokenHash = hashLeaseToken(token);
+        }
+        catch {
+            return "denied";
+        }
+        if (!hashesEqual(lease.tokenHash, tokenHash))
+            return "denied";
+        this.clear();
+        return "released";
+    }
+    readPersistedLease() {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(this.filePath, "utf8"));
+        }
+        catch (error) {
+            if (error
+                && typeof error === "object"
+                && "code" in error
+                && error.code === "ENOENT")
+                return undefined;
+            throw new Error("maintenance lease state is unreadable", { cause: error });
+        }
+        if (!isPersistedLease(parsed, this.ttlMs)) {
+            throw new Error("maintenance lease state is invalid");
+        }
+        if (parsed.expiresAt <= this.now()) {
+            this.clearFile();
+            return undefined;
+        }
+        return parsed;
+    }
+    writePersistedLease(lease) {
+        const parent = dirname(this.filePath);
+        mkdirSync(parent, { recursive: true, mode: 0o700 });
+        const temporary = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+        let descriptor;
+        try {
+            descriptor = openSync(temporary, "wx", 0o600);
+            writeFileSync(descriptor, `${JSON.stringify(lease)}\n`, "utf8");
+            fsyncSync(descriptor);
+            closeSync(descriptor);
+            descriptor = undefined;
+            renameSync(temporary, this.filePath);
+            this.syncDirectory(parent);
+        }
+        finally {
+            if (descriptor !== undefined)
+                closeSync(descriptor);
+            rmSync(temporary, { force: true });
+        }
+    }
+    clear() {
+        this.clearFile();
+        this.lease = undefined;
+        this.cancelExpiry();
+    }
+    clearFile() {
+        rmSync(this.filePath, { force: true });
+        this.syncDirectory(dirname(this.filePath));
+    }
+    expire() {
+        this.clear();
+        this.onExpired();
+    }
+    scheduleExpiry(delayOverride) {
+        this.cancelExpiry();
+        if (!this.lease)
+            return;
+        const delay = delayOverride ?? Math.max(0, this.lease.expiresAt - this.now());
+        this.expiryTimer = setTimeout(() => {
+            this.expiryTimer = undefined;
+            if (!this.lease)
+                return;
+            if (this.lease.expiresAt > this.now()) {
+                this.scheduleExpiry();
+                return;
+            }
+            try {
+                this.expire();
+            }
+            catch {
+                // Keep the in-memory fence and retry cleanup. A failed durability
+                // operation must not turn an expired lease into open admission.
+                this.scheduleExpiry(EXPIRY_RETRY_MS);
+            }
+        }, Math.min(delay, MAX_TIMER_DELAY_MS));
+        this.expiryTimer.unref?.();
+    }
+    cancelExpiry() {
+        if (this.expiryTimer)
+            clearTimeout(this.expiryTimer);
+        this.expiryTimer = undefined;
+    }
+}
+function fsyncDirectory(directory) {
+    let descriptor;
+    try {
+        descriptor = openSync(directory, "r");
+        fsyncSync(descriptor);
+    }
+    catch (error) {
+        if (error
+            && typeof error === "object"
+            && "code" in error
+            && error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function hashLeaseToken(token) {
+    if (!LEASE_TOKEN_PATTERN.test(token)) {
+        throw new Error("maintenance lease token must be 32-256 base64url characters");
+    }
+    return createHash("sha256").update(token, "utf8").digest("hex");
+}
+function hashesEqual(left, right) {
+    const leftBuffer = Buffer.from(left, "hex");
+    const rightBuffer = Buffer.from(right, "hex");
+    return leftBuffer.length === rightBuffer.length
+        && timingSafeEqual(leftBuffer, rightBuffer);
+}
+function isPersistedLease(value, maximumTtlMs) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return candidate.schemaVersion === LEASE_SCHEMA_VERSION
+        && typeof candidate.tokenHash === "string"
+        && /^[a-f0-9]{64}$/.test(candidate.tokenHash)
+        && Number.isSafeInteger(candidate.createdAt)
+        && Number.isSafeInteger(candidate.expiresAt)
+        && candidate.createdAt >= 0
+        && candidate.expiresAt > candidate.createdAt
+        && candidate.expiresAt - candidate.createdAt <= maximumTtlMs;
+}

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

@@ -20,6 +20,7 @@ import { mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { rynxHome } from "@rynx-ai/core";
 import { db } from "../db.js";
+import { transaction } from "../sqlite.js";
 /** Mirrors the daemon runtime store's default resolution. */
 function defaultProxyDir() {
     return path.join(rynxHome(), ".codex-proxy");
@@ -46,9 +47,9 @@ export function cleanupLegacySessions(opts = {}) {
     let deletedLogRows = 0;
     let deletedSessions = 0;
     let prunedStoreEntries = 0;
-    conn.transaction(() => {
-        deletedLogRows = conn.prepare(`DELETE FROM session_items WHERE ${LEGACY_LOG}`).run().changes;
-        deletedSessions = conn.prepare(`DELETE FROM sessions WHERE ${LEGACY_META}`).run().changes;
+    transaction(conn, () => {
+        deletedLogRows = Number(conn.prepare(`DELETE FROM session_items WHERE ${LEGACY_LOG}`).run().changes);
+        deletedSessions = Number(conn.prepare(`DELETE FROM sessions WHERE ${LEGACY_META}`).run().changes);
     })();
     // The runtime store is daemon-owned. Plugin routing stores remain private to
     // their plugins and are never inspected by this migration.

package/dist/plugin-cli.d.ts

@@ -20,6 +20,16 @@ export interface PluginCliCommandResult {
         stderrTruncated: boolean;
     };
 }
+export interface InstalledPluginListItem {
+    id: string;
+    version: string;
+    source: "local" | "git";
+    state: "enabled" | "disabled";
+}
+/** Read the durable installed-plugin inventory without contacting the daemon. */
+export declare function listInstalledPlugins(): InstalledPluginListItem[];
+/** Render manifest-declared command help without executing plugin code. */
+export declare function installedPluginCommandUsage(pluginId: string): string;
 /** Execute one statically declared, language-neutral plugin command. */
 export declare function runPluginCliCommand(pluginId: string, args: readonly string[], options?: RunPluginCliOptions): Promise<PluginCliCommandResult>;
 export declare function pluginCommandUsage(record: RunnablePluginRecord): string;

package/dist/plugin-cli.js

@@ -3,12 +3,29 @@ import { mkdirSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { createPluginCliInvocationLeaseId, removePluginRuntimeLease, writePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
 import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
 import { pluginDataDir, pluginRuntimeCacheDir } from "./plugin-installer.js";
 import { validatePluginPackageSnapshot } from "./plugin-package.js";
-import { getPlugin } from "./plugin-store.js";
+import { getPlugin, listPlugins, } from "./plugin-store.js";
 import { loadOrCreateDaemonInstallationIdentitySync } from "./installation-id.js";
 const DEFAULT_TERMINATION_GRACE_MS = 2_000;
 const MAX_TERMINATION_GRACE_MS = 30_000;
+/** Read the durable installed-plugin inventory without contacting the daemon. */
+export function listInstalledPlugins() {
+    return listPlugins().map((record) => ({
+        id: record.canonicalId,
+        version: record.version,
+        source: record.source,
+        state: record.enabled ? "enabled" : "disabled",
+    }));
+}
+/** Render manifest-declared command help without executing plugin code. */
+export function installedPluginCommandUsage(pluginId) {
+    const record = getPlugin(pluginId);
+    if (!record)
+        throw new Error(`plugin "${pluginId}" is not installed`);
+    return pluginCommandUsage(record);
+}
 /** Execute one statically declared, language-neutral plugin command. */
 export async function runPluginCliCommand(pluginId, args, options = {}) {
     const hostEnv = options.env ?? process.env;
@@ -74,7 +91,7 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
             removePluginRuntimeLease(dataDir, leaseId);
     };
     try {
-        db().transaction(() => {
+        transaction(db(), () => {
             const record = getPlugin(pluginId);
             if (!record)
                 throw new Error(`plugin "${pluginId}" is not installed`);