claudefix 2.7.0 → 2.7.1

package/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * claudefix - stops the scroll glitch from cooking your terminal
+ * claudescreenfix-hardwicksoftware - stops the scroll glitch from cooking your terminal
  *
  * the problem:
  *   claude code uses ink (react for terminals) and it dont clear scrollback
@@ -13,8 +13,6 @@
  *   - 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
@@ -25,15 +23,7 @@
  *   - auto-detects Xvfb/VNC/headless environments
  *   - strips BACKGROUND colors that cause VTE rendering glitches
  *   - keeps foreground colors and spinners working perfectly
- *
- * 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
+ *   - your Zesting still zests, just no broken color blocks
  */
 
 
@@ -88,14 +78,21 @@ function stripCompoundBgCodes(str) {
 
 // supported terminals - only run fix on these
 const SUPPORTED_TERMINALS = [
-  '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)
+  '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',
 ];
 
+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
@@ -109,156 +106,82 @@ const config = {
 };
 
 // ============================================================================
-// RESOURCE LIMITER — Cap Claude's CPU & RAM usage
+// RESOURCE LIMITER — V8 heap cap, forced GC, CPU limiting
 // ============================================================================
-// 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'));
-    }
+    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,
-};
+const _userCfg = _loadUserConfig();
+const _totalMemMB = Math.floor(os.totalmem() / 1048576);
+const _memPct = parseInt(process.env.CLAUDEFIX_MEM_PERCENT || '', 10) || _userCfg.memPercent || 35;
+const _cpuPct = parseInt(process.env.CLAUDEFIX_CPU_PERCENT || process.env.CLAUDE_MAX_CPU || '', 10) || _userCfg.cpuPercent || 0;
+const MAX_HEAP_MB = parseInt(process.env.CLAUDE_MAX_RAM || '', 10) || Math.floor(_totalMemMB * Math.min(100, Math.max(1, _memPct)) / 100);
 
-// 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);
+const _resLimiter = { intervalId: null, gcId: null, cpulimitPid: null };
 
 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');
-    }
-  }
+  if (process.env.CLAUDE_RESOURCE_LIMIT === '0') return;
+  if (process.platform !== 'linux' && process.platform !== 'darwin') return;
 
-  // --- 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;
+  // V8 heap cap + expose GC for child processes
+  const opts = process.env.NODE_OPTIONS || '';
+  if (!opts.includes('--max-old-space-size')) {
+    process.env.NODE_OPTIONS = (opts + ' --max-old-space-size=' + MAX_HEAP_MB).trim();
+  }
+  if (!opts.includes('--expose-gc')) {
+    process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS + ' --expose-gc').trim();
+  }
 
+  // CPU limiting (only if configured > 0)
+  if (_cpuPct > 0 && process.platform === 'linux') {
+    const { execSync, spawn } = require('child_process');
+    const pid = process.pid;
+    const cores = os.cpus().length;
+    const cpulimitVal = Math.floor(_cpuPct * cores / 100) * 100 || _cpuPct;
     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 + ')');
+      const proc = spawn('cpulimit', ['-p', String(pid), '-l', String(cpulimitVal), '-z'], { stdio: 'ignore', detached: true });
+      proc.unref();
+      _resLimiter.cpulimitPid = proc.pid;
     } 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 (_) {}
-      }
+        const niceVal = Math.max(0, Math.min(19, Math.floor(19 * (1 - _cpuPct / 100))));
+        execSync('renice ' + niceVal + ' -p ' + process.pid + ' 2>/dev/null', { stdio: 'pipe' });
+      } 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();
-  }
+  // Periodic forced GC (every 60s)
+  _resLimiter.gcId = setInterval(() => {
+    try { if (global.gc) global.gc(); } catch (_) {}
+  }, 60000);
+  if (_resLimiter.gcId && _resLimiter.gcId.unref) _resLimiter.gcId.unref();
 
-  // --- RAM monitoring ---
-  resourceConfig._intervalId = setInterval(() => {
+  // RAM monitoring (every 30s)
+  const warnMB = Math.floor(MAX_HEAP_MB * 0.7);
+  const critMB = Math.floor(MAX_HEAP_MB * 0.9);
+  _resLimiter.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');
-      }
+      const rssMB = Math.round(process.memoryUsage().rss / 1048576);
+      if (rssMB > critMB && global.gc) global.gc();
     } catch (_) {}
