terminal-pilot 0.0.5 → 0.0.7

package/dist/terminal-session.js

@@ -1,340 +1,1068 @@
+// src/terminal-session.ts
 import { spawn as spawnChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
 import * as nodePty from "node-pty";
-import { stripAnsi } from "./ansi.js";
-import { TerminalBuffer } from "./terminal-buffer.js";
-import { keyToSequence } from "./keys.js";
-import { TerminalScreen } from "./terminal-screen.js";
-const DEFAULT_COLS = 120;
-const DEFAULT_ROWS = 40;
-const DEFAULT_TIMEOUT_MS = 10_000;
-const WAIT_FOR_POLL_MS = 100;
-const TYPE_DELAY_MS = 15;
-const CLOSE_AFTER_SIGNAL_GRACE_MS = 250;
-export class TerminalSession {
-    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);
-            });
+
+// 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/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;
     }
-    async type(text) {
-        for (const character of text) {
-            await this.send(character);
-            await sleep(TYPE_DELAY_MS);
-        }
+  }
+  _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;
     }
-    async fill(text) {
-        await this.send(text.replace(/\r?\n/g, "\r"));
+  }
+  _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));
     }
-    async press(key) {
-        await this.send(keyToSequence(key));
+  }
+  _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));
     }
-    async send(raw) {
-        if (this.exitCode !== null) {
-            return;
+  }
+  _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 params = this._parseCsiParams();
+    const p0 = params[0] ?? 0;
+    const p1 = params[1] ?? 0;
+    if (this._csiPrivate === "?") {
+      if (final === "h" || final === "l") {
+        if (params.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();
         }
-        this.pty.write(raw);
+      }
+      return;
     }
-    async signal(sig) {
-        if (this.exitCode !== null) {
-            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);
         }
-        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);
+        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);
         }
-        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);
+        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));
         }
-    }
-    async screen() {
-        const rawLines = [];
-        for (let row = 0; row < this.currentRows; row += 1) {
-            const cells = this.terminal.displayBuffer.data[row] ?? [];
-            let rawLine = "";
-            for (const cell of cells) {
-                rawLine += cell?.[1] ?? " ";
-            }
-            rawLines.push(trimTrailingSpaces(rawLine));
+        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));
         }
-        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 === undefined) {
-            return lines;
+        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);
         }
-        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);
+        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);
         }
-        this.terminal.resize(cols, rows);
-    }
-    async waitForExit(opts) {
-        if (this.exitCode !== null) {
-            return this.exitCode;
+        break;
+      }
+      case "S":
+        this._scrollUp(Math.max(1, p0));
+        break;
+      case "T":
+        if (params.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);
         }
-        if (opts?.timeout !== undefined) {
-            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;
+        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;
         }
-        return this.exitPromise;
+        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(params);
+        break;
+      default:
+        break;
     }
-    async close() {
-        if (this.exitCode !== null) {
-            return this.exitCode;
+  }
+  _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 */;
         }
-        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");
-            }
+        break;
+      case 4 /* Str */:
+        if (code === 156 || code === 7) {
+          this._state = 0 /* Normal */;
+        } else if (code === 27) {
+          this._state = 0 /* Normal */;
         }
-        return this.exitPromise;
+        break;
+      case 5 /* EscCharset */:
+        this._state = 0 /* Normal */;
+        break;
+      case 6 /* EscHash */:
+        this._state = 0 /* Normal */;
+        break;
     }
-    on(event, cb) {
-        this.emitter.on(event, cb);
+  }
+  _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(params) {
+    const normalizedParams = params.length === 0 ? [0] : params;
+    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, params, index) {
+    const mode = params[index + 1];
+    const target = control === 38 ? "fg" : "bg";
+    if (mode === 5) {
+      const paletteIndex = params[index + 2];
+      if (paletteIndex !== void 0) {
+        this._style[target] = [control, 5, paletteIndex];
+        return index + 2;
+      }
+      return index;
+    }
+    if (mode === 2) {
+      const red = params[index + 2];
+      const green = params[index + 3];
+      const blue = params[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 createPtyProcess({ command, args, cwd, env, cols, rows }) {
-    try {
-        return nodePty.spawn(command, args, {
-            cwd,
-            env,
-            cols,
-            rows,
-            encoding: "utf8"
-        });
+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);
     }
-    catch {
-        return createChildProcessFallback({ command, args, cwd, env });
+    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 createChildProcessFallback({ command, args, cwd, env }) {
-    const child = spawnChildProcess(command, args, {
-        cwd,
-        env,
-        stdio: ["pipe", "pipe", "pipe"]
-    });
-    return new ChildProcessFallback(child);
+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);
 }
-class ChildProcessFallback {
-    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: undefined
-            });
-        });
+
+// 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}`);
     }
-    write(data) {
-        this.child.stdin.write(data);
-    }
-    resize() {
-        // No-op in fallback mode.
-    }
-    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));
-    };
+    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 signalToExitCode(signal) {
-    if (signal === null) {
-        return 0;
-    }
-    const signalNumbers = {
-        SIGTERM: 15,
-        SIGINT: 2,
-        SIGHUP: 1,
-        SIGKILL: 9
+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);
+      }
     };
-    const signalNumber = signalNumbers[signal];
-    if (signalNumber === undefined) {
-        return 1;
-    }
-    return 128 + signalNumber;
+  }
+  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;
-        }
+  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;
+  }
+  return null;
 }
 function removeCharacter(input, charToRemove) {
-    let output = "";
-    for (const character of input) {
-        if (character !== charToRemove) {
-            output += character;
-        }
+  let output = "";
+  for (const character of input) {
+    if (character !== charToRemove) {
+      output += character;
     }
-    return output;
+  }
+  return output;
 }
 function splitHistoryLines(input) {
-    const lines = input.split("\n");
-    if (lines.length > 0 && lines[lines.length - 1] === "") {
-        lines.pop();
-    }
-    return lines;
+  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;
+  let output = "";
+  for (const character of input) {
+    if (character === "\r" || character === "\b") {
+      continue;
     }
-    return output;
-}
-function trimTrailingSpaces(input) {
-    let end = input.length;
-    while (end > 0 && input[end - 1] === " ") {
-        end -= 1;
-    }
-    return input.slice(0, end);
+    output += character;
+  }
+  return output;
 }
 function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, 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);
-        });
+  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);
     });
+  });
 }
+export {
+  TerminalSession
+};
+//# sourceMappingURL=terminal-session.js.map