claudescreenfix-hardwicksoftware 1.0.0 → 1.0.1

package/README.md

@@ -117,6 +117,22 @@ for resize events, we intercept `process.on('SIGWINCH', ...)` and debounce the h
 
 bottom line: smooth terminal, no lag, no memory bloat. it just works.
 
+## changelog
+
+### v1.0.1 (2025-01-08)
+- **FIXED: typing issue** - keystrokes were getting lost because the fix was intercepting stdin echoes
+  - now detects stdin echo writes (single chars, backspace, arrow keys) and passes them through unmodified
+  - added typing cooldown detection - clears are deferred during active typing
+  - periodic clears now use `setImmediate` to not block the event loop
+  - added stdin tracking to properly detect user input activity
+- new config option: `typingCooldownMs` (default 500ms) - how long to wait after typing before allowing clears
+
+### v1.0.0 (2025-01-08)
+- initial release
+- scrollback clearing after 500 renders or 60 seconds
+- SIGWINCH debouncing for tmux/screen users
+- enhanced /clear command to actually clear scrollback
+
 ## known issues
 
 - some old terminals don't support `\x1b[3J` but that's pretty rare nowadays

package/index.cjs

@@ -13,6 +13,11 @@
  *   - hook stdout.write to inject scrollback clears periodically
  *   - debounce SIGWINCH so resize aint thrashing
  *   - enhance /clear to actually clear scrollback not just the screen
+ *
+ * FIXED v1.0.1: typing issue where stdin echo was being intercepted
+ *   - now detects stdin echo writes and passes them through unmodified
+ *   - uses setImmediate for periodic clears to not interrupt typing
+ *   - tracks "active typing" window to defer clears during input
  */
 
 const CLEAR_SCROLLBACK = '\x1b[3J';
@@ -26,6 +31,7 @@ const config = {
   resizeDebounceMs: 150,        // how long to wait before firing resize
   periodicClearMs: 60000,       // clear scrollback every 60s
   clearAfterRenders: 500,       // or after 500 render cycles
+  typingCooldownMs: 500,        // wait this long after typing to clear
   debug: process.env.CLAUDE_TERMINAL_FIX_DEBUG === '1',
   disabled: process.env.CLAUDE_TERMINAL_FIX_DISABLED === '1'
 };
@@ -36,6 +42,9 @@ let lastResizeTime = 0;
 let resizeTimeout = null;
 let originalWrite = null;
 let installed = false;
+let lastTypingTime = 0;           // track when user last typed
+let pendingClear = false;         // defer clear if typing active
+let clearIntervalId = null;
 
 function log(...args) {
   if (config.debug) {
@@ -43,6 +52,64 @@ function log(...args) {
   }
 }
 
+/**
+ * check if user is actively typing (within cooldown window)
+ */
+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
+ */
+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;
+  }
+  return false;
+}
+
+/**
+ * safe clear - defers if typing active
+ */
+function safeClearScrollback() {
+  if (isTypingActive()) {
+    if (!pendingClear) {
+      pendingClear = true;
+      log('deferring clear - typing active');
+      setTimeout(() => {
+        pendingClear = false;
+        if (!isTypingActive()) {
+          safeClearScrollback();
+        }
+      }, config.typingCooldownMs);
+    }
+    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);
+    });
+  }
+}
+
 /**
  * installs the fix - hooks into stdout and sigwinch
  * call this once at startup, calling again is a no-op
@@ -55,21 +122,41 @@ function install() {
 
   originalWrite = process.stdout.write.bind(process.stdout);
 
+  // track stdin to know when user is typing
+  if (process.stdin.isTTY) {
+    process.stdin.on('data', () => {
+      lastTypingTime = Date.now();
+    });
+  }
+
   // hook stdout.write - this is where the magic happens
   process.stdout.write = function(chunk, encoding, callback) {
+    // CRITICAL FIX: pass stdin echoes through unmodified
+    // this prevents the typing issue where keystrokes get lost
     if (typeof chunk === 'string') {
+      // check if this is a stdin echo - if so, pass through immediately
+      if (isStdinEcho(chunk)) {
+        lastTypingTime = Date.now();  // update typing time
+        return originalWrite(chunk, encoding, callback);
+      }
+
       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) {
-          log('clearing scrollback after ' + renderCount + ' renders');
-          renderCount = 0;
-          chunk = CLEAR_SCROLLBACK + chunk;
+          if (!isTypingActive()) {
+            log('clearing scrollback after ' + renderCount + ' renders');
+            renderCount = 0;
+            chunk = CLEAR_SCROLLBACK + chunk;
+          } else {
+            log('skipping render-based clear - typing active');
+          }
         }
       }
 
-      // /clear command should actually clear everything
+      // /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;
@@ -83,17 +170,16 @@ function install() {
   installResizeDebounce();
 
   // periodic cleanup so long sessions dont get cooked
+  // uses safeClearScrollback which respects typing activity
   if (config.periodicClearMs > 0) {
-    setInterval(() => {
-      if (process.stdout.isTTY) {
-        log('periodic scrollback clear');
-        originalWrite(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
-      }
+    clearIntervalId = setInterval(() => {
+      log('periodic clear check');
+      safeClearScrollback();
     }, config.periodicClearMs);
   }
 
   installed = true;
-  log('installed successfully');
+  log('installed successfully - v1.0.1 with typing fix');
 }
 
 function installResizeDebounce() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudescreenfix-hardwicksoftware",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "fixes the scroll glitch in claude code cli - unbounded scrollback, resize thrashing, all that bs",
   "main": "index.cjs",
   "bin": {