mixdog 0.9.1 → 0.9.2

package/src/tui/index.jsx

@@ -6,19 +6,24 @@
  */
 import React from 'react';
 import { render } from 'ink';
-import { createWriteStream, mkdirSync } from 'node:fs';
+import { closeSync, constants as fsConstants, createWriteStream, mkdirSync, openSync, readSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { App } from './App.jsx';
 import { createEngineSession } from './engine.mjs';
 import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.mjs';
+import { touchUiHeartbeat } from '../runtime/channels/lib/runtime-paths.mjs';
 import { emitTerminalBackground, loadThemeSettingFromConfig, theme } from './theme.mjs';
+import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
 
 const TERMINAL_MODE_RESET = '\x1b[?1006l\x1b[?1005l\x1b[?1015l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h';
 const TERMINAL_OSC_RESET_BG = '\x1b]111\x07';
 const TERMINAL_MODE_RESET_HIDDEN_CURSOR = TERMINAL_MODE_RESET.replace('\x1b[?25h', '\x1b[?25l');
 const MOUSE_TRACKING_ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
+// Keyboard-protocol teardown. App.jsx enables kitty + modifyOtherKeys
+// synchronously at raw-mode-on (no query); here we just pop/disable them on
+// exit. POP_KITTY / DISABLE_MODIFY_OTHER_KEYS come from keyboard-protocol.mjs.
 const BOOT_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_BOOT_PROFILE || ''));
 const BOOT_PROFILE_START = globalThis.__mixdogBootProfileStart || (globalThis.__mixdogBootProfileStart = performance.now());
 const EXIT_WAIT_TIMEOUT_MS = positiveIntEnv('MIXDOG_TUI_EXIT_WAIT_MS', 2500);
@@ -136,6 +141,47 @@ function resolveTuiStderrLogPath() {
     || join(process.env.MIXDOG_RUNTIME_ROOT || join(tmpdir(), 'mixdog'), 'mixdog-tui.stderr.log');
 }
 
