@mclawnet/agent 0.6.27 → 0.6.28

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

@@ -474,10 +474,19 @@ var log2 = createLogger2({ module: "agent" });
 var HubConnection = class {
   ws = null;
   heartbeatTimer = null;
+  wakeWatchTimer = null;
   reconnectTimer = null;
   reconnectDelay;
   destroyed = false;
   authState = "pending";
+  /** Liveness tracking — if hub stops acking, the socket is dead even when
+   * the OS hasn't yet noticed (very common after a Mac/laptop wakes from
+   * sleep: the kernel believes the socket is up, but the peer / NAT box
+   * dropped it minutes ago). We probe by counting acks. */
+  lastAckAt = 0;
+  /** Wall-clock checkpoint for the wake watcher. A jump larger than the
+   * interval signals the process was suspended (sleep / Power Nap). */
+  lastWakeTickAt = 0;
   hubUrl;
   token;
   hostname;
@@ -514,6 +523,7 @@ var HubConnection = class {
     this.onConnectCb = opts.onConnect;
     this.onDisconnect = opts.onDisconnect;
     this.onError = opts.onError;
+    this.startWakeWatch();
   }
   setSessionManager(manager) {
     this.sessionManager = manager;
@@ -549,6 +559,7 @@ var HubConnection = class {
   }
   connect() {
     if (this.destroyed) return;
+    if (this.ws || this.reconnectTimer) return;
     this.cleanupConnection();
     this.authState = "pending";
     this.ws = new WebSocket(this.hubUrl);
@@ -585,6 +596,7 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "authenticated") {
+        this.lastAckAt = Date.now();
         if (this.handleSessionMessage(data)) return;
         this.onMessage?.(data);
       }
@@ -592,6 +604,7 @@ var HubConnection = class {
     this.ws.on("close", (code, reason) => {
       log2.warn({ code, reason: reason.toString() }, "disconnected from hub");
       this.stopHeartbeat();
+      this.ws = null;
       this.authState = "pending";
       this.onDisconnect?.(code, reason.toString());
       if (code === WS_CLOSE_INVALID_TOKEN) {
@@ -1123,7 +1136,17 @@ var HubConnection = class {
   }
   startHeartbeat() {
     this.stopHeartbeat();
+    this.lastAckAt = Date.now();
     this.heartbeatTimer = setInterval(() => {
+      const sinceAck = Date.now() - this.lastAckAt;
+      if (sinceAck > this.heartbeatInterval * 2.5) {
+        log2.warn(
+          { sinceAckMs: sinceAck, heartbeatIntervalMs: this.heartbeatInterval },
+          "no ack from hub \u2014 terminating dead socket"
+        );
+        this.terminateAndReconnect("liveness_timeout");
+        return;
+      }
       this.send({ type: "heartbeat", ts: Date.now() });
     }, this.heartbeatInterval);
   }
@@ -1133,16 +1156,84 @@ var HubConnection = class {
       this.heartbeatTimer = null;
     }
   }
+  /**
+   * Detect machine wake-ups (sleep / Power Nap) by watching wall-clock jumps.
+   * Node timers are paused while the process is suspended, so a tick that
+   * fires "late" by more than the watch interval signals the host just woke.
+   * On wake we proactively terminate the socket — it is almost certainly
+   * half-open at this point — instead of waiting up to 2× heartbeat for the
+   * liveness probe above to notice.
+   */
+  startWakeWatch() {
+    this.stopWakeWatch();
+    const intervalMs = 1e3;
+    const jumpThresholdMs = 5e3;
+    this.lastWakeTickAt = Date.now();
+    this.wakeWatchTimer = setInterval(() => {
+      const now = Date.now();
+      const drift = now - this.lastWakeTickAt - intervalMs;
+      this.lastWakeTickAt = now;
+      if (drift <= jumpThresholdMs) return;
+      log2.warn(
+        { driftMs: drift, hasSocket: !!this.ws },
+        "wake detected (clock jump) \u2014 forcing reconnect"
+      );
+      this.reconnectDelay = DEFAULT_RECONNECT_MS;
+      if (this.ws) {
+        this.terminateAndReconnect("wake_detected");
+      } else {
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        this.scheduleReconnect();
+      }
+    }, intervalMs);
+    this.wakeWatchTimer.unref();
+  }
+  stopWakeWatch() {
+    if (this.wakeWatchTimer) {
+      clearInterval(this.wakeWatchTimer);
+      this.wakeWatchTimer = null;
+    }
+  }
+  /**
+   * Hard-kill the socket (RST, no four-way handshake) and immediately schedule
+   * a reconnect. Used when we know the connection is dead but the OS hasn't
+   * surfaced it yet — calling `close()` here would block on a FIN-ACK that
+   * will never arrive.
+   *
+   * 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.
+   */
+  terminateAndReconnect(reason) {
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      try {
+        this.ws.terminate();
+      } catch {
+      }
+      this.ws = null;
+    }
+    log2.warn({ reason }, "forced reconnect");
+    this.authState = "pending";
+    this.scheduleReconnect();
+  }
   scheduleReconnect() {
     if (this.destroyed) return;
+    if (this.reconnectTimer) return;
     log2.warn({ delayMs: this.reconnectDelay }, "reconnecting to hub...");
     this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
       this.connect();
     }, this.reconnectDelay);
     this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
   }
   cleanup() {
     this.cleanupConnection();
+    this.stopWakeWatch();
     this.sessionManager?.closeAll().catch(() => {
     });
   }
@@ -3094,4 +3185,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-K6CQFAGN.js.map
+//# sourceMappingURL=chunk-NQ3WFEXY.js.map