-  }, resourceConfig.checkIntervalMs);
-  if (resourceConfig._intervalId && resourceConfig._intervalId.unref) {
-    resourceConfig._intervalId.unref();
-  }
+  }, 30000);
+  if (_resLimiter.intervalId && _resLimiter.intervalId.unref) _resLimiter.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;
-  }
+  if (_resLimiter.intervalId) { clearInterval(_resLimiter.intervalId); _resLimiter.intervalId = null; }
+  if (_resLimiter.gcId) { clearInterval(_resLimiter.gcId); _resLimiter.gcId = null; }
+  if (_resLimiter.cpulimitPid) { try { process.kill(_resLimiter.cpulimitPid); } catch (_) {} _resLimiter.cpulimitPid = null; }
 }
 
 // state tracking
@@ -273,7 +196,7 @@ let clearIntervalId = null;
 
 function log(...args) {
   if (config.debug) {
-    process.stderr.write('[claudefix] ' + args.join(' ') + '\n');
+    process.stderr.write('[terminal-fix] ' + args.join(' ') + '\n');
   }
 }
 
@@ -284,79 +207,85 @@ function log(...args) {
  * fixes VTE rendering glitches where BG colors overlay text
  */
 function stripBackgroundColors(chunk) {
-  let str = typeof chunk === 'string' ? chunk : chunk.toString();
+  if (typeof chunk !== 'string') return chunk;
 
-  // first pass: strip simple standalone sequences
+  let result = chunk;
+
+  // first pass: strip simple bg patterns
   for (const pattern of ANSI_BG_PATTERNS) {
-    str = str.replace(pattern, '');
+    result = result.replace(pattern, '');
   }
 
-  // second pass: strip compound sequences
-  str = stripCompoundBgCodes(str);
+  // second pass: handle compound sequences like \x1b[0;48;5;236m
+  result = stripCompoundBgCodes(result);
 
-  return 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;
 }
 
 /**
- * check if user is currently typing (within cooldown period)
+ * check if user is actively typing (within cooldown window)
  */
 function isTypingActive() {
   return (Date.now() - lastTypingTime) < config.typingCooldownMs;
 }
 
 /**
- * detect if a write is an stdin echo (user typing)
- * these are typically single chars or short sequences
+ * 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
  */
 function isStdinEcho(chunk) {
-  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;
-
+  // 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;
+  }
   return false;
 }
 
 /**
- * safely clear scrollback without disrupting display
- * uses save/restore cursor and waits for non-typing moment
+ * safe clear - defers if typing active
  */
 function safeClearScrollback() {
-  if (!originalWrite) return;
-
-  // don't clear during typing
   if (isTypingActive()) {
-    pendingClear = true;
+    if (!pendingClear) {
+      pendingClear = true;
+      log('deferring clear - typing active');
+      setTimeout(() => {
+        pendingClear = false;
+        if (!isTypingActive()) {
+          safeClearScrollback();
+        }
+      }, config.typingCooldownMs);
+    }
     return;
   }
 
-  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
+  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);
+    });
   }
 }
 
 /**
- * install the fix
+ * installs the fix - hooks into stdout and sigwinch
  * call this once at startup, calling again is a no-op
  */
 function install() {
@@ -365,7 +294,13 @@ function install() {
     return;
   }
 
-  // Resource limiting — cap CPU & RAM based on user config
+  // only run on supported terminals
+  if (!isTerminalSupported()) {
+    log('terminal not supported: ' + (process.env.TERM || 'unknown') + ' - skipping install');
+    return;
+  }
+
+  // Resource limiting — V8 heap cap, forced GC, CPU limit
   installResourceLimiter();
 
   originalWrite = process.stdout.write.bind(process.stdout);
@@ -388,112 +323,117 @@ function install() {
         return originalWrite(chunk, encoding, callback);
       }
 
-      // strip background colors if enabled
-      if (config.stripBgColors || config.stripColors) {
+      renderCount++;
+
+      // strip colors that cause VTE rendering glitches
+      if (config.stripBgColors) {
         chunk = stripBackgroundColors(chunk);
       }
-    }
 
-    renderCount++;
+      // 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');
+          }
+        }
+      }
 
-    // check if we should clear scrollback
-    if (renderCount >= config.clearAfterRenders && !isTypingActive()) {
-      setImmediate(safeClearScrollback);
+      // /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;
+      }
     }
 
     return originalWrite(chunk, encoding, callback);
   };
 
