@botconnector/bccli 0.4.0-beta.38 → 0.4.0-beta.39

package/dist/chunk-RV74TCEP.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import {
+  runCommand,
+  runHooks
+} from "./chunk-ZMU7MXCH.js";
+import {
+  ConfigError
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/verify.ts
+var MAX_VERIFY_ROUNDS = 2;
+async function runVerify(commands, opts) {
+  const run = opts.run ?? runCommand;
+  const failures = [];
+  for (const cmd of commands) {
+    const r = await run(cmd, { cwd: opts.cwd, timeoutMs: opts.timeoutMs ?? 3e5, signal: opts.signal, env: opts.env });
+    const exitCode = r.exitCode ?? -1;
+    if (exitCode !== 0) failures.push({ cmd, exitCode, output: r.output });
+  }
+  return failures;
+}
+function verifyFollowup(failures, maxBytes = 8e3) {
+  const blocks = failures.map((f) => {
+    const output = f.output.length > maxBytes ? `${f.output.slice(0, maxBytes)}
+[truncated]` : f.output;
+    return `$ ${f.cmd}
+[exit code ${f.exitCode}]
+${output}`;
+  });
+  return t("Automatic verification after your edits failed. Fix the problems so these commands pass, then stop.\n\n{blocks}", {
+    blocks: blocks.join("\n\n")
+  });
+}
+
+// src/print.ts
+function toolLabel(tool) {
+  if (tool === "web_search") return "Search";
+  return tool.charAt(0).toUpperCase() + tool.slice(1);
+}
+async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
+  const format = opts.outputFormat ?? "text";
+  const emit = (line) => io.out.write(`${JSON.stringify(line)}
+`);
+  let result = "";
+  const toolNames = /* @__PURE__ */ new Map();
+  rt.interaction.approvePlan = async () => {
+    if (opts.allowAll) return "allowAll";
+    io.err.write(`${t("Plan needs approval; run with --allow-all.")}
+`);
+    return "no";
+  };
+  let failed = false;
+  let wroteText = false;
+  let edited = false;
+  rt.agent.onEvent = (event) => {
+    switch (event.type) {
+      case "text":
+        if (format === "text") {
+          io.out.write(event.delta);
+          wroteText = true;
+        } else {
+          result += event.delta;
+        }
+        break;
+      case "toolStart":
+        toolNames.set(event.id, event.tool);
+        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
+`);
+        if (format === "stream-json") emit({ type: "tool_use", tool: event.tool, target: event.target });
+        break;
+      case "toolEnd":
+        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
+`);
+        if ((event.tool === "edit" || event.tool === "write") && !event.isError) edited = true;
+        if (format === "stream-json") emit({ type: "tool_result", tool: toolNames.get(event.id), isError: !!event.isError, output: event.output });
+        break;
+      case "stepLimit":
+        io.err.write(`${t("Step limit reached.")}
+`);
+        failed = true;
+        break;
+      case "budgetExceeded":
+        io.err.write(`${t("Budget exceeded ({kind}): {used} of {limit}. Further model calls are blocked; raise usageCap in ~/.bccli/config.json.", { kind: event.kind, used: Math.round(event.used * 100) / 100, limit: event.limit })}
+`);
+        if (format === "stream-json") emit({ type: "error", message: "budgetExceeded" });
+        failed = true;
+        break;
+      case "aborted":
+        io.err.write(`${t("Cancelled.")}
+`);
+        failed = true;
+        break;
+      case "error":
+        io.err.write(`Error: ${event.message}
+`);
+        if (format === "stream-json") emit({ type: "error", message: event.message });
+        failed = true;
+        break;
+    }
+  };
+  rt.agent.askPermission = async (req) => {
+    io.err.write(`  ${t("Needs permission for {tool}. Run with --allow-all or --allowed-tools {kind}.", { tool: req.tool, kind: req.kind })}
+`);
+    return "no";
+  };
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  const start = await runHooks(rt.config.hooks, "SessionStart", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of start.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("SessionStart");
+  try {
+    await rt.agent.run(prompt, controller.signal);
+    const commands = rt.config.verifyCommands;
+    if (edited && commands.length && !controller.signal.aborted) {
+      for (let round = 0; round < MAX_VERIFY_ROUNDS; round++) {
+        io.err.write(`${t("Verifying edits: {cmds}", { cmds: commands.join(", ") })}
+`);
+        const failures = await runVerify(commands, { cwd: rt.cwd, env: rt.env, signal: controller.signal });
+        if (!failures.length) {
+          io.err.write(`${t("Verification passed.")}
+`);
+          break;
+        }
+        if (round === MAX_VERIFY_ROUNDS - 1 || controller.signal.aborted) {
+          io.err.write(`${t("Verification still failing after {n} fix round(s). Run the commands manually to see why.", { n: MAX_VERIFY_ROUNDS })}
+`);
+          failed = true;
+          break;
+        }
+        await rt.agent.run(verifyFollowup(failures), controller.signal);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  const stop = await runHooks(rt.config.hooks, "Stop", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of stop.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("Stop");
+  if (format === "json") {
+    io.out.write(`${JSON.stringify({ status: failed ? "failed" : "ok", model: rt.modelRef, result })}
+`);
+  } else if (format === "stream-json") {
+    if (result) emit({ type: "message", text: result });
+    emit({ type: "result", status: failed ? "failed" : "ok", model: rt.modelRef });
+  } else if (wroteText) {
+    io.out.write("\n");
+  }
+  return failed ? 1 : 0;
+}
+
+// src/worktree.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { basename, dirname, join } from "path";
+function git(cwd, args, bin = "git") {
+  return new Promise((resolve) => {
+    execFile(
+      bin,
+      args,
+      { cwd, maxBuffer: 20 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve({ ok: !error, out: error ? stderr : stdout, missing: error?.code === "ENOENT" })
+    );
+  });
+}
+var NAME_RE = /^[A-Za-z0-9._-]+$/;
+function samePath(a, b) {
+  const norm = (p) => process.platform === "win32" ? p.replace(/\//g, "\\").toLowerCase() : p.replace(/\\/g, "/");
+  return norm(a) === norm(b);
+}
+function worktreeEntries(porcelain) {
+  return porcelain.split(/\r?\n\r?\n/).map((block) => {
+    const path = /^worktree (.+)$/m.exec(block)?.[1]?.trim();
+    if (!path) return void 0;
+    const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
+    return branch ? { path, branch } : { path };
+  }).filter((entry) => !!entry);
+}
+async function resolveWorktree(cwd, name, bin = "git") {
+  if (!NAME_RE.test(name)) {
+    throw new ConfigError(t('Invalid worktree name "{name}": use letters, digits, dot, dash, or underscore (no slashes).', { name }));
+  }
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) throw new ConfigError(t("git is not installed or not on PATH, so -w cannot be used."));
+  if (!inside.ok || inside.out.trim() !== "true") throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const entries = worktreeEntries(list.out);
+  const main = entries[0]?.path;
+  if (!main) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const path = join(dirname(main), `${basename(main)}.worktrees`, name);
+  if (entries.some((entry) => samePath(entry.path, path))) return { path, created: false };
+  if (existsSync(path)) {
+    throw new ConfigError(t("Worktree path {path} already exists but is not a registered worktree; remove or rename it first.", { path }));
+  }
+  const branch = `bccli/${name}`;
+  const hasBranch = (await git(main, ["rev-parse", "--verify", "-q", `refs/heads/${branch}`], bin)).ok;
+  const add = hasBranch ? await git(main, ["worktree", "add", path, branch], bin) : await git(main, ["worktree", "add", "-b", branch, path], bin);
+  if (!add.ok) throw new ConfigError(add.out.trim() || t("This folder is not a git repository, so -w cannot create a worktree."));
+  return { path, created: true };
+}
+async function worktreeListText(cwd, bin = "git") {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) return t("git is not installed or not on PATH, so /worktree cannot be used.");
+  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) return t("This folder is not a git repository, so there is no diff.");
+  const rows = worktreeEntries(list.out).map((entry) => `  ${entry.path}${entry.branch ? ` (${entry.branch})` : ""}`);
+  return [
+    t("Git worktrees:"),
+    ...rows,
+    "",
+    t("Create one with: bccli -w <name>"),
+    t("Remove with: git worktree remove <path>")
+  ].join("\n");
+}
+
+export {
+  MAX_VERIFY_ROUNDS,
+  runVerify,
+  verifyFollowup,
+  toolLabel,
+  runPrint,
+  resolveWorktree,
+  worktreeListText
+};

package/dist/{chunk-U66JJ6RN.js → chunk-SESBH44L.js}

@@ -5,7 +5,7 @@ import {
   readCredentials,
   readJsonConfig,
   removeCredential
-} from "./chunk-H5N4ST6B.js";
+} from "./chunk-M7LLJQ7M.js";
 
 // src/providers.ts
 import { mkdirSync, writeFileSync } from "fs";

package/dist/{chunk-XFTBML3H.js → chunk-VM7HYAJS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   contentText
-} from "./chunk-H66PC2EB.js";
+} from "./chunk-GGNXHJL6.js";
 
 // src/session.ts
 import { randomBytes } from "crypto";

package/dist/{chunk-ASTNW3X2.js → chunk-ZG7HCXYA.js}

@@ -5,26 +5,85 @@ import {
 import {
   REASONING_LEVELS,
   isReasoningLevel
-} from "./chunk-YURAIW7A.js";
+} from "./chunk-NI5JZUZ3.js";
 import {
   ConfigError
-} from "./chunk-H5N4ST6B.js";
+} from "./chunk-M7LLJQ7M.js";
 import {
   parseLang,
   t
-} from "./chunk-4RMP4CNT.js";
+} from "./chunk-M23QBX3V.js";
 
 // src/args.ts
 import { parseArgs } from "util";
