deckide 3.5.24 → 3.5.26

package/dist/routes/terminals.js

@@ -5,7 +5,7 @@ import { TERMINAL_BUFFER_LIMIT } from '../config.js';
 import { createHttpError, handleError, readJson } from '../utils/error.js';
 import { getDefaultShell } from '../utils/shell.js';
 import { saveTerminal, deleteTerminal as deleteTerminalFromDb } from '../utils/database.js';
-import { alignToUtf8Start } from '../utils/utf8.js';
+import { alignToUtf8Start, skipPartialEscapeSequence } from '../utils/utf8.js';
 const DEFAULT_TERMINAL_TITLE = 'ターミナル';
 const MAX_SOCKET_BUFFERED_AMOUNT = 1024 * 1024;
 export function createTerminalRouter(db, decks, terminals) {
@@ -21,15 +21,22 @@ export function createTerminalRouter(db, decks, terminals) {
         if (chunk.length >= TERMINAL_BUFFER_LIMIT) {
             let cutPos = chunk.length - TERMINAL_BUFFER_LIMIT;
             cutPos = alignToUtf8Start(chunk, cutPos);
-            const retainedChunk = Buffer.from(chunk.subarray(cutPos));
-            session.bufferBase += session.bufferLength + cutPos;
-            session.bufferChunks = [retainedChunk];
-            session.bufferLength = retainedChunk.length;
+            let retained = Buffer.from(chunk.subarray(cutPos));
+            // Skip partial escape sequence at the new start
+            const escSkip = skipPartialEscapeSequence(retained, 0);
+            if (escSkip > 0) {
+                retained = Buffer.from(retained.subarray(escSkip));
+            }
+            session.bufferBase += session.bufferLength + cutPos + escSkip;
+            session.bufferChunks = [retained];
+            session.bufferLength = retained.length;
             return;
         }
         session.bufferChunks.push(Buffer.from(chunk));
         session.bufferLength += chunk.length;
+        let trimmed = false;
         while (session.bufferLength > TERMINAL_BUFFER_LIMIT && session.bufferChunks.length > 0) {
+            trimmed = true;
             const overflow = session.bufferLength - TERMINAL_BUFFER_LIMIT;
             const firstChunk = session.bufferChunks[0];
             if (firstChunk.length <= overflow) {
@@ -43,9 +50,9 @@ export function createTerminalRouter(db, decks, terminals) {
             session.bufferBase += cutPos;
             session.bufferLength -= cutPos;
         }
-        // After removing whole chunks, the new first chunk may start with
-        // orphaned UTF-8 continuation bytes from a character that spanned chunks.
-        if (session.bufferChunks.length > 0) {
+        if (trimmed && session.bufferChunks.length > 0) {
+            // After removing whole chunks, the new first chunk may start with
+            // orphaned UTF-8 continuation bytes from a character that spanned chunks.
             const first = session.bufferChunks[0];
             const skip = alignToUtf8Start(first, 0);
             if (skip > 0) {
@@ -53,6 +60,16 @@ export function createTerminalRouter(db, decks, terminals) {
                 session.bufferBase += skip;
                 session.bufferLength -= skip;
             }
+            // Also skip past any partial ANSI CSI escape sequence at the start.
+            // Without this, orphaned parameter bytes like "100;50m" are rendered
+            // as literal text and shift all cursor positions.
+            const cur = session.bufferChunks[0];
+            const escSkip = skipPartialEscapeSequence(cur, 0);
+            if (escSkip > 0) {
+                session.bufferChunks[0] = Buffer.from(cur.subarray(escSkip));
+                session.bufferBase += escSkip;
+                session.bufferLength -= escSkip;
+            }
         }
     }
     function getUniqueTerminalTitle(deckId, requestedTitle) {

package/dist/utils/utf8.js

@@ -53,3 +53,157 @@ export function alignToUtf8End(buf, offset) {
     // The character is incomplete — exclude it
     return pos;
 }
+/**
+ * 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 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.
+ *
+ * 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);
+    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;
+    }
+    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];
+        if (c >= 0x30 && c <= 0x3F) {
+            if (c === 0x3B)
+                hasSemicolon = true;
+            pos++;
+        }
+        else if (c >= 0x20 && c <= 0x2F) {
+            pos++;
+        }
+        else if (c >= 0x40 && c <= 0x7E) {
+            // Only skip if we saw ';' — avoids false positives like "5m"
+            return hasSemicolon ? (pos + 1) - offset : 0;
+        }
+        else {
+            break;
+        }
+    }
+    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.24",
+  "version": "3.5.26",
   "description": "Deck IDE - Browser-based IDE with terminal, file explorer, and git integration",
   "type": "module",
   "bin": {