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

package/dist/chunk-SJH3YLW4.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// src/session.ts
+import { randomBytes } from "crypto";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { join } from "path";
+function projectDir(home, cwd) {
+  const slug = cwd.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-100) || "root";
+  return join(home, "sessions", slug);
+}
+function repairTail(messages) {
+  const out = [...messages];
+  for (let i = out.length - 1; i >= 0; i--) {
+    const m = out[i];
+    if (m.role !== "assistant" || !m.tool_calls?.length) continue;
+    const answered = new Set(out.slice(i + 1).flatMap((x) => x.role === "tool" ? [x.tool_call_id] : []));
+    if (!m.tool_calls.every((c) => answered.has(c.id))) out.length = i;
+    break;
+  }
+  return out;
+}
+var Session = class _Session {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  static create(home, cwd, now = /* @__PURE__ */ new Date()) {
+    const dir = projectDir(home, cwd);
+    mkdirSync(dir, { recursive: true });
+    const stamp = now.toISOString().replace(/[:.]/g, "-");
+    return new _Session(join(dir, `${stamp}-${randomBytes(3).toString("hex")}.jsonl`));
+  }
+  static list(home, cwd) {
+    const dir = projectDir(home, cwd);
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const session = new _Session(join(dir, f));
+      const first = session.load().find((m) => m.role === "user");
+      return { session, mtime: statSync(session.file).mtime, preview: first ? String(first.content).slice(0, 80) : "" };
+    }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
+  }
+  static latest(home, cwd) {
+    return _Session.list(home, cwd)[0]?.session;
+  }
+  write(record) {
+    appendFileSync(this.file, `${JSON.stringify(record)}
+`);
+  }
+  append(message) {
+    this.write({ t: "msg", m: message });
+  }
+  reset() {
+    this.write({ t: "reset" });
+  }
+  load() {
+    if (!existsSync(this.file)) return [];
+    let messages = [];
+    for (const line of readFileSync(this.file, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (record.t === "reset") messages = [];
+      else if (record.t === "msg") messages.push(record.m);
+    }
+    return repairTail(messages);
+  }
+};
+function pruneSessions(home, now = Date.now(), maxAgeDays = 30) {
+  const root = join(home, "sessions");
+  if (!existsSync(root)) return 0;
+  let removed = 0;
+  for (const project of readdirSync(root)) {
+    const dir = join(root, project);
+    for (const file of readdirSync(dir)) {
+      const path = join(dir, file);
+      if (now - statSync(path).mtimeMs > maxAgeDays * 864e5) {
+        rmSync(path);
+        removed++;
+      }
+    }
+  }
+  return removed;
+}
+
+export {
+  Session,
+  pruneSessions
+};

