@botconnector/bccli 0.4.0-beta.4 → 0.4.0-beta.41

package/dist/{chunk-NGLKANMD.js → chunk-AVB6M4JE.js}

@@ -1,12 +1,33 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-RZUJYAQV.js";
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
 
 // src/mcp/config.ts
 import { createHash } from "crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join, resolve } from "path";
+var ENV_REF = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+function expandEnvVars(config, env) {
+  const expand = (value) => value.replace(ENV_REF, (match, name, fallback) => {
+    const resolved = env[name];
+    if (resolved !== void 0) return resolved;
+    return fallback !== void 0 ? fallback : match;
+  });
+  const expandMap = (map) => Object.fromEntries(Object.entries(map).map(([k, v]) => [k, expand(v)]));
+  if (config.type === "http") {
+    return { ...config, url: expand(config.url), ...config.headers ? { headers: expandMap(config.headers) } : {} };
+  }
+  return {
+    ...config,
+    command: expand(config.command),
+    ...config.args ? { args: config.args.map(expand) } : {},
+    ...config.env ? { env: expandMap(config.env) } : {}
+  };
+}
 var globalMcpPath = (home) => join(home, "mcp.json");
 var projectMcpPath = (cwd) => join(cwd, ".bccli", "mcp.json");
 var trustPath = (home) => join(home, "trusted-mcp.json");
