terminal-pilot 0.0.28 → 0.0.29

package/dist/testing/cli-repl.js

@@ -12574,10 +12574,15 @@ async function writeErrorReport(context) {
 
 // ../toolcraft/src/number-schema.ts
 function isValidNumberSchemaValue(value, schema) {
-  return typeof value === "number" && Number.isFinite(value) && (schema.jsonType !== "integer" || Number.isInteger(value));
+  return typeof value === "number" && Number.isFinite(value) && (schema.jsonType !== "integer" || Number.isInteger(value)) && (schema.minimum === void 0 || value >= schema.minimum) && (schema.maximum === void 0 || value <= schema.maximum);
 }
 function getExpectedNumberDescription(schema) {
-  return schema.jsonType === "integer" ? "an integer" : "a number";
+  const type2 = schema.jsonType === "integer" ? "an integer" : "a number";
+  const bounds = [
+    schema.minimum === void 0 ? void 0 : `greater than or equal to ${schema.minimum}`,
+    schema.maximum === void 0 ? void 0 : `less than or equal to ${schema.maximum}`
+  ].filter((bound) => bound !== void 0);
+  return bounds.length === 0 ? type2 : `${type2} ${bounds.join(" and ")}`;
 }
 
 // ../toolcraft/src/renderer.ts
@@ -16474,6 +16479,10 @@ var TerminalBuffer = class {
   }
   _writePrintable(ch) {
     const width = this._cellWidth(ch);
+    if (width === 0) {
+      this._appendCombiningMark(ch);
+      return;
+    }
     if (this._autoWrap && this._pendingWrap) {
       this._cursorX = 0;
       this._newline();
@@ -16508,11 +16517,40 @@ var TerminalBuffer = class {
   _cellWidth(ch) {
     const codePoint = ch.codePointAt(0);
     if (codePoint === void 0) return 0;
+    if (isCombiningCodePoint2(codePoint)) {
+      return 0;
+    }
     if (codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12350 || codePoint >= 12353 && codePoint <= 13247 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127488 && codePoint <= 131069 || codePoint >= 131072 && codePoint <= 262141) {
       return Math.min(2, this._cols);
     }
     return 1;
   }
+  _appendCombiningMark(ch) {
+    const target = this._findCombiningTarget();
+    if (target === null) {
+      return;
+    }
+    const cell = this._screen[target.y]?.[target.x];
+    if (cell === null || cell === void 0) {
+      return;
+    }
+    cell[1] += ch;
+  }
+  _findCombiningTarget() {
+    const startX = this._pendingWrap ? this._cursorX : this._cursorX - 1;
+    for (let y = this._cursorY; y >= 0; y -= 1) {
+      const row = this._screen[y];
+      if (row === void 0) {
+        continue;
+      }
+      for (let x = y === this._cursorY ? startX : this._cols - 1; x >= 0; x -= 1) {
+        if (row[x] !== null) {
+          return { x, y };
+        }
+      }
+    }
+    return null;
+  }
   _setChar(y, x, ch) {
     const row = this._screen[y];
     if (row && x >= 0 && x < this._cols) {
@@ -16653,7 +16691,8 @@ var TerminalBuffer = class {
       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);
+          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);
@@ -17018,6 +17057,9 @@ function createDefaultStyleState() {
     strikethrough: false
   };
 }
+function isCombiningCodePoint2(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071;
+}
 function serializeStyleState(state) {
   const codes = [];
   if (state.bold) {
@@ -17071,6 +17113,8 @@ 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>`;
+var NAMED_KEY_PATTERN = Object.keys(NAMED_KEY_SEQUENCES).map(caseInsensitivePattern).join("|");
+var TERMINAL_KEY_PATTERN = `^(?:${NAMED_KEY_PATTERN}|.|[Cc][Oo][Nn][Tt][Rr][Oo][Ll]\\+[A-Za-z]|[Aa][Ll][Tt]\\+.+)$`;
 function unknownKeyError(key2) {
   return new Error(`Unknown terminal key: ${key2}. ${VALID_KEYS_HINT}`);
 }
@@ -17113,6 +17157,18 @@ function controlKeyToSequence(controlKey) {
   }
   return String.fromCharCode(charCode - 64);
 }
+function caseInsensitivePattern(value) {
+  let pattern = "";
+  for (const character of value) {
+    const lower = character.toLowerCase();
+    const upper = character.toUpperCase();
+    pattern += lower === upper ? escapePatternCharacter(character) : `[${upper}${lower}]`;
+  }
+  return pattern;
+}
+function escapePatternCharacter(character) {
+  return character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
 
 // src/terminal-screen.ts
 var TerminalScreen = class {
@@ -17552,7 +17608,11 @@ function createTerminalPilotRuntime(options = {}) {
   const pendingNames = /* @__PURE__ */ new Set();
   let pilotPromise;
   function getRequestedName(name, env) {
-    return name ?? env?.get(SESSION_ENV_VAR);
+    const requestedName = name ?? env?.get(SESSION_ENV_VAR);
+    if (requestedName !== void 0 && requestedName.trim().length === 0) {
+      throw new UserError("Session name must not be empty.");
+    }
+    return requestedName;
   }
   async function getPilot() {
     pilotPromise ??= launchPilot();
@@ -17588,7 +17648,9 @@ function createTerminalPilotRuntime(options = {}) {
     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))}`);
+      throw new UserError(
+        `Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`
+      );
     }
     const pilot = await getPilot();
     try {
@@ -17596,7 +17658,9 @@ function createTerminalPilotRuntime(options = {}) {
     } catch {
       forgetSession(name, sessionId);
       const active = await listSessions2();
-      throw new UserError(`Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`);
+      throw new UserError(
+        `Session "${name}" was not found. ${formatAvailableSessions(active.map((entry) => entry.name))}`
+      );
     }
   }
   async function listSessions2() {
@@ -17627,6 +17691,9 @@ function createTerminalPilotRuntime(options = {}) {
   }
   return {
     async createSession(params17, env) {
+      if (params17.command.trim().length === 0) {
+        throw new UserError("Command must not be empty.");
+      }
       const requestedName = getRequestedName(params17.session, env) ?? nextSessionName();
       await discardExitedSessionName(requestedName);
       if (nameToId.has(requestedName) || pendingNames.has(requestedName)) {
@@ -17699,7 +17766,9 @@ async function closeSharedTerminalPilotRuntime() {
 
 // src/commands/close-session.ts
 var params = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var closeSession = defineCommand({
   name: "close-session",
@@ -17707,19 +17776,28 @@ var closeSession = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const { exitCode } = await getTerminalPilotRuntime(terminalPilotRuntime).closeSession(params17.session, env);
+    const { exitCode } = await getTerminalPilotRuntime(terminalPilotRuntime).closeSession(
+      params17.session,
+      env
+    );
     return { exitCode };
   }
 });
 
 // src/commands/create-session.ts
 var params2 = S.Object({
-  command: S.String({ description: "Command to execute" }),
+  command: S.String({ description: "Command to execute", minLength: 1, pattern: "\\S" }),
   args: S.Optional(S.Array(S.String(), { description: "Command arguments" })),
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
   cwd: S.Optional(S.String({ description: "Working directory" })),
-  cols: S.Optional(S.Number({ description: "Terminal width in columns" })),
-  rows: S.Optional(S.Number({ description: "Terminal height in rows" })),
+  cols: S.Optional(
+    S.Number({ description: "Terminal width in columns", jsonType: "integer", minimum: 1 })
+  ),
+  rows: S.Optional(
+    S.Number({ description: "Terminal height in rows", jsonType: "integer", minimum: 1 })
+  ),
   observe: S.Optional(S.Boolean({ description: "Mirror PTY output to stderr" }))
 });
 var createSession = defineCommand({
@@ -17729,7 +17807,10 @@ var createSession = defineCommand({
   positional: ["command", "args"],
   params: params2,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).createSession(params17, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).createSession(
+      params17,
+      env
+    );
     return { session: namedSession.name, pid: namedSession.session.pid };
   }
 });
@@ -17737,7 +17818,9 @@ var createSession = defineCommand({
 // src/commands/fill.ts
 var params3 = S.Object({
   text: S.String({ description: "Text to write to the session" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var fill = defineCommand({
   name: "fill",
@@ -17746,7 +17829,10 @@ var fill = defineCommand({
   positional: ["text"],
   params: params3,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.fill(params17.text);
     return void 0;
   }
@@ -17754,7 +17840,9 @@ var fill = defineCommand({
 
 // src/commands/get-session.ts
 var params4 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var getSession = defineCommand({
   name: "get-session",
@@ -17762,7 +17850,10 @@ var getSession = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params4,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     return {
       session: namedSession.name,
       pid: namedSession.session.pid,
@@ -17790,7 +17881,7 @@ var claudeCodeAgent = {
       CLAUDE_CODE_ENABLE_TELEMETRY: "1"
     }
   },
-  configPath: "~/.claude/settings.json",
+  configPath: "~/.claude.json",
   branding: {
     colors: {
       dark: "#C15F3C",
@@ -17805,7 +17896,12 @@ var claudeDesktopAgent = {
   name: "claude-desktop",
   label: "Claude Desktop",
   summary: "Anthropic's official desktop application for Claude",
-  configPath: "~/.claude/settings.json",
+  configPath: "~/.config/Claude/claude_desktop_config.json",
+  configPaths: {
+    darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
+    linux: "~/.config/Claude/claude_desktop_config.json",
+    win32: "~/AppData/Roaming/Claude/claude_desktop_config.json"
+  },
   branding: {
     colors: {
       dark: "#D97757",
@@ -17849,7 +17945,7 @@ var cursorAgent = {
   label: "Cursor",
   summary: "Cursor's CLI coding agent.",
   binaryName: "cursor-agent",
-  configPath: "~/.cursor/cli-config.json",
+  configPath: "~/.cursor/mcp.json",
   branding: {
     colors: {
       dark: "#FFFFFF",
@@ -17889,7 +17985,7 @@ var openCodeAgent = {
       OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
     }
   },
-  configPath: "~/.config/opencode/config.json",
+  configPath: "~/.config/opencode/opencode.json",
   branding: {
     colors: {
       dark: "#4A4F55",
@@ -17907,7 +18003,7 @@ var kimiAgent = {
   aliases: ["kimi-cli"],
   binaryName: "kimi",
   apiShapes: ["openai-chat-completions"],
-  configPath: "~/.kimi/config.toml",
+  configPath: "~/.kimi/mcp.json",
   branding: {
     colors: {
       dark: "#7B68EE",
@@ -19607,8 +19703,10 @@ var listSessions = defineCommand({
 
 // src/commands/press-key.ts
 var params7 = S.Object({
-  key: S.String({ description: "Named key to press" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  key: S.String({ description: "Named key to press", pattern: TERMINAL_KEY_PATTERN }),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var pressKey = defineCommand({
   name: "press-key",
@@ -19617,16 +19715,36 @@ var pressKey = defineCommand({
   positional: ["key"],
   params: params7,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    assertTerminalKey(params17.key);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.press(params17.key);
     return void 0;
   }
 });
+function assertTerminalKey(key2) {
+  try {
+    keyToSequence(key2);
+  } catch (error3) {
+    throw new UserError(error3 instanceof Error ? error3.message : String(error3));
+  }
+}
 
 // src/commands/read-history.ts
 var params8 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
-  last: S.Optional(S.Number({ short: "n", description: "Return only the last N lines" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
+  last: S.Optional(
+    S.Number({
+      short: "n",
+      description: "Return only the last N lines",
+      jsonType: "integer",
+      minimum: 0
+    })
+  )
 });
 var readHistory = defineCommand({
   name: "read-history",
@@ -19634,7 +19752,10 @@ var readHistory = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params8,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const lines = await namedSession.session.history({ last: params17.last });
     return { lines, exitCode: namedSession.session.exitCode };
   }
@@ -19642,7 +19763,9 @@ var readHistory = defineCommand({
 
 // src/commands/read-screen.ts
 var params9 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var readScreen = defineCommand({
   name: "read-screen",
@@ -19650,7 +19773,10 @@ var readScreen = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params9,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const screen = await namedSession.session.screen();
     return {
       lines: [...screen.lines],
@@ -19663,9 +19789,11 @@ var readScreen = defineCommand({
 
 // src/commands/resize.ts
 var params10 = S.Object({
-  cols: S.Number({ description: "Terminal width in columns" }),
-  rows: S.Number({ description: "Terminal height in rows" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  cols: S.Number({ description: "Terminal width in columns", jsonType: "integer", minimum: 1 }),
+  rows: S.Number({ description: "Terminal height in rows", jsonType: "integer", minimum: 1 }),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var resize = defineCommand({
   name: "resize",
@@ -19673,7 +19801,10 @@ var resize = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params10,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.resize(params17.cols, params17.rows);
     return void 0;
   }
@@ -19685,6 +19816,9 @@ import { rename as rename4, rm, writeFile as writeFile6 } from "node:fs/promises
 
 // ../terminal-png/src/ansi-parser.ts
 var ESC2 = "\x1B";
+var TAB_WIDTH = 8;
+var MAX_TERMINAL_ROWS = 1e3;
+var MAX_TERMINAL_COLUMNS = 1e3;
 function createDefaultStyle() {
   return {
     fg: null,
@@ -19969,10 +20103,34 @@ function positionParameter(params17, index, fallback) {
   const value = toInteger(params17.split(";")[index]);
   return value === null || value < 1 ? fallback : value;
 }
+function modeParameter(params17, fallback) {
+  const value = toInteger(params17.split(";")[0]);
+  return value === null ? fallback : value;
+}
+function displayWidth3(text4) {
+  if (text4 === "	") {
+    return TAB_WIDTH;
+  }
+  const codePoint = text4.codePointAt(0);
+  if (codePoint === void 0) {
+    return 0;
+  }
+  if (codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+function hasRenderableCell(line) {
+  return (line ?? []).some((cell) => cell !== void 0 && cell.text.length > 0);
+}
 function buildRuns(lines, lineBreakStyles) {
   const runs = [];
   const defaultStyle = createDefaultStyle();
-  for (let row = 0; row < lines.length; row += 1) {
+  let lastRow = lines.length - 1;
+  while (lastRow > 0 && !hasRenderableCell(lines[lastRow]) && lineBreakStyles[lastRow - 1] === void 0) {
+    lastRow -= 1;
+  }
+  for (let row = 0; row <= lastRow; row += 1) {
     const line = lines[row] ?? [];
     let lastCell = line.length - 1;
     while (lastCell >= 0 && line[lastCell] === void 0) {
@@ -19982,7 +20140,7 @@ function buildRuns(lines, lineBreakStyles) {
       const cell = line[column] ?? { text: " ", style: defaultStyle };
       pushRun(runs, cell.style, cell.text);
     }
-    if (row < lines.length - 1) {
+    if (row < lastRow) {
       pushRun(runs, lineBreakStyles[row] ?? defaultStyle, "\n");
     }
   }
@@ -19994,7 +20152,21 @@ function parseAnsi2(input) {
   let style = createDefaultStyle();
   let row = 0;
   let column = 0;
+  let savedRow = 0;
+  let savedColumn = 0;
   let index = 0;
+  const clampRow = (nextRow) => {
+    if (nextRow < 0) {
+      return 0;
+    }
+    return Math.min(nextRow, MAX_TERMINAL_ROWS - 1);
+  };
+  const clampColumn = (nextColumn) => {
+    if (nextColumn < 0) {
+      return 0;
+    }
+    return Math.min(nextColumn, MAX_TERMINAL_COLUMNS - 1);
+  };
   const ensureLine = () => {
     while (lines.length <= row) {
       lines.push([]);
@@ -20002,12 +20174,64 @@ function parseAnsi2(input) {
   };
   const moveDown = (keepColumn) => {
     lineBreakStyles[row] = cloneStyle(style);
-    row += 1;
+    row = clampRow(row + 1);
     if (!keepColumn) {
       column = 0;
     }
     ensureLine();
   };
+  const eraseLine = (mode) => {
+    const line = lines[row] ?? [];
+    if (mode === 1) {
+      for (let cell = 0; cell <= column; cell += 1) {
+        delete line[cell];
+      }
+      return;
+    }
+    if (mode === 2) {
+      lines[row] = [];
+      return;
+    }
+    line.splice(column);
+  };
+  const eraseDisplay = (mode) => {
+    if (mode === 1) {
+      for (let lineRow = 0; lineRow < row; lineRow += 1) {
+        lines[lineRow] = [];
+      }
+      eraseLine(1);
+      return;
+    }
+    if (mode === 2 || mode === 3) {
+      lines.length = 0;
+      lineBreakStyles.length = 0;
+      ensureLine();
+      return;
+    }
+    eraseLine(0);
+    lines.splice(row + 1);
+    lineBreakStyles.splice(row);
+  };
+  const saveCursor = () => {
+    savedRow = row;
+    savedColumn = column;
+  };
+  const restoreCursor = () => {
+    row = clampRow(savedRow);
+    column = clampColumn(savedColumn);
+    ensureLine();
+  };
+  const writeText = (text4) => {
+    const width = displayWidth3(text4);
+    if (width === 0) {
+      return;
+    }
+    lines[row][column] = { text: text4, style: cloneStyle(style) };
+    for (let offset = 1; offset < width && column + offset < MAX_TERMINAL_COLUMNS; offset += 1) {
+      lines[row][column + offset] = { text: "", style: cloneStyle(style) };
+    }
+    column = clampColumn(column + width);
+  };
   while (index < input.length) {
     const char = input[index];
     if (char === "\n") {
@@ -20030,38 +20254,73 @@ function parseAnsi2(input) {
       index += 1;
       continue;
     }
+    if (char === "	") {
+      const nextTabStop = Math.min(
+        Math.floor(column / TAB_WIDTH) * TAB_WIDTH + TAB_WIDTH,
+        MAX_TERMINAL_COLUMNS
+      );
+      while (column < nextTabStop) {
+        writeText(" ");
+      }
+      index += 1;
+      continue;
+    }
     if (char === ESC2 && input[index + 1] === "]") {
       index = parseOscEnd(input, index);
       continue;
     }
+    if (char === ESC2 && input[index + 1] === "7") {
+      saveCursor();
+      index += 2;
+      continue;
+    }
+    if (char === ESC2 && input[index + 1] === "8") {
+      restoreCursor();
+      index += 2;
+      continue;
+    }
     const csiPrefixLength = char === "\x9B" ? 1 : char === ESC2 && input[index + 1] === "[" ? 2 : null;
     if (csiPrefixLength !== null) {
       const sequence = parseCsi(input, index, csiPrefixLength);
       if (sequence.final === "m") {
         style = applySgr(style, sequence.params);
       } else if (sequence.final === "G") {
-        column = positionParameter(sequence.params, 0, 1) - 1;
+        column = clampColumn(positionParameter(sequence.params, 0, 1) - 1);
       } else if (sequence.final === "C") {
-        column += positionParameter(sequence.params, 0, 1);
+        column = clampColumn(column + positionParameter(sequence.params, 0, 1));
       } else if (sequence.final === "D") {
         column = Math.max(0, column - positionParameter(sequence.params, 0, 1));
       } else if (sequence.final === "A") {
-        row = Math.max(0, row - positionParameter(sequence.params, 0, 1));
+        row = clampRow(row - positionParameter(sequence.params, 0, 1));
       } else if (sequence.final === "B") {
-        row += positionParameter(sequence.params, 0, 1);
+        row = clampRow(row + positionParameter(sequence.params, 0, 1));
+        ensureLine();
+      } else if (sequence.final === "E") {
+        row = clampRow(row + positionParameter(sequence.params, 0, 1));
+        column = 0;
         ensureLine();
+      } else if (sequence.final === "F") {
+        row = clampRow(row - positionParameter(sequence.params, 0, 1));
+        column = 0;
       } else if (sequence.final === "H" || sequence.final === "f") {
-        row = positionParameter(sequence.params, 0, 1) - 1;
-        column = positionParameter(sequence.params, 1, 1) - 1;
+        row = clampRow(positionParameter(sequence.params, 0, 1) - 1);
+        column = clampColumn(positionParameter(sequence.params, 1, 1) - 1);
         ensureLine();
+      } else if (sequence.final === "K") {
+        eraseLine(modeParameter(sequence.params, 0));
+      } else if (sequence.final === "J") {
+        eraseDisplay(modeParameter(sequence.params, 0));
+      } else if (sequence.final === "s") {
+        saveCursor();
+      } else if (sequence.final === "u") {
+        restoreCursor();
       }
       index = sequence.end;
       continue;
     }
     const codePoint = input.codePointAt(index);
     const text4 = codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
-    lines[row][column] = { text: text4, style: cloneStyle(style) };
-    column += 1;
+    writeText(text4);
     index += text4.length;
   }
   return buildRuns(lines, lineBreakStyles);
@@ -20469,11 +20728,11 @@ function splitIntoLines(runs) {
 }
 function measureLines(lines) {
   return Math.max(
-    ...lines.map((line) => displayWidth3(line.map((run) => run.text).join("")) * CHARACTER_WIDTH),
+    ...lines.map((line) => displayWidth4(line.map((run) => run.text).join("")) * CHARACTER_WIDTH),
     0
   );
 }
-function displayWidth3(text4, startColumn = 0) {
+function displayWidth4(text4, startColumn = 0) {
   const segmenter = new Intl.Segmenter();
   let column = startColumn;
   for (const { segment } of segmenter.segment(text4)) {
@@ -20535,7 +20794,7 @@ function renderBackgrounds(line, startX, y, height) {
   let column = 0;
   const rectangles = [];
   for (const run of line) {
-    const width = displayWidth3(run.text, column);
+    const width = displayWidth4(run.text, column);
     const background = resolveBackgroundColor(run);
     if (background !== BACKGROUND && width > 0) {
       rectangles.push(`<rect x="${formatNumber(startX + column * CHARACTER_WIDTH)}" y="${formatNumber(y)}" width="${formatNumber(width * CHARACTER_WIDTH)}" height="${formatNumber(height)}" fill="${escapeXmlAttribute(background)}" />`);
@@ -20569,7 +20828,7 @@ function renderRun(run) {
   if (run.dim) {
     attributes.push('opacity="0.7"');
   }
-  const text4 = run.conceal ? " ".repeat(displayWidth3(run.text)) : run.text;
+  const text4 = run.conceal ? " ".repeat(displayWidth4(run.text)) : run.text;
   return `<tspan ${attributes.join(" ")}>${escapeXmlText(text4)}</tspan>`;
 }
 function renderWindowControls() {
@@ -20618,13 +20877,16 @@ async function renderTerminalPng(ansiText, options = {}) {
   if (options.padding !== void 0 && (!Number.isInteger(options.padding) || options.padding < 0)) {
     throw new Error("Padding must be a non-negative integer.");
   }
+  if (options.output !== void 0 && options.output.length === 0) {
+    throw new Error("Output path must not be empty.");
+  }
   const runs = parseAnsi2(ansiText);
   const svg = renderSvg(runs, {
     padding: options.padding,
     window: options.window
   });
   const png = renderPng(svg);
-  if (options.output) {
+  if (options.output !== void 0) {
     const temporaryPath = `${options.output}.${randomUUID10()}.tmp`;
     let temporaryCreated = false;
     try {
@@ -20650,10 +20912,19 @@ function isAlreadyExistsError3(error3) {
 
 // src/commands/screenshot.ts
 var params11 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
   output: S.String({ short: "o", description: "Path to the output PNG file" }),
   window: S.Optional(S.Boolean({ description: "Include terminal window chrome", default: true })),
-  padding: S.Optional(S.Number({ short: "p", description: "Padding around terminal content" }))
+  padding: S.Optional(
+    S.Number({
+      short: "p",
+      description: "Padding around terminal content",
+      jsonType: "integer",
+      minimum: 0
+    })
+  )
 });
 var screenshot = defineCommand({
   name: "screenshot",
@@ -20661,7 +20932,10 @@ var screenshot = defineCommand({
   scope: ["cli"],
   params: params11,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const screen = await namedSession.session.screen();
     await renderTerminalPng(screen.rawLines.join("\n"), {
       output: params17.output,
@@ -20675,7 +20949,9 @@ var screenshot = defineCommand({
 // src/commands/send-signal.ts
 var params12 = S.Object({
   signal: S.String({ description: "Signal to send to the session process" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var sendSignal = defineCommand({
   name: "send-signal",
@@ -20684,7 +20960,10 @@ var sendSignal = defineCommand({
   positional: ["signal"],
   params: params12,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.signal(params17.signal);
     return void 0;
   }
@@ -20693,7 +20972,9 @@ var sendSignal = defineCommand({
 // src/commands/type.ts
 var params13 = S.Object({
   text: S.String({ description: "Text to write to the session" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  )
 });
 var type = defineCommand({
   name: "type",
@@ -20702,7 +20983,10 @@ var type = defineCommand({
   positional: ["text"],
   params: params13,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     await namedSession.session.type(params17.text);
     return void 0;
   }
@@ -20780,9 +21064,17 @@ async function folderExists(fs4, folderPath) {
 
 // src/commands/wait-for.ts
 var params15 = S.Object({
-  pattern: S.String({ description: "Regular expression pattern to wait for" }),
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
-  timeout: S.Optional(S.Number({ short: "t", description: "Maximum wait time in milliseconds" })),
+  pattern: S.String({
+    description: "Regular expression pattern to wait for",
+    minLength: 1,
+    pattern: "\\S"
+  }),
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
+  timeout: S.Optional(
+    S.Number({ short: "t", description: "Maximum wait time in milliseconds", minimum: 0 })
+  ),
   literal: S.Optional(
     S.Boolean({
       short: "l",
@@ -20797,17 +21089,33 @@ var waitFor = defineCommand({
   positional: ["pattern"],
   params: params15,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    if (params17.pattern.trim().length === 0) {
+      throw new UserError("Wait pattern must not be empty.");
+    }
+    assertTimeout2(params17.timeout);
+    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 };
   }
 });
+function assertTimeout2(timeout) {
+  if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+    throw new UserError("Timeout must be a finite non-negative number.");
+  }
+}
 
 // src/commands/wait-for-exit.ts
 var params16 = S.Object({
-  session: S.Optional(S.String({ short: "s", description: "Session name" })),
-  timeout: S.Optional(S.Number({ short: "t", description: "Maximum wait time in milliseconds" }))
+  session: S.Optional(
+    S.String({ short: "s", description: "Session name", minLength: 1, pattern: "\\S" })
+  ),
+  timeout: S.Optional(
+    S.Number({ short: "t", description: "Maximum wait time in milliseconds", minimum: 0 })
+  )
 });
 var waitForExit2 = defineCommand({
   name: "wait-for-exit",
@@ -20815,7 +21123,13 @@ var waitForExit2 = defineCommand({
   scope: ["cli", "mcp", "sdk"],
   params: params16,
   handler: async ({ params: params17, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params17.session, env);
+    if (params17.timeout !== void 0 && (!Number.isFinite(params17.timeout) || params17.timeout < 0)) {
+      throw new UserError("Timeout must be a finite non-negative number.");
+    }
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params17.session,
+      env
+    );
     const exitCode = await namedSession.session.waitForExit(
       params17.timeout === void 0 ? void 0 : { timeout: params17.timeout }
     );