bajaclaw 1.0.0 → 1.1.0

package/README.md

@@ -53,15 +53,41 @@ Open the UI with `bajaclaw ui` (defaults to `http://127.0.0.1:18790`).
 
 ## Commands
 
+**Run**
+
 | Command | What it does |
 |---|---|
-| `bajaclaw onboard` | First-run setup. ChatGPT by default; all other providers available. |
+| `bajaclaw onboard` | Guided setup: model, fallbacks, local API, channels, features, daemon. |
 | `bajaclaw start` | Start everything (gateway + web UI + local API + channels). |
 | `bajaclaw stop` / `restart` | Control the daemon. |
-| `bajaclaw status` | Health at a glance. |
+| `bajaclaw status` / `doctor` | Health and environment. |
 | `bajaclaw ui` | Open the web interface. |
-| `bajaclaw update` | Check upstream inspirations and write an approve-to-merge proposal. |
-| `bajaclaw doctor` | Environment and health checks. |
+| `bajaclaw uninstall` | Remove the boot daemon. |
+
+**Talk**
+
+| Command | What it does |
+|---|---|
+| `bajaclaw ask "…"` | One-shot question, streamed to your terminal. |
+| `bajaclaw chat` | Interactive terminal chat. |
+| `bajaclaw cowork "…"` | Run a goal end-to-end and print the steps. |
+
+**Manage**
+
+| Command | What it does |
+|---|---|
+| `bajaclaw providers` | List providers and what is configured. |
+| `bajaclaw login <id>` / `logout <id>` | Provider auth (ChatGPT OAuth or API key). |
+| `bajaclaw channels [enable\|disable\|token] <id>` | Messaging channels. |
+| `bajaclaw memory [query\|clear]` | Browse, search, or clear memory. |
+| `bajaclaw skills` | Learned skills. |
+| `bajaclaw update` | Check upstreams and write an approve-to-merge proposal. |
+| `bajaclaw config [get\|set]` | View or change settings. |
+| `bajaclaw logs` | Tail the daemon logs. |
+
+The web dashboard mirrors most of this: set your default model and keys, enable
+channels, search memory, run Cowork goals, toggle features, and watch live
+activity.
 
 ## Models
 

package/bin/bajaclaw.mjs