package/dist/chunk-TBPPXOOZ.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+// src/print.ts
+function toolLabel(tool) {
+  return tool.charAt(0).toUpperCase() + tool.slice(1);
+}
+async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
+  rt.interaction.approvePlan = async () => {
+    if (opts.allowAll) return "allowAll";
+    io.err.write("Rencana butuh persetujuan; jalankan dengan --allow-all.\n");
+    return "no";
+  };
+  let failed = false;
+  let wroteText = false;
+  rt.agent.onEvent = (event) => {
+    switch (event.type) {
+      case "text":
+        io.out.write(event.delta);
+        wroteText = true;
+        break;
+      case "toolStart":
+        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
+`);
+        break;
+      case "toolEnd":
+        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
+`);
+        break;
+      case "stepLimit":
+        io.err.write("Batas langkah tercapai.\n");
+        failed = true;
+        break;
+      case "aborted":
+        io.err.write("Dibatalkan.\n");
+        failed = true;
+        break;
+      case "error":
+        io.err.write(`Error: ${event.message}
+`);
+        failed = true;
+        break;
+    }
+  };
+  rt.agent.askPermission = async (req) => {
+    io.err.write(`  Butuh izin untuk ${req.tool}. Jalankan dengan --allow-all atau --allowed-tools ${req.kind}.
+`);
+    return "no";
+  };
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  try {
+    await rt.agent.run(prompt, controller.signal);
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  if (wroteText) io.out.write("\n");
+  return failed ? 1 : 0;
+}
+
+// src/extensions.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, join } from "path";
+function parseFrontmatter(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (!match) return { data: {}, body: text };
+  const data = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    let value = kv[2].trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      data[kv[1]] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+      continue;
+    }
+    if (/^(["']).*\1$/.test(value)) value = value.slice(1, -1);
+    data[kv[1]] = value;
+  }
+  return { data, body: text.slice(match[0].length) };
+}
+var str = (v) => Array.isArray(v) ? v.join(", ") : v;
+function dirs(r, kind) {
+  return [join(r.userHome, ".claude", kind), join(r.home, kind), join(r.cwd, ".claude", kind), join(r.cwd, ".bccli", kind)];
+}
+function list(dir) {
+  try {
+    return readdirSync(dir).sort();
+  } catch {
+    return [];
+  }
+}
+function loadSkills(r) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs(r, "skills")) {
+    for (const entry of list(dir)) {
+      const file = join(dir, entry, "SKILL.md");
+      if (!existsSync(file)) continue;
+      const { data } = parseFrontmatter(readFileSync(file, "utf8"));
+      const name = str(data.name) || entry;
+      byName.set(name, { name, description: str(data.description) ?? "", dir: join(dir, entry), file });
+    }
+  }
+  return [...byName.values()];
+}
+function loadCommands(r) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs(r, "commands")) {
+    for (const entry of list(dir)) {
+      const file = join(dir, entry);
+      if (!entry.endsWith(".md") || !statSync(file).isFile()) continue;
+      const { data, body } = parseFrontmatter(readFileSync(file, "utf8"));
+      const def = { name: basename(entry, ".md"), body: body.trim() };
+      if (data.description) def.description = str(data.description);
+      if (data["argument-hint"]) def.argumentHint = str(data["argument-hint"]);
+      byName.set(def.name, def);
+    }
+  }
+  return [...byName.values()];
+}
+function loadAgentDefs(r) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs(r, "agents")) {
+    for (const entry of list(dir)) {
+      if (!entry.endsWith(".md")) continue;
+      const { data, body } = parseFrontmatter(readFileSync(join(dir, entry), "utf8"));
+      const name = str(data.name) || basename(entry, ".md");
+      const def = { name, description: str(data.description) ?? "", prompt: body.trim() };
+      if (data.tools)
+        def.tools = Array.isArray(data.tools) ? data.tools : String(data.tools).split(",").map((s) => s.trim()).filter(Boolean);
+      if (data.model) def.model = str(data.model);
+      byName.set(name, def);
+    }
+  }
+  return [...byName.values()];
+}
+
+// src/tools/ignore.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function ignorePatterns(root) {
+  const patterns = ["**/node_modules/**", "**/.git/**"];
+  let lines = [];
+  try {
+    lines = readFileSync2(join2(root, ".gitignore"), "utf8").split(/\r?\n/);
+  } catch {
+    return patterns;
+  }
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+    const p = line.replace(/^\//, "").replace(/\/$/, "");
+    patterns.push(`**/${p}`, `**/${p}/**`);
+  }
+  return patterns;
+}
+
+export {
+  toolLabel,
+  runPrint,
+  ignorePatterns,
+  parseFrontmatter,
+  loadSkills,
+  loadCommands,
+  loadAgentDefs
+};

package/dist/chunk-TV6LEHOH.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import {
+  ConfigError
+} from "./chunk-Z5JM76EL.js";
+
+// src/mcp/catalog.ts
+var CATALOG = [
+  { name: "playwright", description: "kontrol browser (buka halaman, klik, isi form, screenshot)", config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] } },
+  { name: "context7", description: "dokumentasi library terbaru", config: { type: "http", url: "https://mcp.context7.com/mcp" } },
+  { name: "fetch", description: "ambil halaman web jadi markdown (butuh uv)", config: { command: "uvx", args: ["mcp-server-fetch"] } },
+  {
+    name: "filesystem",
+    description: "akses folder di luar project",
+    config: { command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "${dir}"] },
+    inputs: [{ key: "dir", label: "Folder yang boleh diakses" }]
+  },
+  { name: "git", description: "operasi git terstruktur (butuh uv)", config: { command: "uvx", args: ["mcp-server-git"] } },
+  {
+    name: "github",
+    description: "issue, PR, dan repo GitHub",
+    config: { type: "http", url: "https://api.githubcopilot.com/mcp/", headers: { Authorization: "Bearer ${token}" } },
+    inputs: [{ key: "token", label: "GitHub Personal Access Token", secret: true }]
+  }
+];
+function fillTemplate(config, values) {
+  const missing = /* @__PURE__ */ new Set();
+  const fill = (s) => s.replace(/\$\{([A-Za-z0-9_]+)\}/g, (_m, key) => {
+    if (!values[key]) missing.add(key);
+    return values[key] ?? "";
+  });
+  const mapValues = (o) => Object.fromEntries(Object.entries(o).map(([k, v]) => [k, fill(v)]));
+  const out = config.type === "http" ? { type: "http", url: fill(config.url), ...config.headers ? { headers: mapValues(config.headers) } : {} } : {
+    ...config.type ? { type: config.type } : {},
+    command: fill(config.command),
+    ...config.args ? { args: config.args.map(fill) } : {},
+    ...config.env ? { env: mapValues(config.env) } : {}
+  };
+  if (missing.size) throw new ConfigError(`Isian MCP belum lengkap: ${[...missing].join(", ")}`);
+  return out;
+}
+
+export {
+  CATALOG,
+  fillTemplate
+};

