@ai-agent-forge/agent-forge 0.88.4 → 0.88.6

package/dist/plugins/ecosystem/node-package-install-host.js

@@ -447,8 +447,10 @@ async function installStagingRuntimeDependencies(staging, entries, signal) {
         manifest = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(packageEntry.bytes));
     }
     catch {
-        // Package identity is already fully validated by the two manifests;
-        // a package without a parseable package.json installs unchanged.
+        // Unlike the two manifests, a package.json with parse errors is not
+        // part of install validation: the package installs unchanged and the
+        // missing runtime dependencies surface later as module-not-found at
+        // plugin load (registered boundary in the distribution design).
         return;
     }
     if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest))
@@ -546,6 +548,20 @@ export async function createNodePackageInstallHostV1(options) {
     let closed = false;
     const activeOperations = new Set();
     const runtimeHandles = new Map();
+    // Activation serialization: NodePackageInstallHostV1 is a public API and
+    // third-party callers may activate the same installation key concurrently.
+    // Two interleaved activations can both pass the state guard and overwrite
+    // each other's runtimeHandles entry — the losing dispose stops its own
+    // handle while the ledger still reads "active", silently leaking the
+    // surviving runtime, because the persistence layer only serializes
+    // commits and not this in-memory path. Each activation chains onto the
+    // previous one for its key, preserving the existing success semantics: a
+    // queued activation starts only after the previous one settles and is
+    // then rejected by the state guard like any sequential re-activation.
+    // rollback/uninstall stay unchained; their interleavings with activate
+    // are tolerated by the persistence snapshot and the ENOENT handling in
+    // uninstall.
+    const activationChains = new Map();
     const applyPersistentSnapshot = (snapshot) => {
         records.clear();
         activeByKey.clear();
@@ -616,6 +632,28 @@ export async function createNodePackageInstallHostV1(options) {
             await Promise.resolve(handle.dispose());
         runtimeHandles.delete(installationRef);
     };
+    // A dispose that throws keeps its entry in runtimeHandles (disposeRuntime
+    // deletes only after a successful dispose), so re-registering the same
+    // installation ref must not silently overwrite the stale leftover: the
+    // combined handle releases the new runtime first and the stale one in
+    // `finally`, so a failure on either side still reclaims the other.
+    const registerRuntimeHandle = (installationRef, handle) => {
+        const existing = runtimeHandles.get(installationRef);
+        if (existing === undefined) {
+            runtimeHandles.set(installationRef, handle);
+            return;
+        }
+        runtimeHandles.set(installationRef, {
+            dispose: async () => {
+                try {
+                    await Promise.resolve(handle.dispose?.());
+                }
+                finally {
+                    await Promise.resolve(existing.dispose?.());
+                }
+            },
+        });
+    };
     const loadRuntime = async (installation, record, directory, signal) => {
         if (options.loadPlugin === undefined)
             return undefined;
@@ -744,47 +782,76 @@ export async function createNodePackageInstallHostV1(options) {
             }
         },
         async activate(input) {
-            const operation = begin(input.signal);
-            let candidate;
-            try {
-                const scopeRef = opaqueScope(input.scopeRef);
-                const record = getRecord(input.installation, input.record, input.scope, scopeRef);
-                if (record.state !== "installed")
-                    throw new NodePackageInstallErrorV1("installation_identity_mismatch");
-                candidate = await loadRuntime(input.installation, input.record, record.directory, operation.signal);
-                const key = installationKey(input.scope, scopeRef, input.record.pluginId);
-                const previousRef = activeByKey.get(key);
-                if (previousRef !== undefined) {
-                    const previous = records.get(previousRef);
-                    if (previous !== undefined) {
-                        await disposeRuntime(previousRef);
-                    }
-                }
-                await commitRecords((values) => {
-                    const candidateRecord = values.get(input.installation.installationRef);
-                    if (candidateRecord === undefined)
+            // Validate before queueing: a malformed request fails at call time
+            // instead of waiting behind pending activations.
+            const key = installationKey(input.scope, opaqueScope(input.scopeRef), input.record.pluginId);
+            const activateBody = async () => {
+                const operation = begin(input.signal);
+                let candidate;
+                try {
+                    const scopeRef = opaqueScope(input.scopeRef);
+                    const record = getRecord(input.installation, input.record, input.scope, scopeRef);
+                    if (record.state !== "installed")
                         throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+                    candidate = await loadRuntime(input.installation, input.record, record.directory, operation.signal);
+                    const previousRef = activeByKey.get(key);
+                    // Commit the persisted ledger before stopping the previous
+                    // runtime: if the commit fails, the old runtime is still
+                    // running and still matches the ledger, so the caller can
+                    // retry or roll back from a consistent state. Between the
+                    // commit and the dispose below the old and new runtimes
+                    // coexist briefly — the previous plugin keeps serving until
+                    // it is replaced here, which is the correct activation
+                    // window. The new handle is registered before the old
+                    // runtime is disposed, so even if disposeRuntime propagates
+                    // a failing old-runtime dispose, the committed new version
+                    // stays live and the error surfaces through the catch below.
+                    await commitRecords((values) => {
+                        const candidateRecord = values.get(input.installation.installationRef);
+                        if (candidateRecord === undefined)
+                            throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+                        if (previousRef !== undefined) {
+                            const previousRecord = values.get(previousRef);
+                            if (previousRecord !== undefined)
+                                values.set(previousRef, { ...previousRecord, state: "retained" });
+                        }
+                        values.set(input.installation.installationRef, { ...candidateRecord, state: "active" });
+                    });
+                    activeByKey.set(key, input.installation.installationRef);
+                    if (candidate !== undefined)
+                        registerRuntimeHandle(input.installation.installationRef, candidate);
+                    candidate = undefined;
                     if (previousRef !== undefined) {
-                        const previousRecord = values.get(previousRef);
-                        if (previousRecord !== undefined)
-                            values.set(previousRef, { ...previousRecord, state: "retained" });
+                        const previous = records.get(previousRef);
+                        if (previous !== undefined) {
+                            await disposeRuntime(previousRef);
+                        }
                     }
-                    values.set(input.installation.installationRef, { ...candidateRecord, state: "active" });
-                });
-                activeByKey.set(key, input.installation.installationRef);
-                if (candidate !== undefined)
-                    runtimeHandles.set(input.installation.installationRef, candidate);
-                candidate = undefined;
-            }
-            catch (error) {
-                if (candidate?.dispose !== undefined)
-                    await Promise.resolve(candidate.dispose()).catch(() => undefined);
-                if (error instanceof NodePackageInstallErrorV1)
-                    throw error;
-                throw new NodePackageInstallErrorV1("installation_io_failed");
+                }
+                catch (error) {
+                    if (candidate?.dispose !== undefined)
+                        await Promise.resolve(candidate.dispose()).catch(() => undefined);
+                    if (error instanceof NodePackageInstallErrorV1)
+                        throw error;
+                    throw new NodePackageInstallErrorV1("installation_io_failed");
+                }
+                finally {
+                    end(operation.controller);
+                }
+            };
+            // Chain onto the previous activation for this key; the queued body
+            // runs only after it settles, whatever its outcome.
+            const queued = activationChains.get(key) ?? Promise.resolve();
+            const run = queued.catch(() => undefined).then(() => activateBody());
+            activationChains.set(key, run);
+            try {
+                await run;
             }
             finally {
-                end(operation.controller);
+                // Drop the chain entry only while it is still the newest run, so
+                // a queued successor keeps later arrivals chained onto it.
+                if (activationChains.get(key) === run)
+                    activationChains.delete(key);
             }
         },
         async rollback(input) {
@@ -835,7 +902,7 @@ export async function createNodePackageInstallHostV1(options) {
                 });
                 activeByKey.set(installationKey(input.scope, scopeRef, failed.pluginId), input.previous.installationRef);
                 if (candidate !== undefined)
-                    runtimeHandles.set(input.previous.installationRef, candidate);
+                    registerRuntimeHandle(input.previous.installationRef, candidate);
                 candidate = undefined;
             }
             catch (error) {