@evident-ai/cli 3.4.1-dev.6e623a8 → 3.4.1-dev.71ade33

package/dist/index.js

@@ -1138,6 +1138,37 @@ var TelemetryEventTypes = {
   RUNNER_ACTIVITY: "runner.activity"
 };
 
+// ../../packages/types/src/tunnel/binary-frame.ts
+var BINARY_FRAME_REQ_DATA = 1;
+var BINARY_FRAME_RES_DATA = 2;
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeBinaryBodyFrame(type, sid, payload) {
+  const sidBytes = textEncoder.encode(sid);
+  if (sidBytes.length === 0 || sidBytes.length > 255) {
+    throw new RangeError("sid must contain between 1 and 255 UTF-8 bytes");
+  }
+  const frame = new Uint8Array(2 + sidBytes.length + payload.length);
+  frame[0] = type;
+  frame[1] = sidBytes.length;
+  frame.set(sidBytes, 2);
+  frame.set(payload, 2 + sidBytes.length);
+  return frame;
+}
+function decodeBinaryBodyFrame(bytes) {
+  if (bytes.length < 2) return null;
+  const type = bytes[0];
+  if (type !== BINARY_FRAME_REQ_DATA && type !== BINARY_FRAME_RES_DATA) return null;
+  const sidLen = bytes[1];
+  if (sidLen === 0 || bytes.length < 2 + sidLen) return null;
+  const payloadOffset = 2 + sidLen;
+  return {
+    type,
+    sid: textDecoder.decode(bytes.subarray(2, payloadOffset)),
+    payload: bytes.subarray(payloadOffset)
+  };
+}
+
 // ../../packages/types/src/tunnel/index.ts
 var MAX_FRAME_BYTES = 256 * 1024;
 var TUNNEL_DRAIN_PING_PATH = "/__evident/drain";
@@ -1182,7 +1213,7 @@ import ora4 from "ora";
 import { select as select4 } from "@inquirer/prompts";
 
 // src/lib/telemetry.ts
-var CLI_VERSION = (true ? "3.4.1-dev.6e623a8" : void 0) ?? process.env.npm_package_version ?? "unknown";
+var CLI_VERSION = (true ? "3.4.1-dev.71ade33" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
   return CLI_VERSION;
 }
@@ -4720,6 +4751,7 @@ var StreamForwarder = class {
     this.options = options;
   }
   inflight = /* @__PURE__ */ new Map();
+  binaryFramesSupported = false;
   /**
    * Handle an edge→agent frame. Unknown frame types are ignored.
    */
@@ -4739,6 +4771,12 @@ var StreamForwarder = class {
         break;
     }
   }
+  handleBinaryBodyFrame(sid, payload) {
+    this.inflight.get(sid)?.pushBody?.(payload);
+  }
+  setBinaryFramesSupported(supported) {
+    this.binaryFramesSupported = supported;
+  }
   /**
    * Abort every in-flight stream (e.g. on WebSocket close).
    */
@@ -4856,7 +4894,13 @@ var StreamForwarder = class {
           const chunk = Buffer.from(value);
           for (let i = 0; i < chunk.length; i += MAX_FRAME_BYTES) {
             const slice = chunk.subarray(i, i + MAX_FRAME_BYTES);
-            this.send({ type: "res_data", sid, b64: slice.toString("base64") });
+            if (this.binaryFramesSupported) {
+              if (this.ws.readyState === WebSocket.OPEN) {
+                this.ws.send(encodeBinaryBodyFrame(BINARY_FRAME_RES_DATA, sid, slice));
+              }
+            } else {
+              this.send({ type: "res_data", sid, b64: slice.toString("base64") });
+            }
           }
         }
       }
