scripter-x 1.0.33 → 1.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripter-x",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "description": "ScripterX — local Flipkart session extractor (runs on your residential IP, syncs to marthunt)",
   "type": "module",
   "bin": {

package/src/update.js

@@ -48,44 +48,86 @@ export async function runUpdate() {
   }
 }
 
+// Hard-reset the terminal so the freshly-spawned child inherits a CLEAN, cooked TTY.
+//
+// THE BUG this fixes: after the old ink app unmounts, the terminal could still be left in
+// raw mode WITH SGR mouse tracking enabled (`\x1b[?1000h…`). When the restarted process
+// took over that same TTY, every keypress/click emitted raw escape/coordinate codes that
+// got echoed as garbage ("random shit on every keypress") until the user killed + relaunched
+// manually. ink's alt-screen restore only ran on `process.on('exit')` AND the old + new
+// processes briefly shared the TTY, so the disable sequences raced the child's re-enable.
+//
+// Fix: synchronously (1) disable ALL mouse modes + restore the screen, (2) take stdin out of
+// raw mode, pause it, and drop every listener — BEFORE the child is spawned — so there is no
+// window where mouse reporting or a stray raw-mode listener can corrupt the child's input.
+function resetTerminal() {
+  try {
+    if (process.stdout.isTTY) {
+      // disable button/motion/SGR mouse modes (the source of the coordinate-code garbage)
+      process.stdout.write('\x1b[?1000l\x1b[?1003l\x1b[?1006l');
+      process.stdout.write('\x1b[?25h');     // show cursor
+      process.stdout.write('\x1b[?1049l');   // leave alt-screen → normal buffer
+    }
+  } catch { /* */ }
+  try {
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+      process.stdin.setRawMode(false); // back to cooked/canonical mode
+    }
+    // drop every data/keypress listener the old ink app (or our mouse hook) attached, then
+    // pause so nothing in THIS process consumes input meant for the child.
+    process.stdin.removeAllListeners('data');
+    process.stdin.removeAllListeners('keypress');
+    process.stdin.pause();
+  } catch { /* */ }
+}
+
 // Re-exec the CLI so the just-installed version takes over. Spawns a fresh, DETACHED
 // process that inherits this terminal, then exits the current one. The caller MUST have
-// already torn down the ink/alt-screen UI (so the terminal is restored) before calling
-// this — otherwise the child renders over a dirty screen.
+// already torn down the ink/alt-screen UI before calling this.
 //
 // We re-run the CURRENT entry file with node (`process.argv[1]`): after `npm install -g`,
 // the global bin symlink points at the new version, so this loads the updated code. If
 // that entry path is somehow missing, we fall back to the `scripterx` bin on PATH.
 //
+// ORDERING is what makes the restart clean: we resetTerminal() FIRST (cooked TTY, mouse off,
+// stdin drained), THEN spawn the child, THEN exit immediately on the next tick. The child
+// only sets up raw mode / mouse tracking after it boots — by which point the parent is gone,
+// so the two never fight over the TTY. No more leaked keystrokes.
+//
 // NOTE: on success it exits the process and never returns. Returns false only if BOTH
 // spawn attempts throw synchronously, so the caller can show "restart manually".
-export function restartCli({ binName = 'scripterx', delayMs = 150 } = {}) {
+export function restartCli({ binName = 'scripterx' } = {}) {
   // Re-run with the SAME args the user launched with (drop node + the script path), so
   // `scripterx` → interactive shell, `scripterx zepto` → zepto, etc.
   const argv = process.argv.slice(2);
   const entry = process.argv[1];
 
+  // Clean the terminal BEFORE spawning so the child never inherits raw mode / mouse mode.
+  resetTerminal();
+
   const trySpawn = (cmd, args) => {
     const child = spawn(cmd, args, { stdio: 'inherit', detached: true, shell: false });
     child.unref();
     return child;
   };
 
+  const exitSoon = () => {
+    // Exit on the next tick (not after a long timer) so we don't linger on the TTY. The
+    // detached child has already inherited the (now clean) fds and takes over.
+    setImmediate(() => process.exit(0));
+  };
+
   try {
     const primary = trySpawn(process.execPath, [entry, ...argv]);
-    // If the entry re-exec fails to even start, fall back to the named bin on PATH.
     primary.on('error', () => {
       try { trySpawn(binName, argv); } catch { /* nothing more we can do */ }
     });
-    // Exit the old process; its `process.on('exit', restore)` cleans the terminal and the
-    // detached child takes over the same TTY running the new version.
-    setTimeout(() => process.exit(0), delayMs);
+    exitSoon();
     return true;
   } catch {
-    // process.execPath spawn threw synchronously — try the named bin directly.
     try {
       trySpawn(binName, argv);
-      setTimeout(() => process.exit(0), delayMs);
+      exitSoon();
       return true;
     } catch {
       return false;