@buildautomaton/cli 0.1.9 → 0.1.11

package/dist/index.js

@@ -2236,7 +2236,7 @@ var require_websocket = __commonJS({
   "../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
     var EventEmitter2 = __require("events");
-    var https3 = __require("https");
+    var https2 = __require("https");
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
@@ -2771,7 +2771,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes(16).toString("base64");
-      const request = isSecure ? https3.request : http.request;
+      const request = isSecure ? https2.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -22050,9 +22050,6 @@ var require_dist2 = __commonJS({
   }
 });
 
-// src/bridge/connection/create-ws-bridge.ts
-import https from "node:https";
-
 // ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
 var import_receiver = __toESM(require_receiver(), 1);
@@ -22073,26 +22070,77 @@ function applyCliOutboundNetworkPreferences() {
   }
 }
 
+// src/bridge/connection/cli-ws-client.ts
+import https from "node:https";
+var CLI_WEBSOCKET_CLIENT_PING_MS = 25e3;
+function attachWebSocketClientPing(ws, intervalMs) {
+  let timer = null;
+  function clear() {
+    if (timer != null) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  clear();
+  timer = setInterval(() => {
+    if (ws.readyState === wrapper_default.OPEN) {
+      try {
+        ws.ping();
+      } catch {
+      }
+    }
+  }, intervalMs);
+  return clear;
+}
+function buildCliWebSocketClientOptions(wsUrl) {
+  const wsOptions = { perMessageDeflate: false, family: 4 };
+  if (wsUrl.startsWith("wss://")) {
+    wsOptions.agent = new https.Agent({ rejectUnauthorized: false, family: 4 });
+  }
+  return wsOptions;
+}
+function logCliWebSocketError(log2, serviceLabel, err, detail) {
+  const mid = detail ? ` ${detail}` : "";
+  log2(`${serviceLabel} WebSocket error${mid}: ${err.message}`);
+}
+function safeCloseWebSocket(ws) {
+  try {
+    if (ws.readyState === wrapper_default.CLOSED) {
+      ws.removeAllListeners();
+      return;
+    }
+    ws.once("close", () => {
+      ws.removeAllListeners();
+    });
+    ws.close();
+  } catch {
+    try {
+      ws.removeAllListeners();
+    } catch {
+    }
+  }
+}
+function safeSendWebSocketBinary(ws, data) {
+  if (ws.readyState !== wrapper_default.OPEN) return false;
+  try {
+    ws.send(data, { binary: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/bridge/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;
   applyCliOutboundNetworkPreferences();
-  const wsOptions = {
-    perMessageDeflate: false,
-    family: 4
-  };
-  if (url2.startsWith("wss://")) {
-    wsOptions.agent = new https.Agent({ rejectUnauthorized: false, family: 4 });
-  }
-  const ws = new wrapper_default(url2, wsOptions);
-  let clientPingTimer = null;
-  function clearClientPing() {
-    if (clientPingTimer != null) {
-      clearInterval(clientPingTimer);
-      clientPingTimer = null;
-    }
+  const ws = new wrapper_default(url2, buildCliWebSocketClientOptions(url2));
+  let clearClientPing = null;
+  function disposeClientPing() {
+    clearClientPing?.();
+    clearClientPing = null;
   }
   ws.on("unexpected-response", (request, response) => {
     const status = response?.statusCode ?? 0;
@@ -22103,16 +22151,9 @@ function createWsBridge(options) {
     }
   });
   ws.on("open", () => {
-    clearClientPing();
+    disposeClientPing();
     if (clientPingIntervalMs != null && clientPingIntervalMs > 0) {
-      clientPingTimer = setInterval(() => {
-        if (ws.readyState === wrapper_default.OPEN) {
-          try {
-            ws.ping();
-          } catch {
-          }
-        }
-      }, clientPingIntervalMs);
+      clearClientPing = attachWebSocketClientPing(ws, clientPingIntervalMs);
     }
     onOpen?.();
   });
@@ -22133,11 +22174,11 @@ function createWsBridge(options) {
     }
   });
   ws.on("close", (code, reason) => {
-    clearClientPing();
+    disposeClientPing();
     onClose?.(code, reason.toString());
   });
   ws.on("error", (err) => {
-    clearClientPing();
+    disposeClientPing();
     onError2?.(err);
   });
   return ws;
@@ -22823,12 +22864,64 @@ async function createSdkStdioAcpClient(options) {
   });
 }
 
+// src/net/transient-local-fetch-retry.ts
+var LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS = [30, 100, 200, 400];
+function sleepMs(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function collectErrorText(err) {
+  const parts = [];
+  let e = err;
+  for (let depth = 0; depth < 6 && e != null; depth += 1) {
+    if (e instanceof Error) {
+      parts.push(e.message);
+      e = e.cause;
+    } else {
+      parts.push(String(e));
+      break;
+    }
+  }
+  return parts.join(" ").toLowerCase();
+}
+function isTransientLocalServiceError(err) {
+  const text = collectErrorText(err);
+  if (!text) return false;
+  return text.includes("fetch failed") || text.includes("econnrefused") || text.includes("econnreset") || text.includes("epipe") || text.includes("etimedout") || text.includes("socket hang up") || text.includes("network connection lost") || text.includes("ecanceled") || text.includes("aborted") || text.includes("und_err_socket") || text.includes("other side closed") || text.includes("eai_again");
+}
+function isIdempotentHttpMethod(method) {
+  const m = method.toUpperCase();
+  return m === "GET" || m === "HEAD" || m === "OPTIONS";
+}
+async function fetchWithLocalTransientRetries(url2, init, options) {
+  const method = (init?.method ?? "GET").toUpperCase();
+  const allowRetry = isIdempotentHttpMethod(method);
+  const delays = options?.delaysMs ?? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS;
+  const maxAttempts = options?.maxAttempts ?? (allowRetry ? Math.max(1, delays.length + 1) : 1);
+  let lastErr;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      return await fetch(url2, init);
+    } catch (e) {
+      lastErr = e;
+      const canRetry = allowRetry && attempt < maxAttempts - 1 && isTransientLocalServiceError(e);
+      if (!canRetry) throw e;
+      const waitMs = delays[Math.min(attempt, delays.length - 1)] ?? 100;
+      await sleepMs(waitMs);
+    }
+  }
+  throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+
 // src/firehose/proxy/local-proxy.ts
 var ALLOWED_HOSTS = ["localhost", "127.0.0.1", "::1"];
 function isAllowedHost(host) {
   const h = host.replace(/^\[|\]$/g, "");
   return ALLOWED_HOSTS.includes(host) || ALLOWED_HOSTS.includes(h);
 }
+function isIdempotentProxyMethod(method) {
+  const m = method.toUpperCase();
+  return m === "GET" || m === "HEAD" || m === "OPTIONS";
+}
 function checkUrlAndHost(request) {
   let url2;
   try {
@@ -22856,38 +22949,47 @@ async function proxyToLocal(request) {
     path: url2.pathname + url2.search,
     headers: request.headers
   };
-  return new Promise((resolve14) => {
-    const req = mod.request(opts, (res) => {
-      const chunks = [];
-      res.on("data", (c) => chunks.push(c));
-      res.on("end", () => {
-        const body = Buffer.concat(chunks).toString("utf8");
-        const headers = {};
-        for (const [k, v] of Object.entries(res.headers)) {
-          if (typeof v === "string") headers[k] = v;
-          else if (Array.isArray(v) && v[0]) headers[k] = v[0];
-        }
+  const maxAttempts = isIdempotentProxyMethod(request.method) ? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length + 1 : 1;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const once = await new Promise((resolve14) => {
+      const req = mod.request(opts, (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          const body = Buffer.concat(chunks).toString("utf8");
+          const headers = {};
+          for (const [k, v] of Object.entries(res.headers)) {
+            if (typeof v === "string") headers[k] = v;
+            else if (Array.isArray(v) && v[0]) headers[k] = v[0];
+          }
+          resolve14({
+            id: request.id,
+            statusCode: res.statusCode ?? 0,
+            headers,
+            body
+          });
+        });
+      });
+      req.on("error", (err) => {
         resolve14({
           id: request.id,
-          statusCode: res.statusCode ?? 0,
-          headers,
-          body
+          statusCode: 0,
+          headers: {},
+          body: "",
+          error: err.message
         });
       });
+      const method = request.method.toUpperCase();
+      if (request.body && method !== "GET" && method !== "HEAD") req.write(request.body);
+      req.end();
     });
-    req.on("error", (err) => {
-      resolve14({
-        id: request.id,
-        statusCode: 0,
-        headers: {},
-        body: "",
-        error: err.message
-      });
-    });
-    const method = request.method.toUpperCase();
-    if (request.body && method !== "GET" && method !== "HEAD") req.write(request.body);
-    req.end();
-  });
+    const errMsg = once.error ?? "";
+    const canRetry = attempt < maxAttempts - 1 && errMsg !== "" && isTransientLocalServiceError(new Error(errMsg));
+    if (!canRetry) return once;
+    const waitMs = LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS[Math.min(attempt, LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length - 1)] ?? 100;
+    await sleepMs(waitMs);
+  }
+  throw new Error("Local proxy retry loop exited unexpectedly");
 }
 async function proxyToLocalStreaming(request, callbacks) {
   const checked = checkUrlAndHost(request);
@@ -22904,7 +23006,7 @@ async function proxyToLocalStreaming(request, callbacks) {
     if (request.body !== void 0 && request.body !== null && method !== "GET" && method !== "HEAD") {
       init.body = request.body;
     }
-    const res = await fetch(request.url, init);
+    const res = await fetchWithLocalTransientRetries(request.url, init);
     const headers = {};
     res.headers.forEach((value, key) => {
       headers[key] = value;
@@ -23437,9 +23539,9 @@ function runPendingAuth(options) {
       keepaliveInterval = null;
     }
     if (ws) {
-      ws.removeAllListeners();
-      ws.close();
+      const w = ws;
       ws = null;
+      safeCloseWebSocket(w);
     }
   }
   function connect() {
@@ -23482,7 +23584,7 @@ function runPendingAuth(options) {
           connect();
         }, delay2);
       },
-      onError: (err) => logFn(`[Bridge service] WebSocket error while waiting for sign-in: ${err.message}`),
+      onError: (err) => logCliWebSocketError(logFn, "[Bridge service]", err, "while waiting for sign-in"),
       onMessage: (data) => {
         const msg = data;
         if (msg.type === "auth_token" && typeof msg.token === "string") {
@@ -30037,14 +30139,50 @@ async function removeSessionWorktrees(paths, log2) {
 }
 
 // src/git/working-tree-status.ts
-async function commitsAheadOfUpstream(repoDir) {
-  const g = simpleGit(repoDir);
+async function tryConfigGet(g, key) {
+  try {
+    const out = await g.raw(["config", "--get", key]);
+    const v = String(out).trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveRemoteTrackingRefForAhead(g) {
   try {
     await g.raw(["rev-parse", "--verify", "@{u}"]);
+    return "@{u}";
+  } catch {
+  }
+  const branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  if (!branch || branch === "HEAD") return null;
+  const remote = await tryConfigGet(g, `branch.${branch}.remote`) ?? "origin";
+  const merge2 = await tryConfigGet(g, `branch.${branch}.merge`);
+  if (merge2) {
+    const upstreamBranch = merge2.replace(/^refs\/heads\//, "");
+    const ref = `refs/remotes/${remote}/${upstreamBranch}`;
+    try {
+      await g.raw(["rev-parse", "--verify", ref]);
+      return ref;
+    } catch {
+    }
+  }
+  const fallbackRef = `refs/remotes/${remote}/${branch}`;
+  try {
+    await g.raw(["rev-parse", "--verify", fallbackRef]);
+    return fallbackRef;
   } catch {
-    return 0;
+    return null;
   }
-  const out = await g.raw(["rev-list", "--count", "@{u}..HEAD"]);
+}
+async function commitsAheadOfRemoteTracking(repoDir) {
+  const g = simpleGit(repoDir);
+  const trackingRef = await resolveRemoteTrackingRefForAhead(g);
+  if (!trackingRef) return 0;
+  const localSha = (await g.raw(["rev-parse", "HEAD"])).trim();
+  const remoteSha = (await g.raw(["rev-parse", trackingRef])).trim();
+  if (localSha === remoteSha) return 0;
+  const out = await g.raw(["rev-list", "--count", `${trackingRef}..HEAD`]);
   const n = parseInt(String(out).trim(), 10);
   return Number.isNaN(n) ? 0 : n;
 }
@@ -30052,7 +30190,7 @@ async function getRepoWorkingTreeStatus(repoDir) {
   const g = simpleGit(repoDir);
   const st = await g.status();
   const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
-  const ahead = await commitsAheadOfUpstream(repoDir);
+  const ahead = await commitsAheadOfRemoteTracking(repoDir);
   return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0 };
 }
 async function aggregateSessionPathsWorkingTreeStatus(paths) {
@@ -30068,7 +30206,7 @@ async function aggregateSessionPathsWorkingTreeStatus(paths) {
 async function pushAheadOfUpstreamForPaths(paths) {
   for (const p of paths) {
     const g = simpleGit(p);
-    const ahead = await commitsAheadOfUpstream(p);
+    const ahead = await commitsAheadOfRemoteTracking(p);
     if (ahead <= 0) continue;
     await g.push();
   }
@@ -31343,13 +31481,13 @@ var DevServerManager = class {
   }
 };
 
-// src/firehose/connect-firehose.ts
-import https2 from "node:https";
-
 // src/firehose/proxy/start-streaming-proxy.ts
 function startStreamingProxy(ws, log2, pr) {
   proxyToLocalStreaming(pr, {
     onStart: (statusCode, headers) => {
+      if (ws.readyState !== wrapper_default.OPEN) {
+        throw new Error("Preview stream interrupted (firehose connection closed)");
+      }
       const forwardedHeaders = { ...headers };
       const ce = "content-encoding";
       const cl = "content-length";
@@ -31362,7 +31500,10 @@ function startStreamingProxy(ws, log2, pr) {
     },
     onChunk: (chunk) => {
       const idBuf = Buffer.from(pr.id, "utf8");
-      ws.send(Buffer.concat([idBuf, Buffer.from(chunk)]), { binary: true });
+      const buf = Buffer.concat([idBuf, Buffer.from(chunk)]);
+      if (!safeSendWebSocketBinary(ws, buf)) {
+        throw new Error("Preview stream interrupted (firehose connection closed)");
+      }
     },
     onEnd: () => sendWsMessage(ws, { type: "proxy_result_end", id: pr.id }),
     onError: (error40) => {
@@ -31480,22 +31621,15 @@ function tryConsumeBinaryProxyBody(raw, deps) {
 }
 
 // src/firehose/connect-firehose.ts
-var FIREHOSE_CLIENT_PING_MS = 25e3;
 function connectFirehose(options) {
   const { firehoseServerUrl, workspaceId, bridgeName, proxyPorts, log: log2, devServerManager, onOpen, onClose } = options;
   const wsUrl = buildFirehoseCliWsUrl(firehoseServerUrl);
   applyCliOutboundNetworkPreferences();
-  const wsOptions = { perMessageDeflate: false, family: 4 };
-  if (wsUrl.startsWith("wss://")) {
-    wsOptions.agent = new https2.Agent({ rejectUnauthorized: false, family: 4 });
-  }
-  const ws = new wrapper_default(wsUrl, wsOptions);
-  let clientPingTimer = null;
-  function clearClientPing() {
-    if (clientPingTimer != null) {
-      clearInterval(clientPingTimer);
-      clientPingTimer = null;
-    }
+  const ws = new wrapper_default(wsUrl, buildCliWebSocketClientOptions(wsUrl));
+  let clearClientPing = null;
+  function disposeClientPing() {
+    clearClientPing?.();
+    clearClientPing = null;
   }
   const firehoseSend = (payload) => {
     sendWsMessage(ws, payload);
@@ -31509,15 +31643,8 @@ function connectFirehose(options) {
     startStreamingProxy: (pr) => startStreamingProxy(ws, log2, pr)
   };
   ws.on("open", () => {
-    clearClientPing();
-    clientPingTimer = setInterval(() => {
-      if (ws.readyState === wrapper_default.OPEN) {
-        try {
-          ws.ping();
-        } catch {
-        }
-      }
-    }, FIREHOSE_CLIENT_PING_MS);
+    disposeClientPing();
+    clearClientPing = attachWebSocketClientPing(ws, CLI_WEBSOCKET_CLIENT_PING_MS);
     onOpen?.();
     devServerManager.attachFirehose(firehoseSend);
     sendWsMessage(ws, { type: "identify", workspaceId, bridgeName, proxyPorts });
@@ -31533,24 +31660,23 @@ function connectFirehose(options) {
     }
   });
   ws.on("close", (code, reason) => {
-    clearClientPing();
+    disposeClientPing();
     devServerManager.detachFirehose();
     const reasonStr = typeof reason === "string" ? reason : reason.toString();
     onClose?.(code, reasonStr);
   });
   ws.on("error", (err) => {
-    clearClientPing();
-    log2(`[Proxy and log service] WebSocket error: ${err.message}`);
+    disposeClientPing();
+    logCliWebSocketError(log2, "[Proxy and log service]", err);
+    if (ws.readyState === wrapper_default.CONNECTING || ws.readyState === wrapper_default.OPEN) {
+      safeCloseWebSocket(ws);
+    }
   });
   return {
     close() {
-      clearClientPing();
+      disposeClientPing();
       devServerManager.detachFirehose();
-      try {
-        ws.removeAllListeners();
-        ws.close();
-      } catch {
-      }
+      safeCloseWebSocket(ws);
     },
     isConnected: () => ws.readyState === wrapper_default.OPEN
   };
@@ -32729,7 +32855,6 @@ async function refreshBridgeTokens(params) {
 }
 
 // src/bridge/connection/main-bridge-ws-lifecycle.ts
-var BRIDGE_CLIENT_PING_MS = 25e3;
 function createMainBridgeWebSocketLifecycle(params) {
   const {
     state,
@@ -32787,6 +32912,11 @@ function createMainBridgeWebSocketLifecycle(params) {
     const prev = state.currentWs;
     if (prev) {
       prev.removeAllListeners();
+      prev.once("error", () => {
+      });
+      prev.once("close", () => {
+        prev.removeAllListeners();
+      });
       try {
         prev.close();
       } catch {
@@ -32796,7 +32926,7 @@ function createMainBridgeWebSocketLifecycle(params) {
     const url2 = buildBridgeUrl(apiUrl, workspaceId, tokens.accessToken);
     state.currentWs = createWsBridge({
       url: url2,
-      clientPingIntervalMs: BRIDGE_CLIENT_PING_MS,
+      clientPingIntervalMs: CLI_WEBSOCKET_CLIENT_PING_MS,
       onAuthInvalid: () => {
         if (authRefreshInFlight) return;
         void (async () => {
@@ -32832,7 +32962,7 @@ function createMainBridgeWebSocketLifecycle(params) {
       },
       onOpen: handleOpen,
       onClose: handleClose,
-      onError: (err) => logFn(`[Bridge service] WebSocket error: ${err.message}`),
+      onError: (err) => logCliWebSocketError(logFn, "[Bridge service]", err),
       onMessage: (data) => handleBridgeMessage(data, messageDeps)
     });
   }