@botconnector/bccli 0.1.0-beta.3 → 0.2.0-beta.1

package/dist/cli.js

@@ -0,0 +1,1156 @@
+#!/usr/bin/env node
+import {
+  Session,
+  pruneSessions
+} from "./chunk-SJH3YLW4.js";
+import {
+  MODE_ORDER,
+  Permissions,
+  ignorePatterns,
+  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;
+  }
+}
+
+// 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 as existsSync2 } 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 existsSync2(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") : "";
+    return formatDiff(diffLines(old, input.content));
+  },
+  async run(input, ctx) {
+    const abs = resolvePath(ctx.cwd, input.path);
+    if (existsSync2(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 } = 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.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;
+  readFiles = /* @__PURE__ */ new Set();
+  maxSteps;
+  // ponytail: one window for every model; read it from /v1/models metadata when providers expose it.
+  contextWindow;
+  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) {
+    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.definitions,
+          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;
+        }
+        for (let i = 0; i < completion.toolCalls.length; i++) {
+          const call = completion.toolCalls[i];
+          if (signal.aborted) {
+            for (const pending of completion.toolCalls.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) });
+        }
+        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.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(", ")}`);
+    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 };
+    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) });
+      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/context.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var FILES = ["AGENTS.md", "BCCLI.md"];
+function readIf(path) {
+  try {
+    return existsSync3(path) ? readFileSync2(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(join2(home, "BCCLI.md"));
+  if (global) parts.push(`# ${join2(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)}
+${text}`);
+    }
+  }
+  return parts.join("\n\n");
+}
+function isGitRepo(cwd) {
+  for (let dir = cwd; ; dir = dirname2(dir)) {
+    if (existsSync3(join2(dir, ".git"))) return true;
+    if (dirname2(dir) === dir) return false;
+  }
+}
+function buildSystemPrompt(opts) {
+  const instructions = loadInstructions(opts.cwd, opts.home);
+  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.
+- 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}${instructions ? `
+
+Project and user instructions (follow them):
+
+${instructions}` : ""}`;
+}
+
+// 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 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);
+  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 agent = new Agent({
+    provider,
+    tools: ALL_TOOLS,
+    permissions,
+    systemPrompt: buildSystemPrompt({ cwd: opts.cwd, home, model: modelRef }),
+    cwd: opts.cwd,
+    history,
+    onMessage: (m) => session.append(m),
+    onReset: () => session.reset()
+  });
+  return {
+    cwd: opts.cwd,
+    home,
+    config,
+    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.2.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 === "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"');
+    return runPrint(rt, args.prompt);
+  }
+  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");
+  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);
+  }
+);