@amr-m-abdelgawad/devctl 0.8.1 → 0.10.0

package/bin/devctl.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 
-const { closeSync, openSync, readSync } = require("fs");
+const { closeSync, openSync, readSync, writeSync } = require("fs");
 const { resolve } = require("path");
 const { spawn } = require("child_process");
 
@@ -103,6 +103,55 @@ function launch(options) {
   });
 }
 
+// Mirror of TERMINAL_RESTORE_SEQUENCE in app/src/shared/terminal-restore.ts.
+// This launcher is a standalone .cjs that cannot import the app's TypeScript,
+// so the escape sequence is duplicated and kept in sync by hand.
+const TERMINAL_RESTORE_SEQUENCE =
+  "\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1006l\x1b[?1015l\x1b[?1016l" +
+  "\x1b[?2004l\x1b[?1049l\x1b[?25h\x1b[<u\x1b[0m";
+
+// When the Bun child dies abnormally — a native panic exits via a fatal signal
+// (SIGSEGV/SIGABRT) or a non-zero code — OpenTUI never reached its own
+// destroy(), so the terminal is left in raw mode and on the alternate screen.
+// This parent process survives the child's crash, so it is the one place that
+// can still un-raw the inherited TTY. A clean exit (code 0, no signal) means
+// the TUI already restored the terminal itself, so we leave it alone.
+//
+// The bytes are written synchronously to the terminal file descriptors, not
+// through process.stdout.write: a TTY stream write is asynchronous on Windows,
+// and the caller re-raises the child's fatal signal immediately afterwards, so
+// an async write could be dropped when the self-signal kills the wrapper before
+// it flushes. writeSync hands the bytes to the OS before we return, mirroring
+// restoreTerminalModes() in app/src/shared/terminal-restore.ts.
+function restoreTerminalAfterCrash(code, signal, options) {
+  const crashed = Boolean(signal) || (typeof code === "number" && code !== 0);
+  if (!crashed) {
+    return false;
+  }
+  const opts = options !== undefined ? options : {};
+  const write = opts.write !== undefined ? opts.write : writeSync;
+  const targets =
+    opts.targets !== undefined
+      ? opts.targets
+      : [
+          { fd: 1, isTTY: Boolean(process.stdout && process.stdout.isTTY) },
+          { fd: 2, isTTY: Boolean(process.stderr && process.stderr.isTTY) },
+        ];
+  const buffer = Buffer.from(TERMINAL_RESTORE_SEQUENCE);
+  let wrote = false;
+  for (const target of targets) {
+    if (target && target.isTTY) {
+      try {
+        write(target.fd, buffer);
+        wrote = true;
+      } catch (_) {
+        // fd already closed
+      }
+    }
+  }
+  return wrote;
+}
+
 function preserveChildExit(hostProcess, code, signal) {
   if (typeof code === "number") {
     hostProcess.exitCode = code;
@@ -150,6 +199,7 @@ function runMain() {
     for (const [registeredSignal, handler] of handlers) {
       process.off(registeredSignal, handler);
     }
+    restoreTerminalAfterCrash(code, signal);
     preserveChildExit(process, code, signal);
   });
 }
@@ -164,6 +214,8 @@ module.exports = {
   assertSupportedTarget,
   launch,
   preserveChildExit,
+  restoreTerminalAfterCrash,
+  TERMINAL_RESTORE_SEQUENCE,
   readFilePrefix,
   resolveBunExecutable,
   targetFor,