@@ -4873,6 +4917,11 @@ var StreamForwarder = class {
 
 // src/lib/tunnel/connection.ts
 var FAILURE_REASON_HEADER_LC = FORWARD_FAILURE_REASON_HEADER.toLowerCase();
+function toUint8Array(data) {
+  if (Array.isArray(data)) return Buffer.concat(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return data;
+}
 var TunnelUpgradeRejectedError = class extends Error {
   constructor(message, reason) {
     super(message);
@@ -4937,7 +4986,8 @@ function connectTunnel(options) {
   return new Promise((resolve4, reject) => {
     const ws = new WebSocket2(url, {
       headers: {
-        Authorization: authHeader
+        Authorization: authHeader,
+        "X-Evident-Tunnel-Binary-Frames": "1"
       }
     });
     const forwarder = new StreamForwarder(
@@ -4986,7 +5036,25 @@ function connectTunnel(options) {
     ws.on("open", () => {
       onInfo?.("WebSocket connection established");
     });
-    ws.on("message", (data) => {
+    ws.on("message", (data, isBinary) => {
+      if (isBinary) {
+        try {
+          const frame = decodeBinaryBodyFrame(toUint8Array(data));
+          if (frame === null) {
+            onError?.("Failed to handle binary message: invalid frame");
+            return;
+          }
+          if (frame.type !== BINARY_FRAME_REQ_DATA) {
+            onError?.("Failed to handle binary message: unexpected frame type");
+            return;
+          }
+          forwarder.handleBinaryBodyFrame(frame.sid, frame.payload);
+        } catch (error2) {
+          const errorMessage3 = error2 instanceof Error ? error2.message : "Unknown error";
+          onError?.(`Failed to handle binary message: ${errorMessage3}`);
+        }
+        return;
+      }
       let message;
       try {
         message = JSON.parse(data.toString());
@@ -5002,6 +5070,7 @@ function connectTunnel(options) {
       switch (message.type) {
         case "connected": {
           clearTimeout(connectionTimeout);
+          forwarder.setBinaryFramesSupported(message.binary_frames === true);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
           resolve4({
@@ -6299,23 +6368,21 @@ var ChannelDriver = class _ChannelDriver {
    */
   readopted = /* @__PURE__ */ new Set();
   /**
-   * "Don't re-DISPATCH / re-attach this orphan again" (Bug 2/5). Set when a
-   * re-adopted running/orphan row's watcher hit its `processed_at`-anchored
-   * deadline (or an orphan whose window already elapsed): the still-`processing`
-   * server row would otherwise be re-adopted (and re-dispatched) on EVERY ~2s
-   * drain until the 15-min cron resets it — spamming new turns.
-   *
-   * CRITICAL (Bugbot #202): this suppresses ONLY the dispatch/re-attach paths, it
-   * does NOT suppress DONE delivery. A row parked here whose reply later COMPLETES
-   * in opencode must still be delivered via `markDone` on the next drain — so
-   * `readoptOne` computes `state` FIRST and this set is checked only on the
-   * non-done path. It is cleared once the row leaves both processing and pending
-   * lists, so it can never leak. A V2 prompt
-   * acknowledgement with no usable id also uses this fence: OpenCode accepted the
-   * turn, but there is no safe id to watch, so a failed `markFailed` report must not
-   * allow the pending row to post the prompt again.
+   * Readopt give-up fence. Set when recovery declines to start or continue a turn
+   * for a row that is still `processing`, so the next drain does not re-dispatch or
+   * re-attach it before the cron safety net acts. It suppresses only non-done
+   * recovery paths; DONE delivery still runs. Clear it when
+   * `!stillProcessing.has(id)`, because leaving `processing` hands the row back to
+   * normal processing.
    */
   dontRedispatch = /* @__PURE__ */ new Set();
+  /**
+   * Untrackable-ack fence. Set after OpenCode accepts a prompt without returning a
+   * usable message id, because another POST could create a duplicate turn. Keep it
+   * fenced while the row is `processing` or `pending`; clear it only when the row
+   * is absent from both lists.
+   */
+  untrackableAck = /* @__PURE__ */ new Set();
   /** Pending rows seen in the current drain, used to retain terminal dispatch fences. */
   pendingMessageIds = /* @__PURE__ */ new Set();
   /**
@@ -6900,7 +6967,7 @@ var ChannelDriver = class _ChannelDriver {
         skippedAlreadyDispatched += 1;
         continue;
       }
-      if (this.dontRedispatch.has(message.id)) {
+      if (this.untrackableAck.has(message.id)) {
         this.log({
           level: "warn",
           message: `Message ${message.id.slice(0, 8)} is fenced after an untrackable OpenCode turn \u2014 skipping re-dispatch`,
@@ -6966,7 +7033,7 @@ var ChannelDriver = class _ChannelDriver {
         if (err instanceof ChannelAuthError) throw err;
         if (this.isV2 && err instanceof OpenCodeV2PromptAckError) {
           const errorMessage4 = err instanceof Error ? err.message : String(err);
-          this.dontRedispatch.add(message.id);
+          this.untrackableAck.add(message.id);
           this.log({
             level: "error",
             message: `V2 prompt dispatch for message ${message.id.slice(0, 8)} failed after a positive ack with no usable id: ${errorMessage4}`,
@@ -8887,14 +8954,14 @@ var ChannelDriver = class _ChannelDriver {
    */
   async readoptProcessing() {
     const rows = await this.getProcessingMessages();
-    if (this.dontRedispatch.size > 0 || this.doneUndeliverable.size > 0 || this.readoptPollUnresolvedSignalled.size > 0) {
+    if (this.dontRedispatch.size > 0 || this.untrackableAck.size > 0 || this.doneUndeliverable.size > 0 || this.readoptPollUnresolvedSignalled.size > 0) {
       const stillProcessing = new Set(rows.map((r) => r.id));
       for (const id of [
         ...this.dontRedispatch,
         ...this.doneUndeliverable,
         ...this.readoptPollUnresolvedSignalled
       ]) {
-        if (!stillProcessing.has(id) && !this.pendingMessageIds.has(id)) {
+        if (!stillProcessing.has(id)) {
           const cleared = this.dontRedispatch.delete(id);
           const clearedUndeliverable = this.doneUndeliverable.delete(id);
           this.readoptPollUnresolvedSignalled.delete(id);
@@ -8907,6 +8974,16 @@ var ChannelDriver = class _ChannelDriver {
           }
         }
       }
+      for (const id of [...this.untrackableAck]) {
+        if (!stillProcessing.has(id) && !this.pendingMessageIds.has(id)) {
+          this.untrackableAck.delete(id);
+          this.log({
+            level: "debug",
+            message: `Re-adopt: message ${id.slice(0, 8)} left processing and pending \u2014 cleared untrackable-ack fence`,
+            message_id: id
+          });
+        }
+      }
     }
     if (rows.length === 0) return;
     const bySession = /* @__PURE__ */ new Map();
@@ -9063,10 +9140,11 @@ var ChannelDriver = class _ChannelDriver {
       }
       await this.reportSubagentAuthFailures(row.conversation_id, ocId ?? "", row.id, messages);
       this.dontRedispatch.delete(row.id);
+      this.untrackableAck.delete(row.id);
       void this.postSignal(row.conversation_id, row.id, "readopt_failed");
       return;
     }
-    if (this.dontRedispatch.has(row.id)) {
+    if (this.dontRedispatch.has(row.id) || this.untrackableAck.has(row.id)) {
       this.log({
         level: "debug",
         message: `Re-adopt: message ${row.id.slice(0, 8)} already gave up \u2014 left to the cron; skipping until it leaves processing`,
@@ -9175,7 +9253,7 @@ var ChannelDriver = class _ChannelDriver {
    * extracted (#1493 Task 2.4) so the ambiguous-finish guard above can call the
    * SAME delivery instead of duplicating it.
    *
-   * EVEN IF the row was previously parked in `dontRedispatch` (a give-up stops
+   * EVEN IF the row was previously parked by either recovery fence (a give-up stops
    * re-dispatch, not delivery — Bugbot #202). Guarded EXACTLY like the watcher's
    * `settleMessageDone`: auth re-throws; terminal → park in `doneUndeliverable` +
    * leave for cron; transient → log + leave for the next drain (the still-
@@ -9242,6 +9320,7 @@ var ChannelDriver = class _ChannelDriver {
       await this.reportSubagentAuthFailures(row.conversation_id, ocId, row.id, messages);
     }
     this.dontRedispatch.delete(row.id);
+    this.untrackableAck.delete(row.id);
     void this.postSignal(row.conversation_id, row.id, "readopt_done");
   }
   /**
@@ -9364,7 +9443,7 @@ var ChannelDriver = class _ChannelDriver {
             return;
           }
         } else {
-          this.dontRedispatch.add(row.id);
+          this.untrackableAck.add(row.id);
         }
         this.log({
           level: "error",
@@ -9399,17 +9478,6 @@ var ChannelDriver = class _ChannelDriver {
       return;
     }
     if (ocId === null) {
-      if (this.isV2) {
-        this.dontRedispatch.add(row.id);
-        this.log({
-          level: "error",
-          message: `V2 re-adopt dispatch for message ${row.id.slice(0, 8)} completed without an acknowledged message id`,
-          conversation_id: row.conversation_id,
-          message_id: row.id
-        });
-        void this.postSignal(row.conversation_id, row.id, "ack_untrackable");
-        return;
-      }
       this.awaitingReadopt.delete(row.id);
       const streak = this.recordUnconfirmedDispatch(row.id, sessionId);
       if (streak >= MAX_IDENTICAL_REDRIVE_POLL_FAILURES) {