@buildautomaton/cli 0.1.10 → 0.1.11

package/dist/index.js

@@ -22072,6 +22072,26 @@ 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://")) {
@@ -22100,6 +22120,15 @@ function safeCloseWebSocket(ws) {
     }
   }
 }
+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";
@@ -22108,12 +22137,10 @@ function createWsBridge(options) {
   const { url: url2, onMessage, onOpen, onClose, onError: onError2, onAuthInvalid, clientPingIntervalMs } = options;
   applyCliOutboundNetworkPreferences();
   const ws = new wrapper_default(url2, buildCliWebSocketClientOptions(url2));
-  let clientPingTimer = null;
-  function clearClientPing() {
-    if (clientPingTimer != null) {
-      clearInterval(clientPingTimer);
-      clientPingTimer = null;
-    }
+  let clearClientPing = null;
+  function disposeClientPing() {
+    clearClientPing?.();
+    clearClientPing = null;
   }
   ws.on("unexpected-response", (request, response) => {
     const status = response?.statusCode ?? 0;
@@ -22124,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?.();
   });
@@ -22154,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;
@@ -22844,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 {
@@ -22877,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);
@@ -22925,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;
@@ -31404,6 +31485,9 @@ var DevServerManager = class {
 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";
@@ -31416,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) => {
@@ -31534,18 +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 ws = new wrapper_default(wsUrl, buildCliWebSocketClientOptions(wsUrl));
-  let clientPingTimer = null;
-  function clearClientPing() {
-    if (clientPingTimer != null) {
-      clearInterval(clientPingTimer);
-      clientPingTimer = null;
-    }
+  let clearClientPing = null;
+  function disposeClientPing() {
+    clearClientPing?.();
+    clearClientPing = null;
   }
   const firehoseSend = (payload) => {
     sendWsMessage(ws, payload);
@@ -31559,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 });
@@ -31583,18 +31660,21 @@ 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();
+    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();
       safeCloseWebSocket(ws);
     },
@@ -32775,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,
@@ -32847,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 () => {