@buildautomaton/cli 0.1.65 → 0.1.66

package/dist/index.js

@@ -25326,7 +25326,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.65".length > 0 ? "0.1.65" : "0.0.0-dev";
+var CLI_VERSION = "0.1.66".length > 0 ? "0.1.66" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -36351,6 +36351,208 @@ function createOnBridgeIdentified(opts) {
   };
 }
 
+// src/connection/create-bridge-identified-with-heartbeat.ts
+function createBridgeIdentifiedWithHeartbeat(params) {
+  const { bridgeHeartbeat, log: log2, ...identifiedOpts } = params;
+  const onBridgeIdentified = createOnBridgeIdentified({ ...identifiedOpts, logFn: log2 });
+  return (msg) => {
+    onBridgeIdentified(msg);
+    bridgeHeartbeat.start();
+  };
+}
+
+// src/connection/heartbeat/build-heartbeat-message.ts
+function buildBridgeHeartbeatMessage(seq, meanRttMs2) {
+  return meanRttMs2 !== void 0 && Number.isFinite(meanRttMs2) ? { t: "h", s: seq, m: Math.round(meanRttMs2) } : { t: "h", s: seq };
+}
+
+// src/connection/heartbeat/heartbeat-seq.ts
+function createHeartbeatSeqCursor() {
+  let seqCursor = -1;
+  return {
+    next() {
+      seqCursor = seqCursor >= BRIDGE_HEARTBEAT_SEQ_MAX ? 0 : seqCursor + 1;
+      return seqCursor;
+    },
+    reset() {
+      seqCursor = -1;
+    }
+  };
+}
+
+// src/connection/heartbeat/handle-pending-heartbeat-miss.ts
+function handlePendingHeartbeatMiss(params) {
+  const { awaitingSeq, missed, log: log2, ws, onReconnect } = params;
+  if (awaitingSeq === null) return { missed, stopTick: false };
+  const nextMissed = missed + 1;
+  if (nextMissed < BRIDGE_HEARTBEAT_MISSED_ACKS_BEFORE_RECONNECT) {
+    return { missed: nextMissed, stopTick: false };
+  }
+  try {
+    log2("[Bridge service] Heartbeat missed repeatedly; reconnecting\u2026");
+  } catch {
+  }
+  onReconnect();
+  safeCloseWebSocket(ws);
+  return { missed: 0, stopTick: true };
+}
+
+// src/connection/heartbeat/on-every-n-ticks.ts
+function createEveryNTicksRunner(onEveryNTicks) {
+  let tickCount = 0;
+  return {
+    reset() {
+      tickCount = 0;
+    },
+    onTick() {
+      if (!onEveryNTicks || onEveryNTicks.n <= 0) return;
+      tickCount++;
+      if (tickCount % onEveryNTicks.n !== 0) return;
+      try {
+        onEveryNTicks.fn();
+      } catch {
+      }
+    }
+  };
+}
+
+// src/connection/heartbeat/process-heartbeat-ack.ts
+function processHeartbeatAck(params) {
+  const { seq, awaitingSeq, sentAtMs, recordRtt } = params;
+  if (awaitingSeq === null) return { awaitingSeq, missed: 0 };
+  if (!Number.isFinite(seq)) return { awaitingSeq, missed: 0 };
+  const ack = Math.trunc(seq);
+  const pending = awaitingSeq;
+  if (ack < pending) return { awaitingSeq, missed: 0 };
+  if (ack === pending) {
+    recordRtt(Date.now() - sentAtMs);
+  }
+  return { awaitingSeq: null, missed: 0 };
+}
+
+// src/connection/heartbeat/rtt-samples.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 createRttSampleBuffer(maxSamples = BRIDGE_HEARTBEAT_RTT_SAMPLE_MAX) {
+  const samples = [];
+  return {
+    push(rttMs) {
+      if (!Number.isFinite(rttMs) || rttMs < 0 || rttMs >= 6e5) return;
+      samples.push(rttMs);
+      if (samples.length > maxSamples) {
+        samples.splice(0, samples.length - maxSamples);
+      }
+    },
+    clear() {
+      samples.length = 0;
+    },
+    mean() {
+      return meanRttMs(samples);
+    }
+  };
+}
+
+// src/connection/heartbeat/controller.ts
+function createBridgeHeartbeatController(params) {
+  const { getWs, log: log2, onEveryNTicks } = params;
+  let interval = null;
+  let awaitingSeq = null;
+  let sentAtMs = 0;
+  let missed = 0;
+  const seqCursor = createHeartbeatSeqCursor();
+  const rttSamples = createRttSampleBuffer();
+  const everyNTicks = createEveryNTicksRunner(onEveryNTicks);
+  function clearTimer() {
+    if (interval != null) {
+      clearInterval(interval);
+      interval = null;
+    }
+  }
+  function resetPendingState() {
+    awaitingSeq = null;
+    missed = 0;
+    rttSamples.clear();
+  }
+  function tick() {
+    const ws = getWs();
+    if (!ws || ws.readyState !== wrapper_default.OPEN) return;
+    const missResult = handlePendingHeartbeatMiss({
+      awaitingSeq,
+      missed,
+      log: log2,
+      ws,
+      onReconnect: () => {
+        clearTimer();
+        resetPendingState();
+      }
+    });
+    missed = missResult.missed;
+    if (missResult.stopTick) return;
+    const seq = seqCursor.next();
+    sendWsMessage(ws, buildBridgeHeartbeatMessage(seq, rttSamples.mean()));
+    awaitingSeq = seq;
+    sentAtMs = Date.now();
+    everyNTicks.onTick();
+  }
+  return {
+    start() {
+      clearTimer();
+      everyNTicks.reset();
+      resetPendingState();
+      seqCursor.reset();
+      interval = setInterval(tick, BRIDGE_APP_HEARTBEAT_INTERVAL_MS);
+    },
+    stop() {
+      clearTimer();
+      resetPendingState();
+    },
+    onAck(seq) {
+      const result = processHeartbeatAck({
+        seq,
+        awaitingSeq,
+        sentAtMs,
+        recordRtt: rttSamples.push
+      });
+      awaitingSeq = result.awaitingSeq;
+      missed = result.missed;
+    }
+  };
+}
+
+// src/connection/send-bridge-identify.ts
+function sendBridgeIdentify(ws, params) {
+  if (!ws) return;
+  const { identifyReportedPaths, e2ee } = params;
+  sendWsMessage(ws, {
+    type: "identify",
+    role: "cli",
+    cliVersion: CLI_VERSION,
+    bridgeRootPath: identifyReportedPaths.bridgeRootPath,
+    worktreesRootPath: identifyReportedPaths.worktreesRootPath,
+    localShortcutPort: identifyReportedPaths.localShortcutPort,
+    localShortcutToken: identifyReportedPaths.localShortcutToken,
+    ...e2ee ? { e: e2ee.handshake } : {}
+  });
+}
+var BRIDGE_IDENTIFY_REFRESH_EVERY_TICKS = 6;
+
+// src/connection/create-bridge-identify-heartbeat.ts
+function createBridgeIdentifyHeartbeat(params) {
+  const { getWs, log: log2, identifyReportedPaths, e2ee } = params;
+  return createBridgeHeartbeatController({
+    getWs,
+    log: log2,
+    onEveryNTicks: {
+      n: BRIDGE_IDENTIFY_REFRESH_EVERY_TICKS,
+      fn: () => sendBridgeIdentify(getWs(), { identifyReportedPaths, e2ee })
+    }
+  });
+}
+
 // src/connection/create-bridge-message-deps.ts
 function createBridgeMessageDeps(params) {
   const {
@@ -36517,98 +36719,11 @@ function createReportAutoDetectedAgents(getWs, logFn) {
   };
 }
 
-// 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-runtime-message-setup.ts
-function createBridgeRuntimeMessageSetup(options) {
+// src/connection/create-bridge-runtime-message-deps.ts
+function createBridgeRuntimeMessageDeps(params) {
   const {
     apiUrl,
     workspaceId,
-    firehoseServerUrl,
     state,
     getWs,
     log: log2,
@@ -36617,23 +36732,11 @@ function createBridgeRuntimeMessageSetup(options) {
     sessionWorktreeManager,
     previewWorktreeManager,
     previewEnvironmentManager,
-    e2ee
-  } = options;
-  const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: log2 });
-  const baseOnBridgeIdentified = createOnBridgeIdentified({
-    previewEnvironmentManager,
-    firehoseServerUrl,
-    workspaceId,
-    state,
-    logFn: log2
-  });
-  const onBridgeIdentified = (msg) => {
-    baseOnBridgeIdentified(msg);
-    bridgeHeartbeat.start();
-  };
-  const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, log2);
-  const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, log2);
-  const messageDeps = createBridgeMessageDeps({
+    e2ee,
+    onBridgeIdentified,
+    bridgeHeartbeat
+  } = params;
+  return createBridgeMessageDeps({
     getWs,
     log: log2,
     acpManager,
@@ -36641,8 +36744,8 @@ function createBridgeRuntimeMessageSetup(options) {
     previewWorktreeManager,
     onBridgeIdentified,
     bridgeHeartbeat,
-    sendLocalSkillsReport,
-    reportAutoDetectedAgents,
+    sendLocalSkillsReport: createSendLocalSkillsReport(getWs, log2),
+    reportAutoDetectedAgents: createReportAutoDetectedAgents(getWs, log2),
     warmupAgentCapabilitiesOnConnect: createWarmupAgentCapabilitiesOnConnect({
       workspaceId,
       log: log2,
@@ -36658,6 +36761,54 @@ function createBridgeRuntimeMessageSetup(options) {
     cloudApiBaseUrl: apiUrl,
     getCloudAccessToken: () => tokens.accessToken
   });
+}
+
+// src/connection/create-bridge-runtime-message-setup.ts
+function createBridgeRuntimeMessageSetup(options) {
+  const {
+    apiUrl,
+    workspaceId,
+    firehoseServerUrl,
+    state,
+    getWs,
+    log: log2,
+    tokens,
+    acpManager,
+    sessionWorktreeManager,
+    previewWorktreeManager,
+    previewEnvironmentManager,
+    e2ee,
+    identifyReportedPaths
+  } = options;
+  const bridgeHeartbeat = createBridgeIdentifyHeartbeat({
+    getWs,
+    log: log2,
+    identifyReportedPaths,
+    e2ee
+  });
+  const onBridgeIdentified = createBridgeIdentifiedWithHeartbeat({
+    previewEnvironmentManager,
+    firehoseServerUrl,
+    workspaceId,
+    state,
+    log: log2,
+    bridgeHeartbeat
+  });
+  const messageDeps = createBridgeRuntimeMessageDeps({
+    apiUrl,
+    workspaceId,
+    state,
+    getWs,
+    log: log2,
+    tokens,
+    acpManager,
+    sessionWorktreeManager,
+    previewWorktreeManager,
+    previewEnvironmentManager,
+    e2ee,
+    onBridgeIdentified,
+    bridgeHeartbeat
+  });
   return { bridgeHeartbeat, messageDeps };
 }
 
@@ -45463,7 +45614,8 @@ async function createBridgeConnectionRuntime(options, params) {
     sessionWorktreeManager,
     previewWorktreeManager,
     previewEnvironmentManager,
-    e2ee
+    e2ee,
+    identifyReportedPaths
   });
   return {
     state,
@@ -47490,27 +47642,6 @@ function createMainBridgeCloseHandler(params, connect) {
   };
 }
 
-// src/connection/report-git-repos.ts
-function reportGitRepos(getWs, log2) {
-  setImmediate(() => {
-    discoverGitRepos().then((repos) => {
-      if (repos.length > 0) {
-        const socket = getWs();
-        if (socket) {
-          sendWsMessage(socket, {
-            type: "git_repos",
-            repos: repos.map((r) => ({ absolutePath: r.absolutePath, remoteUrl: r.remoteUrl }))
-          });
-        }
-      }
-    }).catch((err) => {
-      log2(
-        `[Bridge service] Git repository discovery failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    });
-  });
-}
-
 // src/connection/main-bridge-ws-open-handler.ts
 function createMainBridgeOpenHandler(params) {
   const {
@@ -47535,16 +47666,7 @@ function createMainBridgeOpenHandler(params) {
     }
     const socket = getWs();
     if (socket) {
-      sendWsMessage(socket, {
-        type: "identify",
-        role: "cli",
-        cliVersion: CLI_VERSION,
-        bridgeRootPath: identifyReportedPaths.bridgeRootPath,
-        worktreesRootPath: identifyReportedPaths.worktreesRootPath,
-        localShortcutPort: identifyReportedPaths.localShortcutPort,
-        localShortcutToken: identifyReportedPaths.localShortcutToken,
-        ...e2ee ? { e: e2ee.handshake } : {}
-      });
+      sendBridgeIdentify(socket, { identifyReportedPaths, e2ee });
       reportGitRepos(getWs, logFn);
       try {
         onBridgeSocketOpen?.();