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

package/dist/plugin-installer.js

@@ -4,6 +4,7 @@ import { join, resolve } from "node:path";
 import { MARKETPLACE_ID_PATTERN, pluginCliInvocationLeasePid, readPluginRuntimeLeases, removePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
 import { rynxHome } from "@rynx-ai/core";
 import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
 import { isBuiltInPluginMarketplace } from "./plugin-marketplace.js";
 import { detectPluginSource, inspectPluginPackage, materializePluginPackage, } from "./plugin-package.js";
 import { canonicalPluginId, getPlugin, removePlugin, upsertPlugin, } from "./plugin-store.js";
@@ -117,7 +118,7 @@ export async function preparePluginInstallation(spec, onProgress = () => { }, op
                         promotedByThisTransaction = true;
                     }
                     promotedPath = realpathSync(target);
-                    db().transaction(() => {
+                    transaction(db(), () => {
                         const current = getPlugin(canonicalId);
                         if (!samePluginGeneration(existing, current)) {
                             throw new Error(`plugin "${canonicalId}" changed concurrently; retry`);
@@ -172,7 +173,7 @@ export async function preparePluginInstallation(spec, onProgress = () => { }, op
 }
 export async function uninstallPlugin(identity, onProgress = () => { }, options = {}) {
     let record;
-    const removed = db().transaction(() => {
+    const removed = transaction(db(), () => {
         record = getPlugin(identity);
         if (!record)
             return false;
@@ -180,6 +181,8 @@ export async function uninstallPlugin(identity, onProgress = () => { }, options
             throw new Error(`bundled plugin "${record.canonicalId}" cannot be uninstalled; disable it instead`);
         }
         assertNoActiveLeases(record);
+        if (options.purgeData)
+            assertNoOwnedSessions(record);
         return removePlugin(record.canonicalId);
     }).immediate();
     if (!removed)
@@ -193,9 +196,37 @@ export async function uninstallPlugin(identity, onProgress = () => { }, options
     onProgress(`uninstalled plugin "${record.canonicalId}"`);
     return true;
 }
+function assertNoOwnedSessions(record) {
+    const row = db()
+        .prepare(`WITH RECURSIVE owned(id) AS (
+         SELECT session_id
+         FROM plugin_session_launch_operations
+         WHERE plugin_id = ?
+         UNION
+         SELECT id FROM sessions WHERE source = ?
+         UNION
+         SELECT sessions.id
+         FROM sessions
+         JOIN owned ON sessions.forked_from_session_id = owned.id
+         UNION
+         SELECT session_fork_operations.target_session_id
+         FROM session_fork_operations
+         JOIN owned ON session_fork_operations.source_session_id = owned.id
+       )
+       SELECT COUNT(*) AS count
+       FROM sessions
+       JOIN owned ON sessions.id = owned.id`)
+        .get(record.canonicalId, `plugin:${record.canonicalId}`);
+    if (row.count > 0) {
+        throw new Error(`cannot purge plugin "${record.canonicalId}": ${row.count} plugin-owned Session(s) still exist`);
+    }
+}
 export function pruneInactivePluginInstallations() {
     const { cacheRoot } = ensureStorageRoots();
     const active = new Set(listActivePaths().map(canonicalFilesystemPath));
+    for (const leased of listActiveRuntimeLeasePaths(cacheRoot)) {
+        active.add(leased);
+    }
     const removed = [];
     for (const marketplace of safeDirectories(cacheRoot)) {
         for (const plugin of safeDirectories(join(cacheRoot, marketplace))) {
@@ -327,6 +358,35 @@ function listActivePaths() {
     }
     return paths;
 }
+function listActiveRuntimeLeasePaths(cacheRoot) {
+    const dataRoot = join(rynxHome(), "plugins", "data");
+    const active = [];
+    for (const marketplace of safeDirectories(dataRoot)) {
+        for (const plugin of safeDirectories(join(dataRoot, marketplace))) {
+            const generationRoot = join(cacheRoot, marketplace, plugin);
+            const managedGenerations = new Set(safeDirectories(generationRoot).map((generation) => canonicalFilesystemPath(join(generationRoot, generation))));
+            if (managedGenerations.size === 0)
+                continue;
+            const dataDir = join(dataRoot, marketplace, plugin);
+            for (const lease of readPluginRuntimeLeases(dataDir)) {
+                // A lease is plugin-owned input. It may pin only the same plugin
+                // namespace from which it was read and only one exact host-owned,
+                // immutable generation directory.
+                if (lease.pluginId !== plugin)
+                    continue;
+                const pid = pluginCliInvocationLeasePid(lease.leaseId);
+                if (pid !== undefined && !isProcessAlive(pid)) {
+                    removePluginRuntimeLease(dataDir, lease.leaseId);
+                    continue;
+                }
+                const installPath = canonicalFilesystemPath(lease.installPath);
+                if (managedGenerations.has(installPath))
+                    active.push(installPath);
+            }
+        }
+    }
+    return active;
+}
 function safeProgress(callback) {
     return (line) => {
         try {

package/dist/plugin-management-service.js

@@ -295,7 +295,6 @@ function toManagementItem(record, settingsAvailable = false, updateState = "unkn
         enabled: record.enabled,
         runtimeState: record.manifest.runtime ? record.runtimeState : "absent",
         ...(record.runtimeError ? { runtimeError: record.runtimeError } : {}),
-        capabilities: [...record.manifest.capabilities],
         hasSettingsUi: settingsAvailable,
         updatedAt: record.updatedAt,
     };
@@ -322,7 +321,6 @@ function toInstallPreparation(token, expiresAtMs, prepared) {
                     subdirectory: prepared.requestedSource.subdir ?? ".",
                 },
             digest: prepared.integrity,
-            capabilities: [...prepared.manifest.capabilities],
             hasRuntime: Boolean(prepared.manifest.runtime),
             hasSettingsUi: Boolean(prepared.manifest.settings),
             ...(prepared.manifest.runtime ? {

package/dist/plugin-marketplace.js

@@ -3,6 +3,7 @@ import { isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { MARKETPLACE_ID_PATTERN, parsePluginMarketplace, } from "@rynx-ai/plugin-sdk";
 import { rynxHome } from "@rynx-ai/core";
 import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
 import { detectPluginSource, materializePluginPackage, parsePluginSourceSpec, pluginSourceFingerprint, } from "./plugin-package.js";
 export function listPluginMarketplaces() {
     return db().prepare("SELECT * FROM plugin_marketplaces ORDER BY marketplace_id").all().map(toRecord);
@@ -27,7 +28,7 @@ export async function addPluginMarketplace(spec, options = {}) {
             throw new Error(`built-in marketplace "${marketplaceId}" is managed by Rynx`);
         }
         const now = new Date().toISOString();
-        db().transaction(() => {
+        transaction(db(), () => {
             const binding = db().prepare(`SELECT source_fingerprint AS sourceFingerprint
          FROM plugin_marketplace_bindings
          WHERE marketplace_id = ?`).get(marketplaceId);

package/dist/plugin-store.js

@@ -57,11 +57,11 @@ export function upsertPlugin(rec) {
     db().prepare(`INSERT INTO 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, capabilities, runtime_state, runtime_error
+       updated_at, install_path, manifest, integrity, runtime_state, runtime_error
      ) VALUES (
        @canonicalId, @marketplaceId, @pluginId, @source, @requestedSource,
        @resolvedRevision, @sourceFingerprint, @version, @enabled, @now,
-       @now, @installPath, @manifest, @integrity, @capabilities, 'stopped', NULL
+       @now, @installPath, @manifest, @integrity, 'stopped', NULL
      )
      ON CONFLICT(canonical_id) DO UPDATE SET
        source_type = excluded.source_type,
@@ -74,7 +74,6 @@ export function upsertPlugin(rec) {
        install_path = excluded.install_path,
        manifest = excluded.manifest,
        integrity = excluded.integrity,
-       capabilities = excluded.capabilities,
        runtime_state = 'stopped',
        runtime_error = NULL`).run({
         canonicalId: rec.canonicalId,
@@ -90,7 +89,6 @@ export function upsertPlugin(rec) {
         installPath: rec.installPath,
         manifest: JSON.stringify(rec.manifest),
         integrity: rec.integrity,
-        capabilities: JSON.stringify(rec.manifest.capabilities),
     });
 }
 export function setPluginEnabled(identity, enabled) {

package/dist/plugin-supervisor.d.ts

@@ -20,6 +20,8 @@ export interface PluginSupervisorOptions {
     restartMaxMs?: number;
     healthPollMs?: number;
     daemonInstanceId?: string;
+    productVersion?: string;
+    cliVersion?: string;
     verifyPackage?: (record: RunnablePluginRecord) => Promise<void>;
 }
 export interface PluginRuntimeStatusSnapshot {
@@ -42,12 +44,15 @@ export declare class PluginSupervisor {
     private readonly spawnRunner;
     private readonly log;
     private readonly daemonInstanceId;
+    private readonly productVersion;
+    private readonly cliVersion;
     private readonly restartBaseMs;
     private readonly restartMaxMs;
     private readonly healthPollMs;
     private readonly verifyPackage;
     private services?;
     private disposed;
+    private disposePromise?;
     constructor(records: readonly RunnablePluginRecord[], options?: PluginSupervisorOptions);
     bindHostServices(services: PluginHostServices): void;
     startPluginRuntimes(): Promise<void>;

package/dist/plugin-supervisor.js

@@ -23,17 +23,22 @@ export class PluginSupervisor {
     spawnRunner;
     log;
     daemonInstanceId;
+    productVersion;
+    cliVersion;
     restartBaseMs;
     restartMaxMs;
     healthPollMs;
     verifyPackage;
     services;
     disposed = false;
+    disposePromise;
     constructor(records, options = {}) {
         this.services = options.services;
         this.spawnRunner = options.spawnRunner ?? spawnPluginRunner;
         this.log = options.log ?? (() => { });
         this.daemonInstanceId = options.daemonInstanceId ?? randomUUID();
+        this.productVersion = options.productVersion ?? "development";
+        this.cliVersion = options.cliVersion ?? "development";
         this.restartBaseMs = options.restartBaseMs ?? DEFAULT_RESTART_BASE_MS;
         this.restartMaxMs = Math.min(options.restartMaxMs ?? MAX_RESTART_DELAY_MS, MAX_RESTART_DELAY_MS);
         this.healthPollMs = options.healthPollMs ?? DEFAULT_HEALTH_POLL_MS;
@@ -211,13 +216,27 @@ export class PluginSupervisor {
         };
     }
     async dispose() {
-        if (this.disposed)
-            return;
+        if (this.disposePromise)
+            return this.disposePromise;
         this.disposed = true;
-        await Promise.allSettled([...this.states.values()].map((state) => this.runSerialized(state.record.canonicalId, async () => {
-            await this.stopState(state);
-            await this.stopSettingsState(state);
-        })));
+        const attempt = (async () => {
+            const stopped = await Promise.allSettled([...this.states.values()].map((state) => this.runSerialized(state.record.canonicalId, async () => {
+                await this.stopState(state);
+                await this.stopSettingsState(state);
+            })));
+            const failures = stopped
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (failures.length > 0) {
+                throw new AggregateError(failures, "plugin supervisor could not stop every runtime");
+            }
+        })();
+        this.disposePromise = attempt;
+        void attempt.catch(() => {
+            if (this.disposePromise === attempt)
+                this.disposePromise = undefined;
+        });
+        return attempt;
     }
     upsertState(record) {
         const current = this.states.get(record.canonicalId);
@@ -237,7 +256,10 @@ export class PluginSupervisor {
         return state;
     }
     async startState(state) {
-        if (this.disposed || state.runner || !state.record.enabled)
+        if (this.disposed
+            || state.runner
+            || blockingCleanupError(state)
+            || !state.record.enabled)
             return;
         const runtime = state.record.manifest.runtime;
         if (!runtime) {
@@ -270,7 +292,8 @@ export class PluginSupervisor {
                 pluginId: state.record.pluginId,
                 principalId: state.record.canonicalId,
                 daemonInstanceId: this.daemonInstanceId,
-                capabilities: state.record.manifest.capabilities,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 services: this.services,
                 ...(state.record.pluginId === "workspace"
                     && isBuiltInPluginMarketplace(state.record.marketplaceId)
@@ -300,7 +323,6 @@ export class PluginSupervisor {
                 role: "runtime",
                 dataDir,
                 cacheDir,
-                capabilities: state.record.manifest.capabilities,
                 handleHostCall: (method, params, signal) => hostRpc.call(method, params, signal),
                 onStderr: (line) => this.log({
                     level: "info",
@@ -333,8 +355,21 @@ export class PluginSupervisor {
             });
         }
         catch (error) {
-            await hostRpc?.dispose().catch(() => undefined);
+            try {
+                await hostRpc?.dispose();
+            }
+            catch (cleanupError) {
+                const failure = new AggregateError([error, cleanupError], "plugin runtime startup failed and active-run cleanup was unproven");
+                state.runtimeCleanupError = failure;
+                this.failState(state, failure);
+                return;
+            }
             state.hostRpc = undefined;
+            if (isUnprovenProcessCleanup(error)) {
+                state.runtimeCleanupError = error;
+                this.failState(state, error);
+                return;
+            }
             removePluginRuntimeLease(dataDir, RUNTIME_LEASE_ID);
             this.failState(state, error);
             this.scheduleRestart(state);
@@ -343,6 +378,9 @@ export class PluginSupervisor {
     async startSettingsState(state) {
         if (this.disposed)
             throw new Error("plugin supervisor is disposed");
+        const cleanupError = blockingCleanupError(state);
+        if (cleanupError)
+            throw cleanupError;
         if (state.settingsRunner)
             return state.settingsRunner;
         const background = state.record.manifest.settings?.background;
@@ -369,7 +407,8 @@ export class PluginSupervisor {
                 pluginId: state.record.pluginId,
                 principalId: state.record.canonicalId,
                 daemonInstanceId: this.daemonInstanceId,
-                capabilities: state.record.manifest.capabilities,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 services: this.services,
                 ...(state.record.pluginId === "workspace"
                     && isBuiltInPluginMarketplace(state.record.marketplaceId)
@@ -398,7 +437,6 @@ export class PluginSupervisor {
                 role: "settings",
                 dataDir,
                 cacheDir,
-                capabilities: state.record.manifest.capabilities,
                 handleHostCall: (method, params, signal) => hostRpc.call(method, params, signal),
                 onStderr: (line) => this.log({
                     level: "info",
@@ -429,8 +467,32 @@ export class PluginSupervisor {
             return runner;
         }
         catch (error) {
-            await runner?.close().catch(() => undefined);
-            await hostRpc?.dispose().catch(() => undefined);
+            const cleanupErrors = [];
+            if (runner) {
+                try {
+                    await runner.close();
+                }
+                catch (cleanupError) {
+                    state.settingsRunner = runner;
+                    cleanupErrors.push(cleanupError);
+                }
+            }
+            try {
+                await hostRpc?.dispose();
+            }
+            catch (cleanupError) {
+                state.settingsHostRpc = hostRpc;
+                cleanupErrors.push(cleanupError);
+            }
+            if (cleanupErrors.length > 0) {
+                const failure = new AggregateError([error, ...cleanupErrors], "plugin settings startup failed and cleanup was unproven");
+                state.settingsCleanupError = failure;
+                throw failure;
+            }
+            if (isUnprovenProcessCleanup(error)) {
+                state.settingsCleanupError = error;
+                throw error;
+            }
             removePluginRuntimeLease(dataDir, SETTINGS_LEASE_ID);
             throw error;
         }
@@ -438,20 +500,71 @@ export class PluginSupervisor {
     async stopSettingsState(state) {
         const runner = state.settingsRunner;
         const hostRpc = state.settingsHostRpc;
-        state.settingsRunner = undefined;
-        state.settingsHostRpc = undefined;
-        await runner?.close().catch(() => undefined);
-        await hostRpc?.dispose().catch(() => undefined);
+        if (state.settingsCleanupError && !runner && !hostRpc) {
+            throw state.settingsCleanupError;
+        }
+        const errors = [];
+        if (runner) {
+            try {
+                await runner.close();
+                if (state.settingsRunner === runner)
+                    state.settingsRunner = undefined;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (hostRpc) {
+            try {
+                await hostRpc.dispose();
+                if (state.settingsHostRpc === hostRpc)
+                    state.settingsHostRpc = undefined;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            const failure = cleanupFailure(errors, "plugin settings cleanup was unproven");
+            state.settingsCleanupError = failure;
+            throw failure;
+        }
+        state.settingsCleanupError = undefined;
         removePluginRuntimeLease(pluginDataDir(state.record.marketplaceId, state.record.pluginId), SETTINGS_LEASE_ID);
     }
     async handleSettingsExit(state, runner, hostRpc, exit) {
         if (state.settingsRunner !== runner)
             return;
+        try {
+            await runner.terminateTree();
+        }
+        catch (error) {
+            state.settingsCleanupError = error;
+            this.log({
+                level: "error",
+                event: "plugin-settings-exited",
+                pluginId: state.record.canonicalId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
         state.settingsRunner = undefined;
-        if (state.settingsHostRpc === hostRpc)
-            state.settingsHostRpc = undefined;
-        await runner.terminateTree().catch(() => undefined);
-        await hostRpc.dispose().catch(() => undefined);
+        try {
+            await hostRpc.dispose();
+            if (state.settingsHostRpc === hostRpc)
+                state.settingsHostRpc = undefined;
+        }
+        catch (error) {
+            state.settingsCleanupError = error;
+            this.log({
+                level: "error",
+                event: "plugin-settings-exited",
+                pluginId: state.record.canonicalId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        state.settingsCleanupError = undefined;
         removePluginRuntimeLease(pluginDataDir(state.record.marketplaceId, state.record.pluginId), SETTINGS_LEASE_ID);
         if (!this.disposed) {
             this.log({
@@ -473,10 +586,38 @@ export class PluginSupervisor {
             clearTimeout(state.healthTimer);
         state.healthTimer = undefined;
         const runner = state.runner;
-        state.runner = undefined;
-        await runner?.close().catch(() => undefined);
-        await state.hostRpc?.dispose().catch(() => undefined);
-        state.hostRpc = undefined;
+        const hostRpc = state.hostRpc;
+        if (state.runtimeCleanupError && !runner && !hostRpc) {
+            throw state.runtimeCleanupError;
+        }
+        const errors = [];
+        if (runner) {
+            try {
+                await runner.close();
+                if (state.runner === runner)
+                    state.runner = undefined;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (hostRpc) {
+            try {
+                await hostRpc.dispose();
+                if (state.hostRpc === hostRpc)
+                    state.hostRpc = undefined;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            const failure = cleanupFailure(errors, "plugin runtime cleanup was unproven");
+            state.runtimeCleanupError = failure;
+            this.failState(state, failure);
+            throw failure;
+        }
+        state.runtimeCleanupError = undefined;
         removePluginRuntimeLease(pluginDataDir(state.record.marketplaceId, state.record.pluginId), RUNTIME_LEASE_ID);
         state.health = undefined;
         state.error = undefined;
@@ -489,10 +630,26 @@ export class PluginSupervisor {
         if (state.healthTimer)
             clearTimeout(state.healthTimer);
         state.healthTimer = undefined;
+        try {
+            await runner.terminateTree();
+        }
+        catch (error) {
+            state.runtimeCleanupError = error;
+            this.failState(state, error);
+            return;
+        }
         state.runner = undefined;
-        await runner.terminateTree().catch(() => undefined);
-        await state.hostRpc?.dispose().catch(() => undefined);
-        state.hostRpc = undefined;
+        try {
+            await state.hostRpc?.dispose();
+            state.hostRpc = undefined;
+        }
+        catch (error) {
+            state.runtimeCleanupError = error;
+            if (!state.stopping && !this.disposed)
+                this.failState(state, error);
+            return;
+        }
+        state.runtimeCleanupError = undefined;
         removePluginRuntimeLease(pluginDataDir(state.record.marketplaceId, state.record.pluginId), RUNTIME_LEASE_ID);
         if (state.stopping || this.disposed)
             return;
@@ -571,13 +728,29 @@ export class PluginSupervisor {
     async failRunningState(state, runner, error) {
         if (state.runner !== runner)
             return;
-        state.runner = undefined;
         if (state.healthTimer)
             clearTimeout(state.healthTimer);
         state.healthTimer = undefined;
-        await runner.close().catch(() => undefined);
-        await state.hostRpc?.dispose().catch(() => undefined);
-        state.hostRpc = undefined;
+        try {
+            await runner.close();
+        }
+        catch (cleanupError) {
+            state.runtimeCleanupError = cleanupError;
+            this.failState(state, cleanupError);
+            return;
+        }
+        state.runner = undefined;
+        try {
+            await state.hostRpc?.dispose();
+            state.hostRpc = undefined;
+        }
+        catch (cleanupError) {
+            state.runtimeCleanupError = cleanupError;
+            if (!state.stopping && !this.disposed)
+                this.failState(state, cleanupError);
+            return;
+        }
+        state.runtimeCleanupError = undefined;
         removePluginRuntimeLease(pluginDataDir(state.record.marketplaceId, state.record.pluginId), RUNTIME_LEASE_ID);
         if (state.stopping || this.disposed)
             return;
@@ -595,6 +768,18 @@ export class PluginSupervisor {
         return current;
     }
 }
+function cleanupFailure(errors, message) {
+    return errors.length === 1 ? errors[0] : new AggregateError(errors, message);
+}
+function blockingCleanupError(state) {
+    return state.runtimeCleanupError ?? state.settingsCleanupError;
+}
+function isUnprovenProcessCleanup(error) {
+    return Boolean(error
+        && typeof error === "object"
+        && "code" in error
+        && error.code === "PROCESS_TREE_STUCK");
+}
 function healthState(health) {
     return health.state;
 }

package/dist/pm2.d.ts

@@ -8,12 +8,21 @@ export declare function formatControlUrl(host: string, port: number): string;
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export declare function startDaemon({ force, quiet }: {
+export declare function startDaemon({ force, quiet, launchEnvironment, }: {
     force: boolean;
     quiet?: boolean;
+    launchEnvironment?: NodeJS.ProcessEnv;
 }): number;
 export declare function isPm2DaemonOnline(): boolean;
-/** Stop and remove the daemon from pm2's process list. */
+/**
+ * Stop the daemon and terminate its dedicated pm2 supervisor.
+ *
+ * PM2_HOME lives below RYNX_HOME, so this supervisor cannot own unrelated
+ * applications. Leaving it alive across an npm replacement is unsafe: the
+ * daemon process container path is resolved inside the old pm2 package. Once
+ * npm swaps @rynx-ai/daemon, that cached path may no longer exist and every
+ * subsequent `rynx start` enters a restart loop before our code can run.
+ */
 export declare function stopDaemon(): number;
 /** Print a one-line status; exit 0 only when online. */
 export declare function statusDaemon(): number;