blun-king-cli 4.1.1 → 5.0.0

package/blun-cli.js

@@ -0,0 +1,763 @@
+#!/usr/bin/env node
+const readline = require("readline");
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+const { spawn } = require("child_process");
+const { listIdentities, getIdentity } = require("./identities");
+const { installSource, EXTENSIONS_DIR } = require("./installer");
+
+const HOME = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const CONFIG_FILE = path.join(HOME, "config.json");
+if (!fs.existsSync(HOME)) fs.mkdirSync(HOME, { recursive: true });
+
+const DEFAULT_CONFIG = {
+  apiUrl: process.env.BLUN_API_URL || "http://127.0.0.1:3200",
+  token: process.env.BLUN_API_TOKEN || "",
+  streamLevel: "normal"
+};
+
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return { ...DEFAULT_CONFIG };
+  }
+
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+async function apiRequest(cfg, method, endpoint, body) {
+  const headers = { "Content-Type": "application/json" };
+  if (cfg.token) headers.Authorization = `Bearer ${cfg.token}`;
+
+  const resp = await fetch(`${cfg.apiUrl}${endpoint}`, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined
+  });
+  const text = await resp.text();
+  let data = {};
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = { raw: text };
+  }
+  if (!resp.ok) throw new Error(data.error || `HTTP ${resp.status}`);
+  return data;
+}
+
+async function apiStreamRequest(cfg, endpoint, body, handlers = {}) {
+  const headers = { "Content-Type": "application/json", Accept: "text/event-stream" };
+  if (cfg.token) headers.Authorization = `Bearer ${cfg.token}`;
+
+  const resp = await fetch(`${cfg.apiUrl}${endpoint}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body || {})
+  });
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(text || `HTTP ${resp.status}`);
+  }
+
+  const decoder = new TextDecoder();
+  const reader = resp.body.getReader();
+  let buffer = "";
+  let currentEvent = "message";
+
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    buffer += decoder.decode(chunk.value, { stream: true });
+
+    while (buffer.includes("\n\n")) {
+      const index = buffer.indexOf("\n\n");
+      const raw = buffer.slice(0, index);
+      buffer = buffer.slice(index + 2);
+      if (!raw.trim()) continue;
+
+      let event = currentEvent;
+      const dataLines = [];
+      for (const line of raw.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+      }
+
+      if (!dataLines.length) continue;
+      const payload = JSON.parse(dataLines.join("\n"));
+      currentEvent = "message";
+
+      if (event === "meta" && handlers.onMeta) handlers.onMeta(payload);
+      if (event === "token" && handlers.onToken) handlers.onToken(payload);
+      if (event === "done" && handlers.onDone) handlers.onDone(payload);
+      if (event === "error" && handlers.onError) handlers.onError(payload);
+    }
+  }
+}
+
+function line(char = "-", len = 48) {
+  return char.repeat(len);
+}
+
+function isPlaceholderContent(content) {
+  return typeof content === "string" && content.length === 0;
+}
+
+function saveReturnedFiles(workdir, files) {
+  if (!Array.isArray(files)) return [];
+  const written = [];
+
+  for (const file of files) {
+    if (!file || !file.path || typeof file.content !== "string") continue;
+    if (isPlaceholderContent(file.content)) continue;
+    const target = path.resolve(workdir, file.path);
+    if (!target.startsWith(path.resolve(workdir))) continue;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, file.content, "utf8");
+    written.push(target);
+  }
+
+  return written;
+}
+
+function formatAnswerBlock(prefix, text) {
+  return String(text || "")
+    .split("\n")
+    .map((entry) => `${prefix}${entry}`)
+    .join("\n");
+}
+
+function parseLearnCommand(input) {
+  const raw = String(input || "").replace(/^\/learn\s+/i, "").trim();
+  if (!raw) return { category: "general", content: "" };
+  const alias = raw.match(/^alias\s+(.+?)=(.+)$/i);
+  if (alias) {
+    return { category: "system", content: `${alias[1].trim()} = ${alias[2].trim()}` };
+  }
+  const prefer = raw.match(/^prefer\s+(.+)$/i);
+  if (prefer) {
+    return { category: "system", content: `Ich bevorzuge ${prefer[1].trim()}.` };
+  }
+  const forbid = raw.match(/^forbid\s+(.+)$/i);
+  if (forbid) {
+    return { category: "system", content: `Mach niemals ${forbid[1].trim()}.` };
+  }
+  const workflow = raw.match(/^workflow\s+(.+?)=(.+)$/i);
+  if (workflow) {
+    return { category: "system", content: `Wenn ich ${workflow[1].trim()} sage, meine ich ${workflow[2].trim()}.` };
+  }
+  const match = raw.match(/^([a-z0-9_-]+)\s*:\s*([\s\S]+)$/i);
+  if (match) {
+    return {
+      category: match[1].toLowerCase(),
+      content: match[2].trim()
+    };
+  }
+  return { category: "general", content: raw };
+}
+
+function parseResumeCommand(input) {
+  const match = String(input || "").match(/^\/resume\s+([a-zA-Z0-9._-]+)/);
+  return match ? match[1] : "";
+}
+
+function parseWatchCommand(input) {
+  const match = String(input || "").match(/^\/watch\s+([a-zA-Z0-9._-]+)/);
+  return match ? match[1] : "";
+}
+
+function formatFlags(flags) {
+  if (!Array.isArray(flags) || flags.length === 0) return "clean";
+  return flags.join(", ");
+}
+
+function formatRoutingSummary(data) {
+  const confidence = data.routing?.confidence ?? data.confidence;
+  const pct = typeof confidence === "number" ? `${Math.round(confidence * 100)}%` : "-";
+  return `routing: ${data.task_type || data.type || "-"}  confidence: ${pct}`;
+}
+
+function formatLearnSummary(data) {
+  const learned = data.learned || {};
+  const types = learned.types || {};
+  return [
+    "",
+    "  Learn",
+    `  ${line()}`,
+    `  user: ${data.user_id || "-"}`,
+    `  category: ${data.category || "general"}`,
+    `  aliases: ${learned.aliasesLearned || 0}  snippets: ${learned.snippetsLearned || 0}`,
+    `  types: pref=${types.preferences || 0} fact=${types.facts || 0} workflow=${types.workflows || 0} guard=${types.guardrails || 0}`,
+    `  file: ${data.file || "-"}`,
+    ""
+  ];
+}
+
+function buildQueueSnapshot({ mode, selectedIdentity, currentJob, queue }) {
+  const lines = [
+    "",
+    "  Queue",
+    `  ${line()}`,
+    `  mode: ${mode}  identity: ${selectedIdentity}`,
+    `  running: ${currentJob ? `#${currentJob.id} ${currentJob.message}` : "idle"}`,
+    `  pending: ${Array.isArray(queue) ? queue.length : 0}`
+  ];
+
+  for (const job of queue || []) {
+    lines.push(`  - #${job.id} ${job.message}`);
+  }
+
+  lines.push("");
+  return lines;
+}
+
+function buildTaskboard({ mode, selectedIdentity, currentJob, queue, jobs = [], lastArtifacts = [] }) {
+  const lines = [
+    "",
+    "  Taskboard",
+    `  ${line()}`,
+    `  mode: ${mode}`,
+    `  identity: ${selectedIdentity}`,
+    `  running: ${currentJob ? `#${currentJob.id} ${currentJob.message}` : "idle"}`,
+    `  pending: ${queue.length}`,
+    `  remote jobs: ${jobs.length}`
+  ];
+
+  if (queue.length) {
+    lines.push("  pending queue:");
+    for (const job of queue.slice(0, 5)) lines.push(`  - #${job.id} ${job.message}`);
+  }
+
+  if (jobs.length) {
+    lines.push("  recent remote jobs:");
+    for (const job of jobs.slice(0, 5)) {
+      const summary = job.summary || {};
+      const detail = [
+        summary.taskType || "",
+        typeof summary.fileCount === "number" && summary.fileCount ? `${summary.fileCount} file` : "",
+        typeof summary.referenceCount === "number" && summary.referenceCount ? `${summary.referenceCount} ref` : ""
+      ].filter(Boolean).join(" | ");
+      lines.push(`  - ${job.id} ${job.status} ${job.endpoint}${detail ? `  ${detail}` : ""}`);
+    }
+  }
+
+  if (lastArtifacts.length) {
+    lines.push("  recent artifacts:");
+    for (const artifact of lastArtifacts.slice(0, 5)) lines.push(`  - ${artifact}`);
+  }
+
+  lines.push("");
+  return lines;
+}
+
+function formatJobResultLines(data, job, workdir, locallyWritten) {
+  const header = `  BLUN King  ${job.label}  ${data.task_type}/${data.role}  ${data.identity || "auto"}`;
+  const lines = ["", header, `  ${line()}`, `  ${formatRoutingSummary(data)}`];
+
+  if (data.quality) {
+    lines.push(`  quality: ${data.quality.score ?? "-"}  flags: ${formatFlags(data.quality.flags)}${data.quality.retried ? "  retried" : ""}${data.quality.blocked ? "  blocked" : ""}`);
+  }
+
+  for (const step of data.steps || []) {
+    lines.push(`  [step ${step.step}] ${step.action}${step.detail ? ` -> ${step.detail}` : ""}${step.files ? ` -> ${step.files.join(", ")}` : ""}`);
+  }
+
+  if (Array.isArray(data.references) && data.references.length) {
+    for (const ref of data.references) {
+      if (ref.error) lines.push(`  [reference] ${ref.url} -> ${ref.error}`);
+      else lines.push(`  [reference] ${ref.url} -> ${ref.title || "no title"}${ref.screenshotPath ? ` (${ref.screenshotPath})` : ""}`);
+    }
+  }
+
+  if (data.artifact?.filename) {
+    lines.push(`  artifact: ${data.artifact.filename}`);
+  }
+
+  if (Array.isArray(data.files) && data.files.length) {
+    const fileList = data.files.map((file) => file.path).filter(Boolean);
+    if (fileList.length) lines.push(`  files: ${fileList.join(", ")}`);
+  }
+
+  if (locallyWritten.length) {
+    lines.push(`  local: ${locallyWritten.map((entry) => path.relative(workdir, entry)).join(", ")}`);
+  }
+
+  if (data.answer) {
+    lines.push(formatAnswerBlock("  ", data.answer));
+  }
+
+  if (data.status || typeof data.verified === "boolean") {
+    lines.push(`  status: ${data.status || "completed"}  verified: ${data.verified ? "yes" : "no"}`);
+  }
+
+  if (data.tokens) {
+    lines.push(`  tokens: ${data.tokens.total ?? "-"} total`);
+  }
+
+  lines.push("");
+  return lines;
+}
+
+function formatRemoteJobLines(job) {
+  const summary = job.summary || {};
+  const lines = [
+    "",
+    `  Job  ${job.id}`,
+    `  ${line()}`,
+    `  endpoint: ${job.endpoint}`,
+    `  status: ${job.status}`,
+    `  session: ${job.sessionId}`
+  ];
+
+  if (job.resumedFrom) lines.push(`  resumed_from: ${job.resumedFrom}`);
+  if (summary.taskType) lines.push(`  task: ${summary.taskType}`);
+  if (typeof summary.durationMs === "number") lines.push(`  duration_ms: ${summary.durationMs}`);
+  if (summary.fileCount) lines.push(`  files: ${summary.fileCount}`);
+  if (summary.referenceCount) lines.push(`  references: ${summary.referenceCount}`);
+  if (summary.artifact) lines.push(`  artifact: ${summary.artifact}`);
+  if (job.error) lines.push(`  error: ${job.error}`);
+  if (job.result?.answer) lines.push(formatAnswerBlock("  ", job.result.answer));
+  lines.push("");
+  return lines;
+}
+
+function runLocalShell(command, workdir) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, {
+      cwd: workdir,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve({ code, stdout, stderr });
+      else reject(new Error(stderr.trim() || `Command failed with exit code ${code}`));
+    });
+  });
+}
+
+async function main() {
+  const cfg = loadConfig();
+  const workdir = process.cwd();
+  const sessionId = `cli_${Date.now()}`;
+  const queue = [];
+  let processing = false;
+  let currentJob = null;
+  let mode = "agent";
+  let selectedIdentity = "auto";
+  let cliClosed = false;
+  let nextJobId = 1;
+  let nextBtwId = 1;
+  const lastArtifacts = [];
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: ""
+  });
+
+  function promptLabel() {
+    return `  You [${mode}/${selectedIdentity}]> `;
+  }
+
+  function renderPrompt() {
+    if (cliClosed || rl.closed || !process.stdin.isTTY) return;
+    rl.setPrompt(promptLabel());
+    rl.prompt(true);
+  }
+
+  function writeLines(lines) {
+    const normalizedLines = Array.isArray(lines) ? lines : [lines];
+    if (process.stdout.isTTY) {
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+    }
+    process.stdout.write(`${normalizedLines.filter(Boolean).join("\n")}\n`);
+    if (!cliClosed && !rl.closed) {
+      renderPrompt();
+    }
+  }
+
+  function showHelp() {
+    writeLines([
+      "",
+      "  Commands:",
+      "  /chat                 use chat endpoint",
+      "  /agent                use agent endpoint",
+      "  /status               show runtime status",
+      "  /health               show health",
+      "  /artifacts            list artifacts",
+      "  /identities           list available identities",
+      "  /identity <name|auto> set a fixed identity or auto",
+      "  /mode                 show current mode, identity and queue state",
+      "  /queue                show running job and pending queue",
+      "  /cancel-pending       drop all pending jobs but keep the running one",
+      "  /bg <message>         submit a background job to the API",
+      "  /jobs                 list background jobs for this session",
+      "  /watch <jobId>        poll a background job until it finishes",
+      "  /resume <jobId>       restart an old background job and queue it again",
+      "  /board                show a compact taskboard",
+      "  /learn [cat:] <text>  learn aliases/preferences/workflows/guardrails",
+      "  /btw <message>        send an immediate side message without waiting for queue",
+      "  /install <source>     install plugin/skill/package locally",
+      "  /browser-open <url>   open a page in the local browser session",
+      "  /browser-click <sel>  click a selector in the local browser session",
+      "  /browser-type <sel> <text>  type into a selector",
+      "  /browser-press <key>  press a key in the local browser session",
+      "  /browser-screenshot [path] save a screenshot from the local browser session",
+      "  /browser-status       show current browser snapshot",
+      "  /browser-close        close the local browser session",
+      "  /local <command>      run a local shell command",
+      "  /ssh <user@host cmd>  run a local SSH deployment command",
+      "  /exit                 quit",
+      ""
+    ]);
+  }
+
+  async function processQueue() {
+    if (processing) return;
+    processing = true;
+
+    while (queue.length) {
+      const job = queue.shift();
+      currentJob = job;
+      try {
+        writeLines([`  [running #${job.id}] ${job.message}  pending:${queue.length}`]);
+        if (job.endpoint === "/chat" && cfg.streamLevel !== "off") {
+          let finalPayload = null;
+          let headerPrinted = false;
+          process.stdout.write("\n");
+          await apiStreamRequest(cfg, "/chat/stream", {
+            message: job.message,
+            session_id: sessionId,
+            workdir,
+            identity: selectedIdentity
+          }, {
+            onMeta(payload) {
+              if (headerPrinted) return;
+              headerPrinted = true;
+              writeLines([
+                "",
+                `  BLUN King  ${job.label}  ${payload.task_type}/${payload.role}  ${payload.identity || "auto"}`,
+                `  ${line()}`,
+                `  routing: ${payload.routing?.task?.type || payload.task_type || "-"}  confidence: ${typeof payload.routing?.confidence === "number" ? `${Math.round(payload.routing.confidence * 100)}%` : "-"}`
+              ]);
+            },
+            onToken(payload) {
+              const text = String(payload.text || "");
+              if (!text) return;
+              if (process.stdout.isTTY) {
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+              }
+              process.stdout.write(`  ${text}`);
+              if (!cliClosed && !rl.closed) renderPrompt();
+            },
+            onDone(payload) {
+              finalPayload = payload;
+            },
+            onError(payload) {
+              throw new Error(payload.error || "Stream failed");
+            }
+          });
+          process.stdout.write("\n");
+          if (finalPayload) {
+            writeLines([
+              `  quality: ${finalPayload.quality?.score ?? "-"}  flags: ${formatFlags(finalPayload.quality?.reasons || finalPayload.quality?.flags || [])}${finalPayload.quality?.retried ? "  retried" : ""}`,
+              ""
+            ]);
+          }
+        } else {
+          const data = await apiRequest(cfg, "POST", job.endpoint, {
+            message: job.message,
+            goal: job.message,
+            session_id: sessionId,
+            workdir,
+            identity: selectedIdentity
+          });
+          const locallyWritten = saveReturnedFiles(workdir, data.files);
+          for (const file of locallyWritten) {
+            lastArtifacts.unshift(path.relative(workdir, file));
+          }
+          writeLines(formatJobResultLines(data, job, workdir, locallyWritten));
+        }
+      } catch (error) {
+        writeLines([`  ERROR [#${job.id}]: ${error.message}`]);
+      } finally {
+        currentJob = null;
+      }
+    }
+
+    processing = false;
+    renderPrompt();
+  }
+
+  try {
+    const health = await fetch(`${cfg.apiUrl}/health`).then((resp) => resp.json());
+    console.log(`Connected to BLUN King API (${health.model})`);
+  } catch (error) {
+    console.error(`API connection failed: ${error.message}`);
+  }
+
+  console.log("");
+  console.log("  BLUN KING CLI v5.0.0");
+  console.log(`  API: ${cfg.apiUrl}`);
+  console.log(`  Dir: ${workdir}`);
+  console.log("  Chat input stays available while jobs run.");
+  console.log("  Normal input goes into pending. /btw uses an immediate side lane.");
+  console.log("");
+  renderPrompt();
+
+  rl.on("close", () => {
+    cliClosed = true;
+  });
+
+  rl.on("line", (input) => {
+    const message = input.trim();
+    if (!message) return renderPrompt();
+
+    if (message === "/exit" || message === "/quit") process.exit(0);
+    if (message === "/help") return showHelp();
+    if (message === "/chat") {
+      mode = "chat";
+      return writeLines(["  Mode switched to chat."]);
+    }
+    if (message === "/agent") {
+      mode = "agent";
+      return writeLines(["  Mode switched to agent."]);
+    }
+    if (message === "/identities") {
+      const lines = ["", "  Available identities:"];
+      for (const identity of listIdentities()) {
+        lines.push(`  - ${identity.id}: ${identity.name}`);
+      }
+      lines.push("");
+      return writeLines(lines);
+    }
+    if (message.startsWith("/identity")) {
+      const nextIdentity = message.split(/\s+/)[1] || "auto";
+      if (nextIdentity !== "auto" && getIdentity(nextIdentity).id !== nextIdentity) {
+        return writeLines([`  Unknown identity: ${nextIdentity}`]);
+      }
+      selectedIdentity = nextIdentity;
+      return writeLines([`  Identity set to ${selectedIdentity}.`]);
+    }
+    if (message === "/mode" || message === "/queue") {
+      return writeLines(buildQueueSnapshot({ mode, selectedIdentity, currentJob, queue }));
+    }
+    if (message === "/board") {
+      apiRequest(cfg, "GET", `/jobs?session_id=${encodeURIComponent(sessionId)}`)
+        .then((data) => writeLines(buildTaskboard({ mode, selectedIdentity, currentJob, queue, jobs: data.jobs || [], lastArtifacts })))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message === "/cancel-pending") {
+      const dropped = queue.length;
+      queue.splice(0, queue.length);
+      return writeLines([`  Pending queue cleared. Dropped: ${dropped}`]);
+    }
+    if (message === "/jobs") {
+      apiRequest(cfg, "GET", `/jobs?session_id=${encodeURIComponent(sessionId)}`)
+        .then((data) => {
+          const lines = ["", "  Jobs", `  ${line()}`];
+          for (const job of data.jobs || []) {
+            const summary = job.summary || {};
+            lines.push(`  - ${job.id}  ${job.status}  ${job.endpoint}${summary.taskType ? `  ${summary.taskType}` : ""}${summary.durationMs ? `  ${summary.durationMs}ms` : ""}`);
+          }
+          lines.push("");
+          writeLines(lines);
+        })
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/watch ")) {
+      const jobId = parseWatchCommand(message);
+      if (!jobId) return writeLines(["  Usage: /watch <jobId>"]);
+      (async () => {
+        let seenLogCount = 0;
+        for (;;) {
+          const job = await apiRequest(cfg, "GET", `/jobs/${jobId}`);
+          const logData = await apiRequest(cfg, "GET", `/jobs/${jobId}/logs`);
+          const newLogs = (logData.logs || []).slice(seenLogCount);
+          for (const entry of newLogs) {
+            writeLines([`  [job ${jobId}] ${entry.event}${entry.payload?.error ? ` -> ${entry.payload.error}` : ""}`]);
+          }
+          seenLogCount = (logData.logs || []).length;
+          if (job.status === "completed" || job.status === "failed") {
+            writeLines(formatRemoteJobLines(job));
+            break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+      })().catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/resume ")) {
+      const jobId = parseResumeCommand(message);
+      if (!jobId) return writeLines(["  Usage: /resume <jobId>"]);
+      apiRequest(cfg, "POST", `/jobs/${jobId}/resume`, {})
+        .then((data) => writeLines([`  resumed job: ${data.job_id} (from ${data.resumed_from})`]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/bg ")) {
+      const payloadMessage = message.slice(4).trim();
+      apiRequest(cfg, "POST", mode === "agent" ? "/agent" : "/chat", {
+        message: payloadMessage,
+        goal: payloadMessage,
+        session_id: sessionId,
+        workdir,
+        identity: selectedIdentity,
+        background: true
+      })
+        .then((data) => writeLines([`  background job queued: ${data.job_id}`]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/learn ")) {
+      const payload = parseLearnCommand(message);
+      apiRequest(cfg, "POST", "/learn", {
+        session_id: sessionId,
+        user_id: sessionId,
+        title: `cli-${Date.now()}`,
+        category: payload.category,
+        content: payload.content
+      })
+        .then((data) => writeLines(formatLearnSummary(data)))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/btw ")) {
+      const btwMessage = message.slice(5).trim();
+      const btwId = nextBtwId++;
+      writeLines([`  [btw #${btwId}] sent immediately`]);
+      apiRequest(cfg, "POST", mode === "agent" ? "/agent" : "/chat", {
+        message: btwMessage,
+        goal: btwMessage,
+        session_id: sessionId,
+        workdir,
+        identity: selectedIdentity
+      })
+        .then((data) => writeLines(formatJobResultLines(data, { id: `btw-${btwId}`, label: `BTW#${btwId}` }, workdir, saveReturnedFiles(workdir, data.files))))
+        .catch((error) => writeLines([`  ERROR [BTW#${btwId}]: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/install ")) {
+      installSource(message.slice(9).trim())
+        .then((result) => writeLines([`  installed ${result.kind}: ${result.target}`, `  extensions: ${EXTENSIONS_DIR}`]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/browser-open ")) {
+      apiRequest(cfg, "POST", "/browser/open", { url: message.slice(14).trim() })
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/browser-click ")) {
+      apiRequest(cfg, "POST", "/browser/click", { selector: message.slice(15).trim() })
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/browser-type ")) {
+      const rest = message.slice(14).trim();
+      const firstSpace = rest.indexOf(" ");
+      const selector = firstSpace === -1 ? rest : rest.slice(0, firstSpace);
+      const text = firstSpace === -1 ? "" : rest.slice(firstSpace + 1);
+      apiRequest(cfg, "POST", "/browser/type", { selector, text })
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/browser-press ")) {
+      apiRequest(cfg, "POST", "/browser/press", { key: message.slice(15).trim() })
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/browser-screenshot")) {
+      const target = message.slice("/browser-screenshot".length).trim();
+      apiRequest(cfg, "POST", "/browser/screenshot", target ? { path: target } : {})
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message === "/browser-status") {
+      apiRequest(cfg, "GET", "/browser/status")
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message === "/browser-close") {
+      apiRequest(cfg, "POST", "/browser/close", {})
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message === "/status") {
+      apiRequest(cfg, "GET", "/runtime/status")
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message === "/health") {
+      fetch(`${cfg.apiUrl}/health`)
+        .then((resp) => resp.json())
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message === "/artifacts") {
+      apiRequest(cfg, "GET", "/artifacts")
+        .then((data) => writeLines(["", JSON.stringify(data, null, 2), ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/local ")) {
+      runLocalShell(message.slice(7), workdir)
+        .then((result) => writeLines(["", result.stdout || "(no output)", ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+    if (message.startsWith("/ssh ")) {
+      runLocalShell(`ssh ${message.slice(5)}`, workdir)
+        .then((result) => writeLines(["", result.stdout || "(no output)", ""]))
+        .catch((error) => writeLines([`  ERROR: ${error.message}`]));
+      return renderPrompt();
+    }
+
+    const endpoint = mode === "agent" ? "/agent" : "/chat";
+    const job = { id: nextJobId++, label: `#${nextJobId - 1}`, message, endpoint };
+    queue.push(job);
+    writeLines([`  [pending #${job.id}] ${message}  queue:${queue.length}`]);
+    processQueue();
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  saveReturnedFiles,
+  parseLearnCommand,
+  parseResumeCommand,
+  parseWatchCommand,
+  buildQueueSnapshot,
+  buildTaskboard
+};