open-agents-ai 0.187.541 → 0.187.543

package/dist/index.js

@@ -551057,6 +551057,29 @@ function tuiSelect(opts) {
   if (items.length === 0) {
     return Promise.resolve({ confirmed: false, key: null, index: -1 });
   }
+  if (!process.stdin.isTTY && process.env["OA_TUI_FORCE_INTERACTIVE"] !== "1") {
+    const lines = [];
+    if (currentTitle) lines.push(currentTitle);
+    if (lines.length) lines.push("");
+    let idx = 1;
+    for (const item of items) {
+      const isSkip = skipSet.has(item.key);
+      const labelPlain = stripAnsi3(item.label);
+      const detailPlain = item.detail ? stripAnsi3(item.detail) : "";
+      if (isSkip) {
+        lines.push(labelPlain);
+      } else {
+        const num = String(idx).padStart(2, " ");
+        const detail = detailPlain ? `  — ${detailPlain}` : "";
+        lines.push(`  ${num}. ${labelPlain}${detail}`);
+        idx++;
+      }
+    }
+    if (opts.customKeyHint) lines.push("", opts.customKeyHint);
+    lines.push("", "(non-interactive: list shown above; pick options by re-running this command from the TUI)");
+    process.stdout.write(lines.join("\n") + "\n");
+    return Promise.resolve({ confirmed: false, key: null, index: -1 });
+  }
   const isSkippable = (idx) => skipSet.has(items[idx].key);
   let filter2 = "";
   let matchSet = /* @__PURE__ */ new Set();
@@ -585939,6 +585962,171 @@ var init_graphical_sudo = __esm({
   }
 });
 
