@react-grab/codex 0.0.81 → 0.0.83

package/dist/client.js

@@ -1,27 +1,23 @@
-// src/constants.ts
-var DEFAULT_PORT = 7567;
+// ../utils/dist/client.js
 var CONNECTION_CHECK_TTL_MS = 5e3;
-
-// src/client.ts
-var DEFAULT_SERVER_URL = `http://localhost:${DEFAULT_PORT}`;
 var STORAGE_KEY = "react-grab:agent-sessions";
-var parseServerSentEvent = (eventStringBlock) => {
+var parseSSEEvent = (eventBlock) => {
   let eventType = "";
   let data = "";
-  for (const line of eventStringBlock.split("\n")) {
+  for (const line of eventBlock.split("\n")) {
     if (line.startsWith("event:")) eventType = line.slice(6).trim();
     else if (line.startsWith("data:")) data = line.slice(5).trim();
   }
   return { eventType, data };
 };
-var streamSSE = async function* (stream, signal) {
-  const streamReader = stream.getReader();
-  const textDecoder = new TextDecoder();
-  let textBuffer = "";
+async function* streamSSE(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
   let aborted = false;
   const onAbort = () => {
     aborted = true;
-    streamReader.cancel().catch(() => {
+    reader.cancel().catch(() => {
     });
   };
   signal.addEventListener("abort", onAbort);
@@ -30,18 +26,16 @@ var streamSSE = async function* (stream, signal) {
       throw new DOMException("Aborted", "AbortError");
     }
     while (true) {
-      const result = await streamReader.read();
+      const result = await reader.read();
       if (aborted || signal.aborted) {
         throw new DOMException("Aborted", "AbortError");
       }
       const { done, value } = result;
-      if (value) textBuffer += textDecoder.decode(value, { stream: true });
-      let boundaryIndex;
-      while ((boundaryIndex = textBuffer.indexOf("\n\n")) !== -1) {
-        const { eventType, data } = parseServerSentEvent(
-          textBuffer.slice(0, boundaryIndex)
-        );
-        textBuffer = textBuffer.slice(boundaryIndex + 2);
+      if (value) buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+        const { eventType, data } = parseSSEEvent(buffer.slice(0, boundary));
+        buffer = buffer.slice(boundary + 2);
         if (eventType === "done") return;
         if (eventType === "error") throw new Error(data || "Agent error");
         if (data) yield data;
@@ -51,12 +45,19 @@ var streamSSE = async function* (stream, signal) {
   } finally {
     signal.removeEventListener("abort", onAbort);
     try {
-      streamReader.releaseLock();
+      reader.releaseLock();
     } catch {
     }
   }
-};
+}
+
+// src/constants.ts
+var DEFAULT_PORT = 7567;
+
+// src/client.ts
+var DEFAULT_SERVER_URL = `http://localhost:${DEFAULT_PORT}`;
 var streamFromServer = async function* (serverUrl, context, signal) {
+  const startTime = Date.now();
   const sessionId = context.sessionId;
   const handleAbort = () => {
     if (sessionId) {
@@ -80,7 +81,37 @@ var streamFromServer = async function* (serverUrl, context, signal) {
     if (!response.body) {
       throw new Error("No response body");
     }
-    yield* streamSSE(response.body, signal);
+    const iterator = streamSSE(response.body, signal)[Symbol.asyncIterator]();
+    let done = false;
+    let pendingNext = iterator.next();
+    while (!done) {
+      const result = await Promise.race([
+        pendingNext.then((iteratorResult) => ({
+          type: "status",
+          iteratorResult
+        })),
+        new Promise(
+          (resolve) => setTimeout(() => resolve({ type: "timeout" }), 100)
+        )
+      ]);
+      if (result.type === "timeout") {
+        const elapsedSeconds = (Date.now() - startTime) / 1e3;
+        yield `Working\u2026 ${elapsedSeconds.toFixed(1)}s`;
+      } else {
+        const iteratorResult = result.iteratorResult;
+        done = iteratorResult.done ?? false;
+        if (!done && iteratorResult.value) {
+          const status = iteratorResult.value;
+          if (status === "Completed successfully") {
+            const totalSeconds = ((Date.now() - startTime) / 1e3).toFixed(1);
+            yield `Completed in ${totalSeconds}s`;
+          } else {
+            yield status;
+          }
+          pendingNext = iterator.next();
+        }
+      }
+    }
   } finally {
     signal.removeEventListener("abort", handleAbort);
   }