@buildautomaton/cli 0.1.27 → 0.1.28

package/dist/cli.js

@@ -25064,7 +25064,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.27".length > 0 ? "0.1.27" : "0.0.0-dev";
+var CLI_VERSION = "0.1.28".length > 0 ? "0.1.28" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -25638,6 +25638,12 @@ function sendWsMessage(ws, payload) {
   }
 }
 
+// src/connection/heartbeat/constants.ts
+var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
+var BRIDGE_HEARTBEAT_SEQ_MAX = 2147483646;
+var BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT = 4;
+var BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX = 5;
+
 // ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
 import process7 from "node:process";
 import { Buffer as Buffer2 } from "node:buffer";
@@ -26616,14 +26622,18 @@ function runPendingAuth(options) {
   }
   function connect() {
     const url2 = buildPendingBridgeUrl(apiUrl, connectionId);
+    let pendingHbSeq = -1;
     ws = createWsBridge({
       url: url2,
       onOpen: () => {
         clearQuietOnOpen();
+        pendingHbSeq = -1;
         sendWsMessage(ws, { type: "identify", role: "cli", cliVersion: CLI_VERSION });
         keepaliveInterval = setInterval(() => {
           if (resolved || !ws || ws.readyState !== 1) return;
-          sendWsMessage(ws, { type: "ping", timestamp: Date.now() });
+          pendingHbSeq = pendingHbSeq >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : pendingHbSeq + 1;
+          const hb = { t: "h", s: pendingHbSeq };
+          sendWsMessage(ws, hb);
         }, PENDING_KEEPALIVE_MS);
         if (browserFallback) {
           clearTimeout(browserFallback);
@@ -37782,6 +37792,7 @@ function reportGitRepos(getWs, log2) {
 var API_TO_BRIDGE_MESSAGE_TYPES = [
   "auth_token",
   "bridge_identified",
+  "ha",
   "dev_servers_config",
   "server_control",
   "agent_config",
@@ -37810,6 +37821,10 @@ function parseApiToBridgeMessage(data, log2) {
     }
     return null;
   }
+  if (t === "ha") {
+    const s = data.s;
+    if (typeof s !== "number" || !Number.isFinite(s)) return null;
+  }
   return data;
 }
 
@@ -37850,6 +37865,13 @@ var handleBridgeIdentified = (msg, deps) => {
   });
 };
 
+// src/connection/heartbeat/ack.ts
+var handleBridgeHeartbeatAck = (msg, deps) => {
+  const raw = msg.s;
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return;
+  deps.onBridgeHeartbeatAck?.(Math.trunc(raw));
+};
+
 // src/agents/acp/from-bridge/handle-bridge-agent-config.ts
 function handleBridgeAgentConfig(msg, { acpManager }) {
   if (!Array.isArray(msg.agents) || msg.agents.length === 0) return;
@@ -39193,6 +39215,9 @@ function dispatchBridgeMessage(msg, deps) {
     case "bridge_identified":
       handleBridgeIdentified(msg, deps);
       break;
+    case "ha":
+      handleBridgeHeartbeatAck(msg, deps);
+      break;
     case "dev_servers_config":
       handleDevServersConfig(msg, deps);
       break;
@@ -39248,9 +39273,17 @@ function dispatchBridgeMessage(msg, deps) {
 }
 
 // src/routing/handle-bridge-message.ts
+function normalizeInboundBridgeWebSocketJson(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return data;
+  const o = data;
+  if (o.t === "ha" && typeof o.s === "number" && Number.isFinite(o.s)) {
+    return { type: "ha", s: Math.trunc(o.s) };
+  }
+  return data;
+}
 function handleBridgeMessage(data, deps) {
   if (!deps.getWs()) return;
-  const msg = parseApiToBridgeMessage(data, deps.log);
+  const msg = parseApiToBridgeMessage(normalizeInboundBridgeWebSocketJson(data), deps.log);
   if (!msg) return;
   setImmediate(() => {
     dispatchBridgeMessage(msg, deps);
@@ -39298,7 +39331,8 @@ function createMainBridgeWebSocketLifecycle(params) {
     persistTokens,
     onAuthInvalid,
     e2ee,
-    identifyReportedPaths
+    identifyReportedPaths,
+    bridgeHeartbeat
   } = params;
   let authRefreshInFlight = false;
   function handleOpen() {
@@ -39330,6 +39364,7 @@ function createMainBridgeWebSocketLifecycle(params) {
     }
   }
   function handleClose(code, reason) {
+    bridgeHeartbeat?.stop();
     try {
       const was = state.currentWs;
       state.currentWs = null;
@@ -39364,6 +39399,7 @@ function createMainBridgeWebSocketLifecycle(params) {
       } catch {
       }
     }
+    bridgeHeartbeat?.stop();
     const prev = state.currentWs;
     if (prev) {
       prev.removeAllListeners();
@@ -39455,6 +39491,92 @@ function createMainBridgeWebSocketLifecycle(params) {
   return { connect };
 }
 
+// src/connection/heartbeat/controller.ts
+function meanRttMs(samples) {
+  if (samples.length === 0) return void 0;
+  let sum = 0;
+  for (const x of samples) sum += x;
+  return sum / samples.length;
+}
+function createBridgeHeartbeatController(params) {
+  const { getWs, log: log2 } = params;
+  let interval = null;
+  let seqCursor = -1;
+  let awaitingSeq = null;
+  let sentAtMs = 0;
+  let missed = 0;
+  const rttSamples = [];
+  function clearTimer() {
+    if (interval != null) {
+      clearInterval(interval);
+      interval = null;
+    }
+  }
+  function nextSeq() {
+    seqCursor = seqCursor >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : seqCursor + 1;
+    return seqCursor;
+  }
+  function tick() {
+    const ws = getWs();
+    if (!ws || ws.readyState !== wrapper_default.OPEN) return;
+    if (awaitingSeq !== null) {
+      missed++;
+      if (missed >= BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT) {
+        try {
+          log2("[Bridge service] Heartbeat missed repeatedly; reconnecting\u2026");
+        } catch {
+        }
+        clearTimer();
+        awaitingSeq = null;
+        missed = 0;
+        rttSamples.length = 0;
+        safeCloseWebSocket(ws);
+        return;
+      }
+    }
+    const seq = nextSeq();
+    const mean = meanRttMs(rttSamples);
+    const payload = mean !== void 0 && Number.isFinite(mean) ? { t: "h", s: seq, m: Math.round(mean) } : { t: "h", s: seq };
+    sendWsMessage(ws, payload);
+    awaitingSeq = seq;
+    sentAtMs = Date.now();
+  }
+  return {
+    start() {
+      clearTimer();
+      awaitingSeq = null;
+      missed = 0;
+      seqCursor = -1;
+      rttSamples.length = 0;
+      interval = setInterval(tick, BRIDGE_APP_HEARTBEAT_INTERVAL_MS);
+    },
+    stop() {
+      clearTimer();
+      awaitingSeq = null;
+      missed = 0;
+      rttSamples.length = 0;
+    },
+    onAck(seq) {
+      if (awaitingSeq === null) return;
+      if (!Number.isFinite(seq)) return;
+      const ack = Math.trunc(seq);
+      const pending = awaitingSeq;
+      if (ack < pending) return;
+      if (ack === pending) {
+        const rtt = Date.now() - sentAtMs;
+        if (Number.isFinite(rtt) && rtt >= 0 && rtt < 6e5) {
+          rttSamples.push(rtt);
+          if (rttSamples.length > BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX) {
+            rttSamples.splice(0, rttSamples.length - BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX);
+          }
+        }
+      }
+      awaitingSeq = null;
+      missed = 0;
+    }
+  };
+}
+
 // src/connection/create-bridge-connection.ts
 async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
@@ -39494,13 +39616,18 @@ async function createBridgeConnection(options) {
   }
   const e2ee = options.e2eCertificate ? createCliE2eeRuntime(options.e2eCertificate) : void 0;
   const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeRoot, e2ee });
-  const onBridgeIdentified = createOnBridgeIdentified({
+  const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: logFn });
+  const baseOnBridgeIdentified = createOnBridgeIdentified({
     devServerManager,
     firehoseServerUrl,
     workspaceId,
     state,
     logFn
   });
+  const onBridgeIdentified = (msg) => {
+    baseOnBridgeIdentified(msg);
+    bridgeHeartbeat.start();
+  };
   const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, logFn);
   const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, logFn);
   const messageDeps = {
@@ -39509,6 +39636,9 @@ async function createBridgeConnection(options) {
     acpManager,
     sessionWorktreeManager,
     onBridgeIdentified,
+    onBridgeHeartbeatAck: (seq) => {
+      bridgeHeartbeat.onAck(seq);
+    },
     sendLocalSkillsReport,
     reportAutoDetectedAgents,
     devServerManager,
@@ -39532,13 +39662,15 @@ async function createBridgeConnection(options) {
     persistTokens,
     onAuthInvalid,
     e2ee,
-    identifyReportedPaths
+    identifyReportedPaths,
+    bridgeHeartbeat
   });
   connect();
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   return {
     close: async () => {
       stopFileIndexWatcher();
+      bridgeHeartbeat.stop();
       await closeBridgeConnection(state, acpManager, devServerManager, logFn);
     }
   };