claudefix 2.6.2 → 2.7.0

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.2",
-  "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",