terminal-pilot 0.0.4 → 0.0.6

package/dist/testing/qa-cli.js

@@ -0,0 +1,2828 @@
+// src/testing/qa-cli.ts
+import assert from "node:assert/strict";
+import { rm } from "node:fs/promises";
+import os2 from "node:os";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/ansi.ts
+var ESC = 27;
+var BEL = 7;
+var ST = 156;
+var CSI = 155;
+var OSC = 157;
+var DCS = 144;
+var SOS = 152;
+var PM = 158;
+var APC = 159;
+function stripAnsi(input) {
+  let output = "";
+  for (let index = 0; index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    if (code === ESC) {
+      const nextCode = input.charCodeAt(index + 1);
+      if (nextCode === 91) {
+        index = consumeCsi(input, index + 2);
+        continue;
+      }
+      if (nextCode === 93) {
+        index = consumeTerminatedString(input, index + 2, true);
+        continue;
+      }
+      if (nextCode === 80 || nextCode === 88 || nextCode === 94 || nextCode === 95) {
+        index = consumeTerminatedString(input, index + 2, false);
+        continue;
+      }
+      if (!Number.isNaN(nextCode)) {
+        index += 1;
+      }
+      continue;
+    }
+    if (code === CSI) {
+      index = consumeCsi(input, index + 1);
+      continue;
+    }
+    if (code === OSC) {
+      index = consumeTerminatedString(input, index + 1, true);
+      continue;
+    }
+    if (code === DCS || code === SOS || code === PM || code === APC) {
+      index = consumeTerminatedString(input, index + 1, false);
+      continue;
+    }
+    output += input[index];
+  }
+  return output;
+}
+function consumeCsi(input, index) {
+  while (index < input.length) {
+    const code = input.charCodeAt(index);
+    if (code >= 64 && code <= 126) {
+      return index;
+    }
+    index += 1;
+  }
+  return input.length;
+}
+function consumeTerminatedString(input, index, allowBellTerminator) {
+  while (index < input.length) {
+    const code = input.charCodeAt(index);
+    if (code === ST || allowBellTerminator && code === BEL) {
+      return index;
+    }
+    if (code === ESC && input.charCodeAt(index + 1) === 92) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  return input.length;
+}
+
+// src/cli.ts
+import { realpath } from "node:fs/promises";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { runCLI } from "@poe-code/cmdkit/cli";
+
+// src/commands/index.ts
+import { defineGroup } from "@poe-code/cmdkit";
+
+// src/commands/close-session.ts
+import { defineCommand, S } from "@poe-code/cmdkit";
+
+// src/commands/runtime.ts
+import { UserError } from "@poe-code/cmdkit";
+
+// src/terminal-pilot.ts
+import { randomUUID } from "node:crypto";
+
+// src/terminal-session.ts
+import { spawn as spawnChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+import * as nodePty from "node-pty";
+
+// src/terminal-buffer.ts
+var RESET_SGR = "\x1B[0m";
+var TerminalBuffer = class {
+  _cols;
+  _rows;
+  _screen;
+  _cursorX = 0;
+  _cursorY = 0;
+  _savedCursor = { x: 0, y: 0 };
+  _scrollTop = 0;
+  _scrollBottom;
+  _state = 0 /* Normal */;
+  _csiParams = "";
+  _csiPrivate = "";
+  _style = createDefaultStyleState();
+  _styleSequence = "";
+  displayBuffer;
+  constructor(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+    this._scrollBottom = rows - 1;
+    this._screen = this._makeScreen(cols, rows);
+    this.displayBuffer = Object.defineProperties(
+      {},
+      {
+        cursorX: { get: () => this._cursorX, enumerable: true },
+        cursorY: { get: () => this._cursorY, enumerable: true },
+        data: { get: () => this._screen, enumerable: true }
+      }
+    );
+  }
+  write(data) {
+    for (const ch of data) {
+      this._feed(ch);
+    }
+  }
+  renderLine(row) {
+    const cells = this._screen[row] ?? [];
+    let lastVisibleCell = -1;
+    for (let index = cells.length - 1; index >= 0; index -= 1) {
+      if (cells[index] !== null) {
+        lastVisibleCell = index;
+        break;
+      }
+    }
+    if (lastVisibleCell === -1) {
+      return "";
+    }
+    let line = "";
+    let activeStyle = "";
+    for (let index = 0; index <= lastVisibleCell; index += 1) {
+      const cell = cells[index];
+      const cellStyle = cell?.style ?? "";
+      if (cellStyle !== activeStyle) {
+        line += cellStyle.length > 0 ? cellStyle : RESET_SGR;
+        activeStyle = cellStyle;
+      }
+      line += cell?.[1] ?? " ";
+    }
+    if (activeStyle.length > 0) {
+      line += RESET_SGR;
+    }
+    return line;
+  }
+  resize(cols, rows) {
+    while (this._screen.length < rows) {
+      this._screen.push(this._makeRow(cols));
+    }
+    this._screen.length = rows;
+    for (let y = 0; y < rows; y++) {
+      const row = this._screen[y] ?? this._makeRow(cols);
+      while (row.length < cols) row.push(null);
+      row.length = cols;
+      this._screen[y] = row;
+    }
+    this._cols = cols;
+    this._rows = rows;
+    this._scrollTop = 0;
+    this._scrollBottom = rows - 1;
+    this._cursorX = this._clamp(this._cursorX, 0, cols - 1);
+    this._cursorY = this._clamp(this._cursorY, 0, rows - 1);
+  }
+  _makeScreen(cols, rows) {
+    return Array.from({ length: rows }, () => this._makeRow(cols));
+  }
+  _makeRow(cols) {
+    return Array(cols).fill(null);
+  }
+  _clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+  }
+  _setChar(y, x, ch) {
+    const row = this._screen[y];
+    if (row && x >= 0 && x < this._cols) {
+      const cell = [ch.charCodeAt(0), ch];
+      if (this._styleSequence.length > 0) {
+        Object.defineProperty(cell, "style", {
+          value: this._styleSequence,
+          writable: true,
+          configurable: true
+        });
+      }
+      row[x] = cell;
+    }
+  }
+  _eraseLine(y, fromX, toX) {
+    const row = this._screen[y];
+    if (!row) return;
+    for (let x = fromX; x <= toX && x < this._cols; x++) {
+      row[x] = null;
+    }
+  }
+  _scrollUp(count) {
+    for (let i = 0; i < count; i++) {
+      this._screen.splice(this._scrollTop, 1);
+      this._screen.splice(this._scrollBottom, 0, this._makeRow(this._cols));
+    }
+  }
+  _scrollDown(count) {
+    for (let i = 0; i < count; i++) {
+      this._screen.splice(this._scrollBottom, 1);
+      this._screen.splice(this._scrollTop, 0, this._makeRow(this._cols));
+    }
+  }
+  _newline() {
+    if (this._cursorY === this._scrollBottom) {
+      this._scrollUp(1);
+    } else {
+      this._cursorY = Math.min(this._cursorY + 1, this._rows - 1);
+    }
+  }
+  _parseCsiParams() {
+    if (!this._csiParams) return [];
+    return this._csiParams.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+  }
+  _execCsi(final) {
+    const params17 = this._parseCsiParams();
+    const p0 = params17[0] ?? 0;
+    const p1 = params17[1] ?? 0;
+    if (this._csiPrivate === "?") {
+      if (final === "h" || final === "l") {
+        if (params17.includes(1049)) {
+          if (final === "h") {
+            this._screen = this._makeScreen(this._cols, this._rows);
+            this._cursorX = 0;
+            this._cursorY = 0;
+          } else {
+            this._screen = this._makeScreen(this._cols, this._rows);
+            this._cursorX = 0;
+            this._cursorY = 0;
+          }
+          this._resetStyle();
+        }
+      }
+      return;
+    }
+    switch (final) {
+      case "A":
+        this._cursorY = this._clamp(this._cursorY - Math.max(1, p0), 0, this._rows - 1);
+        break;
+      case "B":
+        this._cursorY = this._clamp(this._cursorY + Math.max(1, p0), 0, this._rows - 1);
+        break;
+      case "C":
+      // cursor forward
+      case "a":
+        this._cursorX = this._clamp(this._cursorX + Math.max(1, p0), 0, this._cols - 1);
+        break;
+      case "D":
+        this._cursorX = this._clamp(this._cursorX - Math.max(1, p0), 0, this._cols - 1);
+        break;
+      case "E":
+        this._cursorY = this._clamp(this._cursorY + Math.max(1, p0), 0, this._rows - 1);
+        this._cursorX = 0;
+        break;
+      case "F":
+        this._cursorY = this._clamp(this._cursorY - Math.max(1, p0), 0, this._rows - 1);
+        this._cursorX = 0;
+        break;
+      case "G":
+      // cursor horizontal absolute
+      case "`":
+        this._cursorX = this._clamp(Math.max(1, p0) - 1, 0, this._cols - 1);
+        break;
+      case "H":
+      // cursor position
+      case "f":
+        this._cursorY = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        this._cursorX = this._clamp(Math.max(1, p1) - 1, 0, this._cols - 1);
+        break;
+      case "I":
+        for (let i = 0; i < Math.max(1, p0); i++) {
+          this._cursorX = Math.min(this._cols - 1, (Math.floor(this._cursorX / 8) + 1) * 8);
+        }
+        break;
+      case "J":
+        if (p0 === 0) {
+          this._eraseLine(this._cursorY, this._cursorX, this._cols - 1);
+          for (let y = this._cursorY + 1; y < this._rows; y++) this._eraseLine(y, 0, this._cols - 1);
+        } else if (p0 === 1) {
+          for (let y = 0; y < this._cursorY; y++) this._eraseLine(y, 0, this._cols - 1);
+          this._eraseLine(this._cursorY, 0, this._cursorX);
+        } else if (p0 === 2 || p0 === 3) {
+          for (let y = 0; y < this._rows; y++) this._eraseLine(y, 0, this._cols - 1);
+        }
+        break;
+      case "K":
+        if (p0 === 0) this._eraseLine(this._cursorY, this._cursorX, this._cols - 1);
+        else if (p0 === 1) this._eraseLine(this._cursorY, 0, this._cursorX);
+        else if (p0 === 2) this._eraseLine(this._cursorY, 0, this._cols - 1);
+        break;
+      case "X":
+        this._eraseLine(this._cursorY, this._cursorX, this._cursorX + Math.max(1, p0) - 1);
+        break;
+      case "L": {
+        const n = Math.max(1, p0);
+        for (let i = 0; i < n; i++) {
+          this._screen.splice(this._scrollBottom, 1);
+          this._screen.splice(this._cursorY, 0, this._makeRow(this._cols));
+        }
+        break;
+      }
+      case "M": {
+        const n = Math.max(1, p0);
+        for (let i = 0; i < n; i++) {
+          this._screen.splice(this._cursorY, 1);
+          this._screen.splice(this._scrollBottom, 0, this._makeRow(this._cols));
+        }
+        break;
+      }
+      case "P": {
+        const row = this._screen[this._cursorY];
+        if (row) {
+          const n = Math.max(1, p0);
+          row.splice(this._cursorX, n);
+          while (row.length < this._cols) row.push(null);
+        }
+        break;
+      }
+      case "@": {
+        const row = this._screen[this._cursorY];
+        if (row) {
+          const n = Math.max(1, p0);
+          for (let i = 0; i < n; i++) row.splice(this._cursorX, 0, null);
+          row.splice(this._cols);
+        }
+        break;
+      }
+      case "S":
+        this._scrollUp(Math.max(1, p0));
+        break;
+      case "T":
+        if (params17.length <= 1) this._scrollDown(Math.max(1, p0));
+        break;
+      case "Z": {
+        const n = Math.max(1, p0);
+        for (let i = 0; i < n; i++) {
+          this._cursorX = Math.max(0, (Math.ceil(this._cursorX / 8) - 1) * 8);
+        }
+        break;
+      }
+      case "d":
+        this._cursorY = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        break;
+      case "e":
+        this._cursorY = this._clamp(this._cursorY + Math.max(1, p0), 0, this._rows - 1);
+        break;
+      case "r": {
+        const top = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        const bottom = this._clamp((p1 === 0 ? this._rows : p1) - 1, 0, this._rows - 1);
+        if (top < bottom) {
+          this._scrollTop = top;
+          this._scrollBottom = bottom;
+        }
+        this._cursorX = 0;
+        this._cursorY = 0;
+        break;
+      }
+      case "s":
+        this._savedCursor = { x: this._cursorX, y: this._cursorY };
+        break;
+      case "u":
+        this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
+        this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+        break;
+      case "m":
+        this._applySgr(params17);
+        break;
+      default:
+        break;
+    }
+  }
+  _feed(ch) {
+    const code = ch.charCodeAt(0);
+    switch (this._state) {
+      case 0 /* Normal */:
+        this._feedNormal(ch, code);
+        break;
+      case 1 /* Escape */:
+        this._feedEscape(ch, code);
+        break;
+      case 2 /* Csi */:
+        this._feedCsi(ch, code);
+        break;
+      case 3 /* Osc */:
+        if (code === 7 || code === 156) {
+          this._state = 0 /* Normal */;
+        } else if (code === 27) {
+          this._state = 0 /* Normal */;
+        }
+        break;
+      case 4 /* Str */:
+        if (code === 156 || code === 7) {
+          this._state = 0 /* Normal */;
+        } else if (code === 27) {
+          this._state = 0 /* Normal */;
+        }
+        break;
+      case 5 /* EscCharset */:
+        this._state = 0 /* Normal */;
+        break;
+      case 6 /* EscHash */:
+        this._state = 0 /* Normal */;
+        break;
+    }
+  }
+  _feedNormal(ch, code) {
+    if (code === 27) {
+      this._state = 1 /* Escape */;
+    } else if (code === 155) {
+      this._csiParams = "";
+      this._csiPrivate = "";
+      this._state = 2 /* Csi */;
+    } else if (code === 157) {
+      this._state = 3 /* Osc */;
+    } else if (code === 144 || code === 152 || code === 158 || code === 159) {
+      this._state = 4 /* Str */;
+    } else if (code === 7 || code === 5 || code === 6) {
+    } else if (code === 8) {
+      if (this._cursorX > 0) this._cursorX--;
+    } else if (code === 127) {
+      if (this._cursorX > 0) {
+        this._cursorX--;
+        this._setChar(this._cursorY, this._cursorX, " ");
+      }
+    } else if (code === 9) {
+      this._cursorX = Math.min(this._cols - 1, (Math.floor(this._cursorX / 8) + 1) * 8);
+    } else if (code === 10 || code === 11 || code === 12) {
+      this._newline();
+    } else if (code === 13) {
+      this._cursorX = 0;
+    } else if (code === 14 || code === 15) {
+    } else if (code >= 32 && code !== 127) {
+      this._setChar(this._cursorY, this._cursorX, ch);
+      this._cursorX++;
+      if (this._cursorX >= this._cols) {
+        this._cursorX = 0;
+        this._newline();
+      }
+    }
+  }
+  _feedEscape(ch, code) {
+    this._state = 0 /* Normal */;
+    if (code === 91) {
+      this._csiParams = "";
+      this._csiPrivate = "";
+      this._state = 2 /* Csi */;
+    } else if (code === 93) {
+      this._state = 3 /* Osc */;
+    } else if (code === 80 || code === 88 || code === 94 || code === 95) {
+      this._state = 4 /* Str */;
+    } else if (code === 40 || code === 41 || code === 42 || code === 43 || code === 45 || code === 46) {
+      this._state = 5 /* EscCharset */;
+    } else if (code === 35) {
+      this._state = 6 /* EscHash */;
+    } else if (code === 55) {
+      this._savedCursor = { x: this._cursorX, y: this._cursorY };
+    } else if (code === 56) {
+      this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
+      this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+    } else if (code === 68) {
+      this._newline();
+    } else if (code === 69) {
+      this._cursorX = 0;
+      this._newline();
+    } else if (code === 77) {
+      if (this._cursorY === this._scrollTop) {
+        this._scrollDown(1);
+      } else {
+        this._cursorY = Math.max(0, this._cursorY - 1);
+      }
+    } else if (code === 72) {
+    } else if (code === 99) {
+      this._screen = this._makeScreen(this._cols, this._rows);
+      this._cursorX = 0;
+      this._cursorY = 0;
+      this._savedCursor = { x: 0, y: 0 };
+      this._scrollTop = 0;
+      this._scrollBottom = this._rows - 1;
+      this._resetStyle();
+    }
+  }
+  _feedCsi(ch, code) {
+    if (code >= 64 && code <= 126) {
+      this._execCsi(ch);
+      this._state = 0 /* Normal */;
+    } else if (code === 63 || code === 33 || code === 62 || code === 32) {
+      this._csiPrivate = ch;
+    } else if (code >= 48 && code <= 57 || code === 59) {
+      this._csiParams += ch;
+    }
+  }
+  _resetStyle() {
+    this._style = createDefaultStyleState();
+    this._styleSequence = "";
+  }
+  _applySgr(params17) {
+    const normalizedParams = params17.length === 0 ? [0] : params17;
+    for (let index = 0; index < normalizedParams.length; index += 1) {
+      const value = normalizedParams[index] ?? 0;
+      switch (value) {
+        case 0:
+          this._resetStyle();
+          break;
+        case 1:
+          this._style.bold = true;
+          break;
+        case 2:
+          this._style.dim = true;
+          break;
+        case 3:
+          this._style.italic = true;
+          break;
+        case 4:
+          this._style.underline = true;
+          break;
+        case 7:
+          this._style.inverse = true;
+          break;
+        case 9:
+          this._style.strikethrough = true;
+          break;
+        case 21:
+        case 22:
+          this._style.bold = false;
+          this._style.dim = false;
+          break;
+        case 23:
+          this._style.italic = false;
+          break;
+        case 24:
+          this._style.underline = false;
+          break;
+        case 27:
+          this._style.inverse = false;
+          break;
+        case 29:
+          this._style.strikethrough = false;
+          break;
+        case 39:
+          this._style.fg = void 0;
+          break;
+        case 49:
+          this._style.bg = void 0;
+          break;
+        case 38:
+        case 48:
+          index = this._applyExtendedColor(value, normalizedParams, index);
+          break;
+        default:
+          if (value >= 30 && value <= 37 || value >= 90 && value <= 97) {
+            this._style.fg = [value];
+          } else if (value >= 40 && value <= 47 || value >= 100 && value <= 107) {
+            this._style.bg = [value];
+          }
+          break;
+      }
+    }
+    this._styleSequence = serializeStyleState(this._style);
+  }
+  _applyExtendedColor(control, params17, index) {
+    const mode = params17[index + 1];
+    const target = control === 38 ? "fg" : "bg";
+    if (mode === 5) {
+      const paletteIndex = params17[index + 2];
+      if (paletteIndex !== void 0) {
+        this._style[target] = [control, 5, paletteIndex];
+        return index + 2;
+      }
+      return index;
+    }
+    if (mode === 2) {
+      const red = params17[index + 2];
+      const green = params17[index + 3];
+      const blue = params17[index + 4];
+      if (red !== void 0 && green !== void 0 && blue !== void 0) {
+        this._style[target] = [control, 2, red, green, blue];
+        return index + 4;
+      }
+    }
+    return index;
+  }
+};
+function createDefaultStyleState() {
+  return {
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false,
+    inverse: false,
+    strikethrough: false
+  };
+}
+function serializeStyleState(state) {
+  const codes = [];
+  if (state.bold) {
+    codes.push(1);
+  }
+  if (state.dim) {
+    codes.push(2);
+  }
+  if (state.italic) {
+    codes.push(3);
+  }
+  if (state.underline) {
+    codes.push(4);
+  }
+  if (state.inverse) {
+    codes.push(7);
+  }
+  if (state.strikethrough) {
+    codes.push(9);
+  }
+  if (state.fg !== void 0) {
+    codes.push(...state.fg);
+  }
+  if (state.bg !== void 0) {
+    codes.push(...state.bg);
+  }
+  return codes.length === 0 ? "" : `\x1B[${codes.join(";")}m`;
+}
+
+// src/keys.ts
+var NAMED_KEY_SEQUENCES = {
+  Enter: "\r",
+  Tab: "	",
+  Escape: "\x1B",
+  Backspace: "\x7F",
+  Delete: "\x1B[3~",
+  ArrowUp: "\x1B[A",
+  ArrowDown: "\x1B[B",
+  ArrowRight: "\x1B[C",
+  ArrowLeft: "\x1B[D",
+  Home: "\x1B[H",
+  End: "\x1B[F",
+  PageUp: "\x1B[5~",
+  PageDown: "\x1B[6~",
+  Space: " "
+};
+var NAMED_KEY_LOWER = new Map(
+  Object.entries(NAMED_KEY_SEQUENCES).map(([k, v]) => [k.toLowerCase(), v])
+);
+var VALID_KEYS_HINT = `Valid keys: ${Object.keys(NAMED_KEY_SEQUENCES).join(", ")}, Control+<letter>, Alt+<key>`;
+function unknownKeyError(key) {
+  return new Error(`Unknown terminal key: ${key}. ${VALID_KEYS_HINT}`);
+}
+function keyToSequence(key) {
+  const lowerKey = key.toLowerCase();
+  const namedSequence = NAMED_KEY_LOWER.get(lowerKey);
+  if (namedSequence !== void 0) {
+    return namedSequence;
+  }
+  if (lowerKey.startsWith("control+")) {
+    return controlKeyToSequence(key.slice("control+".length));
+  }
+  if (lowerKey.startsWith("alt+")) {
+    const nestedKey = key.slice("alt+".length);
+    if (nestedKey.length === 0) {
+      throw unknownKeyError(key);
+    }
+    if (nestedKey.length === 1) {
+      return "\x1B" + nestedKey;
+    }
+    try {
+      return "\x1B" + keyToSequence(nestedKey);
+    } catch {
+      throw unknownKeyError(key);
+    }
+  }
+  if (key.length === 1) {
+    return key;
+  }
+  throw unknownKeyError(key);
+}
+function controlKeyToSequence(controlKey) {
+  if (controlKey.length !== 1) {
+    throw unknownKeyError(`Control+${controlKey}`);
+  }
+  const uppercaseLetter = controlKey.toUpperCase();
+  const charCode = uppercaseLetter.charCodeAt(0);
+  if (charCode < 65 || charCode > 90) {
+    throw unknownKeyError(`Control+${controlKey}`);
+  }
+  return String.fromCharCode(charCode - 64);
+}
+
+// src/terminal-screen.ts
+var TerminalScreen = class {
+  lines;
+  rawLines;
+  cursor;
+  size;
+  constructor({
+    lines,
+    rawLines,
+    cursor,
+    size
+  }) {
+    this.lines = Object.freeze(lines.map((line) => stripAnsi(line)));
+    this.rawLines = Object.freeze([...rawLines]);
+    this.cursor = Object.freeze({ ...cursor });
+    this.size = Object.freeze({ ...size });
+    Object.freeze(this);
+  }
+  get text() {
+    return this.lines.join("\n");
+  }
+  contains(substring) {
+    return this.text.includes(substring);
+  }
+  line(index) {
+    const normalizedIndex = index < 0 ? this.lines.length + index : index;
+    const line = this.lines[normalizedIndex];
+    if (line === void 0) {
+      throw new RangeError(`Line index out of bounds: ${index}`);
+    }
+    return line;
+  }
+};
+
+// src/terminal-session.ts
+var DEFAULT_COLS = 120;
+var DEFAULT_ROWS = 40;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var WAIT_FOR_POLL_MS = 10;
+var TYPE_DELAY_MS = 15;
+var CLOSE_AFTER_SIGNAL_GRACE_MS = 250;
+var CLOSE_AFTER_SIGTERM_MS = 1e3;
+var TerminalSession = class {
+  id;
+  command;
+  pid;
+  exitCode = null;
+  pty;
+  terminal;
+  emitter = new EventEmitter();
+  exitPromise;
+  rawBuffer = "";
+  lastDataAt = Date.now();
+  currentCols;
+  currentRows;
+  closeRequested = false;
+  signalRequested = false;
+  constructor({
+    id,
+    command,
+    args = [],
+    cwd = process.cwd(),
+    env = process.env,
+    cols = DEFAULT_COLS,
+    rows = DEFAULT_ROWS,
+    observe = false
+  }) {
+    this.id = id;
+    this.command = command;
+    this.currentCols = cols;
+    this.currentRows = rows;
+    this.terminal = new TerminalBuffer(cols, rows);
+    this.pty = createPtyProcess({ command, args, cwd, env, cols, rows });
+    this.pid = this.pty.pid;
+    const dataSubscription = this.pty.onData((chunk) => {
+      this.rawBuffer += chunk;
+      this.lastDataAt = Date.now();
+      this.terminal.write(chunk);
+      if (observe) {
+        process.stderr.write(chunk);
+      }
+    });
+    let exitSubscription;
+    this.exitPromise = new Promise((resolve) => {
+      exitSubscription = this.pty.onExit(({ exitCode }) => {
+        if (this.exitCode !== null) {
+          resolve(this.exitCode);
+          return;
+        }
+        this.exitCode = exitCode;
+        dataSubscription.dispose();
+        exitSubscription?.dispose();
+        this.emitter.emit("exit", exitCode);
+        resolve(exitCode);
+      });
+    });
+  }
+  async type(text) {
+    for (const character of text) {
+      await this.send(character);
+      await sleep(TYPE_DELAY_MS);
+    }
+  }
+  async fill(text) {
+    await this.send(text.replace(/\r?\n/g, "\r"));
+  }
+  async press(key) {
+    await this.send(keyToSequence(key));
+  }
+  async send(raw) {
+    if (this.exitCode !== null) {
+      return;
+    }
+    this.pty.write(raw);
+  }
+  async signal(sig) {
+    if (this.exitCode !== null) {
+      return;
+    }
+    this.signalRequested = true;
+    this.pty.kill(sig);
+  }
+  async waitFor(pattern, opts) {
+    const timeout = opts?.timeout ?? DEFAULT_TIMEOUT_MS;
+    const startedAt = Date.now();
+    while (Date.now() - startedAt <= timeout) {
+      const matched = matchPattern(this.rawBuffer, pattern);
+      if (matched !== null) {
+        return matched;
+      }
+      await sleep(WAIT_FOR_POLL_MS);
+    }
+    throw new Error(`Timed out waiting for pattern after ${timeout}ms: ${String(pattern)}`);
+  }
+  async waitForQuiet(ms) {
+    while (true) {
+      const remaining = ms - (Date.now() - this.lastDataAt);
+      if (remaining <= 0) {
+        return;
+      }
+      await sleep(remaining);
+    }
+  }
+  async screen() {
+    const rawLines = [];
+    for (let row = 0; row < this.currentRows; row += 1) {
+      rawLines.push(this.terminal.renderLine(row));
+    }
+    return new TerminalScreen({
+      lines: rawLines,
+      rawLines,
+      cursor: {
+        row: this.terminal.displayBuffer.cursorY,
+        col: this.terminal.displayBuffer.cursorX
+      },
+      size: {
+        rows: this.currentRows,
+        cols: this.currentCols
+      }
+    });
+  }
+  async history(opts) {
+    const normalized = normalizeHistoryBuffer(stripAnsi(this.rawBuffer));
+    const lines = splitHistoryLines(normalized);
+    if (opts?.last === void 0) {
+      return lines;
+    }
+    const start = Math.max(0, lines.length - opts.last);
+    return lines.slice(start);
+  }
+  async resize(cols, rows) {
+    this.currentCols = cols;
+    this.currentRows = rows;
+    if (this.exitCode === null) {
+      this.pty.resize(cols, rows);
+    }
+    this.terminal.resize(cols, rows);
+  }
+  async waitForExit(opts) {
+    if (this.exitCode !== null) {
+      return this.exitCode;
+    }
+    if (opts?.timeout !== void 0) {
+      const result = await waitForExit(this.exitPromise, opts.timeout);
+      if (result === null) {
+        throw new Error(`Timed out waiting for process to exit after ${opts.timeout}ms`);
+      }
+      return result;
+    }
+    return this.exitPromise;
+  }
+  async close() {
+    if (this.exitCode !== null) {
+      return this.exitCode;
+    }
+    if (!this.closeRequested) {
+      this.closeRequested = true;
+      const gracefulExitCode = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGNAL_GRACE_MS);
+      if (gracefulExitCode !== null) {
+        return gracefulExitCode;
+      }
+      if (this.signalRequested) {
+        return this.exitPromise;
+      }
+      if (this.exitCode === null) {
+        this.pty.kill("SIGTERM");
+        const afterSigterm = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGTERM_MS);
+        if (afterSigterm !== null) {
+          return afterSigterm;
+        }
+      }
+      if (this.exitCode === null) {
+        this.pty.kill("SIGKILL");
+      }
+    }
+    return this.exitPromise;
+  }
+  on(event, cb) {
+    this.emitter.on(event, cb);
+  }
+};
+function createPtyProcess({
+  command,
+  args,
+  cwd,
+  env,
+  cols,
+  rows
+}) {
+  try {
+    return nodePty.spawn(command, args, {
+      cwd,
+      env,
+      cols,
+      rows,
+      encoding: "utf8"
+    });
+  } catch {
+    return createChildProcessFallback({ command, args, cwd, env });
+  }
+}
+function createChildProcessFallback({
+  command,
+  args,
+  cwd,
+  env
+}) {
+  const child = spawnChildProcess(command, args, {
+    cwd,
+    env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return new ChildProcessFallback(child);
+}
+var ChildProcessFallback = class {
+  pid;
+  child;
+  dataEmitter = new EventEmitter();
+  exitEmitter = new EventEmitter();
+  constructor(child) {
+    this.child = child;
+    this.pid = child.pid ?? -1;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", this.handleData);
+    child.stderr.on("data", this.handleData);
+    child.on("exit", (exitCode, signal) => {
+      this.exitEmitter.emit("exit", {
+        exitCode: exitCode ?? signalToExitCode(signal),
+        signal: void 0
+      });
+    });
+  }
+  write(data) {
+    this.child.stdin.write(data);
+  }
+  resize() {
+  }
+  kill(signal) {
+    this.child.kill(signal);
+  }
+  onData(listener) {
+    this.dataEmitter.on("data", listener);
+    return {
+      dispose: () => {
+        this.dataEmitter.off("data", listener);
+      }
+    };
+  }
+  onExit(listener) {
+    this.exitEmitter.on("exit", listener);
+    return {
+      dispose: () => {
+        this.exitEmitter.off("exit", listener);
+      }
+    };
+  }
+  handleData = (chunk) => {
+    this.dataEmitter.emit("data", String(chunk));
+  };
+};
+function signalToExitCode(signal) {
+  if (signal === null) {
+    return 0;
+  }
+  const signalNumbers = {
+    SIGTERM: 15,
+    SIGINT: 2,
+    SIGHUP: 1,
+    SIGKILL: 9
+  };
+  const signalNumber = signalNumbers[signal];
+  if (signalNumber === void 0) {
+    return 1;
+  }
+  return 128 + signalNumber;
+}
+function matchPattern(buffer, pattern) {
+  const clean = normalizeHistoryBuffer(stripAnsi(buffer));
+  for (const line of clean.split("\n")) {
+    if (typeof pattern === "string") {
+      if (line.includes(pattern)) return line;
+    } else {
+      const flags = removeCharacter(pattern.flags, "g");
+      if (new RegExp(pattern.source, flags).test(line)) return line;
+    }
+  }
+  return null;
+}
+function removeCharacter(input, charToRemove) {
+  let output = "";
+  for (const character of input) {
+    if (character !== charToRemove) {
+      output += character;
+    }
+  }
+  return output;
+}
+function splitHistoryLines(input) {
+  const lines = input.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines;
+}
+function normalizeHistoryBuffer(input) {
+  let output = "";
+  for (const character of input) {
+    if (character === "\r" || character === "\b") {
+      continue;
+    }
+    output += character;
+  }
+  return output;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function waitForExit(exitPromise, timeout) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(null);
+    }, timeout);
+    void exitPromise.then((code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(code);
+    });
+  });
+}
+
+// src/terminal-pilot.ts
+var DEFAULT_COLS2 = 120;
+var DEFAULT_ROWS2 = 40;
+var TerminalPilot = class _TerminalPilot {
+  sessionMap = /* @__PURE__ */ new Map();
+  static async launch() {
+    return new _TerminalPilot();
+  }
+  async newSession(opts) {
+    const session = new TerminalSession({
+      id: randomUUID(),
+      command: opts.command,
+      args: opts.args,
+      cwd: opts.cwd,
+      env: opts.env,
+      cols: opts.cols ?? DEFAULT_COLS2,
+      rows: opts.rows ?? DEFAULT_ROWS2,
+      observe: opts.observe ?? false
+    });
+    this.sessionMap.set(session.id, session);
+    return session;
+  }
+  getSession(id) {
+    const session = this.sessionMap.get(id);
+    if (session === void 0) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    return session;
+  }
+  deleteSession(id) {
+    this.sessionMap.delete(id);
+  }
+  sessions() {
+    return [...this.sessionMap.values()].filter((s) => s.exitCode === null);
+  }
+  async close() {
+    const sessions = [...this.sessionMap.values()];
+    try {
+      await Promise.all(sessions.map((session) => session.close()));
+    } finally {
+      this.sessionMap.clear();
+    }
+  }
+};
+
+// src/commands/runtime.ts
+var SESSION_ENV_VAR = "TERMINAL_PILOT_SESSION";
+var sharedRuntime;
+function getTerminalPilotRuntime(runtime) {
+  if (runtime !== void 0) {
+    return runtime;
+  }
+  sharedRuntime ??= createTerminalPilotRuntime();
+  return sharedRuntime;
+}
+function createTerminalPilotRuntime(options = {}) {
+  const launchPilot = options.launchPilot ?? TerminalPilot.launch;
+  const nameToId = /* @__PURE__ */ new Map();
+  const idToName = /* @__PURE__ */ new Map();
+  let pilotPromise;
+  function getRequestedName(name, env) {
+    return name ?? env?.get(SESSION_ENV_VAR);
+  }
+  async function getPilot() {
+    pilotPromise ??= launchPilot();
+    return pilotPromise;
+  }
+  function nextSessionName() {
+    let index = 1;
+    while (nameToId.has(`s${index}`)) {
+      index += 1;
+    }
+    return `s${index}`;
+  }
+  function rememberSession(name, session) {
+    nameToId.set(name, session.id);
+    idToName.set(session.id, name);
+    return { name, session };
+  }
+  function forgetSession(name, sessionId) {
+    nameToId.delete(name);
+    idToName.delete(sessionId);
+  }
+  function formatAvailableSessions(names) {
+    if (names.length === 0) {
+      return "No active sessions are available.";
+    }
+    return `Available sessions: ${names.join(", ")}.`;
+  }
+  async function lookupNamedSession(name) {
+    const sessionId = nameToId.get(name);
+    if (sessionId === void 0) {
+      const active = await listSessions2();
+      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+    }
+    const pilot = await getPilot();
+    try {
+      return { name, session: pilot.getSession(sessionId) };
+    } catch {
+      forgetSession(name, sessionId);
+      const active = await listSessions2();
+      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+    }
+  }
+  async function listSessions2() {
+    const pilot = await getPilot();
+    return pilot.sessions().flatMap((session) => {
+      const name = idToName.get(session.id);
+      if (name === void 0) {
+        return [];
+      }
+      return [{ name, session }];
+    });
+  }
+  return {
+    async createSession(params17, env) {
+      const requestedName = getRequestedName(params17.session, env) ?? nextSessionName();
+      if (nameToId.has(requestedName)) {
+        throw new UserError(`Session "${requestedName}" already exists.`);
+      }
+      const pilot = await getPilot();
+      const session = await pilot.newSession({
+        command: params17.command,
+        args: params17.args,
+        cwd: params17.cwd,
+        cols: params17.cols,
+        rows: params17.rows,
+        observe: params17.observe
+      });
+      return rememberSession(requestedName, session);
+    },
+    async resolveSession(name, env) {
+      const requestedName = getRequestedName(name, env);
+      if (requestedName !== void 0) {
+        return lookupNamedSession(requestedName);
+      }
+      const active = await listSessions2();
+      if (active.length === 1) {
+        return active[0];
+      }
+      if (active.length === 0) {
+        throw new UserError("No active sessions. Create one with create-session.");
+      }
+      throw new UserError(
+        `Multiple active sessions require an explicit session name. Pass --session or set ${SESSION_ENV_VAR}. ${formatAvailableSessions(active.map((entry) => entry.name))}`
+      );
+    },
+    async closeSession(name, env) {
+      const namedSession = await this.resolveSession(name, env);
+      const exitCode = await namedSession.session.close();
+      const pilot = await getPilot();
+      pilot.deleteSession(namedSession.session.id);
+      forgetSession(namedSession.name, namedSession.session.id);
+      return {
+        exitCode,
+        name: namedSession.name
+      };
+    },
+    listSessions: listSessions2,
+    async close() {
+      if (pilotPromise === void 0) {
+        return;
+      }
+      const pilot = await pilotPromise;
+      await pilot.close();
+      pilotPromise = void 0;
+      nameToId.clear();
+      idToName.clear();
+    }
+  };
+}
+async function closeSharedTerminalPilotRuntime() {
+  if (sharedRuntime === void 0) {
+    return;
+  }
+  await sharedRuntime.close();
+  sharedRuntime = void 0;
+}
+
+// src/commands/close-session.ts
+var params = S.Object({
+  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+});
+var closeSession = defineCommand({
+  name: "close-session",
+  description: "Close an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  params,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const { exitCode } = await getTerminalPilotRuntime(terminalPilotRuntime).closeSession(params17.session, env);
+    return { exitCode };
+  }
+});
+
+// src/commands/create-session.ts
+import { defineCommand as defineCommand2, S as S2 } from "@poe-code/cmdkit";
+var params2 = S2.Object({
+  command: S2.String({ description: "Command to execute" }),
+  args: S2.Optional(S2.Array(S2.String(), { description: "Command arguments" })),
+  session: S2.Optional(S2.String({ short: "s", description: "Session name" })),
+  cwd: S2.Optional(S2.String({ description: "Working directory" })),
+  cols: S2.Optional(S2.Number({ description: "Terminal width in columns" })),
+  rows: S2.Optional(S2.Number({ description: "Terminal height in rows" })),
+  observe: S2.Optional(S2.Boolean({ description: "Mirror PTY output to stderr" }))
+});
+var createSession = defineCommand2({
+  name: "create-session",
+  description: "Spawn an interactive CLI in a PTY",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["command", "args"],
+  params: params2,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).createSession(params17, env);
+    return { session: namedSession.name, pid: namedSession.session.pid };
+  }
+});
+
+// src/commands/fill.ts
+import { defineCommand as defineCommand3, S as S3 } from "@poe-code/cmdkit";
+var params3 = S3.Object({
+  text: S3.String({ description: "Text to write to the session" }),
+  session: S3.Optional(S3.String({ short: "s", description: "Session name" }))
+});
+var fill = defineCommand3({
+  name: "fill",
+  description: "Write text to an active terminal session all at once (replaces \\n with \\r)",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["text"],
+  params: params3,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.fill(params17.text);
+    return void 0;
+  }
+});
+
+// src/commands/get-session.ts
+import { defineCommand as defineCommand4, S as S4 } from "@poe-code/cmdkit";
+var params4 = S4.Object({
+  session: S4.Optional(S4.String({ short: "s", description: "Session name" }))
+});
+var getSession = defineCommand4({
+  name: "get-session",
+  description: "Get session metadata (name, pid, command, exitCode)",
+  scope: ["cli", "mcp", "sdk"],
+  params: params4,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    return {
+      session: namedSession.name,
+      pid: namedSession.session.pid,
+      command: namedSession.session.command,
+      exitCode: namedSession.session.exitCode
+    };
+  }
+});
+
+// src/commands/install.ts
+import { installSkill } from "@poe-code/agent-skill-config";
+import { defineCommand as defineCommand5, S as S5 } from "@poe-code/cmdkit";
+
+// src/commands/installer.ts
+import os from "node:os";
+import path from "node:path";
+import * as nodeFs from "node:fs/promises";
+import { readFile } from "node:fs/promises";
+import { UserError as UserError2 } from "@poe-code/cmdkit";
+import {
+  getAgentConfig,
+  resolveAgentSupport as resolveSkillAgentSupport,
+  supportedAgents as skillSupportedAgents
+} from "@poe-code/agent-skill-config";
+var DEFAULT_INSTALL_AGENT = "claude-code";
+var DEFAULT_INSTALL_SCOPE = "local";
+var TERMINAL_PILOT_SKILL_NAME = "terminal-pilot";
+var installableAgents = skillSupportedAgents;
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function resolveInstallerServices(installer) {
+  return {
+    fs: installer?.fs ?? nodeFs,
+    cwd: installer?.cwd ?? process.cwd(),
+    homeDir: installer?.homeDir ?? os.homedir(),
+    platform: installer?.platform ?? process.platform
+  };
+}
+function throwUnsupportedAgent(agent) {
+  throw new UserError2(`Unsupported agent: ${agent}`);
+}
+function resolveInstallableAgent(agent) {
+  const skillSupport = resolveSkillAgentSupport(agent);
+  if (skillSupport.status !== "supported" || !skillSupport.id) {
+    throwUnsupportedAgent(agent);
+  }
+  return skillSupport.id;
+}
+function resolveInstallScope(input) {
+  if (input.local && input.global) {
+    throw new UserError2("Use either --local or --global, not both.");
+  }
+  if (input.local) {
+    return "local";
+  }
+  if (input.global) {
+    return "global";
+  }
+  return DEFAULT_INSTALL_SCOPE;
+}
+var terminalPilotTemplateCache;
+async function loadTerminalPilotTemplate() {
+  if (terminalPilotTemplateCache !== void 0) {
+    return terminalPilotTemplateCache;
+  }
+  const candidates = [
+    new URL("./templates/terminal-pilot.md", import.meta.url),
+    new URL("../templates/terminal-pilot.md", import.meta.url),
+    new URL("../../../agent-skill-config/src/templates/terminal-pilot.md", import.meta.url)
+  ];
+  for (const candidate of candidates) {
+    try {
+      terminalPilotTemplateCache = await readFile(candidate, "utf8");
+      return terminalPilotTemplateCache;
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  throw new UserError2("terminal-pilot skill template is missing.");
+}
+function resolveHomeRelativePath(targetPath, homeDir) {
+  if (targetPath === "~") {
+    return homeDir;
+  }
+  if (targetPath.startsWith("~/")) {
+    return path.join(homeDir, targetPath.slice(2));
+  }
+  return targetPath;
+}
+function getSkillFolderWithHome(agent, scope, cwd, homeDir) {
+  const config = getAgentConfig(agent);
+  if (!config) {
+    throwUnsupportedAgent(agent);
+  }
+  return {
+    displayPath: path.join(
+      scope === "global" ? config.globalSkillDir : config.localSkillDir,
+      TERMINAL_PILOT_SKILL_NAME
+    ),
+    fullPath: path.join(
+      scope === "global" ? resolveHomeRelativePath(config.globalSkillDir, homeDir) : path.resolve(cwd, config.localSkillDir),
+      TERMINAL_PILOT_SKILL_NAME
+    )
+  };
+}
+async function removeSkillFolder(fs, folderPath) {
+  try {
+    await fs.stat(folderPath);
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
+  }
+  if (typeof fs.rm !== "function") {
+    throw new UserError2("The configured filesystem does not support removing directories.");
+  }
+  await fs.rm(folderPath, { recursive: true, force: true });
+  return true;
+}
+
+// src/commands/install.ts
+var params5 = S5.Object({
+  agent: S5.Enum(installableAgents, {
+    description: "Agent to install terminal-pilot for",
+    default: DEFAULT_INSTALL_AGENT
+  }),
+  local: S5.Optional(S5.Boolean({ description: "Install the skill in the current project" })),
+  global: S5.Optional(S5.Boolean({ description: "Install the skill in the user home directory" }))
+});
+var install = defineCommand5({
+  name: "install",
+  description: "Install the terminal-pilot CLI skill.",
+  scope: ["cli"],
+  positional: ["agent"],
+  params: params5,
+  handler: async ({ params: params17, terminalPilotInstaller }) => {
+    const services = resolveInstallerServices(terminalPilotInstaller);
+    const agent = resolveInstallableAgent(params17.agent);
+    const scope = resolveInstallScope(params17);
+    const template = await loadTerminalPilotTemplate();
+    const skillResult = await installSkill(
+      agent,
+      {
+        name: TERMINAL_PILOT_SKILL_NAME,
+        content: template
+      },
+      {
+        fs: services.fs,
+        cwd: services.cwd,
+        homeDir: services.homeDir,
+        scope
+      }
+    );
+    return {
+      agent,
+      scope,
+      skillPath: skillResult.displayPath
+    };
+  }
+});
+
+// src/commands/list-sessions.ts
+import { defineCommand as defineCommand6, S as S6 } from "@poe-code/cmdkit";
+var params6 = S6.Object({});
+var listSessions = defineCommand6({
+  name: "list-sessions",
+  description: "List active terminal sessions",
+  scope: ["cli", "mcp", "sdk"],
+  params: params6,
+  handler: async ({ terminalPilotRuntime }) => {
+    const sessions = await getTerminalPilotRuntime(terminalPilotRuntime).listSessions();
+    return {
+      sessions: sessions.map((namedSession) => ({
+        session: namedSession.name,
+        command: namedSession.session.command,
+        pid: namedSession.session.pid
+      }))
+    };
+  }
+});
+
+// src/commands/press-key.ts
+import { defineCommand as defineCommand7, S as S7 } from "@poe-code/cmdkit";
+var params7 = S7.Object({
+  key: S7.String({ description: "Named key to press" }),
+  session: S7.Optional(S7.String({ short: "s", description: "Session name" }))
+});
+var pressKey = defineCommand7({
+  name: "press-key",
+  description: "Send a named key press to an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["key"],
+  params: params7,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.press(params17.key);
+    return void 0;
+  }
+});
+
+// src/commands/read-history.ts
+import { defineCommand as defineCommand8, S as S8 } from "@poe-code/cmdkit";
+var params8 = S8.Object({
+  session: S8.Optional(S8.String({ short: "s", description: "Session name" })),
+  last: S8.Optional(S8.Number({ short: "n", description: "Return only the last N lines" }))
+});
+var readHistory = defineCommand8({
+  name: "read-history",
+  description: "Read terminal output history",
+  scope: ["cli", "mcp", "sdk"],
+  params: params8,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const lines = await namedSession.session.history({ last: params17.last });
+    return { lines, exitCode: namedSession.session.exitCode };
+  }
+});
+
+// src/commands/read-screen.ts
+import { defineCommand as defineCommand9, S as S9 } from "@poe-code/cmdkit";
+var params9 = S9.Object({
+  session: S9.Optional(S9.String({ short: "s", description: "Session name" }))
+});
+var readScreen = defineCommand9({
+  name: "read-screen",
+  description: "Read the current visible terminal screen",
+  scope: ["cli", "mcp", "sdk"],
+  params: params9,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const screen = await namedSession.session.screen();
+    return {
+      lines: [...screen.lines],
+      cursor: { ...screen.cursor },
+      size: { ...screen.size },
+      exitCode: namedSession.session.exitCode
+    };
+  }
+});
+
+// src/commands/resize.ts
+import { defineCommand as defineCommand10, S as S10 } from "@poe-code/cmdkit";
+var params10 = S10.Object({
+  cols: S10.Number({ description: "Terminal width in columns" }),
+  rows: S10.Number({ description: "Terminal height in rows" }),
+  session: S10.Optional(S10.String({ short: "s", description: "Session name" }))
+});
+var resize = defineCommand10({
+  name: "resize",
+  description: "Resize an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  params: params10,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.resize(params17.cols, params17.rows);
+    return void 0;
+  }
+});
+
+// src/commands/screenshot.ts
+import { defineCommand as defineCommand11, S as S11 } from "@poe-code/cmdkit";
+import { renderTerminalPng } from "terminal-png";
+var params11 = S11.Object({
+  session: S11.Optional(S11.String({ short: "s", description: "Session name" })),
+  output: S11.String({ short: "o", description: "Path to the output PNG file" }),
+  window: S11.Optional(S11.Boolean({ description: "Include terminal window chrome", default: true })),
+  padding: S11.Optional(S11.Number({ short: "p", description: "Padding around terminal content" }))
+});
+var screenshot = defineCommand11({
+  name: "screenshot",
+  description: "Capture the current terminal screen as a PNG image",
+  scope: ["cli"],
+  params: params11,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const screen = await namedSession.session.screen();
+    await renderTerminalPng(screen.rawLines.join("\n"), {
+      output: params17.output,
+      window: params17.window,
+      padding: params17.padding
+    });
+    return void 0;
+  }
+});
+
+// src/commands/send-signal.ts
+import { defineCommand as defineCommand12, S as S12 } from "@poe-code/cmdkit";
+var params12 = S12.Object({
+  signal: S12.String({ description: "Signal to send to the session process" }),
+  session: S12.Optional(S12.String({ short: "s", description: "Session name" }))
+});
+var sendSignal = defineCommand12({
+  name: "send-signal",
+  description: "Send a process signal to an active terminal session",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["signal"],
+  params: params12,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.signal(params17.signal);
+    return void 0;
+  }
+});
+
+// src/commands/type.ts
+import { defineCommand as defineCommand13, S as S13 } from "@poe-code/cmdkit";
+var params13 = S13.Object({
+  text: S13.String({ description: "Text to write to the session" }),
+  session: S13.Optional(S13.String({ short: "s", description: "Session name" }))
+});
+var type = defineCommand13({
+  name: "type",
+  description: "Write text to an active terminal session character-by-character with delay",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["text"],
+  params: params13,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    await namedSession.session.type(params17.text);
+    return void 0;
+  }
+});
+
+// src/commands/uninstall.ts
+import { defineCommand as defineCommand14, S as S14 } from "@poe-code/cmdkit";
+var params14 = S14.Object({
+  agent: S14.Enum(installableAgents, {
+    description: "Agent to uninstall terminal-pilot from",
+    default: DEFAULT_INSTALL_AGENT
+  })
+});
+var uninstall = defineCommand14({
+  name: "uninstall",
+  description: "Remove the terminal-pilot CLI skill.",
+  scope: ["cli"],
+  positional: ["agent"],
+  params: params14,
+  handler: async ({ params: params17, terminalPilotInstaller }) => {
+    const services = resolveInstallerServices(terminalPilotInstaller);
+    const agent = resolveInstallableAgent(params17.agent);
+    const localSkill = getSkillFolderWithHome(
+      agent,
+      "local",
+      services.cwd,
+      services.homeDir
+    );
+    const globalSkill = getSkillFolderWithHome(
+      agent,
+      "global",
+      services.cwd,
+      services.homeDir
+    );
+    const removedSkillPaths = [];
+    if (await removeSkillFolder(services.fs, localSkill.fullPath)) {
+      removedSkillPaths.push(localSkill.displayPath);
+    }
+    if (await removeSkillFolder(services.fs, globalSkill.fullPath)) {
+      removedSkillPaths.push(globalSkill.displayPath);
+    }
+    return {
+      agent,
+      removedSkillPaths
+    };
+  }
+});
+
+// src/commands/wait-for.ts
+import { defineCommand as defineCommand15, S as S15 } from "@poe-code/cmdkit";
+var params15 = S15.Object({
+  pattern: S15.String({ description: "Regular expression pattern to wait for" }),
+  session: S15.Optional(S15.String({ short: "s", description: "Session name" })),
+  timeout: S15.Optional(S15.Number({ short: "t", description: "Maximum wait time in milliseconds" })),
+  literal: S15.Optional(
+    S15.Boolean({
+      short: "l",
+      description: "When true, treat pattern as a literal string instead of a regex"
+    })
+  )
+});
+var waitFor = defineCommand15({
+  name: "wait-for",
+  description: "Wait for terminal output to match a pattern",
+  scope: ["cli", "mcp", "sdk"],
+  positional: ["pattern"],
+  params: params15,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const pattern = params17.literal === true ? params17.pattern : new RegExp(params17.pattern);
+    const line = params17.timeout === void 0 ? await namedSession.session.waitFor(pattern) : await namedSession.session.waitFor(pattern, { timeout: params17.timeout });
+    return { matched: true, line };
+  }
+});
+
+// src/commands/wait-for-exit.ts
+import { defineCommand as defineCommand16, S as S16 } from "@poe-code/cmdkit";
+var params16 = S16.Object({
+  session: S16.Optional(S16.String({ short: "s", description: "Session name" })),
+  timeout: S16.Optional(S16.Number({ short: "t", description: "Maximum wait time in milliseconds" }))
+});
+var waitForExit2 = defineCommand16({
+  name: "wait-for-exit",
+  description: "Wait for a terminal session process to finish",
+  scope: ["cli", "mcp", "sdk"],
+  params: params16,
+  handler: async ({ params: params17, env, terminalPilotRuntime }) => {
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const exitCode = await namedSession.session.waitForExit(
+      params17.timeout === void 0 ? void 0 : { timeout: params17.timeout }
+    );
+    return { exitCode };
+  }
+});
+
+// src/commands/index.ts
+var children = [
+  install,
+  uninstall,
+  createSession,
+  fill,
+  type,
+  pressKey,
+  sendSignal,
+  waitFor,
+  waitForExit2,
+  readScreen,
+  screenshot,
+  readHistory,
+  resize,
+  closeSession,
+  getSession,
+  listSessions
+];
+var terminalPilotGroup = defineGroup({
+  name: "terminal-pilot",
+  scope: ["cli", "mcp", "sdk"],
+  children
+});
+
+// src/cli.ts
+function normalizeArgv(argv) {
+  if (argv.includes("--json") && !argv.some((argument) => argument === "--output" || argument.startsWith("--output="))) {
+    return argv.flatMap((argument) => argument === "--json" ? ["--output", "json"] : [argument]);
+  }
+  return argv;
+}
+async function main(argv = process.argv) {
+  const originalArgv = process.argv;
+  process.argv = normalizeArgv(argv);
+  try {
+    await runCLI(terminalPilotGroup);
+  } finally {
+    process.argv = originalArgv;
+  }
+}
+async function isDirectExecution(argv) {
+  const entryPoint = argv[1];
+  if (typeof entryPoint !== "string" || entryPoint.length === 0) {
+    return false;
+  }
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    const [resolvedEntryPoint, resolvedModulePath] = await Promise.all([
+      realpath(path2.resolve(entryPoint)),
+      realpath(modulePath)
+    ]);
+    return resolvedEntryPoint === resolvedModulePath;
+  } catch {
+    return false;
+  }
+}
+if (await isDirectExecution(process.argv)) {
+  await main();
+}
+
+// src/testing/cli-repl.ts
+function appendJsonOutputFlag(args) {
+  if (args.includes("--json") || args.includes("--output") || args.some((arg) => arg.startsWith("--output="))) {
+    return [...args];
+  }
+  const ddashIndex = args.indexOf("--");
+  if (ddashIndex === -1) {
+    return [...args, "--output", "json"];
+  }
+  return [...args.slice(0, ddashIndex), "--output", "json", "--", ...args.slice(ddashIndex + 1)];
+}
+function toText(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return String(chunk);
+}
+function normalizeOutput(text) {
+  return stripAnsi(text).replaceAll("\r", "").trim();
+}
+function canParseJson(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createTerminalPilotCliRepl() {
+  return {
+    async run(args) {
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+      const originalStderrWrite = process.stderr.write.bind(process.stderr);
+      const previousExitCode = process.exitCode;
+      process.exitCode = 0;
+      process.stdout.write = ((chunk, ...rest) => {
+        stdoutChunks.push(toText(chunk));
+        const callback = typeof rest.at(-1) === "function" ? rest.at(-1) : void 0;
+        callback?.();
+        return true;
+      });
+      process.stderr.write = ((chunk, ...rest) => {
+        stderrChunks.push(toText(chunk));
+        const callback = typeof rest.at(-1) === "function" ? rest.at(-1) : void 0;
+        callback?.();
+        return true;
+      });
+      try {
+        await main(["node", "terminal-pilot", ...args]);
+      } finally {
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+      }
+      const exitCode = process.exitCode ?? 0;
+      process.exitCode = previousExitCode;
+      let stdout = normalizeOutput(stdoutChunks.join(""));
+      let stderr = normalizeOutput(stderrChunks.join(""));
+      if (exitCode !== 0 && stderr.length === 0 && !canParseJson(stdout)) {
+        stderr = stdout;
+        stdout = "";
+      }
+      return {
+        exitCode,
+        stdout,
+        stderr
+      };
+    },
+    async runJson(args) {
+      const result = await this.run(appendJsonOutputFlag(args));
+      if (result.exitCode !== 0) {
+        return {
+          exitCode: result.exitCode,
+          stdout: void 0,
+          stderr: result.stderr
+        };
+      }
+      if (result.stdout.length === 0) {
+        throw new Error(`Expected JSON output for terminal-pilot ${args.join(" ")}, but stdout was empty.`);
+      }
+      return {
+        exitCode: result.exitCode,
+        stdout: JSON.parse(result.stdout),
+        stderr: result.stderr
+      };
+    },
+    async close() {
+      await closeSharedTerminalPilotRuntime();
+    }
+  };
+}
+
+// src/testing/qa-cli.ts
+var testingDirectory = path3.dirname(fileURLToPath2(import.meta.url));
+var repoRoot = path3.resolve(testingDirectory, "../../../..");
+var tsxPath = path3.join(repoRoot, "node_modules", ".bin", "tsx");
+var testCliPath = path3.join(repoRoot, "packages/terminal-pilot/src/testing/test-cli.js");
+var menuCliPath = path3.join(repoRoot, "packages/terminal-pilot/src/testing/menu-cli.js");
+var vimSavedFile = path3.join(os2.tmpdir(), "terminal-pilot-qa-test.txt");
+var vimDiscardFile = path3.join(os2.tmpdir(), "terminal-pilot-qa-discard.txt");
+var QaContext = class {
+  repl = createTerminalPilotCliRepl();
+  async close() {
+    await this.repl.close();
+  }
+  async expectOk(args) {
+    const result = await this.repl.runJson(args);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Command failed (${result.exitCode}): terminal-pilot ${args.join(" ")}
+${result.stderr || "<no error output>"}`
+      );
+    }
+    return result.stdout;
+  }
+  async expectError(args) {
+    const result = await this.repl.run(args);
+    if (result.exitCode === 0) {
+      throw new Error(
+        `Expected command to fail: terminal-pilot ${args.join(" ")}
+stdout: ${result.stdout || "<empty>"}`
+      );
+    }
+    return result.stderr || result.stdout;
+  }
+  async listSessions() {
+    return this.expectOk(["list-sessions"]);
+  }
+  async getSessionIfExists(session) {
+    const result = await this.repl.runJson(["get-session", "-s", session]);
+    if (result.exitCode !== 0) return null;
+    return result.stdout;
+  }
+  async closeSessionIfExists(session) {
+    const existing = await this.getSessionIfExists(session);
+    if (existing !== null) {
+      await this.expectOk(["close-session", "-s", session]);
+    }
+  }
+  async ensurePromptSession(session) {
+    const existing = await this.getSessionIfExists(session);
+    if (existing?.exitCode !== null) {
+      await this.expectOk(["close-session", "-s", session]);
+    }
+    if (existing === null || existing.exitCode !== null) {
+      const created = await this.expectOk([
+        "create-session",
+        "-s",
+        session,
+        tsxPath,
+        testCliPath
+      ]);
+      assert.equal(created.session, session);
+      assert.ok(created.pid > 0);
+    }
+    const screen = await this.expectOk(["read-screen", "-s", session]);
+    if (!screen.lines.some((line) => line.includes("What is your name?"))) {
+      const prompt = await this.expectOk([
+        "wait-for",
+        "-s",
+        session,
+        "-l",
+        "What is your name?"
+      ]);
+      assert.equal(prompt.matched, true);
+    }
+  }
+  async ensureGreetingSession(session, name) {
+    await this.ensurePromptSession(session);
+    const history = await this.expectOk(["read-history", "-s", session]);
+    if (history.lines.some((line) => line.includes(`Hello, ${name}!`))) {
+      return;
+    }
+    await this.expectOk(["fill", "-s", session, `${name}
+`]);
+    const greeted = await this.expectOk([
+      "wait-for",
+      "-s",
+      session,
+      "-l",
+      `Hello, ${name}!`
+    ]);
+    assert.equal(greeted.matched, true);
+  }
+};
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function removeIfExists(filePath) {
+  await rm(filePath, { force: true });
+}
+async function closeSessions(ctx, sessions) {
+  for (const session of sessions) {
+    await ctx.closeSessionIfExists(session);
+  }
+}
+var cases = [
+  {
+    id: 1,
+    title: "Empty session list",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S1");
+      const listed = await ctx.listSessions();
+      assert.deepEqual(listed.sessions, []);
+    }
+  },
+  {
+    id: 2,
+    title: "Create a session",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S1");
+      const created = await ctx.expectOk([
+        "create-session",
+        "-s",
+        "S1",
+        tsxPath,
+        testCliPath
+      ]);
+      assert.equal(created.session, "S1");
+      assert.ok(created.pid > 0);
+    }
+  },
+  {
+    id: 3,
+    title: "Session appears in list",
+    async run(ctx) {
+      await ctx.ensurePromptSession("S1");
+      const listed = await ctx.listSessions();
+      assert.equal(listed.sessions.length, 1);
+      assert.equal(listed.sessions[0]?.session, "S1");
+    }
+  },
+  {
+    id: 4,
+    title: "Get session metadata",
+    async run(ctx) {
+      await ctx.ensurePromptSession("S1");
+      const session = await ctx.expectOk(["get-session", "-s", "S1"]);
+      assert.equal(session.session, "S1");
+      assert.ok(session.pid > 0);
+      assert.match(session.command, /tsx/);
+      assert.equal(session.exitCode, null);
+    }
+  },
+  {
+    id: 5,
+    title: "Wait for prompt",
+    async run(ctx) {
+      await ctx.ensurePromptSession("S1");
+      const waited = await ctx.expectOk([
+        "wait-for",
+        "-s",
+        "S1",
+        "-l",
+        "What is your name?"
+      ]);
+      assert.equal(waited.matched, true);
+      assert.match(waited.line, /What is your name\?/);
+    }
+  },
+  {
+    id: 6,
+    title: "Fill text",
+    async run(ctx) {
+      await ctx.ensurePromptSession("S1");
+      const result = await ctx.expectOk(["fill", "-s", "S1", "Alice\n"]);
+      assert.deepEqual(result, { ok: true });
+    }
+  },
+  {
+    id: 7,
+    title: "Wait for greeting",
+    async run(ctx) {
+      await ctx.ensureGreetingSession("S1", "Alice");
+      const waited = await ctx.expectOk([
+        "wait-for",
+        "-s",
+        "S1",
+        "-l",
+        "Hello, Alice!"
+      ]);
+      assert.equal(waited.matched, true);
+    }
+  },
+  {
+    id: 8,
+    title: "Read screen includes exitCode null",
+    async run(ctx) {
+      await ctx.ensureGreetingSession("S1", "Alice");
+      const screen = await ctx.expectOk(["read-screen", "-s", "S1"]);
+      assert.ok(Array.isArray(screen.lines));
+      assert.equal(typeof screen.cursor.row, "number");
+      assert.equal(typeof screen.cursor.col, "number");
+      assert.equal(typeof screen.size.rows, "number");
+      assert.equal(typeof screen.size.cols, "number");
+      assert.ok(screen.exitCode === null || screen.exitCode === 0);
+    }
+  },
+  {
+    id: 9,
+    title: "Read history includes all output, exitCode null",
+    async run(ctx) {
+      await ctx.ensureGreetingSession("S1", "Alice");
+      const history = await ctx.expectOk(["read-history", "-s", "S1"]);
+      assert.ok(history.lines.length > 0);
+      assert.ok(history.lines.some((line) => line.includes("Hello, Alice!")));
+      assert.ok(history.exitCode === null || history.exitCode === 0);
+    }
+  },
+  {
+    id: 10,
+    title: "Read history with last N",
+    async run(ctx) {
+      await ctx.ensureGreetingSession("S1", "Alice");
+      const history = await ctx.expectOk(["read-history", "-s", "S1", "-n", "2"]);
+      assert.ok(history.lines.length <= 2);
+    }
+  },
+  {
+    id: 11,
+    title: "Close session",
+    async run(ctx) {
+      await ctx.ensureGreetingSession("S1", "Alice");
+      const closed = await ctx.expectOk(["close-session", "-s", "S1"]);
+      assert.equal(typeof closed.exitCode, "number");
+      const listed = await ctx.listSessions();
+      assert.deepEqual(listed.sessions, []);
+      const error = await ctx.expectError(["get-session", "-s", "S1"]);
+      assert.match(error, /not found/);
+    }
+  },
+  {
+    id: 12,
+    title: "terminal_type character-by-character",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S2");
+      try {
+        const created = await ctx.expectOk([
+          "create-session",
+          "-s",
+          "S2",
+          tsxPath,
+          testCliPath
+        ]);
+        assert.equal(created.session, "S2");
+        await ctx.expectOk(["wait-for", "-s", "S2", "-l", "What is your name?"]);
+        await ctx.expectOk(["type", "-s", "S2", "Bob"]);
+        await ctx.expectOk(["press-key", "-s", "S2", "Enter"]);
+        const greeted = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S2",
+          "-l",
+          "Hello, Bob!"
+        ]);
+        assert.equal(greeted.matched, true);
+      } finally {
+        await ctx.closeSessionIfExists("S2");
+      }
+    }
+  },
+  {
+    id: 13,
+    title: "terminal_wait_for with literal flag",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S3");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S3", tsxPath, testCliPath]);
+        const prompt = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S3",
+          "-l",
+          "What is your name?"
+        ]);
+        assert.equal(prompt.matched, true);
+        await ctx.expectOk(["fill", "-s", "S3", "Carol\n"]);
+        const greeted = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S3",
+          "-l",
+          "Hello, Carol!"
+        ]);
+        assert.equal(greeted.matched, true);
+      } finally {
+        await ctx.closeSessionIfExists("S3");
+      }
+    }
+  },
+  {
+    id: 14,
+    title: "terminal_wait_for regex",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S4");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S4", tsxPath, testCliPath]);
+        const prompt = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S4",
+          "What is your name\\?"
+        ]);
+        assert.equal(prompt.matched, true);
+        await ctx.expectOk(["fill", "-s", "S4", "Dan\n"]);
+        const greeted = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S4",
+          "Hello,\\s+Dan"
+        ]);
+        assert.equal(greeted.matched, true);
+      } finally {
+        await ctx.closeSessionIfExists("S4");
+      }
+    }
+  },
+  {
+    id: 15,
+    title: "terminal_wait_for timeout exceeded",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S5");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S5", tsxPath, testCliPath]);
+        const error = await ctx.expectError([
+          "wait-for",
+          "-s",
+          "S5",
+          "-t",
+          "500",
+          "THIS_WILL_NEVER_APPEAR"
+        ]);
+        assert.match(error, /Timed out waiting for pattern/i);
+      } finally {
+        await ctx.closeSessionIfExists("S5");
+      }
+    }
+  },
+  {
+    id: 16,
+    title: "terminal_wait_for_exit natural exit",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S6");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S6", tsxPath, testCliPath]);
+        await ctx.expectOk(["wait-for", "-s", "S6", "-l", "What is your name?"]);
+        await ctx.expectOk(["fill", "-s", "S6", "Eve\n"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "S6",
+          "-t",
+          "5000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+        const session = await ctx.expectOk(["get-session", "-s", "S6"]);
+        assert.equal(session.exitCode, 0);
+        const exitedAgain = await ctx.expectOk(["wait-for-exit", "-s", "S6"]);
+        assert.equal(exitedAgain.exitCode, 0);
+      } finally {
+        await ctx.closeSessionIfExists("S6");
+      }
+    }
+  },
+  {
+    id: 17,
+    title: "terminal_wait_for_exit timeout exceeded",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S7");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S7", tsxPath, testCliPath]);
+        await ctx.expectOk(["wait-for", "-s", "S7", "-l", "What is your name?"]);
+        const error = await ctx.expectError([
+          "wait-for-exit",
+          "-s",
+          "S7",
+          "-t",
+          "300"
+        ]);
+        assert.match(error, /Timed out waiting for process to exit/i);
+      } finally {
+        await ctx.closeSessionIfExists("S7");
+      }
+    }
+  },
+  {
+    id: 18,
+    title: "terminal_send_signal SIGINT",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S8");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S8", tsxPath, testCliPath]);
+        await ctx.expectOk(["wait-for", "-s", "S8", "-l", "What is your name?"]);
+        await ctx.expectOk(["send-signal", "-s", "S8", "SIGINT"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "S8",
+          "-t",
+          "3000"
+        ]);
+        assert.equal(typeof exited.exitCode, "number");
+        const screen = await ctx.expectOk(["read-screen", "-s", "S8"]);
+        assert.equal(screen.exitCode, exited.exitCode);
+      } finally {
+        await ctx.closeSessionIfExists("S8");
+      }
+    }
+  },
+  {
+    id: 19,
+    title: "terminal_resize",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S9");
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "S9",
+          "--cols",
+          "80",
+          "--rows",
+          "24",
+          tsxPath,
+          testCliPath
+        ]);
+        const initialScreen = await ctx.expectOk(["read-screen", "-s", "S9"]);
+        assert.equal(initialScreen.size.cols, 80);
+        assert.equal(initialScreen.size.rows, 24);
+        await ctx.expectOk(["resize", "-s", "S9", "--cols", "120", "--rows", "40"]);
+        const resizedScreen = await ctx.expectOk(["read-screen", "-s", "S9"]);
+        assert.equal(resizedScreen.size.cols, 120);
+        assert.equal(resizedScreen.size.rows, 40);
+        await ctx.expectOk(["wait-for", "-s", "S9", "-l", "What is your name?"]);
+        await ctx.expectOk(["fill", "-s", "S9", "Frank\n"]);
+        const greeted = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S9",
+          "-l",
+          "Hello, Frank!"
+        ]);
+        assert.equal(greeted.matched, true);
+      } finally {
+        await ctx.closeSessionIfExists("S9");
+      }
+    }
+  },
+  {
+    id: 20,
+    title: "Full flow menu-cli with ArrowDown navigation",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S10");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S10", tsxPath, menuCliPath]);
+        await ctx.expectOk(["wait-for", "-s", "S10", "-l", "Select an option:"]);
+        await ctx.expectOk(["press-key", "-s", "S10", "ArrowDown"]);
+        await ctx.expectOk(["press-key", "-s", "S10", "ArrowDown"]);
+        await ctx.expectOk(["press-key", "-s", "S10", "Enter"]);
+        const selected = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S10",
+          "-l",
+          "You selected: Option 3"
+        ]);
+        assert.equal(selected.matched, true);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "S10",
+          "-t",
+          "3000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+      } finally {
+        await ctx.closeSessionIfExists("S10");
+      }
+    }
+  },
+  {
+    id: 21,
+    title: "Full flow menu-cli ArrowUp wrap-around",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("S11");
+      try {
+        await ctx.expectOk(["create-session", "-s", "S11", tsxPath, menuCliPath]);
+        await ctx.expectOk(["wait-for", "-s", "S11", "-l", "Select an option:"]);
+        await ctx.expectOk(["press-key", "-s", "S11", "ArrowUp"]);
+        await ctx.expectOk(["press-key", "-s", "S11", "Enter"]);
+        const selected = await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "S11",
+          "You selected: Option [123]"
+        ]);
+        assert.equal(selected.matched, true);
+      } finally {
+        await ctx.closeSessionIfExists("S11");
+      }
+    }
+  },
+  {
+    id: 22,
+    title: "Multiple concurrent sessions isolation",
+    async run(ctx) {
+      await closeSessions(ctx, ["SA", "SB", "SC"]);
+      try {
+        await ctx.expectOk(["create-session", "-s", "SA", tsxPath, testCliPath]);
+        await ctx.expectOk(["create-session", "-s", "SB", tsxPath, testCliPath]);
+        await ctx.expectOk(["create-session", "-s", "SC", tsxPath, menuCliPath]);
+        const listed = await ctx.listSessions();
+        assert.equal(listed.sessions.length, 3);
+        await ctx.expectOk(["wait-for", "-s", "SA", "-l", "What is your name?"]);
+        await ctx.expectOk(["fill", "-s", "SA", "Session-A\n"]);
+        await ctx.expectOk(["wait-for", "-s", "SB", "-l", "What is your name?"]);
+        await ctx.expectOk(["fill", "-s", "SB", "Session-B\n"]);
+        await ctx.expectOk(["wait-for", "-s", "SC", "-l", "Select an option:"]);
+        await ctx.expectOk(["press-key", "-s", "SC", "Enter"]);
+        await ctx.expectOk(["wait-for", "-s", "SA", "-l", "Hello, Session-A!"]);
+        await ctx.expectOk(["wait-for", "-s", "SB", "-l", "Hello, Session-B!"]);
+        await ctx.expectOk(["wait-for", "-s", "SC", "-l", "You selected: Option 1"]);
+        const historyA = await ctx.expectOk(["read-history", "-s", "SA"]);
+        assert.ok(historyA.lines.some((line) => line.includes("Session-A")));
+        assert.ok(historyA.lines.every((line) => !line.includes("Session-B")));
+        const historyB = await ctx.expectOk(["read-history", "-s", "SB"]);
+        assert.ok(historyB.lines.some((line) => line.includes("Session-B")));
+        assert.ok(historyB.lines.every((line) => !line.includes("Session-A")));
+        await ctx.expectOk(["close-session", "-s", "SB"]);
+        const afterClose = await ctx.listSessions();
+        assert.ok(!afterClose.sessions.some((s) => s.session === "SB"));
+      } finally {
+        await closeSessions(ctx, ["SA", "SB", "SC"]);
+      }
+    }
+  },
+  {
+    id: 23,
+    title: "Final state",
+    async run(ctx) {
+      const listed = await ctx.listSessions();
+      assert.deepEqual(listed.sessions, []);
+    }
+  },
+  {
+    id: 24,
+    title: "Unknown session error",
+    async run(ctx) {
+      const readScreenError = await ctx.expectError(["read-screen", "-s", "does-not-exist"]);
+      assert.match(readScreenError, /not found/);
+      const closeError = await ctx.expectError(["close-session", "-s", "does-not-exist"]);
+      assert.match(closeError, /not found/);
+    }
+  },
+  {
+    id: 25,
+    title: "Bash interactive shell",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("BASH");
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "BASH",
+          "--cols",
+          "120",
+          "--rows",
+          "40",
+          "bash",
+          "--",
+          "--norc",
+          "--noprofile"
+        ]);
+        await ctx.expectOk(["wait-for", "-s", "BASH", "-t", "3000", "\\$\\s*$"]);
+        await ctx.expectOk(["fill", "-s", "BASH", "echo hello-from-bash\n"]);
+        await ctx.expectOk(["wait-for", "-s", "BASH", "-l", "hello-from-bash"]);
+        await ctx.expectOk(["fill", "-s", "BASH", "echo $((6 * 7))\n"]);
+        await ctx.expectOk(["wait-for", "-s", "BASH", "-l", "42"]);
+        await ctx.expectOk(["fill", "-s", "BASH", "sleep 60\n"]);
+        await ctx.expectOk(["wait-for", "-s", "BASH", "-t", "2000", "sleep"]);
+        await ctx.expectOk(["press-key", "-s", "BASH", "Control+c"]);
+        await ctx.expectOk(["wait-for", "-s", "BASH", "-t", "3000", "\\$\\s*$"]);
+        await ctx.expectOk(["fill", "-s", "BASH", "exit 0\n"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "BASH",
+          "-t",
+          "3000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+      } finally {
+        await ctx.closeSessionIfExists("BASH");
+      }
+    }
+  },
+  {
+    id: 26,
+    title: "Bash long output read_history line count",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("BASH2");
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "BASH2",
+          "bash",
+          "--",
+          "--norc",
+          "--noprofile"
+        ]);
+        await ctx.expectOk(["wait-for", "-s", "BASH2", "-t", "3000", "\\$\\s*$"]);
+        await ctx.expectOk([
+          "fill",
+          "-s",
+          "BASH2",
+          'for i in $(seq 1 50); do echo "line $i"; done\n'
+        ]);
+        await ctx.expectOk(["wait-for", "-s", "BASH2", "-l", "line 50"]);
+        const history = await ctx.expectOk(["read-history", "-s", "BASH2"]);
+        for (let index = 1; index <= 50; index += 1) {
+          assert.ok(history.lines.some((line) => line.includes(`line ${index}`)));
+        }
+        const tail = await ctx.expectOk(["read-history", "-s", "BASH2", "-n", "10"]);
+        assert.ok(tail.lines.length <= 10);
+        assert.ok(tail.lines.some((line) => /line 50/.test(line)));
+      } finally {
+        await ctx.closeSessionIfExists("BASH2");
+      }
+    }
+  },
+  {
+    id: 27,
+    title: "Python REPL expression evaluation and multi-line input",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("PY");
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "PY",
+          "--cols",
+          "120",
+          "--rows",
+          "40",
+          "python3",
+          "--",
+          "-q"
+        ]);
+        await ctx.expectOk(["wait-for", "-s", "PY", "-l", ">>>"]);
+        await ctx.expectOk(["fill", "-s", "PY", "2 ** 10\n"]);
+        await ctx.expectOk(["wait-for", "-s", "PY", "-l", "1024"]);
+        await ctx.expectOk(["fill", "-s", "PY", "[x*x for x in range(5)]\n"]);
+        await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "PY",
+          "\\[0, 1, 4, 9, 16\\]"
+        ]);
+        await ctx.expectOk(["fill", "-s", "PY", "def greet(name):\n"]);
+        await ctx.expectOk(["wait-for", "-s", "PY", "\\.\\.\\."]);
+        await ctx.expectOk(["fill", "-s", "PY", "    return f'hi {name}'\n"]);
+        await ctx.expectOk(["wait-for", "-s", "PY", "\\.\\.\\."]);
+        await ctx.expectOk(["fill", "-s", "PY", "\n"]);
+        await ctx.expectOk(["wait-for", "-s", "PY", "-l", ">>>"]);
+        await ctx.expectOk(["fill", "-s", "PY", "greet('world')\n"]);
+        await ctx.expectOk(["wait-for", "-s", "PY", "-l", "hi world"]);
+        await ctx.expectOk(["press-key", "-s", "PY", "Control+d"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "PY",
+          "-t",
+          "3000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+      } finally {
+        await ctx.closeSessionIfExists("PY");
+      }
+    }
+  },
+  {
+    id: 28,
+    title: "Node.js REPL evaluation",
+    async run(ctx) {
+      await ctx.closeSessionIfExists("NODE");
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "NODE",
+          "--cols",
+          "120",
+          "--rows",
+          "40",
+          "node"
+        ]);
+        await ctx.expectOk(["wait-for", "-s", "NODE", "-l", ">"]);
+        await ctx.expectOk(["fill", "-s", "NODE", "Math.PI.toFixed(4)\n"]);
+        await ctx.expectOk(["wait-for", "-s", "NODE", "-l", "3.1416"]);
+        await ctx.expectOk(["fill", "-s", "NODE", "[1,2,3].map(x => x * 2)\n"]);
+        await ctx.expectOk(["wait-for", "-s", "NODE", "\\[ 2, 4, 6 \\]"]);
+        await ctx.expectOk(["fill", "-s", "NODE", "process.version\n"]);
+        await ctx.expectOk(["wait-for", "-s", "NODE", "v\\d+"]);
+        await ctx.expectOk(["press-key", "-s", "NODE", "Control+d"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "NODE",
+          "-t",
+          "3000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+      } finally {
+        await ctx.closeSessionIfExists("NODE");
+      }
+    }
+  },
+  {
+    id: 29,
+    title: "vim open, edit, save and quit",
+    async run(ctx) {
+      await removeIfExists(vimSavedFile);
+      await closeSessions(ctx, ["VIM", "CAT"]);
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "VIM",
+          "--cols",
+          "120",
+          "--rows",
+          "40",
+          "vim",
+          vimSavedFile
+        ]);
+        await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "VIM",
+          "-t",
+          "5000",
+          path3.basename(vimSavedFile)
+        ]);
+        await ctx.expectOk(["press-key", "-s", "VIM", "i"]);
+        await ctx.expectOk(["type", "-s", "VIM", "hello from terminal-pilot"]);
+        await ctx.expectOk(["press-key", "-s", "VIM", "Escape"]);
+        const screen = await ctx.expectOk(["read-screen", "-s", "VIM"]);
+        assert.ok(screen.lines.some((line) => line.includes("hello from terminal-pilot")));
+        assert.equal(screen.exitCode, null);
+        await ctx.expectOk(["fill", "-s", "VIM", ":wq\n"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "VIM",
+          "-t",
+          "5000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+        await ctx.expectOk(["create-session", "-s", "CAT", "cat", vimSavedFile]);
+        await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "CAT",
+          "-l",
+          "hello from terminal-pilot"
+        ]);
+      } finally {
+        await closeSessions(ctx, ["VIM", "CAT"]);
+        await removeIfExists(vimSavedFile);
+      }
+    }
+  },
+  {
+    id: 30,
+    title: "vim quit without saving",
+    async run(ctx) {
+      await removeIfExists(vimDiscardFile);
+      await ctx.closeSessionIfExists("VIM2");
+      try {
+        await ctx.expectOk([
+          "create-session",
+          "-s",
+          "VIM2",
+          "--cols",
+          "80",
+          "--rows",
+          "24",
+          "vim",
+          vimDiscardFile
+        ]);
+        await ctx.expectOk([
+          "wait-for",
+          "-s",
+          "VIM2",
+          "-t",
+          "5000",
+          path3.basename(vimDiscardFile)
+        ]);
+        await ctx.expectOk(["press-key", "-s", "VIM2", "i"]);
+        await ctx.expectOk(["type", "-s", "VIM2", "this should not be saved"]);
+        await ctx.expectOk(["press-key", "-s", "VIM2", "Escape"]);
+        await ctx.expectOk(["fill", "-s", "VIM2", ":q!\n"]);
+        const exited = await ctx.expectOk([
+          "wait-for-exit",
+          "-s",
+          "VIM2",
+          "-t",
+          "5000"
+        ]);
+        assert.equal(exited.exitCode, 0);
+      } finally {
+        await ctx.closeSessionIfExists("VIM2");
+        await removeIfExists(vimDiscardFile);
+      }
+    }
+  },
+  {
+    id: 31,
+    title: "poe-code help output",
+    skipped: true
+  },
+  {
+    id: 32,
+    title: "poe-code configure interactive agent selection",
+    skipped: true
+  },
+  {
+    id: 33,
+    title: "Claude Code version and help",
+    skipped: true
+  },
+  {
+    id: 34,
+    title: "Claude Code single prompt",
+    skipped: true
+  },
+  {
+    id: 35,
+    title: "Claude Code interactive REPL mode",
+    skipped: true
+  },
+  {
+    id: 36,
+    title: "Final state all sessions closed",
+    async run(ctx) {
+      const listed = await ctx.listSessions();
+      assert.deepEqual(listed.sessions, []);
+    }
+  }
+];
+async function main2() {
+  const ctx = new QaContext();
+  const failures = [];
+  try {
+    for (const testCase of cases) {
+      if (testCase.skipped === true) {
+        process.stdout.write(`SKIP ${testCase.id}. ${testCase.title}
+`);
+        continue;
+      }
+      process.stdout.write(`RUN ${testCase.id}. ${testCase.title}
+`);
+      try {
+        await testCase.run?.(ctx);
+        process.stdout.write(`PASS ${testCase.id}. ${testCase.title}
+`);
+      } catch (error) {
+        const reason = formatError(error);
+        failures.push({
+          id: testCase.id,
+          title: testCase.title,
+          reason
+        });
+        process.stdout.write(`FAIL ${testCase.id}. ${testCase.title}
+`);
+        process.stdout.write(`${reason}
+`);
+      }
+    }
+  } finally {
+    await ctx.close();
+  }
+  process.stdout.write(`
+Summary: ${cases.filter((entry) => !entry.skipped).length - failures.length} passed, ${failures.length} failed, ${cases.filter((entry) => entry.skipped).length} skipped.
+`);
+  if (failures.length > 0) {
+    process.stdout.write("\nFailures:\n");
+    for (const failure of failures) {
+      process.stdout.write(`${failure.id}. ${failure.title}: ${failure.reason}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  await main2();
+}
+export {
+  main2 as main
+};
+//# sourceMappingURL=qa-cli.js.map