claudefix 2.6.1 → 2.7.0

package/bin/claude-fixed.js

@@ -295,56 +295,131 @@ if (debug) {
  */
 function stripColors(data) {
   let str = data;
+  const isGtk4 = forceNuclear || terminalType === 'ptyxis' || terminalType === 'gtk4-vte';
 
-  // 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;
+  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++;
+        }
       }
-      // 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`;
+      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`;
   });
 
+  // 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;
 }
 
@@ -405,15 +480,6 @@ 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';
@@ -797,19 +863,23 @@ if (!usePTY) {
     }
   }
 
-  // How many footer rows to reserve (1 for claudefix, +1 if specmem active)
-  const footerRows = specmemActive ? 2 : 1;
+  // How many footer rows to reserve (1 for claudefix, +2 if specmem active for team comms + status)
+  const footerRows = specmemActive ? 3 : 1;
 
   function setupScrollRegion() {
     const rows = process.stdout.rows || 24;
     const cols = process.stdout.columns || 80;
 
     if (sshMode || !showFooter) {
+      // SSH mode or no footer: NO scroll region manipulation
       ptyProcess.resize(cols, rows);
     } else {
-      // Reserve bottom row(s) for footer via scroll region + PTY resize
+      // Local mode with footer: reserve bottom row(s) for footer
+      // FIX: Handle edge case where terminal is too small
       const contentRows = Math.max(1, rows - footerRows);
 
+      // FIX: Reset scroll region first, then set new one to avoid clipping
+      // This prevents content from being cut off during dynamic resize
       process.stdout.write(
         '\x1b[r' +                          // Reset scroll region to full terminal
         '\x1b7' +                           // Save cursor position
@@ -817,6 +887,7 @@ if (!usePTY) {
         '\x1b8'                             // Restore cursor position
       );
 
+      // Resize PTY to content area (excludes footer row(s))
       ptyProcess.resize(cols, contentRows);
     }
   }
@@ -861,13 +932,6 @@ if (!usePTY) {
     );
   }
 
-  // FIX (Linux only): Clear screen once at startup to prevent ghost frames.
-  // Ink renders inline (no alternate screen) and re-renders during startup cause
-  // content to stack/triplicate. A single clear before first output fixes this.
-  // NOTE: Do NOT use alternate screen (\x1b[?1049h) — it makes Ink switch to
-  // full-screen mode where it sends \x1b[H\x1b[J which erases the footer.
-  let startupCleared = false;
-
   // Initial setup
   setupScrollRegion();
   if (!sshMode && showFooter) drawFooter();
@@ -905,74 +969,53 @@ if (!usePTY) {
   // macOS Terminal.app doesn't have VTE bugs, so skip aggressive escape mangling
   const isAppleTerminal = process.env.TERM_PROGRAM === 'Apple_Terminal';
 
-  // 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 = '';
-
+  ptyProcess.onData((data) => {
+    // Stop forwarding output once we're cleaning up - prevents Claude's
+    // dying output from overwriting our exit banner
+    if (exiting) return;
     // 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;
-    if (shouldStrip) output = stripColors(output);
+    let output = shouldStrip ? stripColors(data) : data;
 
-    // Intercept scroll region resets from Ink — replace with our constrained region
+    // 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): Inject scrollback clear on full screen clears
+    // 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).
     if (!isMac) {
-      if (output.includes('\x1b[2J')) {
+      if (output.includes('\x1b[2J') || output.includes('\x1b[3J')) {
         output = output.replace(/\x1b\[2J/g, '\x1b[2J\x1b[3J');
       }
     }
 
-    // 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 (Linux only): Clear screen once before first output to prevent
-    // startup ghost frames (triplicated content from Ink's initial renders)
-    if (!isMac && !startupCleared) {
-      startupCleared = true;
-      output = '\x1b[2J\x1b[3J\x1b[H' + output;
+    // 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');
+      }
     }
 
     process.stdout.write(output);
     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
@@ -1037,9 +1080,7 @@ if (!usePTY) {
     clearInterval(memCheckInterval);
     if (gcInterval) clearInterval(gcInterval);
     if (pendingDraw) clearTimeout(pendingDraw);
-    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
-    if (outputBuffer) { process.stdout.write(outputBuffer); outputBuffer = ''; }
-    // Clean exit: leave alternate screen, reset scroll region
+    // Clean exit: reset scroll region, clear screen, show exit banner
     if (!sshMode && showFooter) {
       process.stdout.write(
         '\x1b[r' +       // Reset scroll region to full terminal
@@ -1097,8 +1138,6 @@ 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 (!sshMode && showFooter) {
       process.stdout.write(
         '\x1b[r' +       // Reset scroll region

package/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * claudescreenfix-hardwicksoftware - stops the scroll glitch from cooking your terminal
+ * claudefix - stops the scroll glitch from cooking your terminal
  *
  * the problem:
  *   claude code uses ink (react for terminals) and it dont clear scrollback
@@ -13,6 +13,8 @@
  *   - hook stdout.write to inject scrollback clears periodically
  *   - debounce SIGWINCH so resize aint thrashing
  *   - enhance /clear to actually clear scrollback not just the screen
+ *   - RESOURCE LIMITING: cap CPU + RAM via cpulimit/cgroup/nice + V8 flags
+ *   - GC FORCING: periodic garbage collection to fight V8 heap bloat
  *
  * FIXED v1.0.1: typing issue where stdin echo was being intercepted
  *   - now detects stdin echo writes and passes them through unmodified
@@ -23,7 +25,15 @@
  *   - auto-detects Xvfb/VNC/headless environments
  *   - strips BACKGROUND colors that cause VTE rendering glitches
  *   - keeps foreground colors and spinners working perfectly
- *   - your Zesting still zests, just no broken color blocks
+ *
+ * NEW v2.7.0: resource limiting
+ *   - reads ~/.claudefix.json for memPercent/cpuPercent settings
+ *   - applies --max-old-space-size to child processes via NODE_OPTIONS
+ *   - cpulimit/cgroup/renice for CPU capping
+ *   - periodic forced GC via --expose-gc
+ *   - RAM monitoring with threshold warnings
+ *
+ * Developed by Hardwick Software Services - https://justcalljon.pro
  */
 
 
@@ -78,21 +88,14 @@ function stripCompoundBgCodes(str) {
 
 // supported terminals - only run fix on these
 const SUPPORTED_TERMINALS = [
-  'xterm', 'xterm-256color', 'xterm-color',
-  'screen', 'screen-256color',
-  'tmux', 'tmux-256color',
-  'linux', 'vt100', 'vt220',
-  'rxvt', 'rxvt-unicode', 'rxvt-unicode-256color',
-  'gnome', 'gnome-256color',
-  'konsole', 'konsole-256color',
+  'xterm', 'xterm-256color', 'screen', 'screen-256color',
+  'tmux', 'tmux-256color', 'rxvt', 'rxvt-unicode', 'rxvt-unicode-256color',
+  'vt100', 'vt220', 'linux', 'ansi', 'cygwin',
+  'alacritty', 'foot', 'foot-extra', 'kitty', 'kitty-direct', 'xterm-kitty',
+  'wezterm', 'xterm-ghostty', 'ghostty',
+  'dumb' // support dumb terminals too (VNC/headless)
 ];
 
-function isTerminalSupported() {
-  const term = process.env.TERM || '';
-  // check exact match or prefix match
-  return SUPPORTED_TERMINALS.some(t => term === t || term.startsWith(t + '-'));
-}
-
 // config - tweak these if needed
 const config = {
   resizeDebounceMs: 150,        // how long to wait before firing resize
@@ -105,6 +108,159 @@ const config = {
   stripColors: process.env.CLAUDE_STRIP_COLORS !== '0', // strip by default, disable with =0
 };
 
+// ============================================================================
+// RESOURCE LIMITER — Cap Claude's CPU & RAM usage
+// ============================================================================
+// Reads from ~/.claudefix.json (memPercent, cpuPercent) or env vars:
+//   CLAUDE_MAX_CPU=50      → max 50% CPU
+//   CLAUDE_MAX_RAM=4096    → max 4GB RSS in MB
+//   CLAUDEFIX_MEM_PERCENT=35 → 35% of system RAM for V8 heap
+//   CLAUDEFIX_CPU_PERCENT=80 → 80% CPU cap
+//   CLAUDE_RESOURCE_LIMIT=0  → disable resource limiting
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+// Load user config from ~/.claudefix.json
+function _loadUserConfig() {
+  try {
+    const cfgPath = path.join(os.homedir(), '.claudefix.json');
+    if (fs.existsSync(cfgPath)) {
+      return JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    }
+  } catch (_) {}
+  return {};
+}
+
+const _userConfig = _loadUserConfig();
+
+const resourceConfig = {
+  // Memory: percentage of system RAM for V8 heap
+  memPercent: parseInt(process.env.CLAUDEFIX_MEM_PERCENT || '', 10) || _userConfig.memPercent || 35,
+  memEnabled: _userConfig.memoryLimit !== false && process.env.CLAUDE_RESOURCE_LIMIT !== '0',
+  // CPU: percentage cap (0 = no limit)
+  cpuPercent: parseInt(process.env.CLAUDEFIX_CPU_PERCENT || process.env.CLAUDE_MAX_CPU || '', 10) || _userConfig.cpuPercent || 0,
+  // RAM monitoring
+  maxRamMB: parseInt(process.env.CLAUDE_MAX_RAM || '', 10) || 0, // 0 = auto from memPercent
+  checkIntervalMs: 30000,
+  gcIntervalMs: 60000,
+  enabled: process.env.CLAUDE_RESOURCE_LIMIT !== '0',
+  _intervalId: null,
+  _gcIntervalId: null,
+  _cpulimitPid: null,
+};
+
+// Calculate actual limits
+const TOTAL_MEM_MB = Math.floor(os.totalmem() / 1048576);
+const MAX_HEAP_MB = resourceConfig.maxRamMB || Math.floor(TOTAL_MEM_MB * Math.min(100, Math.max(1, resourceConfig.memPercent)) / 100);
+const WARN_THRESHOLD_MB = Math.floor(MAX_HEAP_MB * 0.7);
+const CRITICAL_THRESHOLD_MB = Math.floor(MAX_HEAP_MB * 0.9);
+
+function installResourceLimiter() {
+  if (!resourceConfig.enabled || process.platform !== 'linux') return;
+
+  const { execSync, spawn } = require('child_process');
+  const pid = process.pid;
+
+  // --- Set NODE_OPTIONS for V8 heap limit + GC exposure ---
+  // This affects the CURRENT process and any child processes
+  if (resourceConfig.memEnabled) {
+    const existingOpts = process.env.NODE_OPTIONS || '';
+    if (!existingOpts.includes('--max-old-space-size')) {
+      process.env.NODE_OPTIONS = (existingOpts + ' --max-old-space-size=' + MAX_HEAP_MB).trim();
+      log('resource: NODE_OPTIONS set --max-old-space-size=' + MAX_HEAP_MB + 'MB (' + resourceConfig.memPercent + '% of ' + TOTAL_MEM_MB + 'MB)');
+    }
+    if (!existingOpts.includes('--expose-gc')) {
+      process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS + ' --expose-gc').trim();
+      log('resource: NODE_OPTIONS set --expose-gc');
+    }
+  }
+
+  // --- CPU limiting via cpulimit (if configured and available) ---
+  if (resourceConfig.cpuPercent > 0) {
+    const cpuCores = os.cpus().length;
+    // cpulimit uses percentage per-core, so 50% on 4 cores = 200% cpulimit value
+    const cpulimitVal = Math.floor(resourceConfig.cpuPercent * cpuCores / 100) * 100 || resourceConfig.cpuPercent;
+
+    try {
+      execSync('which cpulimit 2>/dev/null', { stdio: 'pipe' });
+      const cpulimitProc = spawn('cpulimit', ['-p', String(pid), '-l', String(cpulimitVal), '-z'], {
+        stdio: 'ignore', detached: true
+      });
+      cpulimitProc.unref();
+      resourceConfig._cpulimitPid = cpulimitProc.pid;
+      log('resource: cpulimit attached (pid=' + pid + ', limit=' + resourceConfig.cpuPercent + '%, cpulimit=' + cpulimitVal + ')');
+    } catch (_) {
+      // No cpulimit — try cgroup v2
+      try {
+        const cgroupDir = '/sys/fs/cgroup/claudefix-' + pid;
+        if (fs.existsSync('/sys/fs/cgroup/cgroup.controllers')) {
+          fs.mkdirSync(cgroupDir, { recursive: true });
+          const quota = resourceConfig.cpuPercent * 1000;
+          fs.writeFileSync(cgroupDir + '/cpu.max', quota + ' 100000');
+          fs.writeFileSync(cgroupDir + '/cgroup.procs', String(pid));
+          log('resource: cgroup v2 attached (cpu=' + resourceConfig.cpuPercent + '%)');
+        }
+      } catch (_cgErr) {
+        // Fallback: renice
+        try {
+          const niceVal = Math.max(0, Math.min(19, Math.floor(19 * (1 - resourceConfig.cpuPercent / 100))));
+          execSync('renice ' + niceVal + ' -p ' + pid + ' 2>/dev/null', { stdio: 'pipe' });
+          log('resource: renice applied (nice=' + niceVal + ')');
+        } catch (_) {}
+      }
+    }
+  }
+
+  // --- Periodic forced GC ---
+  resourceConfig._gcIntervalId = setInterval(() => {
+    try {
+      if (global.gc) {
+        global.gc();
+        log('resource: forced GC');
+      }
+    } catch (_) {}
+  }, resourceConfig.gcIntervalMs);
+  if (resourceConfig._gcIntervalId && resourceConfig._gcIntervalId.unref) {
+    resourceConfig._gcIntervalId.unref();
+  }
+
+  // --- RAM monitoring ---
+  resourceConfig._intervalId = setInterval(() => {
+    try {
+      const mem = process.memoryUsage();
+      const rssMB = Math.round(mem.rss / 1048576);
+      const heapMB = Math.round(mem.heapUsed / 1048576);
+
+      if (rssMB > CRITICAL_THRESHOLD_MB) {
+        log('resource: CRITICAL RAM ' + rssMB + 'MB (heap=' + heapMB + 'MB) exceeds ' + CRITICAL_THRESHOLD_MB + 'MB');
+        if (global.gc) global.gc();
+      } else if (rssMB > WARN_THRESHOLD_MB) {
+        log('resource: WARNING RAM ' + rssMB + 'MB approaching limit ' + MAX_HEAP_MB + 'MB');
+      }
+    } catch (_) {}
+  }, resourceConfig.checkIntervalMs);
+  if (resourceConfig._intervalId && resourceConfig._intervalId.unref) {
+    resourceConfig._intervalId.unref();
+  }
+}
+
+function cleanupResourceLimiter() {
+  if (resourceConfig._intervalId) {
+    clearInterval(resourceConfig._intervalId);
+    resourceConfig._intervalId = null;
+  }
+  if (resourceConfig._gcIntervalId) {
+    clearInterval(resourceConfig._gcIntervalId);
+    resourceConfig._gcIntervalId = null;
+  }
+  if (resourceConfig._cpulimitPid) {
+    try { process.kill(resourceConfig._cpulimitPid); } catch (_) {}
+    resourceConfig._cpulimitPid = null;
+  }
+}
+
 // state tracking
 let renderCount = 0;
 let lastResizeTime = 0;
@@ -117,7 +273,7 @@ let clearIntervalId = null;
 
 function log(...args) {
   if (config.debug) {
-    process.stderr.write('[terminal-fix] ' + args.join(' ') + '\n');
+    process.stderr.write('[claudefix] ' + args.join(' ') + '\n');
   }
 }
 
@@ -128,85 +284,79 @@ function log(...args) {
  * fixes VTE rendering glitches where BG colors overlay text
  */
 function stripBackgroundColors(chunk) {
-  if (typeof chunk !== 'string') return chunk;
-
-  let result = chunk;
+  let str = typeof chunk === 'string' ? chunk : chunk.toString();
 
-  // first pass: strip simple bg patterns
+  // first pass: strip simple standalone sequences
   for (const pattern of ANSI_BG_PATTERNS) {
-    result = result.replace(pattern, '');
+    str = str.replace(pattern, '');
   }
 
-  // second pass: handle compound sequences like \x1b[0;48;5;236m
-  result = stripCompoundBgCodes(result);
+  // second pass: strip compound sequences
+  str = stripCompoundBgCodes(str);
 
-  // cleanup: remove empty/malformed sequences
-  result = result.replace(/\x1b\[;*m/g, '\x1b[0m'); // \x1b[;m -> \x1b[0m
-  result = result.replace(/\x1b\[m/g, '\x1b[0m');   // \x1b[m -> \x1b[0m
-
-  return result;
+  return str;
 }
 
 /**
- * check if user is actively typing (within cooldown window)
+ * check if user is currently typing (within cooldown period)
  */
 function isTypingActive() {
   return (Date.now() - lastTypingTime) < config.typingCooldownMs;
 }
 
 /**
- * detect if this looks like a stdin echo (single printable char or short sequence)
- * stdin echoes are typically: single chars, backspace sequences, arrow key echoes
+ * detect if a write is an stdin echo (user typing)
+ * these are typically single chars or short sequences
  */
 function isStdinEcho(chunk) {
-  // single printable character (including space)
-  if (chunk.length === 1 && chunk.charCodeAt(0) >= 32 && chunk.charCodeAt(0) <= 126) {
-    return true;
-  }
-  // backspace/delete echo (usually 1-3 chars with control codes)
-  if (chunk.length <= 4 && (chunk.includes('\b') || chunk.includes('\x7f'))) {
-    return true;
-  }
-  // arrow key echo or cursor movement (short escape sequences)
-  if (chunk.length <= 6 && chunk.startsWith('\x1b[') && !chunk.includes('J') && !chunk.includes('H')) {
-    return true;
-  }
-  // enter/newline
-  if (chunk === '\n' || chunk === '\r' || chunk === '\r\n') {
-    return true;
-  }
+  if (typeof chunk !== 'string') return false;
+  const len = chunk.length;
+
+  // single printable char = definitely typing
+  if (len === 1 && chunk.charCodeAt(0) >= 32) return true;
+
+  // newline/carriage return = enter key
+  if (len === 1 && (chunk === '\n' || chunk === '\r')) return true;
+
+  // backspace sequences
+  if (chunk === '\b \b' || chunk === '\x7f') return true;
+
+  // short escape sequences (arrow keys, etc)
+  if (len <= 4 && chunk.startsWith('\x1b[')) return true;
+
+  // tab completion results are usually short
+  if (len <= 20 && !chunk.includes('\n') && !chunk.includes('\x1b[')) return true;
+
   return false;
 }
 
 /**
- * safe clear - defers if typing active
+ * safely clear scrollback without disrupting display
+ * uses save/restore cursor and waits for non-typing moment
  */
 function safeClearScrollback() {
+  if (!originalWrite) return;
+
+  // don't clear during typing
   if (isTypingActive()) {
-    if (!pendingClear) {
-      pendingClear = true;
-      log('deferring clear - typing active');
-      setTimeout(() => {
-        pendingClear = false;
-        if (!isTypingActive()) {
-          safeClearScrollback();
-        }
-      }, config.typingCooldownMs);
-    }
+    pendingClear = true;
     return;
   }
 
-  if (originalWrite && process.stdout.isTTY) {
-    // use setImmediate to not block the event loop
-    setImmediate(() => {
-      log('executing deferred scrollback clear');
-      originalWrite(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
-    });
+  try {
+    // save cursor, clear scrollback, restore cursor
+    // this prevents the "jump to top" glitch
+    originalWrite(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
+    renderCount = 0;
+    pendingClear = false;
+    log('scrollback cleared (periodic)');
+  } catch (e) {
+    // stdout might be destroyed
   }
 }
 
 /**
- * installs the fix - hooks into stdout and sigwinch
+ * install the fix
  * call this once at startup, calling again is a no-op
  */
 function install() {
@@ -215,11 +365,8 @@ function install() {
     return;
   }
 
-  // only run on supported terminals
-  if (!isTerminalSupported()) {
-    log('terminal not supported: ' + (process.env.TERM || 'unknown') + ' - skipping install');
-    return;
-  }
+  // Resource limiting — cap CPU & RAM based on user config
+  installResourceLimiter();
 
   originalWrite = process.stdout.write.bind(process.stdout);
 
@@ -241,117 +388,112 @@ function install() {
         return originalWrite(chunk, encoding, callback);
       }
 
-      renderCount++;
-
-      // strip colors that cause VTE rendering glitches
-      if (config.stripBgColors) {
+      // strip background colors if enabled
+      if (config.stripBgColors || config.stripColors) {
         chunk = stripBackgroundColors(chunk);
       }
+    }
 
-      // ink clears screen before re-render, we piggyback on that
-      // but only if not actively typing
-      if (chunk.includes(CLEAR_SCREEN) || chunk.includes(HOME_CURSOR)) {
-        if (config.clearAfterRenders > 0 && renderCount >= config.clearAfterRenders) {
-          if (!isTypingActive()) {
-            log('clearing scrollback after ' + renderCount + ' renders');
-            renderCount = 0;
-            chunk = CLEAR_SCROLLBACK + chunk;
-          } else {
-            log('skipping render-based clear - typing active');
-          }
-        }
-      }
+    renderCount++;
 
-      // /clear command should actually clear everything (immediate, user-requested)
-      if (chunk.includes('Conversation cleared') || chunk.includes('Chat cleared')) {
-        log('/clear detected, nuking scrollback');
-        chunk = CLEAR_SCROLLBACK + chunk;
-      }
+    // check if we should clear scrollback
+    if (renderCount >= config.clearAfterRenders && !isTypingActive()) {
+      setImmediate(safeClearScrollback);
     }
 
     return originalWrite(chunk, encoding, callback);
   };
 
-  // debounce resize events - tmux users know the pain
-  installResizeDebounce();
+  // periodic scrollback clearing
+  clearIntervalId = setInterval(() => {
+    if (pendingClear || renderCount > 100) {
+      setImmediate(safeClearScrollback);
+    }
+  }, config.periodicClearMs);
 
-  // periodic cleanup so long sessions dont get cooked
-  // uses safeClearScrollback which respects typing activity
-  if (config.periodicClearMs > 0) {
-    clearIntervalId = setInterval(() => {
-      log('periodic clear check');
-      safeClearScrollback();
-    }, config.periodicClearMs);
+  // don't let the interval keep the process alive
+  if (clearIntervalId && clearIntervalId.unref) {
+    clearIntervalId.unref();
   }
 
+  // install resize debouncing
+  installResizeDebounce();
+
   installed = true;
-  const mode = config.stripBgColors ? 'bg+dim colors stripped' : 'all colors preserved';
-  log('installed successfully - v2.3.1 - ' + mode + ' - TERM=' + process.env.TERM);
+  log('installed (periodic=' + config.periodicClearMs + 'ms, renders=' + config.clearAfterRenders +
+      ', heap=' + MAX_HEAP_MB + 'MB, cpu=' + (resourceConfig.cpuPercent || 'unlimited') + ')');
 }
 
+/**
+ * debounce SIGWINCH events
+ * tmux/screen fire these like crazy during resize
+ */
 function installResizeDebounce() {
-  const originalOn = process.on.bind(process);
-  let sigwinchHandlers = [];
+  const originalListeners = process.listeners('SIGWINCH');
 
   function debouncedSigwinch() {
     const now = Date.now();
-    const timeSince = now - lastResizeTime;
-    lastResizeTime = now;
-
-    if (resizeTimeout) clearTimeout(resizeTimeout);
-
-    // if events coming too fast, batch em
-    if (timeSince < config.resizeDebounceMs) {
+    if (now - lastResizeTime < config.resizeDebounceMs) {
+      // too fast, schedule for later
+      clearTimeout(resizeTimeout);
       resizeTimeout = setTimeout(() => {
-        log('firing debounced resize');
-        sigwinchHandlers.forEach(h => { try { h(); } catch(e) {} });
+        lastResizeTime = Date.now();
+        for (const listener of originalListeners) {
+          listener();
+        }
       }, config.resizeDebounceMs);
-    } else {
-      sigwinchHandlers.forEach(h => { try { h(); } catch(e) {} });
+      return;
+    }
+    lastResizeTime = now;
+    for (const listener of originalListeners) {
+      listener();
     }
   }
 
+  // replace SIGWINCH handler
+  process.removeAllListeners('SIGWINCH');
+  process.on('SIGWINCH', debouncedSigwinch);
+
+  // intercept future .on('SIGWINCH') calls
+  const origOn = process.on.bind(process);
   process.on = function(event, handler) {
     if (event === 'SIGWINCH') {
-      sigwinchHandlers.push(handler);
-      if (sigwinchHandlers.length === 1) {
-        originalOn('SIGWINCH', debouncedSigwinch);
-      }
-      return this;
+      originalListeners.push(handler);
+      return process;
     }
-    return originalOn(event, handler);
+    return origOn(event, handler);
   };
-
-  log('resize debounce installed');
 }
 
 /**
- * manually clear scrollback - call this whenever you want
+ * manually clear scrollback (e.g., on /clear command)
  */
 function clearScrollback() {
   if (originalWrite) {
-    originalWrite(CLEAR_SCROLLBACK);
-  } else {
-    process.stdout.write(CLEAR_SCROLLBACK);
+    originalWrite(CLEAR_SCREEN + HOME_CURSOR + CLEAR_SCROLLBACK);
+    renderCount = 0;
+    log('scrollback cleared (manual)');
   }
-  log('manual scrollback clear');
 }
 
 /**
- * get current stats for debugging
+ * get stats about the fix
  */
 function getStats() {
   return {
+    installed,
     renderCount,
     lastResizeTime,
-    installed,
-    config
+    config: { ...config },
+    resourceLimits: {
+      maxHeapMB: MAX_HEAP_MB,
+      memPercent: resourceConfig.memPercent,
+      cpuPercent: resourceConfig.cpuPercent,
+      totalMemMB: TOTAL_MEM_MB,
+    }
   };
 }
 
-/**
- * update config at runtime
- */
 function setConfig(key, value) {
   if (key in config) {
     config[key] = value;
@@ -365,6 +507,7 @@ function setConfig(key, value) {
 function disable() {
   if (originalWrite) {
     process.stdout.write = originalWrite;
+    cleanupResourceLimiter();
     log('disabled');
   }
 }
@@ -376,5 +519,7 @@ module.exports = {
   setConfig,
   disable,
   stripColors: stripBackgroundColors,
-  config
+  config,
+  resourceConfig,
+  MAX_HEAP_MB
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claudefix",
-  "version": "2.6.1",
-  "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",
+  "version": "2.7.0",
+  "description": "Fixes screen glitching, blocky colors, memory leaks AND resource hogging in Claude Code CLI on Linux and macOS. V8 heap capping (--max-old-space-size), forced GC (--expose-gc), CPU limiting (cpulimit/cgroup/nice), RAM monitoring. All configurable via ~/.claudefix.json or env vars. Developed by Hardwick Software Services @ https://justcalljon.pro",
   "main": "index.cjs",
   "bin": {
     "claude-fixed": "bin/claude-fixed.js",