+/** Drain stdin so queued key/mouse bytes do not leak into the shell after exit. */
+function drainStdin(stdin = process.stdin) {
+  if (!stdin.isTTY) return;
+  try {
+    while (stdin.read() !== null) {
+      /* discard */
+    }
+  } catch {
+    /* stream may be destroyed */
+  }
+  if (process.platform === 'win32') return;
+  const tty = stdin;
+  const wasRaw = tty.isRaw === true;
+  let fd = -1;
+  try {
+    if (!wasRaw) tty.setRawMode?.(true);
+    fd = openSync('/dev/tty', fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
+    const buf = Buffer.alloc(1024);
+    for (let i = 0; i < 64; i++) {
+      if (readSync(fd, buf, 0, buf.length, null) <= 0) break;
+    }
+  } catch {
+    /* EAGAIN, ENXIO, ENOENT, EBADF, EIO */
+  } finally {
+    if (fd >= 0) {
+      try {
+        closeSync(fd);
+      } catch {
+        /* ignore */
+      }
+    }
+    if (!wasRaw) {
+      try {
+        tty.setRawMode?.(false);
+      } catch {
+        /* TTY may be gone */
+      }
+    }
+  }
+}
+
 function installTuiStderrGuard() {
   if (process.env.MIXDOG_TUI_ALLOW_STDERR === '1') return () => {};
   const originalWrite = process.stderr.write.bind(process.stderr);
@@ -177,9 +223,9 @@ function installTuiStderrGuard() {
   };
 }
 
-export async function runTui({ provider, model, toolMode } = {}) {
+export async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {}) {
   const startedAt = performance.now();
-  bootProfile('run:start', { provider, model, toolMode });
+  bootProfile('run:start', { provider, model, toolMode, remote });
   // The React/ink TUI needs a raw-mode-capable TTY (interactive input). In a
   // pipe/redirect/CI, ink's input hooks throw — bail with a clear hint instead.
   if (!process.stdin.isTTY) {
@@ -191,13 +237,19 @@ export async function runTui({ provider, model, toolMode } = {}) {
   }
 
   const restoreStderr = installTuiStderrGuard();
-  const restorePrimedInput = () => {}; // stdin raw mode is owned by Ink's useInput effects
+  const restorePrimedInput = () => drainStdin(process.stdin);
   let restored = false;
   const restoreTerminal = () => {
     if (restored) return;
     restored = true;
     restorePrimedInput();
-    try { process.stdout.write(`${TERMINAL_MODE_RESET}\x1b[0 q\x1b[?1049l${TERMINAL_MODE_RESET}${TERMINAL_OSC_RESET_BG}`); } catch { /* ignore */ }
+    try {
+      process.stdout.write(
+        // Pop kitty + disable modifyOtherKeys BEFORE leaving the alt screen.
+        // Both are no-ops if nothing was enabled, so this is always safe.
+        `${TERMINAL_MODE_RESET}\x1b[0 q${POP_KITTY}${DISABLE_MODIFY_OTHER_KEYS}\x1b[?1049l${TERMINAL_MODE_RESET}${TERMINAL_OSC_RESET_BG}`,
+      );
+    } catch { /* ignore */ }
   };
 
   // Enter the alternate screen buffer before session/runtime boot so no stale
@@ -211,6 +263,10 @@ export async function runTui({ provider, model, toolMode } = {}) {
   // fat block. PromptInput parks this hardware cursor at the insertion point via
   // useCursor; the terminal also anchors IME composition to it.
   process.stdout.write('\x1b[5 q'); // blinking bar
+  // NOTE: extended-keys enabling (kitty + modifyOtherKeys) is done by App.jsx's
+  // mount effect, SYNCHRONOUSLY at ink's raw-mode-on — no query, no round-trip —
+  // so the first Ctrl+Enter is already covered. Only teardown lives here (see
+  // restoreTerminal above).
 
   process.on('exit', restoreTerminal);
 
@@ -223,7 +279,7 @@ export async function runTui({ provider, model, toolMode } = {}) {
 
   let store;
   try {
-    store = await createEngineSession({ provider, model, toolMode });
+    store = await createEngineSession({ provider, model, toolMode, remote });
     bootProfile('store:ready', { ms: (performance.now() - startedAt).toFixed(1) });
   } catch (error) {
     restoreTerminal();
@@ -260,11 +316,58 @@ export async function runTui({ provider, model, toolMode } = {}) {
     },
   });
 
+  // Zombie-Lead repro (2026-07-02): the render loop can wedge (all owning
+  // PIDs still alive) leaving active-instance.json's pid-only staleness
+  // check unable to detect it. Heartbeat every 30s so runtime-paths.mjs can
+  // fall back to a ui_heartbeat_at staleness check when pids look fine.
+  // Best-effort: a failed/late write just means the next tick catches up,
+  // and the timer is unref'd so it never keeps the process alive on its own.
+  const uiHeartbeatTimer = setInterval(() => {
+    try { touchUiHeartbeat(); } catch { /* ignore */ }
+  }, 30_000);
+  if (typeof uiHeartbeatTimer.unref === 'function') uiHeartbeatTimer.unref();
+  try { touchUiHeartbeat(); } catch { /* ignore */ }
+
+  // Zombie-Lead repro (2026-07-02): stdio can die (TTY hangup, EPIPE on a
+  // detached/piped stdout) without the process ever receiving SIGHUP/SIGTERM,
+  // leaving a zombie renderer looping forever with nothing left to draw to.
+  // Treat a dead stdio surface as fatal and route it through the same
+  // signalCleanup teardown used for signals.
+  // 'error' whitelist: only codes that mean the stream is truly gone.
+  // Transient EAGAIN (backpressure) or terminal-resize noise must NOT be
+  // treated as fatal here — only EPIPE / ERR_STREAM_DESTROYED / EIO.
+  const STDIO_DEATH_FATAL_CODES = new Set(['EPIPE', 'ERR_STREAM_DESTROYED', 'EIO']);
+  const stdioDeathListeners = [];
+  const registerStdioDeath = (stream, event, { requireCode = false } = {}) => {
+    if (!stream || typeof stream.on !== 'function') return;
+    const handler = (err) => {
+      if (requireCode && !(err && STDIO_DEATH_FATAL_CODES.has(err.code))) return;
+      void signalCleanup.run('stdio-dead', {
+        code: 1,
+        shouldExit: true,
+        error: err || new Error(`stdio ${event} (source: ${stream === process.stdin ? 'stdin' : stream === process.stdout ? 'stdout' : 'stderr'})`),
+      });
+    };
+    stream.on(event, handler);
+    stdioDeathListeners.push([stream, event, handler]);
+  };
+  // stdin end/close/error: TTY/pipe on the input side is gone — nothing left
+  // to read from, no point keeping the renderer alive.
+  registerStdioDeath(process.stdin, 'end');
+  registerStdioDeath(process.stdin, 'close');
+  registerStdioDeath(process.stdin, 'error', { requireCode: true });
+  // stdout/stderr: 'close' always means the fd is gone (fatal); 'error' is
+  // filtered to the whitelist above so resize/EAGAIN noise doesn't kill us.
+  registerStdioDeath(process.stdout, 'error', { requireCode: true });
+  registerStdioDeath(process.stdout, 'close');
+  registerStdioDeath(process.stderr, 'error', { requireCode: true });
+  registerStdioDeath(process.stderr, 'close');
+
   // exitOnCtrlC:false — App handles Ctrl+C as an interrupt/line-clear so Ink
   // does not exit abruptly. Explicit exits go through /exit or /quit so teardown
   // still restores the cursor, mouse mode, and alternate screen cleanly.
   try {
-    const instance = render(<App store={store} />, { exitOnCtrlC: false, maxFps: 120, onRender: makeRenderProfiler() });
+    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 120, onRender: makeRenderProfiler() });
     bootProfile('render:mounted', { ms: (performance.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     // [mixdog fork] Hand the ink renderer's drag-selection setter to the store so
@@ -281,8 +384,15 @@ export async function runTui({ provider, model, toolMode } = {}) {
     if (mouseTracking && typeof instance.getWordRectAt === 'function') {
       store.getWordRectAt = instance.getWordRectAt;
     }
+    if (mouseTracking && typeof instance.getLineRectAt === 'function') {
+      store.getLineRectAt = instance.getLineRectAt;
+    }
     await waitUntilExit();
   } finally {
+    clearInterval(uiHeartbeatTimer);
+    for (const [stream, event, handler] of stdioDeathListeners.splice(0)) {
+      try { stream.off(event, handler); } catch { /* ignore */ }
+    }
     signalCleanup.uninstall();
     try {
       await disposeStoreOnce('cli-react-exit');

package/src/tui/keyboard-protocol.mjs

@@ -0,0 +1,42 @@
+/**
+ * src/tui/keyboard-protocol.mjs — terminal extended-keys capability gate.
+ *
+ * We do NOT query the terminal. Instead, mirroring Claude Code, we enable the
+ * kitty keyboard protocol AND xterm modifyOtherKeys SYNCHRONOUSLY at the moment
+ * raw mode turns on (see App.jsx's mount effect), gated by the allowlist below.
+ * Writing both enables unconditionally is safe — a terminal honors whichever it
+ * implements (Windows Terminal 1.24 has no kitty support but DOES honor
+ * modifyOtherKeys), and doing it before the first keypair is read removes the
+ * round-trip race that made the first Ctrl+Enter submit instead of inserting a
+ * newline.
+ *
+ * Enable / disable byte sequences (used by App.jsx enable + index.jsx teardown):
+ *   ENABLE_KITTY_KEYBOARD     \x1b[>1u    push kitty flags=1 (disambiguate)
+ *   ENABLE_MODIFY_OTHER_KEYS  \x1b[>4;2m  xterm modifyOtherKeys level 2
+ *   POP_KITTY                 \x1b[<u     pop the kitty stack entry
+ *   DISABLE_MODIFY_OTHER_KEYS \x1b[>4;0m  modifyOtherKeys off
+ */
+export const ENABLE_KITTY_KEYBOARD = '\x1b[>1u';
+export const ENABLE_MODIFY_OTHER_KEYS = '\x1b[>4;2m';
+export const POP_KITTY = '\x1b[<u';
+export const DISABLE_MODIFY_OTHER_KEYS = '\x1b[>4;0m';
+
+// Allowlist of terminals known to honor kitty and/or xterm modifyOtherKeys.
+// Mirrors Claude Code's supportsExtendedKeys allowlist. VS Code's xterm.js
+// integrated terminal mishandles these sequences, so it is excluded first.
+// Honors the MIXDOG_TUI_EXTENDED_KEYS opt-out (=0) / override (=1).
+export function supportsExtendedKeys() {
+  const raw = String(process.env.MIXDOG_TUI_EXTENDED_KEYS ?? '').trim();
+  if (/^(0|false|no|off)$/i.test(raw)) return false;
+  if (/^(1|true|yes|on)$/i.test(raw)) return true;
+  if (process.env.TERM_PROGRAM === 'vscode') return false;
+  if (process.env.WT_SESSION) return true; // Windows Terminal
+  if (process.env.TERM?.includes('kitty')) return true;
+  if (process.env.KITTY_WINDOW_ID) return true;
+  if (process.env.TERM_PROGRAM === 'WezTerm') return true;
+  if (process.env.TERM_PROGRAM === 'ghostty') return true;
+  if (process.env.TERM === 'xterm-ghostty') return true;
+  if (process.env.TMUX) return true;
+  if (process.env.TERM_PROGRAM === 'iTerm.app') return true;
+  return false;
+}