@ai-sdk/harness-claude-code 1.0.68 → 1.0.70

package/dist/index.js

@@ -22,6 +22,7 @@ import {
   writeSkills as writeHarnessSkills
 } from "@ai-sdk/harness/utils";
 import {
+  safeParseJSON,
   tool
 } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
@@ -151,7 +152,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 ]);
 
 // src/version.ts
-var VERSION = true ? "1.0.68" : "0.0.0-test";
+var VERSION = true ? "1.0.70" : "0.0.0-test";
 
 // src/claude-code-harness.ts
 var CLAUDE_CODE_CLIENT_APP = `ai-sdk/harness-claude-code/${VERSION}`;
@@ -1045,32 +1046,77 @@ async function readBridgeAsset(name) {
   }
   throw lastErr ?? new Error(`bridge asset not found: ${name}`);
 }
-async function waitForBridgeHello({
-  ws,
-  timeoutMs
+function openWebSocketAndWaitForBridgeHello({
+  url,
+  openTimeoutMs,
+  getHelloTimeoutMs
 }) {
-  await new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    let opened = false;
+    let sawBridgeHello = false;
     let settled = false;
+    let openTimer;
+    let helloTimer;
     const cleanup = () => {
+      if (openTimer) clearTimeout(openTimer);
+      if (helloTimer) clearTimeout(helloTimer);
+      ws.off("open", onOpen);
       ws.off("message", onMessage);
       ws.off("close", onClose);
       ws.off("error", onError);
-      if (timer) clearTimeout(timer);
     };
     const settle = (err) => {
       if (settled) return;
       settled = true;
       cleanup();
-      if (err) reject(err);
-      else resolve();
+      if (err) {
+        try {
+          ws.terminate();
+        } catch {
+        }
+        reject(err);
+      } else {
+        resolve(ws);
+      }
     };
-    const onMessage = (raw) => {
-      try {
-        const text = typeof raw === "string" ? raw : raw.toString ? raw.toString("utf8") : String(raw);
-        const parsed = JSON.parse(text);
-        if (parsed?.type === "bridge-hello") settle();
-      } catch {
+    const tryResolve = () => {
+      if (opened && sawBridgeHello) settle();
+    };
+    const startHelloTimer = () => {
+      if (helloTimer) return;
+      const helloTimeoutMs = getHelloTimeoutMs();
+      helloTimer = setTimeout(
+        () => settle(
+          new Error(
+            `claude-code bridge did not send bridge-hello within ${helloTimeoutMs}ms`
+          )
+        ),
+        helloTimeoutMs
+      );
+      helloTimer.unref?.();
+    };
+    const onOpen = () => {
+      opened = true;
+      if (openTimer) {
+        clearTimeout(openTimer);
+        openTimer = void 0;
       }
+      startHelloTimer();
+      tryResolve();
+    };
+    const onMessage = (raw) => {
+      void (async () => {
+        const parsed = await safeParseJSON({
+          text: webSocketMessageToString(raw)
+        });
+        if (!parsed.success || settled) return;
+        const value = parsed.value;
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "bridge-hello") {
+          sawBridgeHello = true;
+          tryResolve();
+        }
+      })();
     };
     const onClose = () => {
       settle(
@@ -1078,15 +1124,12 @@ async function waitForBridgeHello({
       );
     };
     const onError = (err) => settle(err);
-    const timer = setTimeout(
-      () => settle(
-        new Error(
-          `claude-code bridge did not send bridge-hello within ${timeoutMs}ms`
-        )
-      ),
-      timeoutMs
+    openTimer = setTimeout(
+      () => settle(new Error(`WebSocket open timed out after ${openTimeoutMs}ms`)),
+      openTimeoutMs
     );
-    timer.unref?.();
+    openTimer.unref?.();
+    ws.on("open", onOpen);
     ws.on("message", onMessage);
     ws.on("close", onClose);
     ws.on("error", onError);
@@ -1101,24 +1144,15 @@ async function openBridgeWebSocket({
   let lastError;
   while (Date.now() < deadline) {
     attempt++;
-    let ws;
     try {
       const remaining = Math.max(1, deadline - Date.now());
-      ws = await openWebSocket({
+      return await openWebSocketAndWaitForBridgeHello({
         url: wsUrl,
-        timeoutMs: Math.min(1e4, remaining)
-      });
-      await waitForBridgeHello({
-        ws,
-        timeoutMs: Math.min(5e3, Math.max(1, deadline - Date.now()))
+        openTimeoutMs: Math.min(1e4, remaining),
+        getHelloTimeoutMs: () => Math.min(5e3, Math.max(1, deadline - Date.now()))
       });
-      return ws;
     } catch (err) {
       lastError = err;
-      try {
-        ws?.close();
-      } catch {
-      }
       const remaining = deadline - Date.now();
       if (remaining <= 0) break;
       await sleep(Math.min(250 * attempt, 1e3, remaining));
@@ -1128,37 +1162,17 @@ async function openBridgeWebSocket({
     `claude-code bridge did not complete WebSocket handshake within ${timeoutMs}ms after ${attempt} attempt(s). Last error: ${formatUnknownError(lastError)}`
   );
 }
-function openWebSocket({
-  url,
-  timeoutMs
-}) {
-  return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url);
-    const timer = setTimeout(() => {
-      cleanup();
-      try {
-        ws.terminate();
-      } catch {
-      }
-      reject(new Error(`WebSocket open timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    timer.unref?.();
-    const cleanup = () => {
-      clearTimeout(timer);
-      ws.off("open", onOpen);
-      ws.off("error", onError);
-    };
-    const onOpen = () => {
-      cleanup();
-      resolve(ws);
-    };
-    const onError = (err) => {
-      cleanup();
-      reject(err);
-    };
-    ws.once("open", onOpen);
-    ws.once("error", onError);
-  });
+function webSocketMessageToString(raw) {
+  if (typeof raw === "string") return raw;
+  if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+  if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
+  if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
+  if (ArrayBuffer.isView(raw)) {
+    return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString(
+      "utf8"
+    );
+  }
+  return String(raw);
 }
 function sleep(ms) {
   return new Promise((resolve) => {