@mclawnet/agent 0.6.28 → 0.6.30

package/dist/__tests__/hub-connection-reconnect.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hub-connection-reconnect.test.d.ts.map

package/dist/__tests__/hub-connection-reconnect.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-connection-reconnect.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/hub-connection-reconnect.test.ts"],"names":[],"mappings":""}

package/dist/{chunk-NQ3WFEXY.js → chunk-LXSWV3VS.js}

@@ -559,13 +559,13 @@ var HubConnection = class {
   }
   connect() {
     if (this.destroyed) return;
-    if (this.ws || this.reconnectTimer) return;
+    if (this.reconnectTimer) return;
+    if (this.ws && (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN)) {
+      return;
+    }
     this.cleanupConnection();
     this.authState = "pending";
-    this.ws = new WebSocket(this.hubUrl);
-    this.ws.on("open", () => {
-      this.reconnectDelay = DEFAULT_RECONNECT_MS;
-    });
+    this.ws = new WebSocket(this.hubUrl, { handshakeTimeout: 1e4 });
     this.ws.on("message", (raw) => {
       let data;
       try {
@@ -589,6 +589,7 @@ var HubConnection = class {
         log2.info({ agentId: data.agentId }, "registered with hub");
         this.authState = "authenticated";
         this.agentId = data.agentId ?? null;
+        this.reconnectDelay = DEFAULT_RECONNECT_MS;
         this.startHeartbeat();
         this.onConnectCb?.(this.agentId);
         this.tryRecoverSwarms();
@@ -616,6 +617,18 @@ var HubConnection = class {
     this.ws.on("error", (err) => {
       log2.error({ err }, "ws connection error");
       this.onError?.(err);
+      if (this.ws) {
+        const dying = this.ws;
+        this.ws = null;
+        try {
+          dying.removeAllListeners();
+          dying.terminate();
+        } catch {
+        }
+        this.stopHeartbeat();
+        this.authState = "pending";
+        this.scheduleReconnect();
+      }
     });
   }
   send(data) {
@@ -1205,14 +1218,26 @@ var HubConnection = class {
    *
    * We `removeAllListeners()` before terminating so the close handler can't
    * also call `scheduleReconnect()` — single-entry reconnect is easier to
-   * reason about than relying on the timer-slot idempotency check.
+   * reason about than relying on the timer-slot idempotency check. We then
+   * re-attach a no-op `error` listener: terminating a socket still in
+   * CONNECTING state (very common right after a wake — the post-sleep
+   * reconnect attempt may not have completed the handshake yet) emits an
+   * asynchronous `error` event, and an unhandled `error` on a WebSocket
+   * (which extends EventEmitter) crashes the whole process.
    */
   terminateAndReconnect(reason) {
     this.stopHeartbeat();
     if (this.ws) {
-      this.ws.removeAllListeners();
+      const ws = this.ws;
+      ws.removeAllListeners();
+      ws.on("error", () => {
+      });
       try {
-        this.ws.terminate();
+        if (ws.readyState === WebSocket.CONNECTING) {
+          ws.close();
+        } else {
+          ws.terminate();
+        }
       } catch {
       }
       this.ws = null;
@@ -1224,12 +1249,15 @@ var HubConnection = class {
   scheduleReconnect() {
     if (this.destroyed) return;
     if (this.reconnectTimer) return;
-    log2.warn({ delayMs: this.reconnectDelay }, "reconnecting to hub...");
+    const cap = Math.min(this.reconnectDelay, this.maxReconnectDelay);
+    const base = Math.min(DEFAULT_RECONNECT_MS, cap);
+    const delay = Math.floor(base + Math.random() * Math.max(0, cap - base));
+    log2.warn({ delayMs: delay, capMs: cap }, "reconnecting to hub...");
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connect();
-    }, this.reconnectDelay);
-    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+    }, delay);
+    this.reconnectDelay = Math.min(cap * 2, this.maxReconnectDelay);
   }
   cleanup() {
     this.cleanupConnection();
@@ -2059,6 +2087,13 @@ var SessionManager = class {
   // correctly routed to the "spawn new + --resume" branch instead of trying
   // to write to a process we are about to kill.
   aborting = /* @__PURE__ */ new Set();
+  // Sessions whose exit was triggered by an explicit close/abort/closeAll —
+  // used by the onExit hook to label the resulting exit event as `expected`
+  // (so SwarmCoordinator can skip flipping the role to `crashed`). The set is
+  // populated *before* `adapter.stop()` runs and drained inside the onExit
+  // handler. A leftover entry would only matter if a session id were reused,
+  // which createSession already forbids (line 193 throws on duplicate).
+  expectedExits = /* @__PURE__ */ new Set();
   idleSweepTimer = null;
   // PR-A: effective sweeper config. Initialized from env at construct time
   // and overridable per-instance via startIdleSweeper(overrides) — the
@@ -2094,6 +2129,14 @@ var SessionManager = class {
   onSessionError;
   onSessionStarted;
   onBeforeClose;
+  /**
+   * Fires whenever the underlying child process exits — both expected
+   * (closeSession/abortSession) and unexpected (crash, OOM, external SIGKILL).
+   * `expected` lets the listener distinguish so a swarm coordinator can flip
+   * the role to `crashed` only on unplanned exits. Wired in start.ts to route
+   * swarm-role exits to SwarmCoordinator.handleRoleCrashed.
+   */
+  onSessionExit;
   // PR-A: classifies a sessionId as 'chat' or 'swarm-role'. Injected by
   // start.ts via SwarmCoordinator.isSwarmSession to keep SessionManager
   // independent of the swarm package. Defaults to 'chat' if absent — safe
@@ -2107,6 +2150,7 @@ var SessionManager = class {
     this.onSessionError = options.onSessionError;
     this.onSessionStarted = options.onSessionStarted;
     this.onBeforeClose = options.onBeforeClose;
+    this.onSessionExit = options.onSessionExit;
     this.classify = options.classify ?? (() => "chat");
     this.checkpointPath = options.checkpointPath ?? null;
     this.checkpointDebounceMs = options.checkpointDebounceMs ?? 5e3;
@@ -2245,13 +2289,37 @@ ${notice.text}`;
       }
       this.adapter.onExit?.(process2, (code) => {
         if (this.sessions.get(options.sessionId) === process2) {
+          const expected = this.expectedExits.delete(options.sessionId);
           this.sessions.delete(options.sessionId);
           this.sessionMeta.delete(options.sessionId);
           this.activelyExecuting.delete(options.sessionId);
           this.conversationBuffer.delete(options.sessionId);
           this.scheduleCheckpoint();
-          log5.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
-          this.onSessionError(options.sessionId, `backend process exited (code=${code ?? "null"})`);
+          if (!expected) {
+            log5.warn({ sessionId: options.sessionId, exitCode: code }, "backend process exited unexpectedly, evicted from session map");
+            this.onSessionError(options.sessionId, `backend process exited (code=${code ?? "null"})`);
+          } else {
+            log5.debug({ sessionId: options.sessionId, exitCode: code }, "backend process exited as expected");
+          }
+          try {
+            this.onSessionExit?.(options.sessionId, {
+              code: code ?? null,
+              expected,
+              ...expected ? {} : { reason: `exit code=${code ?? "null"}` }
+            });
+          } catch (err) {
+            log5.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
+          }
+        } else {
+          const expected = this.expectedExits.delete(options.sessionId);
+          try {
+            this.onSessionExit?.(options.sessionId, {
+              code: code ?? null,
+              expected
+            });
+          } catch (err) {
+            log5.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
+          }
         }
       });
       return process2.id;
@@ -2280,6 +2348,7 @@ ${notice.text}`;
     const process2 = this.sessions.get(sessionId);
     if (!process2) return;
     this.aborting.add(sessionId);
+    this.expectedExits.add(sessionId);
     this.conversationBuffer.delete(sessionId);
     this.sessions.delete(sessionId);
     this.sessionMeta.delete(sessionId);
@@ -2300,6 +2369,7 @@ ${notice.text}`;
       });
     }
     this.conversationBuffer.delete(sessionId);
+    this.expectedExits.add(sessionId);
     this.sessions.delete(sessionId);
     this.sessionMeta.delete(sessionId);
     this.activelyExecuting.delete(sessionId);
@@ -2316,6 +2386,7 @@ ${notice.text}`;
           });
         }
         this.conversationBuffer.delete(sessionId);
+        this.expectedExits.add(sessionId);
         this.sessions.delete(sessionId);
         this.sessionMeta.delete(sessionId);
         this.activelyExecuting.delete(sessionId);
@@ -3128,6 +3199,15 @@ async function startAgent(options) {
         error
       });
     },
+    onSessionExit: (sessionId, info) => {
+      if (info.expected) return;
+      if (!swarmCoordinator?.isSwarmSession(sessionId)) return;
+      try {
+        swarmCoordinator.handleRoleCrashed(sessionId, info.reason ?? `exit code=${info.code ?? "null"}`);
+      } catch (err) {
+        log9.warn({ err, sessionId }, "swarmCoordinator.handleRoleCrashed threw");
+      }
+    },
     onBeforeClose,
     // PR-A: classify session kind for the idle sweeper. SessionManager stays
     // independent of the swarm package; we hand it a closure that defers to
@@ -3185,4 +3265,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-NQ3WFEXY.js.map
+//# sourceMappingURL=chunk-LXSWV3VS.js.map