+// packages/cli/src/api/command-passthrough.ts
+var command_passthrough_exports = {};
+__export(command_passthrough_exports, {
+  runCommand: () => runCommand
+});
+function stripAnsi5(s2) {
+  return s2.replace(/\x1B(?:\[[\d;?]*[a-zA-Z]|\][^\x07\x1B]*[\x07\x1B]?|[@-Z\\-_])/g, "");
+}
+async function runCommand(input, opts) {
+  const start2 = Date.now();
+  const trimmed = input.trim();
+  const slashCmd = trimmed.startsWith("/") ? trimmed : "/" + trimmed;
+  const [rawCmd, ...rest] = slashCmd.slice(1).split(/\s+/);
+  const cmdName = rawCmd ?? "";
+  const argsStr = rest.join(" ");
+  const release = await acquireLock2();
+  try {
+    const buf = [];
+    setContentWriteHook({
+      begin: () => {
+      },
+      end: () => {
+      },
+      redirect: () => (text) => {
+        buf.push(text);
+      }
+    });
+    const origWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = function(chunk, ...rest2) {
+      if (typeof chunk === "string") buf.push(chunk);
+      else if (chunk instanceof Buffer) buf.push(chunk.toString("utf-8"));
+      const cb = rest2.find((r2) => typeof r2 === "function");
+      if (cb) cb();
+      return true;
+    };
+    let kind = "handled";
+    let errMsg;
+    try {
+      const ctx3 = buildSyntheticContext(opts?.config, opts?.repoRoot);
+      kind = await handleSlashCommand(slashCmd, ctx3);
+    } catch (e2) {
+      kind = "error";
+      errMsg = e2 instanceof Error ? e2.message : String(e2);
+      buf.push(`
+[error] ${errMsg}
+`);
+    } finally {
+      process.stdout.write = origWrite;
+      setContentWriteHook({ begin: () => {
+      }, end: () => {
+      } });
+    }
+    const ansi5 = buf.join("");
+    return {
+      ok: kind !== "error" && kind !== "not_a_command",
+      command: cmdName,
+      args: argsStr,
+      kind,
+      output: stripAnsi5(ansi5).trim(),
+      ansi: ansi5,
+      durationMs: Date.now() - start2,
+      error: errMsg
+    };
+  } finally {
+    release();
+  }
+}
+function acquireLock2() {
+  let release;
+  const next = new Promise((res) => {
+    release = res;
+  });
+  const prev = _passthroughLock;
+  _passthroughLock = next;
+  return prev.then(() => release);
+}
+function buildSyntheticContext(config, repoRoot) {
+  const cfg = config ?? loadConfig();
+  return {
+    config: cfg,
+    repoRoot: repoRoot ?? process.cwd(),
+    rl: makeRejectingReadline(),
+    setModel: (_model) => {
+    },
+    setVerbose: (_verbose) => {
+    },
+    setEndpoint: (_url, _t, _k) => {
+    },
+    deactivateStatusBar: () => {
+    },
+    disableMouse: () => {
+    },
+    enableMouse: () => {
+    },
+    isMouseEnabled: () => false,
+    lockFooter: () => {
+    },
+    unlockFooter: () => {
+    },
+    stopBanner: () => {
+    },
+    killEphemeral: () => {
+    },
+    setKeyPool: (_keys) => {
+    },
+    clearScreen: () => {
+    },
+    newSession: () => {
+    },
+    refreshBanner: () => {
+    },
+    exit: () => {
+      renderError2("/quit and /exit are TUI-only — close the browser tab to end the GUI session.");
+    },
+    voiceToggle: async () => {
+      renderError2(`voice ${TUI_ONLY_HINT} — use the GUI voice button instead.`);
+      return "voice not available in GUI";
+    },
+    voiceSetModel: async (_id2) => {
+      renderError2(`voice model ${TUI_ONLY_HINT}`);
+      return "";
+    },
+    saveSettings: (_settings) => {
+    }
+  };
+}
+function makeRejectingReadline() {
+  const reject = () => {
+    throw new Error(
+      "interactive prompts are not supported via the GUI command bridge — run this command from the TUI (open a terminal and type `oa`)."
+    );
+  };
+  const noop2 = () => {
+  };
+  return {
+    question: (_q, _cb) => reject(),
+    close: noop2,
+    write: noop2,
+    on: () => noop2,
+    once: () => noop2,
+    off: () => noop2,
+    removeListener: () => noop2,
+    pause: noop2,
+    resume: noop2,
+    setPrompt: noop2,
+    prompt: noop2,
+    line: "",
+    cursor: 0,
+    terminal: false,
+    input: { isTTY: false, on: noop2, once: noop2, removeListener: noop2, pause: noop2, resume: noop2 },
+    output: { write: noop2, columns: 80, rows: 24, isTTY: false }
+  };
+}
+var _passthroughLock, TUI_ONLY_HINT;
+var init_command_passthrough = __esm({
+  "packages/cli/src/api/command-passthrough.ts"() {
+    "use strict";
+    init_render2();
+    init_commands();
+    init_config();
+    _passthroughLock = Promise.resolve();
+    TUI_ONLY_HINT = "(this command is TUI-only — no-op in GUI)";
+  }
+});
+
 // packages/cli/src/api/routes-v1.ts
 import { existsSync as existsSync103, readFileSync as readFileSync83, readdirSync as readdirSync34, statSync as statSync34 } from "node:fs";
 import { join as join119, resolve as pathResolve2 } from "node:path";
@@ -586026,6 +586214,8 @@ async function tryRouteV1(ctx3) {
   }
   if (pathname === "/v1/share/generate" && method === "POST") return handleGenerateShare(ctx3);
   if (pathname === "/v1/remote-proxy" && method === "POST") return handleRemoteProxy(ctx3);
+  if (pathname === "/v1/command" && method === "POST") return handleCommandPassthrough(ctx3);
+  if (pathname === "/v1/commands" && method === "GET") return handleCommandsList(ctx3);
   if (pathname === "/v1/tor/status" && method === "GET") return handleTorStatus(ctx3);
   if (pathname === "/v1/tor/enable" && method === "POST") return handleTorEnable(ctx3);
   if (pathname === "/v1/tor/disable" && method === "POST") return handleTorDisable(ctx3);
