@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/{chunk-SQFXI7VK.js → chunk-LQIW3YFY.js}

@@ -15,27 +15,27 @@ import {
   MODIFIER_CTRL_BIT,
   MODIFIER_SHIFT_BIT,
   clipboardHasImage
-} from "./chunk-4LVZNIDO.js";
-import {
-  noteInteraction
-} from "./chunk-KW7NOTN6.js";
+} from "./chunk-J56UI34H.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
 import {
   use_stdin_default,
   use_stdout_default
-} from "./chunk-FFFM6NJV.js";
+} from "./chunk-6GMVPFB2.js";
+import {
+  noteInteraction
+} from "./chunk-KW7NOTN6.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-ZDP2Y2AL.js";
+} from "./chunk-CIKQ7KKO.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -241,6 +241,10 @@ function KeypressProvider({
   const { stdin, setRawMode } = use_stdin_default();
   const subscribers = (0, import_react2.useRef)(/* @__PURE__ */ new Set()).current;
   const mouseSubscribers = (0, import_react2.useRef)(/* @__PURE__ */ new Set()).current;
+  const [pasteProgress, setPasteProgress] = (0, import_react2.useState)({
+    active: false,
+    receivedBytes: 0
+  });
   const subscribe = (0, import_react2.useCallback)(
     (handler) => {
       subscribers.add(handler);
@@ -274,9 +278,10 @@ function KeypressProvider({
       usePassthrough = true;
     }
     let isPaste = false;
-    let pasteBuffer = Buffer.alloc(0);
+    let pasteChunks = [];
     let pasteAlreadyFlushed = false;
     let pasteIdleTimeout = null;
+    let lastPasteChunkAt = 0;
     const kittySequenceBufferRef = { current: "" };
     let kittySequenceTimeout = null;
     let backslashTimeout = null;
@@ -346,10 +351,10 @@ function KeypressProvider({
     }, "clearPasteIdleTimeout");
     const forceFlushStuckPaste = /* @__PURE__ */ __name(() => {
       clearPasteIdleTimeout();
-      if (!isPaste && pasteBuffer.length === 0) return;
-      const buffered = pasteBuffer.toString();
+      if (!isPaste && pasteChunks.length === 0) return;
+      const buffered = pasteChunks.join("");
       isPaste = false;
-      pasteBuffer = Buffer.alloc(0);
+      pasteChunks = [];
       pasteAlreadyFlushed = true;
       if (buffered.length > 0) {
         broadcast({
@@ -362,12 +367,21 @@ function KeypressProvider({
         });
       }
     }, "forceFlushStuckPaste");
+    const onPasteIdleTimeout = /* @__PURE__ */ __name(() => {
+      const idleFor = Date.now() - lastPasteChunkAt;
+      if (idleFor >= PASTE_IDLE_TIMEOUT_MS) {
+        forceFlushStuckPaste();
+      } else {
+        pasteIdleTimeout = setTimeout(
+          onPasteIdleTimeout,
+          PASTE_IDLE_TIMEOUT_MS - idleFor
+        );
+      }
+    }, "onPasteIdleTimeout");
     const startPasteIdleTimeout = /* @__PURE__ */ __name(() => {
-      clearPasteIdleTimeout();
-      pasteIdleTimeout = setTimeout(
-        forceFlushStuckPaste,
-        PASTE_IDLE_TIMEOUT_MS
-      );
+      lastPasteChunkAt = Date.now();
+      if (pasteIdleTimeout) return;
+      pasteIdleTimeout = setTimeout(onPasteIdleTimeout, PASTE_IDLE_TIMEOUT_MS);
     }, "startPasteIdleTimeout");
     const createPrintableKey = /* @__PURE__ */ __name((char) => {
       const printableName = char === " " ? "space" : /^[A-Za-z]$/.test(char) ? char.toLowerCase() : char;
@@ -462,11 +476,11 @@ function KeypressProvider({
         };
       }
       const csiUPrefix = new RegExp(
-        `^${ESC2}\\[(\\d+)(?::\\d+)*(?:;(\\d+)(?::\\d+)*)?(?:;\\d+)?([u~])`
+        `^${ESC2}\\[(\\d+)(?::\\d+)*(?:;(\\d+)(?::\\d+)*)?(?:;(\\d+))?([u~])`
       );
       m = buffer.match(csiUPrefix);
       if (m) {
-        const keyCode = parseInt(m[1], 10);
+        let keyCode = parseInt(m[1], 10);
         let modifiers = m[2] ? parseInt(m[2], 10) : KITTY_MODIFIER_BASE;
         if (modifiers >= KITTY_MODIFIER_EVENT_TYPES_OFFSET) {
           modifiers -= KITTY_MODIFIER_EVENT_TYPES_OFFSET;
@@ -475,7 +489,10 @@ function KeypressProvider({
         const shift = (modifierBits & MODIFIER_SHIFT_BIT) === MODIFIER_SHIFT_BIT;
         const alt = (modifierBits & MODIFIER_ALT_BIT) === MODIFIER_ALT_BIT;
         const ctrl = (modifierBits & MODIFIER_CTRL_BIT) === MODIFIER_CTRL_BIT;
-        const terminator = m[3];
+        const terminator = m[4];
+        if (keyCode === CHAR_CODE_ESC && terminator === "~" && m[3]) {
+          keyCode = parseInt(m[3], 10);
+        }
         if (terminator === "~") {
           let name2 = null;
           switch (keyCode) {
@@ -708,9 +725,9 @@ function KeypressProvider({
       }
       const isCtrlCKey = key.ctrl && key.name === "c" || key.sequence === `${ESC2}${KITTY_CTRL_C}`;
       if (isCtrlCKey) {
-        if (isPaste || pasteBuffer.length > 0) {
+        if (isPaste || pasteChunks.length > 0) {
           isPaste = false;
-          pasteBuffer = Buffer.alloc(0);
+          pasteChunks = [];
           pasteAlreadyFlushed = true;
           clearPasteIdleTimeout();
         }
@@ -747,18 +764,20 @@ function KeypressProvider({
         if (pasteAlreadyFlushed) {
           pasteAlreadyFlushed = false;
           isPaste = false;
-          pasteBuffer = Buffer.alloc(0);
+          pasteChunks = [];
           return;
         }
         isPaste = false;
-        if (pasteBuffer.toString().length > 0) {
+        const buffered = pasteChunks.join("");
+        pasteChunks = [];
+        if (buffered.length > 0) {
           broadcast({
             name: "",
             ctrl: false,
             meta: false,
             shift: false,
             paste: true,
-            sequence: pasteBuffer.toString()
+            sequence: buffered
           });
         } else {
           let clipboardImageUnavailable = false;
@@ -773,14 +792,13 @@ function KeypressProvider({
             paste: true,
             pasteImage: hasImage,
             clipboardImageUnavailable,
-            sequence: pasteBuffer.toString()
+            sequence: buffered
           });
         }
-        pasteBuffer = Buffer.alloc(0);
         return;
       }
       if (isPaste) {
-        pasteBuffer = Buffer.concat([pasteBuffer, Buffer.from(key.sequence)]);
+        pasteChunks.push(key.sequence);
         startPasteIdleTimeout();
         return;
       }
@@ -826,7 +844,8 @@ function KeypressProvider({
         broadcast(key);
         return;
       }
-      if (kittyProtocolEnabled) {
+      const isModifyOtherKeysSequence = key.sequence?.startsWith(`${ESC2}[27`) ?? false;
+      if (kittyProtocolEnabled || kittySequenceBufferRef.current || isModifyOtherKeysSequence) {
         if (kittySequenceBufferRef.current || key.sequence.startsWith(`${ESC2}[`) && !key.sequence.startsWith(PASTE_MODE_PREFIX) && !key.sequence.startsWith(PASTE_MODE_SUFFIX) && !key.sequence.startsWith(FOCUS_IN) && !key.sequence.startsWith(FOCUS_OUT)) {
           updateKittyBuffer(kittySequenceBufferRef.current + key.sequence);
           startKittyTimeout();
@@ -1053,6 +1072,159 @@ function KeypressProvider({
         flushRawBuffer();
       }
     }, "handleRawKeypress");
+    const pasteModePrefixBuf = Buffer.from(PASTE_MODE_PREFIX);
+    const pasteModeSuffixBuf = Buffer.from(PASTE_MODE_SUFFIX);
+    function partialMarkerTailLength(chunk, marker, minLen = 2) {
+      const maxCheck = Math.min(chunk.length, marker.length - 1);
+      for (let len = maxCheck; len >= minLen; len--) {
+        const tail = chunk.subarray(chunk.length - len);
+        if (marker.subarray(0, len).equals(tail)) {
+          return len;
+        }
+      }
+      return 0;
+    }
+    __name(partialMarkerTailLength, "partialMarkerTailLength");
+    let rawStdinTail = Buffer.alloc(0);
+    let rawPasteAccumulating = false;
+    let rawPasteChunks = [];
+    let rawPasteReceivedBytes = 0;
+    let rawPasteIdleTimeout = null;
+    const clearRawPasteIdleTimeout = /* @__PURE__ */ __name(() => {
+      if (rawPasteIdleTimeout) {
+        clearTimeout(rawPasteIdleTimeout);
+        rawPasteIdleTimeout = null;
+      }
+    }, "clearRawPasteIdleTimeout");
+    const forceFlushRawPaste = /* @__PURE__ */ __name(() => {
+      clearRawPasteIdleTimeout();
+      if (!rawPasteAccumulating && rawPasteChunks.length === 0 && rawStdinTail.length === 0)
+        return;
+      if (rawStdinTail.length > 0) {
+        rawPasteChunks.push(rawStdinTail);
+        rawStdinTail = Buffer.alloc(0);
+      }
+      const content = Buffer.concat(rawPasteChunks);
+      rawPasteChunks = [];
+      rawPasteAccumulating = false;
+      broadcastPasteFromRaw(content);
+    }, "forceFlushRawPaste");
+    const startRawPasteIdleTimeout = /* @__PURE__ */ __name(() => {
+      clearRawPasteIdleTimeout();
+      rawPasteIdleTimeout = setTimeout(
+        forceFlushRawPaste,
+        PASTE_IDLE_TIMEOUT_MS
+      );
+    }, "startRawPasteIdleTimeout");
+    const broadcastPasteFromRaw = /* @__PURE__ */ __name((content) => {
+      pasteAlreadyFlushed = true;
+      setPasteProgress({ active: false, receivedBytes: 0 });
+      const text = content.toString("utf-8");
+      if (text.length > 0) {
+        broadcast({
+          name: "",
+          ctrl: false,
+          meta: false,
+          shift: false,
+          paste: true,
+          sequence: text
+        });
+      } else {
+        let clipboardImageUnavailable = false;
+        void clipboardHasImage(() => {
+          clipboardImageUnavailable = true;
+        }).then((hasImage) => {
+          broadcast({
+            name: "",
+            ctrl: false,
+            meta: false,
+            shift: false,
+            paste: true,
+            pasteImage: hasImage,
+            clipboardImageUnavailable,
+            sequence: ""
+          });
+        });
+      }
+    }, "broadcastPasteFromRaw");
+    const handleStdinData = /* @__PURE__ */ __name((data) => {
+      const raw = Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+      const buf = rawStdinTail.length > 0 ? Buffer.concat([rawStdinTail, raw]) : raw;
+      rawStdinTail = Buffer.alloc(0);
+      let cursor = 0;
+      while (cursor < buf.length) {
+        if (rawPasteAccumulating) {
+          const suffixIdx = buf.indexOf(pasteModeSuffixBuf, cursor);
+          if (suffixIdx === -1) {
+            const remaining = buf.subarray(cursor);
+            const tailLen = partialMarkerTailLength(
+              remaining,
+              pasteModeSuffixBuf,
+              1
+            );
+            const contentEnd = remaining.length - tailLen;
+            if (contentEnd > 0) {
+              const chunk = remaining.subarray(0, contentEnd);
+              rawPasteChunks.push(chunk);
+              rawPasteReceivedBytes += chunk.length;
+              setPasteProgress((prev) => ({
+                ...prev,
+                receivedBytes: rawPasteReceivedBytes
+              }));
+            }
+            if (tailLen > 0) {
+              rawStdinTail = Buffer.from(remaining.subarray(contentEnd));
+            }
+            startRawPasteIdleTimeout();
+            cursor = buf.length;
+          } else {
+            clearRawPasteIdleTimeout();
+            if (suffixIdx > cursor) {
+              rawPasteChunks.push(buf.subarray(cursor, suffixIdx));
+            }
+            const pasteContent = Buffer.concat(rawPasteChunks);
+            rawPasteChunks = [];
+            rawPasteAccumulating = false;
+            broadcastPasteFromRaw(pasteContent);
+            cursor = suffixIdx + pasteModeSuffixBuf.length;
+          }
+        } else {
+          const prefixIdx = buf.indexOf(pasteModePrefixBuf, cursor);
+          if (prefixIdx === -1) {
+            const remaining = buf.subarray(cursor);
+            if (remaining.length > 0) {
+              const tailLen = partialMarkerTailLength(
+                remaining,
+                pasteModePrefixBuf
+              );
+              if (tailLen > 0) {
+                const safe = remaining.subarray(0, remaining.length - tailLen);
+                if (safe.length > 0) keypressStream.write(safe);
+                rawStdinTail = Buffer.from(
+                  remaining.subarray(remaining.length - tailLen)
+                );
+              } else {
+                keypressStream.write(remaining);
+              }
+            }
+            cursor = buf.length;
+          } else {
+            if (prefixIdx > cursor) {
+              keypressStream.write(buf.subarray(cursor, prefixIdx));
+            }
+            rawPasteAccumulating = true;
+            rawPasteChunks = [];
+            rawPasteReceivedBytes = 0;
+            startRawPasteIdleTimeout();
+            setPasteProgress({
+              active: true,
+              receivedBytes: 0
+            });
+            cursor = prefixIdx + pasteModePrefixBuf.length;
+          }
+        }
+      }
+    }, "handleStdinData");
     let rl;
     if (usePassthrough) {
       rl = readline.createInterface({
@@ -1063,9 +1235,14 @@ function KeypressProvider({
       keypressStream.on("keypress", handleKeypress);
       stdin.on("data", handleRawKeypress);
     } else {
-      rl = readline.createInterface({ input: stdin, escapeCodeTimeout: 0 });
-      readline.emitKeypressEvents(stdin, rl);
+      rl = readline.createInterface({
+        input: keypressStream,
+        escapeCodeTimeout: 0
+      });
+      readline.emitKeypressEvents(keypressStream, rl);
+      keypressStream.on("keypress", handleKeypress);
       stdin.on("keypress", handleKeypress);
+      stdin.on("data", handleStdinData);
     }
     let replayPending = false;
     if (capturedInput.length > 0) {
@@ -1088,7 +1265,9 @@ function KeypressProvider({
         keypressStream.removeListener("keypress", handleKeypress);
         stdin.removeListener("data", handleRawKeypress);
       } else {
+        keypressStream.removeListener("keypress", handleKeypress);
         stdin.removeListener("keypress", handleKeypress);
+        stdin.removeListener("data", handleStdinData);
       }
       rl.close();
       setRawMode(false);
@@ -1098,21 +1277,27 @@ function KeypressProvider({
       }
       clearKittyBufferAndTimeout();
       clearPasteIdleTimeout();
+      clearRawPasteIdleTimeout();
       resetSgrMouse();
       if (rawFlushTimeout) {
         clearTimeout(rawFlushTimeout);
         rawFlushTimeout = null;
       }
-      if (isPaste) {
-        broadcast({
-          name: "",
-          ctrl: false,
-          meta: false,
-          shift: false,
-          paste: true,
-          sequence: pasteBuffer.toString()
-        });
-        pasteBuffer = Buffer.alloc(0);
+      if (rawPasteAccumulating || rawPasteChunks.length > 0) {
+        forceFlushRawPaste();
+      } else if (isPaste) {
+        const buffered = pasteChunks.join("");
+        if (buffered.length > 0) {
+          broadcast({
+            name: "",
+            ctrl: false,
+            meta: false,
+            shift: false,
+            paste: true,
+            sequence: buffered
+          });
+        }
+        pasteChunks = [];
       }
     };
   }, [
@@ -1134,7 +1319,8 @@ function KeypressProvider({
         unsubscribe,
         subscribeMouse,
         unsubscribeMouse,
-        pasteWorkaround
+        pasteWorkaround,
+        pasteProgress
       },
       children
     }