scripter-x 1.0.36 → 1.0.38

package/package.json

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

package/src/update.js

@@ -121,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;