@botconnector/bccli 0.4.0-beta.5 → 0.4.0-beta.51

package/dist/chunk-DP7EBW53.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+import {
+  defineTool
+} from "./chunk-PSO7R5AD.js";
+import {
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/tools/websearch.ts
+import { z } from "zod";
+var clean = (items, max) => (Array.isArray(items) ? items : []).filter((r) => typeof r?.url === "string" && /^https?:\/\//.test(r.url)).slice(0, max).map((r) => ({
+  title: String(r.title || r.url).slice(0, 200),
+  url: r.url,
+  snippet: String(r.snippet || r.description || "").replace(/\s+/g, " ").trim().slice(0, 600)
+}));
+async function postJson(url, body, headers, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)])
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+function createWebSearchTool(opts) {
+  const keenableURL = opts.keenableURL ?? "https://api.keenable.ai/v1/search/public";
+  return defineTool({
+    name: "web_search",
+    description: "Search the web. Returns titles, URLs and short snippets. Use it to find the right pages instead of guessing URLs; then fetch a result URL when you need the full page.",
+    schema: z.object({
+      query: z.string().min(1).max(500).describe("Search query"),
+      max_results: z.number().int().min(1).max(10).optional().describe("Number of results (default 6)")
+    }),
+    kind: "read",
+    target: (input) => input.query,
+    parallelSafe: () => true,
+    async run(input, ctx) {
+      const max = input.max_results ?? 6;
+      const errors = [];
+      let results = [];
+      const bc = opts.botconnector();
+      if (bc) {
+        try {
+          const data = await postJson(`${bc.baseURL.replace(/\/+$/, "")}/web/search`, { query: input.query, max_results: max }, { authorization: `Bearer ${bc.apiKey}` }, ctx.signal);
+          results = clean(data.results, max);
+        } catch (error) {
+          errors.push(`BotConnector: ${error.message}`);
+        }
+      }
+      if (!results.length) {
+        try {
+          const data = await postJson(keenableURL, { query: input.query }, { "x-keenable-title": "BotConnector" }, ctx.signal);
+          results = clean(data.results, max);
+        } catch (error) {
+          errors.push(`Keenable: ${error.message}`);
+        }
+      }
+      if (!results.length) {
+        return { output: errors.length ? `Web search failed (${errors.join("; ")}).` : "No results.", isError: errors.length > 0 };
+      }
+      const output = results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`).join("\n");
+      return { output, display: t("{n} results", { n: results.length }) };
+    }
+  });
+}
+
+// src/tools/fetch.ts
+import { lookup as dnsCbLookup } from "dns";
+import { lookup as dnsLookup } from "dns/promises";
+import { isIP } from "net";
+import { Agent, fetch as undiciFetch } from "undici";
+import { z as z2 } from "zod";
+var MAX_CHARS = 12e3;
+var FOCUS_CHUNKS = 3;
+var FOCUS_SIZE = 800;
+var CACHE_MAX = 16;
+var CACHE_TTL_MS = 15 * 6e4;
+var CACHE_MAX_CHARS = 2e6;
+var MAX_BYTES = 5 * 1024 * 1024;
+async function readCapped(res) {
+  const reader = res.body?.getReader();
+  if (!reader) return { text: "", truncated: false };
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) return { text: Buffer.concat(chunks).toString("utf8"), truncated: false };
+    size += value.length;
+    if (size > MAX_BYTES) {
+      chunks.push(value.subarray(0, value.length - (size - MAX_BYTES)));
+      await reader.cancel();
+      return { text: Buffer.concat(chunks).toString("utf8"), truncated: true };
+    }
+    chunks.push(value);
+  }
+}
+function htmlToText(html) {
+  return html.replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, "").replace(/<(br|\/p|\/div|\/h[1-6]|\/li|\/tr)\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").split("\n").map((l) => l.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
+}
+function describeFetchError(error) {
+  const cause = error.cause;
+  const code = cause?.code ?? "";
+  const detail = cause?.message ?? error.message;
+  if (error.name === "TimeoutError") return "no response within 30 seconds";
+  if (code === "ENOTFOUND" || code === "EAI_AGAIN") return `${detail} \u2014 DNS could not find the host (typo, offline, or blocked by DNS/ISP)`;
+  if (/CERT|SELF_SIGNED|UNABLE_TO/.test(code)) {
+    return `${detail} \u2014 TLS certificate rejected; often caused by an antivirus or proxy that inspects HTTPS. Try running with NODE_OPTIONS=--use-system-ca`;
+  }
+  if (/ECONNRESET|ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|UND_ERR_CONNECT_TIMEOUT|UND_ERR_SOCKET/.test(code)) {
+    return `${detail} \u2014 connection failed (firewall, proxy, or the site is blocked by the network)`;
+  }
+  return code ? `${detail} (${code})` : detail;
+}
+var tokensOf = (text) => Math.ceil(text.length / 4);
+function isPrivateHost(host) {
+  const h = host.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || /\.(local|internal|lan|localdomain|home\.arpa)$/.test(h)) return true;
+  if (h.includes(":")) return /^(::1?$|f[cd]|fe[89ab]|::ffff:)/.test(h);
+  const v4 = h.match(/^(\d+)\.(\d+)\.\d+\.\d+$/);
+  if (v4) {
+    const [a, b] = [Number(v4[1]), Number(v4[2])];
+    return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  return !h.includes(".");
+}
+var words = (s) => s.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [];
+function pinLookup(pinned) {
+  return (hostname, options, callback) => {
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const family = typeof options === "number" ? options : opts.family;
+    const realDns = () => dnsCbLookup(hostname, typeof options === "number" ? { family: options } : opts, callback);
+    if (!pinned.length) return realDns();
+    const list = family ? pinned.filter((a) => a.family === family) : pinned;
+    if (!list.length) {
+      callback(Object.assign(new Error(`no pinned address for family ${family}`), { code: "ENOTFOUND" }), "");
+      return;
+    }
+    if (opts.all) callback(null, list);
+    else callback(null, list[0].address, list[0].family);
+  };
+}
+function pickRelevant(text, query, count = FOCUS_CHUNKS, size = FOCUS_SIZE) {
+  const chunks = [];
+  let cur = "";
+  for (const line of text.split("\n")) {
+    for (let i = 0; i < Math.max(line.length, 1); i += size) {
+      cur += `${line.slice(i, i + size)}
+`;
+      if (cur.length >= size) {
+        chunks.push(cur.trimEnd());
+        cur = "";
+      }
+    }
+  }
+  if (cur.trim()) chunks.push(cur.trimEnd());
+  const q = [...new Set(words(query))];
+  const docs = chunks.map(words);
+  const avg = docs.reduce((n, d) => n + d.length, 0) / (docs.length || 1) || 1;
+  const idf = q.map((t2) => {
+    const df = docs.filter((d) => d.includes(t2)).length;
+    return Math.log(1 + (docs.length - df + 0.5) / (df + 0.5));
+  });
+  const scored = docs.map((d, i) => ({
+    i,
+    score: q.reduce((sum, t2, k) => {
+      const tf = d.filter((w) => w === t2).length;
+      return sum + idf[k] * tf * 2.2 / (tf + 1.2 * (0.25 + 0.75 * d.length / avg));
+    }, 0)
+  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score).slice(0, count).sort((a, b) => a.i - b.i);
+  return scored.length ? scored.map((c) => chunks[c.i]).join("\n\u2026\n") : null;
+}
+var cache = /* @__PURE__ */ new Map();
+function remember(key, value, size) {
+  if (size > CACHE_MAX_CHARS) return;
+  cache.delete(key);
+  cache.set(key, value);
+  if (cache.size > CACHE_MAX) cache.delete(cache.keys().next().value);
+}
+function recall(key) {
+  const hit = cache.get(key);
+  if (typeof hit === "object" && Date.now() - hit.at > CACHE_TTL_MS) {
+    cache.delete(key);
+    return void 0;
+  }
+  return hit;
+}
+var ACCEPT = "text/markdown, text/html;q=0.9, text/plain;q=0.8, */*;q=0.5";
+var withCost = (text, what) => `${what} \xB7 ${t("~{n} tokens", { n: tokensOf(text) })}`;
+function createFetchTool(opts = {}) {
+  const keenableURL = opts.keenableURL === void 0 ? "https://api.keenable.ai/v1/fetch/public" : opts.keenableURL;
+  const isPrivate = opts.isPrivate ?? isPrivateHost;
+  const lookup = opts.lookup ?? ((hostname) => dnsLookup(hostname, { all: true }));
+  return defineTool({
+    name: "fetch",
+    description: `Fetch a URL (http/https) as text/markdown. Costs the user tokens, so ask for as little as you need:
+- Pass \`prompt\` (what you want to know from the page) to get only the relevant excerpt instead of the whole page. Prefer this whenever you are looking for specific facts.
+- Without \`prompt\` you get the first ${MAX_CHARS} characters; the reply tells you the \`offset\` to continue from.
+- Fetching a page that is already in this conversation is wasteful; reuse what you have.`,
+    schema: z2.object({
+      url: z2.string().describe("Absolute http(s) URL"),
+      prompt: z2.string().max(2e3).optional().describe("What to look for in the page; returns only the relevant excerpt"),
+      offset: z2.number().int().min(0).optional().describe("Start reading at this character (to continue a truncated page)")
+    }),
+    kind: "fetch",
+    target: (input) => input.url,
+    async run(input, ctx) {
+      if (!/^https?:\/\//i.test(input.url)) return { output: "URL must start with http:// or https://", isError: true };
+      const target = new URL(input.url);
+      let pinned;
+      if (!isPrivate(target.hostname) && isIP(target.hostname) === 0) {
+        try {
+          const addresses = await lookup(target.hostname);
+          const internal = addresses.find((a) => isPrivate(a.address));
+          if (internal) {
+            return {
+              output: t("Blocked: {host} resolves to a private address ({addr}). Fetching an internal host through a public DNS name is not allowed.", { host: target.hostname, addr: internal.address }),
+              isError: true
+            };
+          }
+          pinned = addresses;
+        } catch {
+        }
+      }
+      const prompt = input.prompt?.trim();
+      const askKeenable = !!prompt && !input.offset && !!keenableURL && !target.username && !target.password && !isPrivate(target.hostname);
+      if (askKeenable) {
+        const key = `x
+${input.url}
+${prompt}`;
+        const hit = recall(key);
+        if (hit) {
+          ctx.refundFetch?.();
+          return { output: hit, display: withCost(hit, t("focused excerpt \xB7 cache")) };
+        }
+        const out = await extractWithKeenable(keenableURL, input.url, prompt, ctx.signal);
+        if (out) {
+          const output2 = `[Excerpt from ${input.url} for "${prompt}" (extracted by Keenable). If it says the answer is not there, try fetch without a prompt.]
+${out}`;
+          remember(key, output2, output2.length);
+          return { output: output2, display: withCost(output2, t("focused excerpt (Keenable)")) };
+        }
+      }
+      let page = recall(`p
+${input.url}`);
+      const cached = !!page;
+      if (cached) ctx.refundFetch?.();
+      if (!page) {
+        const loaded = await loadPage(input.url, ctx.signal, pinned, opts.fetchPage);
+        if ("error" in loaded) return { output: loaded.error, isError: true };
+        page = loaded;
+        remember(`p
+${input.url}`, page, page.text.length);
+      }
+      const { text, truncated } = page;
+      const via = cached ? " \xB7 cache" : "";
+      if (prompt && !input.offset) {
+        const picked = pickRelevant(text, prompt);
+        if (picked) {
+          const output2 = `[Most relevant excerpt from ${input.url} for "${prompt}" (${text.length} characters total). Full page: fetch without a prompt.]
+${picked}`;
+          return { output: output2, display: withCost(output2, `${t("focused excerpt (local)")}${via}`) };
+        }
+      }
+      const offset = input.offset ?? 0;
+      if (offset >= text.length && text.length > 0) {
+        return { output: `offset ${offset} is past the end of the page (${text.length} characters).`, isError: true };
+      }
+      const end = Math.min(offset + MAX_CHARS, text.length);
+      let output = text.slice(offset, end);
+      if (end < text.length || truncated) {
+        const total = truncated ? `${text.length}+` : text.length;
+        output += `
+\u2026 [truncated: characters ${offset}-${end} of ${total}. Continue with offset=${end}, or use prompt for a focused excerpt.]`;
+      }
+      const size = truncated ? t("over 5 MB, truncated") : t("{n} characters", { n: text.length });
+      return { output, display: withCost(output, `${size}${via}`) };
+    }
+  });
+}
+async function extractWithKeenable(endpoint, url, prompt, signal) {
+  try {
+    const u = new URL(endpoint);
+    u.searchParams.set("url", url);
+    u.searchParams.set("prompt", prompt);
+    u.searchParams.set("live", "true");
+    u.searchParams.set("max_chars", String(MAX_CHARS));
+    const res = await fetch(u, { headers: { "X-Keenable-Title": "BotConnector" }, signal: AbortSignal.any([signal, AbortSignal.timeout(25e3)]) });
+    if (!res.ok) return void 0;
+    const content = (await res.json()).content;
+    return typeof content === "string" && content.trim() ? content.slice(0, MAX_CHARS) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadPage(inputUrl, signal, pinned, fetchPage) {
+  let url = new URL(inputUrl);
+  const dispatcher = pinned?.length ? new Agent({ connect: { lookup: pinLookup(pinned) } }) : void 0;
+  const doFetch = fetchPage ?? (dispatcher ? undiciFetch : fetch);
+  try {
+    let res;
+    for (let hop = 0; hop < 5; hop++) {
+      res = await doFetch(url, {
+        headers: { accept: ACCEPT },
+        signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)]),
+        redirect: "manual",
+        ...dispatcher ? { dispatcher } : {}
+      });
+      const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
+      if (!location) break;
+      const next = new URL(location, url);
+      if (next.host !== url.host) {
+        await res.body?.cancel();
+        return { error: `Redirect to another host: ${next.href}. Call fetch again with that URL if needed (permission will be requested).` };
+      }
+      await res.body?.cancel();
+      url = next;
+    }
+    if (!res) return { error: `Failed to fetch ${inputUrl}` };
+    const { text: body, truncated } = await readCapped(res);
+    const type = res.headers.get("content-type") ?? "";
+    const text = type.includes("html") ? htmlToText(body) : body;
+    if (!res.ok) return { error: `HTTP ${res.status} from ${inputUrl}: ${text.slice(0, 500)}` };
+    return { text, truncated, at: Date.now() };
+  } catch (error) {
+    return { error: `Failed to fetch ${inputUrl}: ${describeFetchError(error)}` };
+  } finally {
+    await dispatcher?.close().catch(() => {
+    });
+  }
+}
+var fetchTool = createFetchTool();
+
+export {
+  isPrivateHost,
+  createFetchTool,
+  fetchTool,
+  createWebSearchTool
+};

package/dist/{chunk-SJH3YLW4.js → chunk-F6ACN47V.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  contentText
+} from "./chunk-R4BJBTWC.js";
 
 // src/session.ts
 import { randomBytes } from "crypto";
@@ -36,7 +39,7 @@ var Session = class _Session {
     return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
       const session = new _Session(join(dir, f));
       const first = session.load().find((m) => m.role === "user");
-      return { session, mtime: statSync(session.file).mtime, preview: first ? String(first.content).slice(0, 80) : "" };
+      return { session, mtime: statSync(session.file).mtime, preview: first ? contentText(first.content).slice(0, 80) : "" };
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
   }
   static latest(home, cwd) {
@@ -49,26 +52,77 @@ var Session = class _Session {
   append(message) {
     this.write({ t: "msg", m: message });
   }
+  appendUsage(usage) {
+    this.write({ t: "usage", ...usage });
+  }
   reset() {
     this.write({ t: "reset" });
   }
-  load() {
+  records() {
     if (!existsSync(this.file)) return [];
-    let messages = [];
+    const out = [];
     for (const line of readFileSync(this.file, "utf8").split("\n")) {
       if (!line.trim()) continue;
-      let record;
       try {
-        record = JSON.parse(line);
+        out.push(JSON.parse(line));
       } catch {
-        continue;
       }
+    }
+    return out;
+  }
+  /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+  load() {
+    let messages = [];
+    for (const record of this.records()) {
       if (record.t === "reset") messages = [];
       else if (record.t === "msg") messages.push(record.m);
     }
     return repairTail(messages);
   }
+  /**
+   * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+   * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+   * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+   */
+  loadHistory() {
+    const segments = [[]];
+    for (const record of this.records()) {
+      if (record.t === "reset") segments.push([]);
+      else if (record.t === "msg") segments[segments.length - 1].push(record.m);
+    }
+    let shown = segments[0];
+    for (const segment of segments.slice(1)) {
+      if (!isCompactionSummary(segment[0])) {
+        shown = segment;
+        continue;
+      }
+      const kept = segment.slice(2);
+      let at = 0;
+      while (at <= shown.length && !endsWithPrefixOf(shown, at, kept)) at++;
+      shown = [...shown, ...kept.slice(shown.length - at)];
+    }
+    return repairTail(shown.filter((m) => !isCompactionSummary(m) && !isCompactionAck(m)));
+  }
 };
+var SUMMARY_PREFIX = "Summary of the previous conversation:";
+var SUMMARY_ACK = "OK, I will continue from this summary.";
+function isCompactionSummary(m) {
+  return m?.role === "user" && typeof m.content === "string" && m.content.startsWith(SUMMARY_PREFIX);
+}
+function isCompactionAck(m) {
+  return m.role === "assistant" && m.content === SUMMARY_ACK;
+}
+function sameMessage(a, b) {
+  if (a.role !== b.role) return false;
+  if (a.role === "tool" && b.role === "tool") return a.tool_call_id === b.tool_call_id;
+  return JSON.stringify(a.content) === JSON.stringify(b.content) && JSON.stringify("tool_calls" in a && a.tool_calls) === JSON.stringify("tool_calls" in b && b.tool_calls);
+}
+function endsWithPrefixOf(shown, at, kept) {
+  const n = shown.length - at;
+  if (n > kept.length) return false;
+  for (let j = 0; j < n; j++) if (!sameMessage(shown[at + j], kept[j])) return false;
+  return true;
+}
 function pruneSessions(home, now = Date.now(), maxAgeDays = 30) {
   const root = join(home, "sessions");
   if (!existsSync(root)) return 0;

package/dist/chunk-FTFVW7XD.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+import {
+  MODE_ORDER
+} from "./chunk-GAFJEQTJ.js";
+import {
+  REASONING_LEVELS,
+  isReasoningLevel
+} from "./chunk-SNKVS26H.js";
+import {
+  ConfigError
+} from "./chunk-NDEJUL44.js";
+import {
+  parseLang,
+  t
+} from "./chunk-XLC6T4SX.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]        OAuth login (or --key paste API key, --logout remove)
+  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 plugins               list, install, remove, or update plugins
+  bccli gh-bot [serve]         GitHub comment bot (off-by-default; needs config)
+  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>|serve [--base-url <url>]    manage MCP servers, or serve this account's tools over stdio
+  bccli completion <shell>     print a shell completion script (bash, zsh, fish, powershell)
+  bccli stats [--days N] [--tools N] [--models [N|all]] [--project slug]
+                                     show token usage from local sessions (default: last 7 days)
+  bccli export [session] [file]  copy a session JSONL to a file (default: last session here)
+  bccli import <file>          import a session JSONL into the current project
+  bccli pr <number> [--repo owner/name] [task]   check out a GitHub PR and run a task on it
+  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
+
+Options:
+  -m, --model <provider/model>  choose a model, e.g. bc-cloud/glm-5.3-flash
+      --reasoning <level>        auto | off | low | medium | high | max
+  -c, --continue                continue the last session in this folder
+  -r, --resume                  pick a session to continue
+      --allow-all               run all tools without asking for permission
+      --allowed-tools <a,b>     tools allowed without asking: bash, edit, fetch
+  -w, --worktree <name>        run in git worktree ../<repo>.worktrees/<name> (created, or reused if it exists)
+      --output-format <fmt>     text | json | stream-json for -p (machine-readable output)
+      --permission-mode <mode>  default | acceptEdits | plan | allowAll
+      --lang <en|id>            interface language (default: en; or BCCLI_LANG, or "language" in config)
+  -v, --version                 version
+  -h, --help                    this help`;
+var helpText = () => t(HELP);
+function parseCliArgs(argv) {
+  const expanded = argv.map(
+    (a, i) => a === "--models" && (i + 1 >= argv.length || argv[i + 1].startsWith("-")) ? "--models=all" : a
+  );
+  const { values, positionals } = parseArgs({
+    args: expanded,
+    allowPositionals: true,
+    options: {
+      print: { type: "boolean", short: "p" },
+      model: { type: "string", short: "m" },
+      reasoning: { type: "string" },
+      lang: { type: "string" },
+      continue: { type: "boolean", short: "c" },
+      resume: { type: "boolean", short: "r" },
+      "allow-all": { type: "boolean" },
+      "allowed-tools": { type: "string" },
+      worktree: { type: "string", short: "w" },
+      "output-format": { type: "string" },
+      "permission-mode": { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      url: { type: "string" },
+      name: { type: "string" },
+      "key-env": { type: "string" },
+      value: { type: "string", multiple: true },
+      key: { type: "boolean" },
+      logout: { type: "boolean" },
+      port: { type: "string" },
+      host: { type: "string" },
+      token: { type: "string" },
+      "base-url": { type: "string" },
+      days: { type: "string" },
+      tools: { type: "string" },
+      models: { type: "string" },
+      project: { type: "string" },
+      repo: { type: "string" }
+    }
+  });
+  const reasoning = values.reasoning;
+  if (reasoning && !isReasoningLevel(reasoning)) {
+    throw new ConfigError(t("--reasoning must be one of: {levels}", { levels: REASONING_LEVELS.join(", ") }));
+  }
+  const mode = values["permission-mode"];
+  if (mode && !MODE_ORDER.includes(mode)) {
+    throw new ConfigError(t("--permission-mode must be one of: {modes}", { modes: MODE_ORDER.join(", ") }));
+  }
+  if (values.lang !== void 0 && !parseLang(values.lang)) throw new ConfigError(t("--lang must be one of: en, id"));
+  const outputFormat = values["output-format"];
+  if (outputFormat !== void 0 && !["text", "json", "stream-json"].includes(outputFormat)) {
+    throw new ConfigError(t("--output-format must be one of: {formats}", { formats: "text, json, stream-json" }));
+  }
+  const [first, ...rest] = positionals;
+  const SUBCOMMANDS = ["login", "models", "update", "acp", "serve", "plugins", "gh-bot", "provider", "mcp", "connect", "disconnect", "integrations", "completion", "stats", "export", "import", "pr"];
+  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"));
+  }
+  const days = values.days !== void 0 ? Number(values.days) : void 0;
+  if (days !== void 0 && (!Number.isInteger(days) || days < 1)) {
+    throw new ConfigError(t("--days must be a positive integer"));
+  }
+  const tools = values.tools !== void 0 ? Number(values.tools) : void 0;
+  if (tools !== void 0 && (!Number.isInteger(tools) || tools < 1)) {
+    throw new ConfigError(t("--tools must be a positive integer"));
+  }
+  let models;
+  if (values.models !== void 0) {
+    models = values.models === "" || values.models === "all" ? "all" : values.models;
+    if (models !== "all" && (!Number.isInteger(Number(models)) || Number(models) < 1)) {
+      throw new ConfigError(t('--models must be a positive integer or "all"'));
+    }
+  }
+  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,
+    print: !!values.print,
+    model: values.model,
+    reasoning,
+    lang: parseLang(values.lang),
+    continue: !!values.continue,
+    resume: !!values.resume,
+    allowAll: !!values["allow-all"],
+    allowedTools: (values["allowed-tools"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+    worktree: values.worktree,
+    outputFormat,
+    permissionMode: mode,
+    help: !!values.help,
+    version: !!values.version,
+    loginProvider: command === "login" ? rest[0] ?? "bc-cloud" : void 0,
+    key: !!values.key,
+    logout: !!values.logout,
+    subArgs: ["models", "plugins", "gh-bot", "provider", "mcp", "connect", "disconnect", "integrations", "completion", "stats", "export", "import", "pr"].includes(command) ? rest : [],
+    url: values.url,
+    name: values.name,
+    keyEnv: values["key-env"],
+    values: values.value ?? [],
+    port,
+    host: values.host,
+    token: values.token,
+    baseUrl: values["base-url"],
+    days,
+    tools,
+    models,
+    project: values.project,
+    repo: values.repo
+  };
+}
+
+export {
+  MAX_FRAME_BYTES,
+  parseClientFrame,
+  LOOPBACK_BIND,
+  trustFence,
+  bearerOk,
+  randomToken,
+  helpText,
+  parseCliArgs
+};