@aiderdesk/aiderdesk 0.70.0 → 0.71.0

package/out/cli.js

@@ -3,9 +3,11 @@ const fs = require("fs");
 const path = require("path");
 const commander = require("commander");
 const child_process = require("child_process");
-const piTui = require("@mariozechner/pi-tui");
+const piTui = require("@earendil-works/pi-tui");
+const http = require("http");
 const READY_PATTERN = /AiderDesk Runner is ready and running on port (\d+)/;
 const DEFAULT_PORT = 24337;
+const DEFAULT_HOST = "localhost";
 const MAX_LOG_LINES = 500;
 const pkgRoot = path.resolve(path.dirname(__filename), "..");
 const resourcesDir = path.resolve(pkgRoot, "out", "resources");
@@ -548,6 +550,1008 @@ function registerTuiCommand(program2) {
     runTui(port);
   });
 }
+const REASONING_PREVIEW_LINES = 5;
+const TOOL_PREVIEW_LINES = 5;
+const BLOCK_INDENT = 4;
+const HEADER_HINT = c.gray("[Enter]");
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+const ICON_REASONING = "💭";
+const ICON_TOOL_RUNNING = "⚙";
+const ICON_TOOL_OK = "✓";
+const ICON_TOOL_ERR = "✗";
+const ICON_USER = "🧑";
+function formatToolArgs$1(args) {
+  if (!args || typeof args !== "object") {
+    return "";
+  }
+  const entries = Object.entries(args);
+  if (entries.length === 0) {
+    return "";
+  }
+  const summary = entries.map(([key, value]) => {
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    const truncated = str.length > 60 ? str.substring(0, 57) + "..." : str;
+    return `${key}=${truncated}`;
+  }).join(", ");
+  return `(${summary})`;
+}
+function getSpinnerFrame(elapsedMs) {
+  const idx = Math.floor(elapsedMs / SPINNER_INTERVAL_MS) % SPINNER_FRAMES.length;
+  return SPINNER_FRAMES[idx] ?? SPINNER_FRAMES[0];
+}
+class RunStreamModel {
+  constructor() {
+    this.blocks = [];
+    this.reasoningByMessageId = /* @__PURE__ */ new Map();
+    this.answerByMessageId = /* @__PURE__ */ new Map();
+    this.toolById = /* @__PURE__ */ new Map();
+  }
+  appendReasoning(messageId, text) {
+    if (!text) return;
+    let block = this.reasoningByMessageId.get(messageId);
+    if (!block) {
+      block = { type: "reasoning", id: messageId, text: "", streaming: true };
+      this.reasoningByMessageId.set(messageId, block);
+      this.blocks.push(block);
+    }
+    block.text += text;
+  }
+  freezeReasoning(messageId) {
+    const block = this.reasoningByMessageId.get(messageId);
+    if (block) {
+      block.streaming = false;
+    }
+  }
+  appendAnswer(messageId, text) {
+    if (!text) return;
+    let block = this.answerByMessageId.get(messageId);
+    if (!block) {
+      this.freezeReasoning(messageId);
+      block = { type: "answer", id: messageId, text: "", finished: false };
+      this.answerByMessageId.set(messageId, block);
+      this.blocks.push(block);
+    }
+    block.text += text;
+  }
+  startTool(id, toolName, args) {
+    if (this.toolById.has(id)) return;
+    const block = {
+      type: "tool",
+      id,
+      toolName,
+      argsSummary: formatToolArgs$1(args),
+      output: "",
+      error: false,
+      finished: false
+    };
+    this.toolById.set(id, block);
+    this.blocks.push(block);
+  }
+  endTool(id, output, error = false) {
+    const block = this.toolById.get(id);
+    if (!block) return;
+    block.output = output ?? "";
+    block.error = error;
+    block.finished = true;
+  }
+  completeResponse(messageId, fullContent) {
+    let block = this.answerByMessageId.get(messageId);
+    if (!block) {
+      if (fullContent) {
+        this.appendAnswer(messageId, fullContent);
+      }
+      block = this.answerByMessageId.get(messageId);
+    } else if (fullContent && fullContent.startsWith(block.text)) {
+      block.text = fullContent;
+    } else if (fullContent && !block.text) {
+      block.text = fullContent;
+    }
+    if (block) {
+      block.finished = true;
+    }
+    this.freezeReasoning(messageId);
+  }
+  getBlocks() {
+    return this.blocks;
+  }
+  getSelectableIndices() {
+    const out = [];
+    for (let i = 0; i < this.blocks.length; i++) {
+      const b = this.blocks[i];
+      if (b && (b.type === "reasoning" || b.type === "tool")) {
+        out.push(i);
+      }
+    }
+    return out;
+  }
+}
+function renderReasoningPreview(block, width, maxLines = REASONING_PREVIEW_LINES) {
+  if (!block.text) return [];
+  const wrapWidth = Math.max(1, width - BLOCK_INDENT);
+  const wrapped = piTui.wrapTextWithAnsi(block.text, wrapWidth);
+  const lines = wrapped.length > maxLines ? wrapped.slice(-maxLines) : wrapped;
+  return lines.map((line) => c.gray(" ".repeat(BLOCK_INDENT) + piTui.truncateToWidth(line, wrapWidth)));
+}
+function renderToolPreview(block, width, maxLines = TOOL_PREVIEW_LINES) {
+  if (!block.output) return [];
+  const wrapWidth = Math.max(1, width - BLOCK_INDENT);
+  const wrapped = piTui.wrapTextWithAnsi(block.output, wrapWidth);
+  const lines = wrapped.length > maxLines ? wrapped.slice(0, maxLines) : wrapped;
+  const colorFn = block.error ? c.red : c.gray;
+  const out = lines.map((line) => colorFn(" ".repeat(BLOCK_INDENT) + piTui.truncateToWidth(line, wrapWidth)));
+  if (wrapped.length > maxLines) {
+    const moreCount = wrapped.length - maxLines;
+    out.push(c.gray(" ".repeat(BLOCK_INDENT) + `… +${moreCount} more [Enter]`));
+  }
+  return out;
+}
+function renderReasoningFull(block, width) {
+  if (!block.text) return [c.gray("(empty)")];
+  const wrapWidth = Math.max(1, width);
+  const wrapped = piTui.wrapTextWithAnsi(block.text, wrapWidth);
+  if (wrapped.length === 0) {
+    return [c.gray("(empty)")];
+  }
+  const numWidth = String(wrapped.length).length + 2;
+  return wrapped.map((line, i) => {
+    const num = String(i + 1).padStart(numWidth, " ");
+    return c.gray(num + " " + piTui.truncateToWidth(line, wrapWidth - numWidth - 1));
+  });
+}
+function renderToolFull(block, width) {
+  const wrapWidth = Math.max(1, width);
+  const wrapped = block.output ? piTui.wrapTextWithAnsi(block.output, wrapWidth) : [];
+  const colorFn = block.error ? c.red : c.gray;
+  if (wrapped.length === 0) {
+    return [colorFn("(no output)")];
+  }
+  const numWidth = String(wrapped.length).length + 2;
+  return wrapped.map((line, i) => {
+    const num = String(i + 1).padStart(numWidth, " ");
+    return colorFn(num + " " + piTui.truncateToWidth(line, wrapWidth - numWidth - 1));
+  });
+}
+function renderAnswerLines(block, width) {
+  if (!block.text) return [];
+  const wrapWidth = Math.max(1, width - 2);
+  const wrapped = piTui.wrapTextWithAnsi(block.text, wrapWidth);
+  return wrapped.map((line) => piTui.truncateToWidth(line, wrapWidth));
+}
+function buildBlockHeader(block, width, selected) {
+  if (block.type === "answer") {
+    return null;
+  }
+  const marker = selected ? c.cyan("▶") : " ";
+  let icon;
+  let body;
+  let iconColor;
+  let showHint = false;
+  if (block.type === "reasoning") {
+    icon = ICON_REASONING;
+    body = block.streaming ? "Thinking…" : "Thinking";
+    iconColor = c.gray;
+    showHint = !!block.text;
+  } else {
+    if (block.finished) {
+      icon = block.error ? ICON_TOOL_ERR : ICON_TOOL_OK;
+      iconColor = block.error ? c.red : c.green;
+      showHint = !!block.output;
+    } else {
+      icon = ICON_TOOL_RUNNING;
+      iconColor = c.yellow;
+      showHint = false;
+    }
+    body = block.toolName + (block.argsSummary || "");
+  }
+  const left = ` ${marker} ${iconColor(icon)}  ${c.bold}${body}${c.reset}`;
+  const leftW = piTui.visibleWidth(left);
+  const hintStr = showHint ? HEADER_HINT : "";
+  const hintW = piTui.visibleWidth(hintStr);
+  const pad = Math.max(1, width - leftW - hintW);
+  return piTui.truncateToWidth(left + " ".repeat(pad) + hintStr, width);
+}
+class ContentOverlay {
+  constructor(title) {
+    this.lines = [];
+    this.scrollOffset = 0;
+    this.title = title;
+  }
+  setContent(lines) {
+    this.lines = lines;
+    this.scrollOffset = 0;
+  }
+  invalidate() {
+  }
+  handleInput(data) {
+    if (piTui.matchesKey(data, piTui.Key.escape) || piTui.matchesKey(data, "q") || piTui.matchesKey(data, piTui.Key.enter)) {
+      this.onClose?.();
+      return;
+    }
+    const total = this.lines.length;
+    const viewport = this.viewportHeight();
+    const maxOffset = Math.max(0, total - viewport);
+    if (piTui.matchesKey(data, piTui.Key.up)) {
+      this.scrollOffset = Math.min(this.scrollOffset + 1, maxOffset);
+    } else if (piTui.matchesKey(data, piTui.Key.down)) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+    } else if (piTui.matchesKey(data, piTui.Key.pageUp)) {
+      this.scrollOffset = Math.min(this.scrollOffset + viewport, maxOffset);
+    } else if (piTui.matchesKey(data, piTui.Key.pageDown)) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - viewport);
+    } else if (piTui.matchesKey(data, piTui.Key.home)) {
+      this.scrollOffset = maxOffset;
+    } else if (piTui.matchesKey(data, piTui.Key.end)) {
+      this.scrollOffset = 0;
+    }
+  }
+  viewportHeight() {
+    const termRows = process.stdout.rows || 24;
+    return Math.max(3, termRows - 5);
+  }
+  render(width) {
+    const viewport = this.viewportHeight();
+    const result = [
+      c.bgCyanBlack(` ${this.title} `),
+      c.gray("─".repeat(width))
+    ];
+    const start = this.scrollOffset;
+    const visible = this.lines.slice(start, start + viewport);
+    for (const line of visible) {
+      result.push(piTui.truncateToWidth(line, width));
+    }
+    while (result.length < viewport + 2) {
+      result.push("");
+    }
+    result.push(c.gray("─".repeat(width)));
+    const total = this.lines.length;
+    const label = total === 0 ? " empty " : ` ${start + 1}-${Math.min(start + viewport, total)} of ${total} `;
+    const scrollHint = c.gray(" ↑↓ scroll • Esc/Enter close ");
+    const hintW = piTui.visibleWidth(scrollHint);
+    const labelStr = c.gray(label);
+    const labelW = piTui.visibleWidth(labelStr);
+    const pad = Math.max(1, width - hintW - labelW);
+    result.push(piTui.truncateToWidth(scrollHint + " ".repeat(pad) + labelStr, width));
+    return result;
+  }
+}
+class RunStreamView {
+  constructor(tui, model, opts) {
+    this.selectedSlot = 0;
+    this.followSelection = true;
+    this.scrollOffset = 0;
+    this.autoFollow = true;
+    this.finished = false;
+    this.status = "streaming";
+    this.overlay = null;
+    this.loadingMessage = null;
+    this.spinnerStartTime = 0;
+    this.spinnerIntervalId = null;
+    this.tui = tui;
+    this.model = model;
+    this.opts = opts;
+    this.headerText = `AiderDesk Run${opts.taskId ? ` — task:${opts.taskId}` : ""}`;
+  }
+  notifyChanged() {
+    if (this.followSelection) {
+      const indices = this.model.getSelectableIndices();
+      this.selectedSlot = Math.max(0, indices.length - 1);
+    }
+    this.tui.requestRender();
+  }
+  setInterrupted() {
+    this.status = "interrupted";
+    this.finished = true;
+    this.tui.requestRender();
+  }
+  setFinished() {
+    this.finished = true;
+    if (this.status === "streaming") {
+      this.status = "done";
+    }
+    this.stopSpinner();
+    this.loadingMessage = null;
+    this.tui.requestRender();
+  }
+  setLoadingMessage(message) {
+    this.loadingMessage = message;
+    if (message) {
+      this.startSpinner();
+    } else {
+      this.stopSpinner();
+    }
+    this.tui.requestRender();
+  }
+  startSpinner() {
+    if (this.spinnerIntervalId) return;
+    this.spinnerStartTime = Date.now();
+    this.spinnerIntervalId = setInterval(() => {
+      this.tui.requestRender();
+    }, SPINNER_INTERVAL_MS);
+  }
+  stopSpinner() {
+    if (this.spinnerIntervalId) {
+      clearInterval(this.spinnerIntervalId);
+      this.spinnerIntervalId = null;
+    }
+  }
+  invalidate() {
+    this.tui.requestRender();
+  }
+  handleInput(data) {
+    if (piTui.matchesKey(data, piTui.Key.ctrl("c"))) {
+      return;
+    }
+    if (this.overlay) {
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.escape)) {
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.enter) || piTui.matchesKey(data, "e")) {
+      this.toggleOverlay();
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.up)) {
+      const indices = this.model.getSelectableIndices();
+      if (indices.length === 0) return;
+      this.selectedSlot = (this.selectedSlot - 1 + indices.length) % indices.length;
+      this.followSelection = this.selectedSlot === indices.length - 1;
+      this.tui.requestRender();
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.down)) {
+      const indices = this.model.getSelectableIndices();
+      if (indices.length === 0) return;
+      this.selectedSlot = (this.selectedSlot + 1) % indices.length;
+      this.followSelection = this.selectedSlot === indices.length - 1;
+      this.tui.requestRender();
+      return;
+    }
+    const viewportHeight = Math.max(3, (process.stdout.rows || 24) / 2);
+    if (piTui.matchesKey(data, piTui.Key.pageUp)) {
+      this.scrollOffset += Math.max(3, Math.floor(viewportHeight));
+      this.autoFollow = false;
+      this.tui.requestRender();
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.pageDown)) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - Math.max(3, Math.floor(viewportHeight)));
+      if (this.scrollOffset === 0) this.autoFollow = true;
+      this.tui.requestRender();
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.end)) {
+      this.scrollOffset = 0;
+      this.autoFollow = true;
+      this.tui.requestRender();
+      return;
+    }
+    if (piTui.matchesKey(data, piTui.Key.home)) {
+      this.scrollOffset = Number.MAX_SAFE_INTEGER;
+      this.autoFollow = false;
+      this.tui.requestRender();
+      return;
+    }
+  }
+  toggleOverlay() {
+    if (this.overlay) {
+      this.overlay.handle.hide();
+      this.overlay = null;
+      return;
+    }
+    const indices = this.model.getSelectableIndices();
+    if (this.selectedSlot < 0 || this.selectedSlot >= indices.length) return;
+    const blockIndex = indices[this.selectedSlot];
+    const blocks = this.model.getBlocks();
+    const block = blocks[blockIndex];
+    if (!block || block.type === "answer") return;
+    const overlayWidth = Math.min(160, Math.max(60, (process.stdout.columns || 80) - 4));
+    const lines = block.type === "reasoning" ? renderReasoningFull(block, overlayWidth - 6) : renderToolFull(block, overlayWidth - 6);
+    const title = block.type === "reasoning" ? `${ICON_REASONING} Thinking` : `${block.error ? ICON_TOOL_ERR : ICON_TOOL_OK} ${block.toolName}${block.argsSummary || ""}`;
+    const overlay = new ContentOverlay(title);
+    overlay.setContent(lines);
+    overlay.onClose = () => {
+      if (this.overlay) {
+        this.overlay.handle.hide();
+        this.overlay = null;
+      }
+    };
+    const handle = this.tui.showOverlay(overlay, {
+      width: overlayWidth,
+      maxHeight: Math.floor((process.stdout.rows || 24) * 0.8),
+      anchor: "center"
+    });
+    this.overlay = { handle, component: overlay };
+  }
+  computeSelectedIndex() {
+    const indices = this.model.getSelectableIndices();
+    if (indices.length === 0) return -1;
+    const slot = Math.min(this.selectedSlot, indices.length - 1);
+    return indices[slot];
+  }
+  renderHeader(width) {
+    const left = c.gray(` ${this.headerText}`);
+    const statusText = this.status === "streaming" ? c.yellow("● streaming") : this.status === "interrupted" ? c.red("● interrupted") : c.green("● done");
+    const leftW = piTui.visibleWidth(left);
+    const rightW = piTui.visibleWidth(statusText);
+    const pad = Math.max(1, width - leftW - rightW);
+    return piTui.truncateToWidth(left + " ".repeat(pad) + statusText, width);
+  }
+  renderUserPrompt(prompt, width) {
+    const wrapWidth = Math.max(1, width - BLOCK_INDENT - 3);
+    const wrapped = piTui.wrapTextWithAnsi(prompt, wrapWidth);
+    const out = wrapped.map((line) => `${c.cyan(ICON_USER)} ${c.bold}${piTui.truncateToWidth(line, wrapWidth)}${c.reset}`);
+    return out.length > 0 ? out : [c.cyan(ICON_USER)];
+  }
+  renderFooter(width) {
+    const hint = c.gray(" ↑↓ select • Enter expand • Ctrl+C interrupt ");
+    let right = "";
+    if (!this.autoFollow) {
+      right = c.gray(this.scrollOffset === Number.MAX_SAFE_INTEGER ? " top " : ` ↑${this.scrollOffset} `);
+    }
+    const hintW = piTui.visibleWidth(hint);
+    const rightW = piTui.visibleWidth(right);
+    const pad = Math.max(1, width - hintW - rightW);
+    return piTui.truncateToWidth(hint + " ".repeat(pad) + right, width);
+  }
+  render(width) {
+    const lines = [];
+    lines.push(this.renderHeader(width));
+    lines.push(c.gray("─".repeat(width)));
+    if (this.opts.prompt) {
+      lines.push(...this.renderUserPrompt(this.opts.prompt, width));
+      lines.push("");
+    }
+    const selectedIndex = this.computeSelectedIndex();
+    const blocks = this.model.getBlocks();
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+      if (!block) continue;
+      const selected = i === selectedIndex;
+      const header = buildBlockHeader(block, width, selected);
+      if (header !== null) {
+        lines.push(header);
+      }
+      if (block.type === "reasoning") {
+        lines.push(...renderReasoningPreview(block, width));
+      } else if (block.type === "tool") {
+        lines.push(...renderToolPreview(block, width));
+      } else {
+        lines.push(...renderAnswerLines(block, width));
+      }
+      lines.push("");
+    }
+    if (this.loadingMessage) {
+      const elapsed = Date.now() - this.spinnerStartTime;
+      const frame = getSpinnerFrame(elapsed);
+      const msg = this.loadingMessage || "";
+      lines.push(c.yellow(`${frame} ${msg}`));
+      lines.push("");
+    }
+    lines.push(c.gray("─".repeat(width)));
+    lines.push(this.renderFooter(width));
+    const termHeight = process.stdout.rows || 24;
+    const viewport = termHeight;
+    const total = lines.length;
+    let start;
+    if (this.autoFollow) {
+      start = Math.max(0, total - viewport);
+    } else if (this.scrollOffset === Number.MAX_SAFE_INTEGER) {
+      start = 0;
+    } else {
+      start = Math.max(0, Math.min(total - viewport, total - viewport - this.scrollOffset));
+    }
+    const visible = lines.slice(start, start + viewport);
+    while (visible.length < viewport) {
+      visible.push("");
+    }
+    return visible;
+  }
+}
+const parseEventData = (raw) => {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+};
+const createDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+const formatToolArgs = (args) => {
+  if (!args || typeof args !== "object") {
+    return "";
+  }
+  const entries = Object.entries(args);
+  if (entries.length === 0) {
+    return "";
+  }
+  const summary = entries.map(([key, value]) => {
+    const str = typeof value === "string" ? value : JSON.stringify(value);
+    const truncated = str.length > 60 ? str.substring(0, 57) + "..." : str;
+    return `${key}=${truncated}`;
+  }).join(", ");
+  return `(${summary})`;
+};
+const readStdin = async () => {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+};
+const fetchJSON = async (host, port, path2, method, body) => {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: host,
+      port,
+      path: path2,
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...{}
+      }
+    };
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        let data;
+        try {
+          data = JSON.parse(raw);
+        } catch {
+          data = raw;
+        }
+        resolve({ status: res.statusCode || 200, data });
+      });
+    });
+    req.on("error", reject);
+    req.setTimeout(3e5, () => {
+      req.destroy(new Error("Request timed out"));
+    });
+    req.end();
+  });
+};
+const callInterrupt = (host, port, projectDir, taskId) => {
+  if (!taskId) return Promise.resolve();
+  const body = JSON.stringify({ projectDir, taskId });
+  return new Promise((resolve) => {
+    const options = {
+      hostname: host,
+      port,
+      path: "/api/project/interrupt",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      }
+    };
+    const req = http.request(options, (res) => {
+      res.on("data", () => {
+      });
+      res.on("end", () => resolve());
+    });
+    req.on("error", () => resolve());
+    req.setTimeout(2e3, () => {
+      req.destroy();
+      resolve();
+    });
+    req.write(body);
+    req.end();
+  });
+};
+const requestSSEStream = (host, port, body) => {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: host,
+      port,
+      path: "/api/run-prompt",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Content-Length": Buffer.byteLength(body)
+      }
+    };
+    const req = http.request(options, (res) => {
+      if (res.statusCode !== 200) {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          const raw = Buffer.concat(chunks).toString("utf-8");
+          reject(new Error(`Server returned ${res.statusCode}: ${raw}`));
+        });
+        return;
+      }
+      const taskId = res.headers["x-task-id"];
+      resolve({ stream: res, taskId: taskId || "" });
+    });
+    req.on("error", reject);
+    req.setTimeout(6e5, () => {
+      req.destroy(new Error("Request timed out"));
+    });
+    req.write(body);
+    req.end();
+  });
+};
+const parseSSEEvents = (stream) => {
+  const events = [];
+  let resolve = null;
+  const push = (event) => {
+    events.push(event);
+    if (resolve) {
+      resolve();
+      resolve = null;
+    }
+  };
+  let buffer = "";
+  let currentType = "";
+  let currentData = "";
+  stream.on("data", (chunk) => {
+    buffer += chunk.toString("utf-8");
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.startsWith(":")) {
+        continue;
+      } else if (line.startsWith("event:")) {
+        currentType = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        currentData += (currentData ? "\n" : "") + line.slice(5).trimStart();
+      } else if (line === "") {
+        if (currentType || currentData) {
+          push({ type: currentType, data: currentData });
+          currentType = "";
+          currentData = "";
+        }
+      }
+    }
+  });
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          while (events.length === 0) {
+            const d = createDeferred();
+            resolve = d.resolve;
+            await d.promise;
+          }
+          const event = events.shift();
+          return { value: event, done: false };
+        }
+      };
+    }
+  };
+};
+const formatJSONLine = (type, raw) => {
+  const { taskId, baseDir, ...data } = raw;
+  return JSON.stringify({ type, taskId, projectDir: baseDir, data }) + "\n";
+};
+const runPrompt = async (messages, opts) => {
+  const port = resolvePort(opts.port ? parseInt(opts.port) : void 0);
+  const host = opts.host || DEFAULT_HOST;
+  const format = opts.format === "json" ? "json" : "text";
+  const quiet = opts.quiet;
+  const projectDir = process.cwd();
+  let prompt = messages.join(" ").trim();
+  const stdinContent = await readStdin();
+  if (stdinContent) {
+    prompt = prompt ? `${prompt}
+
+${stdinContent}` : stdinContent;
+  }
+  if (!prompt) {
+    process.stderr.write("Error: No prompt provided. Pass a message or pipe stdin.\n");
+    process.exit(1);
+  }
+  try {
+    const health = await fetchJSON(host, port, "/api/health", "GET");
+    if (health.status !== 200 || health.data.status !== "ok") {
+      process.stderr.write("Error: AiderDesk server is not healthy.\n");
+      process.exit(1);
+    }
+  } catch {
+    process.stderr.write(
+      `Error: AiderDesk server is not running on ${host}:${port}. Start it first with 'aiderdesk' or 'aiderdesk start'.
+`
+    );
+    process.exit(1);
+  }
+  const requestBody = { prompt, projectDir };
+  if (opts.model) {
+    requestBody.model = opts.model;
+  }
+  if (opts.agentProfile) {
+    requestBody.agentProfileId = opts.agentProfile;
+  }
+  if (opts.taskId) {
+    requestBody.taskId = opts.taskId;
+  }
+  const body = JSON.stringify(requestBody);
+  let reqClosed = false;
+  const sseResponse = await requestSSEStream(host, port, body);
+  const taskId = sseResponse.taskId;
+  const eventStream = parseSSEEvents(sseResponse.stream);
+  let interrupted = false;
+  const handleInterrupt = (tui) => {
+    if (interrupted) {
+      process.exit(130);
+    }
+    interrupted = true;
+    if (tui) {
+      tui.stop();
+    }
+    process.stderr.write("\nInterrupting...\n");
+    if (!reqClosed) {
+      sseResponse.stream.destroy();
+    }
+    void callInterrupt(host, port, projectDir, taskId).then(() => process.exit(130));
+    setTimeout(() => process.exit(130), 2e3);
+  };
+  process.on("SIGINT", () => handleInterrupt());
+  process.on("SIGTERM", () => handleInterrupt());
+  const interactive = format === "text" && !quiet && !!process.stdout.isTTY && !!process.stdin.isTTY;
+  if (interactive) {
+    await runInteractiveStream({
+      host,
+      port,
+      projectDir,
+      taskId,
+      prompt,
+      eventStream,
+      sseResponse,
+      onInterrupt: (tui) => handleInterrupt(tui),
+      onDone: (success) => {
+        reqClosed = true;
+        process.exit(success ? 0 : 1);
+      }
+    });
+    return;
+  }
+  let currentResponseText = "";
+  let finished = false;
+  let lastResponseCompleted = null;
+  const seenToolStarts = /* @__PURE__ */ new Set();
+  const seenToolEnds = /* @__PURE__ */ new Set();
+  if (format === "text" && !quiet) {
+    process.stderr.write(`Running prompt in ${projectDir}
+`);
+  }
+  for await (const event of eventStream) {
+    const eventData = parseEventData(event.data);
+    if (!eventData) continue;
+    switch (event.type) {
+      case "response-chunk": {
+        if (format === "json" && !quiet) {
+          process.stdout.write(formatJSONLine("response-chunk", eventData));
+        } else if (format === "text" && !quiet) {
+          const text = eventData.chunk || "";
+          if (text) {
+            process.stdout.write(text);
+            currentResponseText += text;
+          }
+        }
+        break;
+      }
+      case "response-completed": {
+        if (format === "json" && !quiet) {
+          process.stdout.write(formatJSONLine("response-completed", eventData));
+        } else if (quiet) {
+          lastResponseCompleted = eventData;
+        } else {
+          if (eventData.content) {
+            const remainingContent = eventData.content.startsWith(currentResponseText) ? eventData.content.slice(currentResponseText.length) : eventData.content;
+            if (remainingContent) {
+              process.stdout.write(remainingContent);
+            }
+            if (!eventData.content.endsWith("\n")) {
+              process.stdout.write("\n");
+            }
+          } else if (currentResponseText && !currentResponseText.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+        }
+        currentResponseText = "";
+        break;
+      }
+      case "stream-end": {
+        if (quiet && lastResponseCompleted) {
+          if (format === "json") {
+            process.stdout.write(formatJSONLine("response-completed", lastResponseCompleted));
+          } else {
+            const content = lastResponseCompleted.content || "";
+            if (content) {
+              process.stdout.write(content);
+              if (!content.endsWith("\n")) {
+                process.stdout.write("\n");
+              }
+            }
+          }
+        }
+        finished = true;
+        break;
+      }
+      case "tool": {
+        const toolId = eventData.id || "";
+        if (toolId && eventData.toolName) {
+          if (!eventData.finished) {
+            if (seenToolStarts.has(toolId)) {
+              break;
+            }
+            seenToolStarts.add(toolId);
+            if (format === "json" && !quiet) {
+              process.stdout.write(formatJSONLine("tool-start", eventData));
+            } else if (format === "text" && !quiet) {
+              const argsSummary = formatToolArgs(eventData.args);
+              process.stderr.write(`  \x1B[2m⚙ ${eventData.toolName}${argsSummary}\x1B[0m
+`);
+            }
+          } else {
+            if (seenToolEnds.has(toolId)) {
+              break;
+            }
+            seenToolEnds.add(toolId);
+            if (format === "json" && !quiet) {
+              process.stdout.write(formatJSONLine("tool-end", eventData));
+            } else if (format === "text" && !quiet) {
+              const hasError = eventData.response === "error";
+              const symbol = hasError ? "✗" : "✓";
+              process.stderr.write(`  \x1B[2m${symbol} ${eventData.toolName}\x1B[0m
+`);
+            }
+          }
+        }
+        break;
+      }
+      case "log": {
+        if (format === "json" && !quiet) {
+          process.stdout.write(formatJSONLine("log", eventData));
+        } else if (format === "text" && eventData.level === "error" && eventData.message) {
+          process.stderr.write(`\x1B[31mError: ${eventData.message}\x1B[0m
+`);
+        }
+        break;
+      }
+      case "ask-question": {
+        if (format === "json" && !quiet) {
+          process.stdout.write(formatJSONLine("ask-question", eventData));
+        } else if (format === "text" && eventData.question) {
+          process.stderr.write(`
+? ${eventData.question}
+`);
+        }
+        break;
+      }
+      default: {
+        if (format === "json" && !quiet) {
+          process.stdout.write(formatJSONLine(event.type, eventData));
+        }
+        break;
+      }
+    }
+    if (finished) {
+      break;
+    }
+  }
+  reqClosed = true;
+  process.exit(finished ? 0 : 1);
+};
+const runInteractiveStream = async (args) => {
+  const terminal = new piTui.ProcessTerminal();
+  const tui = new piTui.TUI(terminal);
+  const model = new RunStreamModel();
+  const view = new RunStreamView(tui, model, {
+    projectDir: args.projectDir,
+    taskId: args.taskId,
+    host: args.host,
+    port: args.port,
+    prompt: args.prompt,
+    onInterrupt: () => {
+    }
+  });
+  tui.addChild(view);
+  tui.setFocus(view);
+  tui.addInputListener((data) => {
+    if (piTui.matchesKey(data, piTui.Key.ctrl("c"))) {
+      view.setInterrupted();
+      args.onInterrupt(tui);
+      return { consume: true };
+    }
+    return void 0;
+  });
+  process.stdout.write("\x1B[2J\x1B[H");
+  tui.start();
+  let success = false;
+  try {
+    for await (const event of args.eventStream) {
+      const eventData = parseEventData(event.data);
+      if (!eventData) continue;
+      switch (event.type) {
+        case "response-chunk": {
+          if (eventData.reasoning && eventData.messageId) {
+            model.appendReasoning(eventData.messageId, eventData.reasoning);
+          }
+          if (eventData.chunk && eventData.messageId) {
+            model.appendAnswer(eventData.messageId, eventData.chunk);
+          }
+          view.notifyChanged();
+          break;
+        }
+        case "response-completed": {
+          if (eventData.messageId) {
+            model.completeResponse(eventData.messageId, eventData.content);
+          }
+          view.notifyChanged();
+          break;
+        }
+        case "tool": {
+          const toolId = eventData.id || "";
+          if (toolId && eventData.toolName) {
+            if (!eventData.finished) {
+              model.startTool(toolId, eventData.toolName, eventData.args);
+            } else {
+              const hasError = eventData.response === "error";
+              model.endTool(toolId, eventData.response, hasError);
+            }
+            view.notifyChanged();
+          }
+          break;
+        }
+        case "log": {
+          if (eventData.level === "loading") {
+            if (eventData.message) {
+              view.setLoadingMessage(eventData.message);
+            } else {
+              view.setLoadingMessage(null);
+            }
+          } else if (eventData.level === "error" && eventData.message) {
+            view.setLoadingMessage(null);
+          }
+          break;
+        }
+        case "stream-end": {
+          success = true;
+          view.setFinished();
+          break;
+        }
+        default:
+          break;
+      }
+      if (success) {
+        break;
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message === "Request timed out") {
+      view.setInterrupted();
+    }
+  } finally {
+    args.sseResponse.stream.destroy();
+    setTimeout(() => {
+      tui.stop();
+      args.onDone(success);
+    }, 750);
+  }
+};
+function registerRunCommand(program2) {
+  program2.command("run [message...]").description("Run a prompt non-interactively and stream output").option("-p, --port <port>", "server port (env: AIDER_DESK_PORT)", parseInt).option("--host <host>", `server host (default: ${DEFAULT_HOST})`).option("-f, --format <format>", "output format: text (default) or json", "text").option("-q, --quiet", "suppress progress indicators").option("-m, --model <model>", "model to use (format: provider/model, e.g. openai/gpt-4o)").option("-a, --agent-profile <id>", "agent profile ID to use").option("-t, --task-id <id>", "run on an existing task instead of creating a new one").action((messages, opts) => {
+    runPrompt(messages, opts);
+  });
+}
 function getVersion() {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
@@ -560,4 +1564,5 @@ const program = new commander.Command();
 program.name("aiderdesk").description("AiderDesk - AI-Powered Development Platform").version(getVersion(), "-v, --version", "show version number").helpOption("-h, --help", "show help");
 registerStartCommand(program);
 registerTuiCommand(program);
+registerRunCommand(program);
 program.parse();