@qwen-code/qwen-code 0.21.9 → 0.21.10-nightly.20260812.a64d1291d2

package/chunks/{chunk-HZGBKOX3.js → chunk-EE6LY6EF.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-UJUM2SRN.js";
+} from "./chunk-3MJEGPUL.js";
 import {
   parseAndFormatApiError
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-NX2E4GYA.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay

package/chunks/{chunk-I5VM3SKY.js → chunk-EV3LZGGK.js}

@@ -25,31 +25,69 @@ import { getHeapStatistics } from "node:v8";
 
 // packages/acp-bridge/src/ndJsonStream.ts
 init_esbuild_shims();
-function ndJsonStream(output, input, hooks) {
+import { createHash } from "node:crypto";
+var NdJsonFrameTooLargeError = class extends Error {
+  constructor(direction, limitBytes, observedBytes) {
+    super(
+      `NDJSON ${direction} frame exceeds ${limitBytes} bytes (observed ${observedBytes} bytes)`
+    );
+    this.direction = direction;
+    this.limitBytes = limitBytes;
+    this.observedBytes = observedBytes;
+    this.name = "NdJsonFrameTooLargeError";
+  }
+  static {
+    __name(this, "NdJsonFrameTooLargeError");
+  }
+  code = "ndjson_frame_too_large";
+};
+var NdJsonQueueLimitError = class extends Error {
+  constructor(maxQueuedMessages, maxQueuedBytes, requiredBytes, availableBytes) {
+    super(
+      `NDJSON decoded queue is full (required ${requiredBytes} bytes, available ${availableBytes} bytes)`
+    );
+    this.maxQueuedMessages = maxQueuedMessages;
+    this.maxQueuedBytes = maxQueuedBytes;
+    this.requiredBytes = requiredBytes;
+    this.availableBytes = availableBytes;
+    this.name = "NdJsonQueueLimitError";
+  }
+  static {
+    __name(this, "NdJsonQueueLimitError");
+  }
+  code = "ndjson_queue_limit_exceeded";
+};
+var NdJsonIncompleteFrameError = class extends Error {
+  constructor(observedBytes) {
+    super(`NDJSON input ended with an incomplete ${observedBytes}-byte frame`);
+    this.observedBytes = observedBytes;
+    this.name = "NdJsonIncompleteFrameError";
+  }
+  static {
+    __name(this, "NdJsonIncompleteFrameError");
+  }
+  code = "ndjson_incomplete_frame";
+};
+function ndJsonStream(output, input, hooks, limits) {
   const textEncoder = new TextEncoder();
   const textDecoder = new TextDecoder();
-  const readable = new ReadableStream({
-    async start(controller) {
-      const pending = [];
-      const reader = input.getReader();
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (!value) continue;
-          readChunk(value, pending, controller, textDecoder, hooks);
-        }
-      } finally {
-        reader.releaseLock();
-        controller.close();
-      }
-    }
-  });
+  if (limits) validateNdJsonStreamLimits(limits);
+  const readable = limits ? createBoundedReadable(input, textDecoder, hooks, limits) : createLegacyReadable(input, textDecoder, hooks);
   const writable = new WritableStream({
     async write(message) {
       const content = JSON.stringify(message);
       const payload = textEncoder.encode(content);
-      const frame = new Uint8Array(payload.byteLength + 1);
+      const frameBytes = payload.byteLength + 1;
+      if (limits && frameBytes > limits.maxFrameBytes) {
+        const error = new NdJsonFrameTooLargeError(
+          "sent",
+          limits.maxFrameBytes,
+          frameBytes
+        );
+        callHook(hooks?.onTransportError, error);
+        throw error;
+      }
+      const frame = new Uint8Array(frameBytes);
       frame.set(payload);
       frame[payload.byteLength] = 10;
       const writer = output.getWriter();
@@ -61,6 +99,9 @@ function ndJsonStream(output, input, hooks) {
           bytes: payload.byteLength,
           message
         });
+      } catch (error) {
+        if (limits) callHook(hooks?.onTransportError, error);
+        throw error;
       } finally {
         writer.releaseLock();
       }
@@ -69,12 +110,110 @@ function ndJsonStream(output, input, hooks) {
   return { readable, writable };
 }
 __name(ndJsonStream, "ndJsonStream");
-function readChunk(chunk, pending, controller, textDecoder, hooks) {
+function createLegacyReadable(input, textDecoder, hooks) {
+  return new ReadableStream({
+    async start(controller) {
+      const pending = [];
+      const reader = input.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (!value) continue;
+          readLegacyChunk(value, pending, controller, textDecoder, hooks);
+        }
+      } finally {
+        reader.releaseLock();
+        controller.close();
+      }
+    }
+  });
+}
+__name(createLegacyReadable, "createLegacyReadable");
+function createBoundedReadable(input, textDecoder, hooks, limits) {
+  const pending = new BoundedFrameBuffer(limits.maxFrameBytes);
+  const minimumQueueCharge = Math.ceil(
+    limits.maxQueuedBytes / limits.maxQueuedMessages
+  );
+  let nextQueueCharge = minimumQueueCharge;
+  let reader;
+  let canceled = false;
+  return new ReadableStream(
+    {
+      start(controller) {
+        reader = input.getReader();
+        void pumpBoundedInput(
+          reader,
+          pending,
+          controller,
+          textDecoder,
+          hooks,
+          limits,
+          minimumQueueCharge,
+          (charge) => {
+            nextQueueCharge = charge;
+          },
+          () => canceled
+        );
+      },
+      async cancel(reason) {
+        canceled = true;
+        pending.clear();
+        if (reader) await cancelReader(reader, reason);
+      }
+    },
+    {
+      highWaterMark: limits.maxQueuedBytes,
+      size: /* @__PURE__ */ __name(() => nextQueueCharge, "size")
+    }
+  );
+}
+__name(createBoundedReadable, "createBoundedReadable");
+async function pumpBoundedInput(reader, pending, controller, textDecoder, hooks, limits, minimumQueueCharge, setNextQueueCharge, isCanceled) {
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) {
+        if (isCanceled()) return;
+        if (pending.byteLength > 0) {
+          throw new NdJsonIncompleteFrameError(pending.byteLength);
+        }
+        controller.close();
+        return;
+      }
+      if (!result.value) continue;
+      readBoundedChunk(
+        result.value,
+        pending,
+        controller,
+        textDecoder,
+        hooks,
+        limits,
+        minimumQueueCharge,
+        setNextQueueCharge
+      );
+    }
+  } catch (error) {
+    if (isCanceled()) return;
+    pending.clear();
+    callHook(hooks?.onTransportError, error);
+    await cancelReader(reader, error);
+    if (!isCanceled()) controller.close();
+  } finally {
+    pending.clear();
+    reader.releaseLock();
+  }
+}
+__name(pumpBoundedInput, "pumpBoundedInput");
+function readLegacyChunk(chunk, pending, controller, textDecoder, hooks) {
   let start = 0;
   let newline = chunk.indexOf(10, start);
   while (newline !== -1) {
-    const lineBytes = takeLineBytes(pending, chunk.subarray(start, newline));
-    handleLine(lineBytes, controller, textDecoder, hooks);
+    const lineBytes = takeLegacyLineBytes(
+      pending,
+      chunk.subarray(start, newline)
+    );
+    handleLegacyLine(lineBytes, controller, textDecoder, hooks);
     start = newline + 1;
     newline = chunk.indexOf(10, start);
   }
@@ -82,8 +221,39 @@ function readChunk(chunk, pending, controller, textDecoder, hooks) {
     pending.push(chunk.subarray(start));
   }
 }
