@buildautomaton/cli 0.1.39 → 0.1.40

package/dist/index.js

@@ -22093,9 +22093,9 @@ function attachWebSocketClientPing(ws, intervalMs) {
   return clear;
 }
 function buildCliWebSocketClientOptions(wsUrl) {
-  const wsOptions = { perMessageDeflate: false, family: 4 };
+  const wsOptions = { perMessageDeflate: false };
   if (wsUrl.startsWith("wss://")) {
-    wsOptions.agent = new https.Agent({ rejectUnauthorized: false, family: 4 });
+    wsOptions.agent = new https.Agent({ rejectUnauthorized: false });
   }
   return wsOptions;
 }
@@ -22130,11 +22130,47 @@ function safeSendWebSocketBinary(ws, data) {
   }
 }
 
+// src/connection/parse-compact-heartbeat-ack.ts
+function tryParseCompactHeartbeatAck(raw) {
+  let str = null;
+  if (typeof raw === "string") {
+    str = raw;
+  } else if (Buffer.isBuffer(raw)) {
+    str = raw.toString("utf8");
+  } else if (raw instanceof ArrayBuffer) {
+    str = Buffer.from(raw).toString("utf8");
+  } else {
+    return null;
+  }
+  if (str.length > 64 || !str.includes('"ha"')) return null;
+  try {
+    const parsed = JSON.parse(str);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const o = parsed;
+    if (o.t !== "ha") return null;
+    const s = o.s;
+    if (typeof s !== "number" || !Number.isFinite(s)) return null;
+    return Math.trunc(s);
+  } catch {
+    return null;
+  }
+}
+
 // src/connection/create-ws-bridge.ts
 var BRIDGE_AUTH_ERROR_HEADER = "x-bridge-auth-error";
 var BRIDGE_AUTH_ERROR_TOKEN_INVALID = "token_invalid";
 function createWsBridge(options) {
-  const { url: url2, onMessage, onOpen, onClose, onError: onError2, onAuthInvalid, clientPingIntervalMs } = options;
+  const {
+    url: url2,
+    onMessage,
+    onOpen,
+    onClose,
+    onError: onError2,
+    onAuthInvalid,
+    clientPingIntervalMs,
+    onCompactHeartbeatAck,
+    isActiveSocket
+  } = options;
   applyCliOutboundNetworkPreferences();
   const ws = new wrapper_default(url2, buildCliWebSocketClientOptions(url2));
   let clearClientPing = null;
@@ -22158,7 +22194,13 @@ function createWsBridge(options) {
     onOpen?.();
   });
   ws.on("message", (raw) => {
+    const ackSeq = tryParseCompactHeartbeatAck(raw);
+    if (ackSeq != null) {
+      onCompactHeartbeatAck?.(ackSeq);
+      return;
+    }
     setImmediate(() => {
+      if (isActiveSocket && !isActiveSocket(ws)) return;
       try {
         let data;
         if (typeof raw === "string") {
@@ -22169,9 +22211,9 @@ function createWsBridge(options) {
         } else {
           data = raw;
         }
-        onMessage?.(data);
+        onMessage?.(data, ws);
       } catch {
-        onMessage?.(raw);
+        onMessage?.(raw, ws);
       }
     });
   });
@@ -24076,7 +24118,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.39".length > 0 ? "0.1.39" : "0.0.0-dev";
+var CLI_VERSION = "0.1.40".length > 0 ? "0.1.40" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -24965,6 +25007,61 @@ function scheduleMainBridgeReconnect(state, connect, log2, closeMeta) {
   });
 }
 
