@songsid/agend 2.1.2-beta.1 → 2.1.2-beta.3

package/dist/fleet-manager.js

@@ -163,6 +163,10 @@ export class FleetManager {
     failoverActive = new Map(); // instance → current failover model
     // IPC reconnect: tracks instances being intentionally stopped (skip reconnect)
     ipcStoppingInstances = new Set();
+    /** Coalesce concurrent connection attempts for the same daemon socket. */
+    ipcConnectInFlight = new Map();
+    /** At most one reconnect/backoff loop may exist per instance. */
+    ipcReconnectInFlight = new Map();
     // Adapter restart: prevents re-entrant restart attempts
     adapterRestarting = new Set();
     // Adapter isolation: track state per adapter for retry + visibility
@@ -1931,19 +1935,38 @@ export class FleetManager {
         this.logger.info({ adapterId, type: channelConfig.type }, "Additional adapter started");
     }
     /** Connect IPC to a single instance with all handlers */
-    async connectIpcToInstance(name) {
+    connectIpcToInstance(name) {
+        const inFlight = this.ipcConnectInFlight.get(name);
+        if (inFlight)
+            return inFlight;
+        const connection = this.connectIpcToInstanceInternal(name)
+            .finally(() => {
+            if (this.ipcConnectInFlight.get(name) === connection) {
+                this.ipcConnectInFlight.delete(name);
+            }
+        });
+        this.ipcConnectInFlight.set(name, connection);
+        return connection;
+    }
+    async connectIpcToInstanceInternal(name) {
         // Close existing client to prevent socket leak on reconnect
         const existing = this.instanceIpcClients.get(name);
         if (existing) {
-            this.ipcStoppingInstances.add(name);
+            // Remove application listeners before destroying the socket. Even if a
+            // future regression creates two clients, the replaced one cannot keep
+            // handling fleet_outbound messages as an orphan.
+            existing.removeAllListeners();
             try {
-                existing.close();
+                await existing.close();
             }
             catch (err) {
                 this.logger.debug({ err, name }, "IPC client close failed (likely already closed)");
             }
-            this.instanceIpcClients.delete(name);
-            this.ipcStoppingInstances.delete(name);
+            finally {
+                if (this.instanceIpcClients.get(name) === existing) {
+                    this.instanceIpcClients.delete(name);
+                }
+            }
         }
         const sockPath = join(this.getInstanceDir(name), "channel.sock");
         if (!existsSync(sockPath))
@@ -2021,6 +2044,10 @@ export class FleetManager {
             }
             // Auto-reconnect on disconnect (unless intentionally stopping)
             ipc.on("disconnect", () => {
+                // A delayed event from a replaced/stale client must never delete the
+                // current connection or start another reconnect loop.
+                if (this.instanceIpcClients.get(name) !== ipc)
+                    return;
                 this.instanceIpcClients.delete(name);
                 if (this.ipcStoppingInstances.has(name))
                     return;
@@ -2032,7 +2059,20 @@ export class FleetManager {
         }
     }
     /** Attempt IPC reconnection with exponential backoff */
-    async ipcReconnect(name) {
+    ipcReconnect(name) {
+        const inFlight = this.ipcReconnectInFlight.get(name);
+        if (inFlight)
+            return inFlight;
+        const reconnect = this.runIpcReconnect(name)
+            .finally(() => {
+            if (this.ipcReconnectInFlight.get(name) === reconnect) {
+                this.ipcReconnectInFlight.delete(name);
+            }
+        });
+        this.ipcReconnectInFlight.set(name, reconnect);
+        return reconnect;
+    }
+    async runIpcReconnect(name) {
         for (let attempt = 1;; attempt++) {
             if (this.ipcStoppingInstances.has(name) || !this.daemons.has(name))
                 return;