package/dist/chunk-XQLXE666.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  ConfigError
+} from "./chunk-Z5JM76EL.js";
+
+// src/mcp/config.ts
+import { createHash } from "crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var globalMcpPath = (home) => join(home, "mcp.json");
+var projectMcpPath = (cwd) => join(cwd, ".bccli", "mcp.json");
+var trustPath = (home) => join(home, "trusted-mcp.json");
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ConfigError(`File MCP tidak valid: ${path} (${error.message})`);
+  }
+}
+function writePrivate(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+  chmodSync(path, 384);
+}
+function readMcpFile(path) {
+  return readJson(path, {}).mcpServers ?? {};
+}
+function addGlobalServer(home, name, config) {
+  writePrivate(globalMcpPath(home), { mcpServers: { ...readMcpFile(globalMcpPath(home)), [name]: config } });
+}
+function removeGlobalServer(home, name) {
+  const { [name]: _removed, ...rest } = readMcpFile(globalMcpPath(home));
+  writePrivate(globalMcpPath(home), { mcpServers: rest });
+}
+var configHash = (config) => createHash("sha256").update(JSON.stringify(config)).digest("hex");
+function projectTrust(home, cwd, name, config) {
+  const decision = readJson(trustPath(home), {})[resolve(cwd)]?.[name];
+  return decision?.hash === configHash(config) ? decision.allowed : void 0;
+}
+function setProjectTrust(home, cwd, name, allowed, config) {
+  const all = readJson(trustPath(home), {});
+  const key = resolve(cwd);
+  writePrivate(trustPath(home), { ...all, [key]: { ...all[key], [name]: { allowed, hash: configHash(config) } } });
+}
+function serversToStart(home, cwd) {
+  const global = readMcpFile(globalMcpPath(home));
+  const start = Object.entries(global).map(([name, config]) => ({ name, config, source: "global" }));
+  const needTrust = [];
+  for (const [name, config] of Object.entries(readMcpFile(projectMcpPath(cwd)))) {
+    if (global[name]) continue;
+    const trust = projectTrust(home, cwd, name, config);
+    if (trust === true) start.push({ name, config, source: "project" });
+    else if (trust === void 0) needTrust.push({ name, config, source: "project" });
+  }
+  return { start, needTrust };
+}
+
+export {
+  globalMcpPath,
+  projectMcpPath,
+  readMcpFile,
+  addGlobalServer,
+  removeGlobalServer,
+  projectTrust,
+  setProjectTrust,
+  serversToStart
+};

package/dist/chunk-Z5JM76EL.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+// src/presets.ts
+var PRESETS = [
+  { id: "bc-cloud", name: "BotConnector Cloud", baseURL: "https://api.botconnector.id/v1", apiKeyEnv: "BOTCONNECTOR_API_KEY" },
+  { id: "openrouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY" },
+  { id: "openai", name: "OpenAI", baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY" },
+  { id: "gemini", name: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai", apiKeyEnv: "GEMINI_API_KEY" },
+  { id: "deepseek", name: "DeepSeek", baseURL: "https://api.deepseek.com/v1", apiKeyEnv: "DEEPSEEK_API_KEY" },
+  { id: "groq", name: "Groq", baseURL: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY" },
+  { id: "ollama-cloud", name: "Ollama Cloud", baseURL: "https://ollama.com/v1", apiKeyEnv: "OLLAMA_API_KEY" },
+  { id: "ollama", name: "Ollama lokal", baseURL: "http://127.0.0.1:11434/v1", local: true },
+  { id: "lmstudio", name: "LM Studio lokal", baseURL: "http://127.0.0.1:1234/v1", local: true }
+];
+
+// 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: Object.fromEntries(PRESETS.map((p) => [p.id, { baseURL: p.baseURL, apiKeyEnv: p.apiKeyEnv }])),
+  allow: []
+};
+function bccliHome(env = process.env) {
+  return env.BCCLI_HOME ?? join(homedir(), ".bccli");
+}
+function readJsonConfig(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 = readJsonConfig(join(bccliHome(env), "config.json"));
+  const project = readJsonConfig(join(cwd, ".bccli", "config.json"));
+  const known = { ...DEFAULT_CONFIG.providers, ...global.providers };
+  const fromProject = untrustedProviders(project, known);
+  return {
+    model: project.model ?? global.model ?? DEFAULT_CONFIG.model,
+    permissionMode: global.permissionMode ?? DEFAULT_CONFIG.permissionMode,
+    providers: { ...known, ...fromProject },
+    projectProviders: Object.keys(fromProject),
+    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 };
+}
+function removeCredential(providerId, env = process.env) {
+  const creds = readCredentials(env);
+  if (!(providerId in creds)) return;
+  delete creds[providerId];
+  const path = join(bccliHome(env), "credentials");
+  writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+}
+
+export {
+  PRESETS,
+  ConfigError,
+  bccliHome,
+  readJsonConfig,
+  loadConfig,
+  readCredentials,
+  saveCredential,
+  resolveModel,
+  removeCredential
+};