@@ -587704,6 +587894,104 @@ data: ${JSON.stringify({ error: err instanceof Error ? err.message : String(err)
   }
   return true;
 }
+async function handleCommandsList(ctx3) {
+  const { res, requestId } = ctx3;
+  try {
+    const { SLASH_COMMANDS: SLASH_COMMANDS2 } = await Promise.resolve().then(() => (init_render2(), render_exports));
+    const out = [];
+    for (const [sig, desc] of SLASH_COMMANDS2) {
+      const name10 = (sig.split(/\s+/)[0] || "").replace(/^\//, "");
+      if (!name10) continue;
+      out.push({ name: name10, signature: sig, description: desc, kind: "command" });
+    }
+    try {
+      const { discoverSkills: discoverSkills2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports));
+      const skills = discoverSkills2(process.cwd());
+      for (const s2 of Array.isArray(skills) ? skills : []) {
+        const name10 = s2?.name;
+        const desc = s2?.description || "";
+        if (typeof name10 === "string" && name10) {
+          out.push({
+            name: name10,
+            signature: `/${name10}`,
+            description: desc || "(skill)",
+            kind: "skill"
+          });
+        }
+      }
+    } catch {
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const dedup2 = out.filter((c9) => {
+      const k = `${c9.kind}:${c9.signature}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+    sendJson(res, 200, { commands: dedup2, count: dedup2.length });
+  } catch (err) {
+    sendProblem(res, problemDetails({
+      type: P.internalError,
+      status: 500,
+      title: "Commands listing failed",
+      detail: err instanceof Error ? err.message : String(err),
+      instance: requestId
+    }));
+  }
+  return true;
+}
+async function handleCommandPassthrough(ctx3) {
+  const { req: req2, res, requestId } = ctx3;
+  const reqAuth = req2;
+  if (reqAuth._authScope !== "admin" && reqAuth._authScope !== "run") {
+    sendProblem(res, problemDetails({
+      type: P.forbidden,
+      status: 403,
+      title: "Auth required",
+      detail: "Command passthrough requires 'run' or 'admin' scope.",
+      instance: requestId
+    }));
+    return true;
+  }
+  let body;
+  try {
+    body = await parseJsonBodyStrict(req2);
+  } catch {
+    sendProblem(res, problemDetails({
+      type: P.invalidRequest,
+      status: 400,
+      title: "Body must be JSON",
+      detail: "Provide { input: string }",
+      instance: requestId
+    }));
+    return true;
+  }
+  const input = typeof body?.input === "string" ? body.input : "";
+  if (!input.trim()) {
+    sendProblem(res, problemDetails({
+      type: P.invalidRequest,
+      status: 400,
+      title: "input required",
+      detail: "Provide a non-empty 'input' string (e.g. '/help')",
+      instance: requestId
+    }));
+    return true;
+  }
+  try {
+    const { runCommand: runCommand3 } = await Promise.resolve().then(() => (init_command_passthrough(), command_passthrough_exports));
+    const result = await runCommand3(input);
+    sendJson(res, 200, result);
+  } catch (err) {
+    sendProblem(res, problemDetails({
+      type: P.internalError,
+      status: 500,
+      title: "Command dispatch failed",
+      detail: err instanceof Error ? err.message : String(err),
+      instance: requestId
+    }));
+  }
+  return true;
+}
 async function handleRevokeKey(ctx3, prefix) {
   const { req: req2, res, requestId } = ctx3;
   const reqAuth = req2;
@@ -591439,15 +591727,88 @@ async function sendCheckin() {
 }
 window.sendCheckin = sendCheckin;
 
+// ─── Slash command inline runner ────────────────────────────────────────
+// POSTs /v1/command and renders the resulting captured TUI output as a
+// system message in the active chat. Output is plain text by default;
+// when the response carries ANSI we render that into a <pre> block with
+// minimal CSI→span color conversion so theme accents survive.
+async function runSlashCommandInline(rawInput) {
+  const placeholder = addMessage('assistant', '');
+  const head = document.createElement('div');
+  head.style.cssText = 'font-size:0.72rem;color:var(--color-fg-muted);margin-bottom:4px';
+  head.textContent = 'running ' + rawInput.split(/\\s+/)[0] + '…';
+  placeholder.appendChild(head);
+  const body = document.createElement('pre');
+  body.style.cssText = 'margin:0;font-family:var(--font-mono);font-size:0.78rem;white-space:pre-wrap;word-break:break-word';
+  placeholder.appendChild(body);
+  try {
+    const r = await fetch('/v1/command', {
+      method: 'POST',
+      headers: { ...headers(), 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: rawInput }),
+    });
+    if (r.status === 403) {
+      head.textContent = '✗ ' + rawInput;
+      head.style.color = 'var(--color-error)';
+      body.textContent = 'admin/run scope required';
+      return;
+    }
+    const j = await r.json().catch(() => ({}));
+    if (!r.ok) {
+      head.textContent = '✗ ' + rawInput;
+      head.style.color = 'var(--color-error)';
+      body.textContent = (j && j.detail) || ('HTTP ' + r.status);
+      return;
+    }
+    const cmdName = '/' + (j.command || '');
+    const tookMs = j.durationMs || 0;
+    if (j.kind === 'not_a_command') {
+      head.textContent = '? unknown command ' + cmdName;
+      head.style.color = 'var(--color-warning)';
+      body.textContent = j.output || '(no output)';
+    } else if (j.kind === 'exit') {
+      head.textContent = cmdName + ' (exit requested — TUI-only, no-op in GUI)';
+      head.style.color = 'var(--color-fg-muted)';
+      body.textContent = j.output || '';
+    } else if (j.error) {
+      head.textContent = '✗ ' + cmdName;
+      head.style.color = 'var(--color-error)';
+      body.textContent = j.error + (j.output ? '\\n\\n' + j.output : '');
+    } else {
+      head.textContent = '✓ ' + cmdName + (tookMs ? ' (' + tookMs + 'ms)' : '');
+      head.style.color = 'var(--color-success)';
+      body.textContent = j.output || '(no output)';
+    }
+  } catch (e) {
+    head.textContent = '✗ ' + rawInput;
+    head.style.color = 'var(--color-error)';
+    body.textContent = (e && e.message) ? e.message : String(e);
+  }
+}
+
 async function sendMessage() {
   const text = input.value.trim();
   if (!text || streaming) return;
+
+  // ─── Slash command passthrough ────────────────────────────────────────
+  // /foo args  → POST /v1/command, render result inline as a system
+  // message, and skip the chat send entirely. Mirrors TUI behaviour:
+  // commands don't enter the chat history.
+  if (text.startsWith('/') && !text.startsWith('//')) {
+    input.value = '';
+    input.style.height = 'auto';
+    addMessage('user', text);
+    return runSlashCommandInline(text);
+  }
+  // Escape hatch: a literal /-message can be typed by prefixing //.
+  // The leading slash is stripped so the agent sees the real text.
+  const sendText = text.startsWith('//') ? text.slice(1) : text;
   input.value = '';
   input.style.height = 'auto';
 
   // Add user message
-  messages.push({ role: 'user', content: text });
-  addMessage('user', text);
+  messages.push({ role: 'user', content: sendText });
+  addMessage('user', sendText);
 
   // System prompt
   const sysPrompt = document.getElementById('system-prompt').value.trim();
@@ -591483,10 +591844,10 @@ async function sendMessage() {
     // Prepend context files as a FILES block so the agent can read them
     // without having to guess paths. The user picked these via right-click
     // "Add to context" on the workspace tree.
-    let messageWithContext = text;
+    let messageWithContext = sendText;
     if (contextFiles.length > 0) {
       const filesBlock = 'FILES IN CONTEXT:\\n' + contextFiles.map(p => '  - ' + p).join('\\n') + '\\n\\n';
-      messageWithContext = filesBlock + text;
+      messageWithContext = filesBlock + sendText;
     }
 
     // FRESH-SESSION: pull the one-shot fresh flag the newChatSession()
@@ -611858,7 +612219,7 @@ var init_interactive = __esm({
 var run_exports = {};
 __export(run_exports, {
   jobsCommand: () => jobsCommand,
-  runCommand: () => runCommand,
+  runCommand: () => runCommand2,
   statusCommand: () => statusCommand
 });
 import { resolve as resolve40 } from "node:path";
@@ -611872,7 +612233,7 @@ function jobsDir2(repoPath) {
   mkdirSync66(dir, { recursive: true });
   return dir;
 }
-async function runCommand(opts, config) {
+async function runCommand2(opts, config) {
   const mergedConfig = {
     ...config,
     ...opts.verbose !== void 0 ? { verbose: opts.verbose } : {},
@@ -613180,8 +613541,8 @@ async function main() {
         break;
       }
       case "run": {
-        const { runCommand: runCommand2 } = await Promise.resolve().then(() => (init_run(), run_exports));
-        await runCommand2(
+        const { runCommand: runCommand3 } = await Promise.resolve().then(() => (init_run(), run_exports));
+        await runCommand3(
           {
             task: parsed.task,
             // undefined = interactive mode

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.541",
+  "version": "0.187.543",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.541",
+      "version": "0.187.543",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.541",
+  "version": "0.187.543",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",