deckide 3.5.25 → 3.5.26

package/dist/utils/utf8.js

@@ -54,54 +54,106 @@ export function alignToUtf8End(buf, offset) {
     return pos;
 }
 /**
- * Skip past a partial ANSI CSI escape sequence at the start of a buffer.
+ * Skip past a partial ANSI escape sequence at the start of a buffer.
  *
  * When a terminal buffer is trimmed from the front, the cut point may land
- * inside a CSI sequence (e.g. "\x1b[38;2;100;50m").  The ESC and '[' are
- * discarded, leaving orphaned parameter bytes like "100;50m" that xterm.js
+ * inside an escape sequence.  The leading ESC byte (and possibly the type
+ * indicator) is discarded, leaving orphaned payload bytes that xterm.js
  * would render as literal text, shifting all subsequent cursor positions.
  *
- * This function detects two patterns:
- *   1. Buffer starts with '[' followed by CSI parameter / intermediate /
- *      final bytes  →  partial CSI whose ESC was trimmed.
- *   2. Buffer starts with CSI parameter bytes (digits, ';') containing at
- *      least one ';', ending with a final byte  →  partial CSI whose
- *      "ESC [" was trimmed.
+ * Handled sequence types:
+ *
+ *   CSI  (ESC [)  — e.g. "\x1b[38;2;100;50m"
+ *     Detected as: '[' + params/intermediates + final byte
+ *     or: bare params with ';' + final byte  (ESC and '[' both trimmed)
+ *
+ *   OSC  (ESC ])  — e.g. "\x1b]0;title\x07"
+ *     Detected as: ']' + text + BEL/ST terminator
+ *
+ *   DCS  (ESC P)  — e.g. "\x1bP1$r...\x1b\\"
+ *     Detected as: 'P' + text + ST terminator
+ *
+ *   APC  (ESC _)  — e.g. "\x1b_...\x1b\\"
+ *     Detected as: '_' + text + ST terminator
  *
  * Returns the number of bytes to skip (0 if no partial sequence detected).
  */
 export function skipPartialEscapeSequence(buf, offset) {
     if (offset >= buf.length)
         return 0;
+    const b = buf[offset];
+    // ── CSI: starts with '[' (ESC was trimmed) ──
+    if (b === 0x5B /* '[' */) {
+        return skipPartialCSI(buf, offset);
+    }
+    // ── OSC: starts with ']' (ESC was trimmed) ──
+    if (b === 0x5D /* ']' */) {
+        return skipStringSequence(buf, offset);
+    }
+    // ── DCS: starts with 'P' (ESC was trimmed) ──
+    // Only treat as DCS if followed by a parameter byte, '$', or printable
+    // control sequence byte — avoids false positive on words like "Path".
+    if (b === 0x50 /* 'P' */ && offset + 1 < buf.length) {
+        const next = buf[offset + 1];
+        if ((next >= 0x30 && next <= 0x3F) || next === 0x24 /* '$' */) {
+            return skipStringSequence(buf, offset);
+        }
+    }
+    // ── APC: starts with '_' (ESC was trimmed) ──
+    if (b === 0x5F /* '_' */) {
+        return skipStringSequence(buf, offset);
+    }
+    // ── Bare CSI params (both ESC and '[' trimmed) ──
+    if (b >= 0x30 && b <= 0x3F) {
+        return skipBareCSIParams(buf, offset);
+    }
+    return 0;
+}
+/**
+ * Skip a partial CSI sequence starting with '['.
+ * Pattern: '[' params intermediates final
+ */
+function skipPartialCSI(buf, offset) {
     const limit = Math.min(buf.length, offset + 128);
-    let pos = offset;
-    // Pattern 1: starts with '[' (CSI intro without preceding ESC)
-    if (buf[pos] === 0x5B /* '[' */ && pos + 1 < limit) {
-        const next = buf[pos + 1];
-        // Only treat as CSI if next byte is a parameter (0x30-0x3F) or
-        // intermediate (0x20-0x2F) byte — avoids false positives like "[user@host"
-        if ((next >= 0x30 && next <= 0x3F) || (next >= 0x20 && next <= 0x2F)) {
-            pos++; // skip '['
-            while (pos < limit) {
-                const c = buf[pos];
-                if ((c >= 0x30 && c <= 0x3F) || (c >= 0x20 && c <= 0x2F)) {
-                    pos++;
-                    continue;
-                }
-                if (c >= 0x40 && c <= 0x7E) {
-                    // CSI final byte — skip it and we're done
-                    return (pos + 1) - offset;
-                }
-                break;
-            }
-            return 0;
+    if (offset + 1 >= limit)
+        return 0;
+    const next = buf[offset + 1];
+    // Only treat as CSI if the next byte is a parameter (0x30-0x3F) or
+    // intermediate (0x20-0x2F) — avoids false positives like "[user@host"
+    if (next < 0x20 || (next > 0x3F && next < 0x40))
+        return 0;
+    // If next is already a final byte (letter), it could be "[H" (cursor home)
+    // or "[hello" — skip only the 2-byte "[H" style if the byte after final
+    // is a control char or ESC (strong signal it was a real sequence).
+    if (next >= 0x40 && next <= 0x7E) {
+        if (offset + 2 < buf.length) {
+            const after = buf[offset + 2];
+            if (after === 0x1B || after < 0x20)
+                return 2;
         }
         return 0;
     }
-    // Pattern 2: starts with CSI parameter bytes (digits, ';', etc.)
-    const b = buf[pos];
-    if (b < 0x30 || b > 0x3F)
-        return 0;
+    let pos = offset + 1;
+    while (pos < limit) {
+        const c = buf[pos];
+        if ((c >= 0x30 && c <= 0x3F) || (c >= 0x20 && c <= 0x2F)) {
+            pos++;
+            continue;
+        }
+        if (c >= 0x40 && c <= 0x7E) {
+            return (pos + 1) - offset;
+        }
+        break;
+    }
+    return 0;
+}
+/**
+ * Skip bare CSI parameter bytes (both ESC and '[' were trimmed).
+ * Pattern: digits/';' (with at least one ';') + final byte
+ */
+function skipBareCSIParams(buf, offset) {
+    const limit = Math.min(buf.length, offset + 128);
+    let pos = offset;
     let hasSemicolon = false;
     while (pos < limit) {
         const c = buf[pos];
@@ -114,8 +166,7 @@ export function skipPartialEscapeSequence(buf, offset) {
             pos++;
         }
         else if (c >= 0x40 && c <= 0x7E) {
-            // CSI final byte — only skip if we saw at least one semicolon
-            // (avoids false positives like "5m" at the start of normal text)
+            // Only skip if we saw ';' — avoids false positives like "5m"
             return hasSemicolon ? (pos + 1) - offset : 0;
         }
         else {
@@ -124,3 +175,35 @@ export function skipPartialEscapeSequence(buf, offset) {
     }
     return 0;
 }
+/**
+ * Skip a string-type escape sequence (OSC / DCS / APC) that starts with
+ * the type indicator byte (']', 'P', or '_') — the leading ESC was trimmed.
+ *
+ * These sequences are terminated by:
+ *   - BEL  (0x07)              — common for OSC
+ *   - ST   (ESC \  = 0x1B 0x5C) — standard for all
+ *
+ * We scan up to 4 KB for the terminator; if not found we skip nothing
+ * (the partial sequence might span far beyond what we want to discard).
+ */
+function skipStringSequence(buf, offset) {
+    const limit = Math.min(buf.length, offset + 4096);
+    let pos = offset + 1; // skip the type indicator byte
+    while (pos < limit) {
+        const c = buf[pos];
+        if (c === 0x07) {
+            // BEL terminator
+            return (pos + 1) - offset;
+        }
+        if (c === 0x1B && pos + 1 < buf.length && buf[pos + 1] === 0x5C) {
+            // ST terminator (ESC \)
+            return (pos + 2) - offset;
+        }
+        // If we hit another ESC that's NOT followed by '\', it's a new sequence
+        if (c === 0x1B) {
+            return pos - offset;
+        }
+        pos++;
+    }
+    return 0;
+}

package/dist/websocket.js

@@ -149,11 +149,11 @@ function readBufferedRange(session, startOffset, endOffset) {
     if (relativeEnd <= relativeStart || session.bufferChunks.length === 0) {
         return Buffer.alloc(0);
     }
-    // Materialize the raw range first, then align to UTF-8 boundaries.
-    // This avoids splitting multi-byte characters that span chunk boundaries.
+    // Materialize the raw range into a contiguous copy so the caller
+    // is not affected if buffer chunks are later trimmed or reassigned.
     let raw;
     if (session.bufferChunks.length === 1) {
-        raw = session.bufferChunks[0].subarray(relativeStart, relativeEnd);
+        raw = Buffer.from(session.bufferChunks[0].subarray(relativeStart, relativeEnd));
     }
     else {
         const slices = [];
@@ -172,7 +172,7 @@ function readBufferedRange(session, startOffset, endOffset) {
             const endInChunk = Math.min(chunk.length, relativeEnd - chunkStart);
             slices.push(chunk.subarray(startInChunk, endInChunk));
         }
-        raw = slices.length === 1 ? slices[0] : Buffer.concat(slices);
+        raw = Buffer.concat(slices); // concat always creates a new Buffer
     }
     // Align start: skip orphaned continuation bytes
     const alignedStart = alignToUtf8Start(raw, 0);
@@ -181,7 +181,7 @@ function readBufferedRange(session, startOffset, endOffset) {
     if (alignedStart === 0 && alignedEnd === raw.length) {
         return raw;
     }
-    return raw.subarray(alignedStart, alignedEnd);
+    return Buffer.from(raw.subarray(alignedStart, alignedEnd));
 }
 export function setupWebSocketServer(server, terminals) {
     const wss = new WebSocketServer({ server, maxPayload: MAX_MESSAGE_SIZE });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deckide",
-  "version": "3.5.25",
+  "version": "3.5.26",
   "description": "Deck IDE - Browser-based IDE with terminal, file explorer, and git integration",
   "type": "module",
   "bin": {