@visual-z/xeno 0.2.0 → 0.3.0

package/src/apps/startup-input.ts

@@ -0,0 +1,130 @@
+/**
+ * Startup owns raw input until the renderer can (D20). Keystrokes typed while
+ * configuration loads are held as original bytes and handed to the next owner;
+ * only Ctrl+C outside a bracketed paste is interpreted here.
+ */
+
+type StartupStdin = Pick<NodeJS.ReadStream, "isTTY" | "isRaw" | "setRawMode" | "setEncoding" | "on" | "off" | "resume" | "pause" | "unshift">;
+export interface StartupInput {
+  phase(name: string): void;
+  /** Pause, restore the shell's mode and replay held bytes to the next input owner. */
+  handoff(): void;
+  /** Final cleanup discards unsubmitted input instead of leaking it to the shell. */
+  restore(): void;
+  runWithTerminal<T>(run: (handoff: () => void) => Promise<T>): Promise<T>;
+}
+
+export function createStartupInput(opts: {
+  interactive: boolean;
+  stdin?: StartupStdin;
+  signals?: NodeJS.EventEmitter;
+  report?: (message: string) => void;
+  exit?: (code: number) => void;
+}): StartupInput {
+  const stdin = opts.stdin ?? process.stdin;
+  if (!opts.interactive || stdin.isTTY !== true) return {
+    phase() {}, handoff() {}, restore() {}, runWithTerminal: run => run(() => {}),
+  };
+  const signals = opts.signals ?? process;
+  const report = opts.report ?? (message => console.error(message));
+  const exit = opts.exit ?? (code => process.exit(code));
+  const wasRaw = stdin.isRaw === true;
+  let active = false, closed = false, announced = false;
+  let phase = "Reading configuration";
+  let pending: string[] = [];
+  let pasting = false;
+  /** An escape sequence cut across chunks; joined with the next chunk before matching. */
+  let partial = "";
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const release = () => {
+    if (!active) return;
+    active = false;
+    clearTimeout(timer);
+    stdin.pause();
+    stdin.off("data", receive);
+    signals.off("SIGINT", interrupt); signals.off("SIGTERM", terminate); signals.off("SIGHUP", hangup);
+    pasting = false; partial = "";
+    stdin.setRawMode(wasRaw);
+  };
+  const restore = () => { closed = true; release(); pending = []; };
+  const cancel = (code: number) => {
+    if (!active) return;
+    restore();
+    if (code === 130) report("Startup cancelled.");
+    exit(code);
+  };
+  const interrupt = () => cancel(130), terminate = () => cancel(143), hangup = () => cancel(129);
+  const receive = (data: string) => {
+    // Keep original chunks, including partial escapes/pastes, for Pi's own decoder.
+    // The temporary parser only recognizes cancellation outside bracketed paste.
+    pending.push(data);
+    const joined = partial + data;
+    const cut = trailingPartialEscape(joined);
+    const whole = joined.slice(0, joined.length - cut.length);
+    partial = cut;
+    if (interruptsStartup(whole, pasting)) interrupt();
+    pasting = pasteState(whole, pasting);
+  };
+  const announce = () => { if (active) { announced = true; report(`  Starting xeno: ${phase} (Ctrl+C to cancel)`); } };
+  const capture = () => {
+    if (closed || active) return;
+    active = true; announced = false;
+    stdin.setEncoding("utf8");
+    stdin.on("data", receive);
+    signals.on("SIGINT", interrupt); signals.on("SIGTERM", terminate); signals.on("SIGHUP", hangup);
+    stdin.setRawMode(true);
+    stdin.resume();
+    // Assumed UI grace period, not a work deadline: fast starts stay quiet;
+    // a slow stage remains visible without truncating or abandoning its work.
+    timer = setTimeout(announce, 750);
+    timer.unref();
+  };
+  const handoff = () => {
+    if (!active) return;
+    release();
+    const buffered = pending.join(""); pending = [];
+    if (buffered) stdin.unshift(buffered);
+  };
+  capture();
+  return {
+    phase(name) { if (name === phase) return; phase = name; if (announced) announce(); },
+    handoff, restore,
+    async runWithTerminal(run) {
+      // A selector can load settings/history before mounting. Keep owning input
+      // until its synchronous screen.start(), then reacquire only after stop().
+      try { return await run(handoff); }
+      finally { capture(); }
+    },
+  };
+}
+
+/** Bracketed paste state after a chunk: a paste that started and did not end yet. */
+export function pasteState(data: string, pasting: boolean): boolean {
+  const start = data.lastIndexOf("\x1b[200~"), end = data.lastIndexOf("\x1b[201~");
+  if (start < 0 && end < 0) return pasting;
+  return start > end;
+}
+
+/** Ctrl+C as legacy ETX or kitty CSI-u (99;5u press, not a :3 release), outside a paste. */
+export function interruptsStartup(data: string, pasting: boolean): boolean {
+  let outside = "";
+  let inPaste = pasting;
+  for (let i = 0; i < data.length;) {
+    if (data.startsWith("\x1b[200~", i)) { inPaste = true; i += 6; continue; }
+    if (data.startsWith("\x1b[201~", i)) { inPaste = false; i += 6; continue; }
+    if (!inPaste) outside += data[i];
+    i++;
+  }
+  return outside.includes("\x03") || /\x1b\[99;5(?::1)?u/.test(outside);
+}
+
+/** The unfinished CSI/SS3 at the end of a chunk ("\x1b[99;" waiting for "5u"), or "". */
+export function trailingPartialEscape(data: string): string {
+  const at = data.lastIndexOf("\x1b");
+  if (at < 0) return "";
+  const tail = data.slice(at);
+  if (tail === "\x1b") return tail;
+  if (/^\x1b\[[0-9;:?]*$/.test(tail) || /^\x1bO$/.test(tail)) return tail;
+  return "";
+}