@@ -15,7 +36,7 @@ function readJson(path, fallback) {
   try {
     return JSON.parse(readFileSync(path, "utf8"));
   } catch (error) {
-    throw new ConfigError(`File MCP tidak valid: ${path} (${error.message})`);
+    throw new ConfigError(t("Invalid MCP file: {path} ({error})", { path, error: error.message }));
   }
 }
 function writePrivate(path, data) {
@@ -58,6 +79,7 @@ function serversToStart(home, cwd) {
 }
 
 export {
+  expandEnvVars,
   globalMcpPath,
   projectMcpPath,
   readMcpFile,

package/dist/chunk-BUHWQU3V.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import {
+  runCommand,
+  runHooks
+} from "./chunk-DBHDZ5EP.js";
+import {
+  ConfigError
+} from "./chunk-M7LLJQ7M.js";
+import {
+  t
+} from "./chunk-M23QBX3V.js";
+
+// src/verify.ts
+var MAX_VERIFY_ROUNDS = 2;
+async function runVerify(commands, opts) {
+  const run = opts.run ?? runCommand;
+  const failures = [];
+  for (const cmd of commands) {
+    const r = await run(cmd, { cwd: opts.cwd, timeoutMs: opts.timeoutMs ?? 3e5, signal: opts.signal, env: opts.env });
+    const exitCode = r.exitCode ?? -1;
+    if (exitCode !== 0) failures.push({ cmd, exitCode, output: r.output });
+  }
+  return failures;
+}
+function verifyFollowup(failures, maxBytes = 8e3) {
+  const blocks = failures.map((f) => {
+    const output = f.output.length > maxBytes ? `${f.output.slice(0, maxBytes)}
+[truncated]` : f.output;
+    return `$ ${f.cmd}
+[exit code ${f.exitCode}]
+${output}`;
+  });
+  return t("Automatic verification after your edits failed. Fix the problems so these commands pass, then stop.\n\n{blocks}", {
+    blocks: blocks.join("\n\n")
+  });
+}
+
+// src/print.ts
+function toolLabel(tool) {
+  if (tool === "web_search") return "Search";
+  return tool.charAt(0).toUpperCase() + tool.slice(1);
+}
+async function runPrint(rt, prompt, io = { out: process.stdout, err: process.stderr }, opts = {}) {
+  const format = opts.outputFormat ?? "text";
+  const emit = (line) => io.out.write(`${JSON.stringify(line)}
+`);
+  let result = "";
+  const toolNames = /* @__PURE__ */ new Map();
+  rt.interaction.approvePlan = async () => {
+    if (opts.allowAll) return "allowAll";
+    io.err.write(`${t("Plan needs approval; run with --allow-all.")}
+`);
+    return "no";
+  };
+  let failed = false;
+  let wroteText = false;
+  let edited = false;
+  rt.agent.onEvent = (event) => {
+    switch (event.type) {
+      case "text":
+        if (format === "text") {
+          io.out.write(event.delta);
+          wroteText = true;
+        } else {
+          result += event.delta;
+        }
+        break;
+      case "toolStart":
+        toolNames.set(event.id, event.tool);
+        io.err.write(`\u23BF ${toolLabel(event.tool)}  ${event.target}
+`);
+        if (format === "stream-json") emit({ type: "tool_use", tool: event.tool, target: event.target });
+        break;
+      case "toolEnd":
+        if (event.isError) io.err.write(`  \u2717 ${event.output.split("\n")[0]}
+`);
+        if ((event.tool === "edit" || event.tool === "write") && !event.isError) edited = true;
+        if (format === "stream-json") emit({ type: "tool_result", tool: toolNames.get(event.id), isError: !!event.isError, output: event.output });
+        break;
+      case "stepLimit":
+        io.err.write(`${t("Step limit reached.")}
+`);
+        failed = true;
+        break;
+      case "budgetExceeded":
+        io.err.write(`${t("Budget exceeded ({kind}): {used} of {limit}. Further model calls are blocked; raise usageCap in ~/.bccli/config.json.", { kind: event.kind, used: Math.round(event.used * 100) / 100, limit: event.limit })}
+`);
+        if (format === "stream-json") emit({ type: "error", message: "budgetExceeded" });
+        failed = true;
+        break;
+      case "aborted":
+        io.err.write(`${t("Cancelled.")}
+`);
+        failed = true;
+        break;
+      case "error":
+        io.err.write(`Error: ${event.message}
+`);
+        if (format === "stream-json") emit({ type: "error", message: event.message });
+        failed = true;
+        break;
+    }
+  };
+  rt.agent.askPermission = async (req) => {
+    io.err.write(`  ${t("Needs permission for {tool}. Run with --allow-all or --allowed-tools {kind}.", { tool: req.tool, kind: req.kind })}
+`);
+    return "no";
+  };
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  const start = await runHooks(rt.config.hooks, "SessionStart", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of start.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("SessionStart");
+  try {
+    await rt.agent.run(prompt, controller.signal);
+    const commands = rt.config.verifyCommands;
+    if (edited && commands.length && !controller.signal.aborted) {
+      for (let round = 0; round < MAX_VERIFY_ROUNDS; round++) {
+        io.err.write(`${t("Verifying edits: {cmds}", { cmds: commands.join(", ") })}
+`);
+        const failures = await runVerify(commands, { cwd: rt.cwd, env: rt.env, signal: controller.signal });
+        if (!failures.length) {
+          io.err.write(`${t("Verification passed.")}
+`);
+          break;
+        }
+        if (round === MAX_VERIFY_ROUNDS - 1 || controller.signal.aborted) {
+          io.err.write(`${t("Verification still failing after {n} fix round(s). Run the commands manually to see why.", { n: MAX_VERIFY_ROUNDS })}
+`);
+          failed = true;
+          break;
+        }
+        await rt.agent.run(verifyFollowup(failures), controller.signal);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  const stop = await runHooks(rt.config.hooks, "Stop", {}, { env: rt.env, cwd: rt.cwd });
+  for (const warning of stop.warnings) io.err.write(`${warning}
+`);
+  await rt.emitPlugins("Stop");
+  if (format === "json") {
+    io.out.write(`${JSON.stringify({ status: failed ? "failed" : "ok", model: rt.modelRef, result })}
+`);
+  } else if (format === "stream-json") {
+    if (result) emit({ type: "message", text: result });
+    emit({ type: "result", status: failed ? "failed" : "ok", model: rt.modelRef });
+  } else if (wroteText) {
+    io.out.write("\n");
+  }
+  return failed ? 1 : 0;
+}
+
+// src/worktree.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { basename, dirname, join } from "path";
+function git(cwd, args, bin = "git") {
+  return new Promise((resolve) => {
+    execFile(
+      bin,
+      args,
+      { cwd, maxBuffer: 20 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve({ ok: !error, out: error ? stderr : stdout, missing: error?.code === "ENOENT" })
+    );
+  });
+}
+var NAME_RE = /^[A-Za-z0-9._-]+$/;
+function samePath(a, b) {
+  const norm = (p) => process.platform === "win32" ? p.replace(/\//g, "\\").toLowerCase() : p.replace(/\\/g, "/");
+  return norm(a) === norm(b);
+}
+function worktreeEntries(porcelain) {
+  return porcelain.split(/\r?\n\r?\n/).map((block) => {
+    const path = /^worktree (.+)$/m.exec(block)?.[1]?.trim();
+    if (!path) return void 0;
+    const branch = /^branch refs\/heads\/(.+)$/m.exec(block)?.[1];
+    return branch ? { path, branch } : { path };
+  }).filter((entry) => !!entry);
+}
+async function resolveWorktree(cwd, name, bin = "git") {
+  if (!NAME_RE.test(name)) {
+    throw new ConfigError(t('Invalid worktree name "{name}": use letters, digits, dot, dash, or underscore (no slashes).', { name }));
+  }
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) throw new ConfigError(t("git is not installed or not on PATH, so -w cannot be used."));
+  if (!inside.ok || inside.out.trim() !== "true") throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const entries = worktreeEntries(list.out);
+  const main = entries[0]?.path;
+  if (!main) throw new ConfigError(t("This folder is not a git repository, so -w cannot create a worktree."));
+  const path = join(dirname(main), `${basename(main)}.worktrees`, name);
+  if (entries.some((entry) => samePath(entry.path, path))) return { path, created: false };
+  if (existsSync(path)) {
+    throw new ConfigError(t("Worktree path {path} already exists but is not a registered worktree; remove or rename it first.", { path }));
+  }
+  const branch = `bccli/${name}`;
+  const hasBranch = (await git(main, ["rev-parse", "--verify", "-q", `refs/heads/${branch}`], bin)).ok;
+  const add = hasBranch ? await git(main, ["worktree", "add", path, branch], bin) : await git(main, ["worktree", "add", "-b", branch, path], bin);
+  if (!add.ok) throw new ConfigError(add.out.trim() || t("This folder is not a git repository, so -w cannot create a worktree."));
+  return { path, created: true };
+}
+async function worktreeListText(cwd, bin = "git") {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) return t("git is not installed or not on PATH, so /worktree cannot be used.");
+  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
+  const list = await git(cwd, ["worktree", "list", "--porcelain"], bin);
+  if (!list.ok) return t("This folder is not a git repository, so there is no diff.");
+  const rows = worktreeEntries(list.out).map((entry) => `  ${entry.path}${entry.branch ? ` (${entry.branch})` : ""}`);
+  return [
+    t("Git worktrees:"),
+    ...rows,
+    "",
+    t("Create one with: bccli -w <name>"),
+    t("Remove with: git worktree remove <path>")
+  ].join("\n");
+}
+
+export {
+  MAX_VERIFY_ROUNDS,
+  runVerify,
+  verifyFollowup,
+  toolLabel,
+  runPrint,
+  resolveWorktree,
+  worktreeListText
+};