@botconnector/bccli 0.2.0-beta.1 → 0.3.0-beta.2

package/dist/cli.js

@@ -1,346 +1,40 @@
 #!/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 {
-  MODE_ORDER,
-  Permissions,
   ignorePatterns,
+  loadAgentDefs,
+  loadCommands,
+  loadSkills,
+  parseFrontmatter,
   runPrint
-} from "./chunk-WZYWKWPD.js";
-
-// src/args.ts
-import { parseArgs } from "util";
-
-// src/config.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var ConfigError = class extends Error {
-};
-var DEFAULT_CONFIG = {
-  model: "bc-cloud/glm-5.3-flash",
-  permissionMode: "default",
-  providers: {
-    "bc-cloud": { baseURL: "https://api.botconnector.id/v1", apiKeyEnv: "BOTCONNECTOR_API_KEY" }
-  },
-  allow: []
-};
-function bccliHome(env = process.env) {
-  return env.BCCLI_HOME ?? join(homedir(), ".bccli");
-}
-function readJson(path) {
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new ConfigError(`Config tidak valid: ${path} (${error.message})`);
-  }
-}
-function untrustedProviders(project, known) {
-  const out = {};
-  for (const [id, provider] of Object.entries(project.providers ?? {})) {
-    if (known[id] || typeof provider?.baseURL !== "string") continue;
-    out[id] = { baseURL: provider.baseURL };
-  }
-  return out;
-}
-function loadConfig(cwd, env = process.env) {
-  const global = readJson(join(bccliHome(env), "config.json"));
-  const project = readJson(join(cwd, ".bccli", "config.json"));
-  const known = { ...DEFAULT_CONFIG.providers, ...global.providers };
-  return {
-    model: project.model ?? global.model ?? DEFAULT_CONFIG.model,
-    permissionMode: global.permissionMode ?? DEFAULT_CONFIG.permissionMode,
-    providers: { ...known, ...untrustedProviders(project, known) },
-    allow: [...global.allow ?? []]
-  };
-}
-function readCredentials(env = process.env) {
-  const path = join(bccliHome(env), "credentials");
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveCredential(providerId, key, env = process.env) {
-  const home = bccliHome(env);
-  mkdirSync(home, { recursive: true });
-  const path = join(home, "credentials");
-  writeFileSync(path, JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), { mode: 384 });
-  chmodSync(path, 384);
-}
-function resolveModel(config, modelRef, env = process.env) {
-  const slash = modelRef.indexOf("/");
-  if (slash <= 0 || slash === modelRef.length - 1) {
-    throw new ConfigError(`Model harus berformat provider/model, contoh bc-cloud/glm-5.3-flash (dapat: ${modelRef})`);
-  }
-  const providerId = modelRef.slice(0, slash);
-  const provider = config.providers[providerId];
-  if (!provider) {
-    throw new ConfigError(`Provider "${providerId}" tidak ada di config. Tersedia: ${Object.keys(config.providers).join(", ")}`);
-  }
-  const apiKey = (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[providerId] || void 0;
-  if (provider.apiKeyEnv && !apiKey) {
-    throw new ConfigError(`API key untuk ${providerId} belum ada. Jalankan \`bccli login\` atau set env ${provider.apiKeyEnv}.`);
-  }
-  return { providerId, model: modelRef.slice(slash + 1), baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey };
-}
-
-// src/args.ts
-var HELP_TEXT = `BCCLI \u2014 agent AI BotConnector di terminal
-
-Pemakaian:
-  bccli [tugas]                 mode interaktif (opsional langsung dengan tugas)
-  bccli -p "tugas"              jalankan satu tugas tanpa interaksi (skrip/CI)
-  bccli login [provider]        simpan API key (default: bc-cloud)
-  bccli models                  daftar model dari provider aktif
-
-Opsi:
-  -m, --model <provider/model>  pilih model, contoh bc-cloud/glm-5.3-flash
-  -c, --continue                lanjutkan sesi terakhir di folder ini
-  -r, --resume                  pilih sesi untuk dilanjutkan
-      --allow-all               jalankan semua alat tanpa minta izin
-      --allowed-tools <a,b>     alat yang boleh tanpa izin: bash, edit, fetch
-      --permission-mode <mode>  default | acceptEdits | plan | allowAll
-  -v, --version                 versi
-  -h, --help                    bantuan ini`;
-function parseCliArgs(argv) {
-  const { values, positionals } = parseArgs({
-    args: argv,
-    allowPositionals: true,
-    options: {
-      print: { type: "boolean", short: "p" },
-      model: { type: "string", short: "m" },
-      continue: { type: "boolean", short: "c" },
-      resume: { type: "boolean", short: "r" },
-      "allow-all": { type: "boolean" },
-      "allowed-tools": { type: "string" },
-      "permission-mode": { type: "string" },
-      help: { type: "boolean", short: "h" },
-      version: { type: "boolean", short: "v" }
-    }
-  });
-  const mode = values["permission-mode"];
-  if (mode && !MODE_ORDER.includes(mode)) {
-    throw new ConfigError(`--permission-mode harus salah satu dari: ${MODE_ORDER.join(", ")}`);
-  }
-  const [first, ...rest] = positionals;
-  const command = first === "login" || first === "models" ? first : "run";
-  const words = command === "run" ? positionals : rest;
-  return {
-    command,
-    prompt: command === "run" && words.length ? words.join(" ") : void 0,
-    print: !!values.print,
-    model: values.model,
-    continue: !!values.continue,
-    resume: !!values.resume,
-    allowAll: !!values["allow-all"],
-    allowedTools: (values["allowed-tools"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
-    permissionMode: mode,
-    help: !!values.help,
-    version: !!values.version,
-    loginProvider: command === "login" ? rest[0] ?? "bc-cloud" : void 0
-  };
-}
-
-// src/provider.ts
-var ProviderError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-  }
-  status;
-};
-var retryable = (status) => status === 429 || status >= 500;
-function sleep(ms, signal) {
-  return new Promise((resolve2, reject) => {
-    const timer = setTimeout(resolve2, ms);
-    signal?.addEventListener(
-      "abort",
-      () => {
-        clearTimeout(timer);
-        reject(signal.reason);
-      },
-      { once: true }
-    );
-  });
-}
-function errorMessage(body) {
-  try {
-    const parsed = JSON.parse(body);
-    return parsed?.error?.message ?? parsed?.message ?? body.slice(0, 300);
-  } catch {
-    return body.slice(0, 300);
-  }
-}
-var toUsage = (u) => u ? { inputTokens: u.prompt_tokens ?? 0, outputTokens: u.completion_tokens ?? 0 } : void 0;
-async function readStream(res, onText) {
-  let text = "";
-  let usage;
-  let finishReason;
-  const calls = [];
-  const byIndex = /* @__PURE__ */ new Map();
-  let current;
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const handle = (line) => {
-    if (!line.startsWith("data:")) return;
-    const data = line.slice(5).trim();
-    if (!data || data === "[DONE]") return;
-    let event;
-    try {
-      event = JSON.parse(data);
-    } catch {
-      return;
-    }
-    if (event.error) throw new ProviderError(`Error dari provider: ${event.error.message ?? JSON.stringify(event.error)}`);
-    if (event.usage) usage = toUsage(event.usage);
-    const choice = event.choices?.[0];
-    if (!choice) return;
-    if (choice.finish_reason) finishReason = choice.finish_reason;
-    const delta = choice.delta ?? {};
-    if (delta.content) {
-      text += delta.content;
-      onText?.(delta.content);
-    }
-    for (const tc of delta.tool_calls ?? []) {
-      let target = tc.index !== void 0 ? byIndex.get(tc.index) : current;
-      if (!target || tc.index === void 0 && tc.id && target.id && target.id !== tc.id) {
-        target = { id: "", name: "", arguments: "" };
-        calls.push(target);
-        if (tc.index !== void 0) byIndex.set(tc.index, target);
-      }
-      current = target;
-      if (tc.id) target.id = tc.id;
-      if (tc.function?.name && !target.name) target.name = tc.function.name;
-      if (tc.function?.arguments) target.arguments += tc.function.arguments;
-    }
-  };
-  for await (const chunk of res.body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    let newline = buffer.indexOf("\n");
-    while (newline >= 0) {
-      handle(buffer.slice(0, newline).trim());
-      buffer = buffer.slice(newline + 1);
-      newline = buffer.indexOf("\n");
-    }
-  }
-  handle(buffer.trim());
-  const toolCalls = calls.map((call, index) => ({ ...call, id: call.id || `call_${index}` }));
-  return { text, toolCalls, usage, finishReason };
-}
-async function readJson2(res) {
-  const body = await res.json();
-  const choice = body.choices?.[0];
-  const toolCalls = (choice?.message?.tool_calls ?? []).map((tc, i) => ({
-    id: tc.id || `call_${i}`,
-    name: tc.function?.name ?? "",
-    arguments: tc.function?.arguments ?? ""
-  }));
-  return { text: choice?.message?.content ?? "", toolCalls, usage: toUsage(body.usage), finishReason: choice?.finish_reason };
-}
-function createProvider({ baseURL, apiKey, model, fetch: doFetch = fetch, retryDelayMs = 1e3 }) {
-  const headers = { "content-type": "application/json" };
-  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
-  async function post(path, body, signal) {
-    let lastError;
-    for (let attempt = 0; attempt < 4; attempt++) {
-      if (attempt > 0) await sleep(retryDelayMs * 2 ** (attempt - 1), signal);
-      let res;
-      try {
-        res = await doFetch(`${baseURL}${path}`, { method: "POST", headers, body: JSON.stringify(body), signal });
-      } catch (error) {
-        if (signal?.aborted) throw error;
-        lastError = new ProviderError(`Tidak bisa terhubung ke ${baseURL}: ${error.message}`);
-        continue;
-      }
-      if (res.ok) return res;
-      const text = await res.text().catch(() => "");
-      lastError = new ProviderError(`${res.status} dari ${baseURL}: ${errorMessage(text)}`, res.status);
-      if (!retryable(res.status)) throw lastError;
-    }
-    throw lastError ?? new ProviderError("Permintaan gagal");
-  }
-  return {
-    async chat({ messages, tools, signal, onText }) {
-      const res = await post(
-        "/chat/completions",
-        { model, messages, stream: true, stream_options: { include_usage: true }, ...tools?.length ? { tools } : {} },
-        signal
-      );
-      if ((res.headers.get("content-type") ?? "").includes("application/json")) return readJson2(res);
-      if (!res.body) throw new ProviderError("Respons provider kosong");
-      return readStream(res, onText);
-    },
-    async listModels() {
-      const res = await doFetch(`${baseURL}/models`, { headers });
-      if (!res.ok) throw new ProviderError(`${res.status} saat mengambil daftar model`, res.status);
-      const body = await res.json();
-      return (body.data ?? []).map((m) => m.id).sort();
-    }
-  };
-}
-
-// src/login.ts
-function readSecret(prompt) {
-  return new Promise((resolve2) => {
-    process.stdout.write(prompt);
-    const stdin = process.stdin;
-    if (!stdin.isTTY) {
-      let data = "";
-      stdin.on("data", (d) => {
-        data += d;
-      });
-      stdin.on("end", () => resolve2(data.trim()));
-      return;
-    }
-    let value = "";
-    stdin.setRawMode(true);
-    stdin.resume();
-    const onData = (buffer) => {
-      for (const ch of buffer.toString()) {
-        if (ch === "\r" || ch === "\n") {
-          stdin.setRawMode(false);
-          stdin.pause();
-          stdin.off("data", onData);
-          process.stdout.write("\n");
-          resolve2(value.trim());
-          return;
-        }
-        if (ch === "") process.exit(130);
-        if (ch === "\x7F" || ch === "\b") value = value.slice(0, -1);
-        else value += ch;
-      }
-    };
-    stdin.on("data", onData);
-  });
-}
-async function runLogin(providerId, cwd) {
-  const config = loadConfig(cwd);
-  const provider = config.providers[providerId];
-  if (!provider) {
-    console.error(`Provider "${providerId}" tidak ada. Tersedia: ${Object.keys(config.providers).join(", ")}`);
-    return 1;
-  }
-  const key = await readSecret(`API key untuk ${providerId} (${provider.baseURL}): `);
-  if (!key) {
-    console.error("API key kosong, tidak disimpan.");
-    return 1;
-  }
-  try {
-    const models = await createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey: key, model: "" }).listModels();
-    saveCredential(providerId, key);
-    console.log(`Tersimpan. ${models.length} model tersedia di ${providerId}.`);
-    return 0;
-  } catch (error) {
-    console.error(`API key ditolak atau provider tidak bisa dihubungi: ${error.message}`);
-    return 1;
-  }
-}
+} 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";
@@ -775,7 +469,7 @@ var readTool = defineTool({
 });
 
 // src/tools/write.ts
