fix: register exit-abort once process-wide, not per plugin instance

OpenCode Desktop loads one plugin instance per open project in a single Node
process. The plugin factory registered process.once("exit") per instance to
abort the auto-update AbortController, so past Node's default 10-listener cap it
logged MaxListenersExceededWarning ("11 exit listeners added to [process]").

The abort is not useless (it kills a spawned npm install child on hard exit), so
rather than drop it, route all controllers through a module-global registry
(shared/exit-abort-registry.ts) backed by a SINGLE process.once("exit") listener
that fans out to every registered controller. Disposed instances unregister their
controller so the set doesn't grow across Desktop project open/close.

Corrects an earlier mis-attribution (this warning was thought to be Effect/OpenCode
internals; the stack points squarely at plugin() -> process.once at index.ts).

Gate: plugin 2605/0 (+3 registry tests), tsc + biome clean.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/plugin/src/index.ts

@@ -39,6 +39,7 @@ import { registerRpcHandlers } from "./plugin/rpc-handlers";
 import { createToolRegistry } from "./plugin/tool-registry";
 import { type ConflictResult, detectConflicts } from "./shared/conflict-detector";
 import { getMagicContextStorageDir } from "./shared/data-path";
+import { registerExitAbort, unregisterExitAbort } from './shared/exit-abort-registry';
 import { setKeepSubagents } from "./shared/keep-subagents";
 import { log } from "./shared/logger";
 import { refreshModelLimitsFromApi } from "./shared/models-dev-cache";
@@ -69,9 +70,10 @@ const server: Plugin = async (ctx) => {
     // (historian/dreamer/sidekick/migration) instead of deleting on success.
     setKeepSubagents(pluginConfig.keep_subagents === true);
     const autoUpdateAbort = new AbortController();
-    process.once("exit", () => {
-        autoUpdateAbort.abort();
-    });
+    // Abort on process exit via the shared single-listener registry. Registering
+    // a process.once("exit") here directly would add one listener PER plugin
+    // instance, and OpenCode Desktop runs many in one process (Node warns past 10).
+    registerExitAbort(autoUpdateAbort);
 
     // Surface config validation warnings to user and log
     if (pluginConfig.configWarnings?.length) {
@@ -396,6 +398,9 @@ const server: Plugin = async (ctx) => {
                 if (!isDisposedInstanceDirectory(ownInstanceDirectory, disposedDirectory)) return;
                 try {
                     autoUpdateAbort.abort();
+                    // Drop it from the exit-abort registry so disposed instances'
+                    // controllers aren't retained there for the process lifetime.
+                    unregisterExitAbort(autoUpdateAbort);
                 } catch {
                     // best-effort
                 }

packages/plugin/src/shared/exit-abort-registry.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "bun:test";
+import { registerExitAbort, unregisterExitAbort } from "./exit-abort-registry";
+
+// Captured before any registration so we can isolate the ONE listener the
+// registry installs process-wide (it intentionally never removes it, mirroring
+// production, so the suite must not strip it either).
+const baseline = process.listenerCount("exit");
+
+/** The registry's single 'exit' listener (the first one added past baseline). */
+function registryListener(): () => void {
+    return process.listeners("exit").slice(baseline)[0] as () => void;
+}
+
+describe("exit-abort-registry", () => {
+    it("adds exactly ONE process exit listener no matter how many controllers register", () => {
+        registerExitAbort(new AbortController());
+        registerExitAbort(new AbortController());
+        registerExitAbort(new AbortController());
+        expect(process.listenerCount("exit") - baseline).toBe(1);
+    });
+
+    it("aborts every registered controller when the exit listener fires", () => {
+        const a = new AbortController();
+        const b = new AbortController();
+        registerExitAbort(a);
+        registerExitAbort(b);
+
+        // Invoke the registry's listener directly (emitting 'exit' would end the
+        // test process).
+        registryListener()();
+
+        expect(a.signal.aborted).toBe(true);
+        expect(b.signal.aborted).toBe(true);
+        // Still exactly one listener after firing.
+        expect(process.listenerCount("exit") - baseline).toBe(1);
+    });
+
+    it("does not abort a controller that was unregistered before exit", () => {
+        const keep = new AbortController();
+        const drop = new AbortController();
+        registerExitAbort(keep);
+        registerExitAbort(drop);
+        unregisterExitAbort(drop);
+
+        registryListener()();
+
+        expect(keep.signal.aborted).toBe(true);
+        expect(drop.signal.aborted).toBe(false);
+    });
+});

packages/plugin/src/shared/exit-abort-registry.ts

@@ -0,0 +1,46 @@
+/**
+ * Process-global registry of AbortControllers to abort on process exit, backed
+ * by a SINGLE `process.once("exit")` listener no matter how many controllers
+ * register.
+ *
+ * Why this exists: the plugin factory runs once per plugin instance, and
+ * OpenCode Desktop loads many instances in one Node process (one per open
+ * project). Registering a `process.once("exit")` per instance added one listener
+ * each, so past Node's default 10-listener cap it logged a
+ * `MaxListenersExceededWarning` ("11 exit listeners added to [process]"). One
+ * module-global listener that fans out to every registered controller keeps the
+ * count at one.
+ */
+
+const controllers = new Set<AbortController>();
+let listenerRegistered = false;
+
+function abortAll(): void {
+    for (const controller of controllers) {
+        try {
+            controller.abort();
+        } catch {
+            // best-effort: the process is exiting anyway
+        }
+    }
+}
+
+/**
+ * Abort `controller` when the process exits. The underlying `process.once("exit")`
+ * listener is installed on the first call only; subsequent calls just add to the
+ * fan-out set.
+ */
+export function registerExitAbort(controller: AbortController): void {
+    controllers.add(controller);
+    if (listenerRegistered) return;
+    listenerRegistered = true;
+    process.once("exit", abortAll);
+}
+
+/**
+ * Stop tracking `controller` (e.g. when its plugin instance is disposed) so the
+ * set doesn't grow without bound as Desktop opens and closes projects.
+ */
+export function unregisterExitAbort(controller: AbortController): void {
+    controllers.delete(controller);
+}