claudefix 2.5.2 → 2.6.0

package/bin/claude-fixed.js

@@ -295,131 +295,56 @@ if (debug) {
  */
 function stripColors(data) {
   let str = data;
-  const isGtk4 = forceNuclear || terminalType === 'ptyxis' || terminalType === 'gtk4-vte';
 
-  if (isGtk4) {
-    // THERMONUCLEAR MODE for Ptyxis/GTK4 terminals
-    // Strip ALL styling except basic foreground colors
-    // This is aggressive but ensures clean rendering
-
-    // First, strip ALL escape sequences
-    str = str.replace(/\x1b\[[0-9;]*m/g, (match) => {
-      // Only keep sequences that are JUST foreground colors (30-37, 90-97, 38;5;X, 38;2;R;G;B)
-      // and reset (0)
-
-      // Extract the codes
-      const codes = match.slice(2, -1).split(';').filter(c => c !== '');
-
-      if (codes.length === 0) return '\x1b[0m';
-
-      // Filter to only allowed codes
-      const allowed = [];
-      let i = 0;
-      while (i < codes.length) {
-        const code = parseInt(codes[i], 10);
-
-        // Reset
-        if (code === 0) {
-          allowed.push('0');
-          i++;
-        }
-        // Bold (1), but NOT dim (2)
-        else if (code === 1) {
-          allowed.push('1');
-          i++;
-        }
-        // Standard foreground (30-37)
-        else if (code >= 30 && code <= 37) {
-          allowed.push(codes[i]);
-          i++;
-        }
-        // Default foreground (39)
-        else if (code === 39) {
-          allowed.push('39');
-          i++;
-        }
-        // Bright foreground (90-97)
-        else if (code >= 90 && code <= 97) {
-          allowed.push(codes[i]);
-          i++;
-        }
-        // 256-color foreground (38;5;X)
-        else if (code === 38 && codes[i + 1] === '5' && codes[i + 2]) {
-          allowed.push('38', '5', codes[i + 2]);
-          i += 3;
-        }
-        // True color foreground (38;2;R;G;B)
-        else if (code === 38 && codes[i + 1] === '2' && codes[i + 4]) {
-          allowed.push('38', '2', codes[i + 2], codes[i + 3], codes[i + 4]);
-          i += 5;
-        }
-        // Skip backgrounds (40-47, 49, 100-107, 48;5;X, 48;2;R;G;B)
-        else if (code >= 40 && code <= 49) {
-          i++;
-        }
-        else if (code >= 100 && code <= 107) {
-          i++;
-        }
-        else if (code === 48 && codes[i + 1] === '5') {
-          i += 3; // Skip 48;5;X
-        }
-        else if (code === 48 && codes[i + 1] === '2') {
-          i += 5; // Skip 48;2;R;G;B
-        }
-        // Skip other problematic codes (2=dim, 7=inverse, 8=hidden)
-        else if (code === 2 || code === 7 || code === 8 || code === 22 || code === 27 || code === 28) {
-          i++;
-        }
-        else {
-          // Unknown - skip it
-          i++;
-        }
+  // Universal approach: parse each SGR sequence, keep only safe codes
+  // This handles ALL compound sequences correctly (e.g. \x1b[1;38;5;196;48;5;236m)
+  // by parsing code-by-code instead of regex pattern matching
+  str = str.replace(/\x1b\[[0-9;]*m/g, (match) => {
+    const codes = match.slice(2, -1).split(';').filter(c => c !== '');
+
+    if (codes.length === 0) return '\x1b[0m';
+
+    const allowed = [];
+    let i = 0;
+    while (i < codes.length) {
+      const code = parseInt(codes[i], 10);
+
+      // Reset
+      if (code === 0) { allowed.push('0'); i++; }
+      // Bold (1), italic (3), underline (4), strikethrough (9)
+      else if (code === 1 || code === 3 || code === 4 || code === 9) { allowed.push(codes[i]); i++; }
+      // Bold off (22), italic off (23), underline off (24), strikethrough off (29)
+      else if (code === 22 || code === 23 || code === 24 || code === 29) { allowed.push(codes[i]); i++; }
+      // Standard foreground (30-37)
+      else if (code >= 30 && code <= 37) { allowed.push(codes[i]); i++; }
+      // Default foreground (39)
+      else if (code === 39) { allowed.push('39'); i++; }
+      // Bright foreground (90-97)
+      else if (code >= 90 && code <= 97) { allowed.push(codes[i]); i++; }
+      // 256-color foreground (38;5;X)
+      else if (code === 38 && codes[i + 1] === '5' && codes[i + 2]) {
+        allowed.push('38', '5', codes[i + 2]); i += 3;
       }
+      // True color foreground (38;2;R;G;B)
+      else if (code === 38 && codes[i + 1] === '2' && codes[i + 4]) {
+        allowed.push('38', '2', codes[i + 2], codes[i + 3], codes[i + 4]); i += 5;
+      }
+      // Skip ALL backgrounds: 40-47, 49, 100-107
+      else if ((code >= 40 && code <= 49) || (code >= 100 && code <= 107)) { i++; }
+      // Skip 256-color bg (48;5;X)
+      else if (code === 48 && codes[i + 1] === '5') { i += 3; }
+      // Skip true color bg (48;2;R;G;B)
+      else if (code === 48 && codes[i + 1] === '2') { i += 5; }
+      // Skip dim (2), inverse (7), hidden (8) and their offs
+      else if (code === 2 || code === 7 || code === 8 || code === 27 || code === 28) { i++; }
+      // Unknown - skip
+      else { i++; }
+    }
 
-      if (allowed.length === 0) return '';
-      return `\x1b[${allowed.join(';')}m`;
-    });
-
-    return str;
-  }
-
-  // Regular mode for other terminals
-  // Remove standalone background color sequences entirely
-  str = str.replace(/\x1b\[48;5;\d+m/g, '');           // 256-color bg
-  str = str.replace(/\x1b\[48;2;\d+;\d+;\d+m/g, '');   // true color bg
-  str = str.replace(/\x1b\[4[0-7]m/g, '');             // standard bg 40-47
-  str = str.replace(/\x1b\[49m/g, '');                 // default bg
-  str = str.replace(/\x1b\[10[0-7]m/g, '');            // bright bg 100-107
-  str = str.replace(/\x1b\[7m/g, '');                  // inverse
-  str = str.replace(/\x1b\[27m/g, '');                 // inverse off
-
-  // NUCLEAR MODE: Extra aggressive stripping for VTE issues
-  str = str.replace(/\x1b\[2m/g, '');                  // dim text (causes grey)
-  str = str.replace(/\x1b\[22m/g, '');                 // dim off
-  str = str.replace(/\x1b\[8m/g, '');                  // hidden text
-  str = str.replace(/\x1b\[28m/g, '');                 // hidden off
-
-  // Strip any remaining compound sequences with background codes
-  // Matches patterns like \x1b[0;48;5;236m or \x1b[38;5;196;48;5;236m
-  str = str.replace(/\x1b\[([0-9;]*?)(;?48;[52];[0-9;]+)(;?[0-9;]*)m/g, (match, before, bg, after) => {
-    const parts = [before, after].filter(p => p && p.length > 0 && p !== ';');
-    if (parts.length === 0) return '\x1b[0m';
-    return `\x1b[${parts.join(';').replace(/^;|;$/g, '').replace(/;;+/g, ';')}m`;
+    if (allowed.length === 0) return '';
+    return `\x1b[${allowed.join(';')}m`;
   });
 
-  // For combined sequences like \x1b[1;41m (bold + red bg), remove just the bg part
-  // This regex finds sequences with bg codes and removes just those codes
-  str = str.replace(/\x1b\[([0-9;]*)(?:;?)(4[0-7]|49|10[0-7]|48;5;\d+|48;2;\d+;\d+;\d+)(?:;?)([0-9;]*)m/g,
-    (match, before, bg, after) => {
-      const parts = [before, after].filter(p => p && p.length > 0);
-      if (parts.length === 0) return '';
-      return `\x1b[${parts.join(';')}m`;
-    });
-
-  // Clean up any malformed sequences that might be left
-  str = str.replace(/\x1b\[;+m/g, '\x1b[0m');         // \x1b[;;m -> \x1b[0m
-  str = str.replace(/\x1b\[m/g, '\x1b[0m');           // \x1b[m -> \x1b[0m
-
   return str;
 }
 
@@ -480,6 +405,15 @@ function getTerminalType() {
     return 'ptyxis';
   }
 
+  // XFCE4 Terminal - uses VTE but handles ANSI fine, does NOT need thermonuclear mode
+  // Must check BEFORE the VTE version check or it gets misclassified as gtk4-vte
+  if (termProgram === 'xfce4-terminal' || termProgram === 'Xfce Terminal' ||
+      process.env.XFCE_TERMINAL_VERSION ||
+      process.env.WINDOWPATH || // XFCE sets this
+      (process.env.XDG_CURRENT_DESKTOP || '').toLowerCase().includes('xfce')) {
+    return 'xfce-terminal';
+  }
+
   // GTK4 terminals (like Ptyxis) often have GDK_BACKEND set
   if (gdkBackend === 'wayland' && vteVersion) {
     return 'gtk4-vte';
@@ -932,9 +866,22 @@ if (!usePTY) {
     );
   }
 
+  // FIX (Linux only): Enter alternate screen buffer to prevent ghost frames.
+  // Ink renders inline (no alternate screen) — content stacks/triplicates on re-render.
+  // By entering alternate screen ourselves, Ink's output goes to a clean buffer.
+  // On exit, we leave alternate screen to restore the original terminal content.
+  if (!isMac && !sshMode) {
+    process.stdout.write('\x1b[?1049h\x1b[H\x1b[J');  // Enter alternate screen + clear
+  }
+
   // Initial setup
   setupScrollRegion();
-  if (!sshMode && showFooter) drawFooter();
+  if (!sshMode && showFooter) {
+    drawFooter();
+    // Re-draw footer after Ink's initial setup (Ink may overwrite during startup)
+    setTimeout(drawFooter, 500);
+    setTimeout(drawFooter, 1500);
+  }
 
   // Footer refresh - debounced, only redraws AFTER PTY output settles
   // No independent timer - footer only redraws in response to PTY activity
@@ -969,53 +916,82 @@ if (!usePTY) {
   // macOS Terminal.app doesn't have VTE bugs, so skip aggressive escape mangling
   const isAppleTerminal = process.env.TERM_PROGRAM === 'Apple_Terminal';
 
-  ptyProcess.onData((data) => {
-    // Stop forwarding output once we're cleaning up - prevents Claude's
-    // dying output from overwriting our exit banner
-    if (exiting) return;
+  // FIX: Buffer-and-flush approach for ghost frame elimination on Linux.
+  // Problem: Ink sends renders in multiple small chunks. Injecting \x1b[J on any
+  // individual chunk either misses (threshold not met) or nukes partial renders.
+  // Solution: Buffer ALL output, flush after a short idle gap (16ms). When flushing,
+  // if the buffer contains \x1b[H (home cursor = new render), inject \x1b[J after it.
+  // Since the entire render is flushed atomically, clear + content arrive together.
+  let outputBuffer = '';
+  let flushTimer = null;
+  const FLUSH_DELAY_MS = 16;      // Normal flush delay (~1 frame)
+  const COALESCE_DELAY_MS = 80;   // Extended delay during rapid full repaints
+  let lastFullRenderTime = 0;     // When we last flushed a full repaint
+
+  function processAndFlush() {
+    flushTimer = null;
+    if (!outputBuffer || exiting) return;
+
+    let output = outputBuffer;
+    outputBuffer = '';
+
     // Only strip colors if config enabled and env var not disabled
-    // On macOS: skip color stripping entirely for Apple Terminal (no VTE bugs)
     const shouldStrip = config.colorStripping &&
       process.env.CLAUDE_STRIP_BG_COLORS !== '0' &&
       !isAppleTerminal;
-    let output = shouldStrip ? stripColors(data) : data;
+    if (shouldStrip) output = stripColors(output);
 
     // FIX: Intercept scroll region resets from Ink/Claude output.
-    // Ink sends \x1b[r which resets scroll region to full terminal,
-    // causing our footer area to become content area and old content bleeds through.
-    // Replace with our constrained scroll region.
     if (showFooter && !sshMode) {
       const cr = contentRows();
-      // Replace bare scroll region reset with our constrained one
       output = output.replace(/\x1b\[r/g, `\x1b[1;${cr}r`);
-      // Also catch explicit full-terminal scroll regions like \x1b[1;24r
       const fullRows = process.stdout.rows || 24;
       output = output.replace(new RegExp(`\\x1b\\[1;${fullRows}r`, 'g'), `\x1b[1;${cr}r`);
     }
 
-    // FIX (Linux only): When Ink sends a screen clear (\x1b[2J), inject scrollback
-    // clear to prevent old content from sticking around in VTE terminals.
-    // SKIP on macOS: Terminal.app handles \x1b[3J differently and it causes
-    // visual glitches (screen flashing, content disappearing).
+    // FIX (Linux only): Inject scrollback clear on full screen clears
     if (!isMac) {
-      if (output.includes('\x1b[2J') || output.includes('\x1b[3J')) {
+      if (output.includes('\x1b[2J')) {
         output = output.replace(/\x1b\[2J/g, '\x1b[2J\x1b[3J');
       }
     }
 
-    // FIX (Linux only): Detect Ink's home cursor (\x1b[H or \x1b[1;1H) followed
-    // by content - this is a differential re-render. Clear to end of screen after
-    // home to prevent stale content below the new render from showing through.
-    // SKIP on macOS: Apple Terminal repaints on \x1b[J which causes rapid
-    // flickering when combined with Ink's frequent re-renders.
-    if (!isMac) {
-      if (output.includes('\x1b[H') || output.includes('\x1b[1;1H')) {
-        output = output.replace(/(\x1b\[(?:1;1)?H)/, '$1\x1b[J');
-      }
+    // FIX (Linux only): Clear stale content when Ink does a FULL re-render.
+    // Ink sends \x1b[H for both full repaints AND partial updates (just prompt).
+    // We must ONLY clear on full repaints or we wipe content Ink didn't re-send.
+    // Since we buffer the entire render cycle, we can check the buffer size:
+    // - Full repaint: large buffer (most of the screen rewritten)
+    // - Partial update (prompt only): small buffer
+    // Threshold: at least half the screen worth of content (contentRows * 30 bytes)
+    // FIX: Strip Ink's alternate screen sequences — we manage alternate screen
+    // ourselves. If Ink enters/exits alternate screen, it disrupts our scroll
+    // region and footer. Remove these so our alternate screen stays in control.
+    if (!isMac && !sshMode) {
+      output = output.replace(/\x1b\[\?1049[hl]/g, '');
+      // Also strip smcup/rmcup variants
+      output = output.replace(/\x1b\[\?47[hl]/g, '');
     }
 
     process.stdout.write(output);
+    // Re-assert scroll region after each flush (Ink may have sent sequences that
+    // override it, even after our replacements)
+    if (showFooter && !sshMode) {
+      const cr = contentRows();
+      process.stdout.write(`\x1b7\x1b[1;${cr}r\x1b8`);
+    }
     if (showFooter) scheduleFooterDraw();
+  }
+
+  ptyProcess.onData((data) => {
+    if (exiting) return;
+    // Accumulate into buffer
+    outputBuffer += data;
+    // Reset flush timer — wait for output burst to finish
+    if (flushTimer) clearTimeout(flushTimer);
+    // Use longer delay if we recently flushed a full render (coalesce rapid repaints)
+    const recentFullRender = (Date.now() - lastFullRenderTime) < 200;
+    const delay = recentFullRender ? COALESCE_DELAY_MS : FLUSH_DELAY_MS;
+    flushTimer = setTimeout(processAndFlush, delay);
   });
 
   // Forward stdin with Ctrl+Shift+H hotkey
@@ -1080,7 +1056,12 @@ if (!usePTY) {
     clearInterval(memCheckInterval);
     if (gcInterval) clearInterval(gcInterval);
     if (pendingDraw) clearTimeout(pendingDraw);
-    // Clean exit: reset scroll region, clear screen, show exit banner
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    if (outputBuffer) { process.stdout.write(outputBuffer); outputBuffer = ''; }
+    // Clean exit: leave alternate screen, reset scroll region
+    if (!isMac && !sshMode) {
+      process.stdout.write('\x1b[?1049l');  // Exit alternate screen buffer
+    }
     if (!sshMode && showFooter) {
       process.stdout.write(
         '\x1b[r' +       // Reset scroll region to full terminal
@@ -1138,6 +1119,11 @@ if (!usePTY) {
     if (cpuLimiter) try { cpuLimiter.kill(); } catch {}
     if (footerInterval) clearInterval(footerInterval);
     if (pendingDraw) clearTimeout(pendingDraw);
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    if (outputBuffer) { process.stdout.write(outputBuffer); outputBuffer = ''; }
+    if (!isMac && !sshMode) {
+      process.stdout.write('\x1b[?1049l');  // Exit alternate screen buffer
+    }
     if (!sshMode && showFooter) {
       process.stdout.write(
         '\x1b[r' +       // Reset scroll region

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudefix",
-  "version": "2.5.2",
+  "version": "2.6.0",
   "description": "Fixes screen glitching, blocky colors, AND MEMORY LEAKS in Claude Code CLI on Linux and macOS. All features optional via env vars. Shows config options on install. Developed by Hardwick Software Services @ https://justcalljon.pro",
   "main": "index.cjs",
   "bin": {