-__name(readChunk, "readChunk");
-function takeLineBytes(pending, current) {
+__name(readLegacyChunk, "readLegacyChunk");
+function readBoundedChunk(chunk, pending, controller, textDecoder, hooks, limits, minimumQueueCharge, setNextQueueCharge) {
+  let start = 0;
+  let newline = chunk.indexOf(10, start);
+  while (newline !== -1) {
+    const current = chunk.subarray(start, newline);
+    const frameBytes = pending.byteLength + current.byteLength + 1;
+    assertFrameSize("received", limits.maxFrameBytes, frameBytes);
+    if (pending.isJsonWhitespaceLine(current)) {
+      pending.clear();
+      start = newline + 1;
+      newline = chunk.indexOf(10, start);
+      continue;
+    }
+    const queueCharge = Math.max(frameBytes, minimumQueueCharge);
+    const availableBytes = controller.desiredSize;
+    if (availableBytes === null || queueCharge > availableBytes) {
+      throw new NdJsonQueueLimitError(
+        limits.maxQueuedMessages,
+        limits.maxQueuedBytes,
+        queueCharge,
+        Math.max(0, availableBytes ?? 0)
+      );
+    }
+    setNextQueueCharge(queueCharge);
+    handleBoundedLine(pending.take(current), controller, textDecoder, hooks);
+    start = newline + 1;
+    newline = chunk.indexOf(10, start);
+  }
+  if (start < chunk.length) pending.append(chunk.subarray(start));
+}
+__name(readBoundedChunk, "readBoundedChunk");
+function takeLegacyLineBytes(pending, current) {
   if (pending.length === 0) return current;
   const totalLength = pending.reduce((sum, part) => sum + part.byteLength, 0) + current.byteLength;
   const line = new Uint8Array(totalLength);
@@ -96,30 +266,82 @@ function takeLineBytes(pending, current) {
   pending.length = 0;
   return line;
 }
-__name(takeLineBytes, "takeLineBytes");
-function handleLine(lineBytes, controller, textDecoder, hooks) {
+__name(takeLegacyLineBytes, "takeLegacyLineBytes");
+function handleLegacyLine(lineBytes, controller, textDecoder, hooks) {
   const line = textDecoder.decode(lineBytes);
   const trimmedLine = line.trim();
   if (!trimmedLine) return;
   try {
     const message = JSON.parse(trimmedLine);
     controller.enqueue(message);
+    reportReceivedMessage(lineBytes, message, hooks);
+  } catch (err) {
+    console.error("Failed to parse JSON message:", trimmedLine, err);
+  }
+}
+__name(handleLegacyLine, "handleLegacyLine");
+function handleBoundedLine(lineBytes, controller, textDecoder, hooks) {
+  const line = textDecoder.decode(lineBytes);
+  const trimmedLine = line.trim();
+  if (!trimmedLine) return;
+  let message;
+  try {
+    message = JSON.parse(trimmedLine);
+  } catch {
     const bytes = jsonPayloadByteLength(lineBytes);
-    callHook(hooks?.onMessageReceived, bytes);
-    callHook(hooks?.onMessageObserved, {
-      direction: "received",
+    const digest = createHash("sha256").update(lineBytes.subarray(0, bytes)).digest("hex");
+    console.error("Failed to parse JSON message:", {
+      errorKind: "ndjson_parse_error",
       bytes,
-      message
+      sha256: digest,
+      payloadOmitted: true
     });
-  } catch (err) {
-    console.error("Failed to parse JSON message:", trimmedLine, err);
+    return;
   }
+  controller.enqueue(message);
+  reportReceivedMessage(lineBytes, message, hooks);
+}
+__name(handleBoundedLine, "handleBoundedLine");
+function reportReceivedMessage(lineBytes, message, hooks) {
+  const bytes = jsonPayloadByteLength(lineBytes);
+  callHook(hooks?.onMessageReceived, bytes);
+  callHook(hooks?.onMessageObserved, {
+    direction: "received",
+    bytes,
+    message
+  });
 }
-__name(handleLine, "handleLine");
+__name(reportReceivedMessage, "reportReceivedMessage");
 function jsonPayloadByteLength(lineBytes) {
   return lineBytes[lineBytes.byteLength - 1] === 13 ? lineBytes.byteLength - 1 : lineBytes.byteLength;
 }
 __name(jsonPayloadByteLength, "jsonPayloadByteLength");
+function validateNdJsonStreamLimits(limits) {
+  const values = [
+    ["maxFrameBytes", limits.maxFrameBytes],
+    ["maxQueuedMessages", limits.maxQueuedMessages],
+    ["maxQueuedBytes", limits.maxQueuedBytes]
+  ];
+  for (const [name, value] of values) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new RangeError(`${name} must be a positive safe integer`);
+    }
+  }
+}
+__name(validateNdJsonStreamLimits, "validateNdJsonStreamLimits");
+function assertFrameSize(direction, limitBytes, observedBytes) {
+  if (observedBytes > limitBytes) {
+    throw new NdJsonFrameTooLargeError(direction, limitBytes, observedBytes);
+  }
+}
+__name(assertFrameSize, "assertFrameSize");
+async function cancelReader(reader, reason) {
+  try {
+    await reader.cancel(reason);
+  } catch {
+  }
+}
+__name(cancelReader, "cancelReader");
 function callHook(hook, value) {
   try {
     hook?.(value);
@@ -127,6 +349,62 @@ function callHook(hook, value) {
   }
 }
 __name(callHook, "callHook");
+var BoundedFrameBuffer = class {
+  constructor(maxFrameBytes) {
+    this.maxFrameBytes = maxFrameBytes;
+  }
+  static {
+    __name(this, "BoundedFrameBuffer");
+  }
+  buffer;
+  length = 0;
+  get byteLength() {
+    return this.length;
+  }
+  append(bytes) {
+    const requiredBytes = this.length + bytes.byteLength;
+    assertFrameSize("received", this.maxFrameBytes, requiredBytes);
+    if (requiredBytes === 0) return;
+    if (!this.buffer || this.buffer.byteLength < requiredBytes) {
+      const doubledCapacity = Math.min(
+        this.maxFrameBytes,
+        Math.max(1024, (this.buffer?.byteLength ?? 0) * 2)
+      );
+      const next = new Uint8Array(Math.max(requiredBytes, doubledCapacity));
+      if (this.buffer) next.set(this.buffer.subarray(0, this.length));
+      this.buffer = next;
+    }
+    this.buffer.set(bytes, this.length);
+    this.length = requiredBytes;
+  }
+  take(current) {
+    if (this.length === 0) return current;
+    const line = new Uint8Array(this.length + current.byteLength);
+    line.set(this.buffer.subarray(0, this.length));
+    line.set(current, this.length);
+    this.clear();
+    return line;
+  }
+  isJsonWhitespaceLine(current) {
+    if (this.buffer) {
+      for (let index = 0; index < this.length; index++) {
+        if (!isJsonWhitespaceByte(this.buffer[index])) return false;
+      }
+    }
+    for (const byte of current) {
+      if (!isJsonWhitespaceByte(byte)) return false;
+    }
+    return true;
+  }
+  clear() {
+    this.buffer = void 0;
+    this.length = 0;
+  }
+};
+function isJsonWhitespaceByte(byte) {
+  return byte === 32 || byte === 9 || byte === 13;
+}
+__name(isJsonWhitespaceByte, "isJsonWhitespaceByte");
 
 // packages/acp-bridge/src/process-registry.ts
 init_esbuild_shims();
@@ -283,6 +561,11 @@ var TrackedChild = class {
 
 // packages/acp-bridge/src/spawnChannel.ts
 var cachedMemoryArgs;
+var DAEMON_ACP_NDJSON_LIMITS = Object.freeze({
+  maxFrameBytes: 64 * 1024 * 1024,
+  maxQueuedMessages: 256,
+  maxQueuedBytes: 64 * 1024 * 1024
+});
 function getAcpMemoryArgs() {
   if (cachedMemoryArgs) return cachedMemoryArgs;
   const constrainedMemory = process.constrainedMemory;
@@ -334,6 +617,7 @@ function createStderrForwarder(opts) {
 }
 __name(createStderrForwarder, "createStderrForwarder");
 function createSpawnChannelFactory(options = {}) {
+  if (options.pipeLimits) validateNdJsonStreamLimits(options.pipeLimits);
   const processRegistry = options.processRegistry ?? new ProcessRegistry();
   return async (workspaceCwd, childEnvOverrides) => {
     const sourceEnv = options.sourceEnv ?? process.env;
@@ -396,7 +680,20 @@ function createSpawnChannelFactory(options = {}) {
     }
     const writable = Writable.toWeb(child.stdin);
     const readable = Readable.toWeb(child.stdout);
-    const stream = ndJsonStream(writable, readable, options.pipeHooks);
+    const pipeHooks = options.pipeLimits ? {
+      ...options.pipeHooks,
+      onTransportError: /* @__PURE__ */ __name((error) => {
+        void trackedChild.terminate().catch(() => {
+        });
+        options.pipeHooks?.onTransportError?.(error);
+      }, "onTransportError")
+    } : options.pipeHooks;
+    const stream = ndJsonStream(
+      writable,
+      readable,
+      pipeHooks,
+      options.pipeLimits
+    );
     return {
       stream,
       kill: /* @__PURE__ */ __name(() => trackedChild.terminate(), "kill"),
@@ -433,6 +730,7 @@ __name(scrubChildEnv, "scrubChildEnv");
 
 export {
   ndJsonStream,
+  DAEMON_ACP_NDJSON_LIMITS,
   getAcpMemoryArgs,
   createStderrForwarder,
   createSpawnChannelFactory,