claudescreenfix-hardwicksoftware 2.0.0 → 2.1.0

package/bin/claude-fixed.js

@@ -2,44 +2,226 @@
 'use strict';
 
 /**
- * wrapper script - runs claude with the terminal fix loaded
+ * PTY wrapper for Claude Code terminal fix
  *
- * finds your claude binary and runs it with our fix injected
- * you don't need any manual setup, just run claude-fixed instead of claude
- * it'll handle the rest
+ * Since Claude's binary is a Node.js SEA (ELF), we can't inject via --import.
+ * Instead, we spawn claude in a pseudo-terminal and intercept stdout to inject
+ * scrollback clears and handle SIGWINCH debouncing.
  */
 
-const { spawn, execSync } = require('child_process');
+const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// find the loader path - it's in the parent dir
-const loaderPath = path.join(__dirname, '..', 'loader.cjs');
+// Terminal escape codes
+const CLEAR_SCROLLBACK = '\x1b[3J';
+const CURSOR_SAVE = '\x1b[s';
+const CURSOR_RESTORE = '\x1b[u';
+const CLEAR_SCREEN = '\x1b[2J';
+const HOME_CURSOR = '\x1b[H';
 
-if (!fs.existsSync(loaderPath)) {
-  console.error('loader not found at ' + loaderPath);
-  process.exit(1);
+// Config
+const config = {
+  resizeDebounceMs: 150,
+  periodicClearMs: 60000,
+  clearAfterRenders: 500,
+  typingCooldownMs: 500,
+  maxLineCount: 120,
+  debug: process.env.CLAUDE_TERMINAL_FIX_DEBUG === '1',
+  disabled: process.env.CLAUDE_TERMINAL_FIX_DISABLED === '1'
+};
+
+// State
+let renderCount = 0;
+let lineCount = 0;
+let lastTypingTime = 0;
+let lastResizeTime = 0;
+let resizeTimeout = null;
+
+function log(...args) {
+  if (config.debug) {
+    process.stderr.write('[terminal-fix] ' + args.join(' ') + '\n');
+  }
 }
 
-// find claude binary
-let claudeBin;
-try {
-  claudeBin = execSync('which claude', { encoding: 'utf8' }).trim();
-} catch (e) {
-  console.error('claude not found in PATH - make sure it\'s installed');
-  process.exit(1);
+function isTypingActive() {
+  return (Date.now() - lastTypingTime) < config.typingCooldownMs;
 }
 
-// run claude with our fix loaded via NODE_OPTIONS - it's the cleanest way
-const env = Object.assign({}, process.env, {
-  NODE_OPTIONS: '--require ' + loaderPath + ' ' + (process.env.NODE_OPTIONS || '')
-});
+// Find the claude binary
+function findClaude() {
+  const possiblePaths = [
+    path.join(process.env.HOME || '', '.local/bin/claude'),
+    '/usr/local/bin/claude',
+    '/usr/bin/claude'
+  ];
 
-const child = spawn(claudeBin, process.argv.slice(2), {
-  stdio: 'inherit',
-  env: env
-});
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      return p;
+    }
+  }
+
+  // Try which
+  try {
+    const { execSync } = require('child_process');
+    return execSync('which claude', { encoding: 'utf8' }).trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+// Process output chunk, injecting clears as needed
+function processOutput(chunk) {
+  if (config.disabled) return chunk;
+
+  let output = chunk;
+  const str = chunk.toString();
+
+  renderCount++;
+
+  // Count newlines
+  const newlines = (str.match(/\n/g) || []).length;
+  lineCount += newlines;
+
+  // Line limit exceeded - force clear
+  if (lineCount > config.maxLineCount) {
+    log('line limit exceeded (' + lineCount + '), forcing clear');
+    lineCount = 0;
+    output = CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE + output;
+  }
+
+  // Screen clear detected - piggyback our scrollback clear
+  if (str.includes(CLEAR_SCREEN) || str.includes(HOME_CURSOR)) {
+    lineCount = 0;
+    if (config.clearAfterRenders > 0 && renderCount >= config.clearAfterRenders) {
+      if (!isTypingActive()) {
+        log('clearing after ' + renderCount + ' renders');
+        renderCount = 0;
+        output = CLEAR_SCROLLBACK + output;
+      }
+    }
+  }
+
+  // /clear command - nuke everything
+  if (str.includes('Conversation cleared') || str.includes('Chat cleared')) {
+    log('/clear detected');
+    lineCount = 0;
+    output = CLEAR_SCROLLBACK + output;
+  }
+
+  return output;
+}
+
+// Main
+async function main() {
+  if (config.disabled) {
+    log('disabled via env');
+  }
 
-child.on('exit', (code) => {
-  process.exit(code || 0);
+  const claudePath = findClaude();
+  if (!claudePath) {
+    console.error('claude not found in PATH');
+    process.exit(1);
+  }
+
+  log('using claude at: ' + claudePath);
+  log('fix enabled, config:', JSON.stringify(config));
+
+  // Try to use node-pty for proper PTY support
+  let pty;
+  try {
+    pty = require('node-pty');
+  } catch (e) {
+    // Fall back to basic spawn with pipe
+    log('node-pty not available, using basic spawn');
+    pty = null;
+  }
+
+  if (pty && process.stdin.isTTY) {
+    // PTY mode - full terminal emulation
+    const term = pty.spawn(claudePath, process.argv.slice(2), {
+      name: process.env.TERM || 'xterm-256color',
+      cols: process.stdout.columns || 80,
+      rows: process.stdout.rows || 24,
+      cwd: process.cwd(),
+      env: process.env
+    });
+
+    // Handle resize with debounce
+    process.stdout.on('resize', () => {
+      const now = Date.now();
+      if (resizeTimeout) clearTimeout(resizeTimeout);
+
+      if (now - lastResizeTime < config.resizeDebounceMs) {
+        resizeTimeout = setTimeout(() => {
+          log('debounced resize');
+          term.resize(process.stdout.columns, process.stdout.rows);
+        }, config.resizeDebounceMs);
+      } else {
+        term.resize(process.stdout.columns, process.stdout.rows);
+      }
+      lastResizeTime = now;
+    });
+
+    // Track typing
+    process.stdin.on('data', (data) => {
+      lastTypingTime = Date.now();
+      term.write(data);
+    });
+
+    // Process output
+    term.onData((data) => {
+      const processed = processOutput(data);
+      process.stdout.write(processed);
+    });
+
+    term.onExit(({ exitCode }) => {
+      process.exit(exitCode);
+    });
+
+    // Raw mode for proper terminal handling
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    // Periodic clear
+    if (config.periodicClearMs > 0) {
+      setInterval(() => {
+        if (!isTypingActive()) {
+          log('periodic clear');
+          process.stdout.write(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
+        }
+      }, config.periodicClearMs);
+    }
+
+  } else {
+    // Basic mode - just spawn and pipe (limited fix capability)
+    log('basic mode (no PTY)');
+
+    const child = spawn(claudePath, process.argv.slice(2), {
+      stdio: ['inherit', 'pipe', 'inherit'],
+      env: process.env
+    });
+
+    child.stdout.on('data', (data) => {
+      const processed = processOutput(data);
+      process.stdout.write(processed);
+    });
+
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+
+    // Track typing via stdin
+    process.stdin.on('data', () => {
+      lastTypingTime = Date.now();
+    });
+  }
+}
+
+main().catch(err => {
+  console.error('terminal fix error:', err.message);
+  process.exit(1);
 });

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "claudescreenfix-hardwicksoftware",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "fixes the scroll glitch in claude code cli - now with GLITCH DETECTION, 120-line limit enforcement, and auto-recovery",
   "main": "index.cjs",
   "bin": {
     "claude-fixed": "./bin/claude-fixed.js"
   },
   "scripts": {
-    "test": "node -e \"const fix = require('./index.cjs'); fix.install(); console.log(fix.getStats());\""
+    "test": "node bin/claude-fixed.js --version",
+    "test-lib": "node -e \"const fix = require('./index.cjs'); fix.install(); console.log(fix.getStats());\""
   },
   "keywords": [
     "claude",
@@ -41,5 +42,8 @@
     "bin/",
     "README.md",
     "LICENSE"
-  ]
+  ],
+  "dependencies": {
+    "node-pty": "^1.1.0"
+  }
 }