-  // periodic scrollback clearing
-  clearIntervalId = setInterval(() => {
-    if (pendingClear || renderCount > 100) {
-      setImmediate(safeClearScrollback);
-    }
-  }, config.periodicClearMs);
+  // debounce resize events - tmux users know the pain
+  installResizeDebounce();
 
-  // don't let the interval keep the process alive
-  if (clearIntervalId && clearIntervalId.unref) {
-    clearIntervalId.unref();
+  // 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);
   }
 
-  // install resize debouncing
-  installResizeDebounce();
-
   installed = true;
-  log('installed (periodic=' + config.periodicClearMs + 'ms, renders=' + config.clearAfterRenders +
-      ', heap=' + MAX_HEAP_MB + 'MB, cpu=' + (resourceConfig.cpuPercent || 'unlimited') + ')');
+  const mode = config.stripBgColors ? 'bg+dim colors stripped' : 'all colors preserved';
+  log('installed successfully - v2.3.1 - ' + mode + ' - TERM=' + process.env.TERM);
 }
 
-/**
- * debounce SIGWINCH events
- * tmux/screen fire these like crazy during resize
- */
 function installResizeDebounce() {
-  const originalListeners = process.listeners('SIGWINCH');
+  const originalOn = process.on.bind(process);
+  let sigwinchHandlers = [];
 
   function debouncedSigwinch() {
     const now = Date.now();
-    if (now - lastResizeTime < config.resizeDebounceMs) {
-      // too fast, schedule for later
-      clearTimeout(resizeTimeout);
+    const timeSince = now - lastResizeTime;
+    lastResizeTime = now;
+
+    if (resizeTimeout) clearTimeout(resizeTimeout);
+
+    // if events coming too fast, batch em
+    if (timeSince < config.resizeDebounceMs) {
       resizeTimeout = setTimeout(() => {
-        lastResizeTime = Date.now();
-        for (const listener of originalListeners) {
-          listener();
-        }
+        log('firing debounced resize');
+        sigwinchHandlers.forEach(h => { try { h(); } catch(e) {} });
       }, config.resizeDebounceMs);
-      return;
-    }
-    lastResizeTime = now;
-    for (const listener of originalListeners) {
-      listener();
+    } else {
+      sigwinchHandlers.forEach(h => { try { h(); } catch(e) {} });
     }
   }
 
-  // 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') {
-      originalListeners.push(handler);
-      return process;
+      sigwinchHandlers.push(handler);
+      if (sigwinchHandlers.length === 1) {
+        originalOn('SIGWINCH', debouncedSigwinch);
+      }
+      return this;
     }
-    return origOn(event, handler);
+    return originalOn(event, handler);
   };
+
+  log('resize debounce installed');
 }
 
 /**
- * manually clear scrollback (e.g., on /clear command)
+ * manually clear scrollback - call this whenever you want
  */
 function clearScrollback() {
   if (originalWrite) {
-    originalWrite(CLEAR_SCREEN + HOME_CURSOR + CLEAR_SCROLLBACK);
-    renderCount = 0;
-    log('scrollback cleared (manual)');
+    originalWrite(CLEAR_SCROLLBACK);
+  } else {
+    process.stdout.write(CLEAR_SCROLLBACK);
   }
+  log('manual scrollback clear');
 }
 
 /**
- * get stats about the fix
+ * get current stats for debugging
  */
 function getStats() {
   return {
-    installed,
     renderCount,
     lastResizeTime,
-    config: { ...config },
-    resourceLimits: {
-      maxHeapMB: MAX_HEAP_MB,
-      memPercent: resourceConfig.memPercent,
-      cpuPercent: resourceConfig.cpuPercent,
-      totalMemMB: TOTAL_MEM_MB,
-    }
+    installed,
+    config
   };
 }
 
+/**
+ * update config at runtime
+ */
 function setConfig(key, value) {
   if (key in config) {
     config[key] = value;
@@ -519,7 +459,5 @@ module.exports = {
   setConfig,
   disable,
   stripColors: stripBackgroundColors,
-  config,
-  resourceConfig,
-  MAX_HEAP_MB
+  config
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claudefix",
-  "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",
+  "version": "2.7.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",
   "main": "index.cjs",
   "bin": {
     "claude-fixed": "bin/claude-fixed.js",