@@ -1,23 +1,33 @@
 #!/usr/bin/env node
 // BajaClaw CLI. Branded, simple, one command to run everything.
 import { join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
 import { createRequire } from "node:module";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
 import { color, glyph, wordmark, brandline, panel, spinner } from "../src/ui/theme.mjs";
 import { openUrl } from "../src/util.mjs";
-import { load, isOnboarded, CONFIG_DIR } from "../src/config/config.mjs";
+import { load, save, isOnboarded, CONFIG_DIR, PROVIDERS } from "../src/config/config.mjs";
 import * as daemon from "../src/daemon/daemon.mjs";
 import { onboard, onboardNonInteractive } from "../src/onboarding/onboard.mjs";
 import { startEndpoint } from "../plugins/openai-endpoint/server.mjs";
 import { startUiServer } from "../src/daemon/uiserver.mjs";
 import { startGateway } from "../src/daemon/gateway.mjs";
 import { startChannels } from "../channels/manager.mjs";
-import { listReadyProviders } from "../src/agent/agent.mjs";
+import { listReadyProviders, respond, streamRespond } from "../src/agent/agent.mjs";
+import { REGISTRY, isConfigured } from "../src/llm/client.mjs";
+import { saveCred, removeCred, hasCred } from "../src/auth/store.mjs";
+import { login as chatgptLogin } from "../src/auth/chatgpt-oauth.mjs";
+import * as brain from "../plugins/hermes-brain/store.mjs";
+import { runOutcome } from "../plugins/cowork-mode/flow.mjs";
 import { check as checkUpdates } from "../plugins/self-updater/updater.mjs";
 
 const PKG_VERSION = createRequire(import.meta.url)("../package.json").version;
 const argv = process.argv.slice(2);
 const cmd = argv[0];
+const rest = argv.slice(1);
 const flags = new Set(argv.filter((a) => a.startsWith("-")));
+const positional = rest.filter((a) => !a.startsWith("-"));
 
 function ok(s) { console.log(`${glyph.ok} ${s}`); }
 function info(s) { console.log(`${glyph.info} ${s}`); }
@@ -26,32 +36,47 @@ function err(s) { console.log(`${glyph.err} ${color.red(s)}`); }
 
 function help() {
   console.log("\n" + wordmark() + "\n");
-  console.log(panel("Commands", [
-    `${color.bold("bajaclaw start")}      ${color.dim("start everything (gateway daemon + OpenAI endpoint)")}`,
-    `${color.bold("bajaclaw stop")}       ${color.dim("stop the daemon")}`,
-    `${color.bold("bajaclaw restart")}    ${color.dim("restart the daemon")}`,
-    `${color.bold("bajaclaw status")}     ${color.dim("show health")}`,
-    `${color.bold("bajaclaw onboard")}    ${color.dim("first-run setup (ChatGPT by default, all LLMs available)")}`,
+  console.log(panel("Run", [
+    `${color.bold("bajaclaw onboard")}    ${color.dim("guided first-run setup (model, channels, features)")}`,
+    `${color.bold("bajaclaw start")}      ${color.dim("start everything (gateway + UI + local API + channels)")}`,
+    `${color.bold("bajaclaw stop")} / ${color.bold("restart")}  ${color.dim("control the daemon")}`,
+    `${color.bold("bajaclaw status")} / ${color.bold("doctor")}  ${color.dim("health and environment")}`,
     `${color.bold("bajaclaw ui")}         ${color.dim("open the web interface")}`,
-    `${color.bold("bajaclaw update")}     ${color.dim("check upstreams, write an approve-to-merge proposal")}`,
-    `${color.bold("bajaclaw doctor")}     ${color.dim("environment + health checks")}`,
+    `${color.bold("bajaclaw uninstall")}  ${color.dim("remove the boot daemon")}`,
+  ]) + "\n");
+  console.log(panel("Talk", [
+    `${color.bold("bajaclaw ask")} "…"    ${color.dim("one-shot question")}`,
+    `${color.bold("bajaclaw chat")}       ${color.dim("interactive terminal chat")}`,
+    `${color.bold("bajaclaw cowork")} "…" ${color.dim("run a goal end-to-end")}`,
+  ]) + "\n");
+  console.log(panel("Manage", [
+    `${color.bold("bajaclaw providers")}  ${color.dim("list models/providers and what is configured")}`,
+    `${color.bold("bajaclaw login")} <id> / ${color.bold("logout")} <id>  ${color.dim("provider auth")}`,
+    `${color.bold("bajaclaw channels")} [enable|disable|token] ${color.dim("messaging channels")}`,
+    `${color.bold("bajaclaw memory")} [query|clear]  ${color.dim("browse/search/clear memory")}`,
+    `${color.bold("bajaclaw skills")}     ${color.dim("learned skills")}`,
+    `${color.bold("bajaclaw update")}     ${color.dim("check upstreams, write a proposal")}`,
+    `${color.bold("bajaclaw config")} [get|set] ${color.dim("view or change settings")}`,
+    `${color.bold("bajaclaw logs")}       ${color.dim("tail the daemon logs")}`,
   ]) + "\n");
   console.log(color.dim(`  config: ${CONFIG_DIR}`) + "\n");
 }
 
+function openUiUrl() {
+  const cfg = load();
+  const url = `http://${cfg.ui.host}:${cfg.ui.port}/`;
+  info(`Opening ${url}`);
+  if (!openUrl(url)) warn(`Open it manually: ${url}`);
+}
+
 async function cmdStart() {
   console.log("\n" + brandline("start") + "\n");
-  if (!isOnboarded()) {
-    info("First run - writing default config (ChatGPT). Run 'bajaclaw onboard' to sign in.");
-    onboardNonInteractive();
-  }
+  if (!isOnboarded()) { info("First run - writing default config (ChatGPT). Run 'bajaclaw onboard' to sign in."); onboardNonInteractive(); }
   const sp = spinner("starting gateway daemon").start();
   const res = daemon.start();
   sp.stop(glyph.ok, `gateway daemon up (${res.method})`);
   const cfg = load();
-  if (cfg.openaiEndpoint.enabled) {
-    info(`OpenAI endpoint will serve at ${color.bold(`http://${cfg.openaiEndpoint.host}:${cfg.openaiEndpoint.port}/v1`)}`);
-  }
+  if (cfg.openaiEndpoint.enabled) info(`OpenAI endpoint: ${color.bold(`http://${cfg.openaiEndpoint.host}:${cfg.openaiEndpoint.port}/v1`)}`);
   info(`Web UI: ${color.bold(`http://${cfg.ui.host}:${cfg.ui.port}/`)}`);
   const ready = listReadyProviders();
   if (!ready.length) warn("No model configured yet. Run 'bajaclaw onboard' to sign in with ChatGPT (or another provider).");
@@ -59,15 +84,8 @@ async function cmdStart() {
   ok("BajaClaw started. After a reboot, just run 'bajaclaw start' again.");
 }
 
-function cmdStop() {
-  daemon.stop();
-  ok("Stopped.");
-}
-
-async function cmdRestart() {
-  daemon.stop();
-  await cmdStart();
-}
+function cmdStop() { daemon.stop(); ok("Stopped."); }
+async function cmdRestart() { daemon.stop(); await cmdStart(); }
 
 function cmdStatus() {
   const s = daemon.status();
@@ -82,64 +100,201 @@ function cmdStatus() {
 }
 
 function cmdDoctor() {
-  const checks = [];
-  const nodeOk = Number(process.versions.node.split(".")[0]) >= 22;
   const ready = listReadyProviders();
-  checks.push([nodeOk, `Node ${process.versions.node} (need >=22.19)`]);
-  checks.push([ready.length > 0, `A model is configured (${ready.join(", ") || "none yet"})`]);
-  checks.push([isOnboarded(), "Onboarded (config present)"]);
-  checks.push([process.platform === "darwin", `Platform ${process.platform} (launchd daemon = macOS)`]);
-  console.log("\n" + panel("doctor", checks.map(([good, label]) =>
-    `${good ? glyph.ok : glyph.warn} ${label}`)) + "\n");
+  const checks = [
+    [Number(process.versions.node.split(".")[0]) >= 22, `Node ${process.versions.node} (need >=22.19)`],
+    [ready.length > 0, `A model is configured (${ready.join(", ") || "none yet"})`],
+    [isOnboarded(), "Onboarded (config present)"],
+    [process.platform === "darwin", `Platform ${process.platform} (launchd daemon = macOS)`],
+  ];
+  console.log("\n" + panel("doctor", checks.map(([g, l]) => `${g ? glyph.ok : glyph.warn} ${l}`)) + "\n");
 }
 
 async function cmdUpdate() {
-  const cfg = load();
   const sp = spinner("checking OpenClaw / Hermes / Cowork upstreams").start();
-  const r = await checkUpdates(cfg, { write: !flags.has("--check") });
-  sp.stop(glyph.ok, `checked ${Object.keys(r.raw).length} sources`);
+  const r = await checkUpdates(load(), { write: !flags.has("--check") });
+  sp.stop(glyph.ok, `checked sources`);
   if (!r.findings.length) { ok("Everything up to date."); return; }
-  console.log("\n" + panel(`${r.findings.length} update(s)`, r.findings.map((f) =>
-    `${glyph.arrow} ${f.label}: ${color.dim(f.from)} → ${color.bold(color.amber(f.to))}`)) + "\n");
-  if (r.proposalPath) ok(`Proposal written → ${color.dim(r.proposalPath)} (review & approve; nothing auto-merged)`);
+  console.log("\n" + panel(`${r.findings.length} update(s)`, r.findings.map((f) => `${glyph.arrow} ${f.label}: ${color.dim(f.from)} -> ${color.bold(color.amber(f.to))}`)) + "\n");
+  if (r.proposalPath) ok(`Proposal written -> ${color.dim(r.proposalPath)}`);
+}
+
+// ---- talk ----
+async function streamToStdout(messages) {
+  let any = false;
+  for await (const c of streamRespond(messages)) {
+    if (c.delta) { process.stdout.write(c.delta); any = true; }
+    else if (c.text) process.stdout.write(c.text);
+  }
+  process.stdout.write("\n");
+  return any;
+}
+async function cmdAsk() {
+  const prompt = positional.join(" ").trim();
+  if (!prompt) { err('usage: bajaclaw ask "your question"'); process.exitCode = 1; return; }
+  await streamToStdout([{ role: "user", content: prompt }]);
+}
+async function cmdChat() {
+  console.log("\n" + brandline("chat") + color.dim("  (type 'exit' to quit)") + "\n");
+  const rl = createInterface({ input: stdin, output: stdout });
+  const history = [];
+  try {
+    for (;;) {
+      const line = (await rl.question(color.amber("you ") + color.dim("› "))).trim();
+      if (!line || line === "exit" || line === "quit") break;
+      history.push({ role: "user", content: line });
+      process.stdout.write(color.teal("bajaclaw ") + color.dim("› "));
+      let acc = "";
+      for await (const c of streamRespond(history)) {
+        if (c.delta) { process.stdout.write(c.delta); acc += c.delta; }
+        else if (c.text) { process.stdout.write(c.text); acc += c.text; }
+      }
+      process.stdout.write("\n\n");
+      history.push({ role: "assistant", content: acc });
+    }
+  } finally { rl.close(); }
+}
+async function cmdCowork() {
+  const goal = positional.join(" ").trim();
+  if (!goal) { err('usage: bajaclaw cowork "your goal"'); process.exitCode = 1; return; }
+  const sp = spinner(`working: ${goal}`).start();
+  const result = await runOutcome(goal, {
+    execute: async (step) => { const { text } = await respond([{ role: "user", content: `${step.title}: ${step.detail}` }]); return { ok: true, note: text.slice(0, 500) }; },
+  });
+  sp.stop(glyph.ok, `outcome ${result.status}`);
+  console.log("\n" + panel(goal, result.results.map((r) => `${glyph.arrow} ${color.bold(r.step.title)}\n  ${color.dim(r.result?.note || "")}`)) + "\n");
 }
 
-function cmdUi() {
+// ---- manage ----
+function cmdProviders() {
   const cfg = load();
-  const url = `http://${cfg.ui.host}:${cfg.ui.port}/`;
-  info(`Opening ${url}`);
-  if (!openUrl(url)) warn(`Open it manually: ${url}`);
+  const rows = PROVIDERS.map((p) => {
+    const conf = isConfigured(p.id);
+    const def = cfg.defaultProvider === p.id;
+    const tag = def ? color.amber("default") : conf ? color.teal("ready ") : color.dim("not set");
+    return `${glyph.bullet} ${tag}  ${p.label}  ${color.dim(REGISTRY[p.id]?.defaultModel || "")}`;
+  });
+  console.log("\n" + panel("Providers", rows) + "\n");
+}
+
+async function cmdLogin() {
+  const id = positional[0];
+  if (!id || !REGISTRY[id]) { err(`usage: bajaclaw login <provider>  (${PROVIDERS.map((p) => p.id).join(", ")})`); process.exitCode = 1; return; }
+  if (id === "openai-codex") {
+    try { await chatgptLogin({ print: (m) => console.log(color.dim(m)) }); ok("Signed in with ChatGPT."); }
+    catch (e) { err(`sign-in failed: ${e.message}`); process.exitCode = 1; }
+    return;
+  }
+  const meta = PROVIDERS.find((p) => p.id === id);
+  if (meta?.kind === "local") { ok(`${meta.label} is local; no key needed.`); return; }
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const key = (await rl.question(`Paste your ${meta?.label || id} API key: `)).trim();
+    if (!key) { warn("No key entered."); return; }
+    saveCred(id, { type: "key", api_key: key });
+    ok(`Saved ${id} key.`);
+  } finally { rl.close(); }
+}
+function cmdLogout() {
+  const id = positional[0];
+  if (!id) { err("usage: bajaclaw logout <provider>"); process.exitCode = 1; return; }
+  if (!hasCred(id)) { warn(`${id} was not signed in.`); return; }
+  removeCred(id);
+  ok(`Logged out of ${id}.`);
+}
+
+function cmdChannels() {
+  const cfg = load();
+  const sub = positional[0];
+  if (!sub) {
+    const rows = Object.entries(cfg.channels).map(([id, c]) => `${glyph.bullet} ${c.enabled ? color.teal("on ") : color.dim("off")}  ${id}  ${c.token ? color.dim("token set") : color.dim("no token")}`);
+    console.log("\n" + panel("Channels", rows) + "\n");
+    info("bajaclaw channels enable|disable <id>  ·  bajaclaw channels token <id> <token>");
+    return;
+  }
+  const id = positional[1];
+  if (!id || !(id in cfg.channels)) { err(`unknown channel: ${id}`); process.exitCode = 1; return; }
+  if (sub === "enable" || sub === "disable") { cfg.channels[id].enabled = sub === "enable"; save(cfg); ok(`${id} ${sub}d. Run 'bajaclaw restart' to apply.`); }
+  else if (sub === "token") { const tok = positional[2]; if (!tok) { err("usage: bajaclaw channels token <id> <token>"); return; } cfg.channels[id].token = tok; save(cfg); ok(`${id} token set. Run 'bajaclaw restart' to apply.`); }
+  else { err(`unknown subcommand: ${sub}`); process.exitCode = 1; }
+}
+
+function cmdMemory() {
+  const sub = positional[0];
+  if (sub === "clear") { brain.clear(); ok("Memory cleared."); return; }
+  const items = sub ? brain.recall(positional.join(" "), { limit: 20 }) : brain.all().slice(-20).reverse();
+  if (!items.length) { info("No memory yet."); return; }
+  console.log("\n" + panel(sub ? `Memory: "${positional.join(" ")}"` : "Recent memory", items.map((m) => `${glyph.bullet} ${m.task} ${color.dim("- " + (m.outcome || "").slice(0, 60))}`)) + "\n");
+}
+
+function cmdSkills() {
+  const skills = brain.synthesizeSkills({ minSuccesses: 2 });
+  if (!skills.length) { info("No learned skills yet. Repeat a kind of task a few times."); return; }
+  console.log("\n" + panel("Learned skills", skills.map((s) => `${glyph.bullet} ${color.bold(s.name)} ${color.dim(`(${s.from}x) ` + s.summary)}`)) + "\n");
+}
+
+function cmdConfig() {
+  const cfg = load();
+  const sub = positional[0];
+  if (!sub) {
+    const redacted = structuredClone(cfg);
+    for (const id of Object.keys(redacted.channels || {})) if (redacted.channels[id].token) redacted.channels[id].token = "***";
+    console.log(JSON.stringify(redacted, null, 2));
+    return;
+  }
+  const at = (obj, path) => path.split(".").reduce((o, k) => (o == null ? o : o[k]), obj);
+  if (sub === "get") { const v = at(cfg, positional[1] || ""); console.log(typeof v === "object" ? JSON.stringify(v, null, 2) : String(v)); return; }
+  if (sub === "set") {
+    const key = positional[1]; let val = positional.slice(2).join(" ");
+    if (!key) { err("usage: bajaclaw config set <key> <value>"); process.exitCode = 1; return; }
+    if (val === "true") val = true; else if (val === "false") val = false; else if (/^-?\d+$/.test(val)) val = parseInt(val, 10);
+    const parts = key.split("."); let o = cfg;
+    for (let i = 0; i < parts.length - 1; i++) o = o[parts[i]] ??= {};
+    o[parts[parts.length - 1]] = val;
+    save(cfg);
+    ok(`Set ${key} = ${val}. Run 'bajaclaw restart' if it affects the daemon.`);
+    return;
+  }
+  err(`unknown subcommand: ${sub}`); process.exitCode = 1;
 }
 
-// Internal: the supervised process the daemon runs. Boots gateway + endpoint.
+function cmdLogs() {
+  const out = join(CONFIG_DIR, "logs", "gateway.out.log");
+  const errp = join(CONFIG_DIR, "logs", "gateway.err.log");
+  for (const [label, f] of [["out", out], ["err", errp]]) {
+    if (!existsSync(f)) continue;
+    const lines = readFileSync(f, "utf8").trim().split("\n");
+    if (!lines[0]) continue;
+    console.log("\n" + color.dim(`--- ${label} (last 30) ---`));
+    console.log(lines.slice(-30).join("\n"));
+  }
+  console.log("");
+}
+
+function cmdUninstall() {
+  daemon.uninstall();
+  ok("Daemon removed. (Config in ~/.bajaclaw and the npm package are untouched; 'npm rm -g bajaclaw' to uninstall the CLI.)");
+}
+
+// Internal: the supervised process the daemon runs. Boots gateway + endpoint + ui + channels.
 async function cmdServe() {
   const cfg = load();
-  // 1) Native gateway: health + live event stream for the web UI.
   startGateway(cfg, {
+    version: PKG_VERSION,
     onListen: (g) => console.log(`[bajaclaw] gateway on http://${g.host}:${g.port}/`),
     status: () => ({ models: listReadyProviders() }),
   });
-  // 2) Local OpenAI-compatible endpoint (this agent as a local LLM).
-  if (cfg.openaiEndpoint.enabled) {
-    startEndpoint(cfg, { onListen: (ep) => console.log(`[bajaclaw] openai endpoint on http://${ep.host}:${ep.port}/v1`) });
-  }
-  // 3) Web UI (served from web/dist).
+  if (cfg.openaiEndpoint.enabled) startEndpoint(cfg, { onListen: (ep) => console.log(`[bajaclaw] openai endpoint on http://${ep.host}:${ep.port}/v1`) });
   const dist = join(import.meta.dirname, "..", "web", "dist");
-  startUiServer({ dist, host: cfg.ui.host, port: cfg.ui.port,
-    onListen: (u) => console.log(`[bajaclaw] web ui on http://${u.host}:${u.port}/`) });
-  // 4) Native channels (Telegram/Discord/... when enabled in config).
+  startUiServer({ dist, host: cfg.ui.host, port: cfg.ui.port, onListen: (u) => console.log(`[bajaclaw] web ui on http://${u.host}:${u.port}/`) });
   startChannels({ log: console.log }).catch((e) => console.log(`[channels] ${e.message}`));
-  // Keep the supervised process alive.
   process.stdin.resume();
 }
 
 async function main() {
   if (flags.has("--version") || flags.has("-v") || cmd === "version") return console.log(PKG_VERSION);
   switch (cmd) {
-    case undefined:
-    case "help":
-    case "--help":
-    case "-h": return help();
+    case undefined: case "help": case "--help": case "-h": return help();
     case "onboard": return void (await onboard({ yes: flags.has("--yes") || flags.has("-y") }));
     case "start": return await cmdStart();
     case "stop": return cmdStop();
@@ -147,12 +302,22 @@ async function main() {
     case "status": return cmdStatus();
     case "doctor": return cmdDoctor();
     case "update": return await cmdUpdate();
-    case "ui": return cmdUi();
+    case "ui": return openUiUrl();
+    case "uninstall": return cmdUninstall();
+    case "ask": return await cmdAsk();
+    case "chat": return await cmdChat();
+    case "cowork": return await cmdCowork();
+    case "providers": case "models": return cmdProviders();
+    case "login": return await cmdLogin();
+    case "logout": return cmdLogout();
+    case "channels": return cmdChannels();
+    case "memory": return cmdMemory();
+    case "skills": return cmdSkills();
+    case "config": return cmdConfig();
+    case "logs": return cmdLogs();
     case "_serve": return await cmdServe();
     default:
-      err(`unknown command: ${cmd}`);
-      help();
-      process.exitCode = 1;
+      err(`unknown command: ${cmd}`); help(); process.exitCode = 1;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bajaclaw",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "All-in-one personal AI agent — OpenClaw spine + Hermes brain + Cowork outcome mode, with ChatGPT-subscription login, a local OpenAI-compatible endpoint, and a clean web UI.",
   "type": "module",
   "bin": {

package/plugins/hermes-brain/store.mjs

@@ -37,6 +37,13 @@ export function all() {
   return _cache;
 }
 
+export function clear() {
+  ensure();
+  writeFileSync(MEM, "");
+  _cache = [];
+  _cacheKey = statKey();
+}
+
 export function remember({ task, outcome, success, tags = [], at } = {}) {
   ensure();
   const rec = {

package/src/daemon/api.mjs

@@ -0,0 +1,196 @@
+// Local control API for the web dashboard. Binds to localhost via the gateway.
+// JSON over HTTP. No secrets are returned (keys/tokens are write-only).
+import { load, save, PROVIDERS } from "../config/config.mjs";
+import { REGISTRY, isConfigured } from "../llm/client.mjs";
+import { saveCred, loadCred, removeCred, hasCred } from "../auth/store.mjs";
+import { listReadyProviders } from "../agent/agent.mjs";
+import * as brain from "../../plugins/hermes-brain/store.mjs";
+import { runOutcome } from "../../plugins/cowork-mode/flow.mjs";
+import { check as checkUpdates } from "../../plugins/self-updater/updater.mjs";
+
+function send(res, code, obj) {
+  const body = JSON.stringify(obj);
+  res.writeHead(code, { "content-type": "application/json", "access-control-allow-origin": "*" });
+  res.end(body);
+}
+function readJson(req) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => { try { resolve(chunks.length ? JSON.parse(Buffer.concat(chunks).toString()) : {}); } catch { resolve({}); } });
+    req.on("error", () => resolve({}));
+  });
+}
+
+// Config without secrets (channel tokens redacted to a boolean).
+function publicConfig(cfg) {
+  const c = structuredClone(cfg);
+  for (const id of Object.keys(c.channels || {})) {
+    const has = !!c.channels[id].token;
+    if ("token" in c.channels[id]) c.channels[id].token = undefined;
+    c.channels[id].hasToken = has;
+  }
+  return c;
+}
+
+function providerList(cfg) {
+  return PROVIDERS.map((p) => ({
+    id: p.id,
+    label: p.label,
+    kind: p.kind,
+    recommended: !!p.recommended,
+    configured: isConfigured(p.id),
+    isDefault: cfg.defaultProvider === p.id,
+    defaultModel: REGISTRY[p.id]?.defaultModel || null,
+  }));
+}
+
+function channelList(cfg) {
+  const native = new Set(["telegram", "discord"]);
+  return Object.entries(cfg.channels || {}).map(([id, c]) => ({
+    id,
+    enabled: !!c.enabled,
+    hasToken: !!c.token,
+    native: native.has(id),
+  }));
+}
+
+async function reloadChannels() {
+  try {
+    const mgr = await import("../../channels/manager.mjs");
+    mgr.stopChannels();
+    return await mgr.startChannels({ log: () => {} });
+  } catch { return []; }
+}
+
+// Merge only allow-listed config fields from a PATCH body.
+function applyConfigPatch(cfg, body) {
+  const set = (path, val) => {
+    const parts = path.split(".");
+    let o = cfg;
+    for (let i = 0; i < parts.length - 1; i++) o = o[parts[i]] ??= {};
+    o[parts[parts.length - 1]] = val;
+  };
+  if (typeof body.defaultProvider === "string" && REGISTRY[body.defaultProvider]) {
+    set("defaultProvider", body.defaultProvider);
+    cfg.providerOrder = [body.defaultProvider, ...(cfg.providerOrder || []).filter((p) => p !== body.defaultProvider)];
+  }
+  if (Array.isArray(body.providerOrder)) set("providerOrder", body.providerOrder.filter((p) => REGISTRY[p]));
+  if (body.openaiEndpoint) {
+    if (typeof body.openaiEndpoint.enabled === "boolean") set("openaiEndpoint.enabled", body.openaiEndpoint.enabled);
+    if (["agent", "raw"].includes(body.openaiEndpoint.mode)) set("openaiEndpoint.mode", body.openaiEndpoint.mode);
+    if (Number.isInteger(body.openaiEndpoint.port)) set("openaiEndpoint.port", body.openaiEndpoint.port);
+  }
+  if (body.selfUpdate) {
+    if (typeof body.selfUpdate.enabled === "boolean") set("selfUpdate.enabled", body.selfUpdate.enabled);
+    if (["propose", "sandbox", "notify"].includes(body.selfUpdate.mode)) set("selfUpdate.mode", body.selfUpdate.mode);
+  }
+  if (body.features) {
+    if (typeof body.features.hermesBrain === "boolean") set("features.hermesBrain", body.features.hermesBrain);
+    if (typeof body.features.coworkMode === "boolean") set("features.coworkMode", body.features.coworkMode);
+  }
+  return cfg;
+}
+
+// Returns true if it handled the request.
+export async function handleApi(req, res, url, ctx = {}) {
+  const p = url.pathname;
+  if (!p.startsWith("/api/")) return false;
+  const method = req.method;
+  const cfg = load();
+
+  try {
+    if (p === "/api/status" && method === "GET") {
+      send(res, 200, {
+        version: ctx.version || null,
+        ready: listReadyProviders(),
+        defaultProvider: cfg.defaultProvider,
+        ports: { gateway: cfg.gateway.port, ui: cfg.ui.port, openaiEndpoint: cfg.openaiEndpoint.port },
+        endpointMode: cfg.openaiEndpoint.mode,
+        channels: channelList(cfg).filter((c) => c.enabled).map((c) => c.id),
+        memoryCount: (() => { try { return brain.all().length; } catch { return 0; } })(),
+      });
+      return true;
+    }
+
+    if (p === "/api/config" && method === "GET") { send(res, 200, publicConfig(cfg)); return true; }
+    if (p === "/api/config" && (method === "PATCH" || method === "POST")) {
+      const body = await readJson(req);
+      save(applyConfigPatch(cfg, body));
+      send(res, 200, { ok: true, config: publicConfig(load()) });
+      return true;
+    }
+
+    if (p === "/api/providers" && method === "GET") { send(res, 200, { providers: providerList(cfg) }); return true; }
+    let m;
+    if ((m = p.match(/^\/api\/providers\/([\w-]+)\/key$/)) && method === "PUT") {
+      const body = await readJson(req);
+      if (!REGISTRY[m[1]]) { send(res, 404, { error: "unknown provider" }); return true; }
+      if (!body.key) { send(res, 400, { error: "missing key" }); return true; }
+      saveCred(m[1], { type: "key", api_key: String(body.key) });
+      send(res, 200, { ok: true });
+      return true;
+    }
+    if ((m = p.match(/^\/api\/providers\/([\w-]+)$/)) && method === "DELETE") {
+      removeCred(m[1]);
+      send(res, 200, { ok: true });
+      return true;
+    }
+
+    if (p === "/api/channels" && method === "GET") { send(res, 200, { channels: channelList(cfg) }); return true; }
+    if ((m = p.match(/^\/api\/channels\/([\w-]+)$/)) && (method === "PUT" || method === "PATCH")) {
+      const body = await readJson(req);
+      const id = m[1];
+      cfg.channels[id] = cfg.channels[id] || {};
+      if (typeof body.enabled === "boolean") cfg.channels[id].enabled = body.enabled;
+      if (typeof body.token === "string" && body.token) cfg.channels[id].token = body.token;
+      save(cfg);
+      const active = await reloadChannels();
+      send(res, 200, { ok: true, active });
+      return true;
+    }
+
+    if (p === "/api/memory" && method === "GET") {
+      const q = url.searchParams.get("q");
+      const items = q ? brain.recall(q, { limit: 25 }) : brain.all().slice(-50).reverse();
+      send(res, 200, { items });
+      return true;
+    }
+    if (p === "/api/memory" && method === "DELETE") { brain.clear(); send(res, 200, { ok: true }); return true; }
+
+    if (p === "/api/skills" && method === "GET") { send(res, 200, { skills: brain.synthesizeSkills({ minSuccesses: 2 }) }); return true; }
+
+    if (p === "/api/updates" && method === "GET") {
+      const r = await checkUpdates(cfg, { write: false });
+      send(res, 200, { findings: r.findings, proposal: r.proposal });
+      return true;
+    }
+    if (p === "/api/updates/check" && method === "POST") {
+      const r = await checkUpdates(cfg, { write: true });
+      send(res, 200, { findings: r.findings, proposal: r.proposal, proposalPath: r.proposalPath });
+      return true;
+    }
+
+    if (p === "/api/cowork" && method === "POST") {
+      const body = await readJson(req);
+      const goal = String(body.goal || "").trim();
+      if (!goal) { send(res, 400, { error: "missing goal" }); return true; }
+      const { respond } = await import("../agent/agent.mjs");
+      const result = await runOutcome(goal, {
+        execute: async (step) => {
+          const { text } = await respond([{ role: "user", content: `${step.title}: ${step.detail}` }]);
+          return { ok: true, note: text.slice(0, 400) };
+        },
+        onProgress: (e) => ctx.publish?.({ type: "cowork", phase: e.phase, step: e.step?.title }),
+      });
+      send(res, 200, result);
+      return true;
+    }
+
+    send(res, 404, { error: `no api route ${method} ${p}` });
+    return true;
+  } catch (e) {
+    send(res, 500, { error: String(e?.message || e) });
+    return true;
+  }
+}