@botconnector/bccli 0.4.9 → 0.4.11

package/dist/{chunk-HCW67S5M.js → chunk-N6APAYSF.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/version.ts
-var VERSION = true ? "0.4.9" : "0.0.0-dev";
+var VERSION = true ? "0.4.11" : "0.0.0-dev";
 
 export {
   VERSION

package/dist/{chunk-TLCFBQ6E.js → chunk-NT2G5FSX.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   ConfigError
-} from "./chunk-DRJSANKH.js";
+} from "./chunk-C2FUGQJX.js";
 import {
   t
-} from "./chunk-XCVYR5BK.js";
+} from "./chunk-G5TG43R4.js";
 
 // src/mcp/catalog.ts
 var CATALOG = [

package/dist/{chunk-CSIQDFEF.js → chunk-OAXD3X4R.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-PSO7R5AD.js";
 import {
   t
-} from "./chunk-XCVYR5BK.js";
+} from "./chunk-G5TG43R4.js";
 
 // src/tools/bash.ts
 import { spawn } from "child_process";
@@ -34,60 +34,39 @@ function darwinProfile(cwd, network) {
     network ? "(allow network*)" : "(deny network*)"
   ].join("\n");
 }
+function bwrapArgv(cwd, network, command) {
+  return [
+    "bwrap",
+    "--ro-bind",
+    "/",
+    "/",
+    "--dev-bind",
+    "/dev",
+    "/dev",
+    "--proc",
+    "/proc",
+    "--bind",
+    cwd,
+    cwd,
+    "--tmpfs",
+    "/tmp",
+    "--die-with-parent",
+    ...network ? [] : ["--unshare-net"],
+    "--",
+    "/bin/bash",
+    "-c",
+    command
+  ];
+}
 function sandboxArgv(command, opts) {
   if (opts.platform === "darwin") {
     return ["sandbox-exec", "-p", darwinProfile(opts.cwd, opts.network), "/bin/bash", "-c", command];
   }
   if (opts.platform === "linux") {
-    return [
-      "bwrap",
-      "--ro-bind",
-      "/",
-      "/",
-      "--dev-bind",
-      "/dev",
-      "/dev",
-      "--proc",
-      "/proc",
-      "--bind",
-      opts.cwd,
-      opts.cwd,
-      "--tmpfs",
-      "/tmp",
-      "--die-with-parent",
-      ...opts.network ? [] : ["--unshare-net"],
-      "--",
-      "/bin/bash",
-      "-c",
-      command
-    ];
+    return bwrapArgv(opts.cwd, opts.network, command);
   }
   if (opts.platform === "win32" && (opts.wslBwrap || process.env.BCCLI_WIN32_WSL_SANDBOX === "1")) {
-    const wslCwd = winPathToWsl(opts.cwd);
-    return [
-      "wsl.exe",
-      "--",
-      "bwrap",
-      "--ro-bind",
-      "/",
-      "/",
-      "--dev-bind",
-      "/dev",
-      "/dev",
-      "--proc",
-      "/proc",
-      "--bind",
-      wslCwd,
-      wslCwd,
-      "--tmpfs",
-      "/tmp",
-      "--die-with-parent",
-      ...opts.network ? [] : ["--unshare-net"],
-      "--",
-      "/bin/bash",
-      "-c",
-      command
-    ];
+    return ["wsl.exe", "--", ...bwrapArgv(winPathToWsl(opts.cwd), opts.network, command)];
   }
   return void 0;
 }
@@ -156,7 +135,7 @@ function killAllCommands() {
 }
 var backgrounds = /* @__PURE__ */ new Map();
 var nextBackgroundId = 1;
