deckide 3.5.24 → 3.5.25

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,74 @@ export function alignToUtf8End(buf, offset) {
     // The character is incomplete — exclude it
     return pos;
 }
+/**
+ * Skip past a partial ANSI CSI 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
+ * 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.
+ *
+ * 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 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;
+        }
+        return 0;
+    }
+    // Pattern 2: starts with CSI parameter bytes (digits, ';', etc.)
+    const b = buf[pos];
+    if (b < 0x30 || b > 0x3F)
+        return 0;
+    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) {
+            // CSI final byte — only skip if we saw at least one semicolon
+            // (avoids false positives like "5m" at the start of normal text)
+            return hasSemicolon ? (pos + 1) - offset : 0;
+        }
+        else {
+            break;
+        }
+    }
+    return 0;
+}

package/package.json

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