@botconnector/bccli 0.1.0-beta.4 → 0.3.0-beta.1

package/dist/cli.js

@@ -0,0 +1,1246 @@
+#!/usr/bin/env node
+import {
+  HELP_TEXT,
+  parseCliArgs
+} from "./chunk-RDQ7HPWS.js";
+import {
+  addProviderKey,
+  createProvider,
+  listAllModels
+} from "./chunk-MANM7HY6.js";
+import {
+  runLogin
+} from "./chunk-E4BWUMQ2.js";
+import {
+  Session,
+  pruneSessions
+} from "./chunk-SJH3YLW4.js";
+import {
+  ignorePatterns,
+  loadAgentDefs,
+  loadCommands,
+  loadSkills,
+  parseFrontmatter,
+  runPrint
+} from "./chunk-TBPPXOOZ.js";
+import {
+  Permissions
+} from "./chunk-5XN44Q55.js";
+import {
+  providerName
+} from "./chunk-5C6NQFSI.js";
+import {
+  ConfigError,
+  bccliHome,
+  loadConfig,
+  resolveModel
+} from "./chunk-Z5JM76EL.js";
+
+// src/tools/index.ts
+import { z as z8 } from "zod";
+
+// src/tools/bash.ts
+import { spawn } from "child_process";
+import { z } from "zod";
+
+// src/tools/types.ts
+function defineTool(tool) {
+  return tool;
+}
+
+// src/tools/bash.ts
+var HALF = 15e3;
+function killProcessTree(pid, platform = process.platform, spawnFn = spawn) {
+  if (platform === "win32") {
+    const killer = spawnFn("taskkill", ["/pid", String(pid), "/T", "/F"]);
+    killer.on("error", () => {
+      try {
+        process.kill(pid);
+      } catch {
+      }
+    });
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+var active = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function killAllCommands() {
+  for (const kill of active) kill();
+}
+function runCommand(command, opts) {
+  return new Promise((resolve2) => {
+    const child = spawn(command, {
+      cwd: opts.cwd,
+      shell: true,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (!exitHookInstalled) {
+      process.on("exit", killAllCommands);
+      exitHookInstalled = true;
+    }
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    let head = "";
+    let tail = "";
+    let dropped = 0;
+    let timedOut = false;
+    let aborted = false;
+    const onData = (data) => {
+      let s = data;
+      if (head.length < HALF) {
+        const take = s.slice(0, HALF - head.length);
+        head += take;
+        s = s.slice(take.length);
+      }
+      if (s) {
+        tail += s;
+        if (tail.length > HALF) {
+          dropped += tail.length - HALF;
+          tail = tail.slice(-HALF);
+        }
+      }
+    };
+    child.stdout.on("data", onData);
+    child.stderr.on("data", onData);
+    const kill = () => {
+      if (child.pid !== void 0) killProcessTree(child.pid);
+    };
+    const killAsAborted = () => {
+      aborted = true;
+      kill();
+    };
+    active.add(killAsAborted);
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, opts.timeoutMs);
+    const onAbort = () => {
+      aborted = true;
+      kill();
+    };
+    if (opts.signal.aborted) onAbort();
+    opts.signal.addEventListener("abort", onAbort, { once: true });
+    const finish = (exitCode, extra = "") => {
+      active.delete(killAsAborted);
+      clearTimeout(timer);
+      opts.signal.removeEventListener("abort", onAbort);
+      const output = dropped ? `${head}
+\u2026 [${dropped} karakter dipotong] \u2026
+${tail}` : head + tail;
+      resolve2({ output: output + extra, exitCode, timedOut, aborted });
+    };
+    child.on("error", (error) => finish(null, error.message));
+    child.on("close", (code) => finish(code));
+  });
+}
+var bashTool = defineTool({
+  name: "bash",
+  description: "Run a shell command in the project directory. No interactive input. Default timeout 2 minutes (max 10). Use for tests, builds, git, and other CLI tasks.",
+  schema: z.object({
+    command: z.string().describe("The shell command to run"),
+    timeout_ms: z.number().int().min(1e3).max(6e5).optional().describe("Timeout in milliseconds")
+  }),
+  kind: "bash",
+  target: (input) => input.command,
+  async run(input, ctx) {
+    const r = await runCommand(input.command, { cwd: ctx.cwd, timeoutMs: input.timeout_ms ?? 12e4, signal: ctx.signal });
+    const status = r.timedOut ? `[dihentikan: timeout ${Math.round((input.timeout_ms ?? 12e4) / 1e3)} detik]` : r.aborted ? "[dibatalkan user]" : `[exit code ${r.exitCode}]`;
+    return { output: `${r.output.trimEnd()}
+${status}`.trimStart(), isError: r.exitCode !== 0 };
+  }
+});
+
+// src/tools/edit.ts
+import { readFile, writeFile } from "fs/promises";
+import { z as z2 } from "zod";
+
+// src/diff.ts
+import { structuredPatch } from "diff";
+function diffLines(oldText, newText) {
+  const patch = structuredPatch("a", "b", oldText, newText, "", "", { context: 2 });
+  const out = [];
+  for (const hunk of patch.hunks) {
+    let oldLine = hunk.oldStart;
+    let newLine = hunk.newStart;
+    for (const raw of hunk.lines) {
+      const text = raw.slice(1);
+      if (raw[0] === "-") out.push({ kind: "del", line: oldLine++, text });
+      else if (raw[0] === "+") out.push({ kind: "add", line: newLine++, text });
+      else if (raw[0] === " ") {
+        out.push({ kind: "ctx", line: newLine, text });
+        oldLine++;
+        newLine++;
+      }
+    }
+  }
+  return out;
+}
+function formatDiff(lines) {
+  const mark = { add: "+", del: "-", ctx: " " };
+  return lines.map((l) => `${String(l.line).padStart(5)} ${mark[l.kind]} ${l.text}`).join("\n");
+}
+
+// src/tools/paths.ts
+import { isAbsolute, resolve } from "path";
+function resolvePath(cwd, path) {
+  return isAbsolute(path) ? path : resolve(cwd, path);
+}
+function errorCode(error) {
+  return error.code ?? error.message;
+}
+
+// src/tools/edit.ts
+var schema = z2.object({
+  path: z2.string().describe("File path, relative to the project or absolute"),
+  old_string: z2.string().describe("Exact text to replace; must be unique unless replace_all"),
+  new_string: z2.string().describe("Replacement text"),
+  replace_all: z2.boolean().optional().describe("Replace every occurrence")
+});
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  for (let i = haystack.indexOf(needle); i !== -1; i = haystack.indexOf(needle, i + needle.length)) count++;
+  return count;
+}
+function applyEdit(content, input) {
+  if (input.old_string === input.new_string) {
+    return { output: "old_string dan new_string sama; tidak ada perubahan.", isError: true };
+  }
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  const toEol = (s) => s.replace(/\r?\n/g, eol);
+  const attempts = [[input.old_string, input.new_string]];
+  if (toEol(input.old_string) !== input.old_string) attempts.push([toEol(input.old_string), toEol(input.new_string)]);
+  for (const [oldText, newText] of attempts) {
+    const count = oldText ? countOccurrences(content, oldText) : 0;
+    if (count === 0) continue;
+    if (count > 1 && !input.replace_all) {
+      return {
+        output: `old_string muncul ${count} kali di ${input.path}. Tambah konteks agar unik, atau pakai replace_all.`,
+        isError: true
+      };
+    }
+    return input.replace_all ? content.split(oldText).join(newText) : content.replace(oldText, () => newText);
+  }
+  return { output: `old_string tidak ditemukan di ${input.path}. Baca ulang file-nya.`, isError: true };
+}
+var editTool = defineTool({
+  name: "edit",
+  description: "Replace exact text in a file. The file must have been read first. old_string must match exactly (including indentation) and be unique unless replace_all is true.",
+  schema,
+  kind: "edit",
+  target: (input) => input.path,
+  async validate(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    if (!ctx.readFiles.has(abs)) return `Baca ${input.path} dulu dengan read sebelum mengedit.`;
+    let content;
+    try {
+      content = await readFile(abs, "utf8");
+    } catch (error) {
+      return `Tidak bisa membaca ${input.path}: ${errorCode(error)}`;
+    }
+    const next = applyEdit(content, input);
+    return typeof next === "string" ? void 0 : next.output;
+  },
+  async preview(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    const content = await readFile(abs, "utf8");
+    const next = applyEdit(content, input);
+    return typeof next === "string" ? formatDiff(diffLines(content, next)) : void 0;
+  },
+  async run(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    if (!ctx.readFiles.has(abs)) {
+      return { output: `Baca ${input.path} dulu dengan read sebelum mengedit.`, isError: true };
+    }
+    let content;
+    try {
+      content = await readFile(abs, "utf8");
+    } catch (error) {
+      return { output: `Tidak bisa membaca ${input.path}: ${errorCode(error)}`, isError: true };
+    }
+    const next = applyEdit(content, input);
+    if (typeof next !== "string") return next;
+    await writeFile(abs, next);
+    return { output: `Mengedit ${input.path}.`, display: formatDiff(diffLines(content, next)) };
+  }
+});
+
+// src/tools/fetch.ts
+import { z as z3 } from "zod";
+var MAX_CHARS = 5e4;
+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");
+}
+var fetchTool = defineTool({
+  name: "fetch",
+  description: "Fetch a URL (http/https). HTML is converted to plain text. Max 50k characters.",
+  schema: z3.object({ url: z3.string().describe("Absolute http(s) URL") }),
+  kind: "fetch",
+  target: (input) => input.url,
+  async run(input, ctx) {
+    if (!/^https?:\/\//i.test(input.url)) return { output: "URL harus diawali http:// atau https://", isError: true };
+    let url = new URL(input.url);
+    let res;
+    try {
+      for (let hop = 0; hop < 5; hop++) {
+        res = await fetch(url, { signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(3e4)]), redirect: "manual" });
+        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 {
+            output: `Redirect ke host lain: ${next.href}. Panggil fetch lagi dengan URL itu kalau memang perlu (akan diminta izin).`,
+            isError: true
+          };
+        }
+        await res.body?.cancel();
+        url = next;
+      }
+    } catch (error) {
+      return { output: `Gagal mengambil ${input.url}: ${error.message}`, isError: true };
+    }
+    if (!res) return { output: `Gagal mengambil ${input.url}`, isError: true };
+    const { text: body, truncated } = await readCapped(res);
+    if (!res.ok) return { output: `HTTP ${res.status} dari ${input.url}: ${body.slice(0, 500)}`, isError: true };
+    const text = (res.headers.get("content-type") ?? "").includes("html") ? htmlToText(body) : body;
+    const clipped = text.length > MAX_CHARS || truncated ? `${text.slice(0, MAX_CHARS)}
+\u2026 [dipotong]` : text;
+    const display = truncated ? "lebih dari 5 MB, dipotong" : `${text.length} karakter`;
+    return { output: clipped, display };
+  }
+});
+
+// src/tools/glob.ts
+import fg from "fast-glob";
+import { z as z4 } from "zod";
+var globTool = defineTool({
+  name: "glob",
+  description: 'Find files by glob pattern, e.g. "src/**/*.ts". Respects .gitignore. Max 500 results.',
+  schema: z4.object({
+    pattern: z4.string().describe("Glob pattern"),
+    path: z4.string().optional().describe("Base directory, default project root")
+  }),
+  kind: "read",
+  target: (input) => input.pattern,
+  async run(input, ctx) {
+    const root = resolvePath(ctx.cwd, input.path ?? ".");
+    const files = (await fg(input.pattern, { cwd: root, ignore: ignorePatterns(root), onlyFiles: true, dot: true })).sort();
+    if (!files.length) return { output: "Tidak ada file yang cocok." };
+    const shown = files.slice(0, 500);
+    const more = files.length > shown.length ? `
+\u2026 ${files.length - shown.length} file lagi` : "";
+    return { output: shown.join("\n") + more, display: `${files.length} file` };
+  }
+});
+
+// src/tools/grep.ts
+import { execFile } from "child_process";
+import { readFile as readFile2 } from "fs/promises";
+import fg2 from "fast-glob";
+import { z as z5 } from "zod";
+var MAX_MATCHES = 200;
+async function grepJs(pattern, opts) {
+  const regex = new RegExp(pattern, opts.ignoreCase ? "i" : "");
+  const files = await fg2(opts.glob ?? "**/*", { cwd: opts.root, ignore: ignorePatterns(opts.root), onlyFiles: true, dot: true });
+  const out = [];
+  for (const file of files.sort()) {
+    let text;
+    try {
+      const buffer = await readFile2(resolvePath(opts.root, file));
+      if (buffer.subarray(0, 8e3).includes(0)) continue;
+      text = buffer.toString("utf8");
+    } catch {
+      continue;
+    }
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length && out.length < MAX_MATCHES; i++) {
+      if (regex.test(lines[i])) out.push(`${file}:${i + 1}:${lines[i].slice(0, 300)}`);
+    }
+    if (out.length >= MAX_MATCHES) break;
+  }
+  return out;
+}
+function grepRg(pattern, opts) {
+  const args = ["--line-number", "--no-heading", "--color", "never", "--max-columns", "300", "-e", pattern];
+  if (opts.ignoreCase) args.push("-i");
+  if (opts.glob) args.push("-g", opts.glob);
+  args.push(".");
+  return new Promise((resolve2) => {
+    execFile("rg", args, { cwd: opts.root, maxBuffer: 10 * 1024 * 1024 }, (error, stdout) => {
+      const code = error?.code;
+      if (code === "ENOENT") return resolve2(void 0);
+      if (error && error.code !== 1) return resolve2(void 0);
+      resolve2(stdout.split("\n").filter(Boolean).map((l) => l.replace(/^\.\//, "")).slice(0, MAX_MATCHES));
+    });
+  });
+}
+var grepTool = defineTool({
+  name: "grep",
+  description: "Search file contents with a regular expression. Respects .gitignore. Returns path:line:text (max 200).",
+  schema: z5.object({
+    pattern: z5.string().describe("Regular expression"),
+    path: z5.string().optional().describe("Directory to search, default project root"),
+    glob: z5.string().optional().describe('Only files matching this glob, e.g. "**/*.ts"'),
+    ignore_case: z5.boolean().optional()
+  }),
+  kind: "read",
+  target: (input) => input.pattern,
+  async run(input, ctx) {
+    const opts = { root: resolvePath(ctx.cwd, input.path ?? "."), glob: input.glob, ignoreCase: input.ignore_case };
+    try {
+      new RegExp(input.pattern);
+    } catch (error) {
+      return { output: `Regex tidak valid: ${error.message}`, isError: true };
+    }
+    const matches = await grepRg(input.pattern, opts) ?? await grepJs(input.pattern, opts);
+    if (!matches.length) return { output: "Tidak ada yang cocok." };
+    return { output: matches.join("\n"), display: `${matches.length} hasil` };
+  }
+});
+
+// src/tools/read.ts
+import { readFile as readFile3 } from "fs/promises";
+import { z as z6 } from "zod";
+var MAX_LINE = 2e3;
+var readTool = defineTool({
+  name: "read",
+  description: "Read a text file. Returns numbered lines (default first 2000). Use offset/limit for large files. Always read a file before editing it.",
+  schema: z6.object({
+    path: z6.string().describe("File path, relative to the project or absolute"),
+    offset: z6.number().int().min(1).optional().describe("First line to read, 1-based"),
+    limit: z6.number().int().min(1).optional().describe("Number of lines, default 2000")
+  }),
+  kind: "read",
+  target: (input) => input.path,
+  async run(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    let buffer;
+    try {
+      buffer = await readFile3(abs);
+    } catch (error) {
+      return { output: `Tidak bisa membaca ${input.path}: ${errorCode(error)}`, isError: true };
+    }
+    if (buffer.subarray(0, 8e3).includes(0)) {
+      return { output: `${input.path} adalah file biner, tidak dibaca.`, isError: true };
+    }
+    const lines = buffer.toString("utf8").split(/\r?\n/);
+    const start = (input.offset ?? 1) - 1;
+    const limit = input.limit ?? 2e3;
+    const slice = lines.slice(start, start + limit);
+    const body = slice.map((line, i) => {
+      const text = line.length > MAX_LINE ? `${line.slice(0, MAX_LINE)}\u2026 [baris dipotong]` : line;
+      return `${String(start + i + 1).padStart(6)}	${text}`;
+    }).join("\n");
+    const remaining = lines.length - start - slice.length;
+    ctx.readFiles.add(abs);
+    return {
+      output: remaining > 0 ? `${body}
+\u2026 ${remaining} baris lagi (pakai offset)` : body,
+      display: `${slice.length} baris`
+    };
+  }
+});
+
+// src/tools/write.ts
+import { existsSync } from "fs";
+import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+import { z as z7 } from "zod";
+var writeTool = defineTool({
+  name: "write",
+  description: "Create or overwrite a file with the given content. Read an existing file first. Prefer edit for changes.",
+  schema: z7.object({
+    path: z7.string().describe("File path, relative to the project or absolute"),
+    content: z7.string().describe("Full new file content")
+  }),
+  kind: "edit",
+  target: (input) => input.path,
+  async validate(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    return existsSync(abs) && !ctx.readFiles.has(abs) ? `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.` : void 0;
+  },
+  async preview(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    const old = existsSync(abs) ? await readFile4(abs, "utf8") : "";
+    return formatDiff(diffLines(old, input.content));
+  },
+  async run(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    if (existsSync(abs) && !ctx.readFiles.has(abs)) {
+      return { output: `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.`, isError: true };
+    }
+    try {
+      await mkdir(dirname(abs), { recursive: true });
+      await writeFile2(abs, input.content);
+    } catch (error) {
+      return { output: `Gagal menulis ${input.path}: ${errorCode(error)}`, isError: true };
+    }
+    ctx.readFiles.add(abs);
+    const lines = input.content.split("\n").length;
+    return { output: `Menulis ${input.path} (${lines} baris).`, display: `${lines} baris ditulis` };
+  }
+});
+
+// src/tools/index.ts
+var ALL_TOOLS = [readTool, writeTool, editTool, bashTool, grepTool, globTool, fetchTool];
+function toolDefinitions(tools) {
+  return tools.map((tool) => {
+    const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z8.toJSONSchema(tool.schema);
+    return { type: "function", function: { name: tool.name, description: tool.description, parameters } };
+  });
+}
+
+// src/agent.ts
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+var COMPACT_PROMPT = "Summarize the conversation so far for yourself so you can continue the work with no other context. Include: the user goals, decisions made, files touched and their current state, commands run and results, the task in progress and the next step. Be concise but complete.";
+var Agent = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.provider = opts.provider;
+    this.permissions = opts.permissions;
+    this.tools = opts.tools;
+    this.definitions = toolDefinitions(opts.tools);
+    this.turnTools = this.tools;
+    this.turnDefinitions = this.definitions;
+    this.messages = [...opts.history ?? []];
+    this.maxSteps = opts.maxSteps ?? 50;
+    this.contextWindow = opts.contextWindow ?? 128e3;
+  }
+  opts;
+  provider;
+  permissions;
+  messages;
+  totalUsage = { inputTokens: 0, outputTokens: 0 };
+  lastInputTokens = 0;
+  onEvent = () => {
+  };
+  askPermission = async () => "no";
+  tools;
+  definitions;
+  // Snapshot for the running turn: tools added/removed mid-turn (e.g. an MCP server connecting) apply from the next turn.
+  turnTools;
+  turnDefinitions;
+  readFiles = /* @__PURE__ */ new Set();
+  maxSteps;
+  // ponytail: one window for every model; read it from /v1/models metadata when providers expose it.
+  contextWindow;
+  setTools(tools) {
+    this.tools = tools;
+    this.definitions = toolDefinitions(tools);
+  }
+  isParallelSafe(call) {
+    const tool = this.turnTools.find((t) => t.name === call.name);
+    if (!tool?.parallelSafe) return false;
+    try {
+      const parsed = tool.schema.safeParse(JSON.parse(call.arguments || "{}"));
+      return parsed.success && tool.parallelSafe(parsed.data);
+    } catch {
+      return false;
+    }
+  }
+  push(message) {
+    this.messages.push(message);
+    this.opts.onMessage?.(message);
+  }
+  clear() {
+    this.messages = [];
+    this.readFiles.clear();
+    this.lastInputTokens = 0;
+    this.opts.onReset?.();
+  }
+  async compact(signal) {
+    const completion = await this.provider.chat({
+      messages: [{ role: "system", content: this.opts.systemPrompt }, ...this.messages, { role: "user", content: COMPACT_PROMPT }],
+      // Some gateways reject tool_calls in history when no tools are declared.
+      tools: this.definitions,
+      signal
+    });
+    this.clear();
+    this.push({ role: "user", content: `Ringkasan percakapan sebelumnya:
+${completion.text}` });
+    this.push({ role: "assistant", content: "Oke, saya lanjutkan dari ringkasan ini." });
+    this.onEvent({ type: "compacted" });
+  }
+  async run(text, signal) {
+    this.turnTools = this.tools;
+    this.turnDefinitions = this.definitions;
+    try {
+      if (this.lastInputTokens > this.contextWindow * 0.8) await this.compact(signal);
+      this.push({ role: "user", content: text });
+      for (let step = 0; step < this.maxSteps; step++) {
+        if (step > 0 && this.lastInputTokens > this.contextWindow * 0.8) {
+          await this.compact(signal);
+          this.push({ role: "user", content: `Lanjutkan tugas ini sesuai ringkasan di atas: ${text}` });
+        }
+        const completion = await this.provider.chat({
+          messages: [{ role: "system", content: this.opts.systemPrompt }, ...this.messages],
+          tools: this.turnDefinitions,
+          signal,
+          onText: (delta) => this.onEvent({ type: "text", delta })
+        });
+        const usage = completion.usage ?? {
+          inputTokens: estimateTokens(this.opts.systemPrompt) + estimateTokens(JSON.stringify(this.messages)),
+          outputTokens: estimateTokens(completion.text) + (completion.toolCalls.length ? estimateTokens(JSON.stringify(completion.toolCalls)) : 0)
+        };
+        this.totalUsage.inputTokens += usage.inputTokens;
+        this.totalUsage.outputTokens += usage.outputTokens;
+        this.lastInputTokens = usage.inputTokens;
+        this.onEvent({ type: "usage", ...this.totalUsage });
+        this.push({
+          role: "assistant",
+          content: completion.text || null,
+          ...completion.toolCalls.length ? {
+            tool_calls: completion.toolCalls.map((c) => ({
+              id: c.id,
+              type: "function",
+              function: { name: c.name, arguments: c.arguments }
+            }))
+          } : {}
+        });
+        if (!completion.toolCalls.length) {
+          this.onEvent({ type: "done" });
+          return;
+        }
+        const calls = completion.toolCalls;
+        let i = 0;
+        while (i < calls.length) {
+          if (signal.aborted) {
+            for (const pending of calls.slice(i)) this.push({ role: "tool", tool_call_id: pending.id, content: "Dibatalkan oleh user." });
+            this.onEvent({ type: "aborted" });
+            return;
+          }
+          let j = i + 1;
+          if (this.isParallelSafe(calls[i])) while (j < calls.length && this.isParallelSafe(calls[j])) j++;
+          const batch = calls.slice(i, j);
+          const results = await Promise.all(batch.map((c) => this.runTool(c, signal)));
+          batch.forEach((c, k) => {
+            this.push({ role: "tool", tool_call_id: c.id, content: results[k] });
+          });
+          i = j;
+        }
+        if (signal.aborted) {
+          this.onEvent({ type: "aborted" });
+          return;
+        }
+      }
+      this.onEvent({ type: "stepLimit" });
+    } catch (error) {
+      if (signal.aborted) {
+        this.onEvent({ type: "aborted" });
+        return;
+      }
+      const message = error.message;
+      const noTools = error.status === 400 && /tool/i.test(message);
+      this.onEvent({
+        type: "error",
+        message: noTools ? `${message}
+Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model.` : message
+      });
+    }
+  }
+  async runTool(call, signal) {
+    const fail = (output, target2 = "") => {
+      this.onEvent({ type: "toolStart", id: call.id, tool: call.name, target: target2 });
+      this.onEvent({ type: "toolEnd", id: call.id, tool: call.name, output, isError: true });
+      return output;
+    };
+    const tool = this.turnTools.find((t) => t.name === call.name);
+    if (!tool) return fail(`Alat "${call.name}" tidak ada. Alat yang tersedia: ${this.turnTools.map((t) => t.name).join(", ")}`);
+    let args;
+    try {
+      args = JSON.parse(call.arguments || "{}");
+    } catch {
+      return fail(`Argumen bukan JSON valid: ${call.arguments.slice(0, 200)}`);
+    }
+    const parsed = tool.schema.safeParse(args);
+    if (!parsed.success) {
+      return fail(`Argumen tidak valid: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
+    }
+    const input = parsed.data;
+    const target = tool.target(input);
+    const ctx = {
+      cwd: this.opts.cwd,
+      signal,
+      readFiles: this.readFiles,
+      callId: call.id,
+      emit: (event) => this.onEvent(event),
+      ask: (req) => this.askPermission(req),
+      addUsage: (u) => {
+        this.totalUsage.inputTokens += u.inputTokens;
+        this.totalUsage.outputTokens += u.outputTokens;
+        this.onEvent({ type: "usage", ...this.totalUsage });
+      }
+    };
+    this.onEvent({ type: "toolStart", id: call.id, tool: tool.name, target });
+    const invalid = await tool.validate?.(input, ctx).catch((error) => error.message);
+    if (invalid) {
+      this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output: invalid, isError: true });
+      return invalid;
+    }
+    const request = { tool: tool.name, kind: tool.kind, target };
+    let decision = this.permissions.check(request);
+    if (decision === "ask") {
+      const preview = await tool.preview?.(input, ctx).catch(() => void 0);
+      const answer = await this.askPermission({
+        ...request,
+        preview,
+        sessionRules: this.permissions.rulesFor(request),
+        ...this.opts.label ? { agent: this.opts.label } : {}
+      });
+      if (answer === "session") this.permissions.allowForSession(request);
+      decision = answer === "no" ? "deny" : "allow";
+    }
+    if (decision === "deny") {
+      const output = this.permissions.mode === "plan" ? "Ditolak: mode plan hanya boleh membaca dan mencari. Susun rencana untuk user tanpa mengubah apa pun." : "User menolak menjalankan alat ini. Tanyakan ke user apa yang diinginkan, atau coba cara lain.";
+      this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output, isError: true });
+      return output;
+    }
+    let result;
+    try {
+      result = await tool.run(input, ctx);
+    } catch (error) {
+      result = { output: `Error: ${error.message}`, isError: true };
+    }
+    this.onEvent({ type: "toolEnd", id: call.id, tool: tool.name, output: result.output, display: result.display, isError: !!result.isError });
+    return result.output;
+  }
+};
+
+// src/agents.ts
+var EXPLORE_PROMPT = "You are a read-only research agent working for another agent. Search and read the codebase to answer the request. You cannot edit files or run commands. Reply with a concise report: the answer, the relevant file paths with line numbers, and nothing else.";
+var GENERAL_PROMPT = "You are an agent handling a delegated task for another agent. Complete the task end to end with the tools you have, verify the result, and reply with a short report of what you did and what you found.";
+var BUILTIN_AGENTS = [
+  {
+    name: "explore",
+    description: "Read-only: search and read code to answer a question (fast, safe, can run in parallel).",
+    tools: ["read", "grep", "glob"],
+    prompt: EXPLORE_PROMPT,
+    maxSteps: 30
+  },
+  {
+    name: "general",
+    description: "Full tools: carry out a self-contained sub-task (edits and commands still need user permission).",
+    prompt: GENERAL_PROMPT,
+    maxSteps: 50
+  }
+];
+
+// src/mcp/manager.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { z as z9 } from "zod";
+function mcpToolName(server, tool, taken) {
+  const clean = (s) => s.replace(/[^A-Za-z0-9_-]+/g, "_");
+  const base = `mcp__${clean(server)}__${clean(tool)}`.slice(0, 64);
+  let name = base;
+  for (let n = 2; taken.has(name); n++) name = `${base.slice(0, 64 - String(n).length - 1)}_${n}`;
+  taken.add(name);
+  return name;
+}
+function withTimeout(promise, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`timeout ${Math.round(ms / 1e3)} detik`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+var McpManager = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  servers = /* @__PURE__ */ new Map();
+  taken = /* @__PURE__ */ new Set();
+  async start(specs) {
+    await Promise.all(specs.map((spec) => this.add(spec)));
+  }
+  async add(spec) {
+    await this.remove(spec.name);
+    const entry = { spec, state: { name: spec.name, source: spec.source, status: "starting", tools: 0 }, tools: [] };
+    this.servers.set(spec.name, entry);
+    this.opts.onChange?.();
+    const client = new Client({ name: "bccli", version: "0.3.0" });
+    entry.client = client;
+    const timeoutMs = this.opts.connectTimeoutMs ?? 3e4;
+    try {
+      const config = spec.config;
+      const transport = config.type === "http" ? new StreamableHTTPClientTransport(new URL(config.url), { requestInit: { headers: config.headers ?? {} } }) : new StdioClientTransport({
+        command: config.command,
+        args: config.args ?? [],
+        env: { ...process.env, ...config.env },
+        stderr: "ignore"
+      });
+      await withTimeout(client.connect(transport), timeoutMs);
+      const { tools } = await withTimeout(client.listTools(), timeoutMs);
+      if (this.servers.get(spec.name) !== entry) {
+        await client.close().catch(() => {
+        });
+        return;
+      }
+      entry.tools = tools.map((t) => this.wrap(spec.name, client, t));
+      entry.state = { ...entry.state, status: "ready", tools: entry.tools.length };
+    } catch (error) {
+      entry.state = { ...entry.state, status: "error", error: error.message };
+      await client.close().catch(() => {
+      });
+      if (this.servers.get(spec.name) !== entry) return;
+    }
+    this.opts.onChange?.();
+  }
+  wrap(server, client, tool) {
+    return {
+      name: mcpToolName(server, tool.name, this.taken),
+      description: `[MCP ${server}] ${tool.description ?? tool.name}`.slice(0, 1024),
+      schema: z9.record(z9.string(), z9.unknown()),
+      jsonSchema: tool.inputSchema,
+      kind: "mcp",
+      target: (input) => {
+        const text = JSON.stringify(input);
+        return text.length > 80 ? `${text.slice(0, 77)}\u2026` : text;
+      },
+      async run(input, ctx) {
+        try {
+          const result = await client.callTool({ name: tool.name, arguments: input }, void 0, { signal: ctx.signal });
+          const output = (result.content ?? []).map((c) => c.type === "text" ? c.text ?? "" : `[${c.type}]`).join("\n") || "(kosong)";
+          return { output: output.length > 5e4 ? `${output.slice(0, 5e4)}
+\u2026 [dipotong]` : output, isError: !!result.isError };
+        } catch (error) {
+          return { output: `Server MCP ${server} error: ${error.message}`, isError: true };
+        }
+      }
+    };
+  }
+  async remove(name) {
+    const entry = this.servers.get(name);
+    if (!entry) return;
+    this.servers.delete(name);
+    for (const t of entry.tools) this.taken.delete(t.name);
+    if (entry.tools.length) this.opts.onToolsRemoved?.(entry.tools.map((t) => t.name));
+    await entry.client?.close().catch(() => {
+    });
+    this.opts.onChange?.();
+  }
+  tools() {
+    return [...this.servers.values()].flatMap((s) => s.tools);
+  }
+  states() {
+    return [...this.servers.values()].map((s) => s.state);
+  }
+  async stop() {
+    await Promise.all([...this.servers.keys()].map((name) => this.remove(name)));
+  }
+};
+
+// src/setup.ts
+import { homedir } from "os";
+
+// src/context.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join } from "path";
+var FILES = ["AGENTS.md", "BCCLI.md"];
+function readIf(path) {
+  try {
+    return existsSync2(path) ? readFileSync(path, "utf8").trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function loadInstructions(cwd, home) {
+  const dirs = [];
+  for (let dir = cwd; ; dir = dirname2(dir)) {
+    dirs.unshift(dir);
+    if (dirname2(dir) === dir) break;
+  }
+  const parts = [];
+  const global = readIf(join(home, "BCCLI.md"));
+  if (global) parts.push(`# ${join(home, "BCCLI.md")}
+${global}`);
+  for (const dir of dirs) {
+    for (const name of FILES) {
+      const text = readIf(join(dir, name));
+      if (text) parts.push(`# ${join(dir, name)}
+${text}`);
+    }
+  }
+  return parts.join("\n\n");
+}
+function isGitRepo(cwd) {
+  for (let dir = cwd; ; dir = dirname2(dir)) {
+    if (existsSync2(join(dir, ".git"))) return true;
+    if (dirname2(dir) === dir) return false;
+  }
+}
+function buildSystemPrompt(opts) {
+  const instructions = loadInstructions(opts.cwd, opts.home);
+  const skills = (opts.skills ?? []).slice(0, 50);
+  const skillText = skills.length ? `
+
+Skills (load one with the skill tool when it matches the task):
+${skills.map((s) => `- ${s.name}: ${s.description.slice(0, 200)}`).join("\n")}` : "";
+  return `You are BCCLI, a coding agent by BotConnector running in the user's terminal. You help with software engineering tasks by reading code, editing files, and running commands with the tools provided.
+
+How to work:
+- Understand before changing: read the relevant files and search the codebase first. Never guess file contents.
+- Always read a file before editing it. Make the smallest correct change; match the existing style.
+- For tasks with 3 or more steps, keep a todo list with todo_write and update it as you go.
+- In plan mode you can only read and search. When the plan is ready, call exit_plan with it and wait for approval.
+- Verify your work: run the tests, build or the command that proves the change works, and report the real result.
+- The user must approve edits and commands. If they decline, ask what they want instead of retrying.
+- Be concise. Reply in the user's language. No preamble; lead with the answer or the action.
+- Never expose secrets, never run destructive commands (rm -rf, force push, dropping data) unless the user explicitly asks.
+
+Environment:
+- Working directory: ${opts.cwd}
+- Git repository: ${isGitRepo(opts.cwd) ? "yes" : "no"}
+- Platform: ${opts.platform ?? process.platform}
+- Date: ${opts.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+- Model: ${opts.model}${skillText}${instructions ? `
+
+Project and user instructions (follow them):
+
+${instructions}` : ""}`;
+}
+
+// src/tools/plan.ts
+import { z as z10 } from "zod";
+function createExitPlanTool(opts) {
+  return defineTool({
+    name: "exit_plan",
+    description: "Plan mode only: present the finished plan to the user for approval. If approved you may start implementing it.",
+    schema: z10.object({ plan: z10.string().describe("The plan, in markdown") }),
+    kind: "read",
+    target: () => "rencana",
+    async run(input) {
+      if (opts.permissions.mode !== "plan") return { output: "exit_plan hanya dipakai di mode plan.", isError: true };
+      const decision = await opts.interaction.approvePlan(input.plan);
+      if (decision === "no") {
+        return { output: "User belum menyetujui. Tanyakan apa yang perlu diperbaiki, perbaiki rencananya, lalu panggil exit_plan lagi." };
+      }
+      opts.permissions.mode = decision;
+      return { output: `Rencana disetujui. Mode sekarang ${decision}. Mulai kerjakan rencananya sekarang.` };
+    }
+  });
+}
+
+// src/tools/skill.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { z as z11 } from "zod";
+function createSkillTool(skills) {
+  return defineTool({
+    name: "skill",
+    description: "Load a skill (instructions for a kind of task) by name. Use it when a listed skill matches the task, then follow it.",
+    schema: z11.object({ name: z11.string().describe("Skill name from the list in the system prompt") }),
+    kind: "read",
+    target: (input) => input.name,
+    async run(input) {
+      const skill = skills.find((s) => s.name === input.name);
+      if (!skill) return { output: `Skill "${input.name}" tidak ada. Tersedia: ${skills.map((s) => s.name).join(", ") || "(tidak ada)"}`, isError: true };
+      const { body } = parseFrontmatter(readFileSync2(skill.file, "utf8"));
+      return { output: `Base directory for this skill: ${skill.dir}
+
+${body}`, display: skill.description.slice(0, 60) };
+    }
+  });
+}
+
+// src/tools/task.ts
+import { z as z12 } from "zod";
+function createTaskTool(opts) {
+  const byName = new Map(opts.agents.map((a) => [a.name, a]));
+  const list = opts.agents.map((a) => `- ${a.name}: ${a.description}`).join("\n");
+  return defineTool({
+    name: "task",
+    description: `Delegate a self-contained sub-task to a subagent. It starts with an empty context and returns only its final report. Available agents:
+${list}`,
+    schema: z12.object({
+      agent: z12.string().describe("Agent name"),
+      description: z12.string().describe("3-6 word summary shown to the user"),
+      prompt: z12.string().describe("Full instructions; the subagent sees nothing else")
+    }),
+    kind: "read",
+    target: (input) => `[${input.agent}] ${input.description}`,
+    // Parallel only when the resolved agent can do nothing but read (a project file may redefine "explore").
+    parallelSafe: (input) => {
+      const allowed = byName.get(input.agent)?.tools;
+      if (!allowed) return false;
+      const base = opts.baseTools();
+      return allowed.every((name) => base.find((t) => t.name === name)?.kind === "read");
+    },
+    async run(input, ctx) {
+      const def = byName.get(input.agent);
+      if (!def) return { output: `Agent "${input.agent}" tidak ada. Tersedia: ${[...byName.keys()].join(", ")}`, isError: true };
+      const base = opts.baseTools().filter((t) => t.name !== "task" && t.name !== "exit_plan");
+      const unknown = (def.tools ?? []).filter((n) => !base.some((t) => t.name === n));
+      if (unknown.length) return { output: `Agent "${def.name}": alat tidak dikenal: ${unknown.join(", ")}`, isError: true };
+      const allowed = def.tools;
+      const tools = allowed ? base.filter((t) => allowed.includes(t.name)) : base;
+      let provider;
+      try {
+        provider = def.model ? opts.providerFor(def.model) : opts.provider();
+      } catch (error) {
+        return { output: `Agent "${def.name}": ${error.message}`, isError: true };
+      }
+      const child = new Agent({
+        provider,
+        tools,
+        permissions: opts.permissions,
+        systemPrompt: `${opts.systemPrompt}
+
+# Your role
+${def.prompt}`,
+        cwd: opts.cwd,
+        maxSteps: def.maxSteps ?? 50,
+        label: def.name
+      });
+      let outcome;
+      let steps = 0;
+      child.onEvent = (event) => {
+        if (event.type === "toolStart") steps++;
+        if (event.type === "error" || event.type === "stepLimit" || event.type === "aborted" || event.type === "done") outcome = event;
+        if (event.type !== "usage" && ctx.callId) ctx.emit?.({ type: "subagent", parentId: ctx.callId, agent: def.name, event });
+      };
+      if (ctx.ask) child.askPermission = ctx.ask;
+      await child.run(input.prompt, ctx.signal);
+      ctx.addUsage?.(child.totalUsage);
+      const tokens = child.totalUsage.inputTokens + child.totalUsage.outputTokens;
+      const display = `${steps} langkah \xB7 ${tokens >= 1e3 ? `${Math.round(tokens / 1e3)}k` : tokens} token`;
+      if (outcome?.type === "error") return { output: `Subagent ${def.name} gagal: ${outcome.message}`, isError: true, display };
+      if (outcome?.type === "aborted") return { output: `Subagent ${def.name} dibatalkan.`, isError: true, display };
+      const last = [...child.messages].reverse().find((m) => m.role === "assistant" && m.content);
+      const report = last && typeof last.content === "string" ? last.content : "(tidak ada laporan)";
+      const suffix = outcome?.type === "stepLimit" ? `
+
+(Subagent berhenti di batas ${def.maxSteps ?? 50} langkah.)` : "";
+      return { output: report + suffix, display };
+    }
+  });
+}
+
+// src/tools/todo.ts
+import { z as z13 } from "zod";
+var TodoStore = class {
+  items = [];
+  listeners = /* @__PURE__ */ new Set();
+  set(items) {
+    this.items = items;
+    for (const fn of this.listeners) fn(items);
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+};
+function createTodoTool(store) {
+  return defineTool({
+    name: "todo_write",
+    description: "Write the task list for multi-step work (3+ steps). Send the whole list every time; exactly one item in_progress while working. Mark items completed as soon as they are done.",
+    schema: z13.object({
+      todos: z13.array(z13.object({ content: z13.string(), status: z13.enum(["pending", "in_progress", "completed"]) }))
+    }),
+    kind: "read",
+    target: (input) => `${input.todos.length} item`,
+    async run(input) {
+      if (input.todos.filter((t) => t.status === "in_progress").length > 1) {
+        return { output: "Hanya boleh satu item in_progress.", isError: true };
+      }
+      store.set(input.todos);
+      const done = input.todos.filter((t) => t.status === "completed").length;
+      return { output: `Todo diperbarui: ${done}/${input.todos.length} selesai.` };
+    }
+  });
+}
+
+// src/setup.ts
+var TOOL_RULES = { bash: "bash", edit: "edit", write: "edit", fetch: "fetch" };
+function createRuntime(opts) {
+  const env = opts.env ?? process.env;
+  const home = bccliHome(env);
+  let config = loadConfig(opts.cwd, env);
+  let modelRef = opts.args.model ?? config.model;
+  const makeProvider = (ref) => {
+    const resolved = resolveModel(config, ref, env);
+    return opts.provider ?? createProvider({ baseURL: resolved.baseURL, apiKey: resolved.apiKey, model: resolved.model });
+  };
+  const provider = makeProvider(modelRef);
+  const mode = opts.args.allowAll ? "allowAll" : opts.args.permissionMode ?? config.permissionMode;
+  const rules = [...config.allow, ...opts.args.allowedTools.map((t) => TOOL_RULES[t] ?? t)];
+  const permissions = new Permissions(mode, rules, opts.cwd);
+  const roots = { cwd: opts.cwd, home, userHome: opts.userHome ?? homedir() };
+  const skills = loadSkills(roots);
+  const commands = loadCommands(roots);
+  const agentDefs = loadAgentDefs(roots);
+  const todos = new TodoStore();
+  const interaction = { approvePlan: async () => "no" };
+  let session = Session.create(home, opts.cwd);
+  let history = opts.history;
+  if (!history && opts.args.continue) {
+    const latest = Session.latest(home, opts.cwd);
+    if (latest) {
+      session = latest;
+      history = latest.load();
+    }
+  }
+  const systemPrompt = buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef, skills });
+  const baseTools = [...ALL_TOOLS, createSkillTool(skills), createTodoTool(todos), createExitPlanTool({ permissions, interaction })];
+  const task = createTaskTool({
+    agents: [...BUILTIN_AGENTS, ...agentDefs],
+    // Subagents get whatever the main agent has right now (incl. MCP tools), minus task itself.
+    baseTools: () => agent.tools.filter((t) => t.name !== "task"),
+    permissions,
+    provider: () => agent.provider,
+    providerFor: makeProvider,
+    systemPrompt,
+    cwd: opts.cwd
+  });
+  const agent = new Agent({
+    provider,
+    tools: [...baseTools, task],
+    permissions,
+    systemPrompt,
+    cwd: opts.cwd,
+    history,
+    onMessage: (m) => session.append(m),
+    onReset: () => session.reset()
+  });
+  const mcp = new McpManager({
+    onChange: () => agent.setTools([...baseTools, task, ...mcp.tools()]),
+    // A later server may reuse a sanitized name; it must not inherit this one's "[a]" grants.
+    onToolsRemoved: (names) => {
+      for (const name of names) permissions.revoke(`mcp(${name})`);
+    }
+  });
+  return {
+    cwd: opts.cwd,
+    home,
+    env,
+    skills,
+    commands,
+    agentDefs,
+    todos,
+    interaction,
+    mcp,
+    startMcp: (specs) => mcp.start(specs),
+    get config() {
+      return config;
+    },
+    reloadConfig() {
+      config = loadConfig(opts.cwd, env);
+    },
+    providerLabel() {
+      return providerName(config, modelRef.slice(0, modelRef.indexOf("/")));
+    },
+    listModels: (only) => listAllModels(config, env, { fetch: opts.fetch, only }),
+    addProviderKey(id, key) {
+      return addProviderKey(id, key, { env, cwd: opts.cwd, out: () => {
+      }, err: () => {
+      }, readSecret: async () => "", fetch: opts.fetch });
+    },
+    get modelRef() {
+      return modelRef;
+    },
+    agent,
+    get session() {
+      return session;
+    },
+    resume(previous) {
+      session = previous;
+      agent.messages = previous.load();
+    },
+    setModel(ref) {
+      agent.provider = makeProvider(ref);
+      modelRef = ref;
+    }
+  };
+}
+
+// src/version.ts
+var VERSION = true ? "0.3.0-beta.1" : "0.0.0-dev";
+
+// src/cli.ts
+async function main() {
+  const args = parseCliArgs(process.argv.slice(2));
+  if (args.version) {
+    console.log(VERSION);
+    return 0;
+  }
+  if (args.help) {
+    console.log(HELP_TEXT);
+    return 0;
+  }
+  const cwd = process.cwd();
+  if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd);
+  if (args.command === "mcp") {
+    const { runMcpCommand } = await import("./mcpCli-BV3IGR47.js");
+    const { readSecret } = await import("./login-IXJD5O7Z.js");
+    return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
+  }
+  if (args.command === "provider") {
+    const { runProviderCommand } = await import("./providerCli-7QNAYIFT.js");
+    const { readSecret } = await import("./login-IXJD5O7Z.js");
+    return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
+  }
+  if (args.command === "models") {
+    const config = loadConfig(cwd);
+    const resolved = resolveModel(config, args.model ?? config.model);
+    const models = await createProvider(resolved).listModels();
+    console.log(models.map((m) => `${resolved.providerId}/${m}`).join("\n"));
+    return 0;
+  }
+  const rt = createRuntime({ cwd, args });
+  try {
+    pruneSessions(rt.home);
+  } catch {
+  }
+  if (args.print) {
+    if (!args.prompt) throw new ConfigError('Mode -p butuh tugas, contoh: bccli -p "jelaskan repo ini"');
+    const { serversToStart } = await import("./config-XPWPGNZJ.js");
+    const plan = serversToStart(rt.home, cwd);
+    for (const s of plan.needTrust) {
+      console.error(`Server MCP project "${s.name}" dilewati (belum diizinkan; jalankan bccli interaktif sekali untuk menyetujuinya).`);
+    }
+    await rt.startMcp(plan.start);
+    try {
+      return await runPrint(rt, args.prompt, void 0, { allowAll: args.allowAll });
+    } finally {
+      await rt.mcp.stop();
+    }
+  }
+  if (!process.stdin.isTTY) throw new ConfigError('Mode interaktif butuh terminal. Untuk skrip/CI pakai: bccli -p "tugas"');
+  const { startInteractive } = await import("./ui-6PGC4T6N.js");
+  return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION });
+}
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    console.error(error instanceof ConfigError || error?.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" ? error.message : error);
+    process.exit(1);
+  }
+);