@rynx-ai/daemon 0.1.11-beta.52 → 0.1.11-beta.54

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11-beta.52",
+  "version": "0.1.11-beta.54",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/bundled-plugins.js

@@ -2,9 +2,8 @@ import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync,
 import { fileURLToPath } from "node:url";
 import { isAbsolute, join } from "node:path";
 import { rynxHome } from "@rynx-ai/core";
-import { removePluginRuntimeLease } from "@rynx-ai/plugin-sdk";
 import { pluginDataDir, preparePluginInstallation, } from "./plugin-installer.js";
-import { PLUGIN_HOST_RUNTIME_LEASE_IDS } from "./plugin-host-leases.js";
+import { reclaimPluginHostLeases as reclaimHostLeases } from "./plugin-host-leases.js";
 import { addPluginMarketplace, resolveMarketplacePlugin, } from "./plugin-marketplace.js";
 import { DEFAULT_BUNDLED_PLUGINS, OFFICIAL_MARKETPLACE_ID, } from "./official-plugins.js";
 import { getPlugin, setPluginEnabled } from "./plugin-store.js";
@@ -64,9 +63,7 @@ function reclaimPluginHostLeases(identity) {
     if (!installed)
         return;
     const dataDir = pluginDataDir(installed.marketplaceId, installed.pluginId);
-    for (const leaseId of PLUGIN_HOST_RUNTIME_LEASE_IDS) {
-        removePluginRuntimeLease(dataDir, leaseId);
-    }
+    reclaimHostLeases(dataDir);
 }
 function syncBundledMarketplace(bundleDirectory) {
     const distributionRoot = join(rynxHome(), "distribution");

package/dist/daemon-server.js

@@ -1,3 +1,4 @@
+import { toMarketplaceItem } from "./plugin-management.js";
 /**
  * Shared daemon composition root.
  *
@@ -120,16 +121,6 @@ async function assertWorkspaceDirectories(directories) {
         throw new MachineSessionServiceFailure("failed_precondition", "one or more Project directories are unavailable");
     }
 }
-function toMarketplaceItem(record) {
-    return {
-        id: record.marketplaceId,
-        source: record.sourceType,
-        builtIn: record.builtIn,
-        plugins: record.catalog.plugins.map((plugin) => ({ id: plugin.id })),
-        resolvedRevision: record.resolvedRevision,
-        refreshedAt: record.refreshedAt,
-    };
-}
 export function daemonActivityBlocksShutdown(activity) {
     return activity.runningTurns > 0
         || activity.pendingInteractions > 0

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

@@ -1,4 +1,11 @@
-/** Fixed leases owned by the resident daemon's plugin supervisor. A new daemon
- * may reclaim these only after it has acquired the exclusive RYNX_HOME owner
- * lock and before starting any plugin runners. */
+/** Fixed records owned by the resident daemon, not independent process locks. */
 export declare const PLUGIN_HOST_RUNTIME_LEASE_IDS: readonly ["host-runtime", "host-settings"];
+type HostLeaseId = typeof PLUGIN_HOST_RUNTIME_LEASE_IDS[number];
+export declare function removePluginHostLease(dataDir: string, id: HostLeaseId): void;
+/** The caller owns RYNX_HOME exclusively, or has stopped this plugin under the
+ * supervisor's queue. Take over only the previous host's fixed records. Missing
+ * PID metadata must not prevent startup or offline repair. Plugin-owned and
+ * independent CLI leases continue to protect their installation directories.
+ * This does not terminate processes: their lifetime is managed separately. */
+export declare function reclaimPluginHostLeases(dataDir: string, only?: HostLeaseId): void;
+export {};

package/dist/plugin-host-leases.js

@@ -1,7 +1,21 @@
-/** Fixed leases owned by the resident daemon's plugin supervisor. A new daemon
- * may reclaim these only after it has acquired the exclusive RYNX_HOME owner
- * lock and before starting any plugin runners. */
-export const PLUGIN_HOST_RUNTIME_LEASE_IDS = [
-    "host-runtime",
-    "host-settings",
-];
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { removePluginRuntimeLease } from "@rynx-ai/plugin-sdk";
+/** Fixed records owned by the resident daemon, not independent process locks. */
+export const PLUGIN_HOST_RUNTIME_LEASE_IDS = ["host-runtime", "host-settings"];
+export function removePluginHostLease(dataDir, id) {
+    removePluginRuntimeLease(dataDir, id);
+    // Remove diagnostics written by the earlier recovery implementation too.
+    rmSync(join(dataDir, `.${id}-process.json`), { force: true });
+}
+/** The caller owns RYNX_HOME exclusively, or has stopped this plugin under the
+ * supervisor's queue. Take over only the previous host's fixed records. Missing
+ * PID metadata must not prevent startup or offline repair. Plugin-owned and
+ * independent CLI leases continue to protect their installation directories.
+ * This does not terminate processes: their lifetime is managed separately. */
+export function reclaimPluginHostLeases(dataDir, only) {
+    for (const id of PLUGIN_HOST_RUNTIME_LEASE_IDS) {
+        if (!only || id === only)
+            removePluginHostLease(dataDir, id);
+    }
+}

package/dist/plugin-host-rpc.js

@@ -9,7 +9,7 @@ import { PluginRunnerError } from "@rynx-ai/plugin-runner";
 import { ensurePluginSessionLaunch, replayPluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
 import { createControlLink } from "./control-link-store.js";
 import { nodeLogFiles, sessionLogFiles } from "./log-files.js";
-import { issueSessionPortalTicket, revokeSessionPortalGrant, } from "./session-portal-grant-store.js";
+import { issueSessionPortalTicket, revokeSessionPortalGrant, renewSessionPortalGrant, } from "./session-portal-grant-store.js";
 import { claimSessionTimelineProjection, completeSessionTimelineProjection, } from "./session-timeline-projection-store.js";
 const MAX_MESSAGE_LENGTH = 1_000_000;
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
@@ -134,6 +134,7 @@ export class PluginHostRpc {
                         ? {
                             sessionPortalEmbedOrigin: true,
                             sessionPortalGrantRevocation: true,
+                            sessionPortalGrantRenewal: true,
                         }
                         : {}),
                 },
@@ -251,6 +252,33 @@ export class PluginHostRpc {
                     this.ownedSession(sessionId);
                     return this.issueSessionPortalLink("single_session", requiredSessionPortalAccess(input), sessionId, optionalSessionPortalEmbedOrigin(input.embedOrigin), optionalString(input.grantHandle, "grantHandle", 128));
                 }
+                case "session.portal.grant.renew": {
+                    const input = record(params);
+                    const scope = input.scope;
+                    if (scope !== "single_session" && scope !== "plugin_sessions") {
+                        throw new PluginHostCallError("INVALID_PARAMS", "scope must be single_session or plugin_sessions");
+                    }
+                    const sessionId = scope === "single_session" ? requiredSessionId(input) : undefined;
+                    if (sessionId)
+                        this.ownedSession(sessionId);
+                    else if (input.sessionId !== undefined) {
+                        throw new PluginHostCallError("INVALID_PARAMS", "plugin_sessions scope cannot specify a Session");
+                    }
+                    const embedOrigin = optionalSessionPortalEmbedOrigin(input.embedOrigin);
+                    if (!embedOrigin)
+                        throw new PluginHostCallError("INVALID_PARAMS", "embedOrigin is required for renewal");
+                    const renewed = renewSessionPortalGrant({
+                        pluginId: this.principalId,
+                        grantHandle: requiredString(input.grantHandle, "grantHandle", 128),
+                        scope,
+                        access: requiredSessionPortalAccess(input),
+                        sessionId,
+                        embedOrigin,
+                    });
+                    if (!renewed)
+                        throw new PluginHostCallError("HOST_CALL_FAILED", "Session Portal grant expired, revoked, or does not match the authorized scope");
+                    return renewed;
+                }
                 case "session.portal.grant.revoke": {
                     const grantHandle = requiredString(record(params).grantHandle, "grantHandle", 128);
                     return revokeSessionPortalGrant({

package/dist/plugin-installer.d.ts

@@ -50,3 +50,4 @@ export declare function pruneInactivePluginInstallations(): string[];
 export declare function pluginDataDir(marketplaceId: string, pluginId: string): string;
 export declare function pluginRuntimeCacheDir(marketplaceId: string, pluginId: string, integrity: string): string;
 export declare function marketplaceStorageSegment(marketplaceId: string): string;
+export declare function assertNoActiveLeases(record: PluginRecord | undefined): void;

package/dist/plugin-installer.js

@@ -270,7 +270,7 @@ function ensureStorageRoots() {
     mkdirSync(stagingRoot, { recursive: true, mode: 0o700 });
     return { cacheRoot, stagingRoot };
 }
-function assertNoActiveLeases(record) {
+export function assertNoActiveLeases(record) {
     if (!record)
         return;
     const dataDir = pluginDataDir(record.marketplaceId, record.pluginId);

package/dist/plugin-maintenance-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugin-maintenance-entry.js

@@ -0,0 +1,19 @@
+import { capturePluginRecovery, restorePluginRecovery, inspectPluginInstallation } from "./plugin-maintenance.js";
+async function main(args) {
+    if (args[0] === "capabilities")
+        return { recoveryFormat: 1, minimumNode: "22.16.0", offlineManagement: 1 };
+    if (args[0] === "inspect" && args.length === 2)
+        return inspectPluginInstallation(args[1]);
+    if (args[0] === "capture" && (args.length === 3 || args.length === 5)) {
+        return capturePluginRecovery(args[1], args[2], {
+            marketPackage: args[3], retainedMarketPackage: args[4],
+        });
+    }
+    if (args[0] === "restore" && args.length === 2)
+        return restorePluginRecovery(args[1]);
+    throw new Error("Usage: node plugin-maintenance.mjs capabilities | capture <plugin@market> <backup-directory> [<current-market-package> <retained-market-package>] | restore <backup-directory>. Run capture/restore after stopping Rynx; recovery restores the plugin enabled.");
+}
+main(process.argv.slice(2)).then((result) => console.log(JSON.stringify(result))).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/plugin-maintenance.d.ts

@@ -0,0 +1,21 @@
+export declare function capturePluginRecovery(identity: string, directory: string, options?: {
+    marketPackage?: string;
+    retainedMarketPackage?: string;
+}): Promise<{
+    version: string;
+    digest: string;
+}>;
+export declare function restorePluginRecovery(directory: string): Promise<{
+    version: string;
+    digest: string;
+    enabled: true;
+}>;
+/** Read-only version/integrity evidence, also usable with historical CLIs. */
+export declare function inspectPluginInstallation(identity: string): Promise<{
+    id: string;
+    version: string | number | null;
+    digest: string | number | null;
+    enabled: boolean;
+    runtimeState: string | number | null;
+    runtimeError: string | number | null;
+}>;

package/dist/plugin-maintenance.js

@@ -0,0 +1,189 @@
+/** Rynx-owned recovery format. This entry never migrates the daemon database. */
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { acquireDaemonOwner } from "./daemon-owner.js";
+import { dbPath } from "./db.js";
+import { assertNoActiveLeases, pluginDataDir } from "./plugin-installer.js";
+import { reclaimPluginHostLeases } from "./plugin-host-leases.js";
+import { validatePluginPackageSnapshot } from "./plugin-package.js";
+const columns = {
+    plugin_installations: "canonical_id marketplace_id plugin_id source_type requested_source resolved_revision source_fingerprint version enabled installed_at updated_at install_path manifest integrity runtime_state runtime_error".split(" "),
+    plugin_marketplaces: "marketplace_id source_type requested_source resolved_revision source_fingerprint built_in catalog created_at refreshed_at".split(" "),
+    plugin_marketplace_bindings: "marketplace_id source_fingerprint created_at".split(" "),
+};
+function openExisting(readOnly = false) {
+    if (!existsSync(dbPath()))
+        throw new Error("Rynx database does not exist; use plugin install for a new installation");
+    const connection = new DatabaseSync(dbPath(), { timeout: 5000, readOnly });
+    try {
+        for (const [table, expected] of Object.entries(columns)) {
+            const actual = connection.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name).sort();
+            if (JSON.stringify(actual) !== JSON.stringify([...expected].sort())) {
+                throw new Error(`Unsupported recovery schema for ${table}; keep the original CLI and installation unchanged`);
+            }
+        }
+        return connection;
+    }
+    catch (error) {
+        connection.close();
+        throw error;
+    }
+}
+function checkLeases(row) {
+    const record = {
+        canonicalId: row.canonical_id, marketplaceId: row.marketplace_id,
+        pluginId: row.plugin_id, installPath: row.install_path,
+    };
+    reclaimPluginHostLeases(pluginDataDir(record.marketplaceId, record.pluginId));
+    assertNoActiveLeases(record);
+}
+async function checkPackage(row, directory) {
+    const digest = await validatePluginPackageSnapshot(directory);
+    if (digest !== row.integrity)
+        throw new Error(`Recovery package digest differs from installed ${row.canonical_id}`);
+}
+function atomicJson(file, data) {
+    const temporary = `${file}.tmp-${process.pid}`;
+    writeFileSync(temporary, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+    renameSync(temporary, file);
+}
+export async function capturePluginRecovery(identity, directory, options = {}) {
+    const owner = await acquireDaemonOwner();
+    let connection;
+    try {
+        connection = openExisting();
+        const installation = connection.prepare("SELECT * FROM plugin_installations WHERE canonical_id = ?").get(identity);
+        if (!installation)
+            throw new Error(`Plugin ${identity} is not installed`);
+        checkLeases(installation);
+        await checkPackage(installation, String(installation.install_path));
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        if (existsSync(join(directory, "snapshot.json")))
+            throw new Error("Recovery snapshot already exists; preserve it and use a new attempt directory");
+        let packagePath = join(resolve(directory), "package");
+        let reuseMarket = false;
+        if (options.marketPackage && options.retainedMarketPackage) {
+            try {
+                await checkPackage(installation, options.marketPackage);
+                reuseMarket = true;
+            }
+            catch { }
+        }
+        if (reuseMarket)
+            packagePath = resolve(options.retainedMarketPackage);
+        else
+            cpSync(String(installation.install_path), packagePath, { recursive: true, errorOnExist: true, force: false });
+        const snapshot = {
+            schemaVersion: 1, database: dbPath(), installation, packagePath,
+            ...(reuseMarket ? { alternatePackagePath: resolve(options.marketPackage) } : {}),
+            marketplace: connection.prepare("SELECT * FROM plugin_marketplaces WHERE marketplace_id = ?").get(installation.marketplace_id) ?? null,
+            binding: connection.prepare("SELECT * FROM plugin_marketplace_bindings WHERE marketplace_id = ?").get(installation.marketplace_id) ?? null,
+        };
+        atomicJson(join(directory, "snapshot.json"), snapshot);
+        return { version: String(installation.version), digest: String(installation.integrity) };
+    }
+    finally {
+        connection?.close();
+        await owner.release();
+    }
+}
+export async function restorePluginRecovery(directory) {
+    const owner = await acquireDaemonOwner();
+    let connection;
+    try {
+        connection = openExisting();
+        const snapshot = JSON.parse(readFileSync(join(directory, "snapshot.json"), "utf8"));
+        if (snapshot.schemaVersion !== 1 || snapshot.database !== dbPath())
+            throw new Error("Recovery snapshot belongs to a different format or Rynx database");
+        for (const [key, table] of [["installation", "plugin_installations"], ["marketplace", "plugin_marketplaces"], ["binding", "plugin_marketplace_bindings"]]) {
+            const row = snapshot[key];
+            if (!row && key !== "installation")
+                continue;
+            if (!row || JSON.stringify(Object.keys(row).sort()) !== JSON.stringify([...columns[table]].sort()))
+                throw new Error(`Invalid recovery ${key}`);
+        }
+        const original = snapshot.installation;
+        const current = connection.prepare("SELECT * FROM plugin_installations WHERE canonical_id = ?").get(original.canonical_id);
+        if (current)
+            checkLeases(current);
+        checkLeases(original);
+        let packagePath = snapshot.packagePath;
+        try {
+            await checkPackage(original, packagePath);
+        }
+        catch (error) {
+            if (!snapshot.alternatePackagePath)
+                throw error;
+            packagePath = snapshot.alternatePackagePath;
+            await checkPackage(original, packagePath);
+        }
+        atomicJson(join(directory, "restore-progress.json"), { phase: "package-verified", at: new Date().toISOString() });
+        const destination = String(original.install_path);
+        let intact = false;
+        try {
+            await checkPackage(original, destination);
+            intact = true;
+        }
+        catch { }
+        if (!intact) {
+            mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+            const staged = `${destination}.recover-${process.pid}`;
+            try {
+                cpSync(packagePath, staged, { recursive: true, errorOnExist: true, force: false });
+                await checkPackage(original, staged);
+                if (existsSync(destination))
+                    renameSync(destination, `${destination}.damaged-${Date.now()}`);
+                renameSync(staged, destination);
+            }
+            finally {
+                rmSync(staged, { recursive: true, force: true });
+            }
+        }
+        connection.exec("BEGIN IMMEDIATE");
+        try {
+            for (const [table, value] of [
+                ["plugin_marketplace_bindings", snapshot.binding],
+                ["plugin_marketplaces", snapshot.marketplace],
+                ["plugin_installations", { ...original, enabled: 1, runtime_state: "stopped", runtime_error: null }],
+            ]) {
+                const primary = table === "plugin_installations" ? "canonical_id" : "marketplace_id";
+                // Only this plugin and its existing Market registration are restored.
+                // No session, private plugin data, or unrelated table is copied back.
+                if (!value) {
+                    connection.prepare(`DELETE FROM ${table} WHERE ${primary} = ?`).run(original.marketplace_id);
+                    continue;
+                }
+                const keys = [...columns[table]];
+                connection.prepare(`INSERT INTO ${table} (${keys.join(",")}) VALUES (${keys.map(() => "?").join(",")}) ON CONFLICT(${primary}) DO UPDATE SET ${keys.filter((key) => key !== primary).map((key) => `${key}=excluded.${key}`).join(",")}`)
+                    .run(...keys.map((key) => value[key]));
+            }
+            connection.exec("COMMIT");
+        }
+        catch (error) {
+            connection.exec("ROLLBACK");
+            throw error;
+        }
+        atomicJson(join(directory, "restore-progress.json"), { phase: "installation-restored", at: new Date().toISOString() });
+        return { version: String(original.version), digest: String(original.integrity), enabled: true };
+    }
+    finally {
+        connection?.close();
+        await owner.release();
+    }
+}
+/** Read-only version/integrity evidence, also usable with historical CLIs. */
+export async function inspectPluginInstallation(identity) {
+    const connection = openExisting(true);
+    try {
+        const row = connection.prepare("SELECT * FROM plugin_installations WHERE canonical_id = ?").get(identity);
+        if (!row)
+            throw new Error(`Plugin ${identity} is not installed`);
+        await checkPackage(row, String(row.install_path));
+        return { id: identity, version: row.version, digest: row.integrity, enabled: row.enabled === 1,
+            runtimeState: row.runtime_state, runtimeError: row.runtime_error };
+    }
+    finally {
+        connection.close();
+    }
+}