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

package/dist/plugin-installer.js

@@ -180,6 +180,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 +195,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 +357,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-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,6 +292,8 @@ export class PluginSupervisor {
                 pluginId: state.record.pluginId,
                 principalId: state.record.canonicalId,
                 daemonInstanceId: this.daemonInstanceId,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 capabilities: state.record.manifest.capabilities,
                 services: this.services,
                 ...(state.record.pluginId === "workspace"
@@ -333,8 +357,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 +380,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,6 +409,8 @@ export class PluginSupervisor {
                 pluginId: state.record.pluginId,
                 principalId: state.record.canonicalId,
                 daemonInstanceId: this.daemonInstanceId,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 capabilities: state.record.manifest.capabilities,
                 services: this.services,
                 ...(state.record.pluginId === "workspace"
@@ -429,8 +471,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 +504,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 +590,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 +634,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 +732,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 +772,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;