@vibedeckx/linux-x64 0.3.33 → 0.3.34

package/dist/bin.js

@@ -240344,7 +240344,7 @@ ${opts.reviewFocus}` : null,
 ## Scope \u2014 the change under review
 
 The reviewed turn changed exactly these files:
-${scope.changedFiles.map((f2) => `- ${f2}`).join("\n")}
+${scope.changedFiles.map((f2) => `- \`${f2}\``).join("\n")}
 
 It starts from commit \`${scope.startHead}\` \u2014 use \`git diff ${scope.startHead} -- <file>\` and \`git log ${scope.startHead}..HEAD\` to see the content.
 
@@ -263527,6 +263527,10 @@ var MACHINE_KEY_SETTING = "reverse_machine_private_key";
 var RECONNECT_BASE_DELAY_MS = 1e3;
 var RECONNECT_MAX_DELAY_MS = 3e4;
 var NO_PING_TIMEOUT_MS = 4e4;
+var HANDSHAKE_TIMEOUT_MS = 2e4;
+var SUPERVISOR_INTERVAL_MS = 1e4;
+var DIAL_TIMEOUT_MS = 25e3;
+var CLOSING_TIMEOUT_MS = 1e4;
 var AUTH_REJECT_CODES = /* @__PURE__ */ new Set([4001, 4003]);
 var HEALTHY_CONNECTION_MS = 5e3;
 function isTextualContentType(contentType2) {
@@ -263544,7 +263548,13 @@ var ReverseConnectClient = class {
   reconnectAttempt = 0;
   openedAt = null;
   reconnectTimer = null;
-  noPingTimer = null;
+  supervisorTimer = null;
+  /** When the current dial started — the CONNECTING watchdog's reference point. */
+  dialStartedAt = 0;
+  /** Last time the hub said anything on the control socket (a superset of pings). */
+  lastFrameAt = 0;
+  /** First tick that observed CLOSING, so a stalled teardown can be forced. */
+  closingSince = 0;
   shuttingDown = false;
   constructor(localServer, serverUrl, token, localPort) {
     this.localServer = localServer;
@@ -263554,27 +263564,42 @@ var ReverseConnectClient = class {
   }
   connect() {
     if (this.shuttingDown) return;
+    this.startSupervisor();
+    if (this.ws) {
+      console.warn("[ReverseClient] connect() called with a live socket \u2014 discarding the old one");
+      const stale = this.ws;
+      this.ws = null;
+      try {
+        stale.terminate();
+      } catch {
+      }
+    }
     const cleanUrl = this.serverUrl.replace(/\/+$/, "");
     const wsProtocol = cleanUrl.startsWith("https") ? "wss" : "ws";
     const wsUrl = cleanUrl.replace(/^https?/, wsProtocol);
     const connectUrl = `${wsUrl}/api/reverse-connect?token=${encodeURIComponent(this.token)}`;
     console.log(`[ReverseClient] Connecting to ${cleanUrl}...`);
-    this.ws = new wrapper_default(connectUrl, {
-      maxPayload: 11 * 1024 * 1024
-    });
-    this.ws.on("open", () => {
+    this.dialStartedAt = Date.now();
+    this.closingSince = 0;
+    const ws = new wrapper_default(connectUrl, {
+      maxPayload: 11 * 1024 * 1024,
+      handshakeTimeout: HANDSHAKE_TIMEOUT_MS
+    });
+    this.ws = ws;
+    ws.on("open", () => {
       console.log("[ReverseClient] Socket open, awaiting server handshake");
       this.openedAt = Date.now();
-      this.resetNoPingTimer();
+      this.lastFrameAt = Date.now();
       const frame = {
         type: "status",
         ready: true,
         version: readPackageVersion(),
         capabilities: WORKER_CAPABILITY_KEYS
       };
-      this.ws.send(JSON.stringify(frame));
+      ws.send(JSON.stringify(frame));
     });
-    this.ws.on("message", (data) => {
+    ws.on("message", (data) => {
+      this.lastFrameAt = Date.now();
       try {
         const frame = JSON.parse(data.toString());
         this.handleFrame(frame);
@@ -263582,48 +263607,127 @@ var ReverseConnectClient = class {
         console.error("[ReverseClient] Failed to parse frame:", err);
       }
     });
-    this.ws.on("close", (code, reason) => {
+    ws.on("close", (code, reason) => {
       const safeReason = redactSecretForms(reason?.toString() || "", this.token);
-      const rejected = AUTH_REJECT_CODES.has(code);
-      const uptime = this.openedAt === null ? 0 : Date.now() - this.openedAt;
-      if (rejected) {
-        console.error(
-          `[ReverseClient] Server rejected this connection (code=${code}, reason=${safeReason}). ` + (code === 4001 ? "The connect token is no longer valid \u2014 open Settings \u2192 Remote Servers, read the current token, and re-run `vibedeckx connect` with it." : "This machine's identity was refused \u2014 the remote record may belong to another machine or another account.") + " Retrying with backoff, but it will not recover on its own."
-        );
-      } else {
-        console.log(`[ReverseClient] Disconnected (code=${code}, reason=${safeReason})`);
-      }
-      if (!rejected && this.openedAt !== null && uptime >= HEALTHY_CONNECTION_MS) {
-        this.reconnectAttempt = 0;
-      }
-      this.openedAt = null;
-      this.clearNoPingTimer();
-      this.closeAllLocalChannels();
-      void this.localServer.remoteMcpSessionManager?.closeAll("reverse-connect disconnected");
-      this.ws = null;
-      if (!this.shuttingDown) {
-        this.scheduleReconnect();
-      }
+      this.handleDisconnect(ws, `code=${code}, reason=${safeReason}`, code);
     });
-    this.ws.on("error", (err) => {
+    ws.on("error", (err) => {
+      if (ws !== this.ws) return;
       console.error(
         "[ReverseClient] WebSocket error:",
         redactErrorSecret(err, this.token)
       );
     });
   }
+  /**
+   * The single "this connection is over" funnel. Reached from the close event,
+   * from the supervisor declaring a socket dead, or from both in that order —
+   * so it keys on socket identity and schedules at most one reconnect per
+   * connection.
+   */
+  handleDisconnect(ws, reason, code) {
+    if (ws !== null && ws !== this.ws) return;
+    const rejected = code !== void 0 && AUTH_REJECT_CODES.has(code);
+    const uptime = this.openedAt === null ? 0 : Date.now() - this.openedAt;
+    if (rejected) {
+      console.error(
+        `[ReverseClient] Server rejected this connection (${reason}). ` + (code === 4001 ? "The connect token is no longer valid \u2014 open Settings \u2192 Remote Servers, read the current token, and re-run `vibedeckx connect` with it." : "This machine's identity was refused \u2014 the remote record may belong to another machine or another account.") + " Retrying with backoff, but it will not recover on its own."
+      );
+    } else {
+      console.log(`[ReverseClient] Disconnected (${reason})`);
+    }
+    if (!rejected && this.openedAt !== null && uptime >= HEALTHY_CONNECTION_MS) {
+      this.reconnectAttempt = 0;
+    }
+    this.openedAt = null;
+    this.closingSince = 0;
+    this.closeAllLocalChannels();
+    void this.localServer.remoteMcpSessionManager?.closeAll("reverse-connect disconnected");
+    this.ws = null;
+    if (ws) {
+      try {
+        ws.terminate();
+      } catch {
+      }
+    }
+    if (this.shuttingDown) return;
+    if (this.reconnectTimer) return;
+    this.scheduleReconnect();
+  }
+  startSupervisor() {
+    if (this.supervisorTimer) return;
+    this.supervisorTimer = setInterval(() => this.superviseTick(), SUPERVISOR_INTERVAL_MS);
+    this.supervisorTimer.unref?.();
+  }
+  stopSupervisor() {
+    if (!this.supervisorTimer) return;
+    clearInterval(this.supervisorTimer);
+    this.supervisorTimer = null;
+  }
+  /**
+   * Level-triggered recovery: judges the current state against the wall clock
+   * rather than waiting to be armed by an event. That is what survives a dial
+   * that never completes, a close frame the peer never answers, and a host that
+   * was suspended for hours.
+   */
+  superviseTick() {
+    if (this.shuttingDown) return;
+    const now3 = Date.now();
+    const ws = this.ws;
+    if (ws === null) {
+      if (!this.reconnectTimer) {
+        console.warn("[ReverseClient] Supervisor: no socket and no pending reconnect \u2014 self-healing");
+        this.scheduleReconnect();
+      }
+      return;
+    }
+    switch (ws.readyState) {
+      case wrapper_default.CONNECTING: {
+        const stuckFor = now3 - this.dialStartedAt;
+        if (stuckFor > DIAL_TIMEOUT_MS) {
+          console.warn(
+            `[ReverseClient] Supervisor: dial stuck ${Math.round(stuckFor / 1e3)}s with no handshake \u2014 terminating`
+          );
+          this.handleDisconnect(ws, "dial timeout");
+        }
+        break;
+      }
+      case wrapper_default.OPEN: {
+        const silentFor = now3 - this.lastFrameAt;
+        if (silentFor > NO_PING_TIMEOUT_MS) {
+          console.warn(
+            `[ReverseClient] Supervisor: no hub traffic for ${Math.round(silentFor / 1e3)}s \u2014 terminating`
+          );
+          this.handleDisconnect(ws, "no ping timeout");
+        }
+        break;
+      }
+      case wrapper_default.CLOSING: {
+        if (this.closingSince === 0) {
+          this.closingSince = now3;
+        } else if (now3 - this.closingSince > CLOSING_TIMEOUT_MS) {
+          console.warn("[ReverseClient] Supervisor: close handshake stalled \u2014 terminating");
+          this.handleDisconnect(ws, "closing stalled");
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
   shutdown() {
     this.shuttingDown = true;
-    this.clearNoPingTimer();
+    this.stopSupervisor();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
     this.closeAllLocalChannels();
-    if (this.ws && (this.ws.readyState === wrapper_default.OPEN || this.ws.readyState === wrapper_default.CONNECTING)) {
-      this.ws.close(1e3, "Shutdown");
-    }
+    const ws = this.ws;
     this.ws = null;
+    if (ws && (ws.readyState === wrapper_default.OPEN || ws.readyState === wrapper_default.CONNECTING)) {
+      ws.close(1e3, "Shutdown");
+    }
   }
   async handleFrame(frame) {
     switch (frame.type) {
@@ -263796,7 +263900,6 @@ var ReverseConnectClient = class {
     }
   }
   handlePing(frame) {
-    this.resetNoPingTimer();
     const pong = { type: "pong", ts: frame.ts };
     this.sendFrame(pong);
   }
@@ -263819,21 +263922,6 @@ var ReverseConnectClient = class {
       this.connect();
     }, totalDelay);
   }
-  resetNoPingTimer() {
-    this.clearNoPingTimer();
-    this.noPingTimer = setTimeout(() => {
-      console.log(`[ReverseClient] No ping received in ${NO_PING_TIMEOUT_MS / 1e3}s, reconnecting...`);
-      if (this.ws) {
-        this.ws.close(1e3, "No ping timeout");
-      }
-    }, NO_PING_TIMEOUT_MS);
-  }
-  clearNoPingTimer() {
-    if (this.noPingTimer) {
-      clearTimeout(this.noPingTimer);
-      this.noPingTimer = null;
-    }
-  }
   closeAllLocalChannels() {
     for (const [id, ws] of this.localChannels) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.33",
+  "version": "0.3.34",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"