scripter-x 1.0.35 → 1.0.38

package/package.json

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

package/src/ui/fullscreen.js

@@ -37,6 +37,9 @@ export function FullScreen({ children }) {
 // We register restore on exit + the kill signals so it runs no matter how we leave.
 export function enterAltScreen() {
   process.stdout.write('\x1b[?1049h'); // switch to alternate buffer
+  process.stdout.write('\x1b[r');        // reset scroll region to full screen (in case a prior
+                                         // session — e.g. an update-restart — left DECSTBM set,
+                                         // which would push our output to the bottom of the screen)
   process.stdout.write('\x1b[2J\x1b[H'); // clear + home
   process.stdout.write('\x1b[?25l');     // hide cursor (we draw our own ▏)
   let restored = false;
@@ -44,7 +47,10 @@ export function enterAltScreen() {
     if (restored) return;
     restored = true;
     try {
-      process.stdout.write('\x1b[?1000l\x1b[?1003l\x1b[?1006l'); // disable ALL mouse modes
+      process.stdout.write('\x1b[?1000l\x1b[?1003l\x1b[?1006l\x1b[?1015l'); // disable ALL mouse modes
+      process.stdout.write('\x1b[?2004l');  // disable bracketed-paste
+      process.stdout.write('\x1b[r');       // reset scroll region (so typed text isn't stuck at the bottom)
+      process.stdout.write('\x1b[?7h');     // restore line wrap
       process.stdout.write('\x1b[?25h');    // show cursor
       process.stdout.write('\x1b[?1049l');   // back to normal buffer (history intact)
     } catch { /* */ }

package/src/update.js

@@ -95,10 +95,18 @@ function npmCliPath() {
 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
+      // Order matters. We must undo EVERY terminal mode the ink/fullscreen UI set, not just
+      // mouse + alt-screen — a leftover scroll region (DECSTBM) or bracketed-paste mode makes
+      // typed characters land at the bottom of the screen instead of at the prompt.
+      const w = (s) => process.stdout.write(s);
+      w('\x1b[?1000l\x1b[?1003l\x1b[?1006l\x1b[?1015l'); // disable ALL mouse modes
+      w('\x1b[?2004l');        // disable bracketed-paste mode
+      w('\x1b[r');             // reset scroll region (DECSTBM) to the full screen  ← the bottom-text fix
+      w('\x1b[?7h');           // re-enable line wrap (autowrap)
+      w('\x1b[0m');            // reset SGR (colors/attrs)
+      w('\x1b[?1049l');        // leave alt-screen → normal buffer (history intact)
+      w('\x1b[?25h');          // show cursor
+      w('\x1b[!p');            // DECSTR: soft terminal reset (restores sane default modes)
     }
   } catch { /* */ }
   try {
@@ -113,53 +121,55 @@ function resetTerminal() {
   } 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 before calling this.
+// Re-exec the CLI so the just-installed version takes over, keeping the SAME controlling
+// terminal so input goes to the new process — not back to the shell.
 //
-// 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.
+// THE BUG this fixes: the old code spawned the child with `detached:true` + `child.unref()`,
+// which puts the child in its OWN session and RELINQUISHES the controlling TTY. The child
+// then can't be the foreground job, so the user's shell (zsh) stays in the foreground and
+// echoes every keystroke at the bottom of the screen, while the orphaned child renders the
+// banner in the background. That's exactly the "typing shows at the bottom" symptom.
 //
-// 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.
+// Correct pattern for a TTY hand-off: spawn the child ATTACHED (not detached, no unref) with
+// inherited stdio, and keep THIS process alive as its parent until it exits, then mirror its
+// exit code. The child is a normal foreground job sharing our controlling terminal, so it
+// owns stdin and raw mode works. We reset the terminal first so it boots onto a clean screen.
 //
-// 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".
+// 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 missing we fall back to the `scripterx` bin on PATH.
+//
+// NOTE: on success this never returns (it waits, then process.exit mirrors the child). Returns
+// false only if BOTH spawn attempts throw synchronously.
 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.
+  // Clean the terminal BEFORE spawning so the child boots onto a clean, cooked screen.
   resetTerminal();
 
-  const trySpawn = (cmd, args) => {
-    const child = spawn(cmd, args, { stdio: 'inherit', detached: true, shell: false });
-    child.unref();
-    return child;
-  };
+  // ATTACHED spawn: child shares our controlling TTY and becomes the foreground job. We keep
+  // running as its parent and exit with its code when it finishes — so the shell prompt only
+  // returns after the (new) CLI actually quits.
+  const trySpawn = (cmd, args) => spawn(cmd, args, { stdio: 'inherit', shell: false });
 
-  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));
+  const supervise = (child) => {
+    child.on('exit', (code, signal) => {
+      if (signal) { try { process.kill(process.pid, signal); } catch { process.exit(1); } }
+      else process.exit(code == null ? 0 : code);
+    });
   };
 
   try {
     const primary = trySpawn(process.execPath, [entry, ...argv]);
     primary.on('error', () => {
-      try { trySpawn(binName, argv); } catch { /* nothing more we can do */ }
+      try { supervise(trySpawn(binName, argv)); } catch { process.exit(1); }
     });
-    exitSoon();
+    supervise(primary);
     return true;
   } catch {
     try {
-      trySpawn(binName, argv);
-      exitSoon();
+      supervise(trySpawn(binName, argv));
       return true;
     } catch {
       return false;