+
+// src/serveProtocol.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+var MAX_FRAME_BYTES = 262144;
+function parseClientFrame(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return { error: "invalid JSON frame" };
+  }
+  const f = value;
+  if (typeof f?.streamId !== "string" || f.streamId === "") return { error: "frame requires a streamId" };
+  if (f.type === "open") {
+    if (typeof f.target !== "string" || f.target === "") return { error: "open requires a target" };
+    return { type: "open", streamId: f.streamId, target: f.target };
+  }
+  if (f.type === "cancel") return { type: "cancel", streamId: f.streamId };
+  return { error: `unknown frame type: ${String(f?.type)}` };
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]", "::1"]);
+var LOOPBACK_BIND = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+function trustFence(headers, port) {
+  const host = headers.host;
+  if (!host) return "missing Host header";
+  const sep = host.lastIndexOf(":");
+  const hostname = sep > -1 ? host.slice(0, sep) : host;
+  const hostPort = sep > -1 ? Number(host.slice(sep + 1)) : 80;
+  if (!LOOPBACK_HOSTS.has(hostname)) return `non-loopback Host: ${hostname}`;
+  if (hostPort !== port) return `Host port ${hostPort} does not match listener ${port}`;
+  if (headers.origin) {
+    let origin;
+    try {
+      origin = new URL(headers.origin);
+    } catch {
+      return "malformed Origin header";
+    }
+    const originHost = origin.hostname === "::1" ? "[::1]" : origin.hostname;
+    const originPort = origin.port ? Number(origin.port) : origin.protocol === "https:" ? 443 : 80;
+    if (!LOOPBACK_HOSTS.has(originHost)) return `cross-origin Origin: ${headers.origin}`;
+    if (originPort !== port) return "Origin port mismatch";
+  }
+  if (headers["sec-fetch-site"] === "cross-site") return "cross-site request";
+  return null;
+}
+function bearerOk(header, token) {
+  if (!header?.startsWith("Bearer ")) return false;
+  const got = Buffer.from(header.slice(7));
+  const want = Buffer.from(token);
+  return got.length === want.length && timingSafeEqual(got, want);
+}
+function randomToken() {
+  return randomBytes(32).toString("hex");
+}
+
+// src/args.ts
 var HELP = `BCCLI \u2014 BotConnector's AI coding agent for the terminal
 
 Usage:
   bccli [task]                  interactive mode (optionally start with a task)
   bccli -p "task"               run one task without interaction (scripts/CI)
   bccli login [provider]        save an API key (default: bc-cloud)
-  bccli models                  list models from the active provider
+  bccli models [provider]       list models (default: the active provider)
+  bccli update                  install the newest bccli from npm
+  bccli acp                     run as an ACP agent for editors (Zed, ...)
+  bccli serve [--port N]        serve sessions over HTTP+WS for IDEs/bots
   bccli provider list|add <id>|remove <id>   manage providers (custom: --url <url> [--name N] [--key-env ENV])
-  bccli mcp list|add <name>|remove <name>|auth <name>|logout <name>    manage MCP servers (catalog, --url <url>, OAuth)
+  bccli mcp list|add <name>|remove <name>|auth <name>|logout <name>|serve [--base-url <url>]    manage MCP servers, or serve this account's tools over stdio
   bccli integrations             show the status of external agent integrations
   bccli connect <agent>          opencode, aider, cline, dsh, codex, claude-code, cursor, openai-cli, openai-sdk, openai-compatible, openclaw, hermes
   bccli disconnect <agent>       remove an integration and restore the previous config
@@ -64,7 +123,11 @@ function parseCliArgs(argv) {
       url: { type: "string" },
       name: { type: "string" },
       "key-env": { type: "string" },
-      value: { type: "string", multiple: true }
+      value: { type: "string", multiple: true },
+      port: { type: "string" },
+      host: { type: "string" },
+      token: { type: "string" },
+      "base-url": { type: "string" }
     }
   });
   const reasoning = values.reasoning;
@@ -81,9 +144,16 @@ function parseCliArgs(argv) {
     throw new ConfigError(t("--output-format must be one of: {formats}", { formats: "text, json, stream-json" }));
   }
   const [first, ...rest] = positionals;
-  const SUBCOMMANDS = ["login", "models", "provider", "mcp", "connect", "disconnect", "integrations"];
+  const SUBCOMMANDS = ["login", "models", "update", "acp", "serve", "provider", "mcp", "connect", "disconnect", "integrations"];
   const command = SUBCOMMANDS.includes(first) ? first : "run";
   const words = command === "run" ? positionals : rest;
+  const port = values.port !== void 0 ? Number(values.port) : void 0;
+  if (port !== void 0 && (!Number.isInteger(port) || port < 0 || port > 65535)) {
+    throw new ConfigError(t("--port must be a number between 0 and 65535"));
+  }
+  if (values.host !== void 0 && !LOOPBACK_BIND.has(values.host)) {
+    throw new ConfigError(t("serve only accepts loopback --host (127.0.0.1, localhost, ::1)"));
+  }
   return {
     command,
     prompt: command === "run" && words.length ? words.join(" ") : void 0,
@@ -101,15 +171,25 @@ function parseCliArgs(argv) {
     help: !!values.help,
     version: !!values.version,
     loginProvider: command === "login" ? rest[0] ?? "bc-cloud" : void 0,
-    subArgs: ["provider", "mcp", "connect", "disconnect", "integrations"].includes(command) ? rest : [],
+    subArgs: ["models", "provider", "mcp", "connect", "disconnect", "integrations"].includes(command) ? rest : [],
     url: values.url,
     name: values.name,
     keyEnv: values["key-env"],
-    values: values.value ?? []
+    values: values.value ?? [],
+    port,
+    host: values.host,
+    token: values.token,
+    baseUrl: values["base-url"]
   };
 }
 
 export {
+  MAX_FRAME_BYTES,
+  parseClientFrame,
+  LOOPBACK_BIND,
+  trustFence,
+  bearerOk,
+  randomToken,
   helpText,
   parseCliArgs
 };