-function startBackground(command, cwd, env, shell) {
+function startBackground(command, cwd, env, shell, maxRetained) {
   const child = spawnChild(command, cwd, env, shell);
   const task = {
     id: nextBackgroundId++,
@@ -177,6 +156,10 @@ function startBackground(command, cwd, env, shell) {
     if (child.pid !== void 0) killProcessTree(child.pid);
   };
   backgrounds.set(task.id, task);
+  for (const [id, other] of backgrounds) {
+    if (backgrounds.size <= maxRetained) break;
+    if (id !== task.id && other.status === "exited") backgrounds.delete(id);
+  }
   const onData = (data) => {
     let s = data;
     if (task.head.length < HALF) {
@@ -385,6 +368,7 @@ var SHELL_NOTE = {
 function createBashTool(options = {}) {
   const offline = options.networkPolicy === "offline";
   const sandbox = options.sandbox === true;
+  const maxRetained = options.maxRetainedTasks ?? 50;
   const platform = options.platform ?? process.platform;
   const shell = resolveShell({ platform, env: process.env, exists: existsSync2, ...options.shellDeps });
   const childEnv = offline ? offlineEnv() : void 0;
@@ -431,7 +415,7 @@ Network access is off (networkPolicy "offline"): internet commands such as curl,
       }
       if (input.background) {
         if (!input.command) return { output: 'The "command" argument is required to start a background task.', isError: true };
-        const task = startBackground(exec, ctx.cwd, childEnv, shell);
+        const task = startBackground(exec, ctx.cwd, childEnv, shell, maxRetained);
         return {
           output: `Background task #${task.id} started: ${input.command}
 Poll it with {task_id: ${task.id}}; stop it with {task_id: ${task.id}, kill: true}.`

package/dist/{chunk-EOJNFGOP.js → chunk-OOOS5RCT.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   reasoningPayload
-} from "./chunk-EAR2C6TS.js";
+} from "./chunk-XZ2TI5HV.js";
 import {
   t
-} from "./chunk-XCVYR5BK.js";
+} from "./chunk-G5TG43R4.js";
 
 // src/provider.ts
 import OpenAI from "openai";
@@ -78,6 +78,17 @@ function outputReasoningSummary(items) {
   }).map((part) => part && typeof part === "object" && "text" in part && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
 }
 var retryable = (status) => status === 429 || status >= 500;
+function httpIdleMs() {
+  const raw = Number(process.env.BCCLI_HTTP_IDLE_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 6e4;
+}
+function statusHint(status) {
+  if (status === 401 || status === 403) return t("The API key was rejected. Check the key for this provider (bccli login) or its API key environment variable.");
+  if (status === 404) return t("Model or endpoint not found. Check the model name and the provider base URL.");
+  if (status === 429) return t("Rate limit reached. Wait a moment, or switch model with /model.");
+  if (status >= 500) return t("The provider is having trouble. Try again, or switch model with /model.");
+  return void 0;
+}
 function detectRepetition(text) {
   const tail = text.slice(-600);
   for (let len = 1; len <= 12; len++) {
@@ -120,7 +131,7 @@ var toUsage = (u) => u ? {
   ...u.prompt_tokens_details?.cached_tokens != null ? { cachedInputTokens: u.prompt_tokens_details.cached_tokens } : {},
   ...u.prompt_tokens_details?.cache_write_tokens != null ? { cacheWriteTokens: u.prompt_tokens_details.cache_write_tokens } : {}
 } : void 0;
-async function readStream(res, onText, onThinking) {
+async function readStream(res, onText, onThinking, signal) {
   let text = "";
   let thinking = "";
   const splitter = new ThinkSplitter();
@@ -137,6 +148,7 @@ async function readStream(res, onText, onThinking) {
   };
   let usage;
   let finishReason;
+  let sawDone = false;
   const calls = [];
   const byIndex = /* @__PURE__ */ new Map();
   let current;
@@ -146,7 +158,11 @@ async function readStream(res, onText, onThinking) {
   const handle = (line) => {
     if (!line.startsWith("data:")) return;
     const data = line.slice(5).trim();
-    if (!data || data === "[DONE]") return;
+    if (!data) return;
+    if (data === "[DONE]") {
+      sawDone = true;
+      return;
+    }
     let event;
     try {
       event = JSON.parse(data);
@@ -175,18 +191,45 @@ async function readStream(res, onText, onThinking) {
       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 && loopAt < 0) {
-      handle(buffer.slice(0, newline).trim());
-      buffer = buffer.slice(newline + 1);
-      newline = buffer.indexOf("\n");
-    }
-    if (loopAt >= 0) return { text: text.slice(0, loopAt), toolCalls: [], thinking: thinking || void 0, usage, finishReason: "repetition" };
+  const iterator = res.body[Symbol.asyncIterator]();
+  const idle = httpIdleMs();
+  const onAbort = () => void iterator.return?.();
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort);
+  try {
+    for (; ; ) {
+      let timer;
+      const stalled = new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new ProviderError(t("The provider stopped sending data for {seconds}s. The answer above may be incomplete; try again.", { seconds: String(Math.round(idle / 1e3)) }))),
+          idle
+        );
+      });
+      let step;
+      try {
+        step = await Promise.race([iterator.next(), stalled]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+      if (step.done) break;
+      buffer += decoder.decode(step.value, { stream: true });
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0 && loopAt < 0) {
+        handle(buffer.slice(0, newline).trim());
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf("\n");
+      }
+      if (loopAt >= 0) return { text: text.slice(0, loopAt), toolCalls: [], thinking: thinking || void 0, usage, finishReason: "repetition" };
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    void iterator.return?.();
   }
   handle(buffer.trim());
   emit(splitter.flush());
+  if (!sawDone && !finishReason) {
+    throw new ProviderError(t("The response ended before it finished (no finish_reason or [DONE]). The answer above is incomplete; try again."));
+  }
   const toolCalls = calls.map((call, index) => ({ ...call, id: call.id || `call_${index}` }));
   return { text, toolCalls, thinking: thinking || void 0, usage, finishReason };
 }
@@ -397,7 +440,7 @@ function hasPendingProgrammaticReplay(messages) {
   }
   return pending;
 }
-async function readResponsesStream(res, onText, onThinking) {
+async function readResponsesStream(res, onText, onThinking, signal) {
   let text = "";
   let thinking = "";
   let usage;
@@ -499,17 +542,28 @@ async function readResponsesStream(res, onText, onThinking) {
       );
     }
   };
-  for await (const chunk of res.body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    let newline = buffer.indexOf("\n");
-    while (newline >= 0 && loopAt < 0) {
-      handle(buffer.slice(0, newline).trim());
-      buffer = buffer.slice(newline + 1);
-      newline = buffer.indexOf("\n");
-    }
-    if (loopAt >= 0) {
-      return { text: text.slice(0, loopAt), toolCalls: [], usage, finishReason: "repetition" };
+  const iterator = res.body[Symbol.asyncIterator]();
+  const onAbort = () => void iterator.return?.();
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort);
+  try {
+    for (; ; ) {
+      const step = await iterator.next();
+      if (step.done) break;
+      buffer += decoder.decode(step.value, { stream: true });
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0 && loopAt < 0) {
+        handle(buffer.slice(0, newline).trim());
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf("\n");
+      }
+      if (loopAt >= 0) {
+        return { text: text.slice(0, loopAt), toolCalls: [], usage, finishReason: "repetition" };
+      }
     }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    void iterator.return?.();
   }
   handle(buffer.trim());
   return {
@@ -882,12 +936,26 @@ function createProvider(options) {
         await sleep(delay, signal);
       }
       let res;
+      const idleAbort = new AbortController();
+      const forwardAbort = () => idleAbort.abort(signal?.reason);
+      if (signal?.aborted) forwardAbort();
+      else signal?.addEventListener("abort", forwardAbort);
+      const idle = httpIdleMs();
+      const headerTimer = setTimeout(() => idleAbort.abort(new Error("idle-timeout")), idle);
       try {
-        res = await doFetch(`${baseURL}${path}`, { method: "POST", headers, body: JSON.stringify(body), signal });
+        res = await doFetch(`${baseURL}${path}`, { method: "POST", headers, body: JSON.stringify(body), signal: idleAbort.signal });
       } catch (error) {
         if (signal?.aborted) throw error;
+        if (idleAbort.signal.aborted) {
+          throw new ProviderError(
+            t("The provider did not respond within {seconds}s. Check the connection, then try again.", { seconds: String(Math.round(idle / 1e3)) })
+          );
+        }
         lastError = new ProviderError(t("Cannot connect to {url}: {error}", { url: baseURL, error: error.message }));
         continue;
+      } finally {
+        clearTimeout(headerTimer);
+        signal?.removeEventListener("abort", forwardAbort);
       }
       if (res.ok) return res;
       const retryHeader = res.headers.get("retry-after");
@@ -896,7 +964,9 @@ function createProvider(options) {
         if (Number.isFinite(secs) && secs > 0 && secs <= 30) retryAfterWaitMs = Math.ceil(secs * 1e3);
       }
       const text = await res.text().catch(() => "");
-      lastError = new ProviderError(t("{status} from {url}: {message}", { status: res.status, url: baseURL, message: errorMessage(text) }), res.status);
+      const raw = t("{status} from {url}: {message}", { status: res.status, url: baseURL, message: errorMessage(text) });
+      const hint = statusHint(res.status);
+      lastError = new ProviderError(hint ? `${hint} (${raw})` : raw, res.status);
       const deterministicQuota429 = res.status === 429 && /"code"\s*:\s*"(?:luna_monthly_quota_exhausted|plan_allowance_exhausted)"/i.test(text);
       if (!retryable(res.status) || deterministicQuota429) throw lastError;
     }
@@ -937,7 +1007,7 @@ function createProvider(options) {
         );
         if ((res2.headers.get("content-type") ?? "").includes("application/json")) return readResponsesJson(res2, onThinking);
         if (!res2.body) throw new ProviderError(t("Empty response from the provider"));
-        return readResponsesStream(res2, onText, onThinking);
+        return readResponsesStream(res2, onText, onThinking, signal);
       }
       const res = await post(
         "/chat/completions",
@@ -946,7 +1016,7 @@ function createProvider(options) {
       );
       if ((res.headers.get("content-type") ?? "").includes("application/json")) return readJson(res, onText, onThinking);
       if (!res.body) throw new ProviderError(t("Empty response from the provider"));
-      return readStream(res, onText, onThinking);
+      return readStream(res, onText, onThinking, signal);
     },
     async listModels() {
       const res = await doFetch(`${baseURL}/models`, { headers });

package/dist/{chunk-Z2ELYJ5O.js → chunk-WSZF2CTU.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   MODE_ORDER
-} from "./chunk-WFZKJY3R.js";
+} from "./chunk-YYTFJUO2.js";
 import {
   REASONING_LEVELS,
   isReasoningLevel
-} from "./chunk-EAR2C6TS.js";
+} from "./chunk-XZ2TI5HV.js";
 import {
   ConfigError
-} from "./chunk-DRJSANKH.js";
+} from "./chunk-C2FUGQJX.js";
 import {
   parseLang,
   t
-} from "./chunk-XCVYR5BK.js";
+} from "./chunk-G5TG43R4.js";
 
 // src/args.ts
 import { parseArgs } from "util";
@@ -112,6 +112,7 @@ Options:
   -r, --resume                  pick a session to continue
       --allow-all               run all tools without asking for permission
       --allowed-tools <a,b>     tools allowed without asking: bash, edit, fetch
+      --fail-on-tool-error      with -p: exit 1 when any tool call fails (for CI)
   -w, --worktree <name>        run in git worktree ../<repo>.worktrees/<name> (created, or reused if it exists)
       --output-format <fmt>     text | json | stream-json for -p (machine-readable output)
       --permission-mode <mode>  default | acceptEdits | plan | allowAll
@@ -137,6 +138,9 @@ function parseCliArgs(argv) {
       continue: { type: "boolean", short: "c" },
       resume: { type: "boolean", short: "r" },
       "allow-all": { type: "boolean" },
+      command: { type: "string" },
+      args: { type: "string" },
+      "fail-on-tool-error": { type: "boolean" },
       "allowed-tools": { type: "string" },
       worktree: { type: "string", short: "w" },
       "output-format": { type: "string" },
@@ -210,6 +214,7 @@ function parseCliArgs(argv) {
     continue: !!values.continue,
     resume: !!values.resume,
     allowAll: !!values["allow-all"],
+    failOnToolError: !!values["fail-on-tool-error"],
     allowedTools: (values["allowed-tools"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
     worktree: values.worktree,
     outputFormat,
@@ -221,6 +226,8 @@ function parseCliArgs(argv) {
     logout: !!values.logout,
     subArgs: ["models", "plugins", "gh-bot", "provider", "mcp", "connect", "disconnect", "integrations", "completion", "stats", "export", "import", "pr"].includes(command) ? rest : [],
     url: values.url,
+    stdioCommand: values.command,
+    stdioArgs: values.args,
     name: values.name,
     keyEnv: values["key-env"],
     values: values.value ?? [],

package/dist/{chunk-62UTSCWF.js → chunk-X24APPXO.js}

@@ -6,7 +6,7 @@ import {
   readJsonConfig,
   removeCredential,
   writeFileAtomic
-} from "./chunk-DRJSANKH.js";
+} from "./chunk-C2FUGQJX.js";
 
 // src/providers.ts
 import { join } from "path";

package/dist/{chunk-EAR2C6TS.js → chunk-XZ2TI5HV.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   t
-} from "./chunk-XCVYR5BK.js";
+} from "./chunk-G5TG43R4.js";
 
 // src/reasoning.ts
 var REASONING_LEVELS = ["auto", "off", "low", "medium", "high", "max"];

package/dist/{chunk-HPYI7L4W.js → chunk-Y6AZGGH7.js}

@@ -2,17 +2,17 @@
 import {
   hasKey,
   providerName
-} from "./chunk-62UTSCWF.js";
+} from "./chunk-X24APPXO.js";
 import {
   createProvider
-} from "./chunk-EOJNFGOP.js";
+} from "./chunk-OOOS5RCT.js";
 import {
   PRESETS,
   readCredentials
-} from "./chunk-DRJSANKH.js";
+} from "./chunk-C2FUGQJX.js";
 import {
   t
-} from "./chunk-XCVYR5BK.js";
+} from "./chunk-G5TG43R4.js";
 
 // src/models.ts
 function order(ids) {

package/dist/{chunk-WFZKJY3R.js → chunk-YYTFJUO2.js}

@@ -94,7 +94,7 @@ var Permissions = class {
   }
   /** Rules that "[a] allow for this session" would add; undefined when it must always be asked. */
   rulesFor(req) {
-    if (requiresSensitiveToolApproval(req) && (req.kind === "read" || process.env.BC_TOOL_POLICY_ENFORCE === "true"))
+    if (requiresSensitiveToolApproval(req) && (req.kind === "read" || req.kind === "edit" || process.env.BC_TOOL_POLICY_ENFORCE === "true"))
       return void 0;
     if (req.kind === "edit") return this.editInProject(req.target) ? ["edit(project)"] : void 0;
     if (req.kind === "fetch") {
@@ -116,7 +116,8 @@ var Permissions = class {
   }
   check(req) {
     if (this.mode === "plan" && req.kind !== "read") return "deny";
-    if (req.kind === "read" && this.mode !== "allowAll" && requiresSensitiveToolApproval(req)) return "ask";
+    if ((req.kind === "read" || req.kind === "edit") && this.mode !== "allowAll" && requiresSensitiveToolApproval(req))
+      return "ask";
     if (process.env.BC_TOOL_POLICY_ENFORCE === "true" && requiresSensitiveToolApproval(req)) return "ask";
     if (req.kind === "read") return "allow";
     if (this.mode === "allowAll") return "allow";