mixdog 0.9.1 → 0.9.3

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/input-editing.mjs

@@ -122,14 +122,52 @@ export function lineEnd(text, offset) {
   return end === -1 ? value.length : end;
 }
 
-export function caretPosition(text, offset, width) {
+// Return the [start,end) run of same-class characters (word-like vs
+// non-word-like) surrounding `offset`, used by double-click word selection.
+// Mirrors typical desktop double-click behavior: clicking inside a run of
+// letters/digits selects that whole run; clicking on a run of punctuation or
+// whitespace selects that run instead (still deterministic, never empty).
+export function wordRangeAt(text, offset) {
+  const value = String(text || '');
+  const units = graphemeUnits(value);
+  if (units.length === 0) return { start: 0, end: 0 };
+  const off = clampOffset(value, offset);
+  let idx = units.findIndex((u) => off >= u.start && off < u.end);
+  if (idx === -1) {
+    idx = units.length - 1;
+    for (let i = 0; i < units.length; i += 1) {
+      if (units[i].start >= off) { idx = i > 0 ? i - 1 : 0; break; }
+    }
+  }
+  const targetIsWord = wordLike(units[idx].segment);
+  let start = idx;
+  while (start > 0 && wordLike(units[start - 1].segment) === targetIsWord) start -= 1;
+  let end = idx;
+  while (end < units.length - 1 && wordLike(units[end + 1].segment) === targetIsWord) end += 1;
+  return { start: units[start].start, end: units[end].end };
+}
+
+// `hasTrailingContent` (default derived from the full text) decides whether a
+// caret that lands FLUSH on the last column (col === w) rolls to the next row.
+// It must reflect whether ANY rendered cell follows this offset in the FULL
+// text — not just the sliced prefix — otherwise a caret at a mid-text soft-wrap
+// boundary reports {row N, col w} while ink already rendered the next glyph on
+// row N+1, dropping the caret outside the box. PromptInput also appends a
+// trailing space cell when the cursor sits at end-of-input, so "end of text"
+// still has a following cell there; callers pass hasTrailingContent=true for
+// that case.
+export function caretPosition(text, offset, width, hasTrailingContent = undefined) {
   const value = String(text || '');
   const before = value.slice(0, offset);
   const w = safeWidth(width);
+  const followsInFullText = hasTrailingContent === undefined
+    ? offset < value.length
+    : hasTrailingContent === true;
   let row = 0;
   let col = 0;
-
-  for (const { segment } of graphemeSegmenter.segment(before)) {
+  const segments = [...graphemeSegmenter.segment(before)];
+  for (let i = 0; i < segments.length; i += 1) {
+    const { segment } = segments[i];
     if (segment === '\n') {
       row += 1;
       col = 0;
@@ -139,15 +177,24 @@ export function caretPosition(text, offset, width) {
     const segmentWidth = stringWidth(segment);
     if (segmentWidth === 0) continue;
 
+    // Mirror ink's wrap-ansi wrapWord (wrap="hard", wordWrap:false): a glyph
+    // that would overflow the row is pushed WHOLE to the next row (col never
+    // exceeds w for wide chars — no half-column left behind), and a glyph that
+    // lands flush on the last column starts a new row ONLY when more rendered
+    // content follows. Whether content follows is decided from the FULL text
+    // (followsInFullText), not the sliced prefix, so a caret at a mid-text wrap
+    // boundary rolls to row N+1 exactly as ink renders it. The old
+    // `col >= w → row += floor(col/w)` over-counted a row for width-2 glyphs at
+    // odd widths (col could reach w+1), landing the cursor one row too low.
     if (col > 0 && col + segmentWidth > w) {
       row += 1;
       col = 0;
     }
-
     col += segmentWidth;
-    if (col >= w) {
-      row += Math.floor(col / w);
-      col %= w;
+    const moreFollows = i < segments.length - 1 || followsInFullText;
+    if (col === w && moreFollows) {
+      row += 1;
+      col = 0;
     }
   }
 
@@ -185,13 +232,16 @@ function boundaryPositions(text, width) {
   for (const unit of graphemeUnits(value)) offsets.push(unit.end);
 
   const seen = new Set();
-  return offsets
+  const positions = offsets
     .filter((offset) => {
       if (seen.has(offset)) return false;
       seen.add(offset);
       return true;
     })
+    // Decide the flush-boundary advance from the FULL text so a soft-wrap
+    // offset reports {row N+1, col 0} (matching ink) instead of {row N, col w}.
     .map((offset) => ({ offset, ...caretPosition(value, offset, width) }));
+  return positions;
 }
 
 export function verticalOffset(text, offset, width, direction, preferredColumn = null) {

package/src/tui/input-editing.selection.test.mjs

@@ -0,0 +1,75 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  moveCursor,
+  previousWordOffset,
+  nextWordOffset,
+  selectionRange,
+  verticalOffset,
+  wordRangeAt,
+  lineStart,
+  lineEnd,
+} from './input-editing.mjs';
+
+// Whole-word extend (Ctrl+Shift+Left/Right) relies on moveCursor(extend:true)
+// starting/keeping an anchor while jumping by word.
+test('ctrl+shift+right extends selection by whole word', () => {
+  const draft = { value: 'hello world foo', cursor: 0, selectionAnchor: null };
+  const next = moveCursor(draft, nextWordOffset(draft.value, draft.cursor), { extend: true });
+  assert.equal(next.cursor, 'hello'.length);
+  assert.equal(next.selectionAnchor, 0);
+  assert.deepEqual(selectionRange(next), { start: 0, end: 5 });
+});
+
+test('ctrl+shift+left extends selection backward by whole word', () => {
+  const value = 'hello world';
+  const draft = { value, cursor: value.length, selectionAnchor: null };
+  const next = moveCursor(draft, previousWordOffset(value, value.length), { extend: true });
+  assert.equal(next.selectionAnchor, value.length);
+  assert.deepEqual(selectionRange(next), { start: 'hello '.length, end: value.length });
+});
+
+// Shift+Up on the first line yields no vertical move (targetRow < 0) → callers
+// then extend to document start (offset 0).
+test('verticalOffset returns same cursor on first line (up)', () => {
+  const value = 'line1\nline2';
+  const moved = verticalOffset(value, 2, 80, -1, null);
+  assert.equal(moved.cursor, 2, 'no vertical move available above first line');
+});
+
+test('shift+up to document start extends selection to offset 0', () => {
+  const value = 'abc';
+  const draft = { value, cursor: 2, selectionAnchor: null };
+  const next = moveCursor(draft, 0, { extend: true });
+  assert.deepEqual(selectionRange(next), { start: 0, end: 2 });
+});
+
+test('shift+down to document end extends selection to value.length', () => {
+  const value = 'abc';
+  const draft = { value, cursor: 1, selectionAnchor: null };
+  const next = moveCursor(draft, value.length, { extend: true });
+  assert.deepEqual(selectionRange(next), { start: 1, end: 3 });
+});
+
+// Double-click word select: clicking anywhere inside a word run selects the
+// whole run, and a click on punctuation/whitespace selects that run instead.
+test('wordRangeAt selects the word run under the offset', () => {
+  const value = 'hello world foo';
+  assert.deepEqual(wordRangeAt(value, 2), { start: 0, end: 5 });
+  assert.deepEqual(wordRangeAt(value, 6), { start: 6, end: 11 });
+  assert.deepEqual(wordRangeAt(value, 0), { start: 0, end: 5 });
+  assert.deepEqual(wordRangeAt(value, value.length), { start: 12, end: 15 });
+});
+
+test('wordRangeAt selects a punctuation/whitespace run distinctly from words', () => {
+  const value = 'foo---bar';
+  assert.deepEqual(wordRangeAt(value, 4), { start: 3, end: 6 });
+});
+
+// Triple-click line select uses lineStart/lineEnd directly.
+test('lineStart/lineEnd bound the current line for triple-click select', () => {
+  const value = 'line1\nline2\nline3';
+  const offset = value.indexOf('line2') + 2;
+  assert.equal(lineStart(value, offset), 6);
+  assert.equal(lineEnd(value, offset), 11);
+});

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, 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.
+// 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;
+}