+// src/connection/reconnect/duplicate-bridge-connection-detect.ts
+var BRIDGE_SUPERSEDED_CLOSE_REASON_SNIPPET = "superseded";
+var DUPLICATE_BRIDGE_SHORT_SESSION_MS = 25e3;
+var DUPLICATE_BRIDGE_FLAP_MIN_COUNT = 2;
+var DUPLICATE_BRIDGE_FLAP_WINDOW_MS = 9e4;
+var DUPLICATE_BRIDGE_STABLE_SESSION_MS = BRIDGE_APP_HEARTBEAT_INTERVAL_MS * BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT + 5e3;
+var DUPLICATE_BRIDGE_WARNING_MESSAGE = "[Bridge service] It looks like two bridges are using the same token and disconnecting each other. Stop any duplicate @buildautomaton/cli process for this workspace/token (only one bridge should run).";
+function createEmptyDuplicateBridgeFlapTracker() {
+  return {
+    sessionOpenedAtMs: null,
+    shortDisconnectAtMs: []
+  };
+}
+function isSupersededByNewBridgeClose(code, reason) {
+  if (code !== 1e3) return false;
+  return reason.toLowerCase().includes(BRIDGE_SUPERSEDED_CLOSE_REASON_SNIPPET);
+}
+function pruneShortDisconnects(tracker, nowMs) {
+  const cutoff = nowMs - DUPLICATE_BRIDGE_FLAP_WINDOW_MS;
+  tracker.shortDisconnectAtMs = tracker.shortDisconnectAtMs.filter((t) => t >= cutoff);
+}
+function recordBridgeSessionOpened(tracker, nowMs) {
+  tracker.sessionOpenedAtMs = nowMs;
+}
+function evaluateDuplicateBridgeDisconnect(tracker, nowMs, code, reason) {
+  if (isSupersededByNewBridgeClose(code, reason)) {
+    return { kind: "warn", trigger: "superseded_close" };
+  }
+  const openedAt = tracker.sessionOpenedAtMs;
+  tracker.sessionOpenedAtMs = null;
+  if (openedAt == null) {
+    return { kind: "none" };
+  }
+  const sessionMs = nowMs - openedAt;
+  if (sessionMs >= DUPLICATE_BRIDGE_STABLE_SESSION_MS) {
+    tracker.shortDisconnectAtMs = [];
+    return { kind: "none" };
+  }
+  if (sessionMs < DUPLICATE_BRIDGE_SHORT_SESSION_MS) {
+    pruneShortDisconnects(tracker, nowMs);
+    tracker.shortDisconnectAtMs.push(nowMs);
+    if (tracker.shortDisconnectAtMs.length >= DUPLICATE_BRIDGE_FLAP_MIN_COUNT) {
+      return { kind: "warn", trigger: "rapid_short_disconnects" };
+    }
+  }
+  return { kind: "none" };
+}
+function logDuplicateBridgeWarning(log2, result) {
+  if (result.kind !== "warn") return;
+  try {
+    log2(DUPLICATE_BRIDGE_WARNING_MESSAGE);
+  } catch {
+  }
+}
+
 // src/connection/reconnect/firehose-reconnect.ts
 function beginFirehoseDeferredDisconnect(ctx, code, reason, log2) {
   beginTieredSilentReconnectDisconnect({
@@ -37310,8 +37407,10 @@ function normalizeInboundBridgeWebSocketJson(data) {
   }
   return data;
 }
-function handleBridgeMessage(data, deps) {
-  if (!deps.getWs()) return;
+function handleBridgeMessage(data, deps, sourceWs) {
+  const active = deps.getWs();
+  if (!active) return;
+  if (sourceWs != null && sourceWs !== active) return;
   const msg = parseApiToBridgeMessage(normalizeInboundBridgeWebSocketJson(data), deps.log);
   if (!msg) return;
   dispatchBridgeMessage(msg, deps);
@@ -37363,6 +37462,7 @@ function createMainBridgeWebSocketLifecycle(params) {
   } = params;
   let authRefreshInFlight = false;
   function handleOpen() {
+    recordBridgeSessionOpened(state.duplicateBridgeFlap, Date.now());
     const logOpenAsPostRefreshReconnect = state.logBridgeOpenAsReconnect;
     clearMainBridgeReconnectQuietOnOpen(state, logFn);
     state.reconnectAttempt = 0;
@@ -37397,6 +37497,15 @@ function createMainBridgeWebSocketLifecycle(params) {
       state.currentWs = null;
       if (was) was.removeAllListeners();
       const willReconnect = !state.closedByUser;
+      if (willReconnect) {
+        const duplicateResult = evaluateDuplicateBridgeDisconnect(
+          state.duplicateBridgeFlap,
+          Date.now(),
+          code,
+          reason
+        );
+        logDuplicateBridgeWarning(logFn, duplicateResult);
+      }
       beginMainBridgeDeferredDisconnect(state, code, reason, logFn, willReconnect);
       if (willReconnect) {
         state.lastReconnectCloseMeta = { code, reason };
@@ -37446,6 +37555,10 @@ function createMainBridgeWebSocketLifecycle(params) {
       state.currentWs = createWsBridge({
         url: url2,
         clientPingIntervalMs: CLI_WEBSOCKET_CLIENT_PING_MS,
+        isActiveSocket: (socket) => state.currentWs === socket,
+        onCompactHeartbeatAck: (seq) => {
+          messageDeps.onBridgeHeartbeatAck?.(seq);
+        },
         onAuthInvalid: () => {
           if (authRefreshInFlight) return;
           void (async () => {
@@ -37499,9 +37612,9 @@ function createMainBridgeWebSocketLifecycle(params) {
           } catch {
           }
         },
-        onMessage: (data) => {
+        onMessage: (data, sourceWs) => {
           try {
-            handleBridgeMessage(data, messageDeps);
+            handleBridgeMessage(data, messageDeps, sourceWs);
           } catch {
           }
         }
@@ -37945,6 +38058,7 @@ async function createBridgeConnection(options) {
     currentWs: null,
     mainQuiet: createEmptyReconnectQuietSlot(),
     mainOutage: createEmptyReconnectOutageTracker(),
+    duplicateBridgeFlap: createEmptyDuplicateBridgeFlapTracker(),
     firehoseHandle: null,
     lastFirehoseParams: null,
     firehoseReconnectTimeout: null,