terminal-pilot 0.0.27 → 0.0.29

package/dist/commands/wait-for.js

@@ -249,6 +249,12 @@ function cloneRequires(requires) {
     check: requires.check
   };
 }
+function cloneCommandExamples(examples) {
+  return (examples ?? []).map((example) => ({
+    title: example.title,
+    params: { ...example.params }
+  }));
+}
 function parseStackPath(candidate) {
   if (candidate.startsWith("file://")) {
     try {
@@ -342,9 +348,11 @@ function createBaseCommand(config) {
     kind: "command",
     name: config.name,
     description: config.description,
+    examples: cloneCommandExamples(config.examples),
     aliases: [...config.aliases ?? []],
     positional: [...config.positional ?? []],
     params: config.params,
+    result: config.result,
     secrets: cloneSecrets(config.secrets),
     scope: resolveCommandScope(config.scope, void 0),
     confirm: config.confirm ?? false,
@@ -356,6 +364,8 @@ function createBaseCommand(config) {
   Object.defineProperty(command, commandConfigSymbol, {
     value: {
       scope: cloneScope(config.scope),
+      examples: cloneCommandExamples(config.examples),
+      result: config.result,
       humanInLoop: config.humanInLoop,
       secrets: cloneSecrets(config.secrets),
       requires: cloneRequires(config.requires),
@@ -373,9 +383,11 @@ function materializeCommand(command, inherited) {
     kind: "command",
     name: command.name,
     description: command.description,
+    examples: cloneCommandExamples(internal.examples),
     aliases: [...command.aliases],
     positional: [...command.positional],
     params: command.params,
+    result: internal.result,
     secrets: mergeSecrets(inherited.secrets, internal.secrets),
     scope: resolveCommandScope(internal.scope, inherited.scope),
     confirm: command.confirm,
@@ -387,6 +399,8 @@ function materializeCommand(command, inherited) {
   Object.defineProperty(materialized, commandConfigSymbol, {
     value: {
       scope: cloneScope(internal.scope),
+      examples: cloneCommandExamples(internal.examples),
+      result: internal.result,
       humanInLoop: internal.humanInLoop,
       secrets: cloneSecrets(internal.secrets),
       requires: cloneRequires(internal.requires),
@@ -664,6 +678,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();
@@ -698,11 +716,40 @@ var TerminalBuffer = class {
   _cellWidth(ch) {
     const codePoint = ch.codePointAt(0);
     if (codePoint === void 0) return 0;
+    if (isCombiningCodePoint(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) {
@@ -843,7 +890,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);
@@ -1208,6 +1256,9 @@ function createDefaultStyleState() {
     strikethrough: false
   };
 }
+function isCombiningCodePoint(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) {
@@ -1261,6 +1312,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(key) {
   return new Error(`Unknown terminal key: ${key}. ${VALID_KEYS_HINT}`);
 }
@@ -1303,6 +1356,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 {
@@ -1742,7 +1807,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();
@@ -1778,7 +1847,9 @@ function createTerminalPilotRuntime(options = {}) {
     const sessionId = nameToId.get(name);
     if (sessionId === void 0) {
       const active = await listSessions();
-      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 {
@@ -1786,7 +1857,9 @@ function createTerminalPilotRuntime(options = {}) {
     } catch {
       forgetSession(name, sessionId);
       const active = await listSessions();
-      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 listSessions() {
@@ -1817,6 +1890,9 @@ function createTerminalPilotRuntime(options = {}) {
   }
   return {
     async createSession(params2, env) {
+      if (params2.command.trim().length === 0) {
+        throw new UserError("Command must not be empty.");
+      }
       const requestedName = getRequestedName(params2.session, env) ?? nextSessionName();
       await discardExitedSessionName(requestedName);
       if (nameToId.has(requestedName) || pendingNames.has(requestedName)) {
@@ -1882,9 +1958,17 @@ function createTerminalPilotRuntime(options = {}) {
 
 // src/commands/wait-for.ts
 var params = 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",
@@ -1899,12 +1983,24 @@ var waitFor = defineCommand({
   positional: ["pattern"],
   params,
   handler: async ({ params: params2, env, terminalPilotRuntime }) => {
-    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(params2.session, env);
+    if (params2.pattern.trim().length === 0) {
+      throw new UserError("Wait pattern must not be empty.");
+    }
+    assertTimeout2(params2.timeout);
+    const namedSession = await getTerminalPilotRuntime(terminalPilotRuntime).resolveSession(
+      params2.session,
+      env
+    );
     const pattern = params2.literal === true ? params2.pattern : new RegExp(params2.pattern);
     const line = params2.timeout === void 0 ? await namedSession.session.waitFor(pattern) : await namedSession.session.waitFor(pattern, { timeout: params2.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.");
+  }
+}
 export {
   waitFor
 };