@schmitech/orbit-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1577 @@
+// src/cli.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/args.ts
+var ArgsError = class extends Error {
+};
+var FLAGS = /* @__PURE__ */ new Set(["--url", "--key", "--health", "--agent", "--model"]);
+function isFlagLike(value) {
+  return value === void 0 || FLAGS.has(value);
+}
+function parseArgs(argv) {
+  const result = { health: false, positional: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--url": {
+        const value = argv[i + 1];
+        if (isFlagLike(value)) {
+          throw new ArgsError(`--url requires a value`);
+        }
+        result.url = value;
+        i++;
+        break;
+      }
+      case "--key": {
+        const value = argv[i + 1];
+        if (isFlagLike(value)) {
+          throw new ArgsError(`--key requires a value`);
+        }
+        result.key = value;
+        i++;
+        break;
+      }
+      case "--health":
+        result.health = true;
+        break;
+      case "--agent": {
+        const value = argv[i + 1];
+        if (isFlagLike(value)) {
+          throw new ArgsError(`--agent requires a value`);
+        }
+        result.agent = value;
+        i++;
+        break;
+      }
+      case "--model": {
+        const value = argv[i + 1];
+        if (isFlagLike(value)) {
+          throw new ArgsError(`--model requires a value`);
+        }
+        result.model = value;
+        i++;
+        break;
+      }
+      default:
+        result.positional.push(arg);
+    }
+  }
+  return result;
+}
+
+// src/prompt.ts
+import * as readline from "readline";
+var ETX = "";
+var DEL = "\x7F";
+var BS = "\b";
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function askSecret(question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    process.stderr.write(question);
+    const wasRaw = stdin.isTTY ? stdin.isRaw : false;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let value = "";
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      if (stdin.isTTY) stdin.setRawMode(wasRaw);
+      stdin.pause();
+    };
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\n" || char === "\r") {
+          cleanup();
+          process.stderr.write("\n");
+          resolve(value.trim());
+          return;
+        } else if (char === ETX) {
+          cleanup();
+          process.stderr.write("\n");
+          process.exit(130);
+        } else if (char === DEL || char === BS) {
+          value = value.slice(0, -1);
+        } else {
+          value += char;
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/connection.ts
+var ConfigError = class extends Error {
+};
+var DEFAULT_URL = "http://localhost:3000";
+async function resolveConnection(args) {
+  let url = args.url ?? process.env.ORBIT_URL;
+  let apiKey = args.key ?? process.env.ORBIT_API_KEY;
+  if (!url) {
+    if (!process.stdin.isTTY) {
+      url = DEFAULT_URL;
+    } else {
+      const answer = await ask(`ORBIT server URL [${DEFAULT_URL}]: `);
+      url = answer || DEFAULT_URL;
+    }
+  }
+  if (!apiKey) {
+    if (!process.stdin.isTTY) {
+      throw new ConfigError(
+        "Missing API key. Pass --key <key> or set ORBIT_API_KEY (preferred over --key, which lands in shell history)."
+      );
+    }
+    apiKey = await askSecret("ORBIT API key: ");
+  }
+  url = url.trim().replace(/\/+$/, "");
+  if (!url) {
+    throw new ConfigError("Server URL cannot be empty.");
+  }
+  if (!apiKey.trim()) {
+    throw new ConfigError("API key cannot be empty.");
+  }
+  return { url, apiKey: apiKey.trim() };
+}
+
+// src/client.ts
+import { ApiClient } from "@schmitech/chatbot-api";
+function createClient(connection, sessionId) {
+  return new ApiClient({
+    apiUrl: connection.url,
+    apiKey: connection.apiKey,
+    sessionId: sessionId ?? null
+  });
+}
+function streamChat(client, message, options = {}) {
+  return client.streamChat(
+    message,
+    options.stream ?? true,
+    options.fileIds,
+    options.threadId,
+    void 0,
+    // audioInput
+    void 0,
+    // audioFormat
+    void 0,
+    // language
+    void 0,
+    // returnAudio
+    void 0,
+    // ttsVoice
+    void 0,
+    // sourceLanguage
+    void 0,
+    // targetLanguage
+    options.abortSignal,
+    options.model,
+    options.skill,
+    void 0
+    // regenerateOfMessageId
+  );
+}
+
+// src/exit-codes.ts
+var EXIT_OK = 0;
+var EXIT_SERVER_ERROR = 1;
+var EXIT_USAGE = 2;
+var EXIT_AUTH = 3;
+var EXIT_NETWORK = 4;
+var EXIT_CANCELLED = 130;
+
+// src/errors.ts
+function classifyError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|fetch failed|Could not connect to the server/i.test(message)) {
+    return { code: EXIT_NETWORK, message: "Could not connect to the server. Check the URL and that it is running." };
+  }
+  if (/:\s*401\b/.test(message) || /invalid|disabled|no associated adapter/i.test(message)) {
+    return { code: EXIT_AUTH, message: "API key is invalid, disabled, or lacks an adapter." };
+  }
+  return { code: EXIT_SERVER_ERROR, message };
+}
+
+// src/attachments.ts
+import { readFile } from "fs/promises";
+import { basename, extname } from "path";
+var MIME_TYPES = {
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function mimeTypeFor(path) {
+  return MIME_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+var ATTACHMENT_PATTERN = /@(\S+)/g;
+var AttachmentError = class extends Error {
+};
+async function extractAttachments(client, message) {
+  const paths = [...message.matchAll(ATTACHMENT_PATTERN)].map((match) => match[1]);
+  if (paths.length === 0) {
+    return { text: message, fileIds: [] };
+  }
+  const fileIds = [];
+  for (const path of paths) {
+    let bytes;
+    try {
+      bytes = await readFile(path);
+    } catch {
+      throw new AttachmentError(`Attachment not found: ${path}`);
+    }
+    const file = new File([bytes], basename(path), { type: mimeTypeFor(path) });
+    const uploaded = await client.uploadFile(file);
+    fileIds.push(uploaded.file_id);
+  }
+  const text = message.replace(ATTACHMENT_PATTERN, "").replace(/\s+/g, " ").trim();
+  return { text: text || "Please review the attached file(s).", fileIds };
+}
+
+// src/artifacts.ts
+import { mkdir, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+var OUT_DIR = "./.orbit-out";
+var INLINE_FIELDS = [
+  { data: "image", format: "image_format", kind: "image" },
+  { data: "video", format: "video_format", kind: "video" },
+  { data: "document", format: "document_format", kind: "document" }
+];
+var URL_FIELDS = [
+  { url: "image_url", kind: "image" },
+  { url: "video_url", kind: "video" },
+  { url: "document_url", kind: "document" },
+  { url: "generated_audio_url", kind: "audio" }
+];
+async function writeArtifact(kind, format, bytes) {
+  await mkdir(OUT_DIR, { recursive: true });
+  const ext = format ? `.${format}` : "";
+  const path = `${OUT_DIR}/${kind}-${randomUUID()}${ext}`;
+  await writeFile(path, bytes);
+  return path;
+}
+function extFromContentType(contentType) {
+  if (!contentType) return "";
+  const subtype = contentType.split("/")[1]?.split(";")[0];
+  return subtype ? `.${subtype}` : "";
+}
+async function saveArtifacts(client, chunk) {
+  const paths = [];
+  const record = chunk;
+  const savedKinds = /* @__PURE__ */ new Set();
+  for (const { data, format, kind } of INLINE_FIELDS) {
+    const base64 = record[data];
+    if (base64) {
+      paths.push(await writeArtifact(kind, record[format], Buffer.from(base64, "base64")));
+      savedKinds.add(kind);
+    }
+  }
+  for (const { url, kind } of URL_FIELDS) {
+    if (savedKinds.has(kind)) continue;
+    const value = record[url];
+    if (value) {
+      const { data, contentType } = await client.downloadArtifact(value);
+      paths.push(await writeArtifact(kind, extFromContentType(contentType).replace(/^\./, "") || void 0, Buffer.from(data)));
+    }
+  }
+  return paths;
+}
+
+// src/one-shot.ts
+async function runOneShot(client, rawMessage, options) {
+  let message;
+  let fileIds;
+  try {
+    ({ text: message, fileIds } = await extractAttachments(client, rawMessage));
+  } catch (error) {
+    if (error instanceof AttachmentError) {
+      process.stderr.write(`${error.message}
+`);
+      return EXIT_USAGE;
+    }
+    const { code, message: errorMessage } = classifyError(error);
+    process.stderr.write(`${errorMessage}
+`);
+    return code;
+  }
+  try {
+    for await (const chunk of streamChat(client, message, {
+      ...options,
+      fileIds,
+      abortSignal: options.signal
+    })) {
+      if (chunk.text) {
+        process.stdout.write(chunk.text);
+      }
+      for (const path of await saveArtifacts(client, chunk)) {
+        process.stderr.write(`Saved artifact: ${path}
+`);
+      }
+    }
+    process.stdout.write("\n");
+    return EXIT_OK;
+  } catch (error) {
+    if (options.signal?.aborted) {
+      return EXIT_CANCELLED;
+    }
+    const { code, message: errorMessage } = classifyError(error);
+    process.stderr.write(`${errorMessage}
+`);
+    return code;
+  }
+}
+
+// src/repl.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as fs from "fs";
+
+// src/agents.ts
+async function listAgents(client, ownAdapter) {
+  const choices = [
+    { label: `${ownAdapter.client_name} (default)`, skill: void 0, adapterName: ownAdapter.adapter_name }
+  ];
+  try {
+    const { skills } = await client.getAllSkills();
+    for (const skill of skills.filter((s) => s.enabled)) {
+      choices.push({
+        label: `${skill.name} \u2014 ${skill.description}`,
+        skill: skill.name,
+        adapterName: skill.adapter_name
+      });
+    }
+  } catch {
+  }
+  return choices;
+}
+function findAgent(agents, query) {
+  const index = Number(query);
+  if (Number.isInteger(index) && index >= 1 && index <= agents.length) {
+    return agents[index - 1];
+  }
+  return agents.find((a) => a.skill?.toLowerCase() === query.toLowerCase());
+}
+
+// src/input.ts
+import * as readline2 from "readline";
+
+// src/tty.ts
+function ansiEnabled() {
+  return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+
+// src/input.ts
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var INVERT = "\x1B[7m";
+var CTRL_C = "";
+var ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+function isWideCodePoint(cp) {
+  return cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp === 9001 || cp === 9002 || cp >= 11904 && cp <= 12350 || // CJK Radicals..CJK Symbols
+  cp >= 12353 && cp <= 13311 || // Hiragana..CJK Compatibility
+  cp >= 13312 && cp <= 19903 || // CJK Extension A
+  cp >= 19968 && cp <= 40959 || // CJK Unified Ideographs
+  cp >= 40960 && cp <= 42191 || // Yi
+  cp >= 44032 && cp <= 55203 || // Hangul Syllables
+  cp >= 63744 && cp <= 64255 || // CJK Compatibility Ideographs
+  cp >= 65072 && cp <= 65103 || // CJK Compatibility Forms
+  cp >= 65280 && cp <= 65376 || // Fullwidth Forms
+  cp >= 65504 && cp <= 65510 || cp >= 127744 && cp <= 129791 || // emoji blocks (approximate)
+  cp >= 131072 && cp <= 262141;
+}
+function isZeroWidthCodePoint(cp) {
+  return cp === 8203 || // zero width space
+  cp === 8204 || cp === 8205 || // zero width joiner
+  cp === 65279 || cp >= 768 && cp <= 879 || // combining diacritics
+  cp >= 6832 && cp <= 6911 || cp >= 7616 && cp <= 7679 || cp >= 8400 && cp <= 8447 || cp >= 65024 && cp <= 65039;
+}
+function displayWidth(str) {
+  const clean = str.replace(ANSI_PATTERN, "");
+  let width = 0;
+  for (const ch of clean) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (isZeroWidthCodePoint(cp)) continue;
+    width += isWideCodePoint(cp) ? 2 : 1;
+  }
+  return width;
+}
+function rowsFor(text, width) {
+  return Math.max(1, Math.ceil(displayWidth(text) / width) || 1);
+}
+var graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function graphemes(str) {
+  if (graphemeSegmenter) {
+    return Array.from(graphemeSegmenter.segment(str), (s) => s.segment);
+  }
+  return Array.from(str);
+}
+function commonPrefix(strings) {
+  if (strings.length === 0) return "";
+  let prefix = strings[0];
+  for (const s of strings.slice(1)) {
+    let i = 0;
+    while (i < prefix.length && i < s.length && prefix[i] === s[i]) i++;
+    prefix = prefix.slice(0, i);
+  }
+  return prefix;
+}
+var LineReader = class {
+  prompt;
+  commands;
+  completer;
+  onSigint;
+  stdin = process.stdin;
+  history = [];
+  buffer = "";
+  cursor = 0;
+  historyIndex = 0;
+  menuVisible = false;
+  menuIndex = 0;
+  menuItems = [];
+  searchMode = false;
+  searchQuery = "";
+  searchMatch;
+  searchScanIndex = 0;
+  secretMode = false;
+  secretPrompt = "";
+  secretBuffer = "";
+  resolveSecret = null;
+  listMode = false;
+  listPrompt = "";
+  listQuery = "";
+  listAllItems = [];
+  listFiltered = [];
+  listIndex = 0;
+  resolveList = null;
+  resolveLine = null;
+  closed = false;
+  wasRaw = false;
+  /** Row offset (relative to the input's first row) the cursor was left on by the last render, for wrapped-line redraw bookkeeping. */
+  lastCursorRow = 0;
+  constructor(options) {
+    this.prompt = options.prompt;
+    this.commands = options.commands;
+    this.completer = options.completer;
+    this.onSigint = options.onSigint;
+    if (this.stdin.isTTY) {
+      readline2.emitKeypressEvents(this.stdin);
+      this.wasRaw = this.stdin.isRaw;
+      this.stdin.setRawMode(true);
+    }
+    this.stdin.resume();
+    this.stdin.setEncoding("utf8");
+    this.stdin.on("keypress", this.onKeypress);
+  }
+  async *[Symbol.asyncIterator]() {
+    while (!this.closed) {
+      const line = await this.readLine();
+      if (line === null) {
+        return;
+      }
+      yield line;
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.stdin.removeListener("keypress", this.onKeypress);
+    if (this.stdin.isTTY) {
+      this.stdin.setRawMode(this.wasRaw);
+    }
+    this.stdin.pause();
+  }
+  /**
+   * `cursor` counts grapheme clusters, not UTF-16 code units — a `cursor--`
+   * next to an emoji or a surrogate-pair character must skip the whole
+   * cluster, not land inside it. This converts that cluster count to the
+   * actual string offset needed for `buffer.slice(...)`.
+   */
+  cursorStringIndex() {
+    return graphemes(this.buffer).slice(0, this.cursor).join("").length;
+  }
+  /**
+   * Insert `text` at string offset `idx` and recompute the cursor by
+   * re-segmenting the resulting prefix, rather than adding `graphemes(text)`
+   * to the old cursor. The terminal delivers a multi-codepoint emoji (e.g. a
+   * ZWJ family sequence) as separate keypress events one codepoint at a
+   * time; segmented alone, a joiner counts as its own cluster, but Unicode's
+   * grapheme rules attach it to whatever already precedes it in the buffer.
+   * Re-segmenting the real prefix after each keystroke keeps the cursor's
+   * cluster count correct instead of drifting ahead of the buffer's actual
+   * cluster count (which crashes the next backspace/delete on an
+   * out-of-range index).
+   */
+  insertAt(idx, text) {
+    this.buffer = this.buffer.slice(0, idx) + text + this.buffer.slice(idx);
+    this.cursor = graphemes(this.buffer.slice(0, idx + text.length)).length;
+  }
+  /**
+   * Read one line of masked input (e.g. an API key) without it ever being
+   * echoed, written to terminal scrollback, or added to line history — only
+   * a `*` per typed character is shown, same masking `prompt.ts::askSecret()`
+   * uses for the initial connection prompt. Ctrl+C cancels and resolves
+   * `null` instead of exiting the process, since a REPL command is in
+   * progress rather than startup.
+   */
+  readSecret(promptText) {
+    this.secretMode = true;
+    this.secretPrompt = promptText;
+    this.secretBuffer = "";
+    this.lastCursorRow = 0;
+    this.renderSecret();
+    return new Promise((resolve) => {
+      this.resolveSecret = resolve;
+    });
+  }
+  /**
+   * Present `items` as an arrow-key-navigable list (type to filter, like the
+   * `/` command menu) and resolve the chosen index, or `null` on Esc/Ctrl+C.
+   * Used for `/agents` and `/models` so picking one doesn't require typing
+   * its number or name.
+   */
+  selectFromList(promptText, items) {
+    this.listMode = true;
+    this.listPrompt = promptText;
+    this.listQuery = "";
+    this.listAllItems = items;
+    this.listFiltered = items.map((_, i) => i);
+    this.listIndex = 0;
+    this.lastCursorRow = 0;
+    this.renderList();
+    return new Promise((resolve) => {
+      this.resolveList = resolve;
+    });
+  }
+  readLine() {
+    this.buffer = "";
+    this.cursor = 0;
+    this.historyIndex = this.history.length;
+    this.menuVisible = false;
+    this.searchMode = false;
+    this.secretMode = false;
+    this.listMode = false;
+    this.lastCursorRow = 0;
+    this.render();
+    return new Promise((resolve) => {
+      this.resolveLine = resolve;
+    });
+  }
+  onKeypress = (str, key) => {
+    if (this.closed) return;
+    const isCtrlC = key.sequence === CTRL_C || key.ctrl && key.name === "c";
+    if (isCtrlC) {
+      if (this.secretMode) {
+        this.finishSecret(null);
+        return;
+      }
+      if (this.listMode) {
+        this.finishList(null);
+        return;
+      }
+      if (this.searchMode) {
+        this.exitSearch();
+        this.render();
+        return;
+      }
+      this.onSigint();
+      return;
+    }
+    if (this.secretMode) {
+      this.handleSecretKey(str, key);
+      return;
+    }
+    if (this.listMode) {
+      this.handleListKey(str, key);
+      return;
+    }
+    if (!this.resolveLine) {
+      return;
+    }
+    if (this.searchMode) {
+      this.handleSearchKey(str, key);
+      return;
+    }
+    if (key.ctrl && key.name === "r") {
+      this.searchMode = true;
+      this.searchQuery = "";
+      this.searchMatch = void 0;
+      this.searchScanIndex = this.history.length;
+      this.render();
+      return;
+    }
+    if (key.ctrl && key.name === "d") {
+      if (this.buffer.length === 0) {
+        this.finish(null);
+      }
+      return;
+    }
+    switch (key.name) {
+      case "return":
+        if (this.menuVisible && this.menuItems.length > 0) {
+          this.selectMenuItemOnEnter();
+          return;
+        }
+        this.submit();
+        return;
+      case "backspace": {
+        if (this.cursor > 0) {
+          const segs = graphemes(this.buffer);
+          const idx = segs.slice(0, this.cursor - 1).join("").length;
+          const removed = segs[this.cursor - 1];
+          this.buffer = this.buffer.slice(0, idx) + this.buffer.slice(idx + removed.length);
+          this.cursor--;
+        }
+        break;
+      }
+      case "delete": {
+        const segs = graphemes(this.buffer);
+        if (this.cursor < segs.length) {
+          const idx = segs.slice(0, this.cursor).join("").length;
+          const removed = segs[this.cursor];
+          this.buffer = this.buffer.slice(0, idx) + this.buffer.slice(idx + removed.length);
+        }
+        break;
+      }
+      case "left":
+        if (this.cursor > 0) this.cursor--;
+        break;
+      case "right":
+        if (this.cursor < graphemes(this.buffer).length) this.cursor++;
+        break;
+      case "up":
+        if (this.menuVisible && this.menuItems.length > 0) {
+          this.menuIndex = (this.menuIndex - 1 + this.menuItems.length) % this.menuItems.length;
+        } else {
+          this.historyUp();
+        }
+        break;
+      case "down":
+        if (this.menuVisible && this.menuItems.length > 0) {
+          this.menuIndex = (this.menuIndex + 1) % this.menuItems.length;
+        } else {
+          this.historyDown();
+        }
+        break;
+      case "tab":
+        if (this.menuVisible && this.menuItems.length > 0) {
+          this.acceptMenuSelection();
+        } else {
+          this.applyCompletion();
+        }
+        break;
+      case "escape":
+        this.menuVisible = false;
+        this.render();
+        return;
+      default:
+        if (str && !key.ctrl && !key.meta && str >= " ") {
+          this.insertAt(this.cursorStringIndex(), str);
+        }
+    }
+    this.updateMenu();
+    this.render();
+  };
+  historyUp() {
+    if (this.historyIndex > 0) {
+      this.historyIndex--;
+      this.buffer = this.history[this.historyIndex];
+      this.cursor = graphemes(this.buffer).length;
+    }
+  }
+  historyDown() {
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex++;
+      this.buffer = this.history[this.historyIndex];
+      this.cursor = graphemes(this.buffer).length;
+    } else {
+      this.historyIndex = this.history.length;
+      this.buffer = "";
+      this.cursor = 0;
+    }
+  }
+  updateMenu() {
+    const match = /^\/(\S*)$/.exec(this.buffer);
+    if (!match) {
+      this.menuVisible = false;
+      return;
+    }
+    const query = match[1].toLowerCase();
+    const items = this.commands.filter((c) => c.name.slice(1).toLowerCase().startsWith(query));
+    if (items.length === 0) {
+      this.menuVisible = false;
+      return;
+    }
+    this.menuItems = items;
+    if (this.menuIndex >= items.length) {
+      this.menuIndex = 0;
+    }
+    this.menuVisible = true;
+  }
+  acceptMenuSelection() {
+    const item = this.menuItems[this.menuIndex];
+    if (!item) return;
+    this.buffer = `${item.name} `;
+    this.cursor = graphemes(this.buffer).length;
+    this.menuVisible = false;
+  }
+  /**
+   * Enter on a visible menu: a command that takes no further argument (empty
+   * `usage`, e.g. `/models`) runs immediately, since there's nothing left to
+   * type — otherwise Enter would just fill the buffer and force a second
+   * Enter to actually submit it. A command that does take an argument (e.g.
+   * `/agents <name|number>`) still only fills the buffer, the same as Tab,
+   * so the user can type that argument before submitting.
+   */
+  selectMenuItemOnEnter() {
+    const item = this.menuItems[this.menuIndex];
+    if (!item) return;
+    if (item.usage) {
+      this.acceptMenuSelection();
+      this.render();
+      return;
+    }
+    this.menuVisible = false;
+    this.buffer = item.name;
+    this.cursor = graphemes(this.buffer).length;
+    this.submit();
+  }
+  applyCompletion() {
+    const idx = this.cursorStringIndex();
+    const [hits, partial] = this.completer(this.buffer.slice(0, idx));
+    if (hits.length === 1) {
+      this.insertAt(idx, hits[0].slice(partial.length));
+    } else if (hits.length > 1) {
+      const common = commonPrefix(hits);
+      if (common.length > partial.length) {
+        this.insertAt(idx, common.slice(partial.length));
+      }
+    }
+  }
+  handleSearchKey(str, key) {
+    if (key.name === "return") {
+      this.buffer = this.searchMatch ?? this.searchQuery;
+      this.cursor = graphemes(this.buffer).length;
+      this.exitSearch();
+      this.submit();
+      return;
+    }
+    if (key.name === "escape" || key.ctrl && key.name === "g") {
+      this.exitSearch();
+      this.render();
+      return;
+    }
+    if (key.ctrl && key.name === "r") {
+      this.findSearchMatch(true);
+      this.render();
+      return;
+    }
+    if (key.name === "backspace") {
+      this.searchQuery = graphemes(this.searchQuery).slice(0, -1).join("");
+      this.searchScanIndex = this.history.length;
+      this.findSearchMatch(false);
+      this.render();
+      return;
+    }
+    if (str && !key.ctrl && !key.meta && str >= " ") {
+      this.searchQuery += str;
+      this.searchScanIndex = this.history.length;
+      this.findSearchMatch(false);
+    }
+    this.render();
+  }
+  handleSecretKey(str, key) {
+    if (key.name === "return") {
+      this.finishSecret(this.secretBuffer);
+      return;
+    }
+    if (key.name === "backspace") {
+      this.secretBuffer = graphemes(this.secretBuffer).slice(0, -1).join("");
+      this.renderSecret();
+      return;
+    }
+    if (key.name === "escape") {
+      this.finishSecret(null);
+      return;
+    }
+    if (str && !key.ctrl && !key.meta && str >= " ") {
+      this.secretBuffer += str;
+      this.renderSecret();
+    }
+  }
+  renderSecret() {
+    if (this.lastCursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, -this.lastCursorRow);
+    }
+    readline2.cursorTo(process.stdout, 0);
+    readline2.clearScreenDown(process.stdout);
+    const masked = "*".repeat(graphemes(this.secretBuffer).length);
+    const text = this.secretPrompt + masked;
+    process.stdout.write(text);
+    const width = process.stdout.columns || 80;
+    this.lastCursorRow = rowsFor(text, width) - 1;
+  }
+  finishSecret(value) {
+    this.secretMode = false;
+    if (this.lastCursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, -this.lastCursorRow);
+    }
+    readline2.cursorTo(process.stdout, 0);
+    readline2.clearScreenDown(process.stdout);
+    process.stdout.write("\n");
+    this.lastCursorRow = 0;
+    const resolve = this.resolveSecret;
+    this.resolveSecret = null;
+    this.secretBuffer = "";
+    resolve?.(value);
+  }
+  handleListKey(str, key) {
+    if (key.name === "return") {
+      const idx = this.listFiltered[this.listIndex];
+      this.finishList(idx === void 0 ? null : idx);
+      return;
+    }
+    if (key.name === "escape") {
+      this.finishList(null);
+      return;
+    }
+    if (key.name === "up") {
+      if (this.listFiltered.length > 0) {
+        this.listIndex = (this.listIndex - 1 + this.listFiltered.length) % this.listFiltered.length;
+      }
+      this.renderList();
+      return;
+    }
+    if (key.name === "down") {
+      if (this.listFiltered.length > 0) {
+        this.listIndex = (this.listIndex + 1) % this.listFiltered.length;
+      }
+      this.renderList();
+      return;
+    }
+    if (key.name === "backspace") {
+      this.listQuery = graphemes(this.listQuery).slice(0, -1).join("");
+      this.updateListFilter();
+      this.renderList();
+      return;
+    }
+    if (str && !key.ctrl && !key.meta && str >= " ") {
+      this.listQuery += str;
+      this.updateListFilter();
+    }
+    this.renderList();
+  }
+  updateListFilter() {
+    const query = this.listQuery.toLowerCase();
+    this.listFiltered = this.listAllItems.map((label, i) => ({ label, i })).filter(({ label }) => label.toLowerCase().includes(query)).map(({ i }) => i);
+    if (this.listIndex >= this.listFiltered.length) {
+      this.listIndex = 0;
+    }
+  }
+  renderList() {
+    const width = process.stdout.columns || 80;
+    if (this.lastCursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, -this.lastCursorRow);
+    }
+    readline2.cursorTo(process.stdout, 0);
+    readline2.clearScreenDown(process.stdout);
+    const color = ansiEnabled();
+    const headerText = `${this.listPrompt}${this.listQuery}`;
+    process.stdout.write(headerText);
+    let listRows = 0;
+    if (this.listFiltered.length === 0) {
+      const text = `${color ? DIM : ""}  (no matches)${color ? RESET : ""}`;
+      process.stdout.write(`
+${text}`);
+      listRows += rowsFor(text, width);
+    } else {
+      for (const [pos, idx] of this.listFiltered.entries()) {
+        const selected = pos === this.listIndex;
+        const marker = selected ? "\u203A" : " ";
+        const text = `${marker} ${this.listAllItems[idx]}`;
+        const rendered = `${selected && color ? INVERT : ""}${text}${selected && color ? RESET : ""}`;
+        process.stdout.write(`
+${rendered}`);
+        listRows += rowsFor(rendered, width);
+      }
+    }
+    const headerRows = rowsFor(headerText, width);
+    const rowsBelowFirst = headerRows - 1 + listRows;
+    if (rowsBelowFirst > 0) {
+      readline2.moveCursor(process.stdout, 0, -rowsBelowFirst);
+    }
+    const cursorAbsolute = displayWidth(headerText);
+    const cursorRow = Math.floor(cursorAbsolute / width);
+    const cursorCol = cursorAbsolute % width;
+    if (cursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, cursorRow);
+    }
+    readline2.cursorTo(process.stdout, cursorCol);
+    this.lastCursorRow = cursorRow;
+  }
+  finishList(index) {
+    this.listMode = false;
+    if (this.lastCursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, -this.lastCursorRow);
+    }
+    readline2.cursorTo(process.stdout, 0);
+    readline2.clearScreenDown(process.stdout);
+    this.lastCursorRow = 0;
+    const resolve = this.resolveList;
+    this.resolveList = null;
+    resolve?.(index);
+  }
+  findSearchMatch(next) {
+    if (!this.searchQuery) {
+      this.searchMatch = void 0;
+      return;
+    }
+    const start = next ? this.searchScanIndex - 1 : this.history.length - 1;
+    for (let i = start; i >= 0; i--) {
+      if (this.history[i].includes(this.searchQuery)) {
+        this.searchMatch = this.history[i];
+        this.searchScanIndex = i;
+        return;
+      }
+    }
+    this.searchMatch = void 0;
+  }
+  exitSearch() {
+    this.searchMode = false;
+    this.searchQuery = "";
+    this.searchMatch = void 0;
+  }
+  submit() {
+    const line = this.buffer;
+    if (line.trim().length > 0) {
+      this.history.push(line);
+    }
+    this.finish(line);
+  }
+  finish(line) {
+    this.menuVisible = false;
+    if (this.lastCursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, -this.lastCursorRow);
+    }
+    readline2.cursorTo(process.stdout, 0);
+    readline2.clearScreenDown(process.stdout);
+    process.stdout.write(line !== null ? `${this.prompt}${line}
+` : "\n");
+    this.lastCursorRow = 0;
+    const resolve = this.resolveLine;
+    this.resolveLine = null;
+    if (line === null) {
+      this.close();
+    }
+    resolve?.(line);
+  }
+  /** Force the in-flight read to end as EOF, e.g. on an idle Ctrl+C. */
+  requestExit() {
+    if (this.searchMode) {
+      this.exitSearch();
+    }
+    this.finish(null);
+  }
+  render() {
+    const width = process.stdout.columns || 80;
+    if (this.lastCursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, -this.lastCursorRow);
+    }
+    readline2.cursorTo(process.stdout, 0);
+    readline2.clearScreenDown(process.stdout);
+    const color = ansiEnabled();
+    if (this.searchMode) {
+      const label = `(reverse-i-search)\`${this.searchQuery}': `;
+      const text = label + (this.searchMatch ?? "");
+      process.stdout.write(text);
+      this.lastCursorRow = rowsFor(text, width) - 1;
+      return;
+    }
+    const inputText = this.prompt + this.buffer;
+    process.stdout.write(inputText);
+    let menuRows = 0;
+    if (this.menuVisible) {
+      for (const [i, item] of this.menuItems.entries()) {
+        const selected = i === this.menuIndex;
+        const marker = selected ? "\u203A" : " ";
+        const usage = item.usage ? ` ${item.usage}` : "";
+        const text = `${marker} ${item.name}${usage} ${color ? DIM : ""}\u2014 ${item.description}${color ? RESET : ""}`;
+        const rendered = `${selected && color ? INVERT : ""}${text}${selected && color ? RESET : ""}`;
+        process.stdout.write(`
+${rendered}`);
+        menuRows += rowsFor(rendered, width);
+      }
+    }
+    const inputRows = rowsFor(inputText, width);
+    const rowsBelowFirst = inputRows - 1 + menuRows;
+    if (rowsBelowFirst > 0) {
+      readline2.moveCursor(process.stdout, 0, -rowsBelowFirst);
+    }
+    const cursorAbsolute = displayWidth(this.prompt) + displayWidth(this.buffer.slice(0, this.cursorStringIndex()));
+    const cursorRow = Math.floor(cursorAbsolute / width);
+    const cursorCol = cursorAbsolute % width;
+    if (cursorRow > 0) {
+      readline2.moveCursor(process.stdout, 0, cursorRow);
+    }
+    readline2.cursorTo(process.stdout, cursorCol);
+    this.lastCursorRow = cursorRow;
+  }
+};
+
+// src/models.ts
+async function listModels(client, adapterName, skill) {
+  const { models } = await client.getAdapterModels(adapterName, skill);
+  return models;
+}
+function findModel(models, query) {
+  const index = Number(query);
+  if (Number.isInteger(index) && index >= 1 && index <= models.length) {
+    return models[index - 1];
+  }
+  return models.find((m) => m.name?.toLowerCase() === query.toLowerCase() || m.id?.toLowerCase() === query.toLowerCase());
+}
+
+// src/markdown.ts
+import { highlight, supportsLanguage } from "cli-highlight";
+var RESET2 = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var ITALIC = "\x1B[3m";
+var HEADING = "\x1B[1;36m";
+function styleLine(line) {
+  const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+  if (heading) {
+    return `${HEADING}${heading[2]}${RESET2}`;
+  }
+  let out = line;
+  out = out.replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${RESET2}`);
+  out = out.replace(/__(.+?)__/g, `${BOLD}$1${RESET2}`);
+  out = out.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, `${ITALIC}$1${RESET2}`);
+  out = out.replace(/`([^`]+)`/g, `${DIM2}$1${RESET2}`);
+  out = out.replace(/^(\s*)[-*+]\s+/, "$1\u2022 ");
+  out = out.replace(/^(\s*>)\s?/, `${DIM2}\u2502${RESET2} `);
+  return out;
+}
+function stripLine(line) {
+  return line.replace(/^#{1,6}\s+/, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^(\s*)[-*+]\s+/, "$1- ");
+}
+var MarkdownRenderer = class {
+  buffer = "";
+  inFence = false;
+  fenceLang;
+  push(text) {
+    this.buffer += text;
+    let newlineIndex;
+    while ((newlineIndex = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, newlineIndex);
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      this.emitLine(line);
+    }
+  }
+  /** Flush any trailing partial line (the model's reply need not end in \n). */
+  flush() {
+    if (this.buffer.length > 0) {
+      this.emitLine(this.buffer);
+      this.buffer = "";
+    }
+  }
+  emitLine(line) {
+    const color = ansiEnabled();
+    const fenceMatch = /^```\s*(\S*)/.exec(line.trim());
+    if (fenceMatch) {
+      this.inFence = !this.inFence;
+      this.fenceLang = this.inFence ? fenceMatch[1] || void 0 : void 0;
+      if (color) {
+        process.stdout.write(`${DIM2}${line}${RESET2}
+`);
+      }
+      return;
+    }
+    if (this.inFence) {
+      if (!color) {
+        process.stdout.write(`${line}
+`);
+        return;
+      }
+      if (this.fenceLang && supportsLanguage(this.fenceLang)) {
+        try {
+          process.stdout.write(`${highlight(line, { language: this.fenceLang, ignoreIllegals: true })}
+`);
+          return;
+        } catch {
+        }
+      }
+      process.stdout.write(`${DIM2}${line}${RESET2}
+`);
+      return;
+    }
+    process.stdout.write(`${color ? styleLine(line) : stripLine(line)}
+`);
+  }
+};
+
+// src/spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS = 80;
+var Spinner = class {
+  timer = null;
+  frame = 0;
+  start() {
+    if (!ansiEnabled() || this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      process.stdout.write(`\r${FRAMES[this.frame]} `);
+      this.frame = (this.frame + 1) % FRAMES.length;
+    }, INTERVAL_MS);
+  }
+  /** Stop and erase the spinner line so following output starts at column 0. */
+  stop() {
+    if (!this.timer) {
+      return;
+    }
+    clearInterval(this.timer);
+    this.timer = null;
+    process.stdout.write("\r\x1B[K");
+  }
+};
+
+// src/repl.ts
+var COMMANDS = [
+  { name: "/new", usage: "", description: "start a new session (clears server-side context)" },
+  { name: "/agents", usage: "<name|number>", description: "pick an agent (arrow keys), or /agents <name|number>" },
+  { name: "/models", usage: "", description: "pick a model for the current agent (arrow keys)" },
+  { name: "/model", usage: "<id|number>", description: "set the model for later turns" },
+  { name: "/key", usage: "", description: "switch API key without restarting (masked prompt)" },
+  { name: "/clear", usage: "", description: "clear the screen and this session's server-side history" },
+  { name: "/help", usage: "", description: "show this message" },
+  { name: "/exit", usage: "", description: "exit" }
+];
+var HELP = `Commands:
+${COMMANDS.map((c) => `  ${(c.name + " " + c.usage).padEnd(21)}${c.description}`).join("\n")}
+  Ctrl+C               cancel the in-flight turn; again (while idle) to exit
+  Ctrl+R               reverse search through this session's input history
+  Ctrl+D               exit
+@path/to/file inline in a message attaches that file to the turn.
+Type / to see a filtered command menu (arrow keys + Tab/Enter to pick).
+Anything else is sent as a chat turn.`;
+function completer(line) {
+  const match = /(?:^|\s)@(\S*)$/.exec(line);
+  if (!match) {
+    return [[], line];
+  }
+  const partial = match[1];
+  const slash = partial.lastIndexOf("/");
+  const dir = slash === -1 ? "." : partial.slice(0, slash) || "/";
+  const prefix = slash === -1 ? partial : partial.slice(slash + 1);
+  const dirPrefix = slash === -1 ? "" : `${partial.slice(0, slash)}/`;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [[], partial];
+  }
+  const hits = entries.filter((entry) => entry.name.startsWith(prefix)).map((entry) => `${dirPrefix}${entry.name}${entry.isDirectory() ? "/" : ""}`);
+  return [hits, partial];
+}
+var CLEAR_HISTORY_TIMEOUT_MS = 1500;
+async function clearHistoryBestEffort(client, sessionId) {
+  let timedOut = false;
+  let error;
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      timedOut = true;
+      resolve();
+    }, CLEAR_HISTORY_TIMEOUT_MS);
+    client.clearConversationHistory(sessionId).catch((err) => {
+      error = classifyError(err).message;
+    }).then(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+  return { timedOut, error };
+}
+async function runRepl(initialClient, connection, initialSkill, initialModel) {
+  let client = initialClient;
+  let ownAdapter;
+  try {
+    ownAdapter = await client.getAdapterInfo();
+  } catch (error) {
+    const { code, message } = classifyError(error);
+    process.stderr.write(`${message}
+`);
+    return code;
+  }
+  let agents = await listAgents(client, ownAdapter);
+  let currentAgent = agents[0];
+  if (initialSkill) {
+    const found = findAgent(agents, initialSkill);
+    if (found) {
+      currentAgent = found;
+    } else {
+      process.stderr.write(`Unknown agent "${initialSkill}"; using the default adapter.
+`);
+    }
+  }
+  let currentModel = initialModel;
+  let lastModels = [];
+  let controller = null;
+  let currentRequestId;
+  let hasAbandonedCleanup = false;
+  const pendingBackgroundCleanups = /* @__PURE__ */ new Set();
+  const rl = new LineReader({
+    prompt: "> ",
+    commands: COMMANDS,
+    completer,
+    onSigint: () => {
+      if (controller) {
+        controller.abort();
+        const sessionId2 = client.getSessionId();
+        if (sessionId2 && currentRequestId) {
+          client.stopChat(sessionId2, currentRequestId).catch(() => {
+          });
+        }
+        process.stdout.write("\n[cancelled]\n");
+      } else {
+        rl.requestExit();
+      }
+    }
+  });
+  process.stdout.write("Connected. Type /help for commands, Ctrl+D to exit.\n");
+  for await (const line of rl) {
+    const text = line.trim();
+    if (!text) {
+      continue;
+    }
+    if (text.startsWith("/")) {
+      const [command, ...rest] = text.split(/\s+/);
+      const arg = rest.join(" ");
+      switch (command) {
+        case "/new": {
+          const oldSessionId = client.getSessionId();
+          client.setSessionId(randomUUID2());
+          process.stdout.write("Started a new session.\n");
+          if (oldSessionId) {
+            const cleanup = clearHistoryBestEffort(client, oldSessionId).then(({ timedOut, error }) => {
+              if (timedOut) {
+                hasAbandonedCleanup = true;
+              }
+              if (timedOut || error) {
+                process.stderr.write(`Previous session's history was not cleared: ${error ?? "timed out"}
+`);
+              }
+            }).catch(() => {
+            });
+            pendingBackgroundCleanups.add(cleanup);
+            cleanup.finally(() => pendingBackgroundCleanups.delete(cleanup));
+          }
+          break;
+        }
+        case "/agents":
+          if (!arg) {
+            const idx = await rl.selectFromList(
+              "Select agent (type to filter, Esc to cancel): ",
+              agents.map((a) => `${a.label}${a === currentAgent ? "  (current)" : ""}`)
+            );
+            if (idx !== null) {
+              currentAgent = agents[idx];
+              currentModel = void 0;
+              lastModels = [];
+              process.stdout.write(`Switched to ${currentAgent.label}.
+`);
+            }
+          } else {
+            const found = findAgent(agents, arg);
+            if (!found) {
+              process.stdout.write(`No agent matches "${arg}". Try /agents to list them.
+`);
+            } else {
+              currentAgent = found;
+              currentModel = void 0;
+              lastModels = [];
+              process.stdout.write(`Switched to ${found.label}.
+`);
+            }
+          }
+          break;
+        case "/models":
+          try {
+            lastModels = await listModels(client, currentAgent.adapterName, currentAgent.skill);
+            if (lastModels.length === 0) {
+              process.stdout.write("This agent has no restricted model list (uses its configured default).\n");
+            } else {
+              const idx = await rl.selectFromList(
+                "Select model (type to filter, Esc to cancel): ",
+                lastModels.map((m) => {
+                  const id = m.name ?? m.id;
+                  return `${id}${id === currentModel ? "  (current)" : ""}`;
+                })
+              );
+              if (idx !== null) {
+                const picked = lastModels[idx];
+                currentModel = picked.name ?? picked.id;
+                process.stdout.write(`Model set to ${currentModel}.
+`);
+              }
+            }
+          } catch (error) {
+            const { message: message2 } = classifyError(error);
+            process.stderr.write(`${message2}
+`);
+          }
+          break;
+        case "/model":
+          if (!arg) {
+            process.stdout.write(`Current model: ${currentModel ?? "(adapter default)"}
+`);
+          } else {
+            const found = findModel(lastModels, arg);
+            currentModel = found ? found.name ?? found.id : arg;
+            process.stdout.write(`Model set to ${currentModel}.
+`);
+          }
+          break;
+        case "/key": {
+          if (arg) {
+            process.stdout.write(
+              "For your key's safety, run /key with no argument \u2014 it will prompt you separately with input hidden.\n"
+            );
+            break;
+          }
+          const newKey = await rl.readSecret("API key: ");
+          if (newKey === null) {
+            process.stdout.write("Cancelled.\n");
+            break;
+          }
+          if (!newKey.trim()) {
+            process.stderr.write("API key cannot be empty.\n");
+            break;
+          }
+          const candidate = createClient(
+            { url: connection.url, apiKey: newKey.trim() },
+            client.getSessionId() ?? void 0
+          );
+          let newAdapter;
+          try {
+            newAdapter = await candidate.getAdapterInfo();
+          } catch (error) {
+            const { message: message2 } = classifyError(error);
+            process.stderr.write(`Could not switch key: ${message2}
+`);
+            break;
+          }
+          client = candidate;
+          ownAdapter = newAdapter;
+          agents = await listAgents(client, ownAdapter);
+          currentAgent = agents[0];
+          currentModel = void 0;
+          lastModels = [];
+          process.stdout.write(`Switched API key. Now using ${currentAgent.label}.
+`);
+          break;
+        }
+        case "/clear": {
+          const sessionId2 = client.getSessionId();
+          let historyError;
+          if (sessionId2) {
+            const result = await clearHistoryBestEffort(client, sessionId2);
+            if (result.timedOut) {
+              hasAbandonedCleanup = true;
+            }
+            historyError = result.timedOut ? "timed out" : result.error;
+          }
+          process.stdout.write("\x1B[H\x1B[2J\x1B[3J");
+          if (historyError) {
+            process.stderr.write(`Terminal cleared, but server-side history was not: ${historyError}
+`);
+          }
+          break;
+        }
+        case "/help":
+          process.stdout.write(`${HELP}
+`);
+          break;
+        case "/exit":
+          rl.requestExit();
+          continue;
+        default:
+          process.stdout.write(`Unknown command: ${command} (try /help)
+`);
+      }
+      continue;
+    }
+    let message;
+    let fileIds;
+    try {
+      ({ text: message, fileIds } = await extractAttachments(client, text));
+    } catch (error) {
+      if (error instanceof AttachmentError) {
+        process.stderr.write(`${error.message}
+`);
+      } else {
+        const { message: msg } = classifyError(error);
+        process.stderr.write(`${msg}
+`);
+      }
+      continue;
+    }
+    controller = new AbortController();
+    currentRequestId = void 0;
+    const renderer = new MarkdownRenderer();
+    const spinner = new Spinner();
+    spinner.start();
+    try {
+      for await (const chunk of streamChat(client, message, {
+        skill: currentAgent.skill,
+        model: currentModel,
+        fileIds,
+        abortSignal: controller.signal
+      })) {
+        if (chunk.request_id) {
+          currentRequestId = chunk.request_id;
+        }
+        if (chunk.text) {
+          spinner.stop();
+          renderer.push(chunk.text);
+        }
+        const artifactPaths = await saveArtifacts(client, chunk);
+        if (artifactPaths.length > 0) {
+          spinner.stop();
+          renderer.flush();
+          for (const path of artifactPaths) {
+            process.stdout.write(`Saved artifact: ${path}
+`);
+          }
+        }
+      }
+      spinner.stop();
+      renderer.flush();
+      process.stdout.write("\n");
+    } catch (error) {
+      spinner.stop();
+      renderer.flush();
+      if (!controller.signal.aborted) {
+        const { message: msg } = classifyError(error);
+        process.stderr.write(`${msg}
+`);
+      }
+    } finally {
+      spinner.stop();
+      controller = null;
+      currentRequestId = void 0;
+    }
+  }
+  process.stdout.write("\n");
+  const sessionId = client.getSessionId();
+  if (sessionId) {
+    const { timedOut } = await clearHistoryBestEffort(client, sessionId);
+    if (timedOut) {
+      hasAbandonedCleanup = true;
+    }
+  }
+  if (hasAbandonedCleanup || pendingBackgroundCleanups.size > 0) {
+    process.exit(0);
+  }
+  return 0;
+}
+
+// src/stdin.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/cli.ts
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    if (error instanceof ArgsError) {
+      process.stderr.write(`${error.message}
+`);
+      process.exit(EXIT_USAGE);
+    }
+    throw error;
+  }
+  let connection;
+  try {
+    connection = await resolveConnection(args);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      process.stderr.write(`${error.message}
+`);
+      process.exit(EXIT_USAGE);
+    }
+    throw error;
+  }
+  const client = createClient(connection, args.health ? void 0 : randomUUID3());
+  if (args.health) {
+    try {
+      const [health, adapterInfo] = await Promise.all([
+        client.getHealth(),
+        client.getAdapterInfo()
+      ]);
+      process.stdout.write(`${JSON.stringify({ ...health, adapter: adapterInfo })}
+`);
+      process.exit(EXIT_OK);
+    } catch (error) {
+      const { code: code2, message: message2 } = classifyError(error);
+      process.stderr.write(`${message2}
+`);
+      process.exit(code2);
+    }
+  }
+  const rawMessage = args.positional[0];
+  if (rawMessage === void 0) {
+    if (!process.stdin.isTTY) {
+      process.stderr.write(
+        'No message provided and stdin is not a terminal. Pass a message, or "-" to read one from stdin.\n'
+      );
+      process.exit(EXIT_USAGE);
+    }
+    const code2 = await runRepl(client, connection, args.agent, args.model);
+    process.exitCode = code2;
+    return;
+  }
+  const message = rawMessage === "-" ? (await readStdin()).trim() : rawMessage;
+  if (!message) {
+    process.stderr.write("No message provided.\n");
+    process.exit(EXIT_USAGE);
+  }
+  process.stdout.on("error", (error) => {
+    if (error.code === "EPIPE") {
+      process.exit(EXIT_OK);
+    }
+  });
+  const controller = new AbortController();
+  process.once("SIGINT", () => controller.abort());
+  const code = await runOneShot(client, message, {
+    skill: args.agent,
+    model: args.model,
+    signal: controller.signal
+  });
+  process.exitCode = code;
+}
+main().catch((error) => {
+  process.stderr.write(`Unexpected error: ${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map