-import { existsSync as existsSync2 } from "fs";
+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";
@@ -790,16 +484,16 @@ var writeTool = defineTool({
   target: (input) => input.path,
   async validate(input, ctx) {
     const abs = resolvePath(ctx.cwd, input.path);
-    return existsSync2(abs) && !ctx.readFiles.has(abs) ? `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.` : void 0;
+    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 = existsSync2(abs) ? await readFile4(abs, "utf8") : "";
+    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 (existsSync2(abs) && !ctx.readFiles.has(abs)) {
+    if (existsSync(abs) && !ctx.readFiles.has(abs)) {
       return { output: `${input.path} sudah ada. Baca dulu dengan read sebelum menimpanya.`, isError: true };
     }
     try {
@@ -818,7 +512,7 @@ var writeTool = defineTool({
 var ALL_TOOLS = [readTool, writeTool, editTool, bashTool, grepTool, globTool, fetchTool];
 function toolDefinitions(tools) {
   return tools.map((tool) => {
-    const { $schema: _ignored, ...parameters } = z8.toJSONSchema(tool.schema);
+    const { $schema: _ignored, ...parameters } = tool.jsonSchema ?? z8.toJSONSchema(tool.schema);
     return { type: "function", function: { name: tool.name, description: tool.description, parameters } };
   });
 }
@@ -833,6 +527,8 @@ var Agent = class {
     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;
@@ -848,10 +544,27 @@ var Agent = class {
   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);
@@ -876,6 +589,8 @@ ${completion.text}` });
     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 });
@@ -886,7 +601,7 @@ ${completion.text}` });
         }
         const completion = await this.provider.chat({
           messages: [{ role: "system", content: this.opts.systemPrompt }, ...this.messages],
-          tools: this.definitions,
+          tools: this.turnDefinitions,
           signal,
           onText: (delta) => this.onEvent({ type: "text", delta })
         });
@@ -913,16 +628,22 @@ ${completion.text}` });
           this.onEvent({ type: "done" });
           return;
         }
-        for (let i = 0; i < completion.toolCalls.length; i++) {
-          const call = completion.toolCalls[i];
+        const calls = completion.toolCalls;
+        let i = 0;
+        while (i < calls.length) {
           if (signal.aborted) {
-            for (const pending of completion.toolCalls.slice(i)) {
-              this.push({ role: "tool", tool_call_id: pending.id, content: "Dibatalkan oleh user." });
-            }
+            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;
           }
-          this.push({ role: "tool", tool_call_id: call.id, content: await this.runTool(call, signal) });
+          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" });
@@ -950,8 +671,8 @@ Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model
       this.onEvent({ type: "toolEnd", id: call.id, tool: call.name, output, isError: true });
       return output;
     };
-    const tool = this.tools.find((t) => t.name === call.name);
-    if (!tool) return fail(`Alat "${call.name}" tidak ada. Alat yang tersedia: ${this.tools.map((t) => t.name).join(", ")}`);
+    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 || "{}");
@@ -964,7 +685,19 @@ Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model
     }
     const input = parsed.data;
     const target = tool.target(input);
-    const ctx = { cwd: this.opts.cwd, signal, readFiles: this.readFiles };
+    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) {
@@ -975,8 +708,14 @@ Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model
     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) });
+      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);
+      if (answer === "all") this.permissions.mode = "allowAll";
       decision = answer === "no" ? "deny" : "allow";
     }
     if (decision === "deny") {
@@ -995,13 +734,142 @@ Model ini sepertinya tidak mendukung tool calling. Coba model lain dengan /model
   }
 };
 
+// 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 existsSync3, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+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 existsSync3(path) ? readFileSync2(path, "utf8").trim() : void 0;
+    return existsSync2(path) ? readFileSync(path, "utf8").trim() : void 0;
   } catch {
     return void 0;
   }
@@ -1013,13 +881,13 @@ function loadInstructions(cwd, home) {
     if (dirname2(dir) === dir) break;
   }
   const parts = [];
-  const global = readIf(join2(home, "BCCLI.md"));
-  if (global) parts.push(`# ${join2(home, "BCCLI.md")}
+  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(join2(dir, name));
-      if (text) parts.push(`# ${join2(dir, name)}
+      const text = readIf(join(dir, name));
+      if (text) parts.push(`# ${join(dir, name)}
 ${text}`);
     }
   }
@@ -1027,17 +895,24 @@ ${text}`);
 }
 function isGitRepo(cwd) {
   for (let dir = cwd; ; dir = dirname2(dir)) {
-    if (existsSync3(join2(dir, ".git"))) return true;
+    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.
@@ -1048,19 +923,168 @@ Environment:
 - 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}${instructions ? `
+- 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);
-  const config = loadConfig(opts.cwd, env);
+  let config = loadConfig(opts.cwd, env);
   let modelRef = opts.args.model ?? config.model;
   const makeProvider = (ref) => {
     const resolved = resolveModel(config, ref, env);
@@ -1070,6 +1094,12 @@ function createRuntime(opts) {
   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) {
@@ -1079,20 +1109,61 @@ function createRuntime(opts) {
       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: ALL_TOOLS,
+    tools: [...baseTools, task],
     permissions,
-    systemPrompt: buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef }),
+    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,
-    config,
+    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;
     },
@@ -1112,7 +1183,7 @@ function createRuntime(opts) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.2.0-beta.1" : "0.0.0-dev";
+var VERSION = true ? "0.3.0-beta.2" : "0.0.0-dev";
 
 // src/cli.ts
 async function main() {
@@ -1127,6 +1198,16 @@ async function main() {
   }
   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);
@@ -1141,10 +1222,20 @@ async function main() {
   }
   if (args.print) {
     if (!args.prompt) throw new ConfigError('Mode -p butuh tugas, contoh: bccli -p "jelaskan repo ini"');
-    return runPrint(rt, args.prompt);
+    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-U6OMOINK.js");
+  const { startInteractive } = await import("./ui-HNIC4DQ6.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION });
 }
 main().then(