@botconnector/bccli 0.4.0 → 0.4.2

package/dist/cli.js

@@ -1,48 +1,49 @@
 #!/usr/bin/env node
 import {
+  resolvePrintPrompt,
   resolveWorktree,
   runPrint
-} from "./chunk-TLPFQIS2.js";
+} from "./chunk-C64KM37J.js";
 import {
   createRuntime
-} from "./chunk-TVALKHFB.js";
-import "./chunk-QZKLZELZ.js";
-import "./chunk-M7CALSP3.js";
-import "./chunk-45SDLMTV.js";
+} from "./chunk-R72OV7RF.js";
+import "./chunk-OK2USAXX.js";
+import "./chunk-ZEPTUKNW.js";
+import "./chunk-JXM6REER.js";
 import "./chunk-PSO7R5AD.js";
 import {
   VERSION
-} from "./chunk-6M5X2KZE.js";
+} from "./chunk-266SY3MC.js";
 import {
   helpText,
   parseCliArgs
-} from "./chunk-KEMYIGCP.js";
-import "./chunk-O7M3TGIW.js";
-import "./chunk-JL5ZCSP2.js";
-import "./chunk-XBO5GACQ.js";
+} from "./chunk-6UO5GX55.js";
+import "./chunk-WFZKJY3R.js";
+import "./chunk-H7XJDKJY.js";
+import "./chunk-IYR5PYA3.js";
 import {
   readGlobalConfigFile
-} from "./chunk-SPRNLS7K.js";
+} from "./chunk-HQW4BROS.js";
 import {
   defaultLoginDeps,
   runLogin
-} from "./chunk-BNA74HPN.js";
-import "./chunk-7F3IWBPQ.js";
+} from "./chunk-TIMSYZIR.js";
+import "./chunk-3I5BW3ZT.js";
 import {
   pruneSessions
-} from "./chunk-QDQU6VY2.js";
-import "./chunk-PUN4HMAG.js";
-import "./chunk-BLOYFIAD.js";
-import "./chunk-L7QI6JN2.js";
+} from "./chunk-SVD4LHJC.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
+import "./chunk-6M55UPES.js";
 import {
   ConfigError,
   setTheme
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   resolveLanguage,
   setLanguage,
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/exit.ts
 var EXIT_GRACE_MS = 1e3;
@@ -84,17 +85,17 @@ async function main() {
   if (args.worktree) cwd = (await resolveWorktree(cwd, args.worktree)).path;
   if (args.command === "login") return runLogin(args.loginProvider ?? "bc-cloud", cwd, args, defaultLoginDeps());
   if (args.command === "mcp") {
-    const { runMcpCommand } = await import("./mcpCli-QUV5SD64.js");
-    const { readSecret } = await import("./login-SYIQP46J.js");
+    const { runMcpCommand } = await import("./mcpCli-SETTCL3K.js");
+    const { readSecret } = await import("./login-RYESFZG6.js");
     return runMcpCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "provider") {
-    const { runProviderCommand } = await import("./providerCli-FAOZHOKW.js");
-    const { readSecret } = await import("./login-SYIQP46J.js");
+    const { runProviderCommand } = await import("./providerCli-5OZI2GQQ.js");
+    const { readSecret } = await import("./login-RYESFZG6.js");
     return runProviderCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), readSecret });
   }
   if (args.command === "connect" || args.command === "disconnect" || args.command === "integrations") {
-    const { runIntegrationCommand } = await import("./integrationCli-P75R2VSC.js");
+    const { runIntegrationCommand } = await import("./integrationCli-HXCSEWH2.js");
     return runIntegrationCommand(args, {
       env: process.env,
       cwd,
@@ -104,23 +105,22 @@ async function main() {
     });
   }
   if (args.command === "models") {
-    const { runModelsCommand } = await import("./modelsCli-TRRB5LX4.js");
+    const { runModelsCommand } = await import("./modelsCli-OP7CDZC7.js");
     return runModelsCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s), fetch: globalThis.fetch });
   }
   if (args.command === "update") {
-    const { runUpdateCommand } = await import("./update-K5IQ2MYR.js");
+    const { runUpdateCommand } = await import("./update-FSS7X5WV.js");
     return runUpdateCommand({ env: process.env });
   }
   if (args.command === "acp") {
-    const { runtimeAgent, runAcp } = await import("./acp-ATIL4JOZ.js");
+    const { runtimeAgent, runAcp } = await import("./acp-UYC6APR5.js");
     await runAcp(process.stdin, process.stdout, { cwd, newAgent: (c) => runtimeAgent(c, args.allowAll) });
     return 0;
   }
   if (args.command === "serve") {
-    const { startServe } = await import("./serve-JG7RLIUD.js");
+    const { serveBanner, startServe } = await import("./serve-4J7HA4JO.js");
     const handle = await startServe({ port: args.port, host: args.host, token: args.token, cwd, env: process.env });
-    process.stderr.write(`bccli serve ${handle.url} \u2014 Authorization: Bearer ${handle.token}
-`);
+    process.stderr.write(serveBanner(handle, { token: args.token }));
     await new Promise((resolve) => {
       const stop = () => {
         void handle.close().finally(resolve);
@@ -131,8 +131,8 @@ async function main() {
     return 0;
   }
   if (args.command === "plugins") {
-    const { runPluginsCommand } = await import("./pluginsCli-GNW4TPVV.js");
-    const { readGlobalPlugins, updateGlobalConfig } = await import("./config-RZ5JONMX.js");
+    const { runPluginsCommand } = await import("./pluginsCli-ZQNKWZHJ.js");
+    const { readGlobalPlugins, updateGlobalConfig } = await import("./config-LAINORU5.js");
     const { runNpmSync } = await import("./npmRunner-LU43GM3W.js");
     return runPluginsCommand(args, {
       out: (s) => console.log(s),
@@ -146,32 +146,41 @@ async function main() {
     });
   }
   if (args.command === "gh-bot") {
-    const { runGhBotCommand } = await import("./ghBotCli-IBCZIWT5.js");
+    const { runGhBotCommand } = await import("./ghBotCli-TSLRORJJ.js");
     return runGhBotCommand(args, { env: process.env, cwd, out: (s) => console.log(s), err: (s) => console.error(s) });
   }
   if (args.command === "completion") {
-    const { runCompletionCommand } = await import("./completion-HPPFDAPB.js");
+    const { runCompletionCommand } = await import("./completion-D2BSBTQO.js");
     return runCompletionCommand(args, { out: (s) => console.log(s), err: (s) => console.error(s) });
   }
   if (args.command === "stats") {
-    const { runStatsCommand } = await import("./statsCli-CF3R7ATL.js");
-    const { bccliHome } = await import("./config-RZ5JONMX.js");
+    const { runStatsCommand } = await import("./statsCli-XR6BEZQQ.js");
+    const { bccliHome } = await import("./config-LAINORU5.js");
     return runStatsCommand(
       { subArgs: args.subArgs, home: bccliHome(process.env), cwd, days: args.days, tools: args.tools, models: args.models, project: args.project },
       { out: (s) => console.log(s), err: (s) => console.error(s) }
     );
   }
   if (args.command === "export" || args.command === "import") {
-    const { runExportCommand, runImportCommand } = await import("./transferCli-TK2GSVRK.js");
-    const { bccliHome } = await import("./config-RZ5JONMX.js");
+    const { runExportCommand, runImportCommand } = await import("./transferCli-R2KEIWQR.js");
+    const { bccliHome } = await import("./config-LAINORU5.js");
     const deps = { subArgs: args.subArgs, home: bccliHome(process.env), cwd };
     const io = { out: (s) => console.log(s), err: (s) => console.error(s) };
     return args.command === "export" ? runExportCommand(deps, io) : runImportCommand(deps, io);
   }
   if (args.command === "pr") {
-    const { runPrCommand } = await import("./prCli-5IMV3VNQ.js");
+    const { runPrCommand } = await import("./prCli-6PUWTMTP.js");
     return runPrCommand(
-      { subArgs: args.subArgs, cwd, allowAll: args.allowAll },
+      {
+        subArgs: args.subArgs,
+        cwd,
+        allowAll: args.allowAll,
+        repo: args.repo,
+        model: args.model,
+        reasoning: args.reasoning,
+        permissionMode: args.permissionMode,
+        allowedTools: args.allowedTools
+      },
       { out: (s) => console.log(s), err: (s) => console.error(s) }
     );
   }
@@ -182,15 +191,22 @@ async function main() {
   } catch {
   }
   if (args.print) {
-    if (!args.prompt) throw new ConfigError(t('-p mode needs a task, e.g. bccli -p "explain this repo"'));
-    const { serversToStart } = await import("./config-COPNMMV6.js");
+    let stdinText;
+    if (!process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+      if (chunks.length) stdinText = Buffer.concat(chunks).toString("utf8");
+    }
+    const finalPrompt = resolvePrintPrompt(args.prompt, stdinText);
+    if (!finalPrompt) throw new ConfigError(t('-p mode needs a task, e.g. bccli -p "explain this repo"'));
+    const { serversToStart } = await import("./config-ENDRMOTP.js");
     const plan = serversToStart(rt.home, cwd);
     for (const s of plan.needTrust) {
       console.error(t('Project MCP server "{name}" skipped (not approved yet; run interactive bccli once to approve it).', { name: s.name }));
     }
     await rt.startMcp(plan.start);
     try {
-      return await runPrint(rt, args.prompt, void 0, { allowAll: args.allowAll, outputFormat: args.outputFormat });
+      return await runPrint(rt, finalPrompt, void 0, { allowAll: args.allowAll, outputFormat: args.outputFormat });
     } finally {
       await rt.mcp.stop();
     }
@@ -199,13 +215,13 @@ async function main() {
   let updateMessage;
   if (rt.config.updateCheck !== "off" && !process.env.BCCLI_NO_UPDATE_CHECK) {
     try {
-      const { checkForUpdate } = await import("./update-K5IQ2MYR.js");
+      const { checkForUpdate } = await import("./update-FSS7X5WV.js");
       const update = await checkForUpdate({ home: rt.home, fetch: globalThis.fetch, now: /* @__PURE__ */ new Date() });
       updateMessage = update;
     } catch {
     }
   }
-  const { startInteractive } = await import("./ui-B3CJ6TGE.js");
+  const { startInteractive } = await import("./ui-36ZEK65V.js");
   return startInteractive(rt, { initialPrompt: args.prompt, resume: args.resume, version: VERSION, updateMessage });
 }
 main().then(

package/dist/clipboardImage.d.ts

@@ -0,0 +1,17 @@
+export interface GrabDeps {
+    platform: NodeJS.Platform;
+    tmpdir: string;
+    now: Date;
+    run?(cmd: string, args: string[]): Promise<{
+        code: number;
+        output: string;
+    }>;
+}
+export declare function clipboardTarget(tmpdir: string, now: Date): string;
+/** Terminals cannot transmit images, so each platform's clipboard tool saves a PNG we can point the model at. */
+export declare function clipboardCommand(platform: NodeJS.Platform, target: string): {
+    cmd: string;
+    args: string[];
+} | undefined;
+/** Returns the saved PNG path, or undefined when the clipboard holds no image / the platform is unsupported. */
+export declare function grabClipboardImage(deps: GrabDeps): Promise<string | undefined>;

package/dist/commands.d.ts

@@ -0,0 +1,16 @@
+import type { CommandDef } from './extensions';
+/** Descriptions are English keys; wrap them in t() when showing them. */
+export declare const SLASH_COMMANDS: {
+    name: string;
+    description: string;
+}[];
+export declare function parseSlash(text: string): {
+    name: string;
+    args: string;
+} | undefined;
+export declare function expandCommand(def: CommandDef, args: string): string;
+/**
+ * /pr: the model runs gh itself (installed on PATH), so this is a prompt, not a fetch.
+ * Empty selector = the PR of the current branch, falling back to a branch diff.
+ */
+export declare function prReviewPrompt(selector: string): string;

package/dist/{completion-HPPFDAPB.js → completion-D2BSBTQO.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/completion.ts
 var SHELLS = ["bash", "zsh", "fish", "powershell"];

package/dist/completion.d.ts

@@ -0,0 +1,14 @@
+import type { CliArgs } from './args';
+export declare const SHELLS: readonly ['bash', 'zsh', 'fish', 'powershell'];
+export type CompletionShell = (typeof SHELLS)[number];
+export declare function isCompletionShell(value: string): value is CompletionShell;
+/** Completion script for a supported shell (bash, zsh, fish, powershell). */
+export declare function completionScript(shell: CompletionShell): string;
+export interface CompletionDeps {
+    out(line: string): void;
+    err?(line: string): void;
+}
+/**
+ * `bccli completion <bash|zsh|fish|powershell>` — print a completion script to stdout.
+ */
+export declare function runCompletionCommand(args: Pick<CliArgs, 'subArgs'>, deps: CompletionDeps): number;

package/dist/{config-COPNMMV6.js → config-ENDRMOTP.js}

@@ -9,9 +9,9 @@ import {
   removeGlobalServer,
   serversToStart,
   setProjectTrust
-} from "./chunk-L7QI6JN2.js";
-import "./chunk-LACUWBWS.js";
-import "./chunk-UZWJQF67.js";
+} from "./chunk-6M55UPES.js";
+import "./chunk-RX4UQX43.js";
+import "./chunk-3WHI4LN3.js";
 export {
   addGlobalServer,
   expandEnvVars,

package/dist/{config-RZ5JONMX.js → config-LAINORU5.js}

@@ -5,26 +5,30 @@ import {
   bccliHome,
   globalConfigPath,
   loadConfig,
+  quarantineCorruptFile,
   readCredentials,
   readGlobalPlugins,
   readJsonConfig,
   removeCredential,
   resolveModel,
   saveCredential,
-  updateGlobalConfig
-} from "./chunk-LACUWBWS.js";
-import "./chunk-UZWJQF67.js";
+  updateGlobalConfig,
+  writeFileAtomic
+} from "./chunk-RX4UQX43.js";
+import "./chunk-3WHI4LN3.js";
 export {
   ConfigError,
   DEFAULT_MAX_STEPS,
   bccliHome,
   globalConfigPath,
   loadConfig,
+  quarantineCorruptFile,
   readCredentials,
   readGlobalPlugins,
   readJsonConfig,
   removeCredential,
   resolveModel,
   saveCredential,
-  updateGlobalConfig
+  updateGlobalConfig,
+  writeFileAtomic
 };

package/dist/config.d.ts

@@ -0,0 +1,99 @@
+import type { ReasoningLevel } from './reasoning';
+import type { HooksConfig } from './hooks';
+import { type Keybind, type KeybindAction } from './keybinds';
+import type { LspServer } from './lsp';
+import type { UsageCap } from './budget';
+import type { Lang } from './i18n';
+export type PermissionMode = 'default' | 'acceptEdits' | 'plan' | 'allowAll';
+export interface ProviderConfig {
+    baseURL: string;
+    apiKeyEnv?: string;
+    name?: string;
+}
+export interface Config {
+    model: string;
+    /** Optional list of fallback model refs tried in order on 429 / 5xx / connection errors. */
+    fallbackModels?: string[];
+    permissionMode: PermissionMode;
+    reasoning: ReasoningLevel;
+    /** Show provider-supplied reasoning summaries in the TUI. Global setting only. */
+    thinkingVisible?: boolean;
+    /** Delete saved sessions older than this many days at startup. Omitted, null or 0 keeps them until you delete them (the default). Global setting only. */
+    sessionRetentionDays?: number | null;
+    /** Click the Thinking block to expand/collapse it. Off by default: it needs terminal mouse reporting, which blocks drag-to-copy. Global setting only; ctrl+t works either way. */
+    thinkingClickCollapse?: boolean;
+    /** Tool-call step cap per turn. Omitted, null or 0 means unlimited (the default); a positive number opts into a cap. */
+    maxSteps?: number | null;
+    /** Interface language; only the global config is read for it. */
+    language?: Lang;
+    /** Tool/session hooks; only the global config is read — the project file is untrusted and must never execute code. */
+    hooks?: HooksConfig;
+    /** Attach images read from disk as vision parts. Only the global config is read; default true. */
+    vision?: boolean;
+    /** Bash network gate: "offline" blocks known internet commands. Only the global config is read. */
+    networkPolicy?: 'allow' | 'offline';
+    /** JS plugin specs, loaded at boot. Only the global config is read — the project file must never execute code. */
+    plugins?: string[];
+    /** Resolved TUI key bindings; only the global config is read (a cloned project must not rebind your keys). */
+    keybinds: Record<KeybindAction, Keybind>;
+    /** Commands run after a turn that edited files (aider --test-cmd style). Only the global config is read. */
+    verifyCommands: string[];
+    /** Per-session token/USD budget; the agent stops calling the model once it is exceeded. Only the global config is read. */
+    usageCap?: UsageCap;
+    /** Daily npm registry check with a notice when a newer bccli exists. Only the global config is read; default "on". */
+    updateCheck?: 'on' | 'off';
+    /** Include a repo map (files + top-level symbols) in the system prompt. Only the global config is read; default false. */
+    repoMap: boolean;
+    /** Color theme name. Only the global config is read; default "default". */
+    theme: string;
+    /** Prompt editing style. Only the global config is read; default "emacs". */
+    editor: 'emacs' | 'vim';
+    /** Run bash commands inside the OS sandbox (macOS sandbox-exec / Linux bwrap). Only the global config is read; default "off". */
+    sandbox: 'off' | 'on';
+    /** LSP servers used by the diagnostics tool. Only the global config is read (it spawns commands). */
+    lsp?: {
+        servers: LspServer[];
+    };
+    providers: Record<string, ProviderConfig>;
+    allow: string[];
+    /** Provider ids that came from the (untrusted) project config. */
+    projectProviders?: string[];
+}
+export interface ResolvedModel {
+    providerId: string;
+    model: string;
+    baseURL: string;
+    apiKey?: string;
+}
+export declare class ConfigError extends Error {
+}
+/**
+ * Default cap on tool-call steps per turn for the main agent: none, like Claude Code, Codex and
+ * OpenCode (its `steps` is unset = unlimited). The turn runs until the model stops or the user
+ * presses Esc. Set maxSteps in the global config to a positive number to opt into a safety cap
+ * (the "type continue" notice then appears when it is reached).
+ */
+export declare const DEFAULT_MAX_STEPS: number | null;
+export declare function bccliHome(env?: NodeJS.ProcessEnv): string;
+export declare function readJsonConfig(path: string): Partial<Config>;
+export declare function loadConfig(cwd: string, env?: NodeJS.ProcessEnv): Config;
+export declare function globalConfigPath(env?: NodeJS.ProcessEnv): string;
+export declare function readGlobalPlugins(env?: NodeJS.ProcessEnv): string[];
+export declare function writeFileAtomic(path: string, data: string, mode?: number): void;
+/**
+ * A corrupt JSON file must never be silently treated as empty: the next write would
+ * wipe whatever the user had. Move it aside in place (timestamped, same folder) so
+ * the data stays recoverable, and warn on stderr. Returns the backup path.
+ */
+export declare function quarantineCorruptFile(path: string, error: unknown): string | undefined;
+/**
+ * Read-modify-write of the global config.json. `mutate` throwing aborts before
+ * any write; the write itself is atomic (tmp + rename in the same directory),
+ * so a failed run never leaves a truncated or half-updated config.
+ */
+export declare function updateGlobalConfig(env: NodeJS.ProcessEnv, mutate: (cfg: Record<string, unknown>) => void): void;
+export declare function readCredentials(env?: NodeJS.ProcessEnv): Record<string, string>;
+export declare function saveCredential(providerId: string, key: string, env?: NodeJS.ProcessEnv): void;
+export declare function resolveModel(config: Config, modelRef: string, env?: NodeJS.ProcessEnv): ResolvedModel;
+/** Returns false when there was no stored key to remove. */
+export declare function removeCredential(providerId: string, env?: NodeJS.ProcessEnv): boolean;

package/dist/context.d.ts

@@ -0,0 +1,13 @@
+import type { SkillDef } from './extensions';
+/** Instruction files in load order: global BCCLI.md, then AGENTS.md/BCCLI.md from the filesystem root down to cwd. */
+export declare function instructionPaths(cwd: string, home: string): string[];
+export declare function loadInstructions(cwd: string, home: string): string;
+export declare function buildSystemPrompt(opts: {
+    cwd: string;
+    home: string;
+    model: string;
+    date?: string;
+    platform?: string;
+    skills?: SkillDef[];
+    repoMap?: string;
+}): string;

package/dist/contextWindow.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_CONTEXT_WINDOW = 128000;
+/** Resolves the context window for a `provider/model` ref; `BCCLI_CONTEXT_WINDOW` overrides everything. */
+export declare function contextWindowFor(modelRef: string, env?: NodeJS.ProcessEnv): number;

package/dist/diff.d.ts

@@ -0,0 +1,7 @@
+export interface DiffLine {
+    kind: 'add' | 'del' | 'ctx';
+    line: number;
+    text: string;
+}
+export declare function diffLines(oldText: string, newText: string): DiffLine[];
+export declare function formatDiff(lines: DiffLine[]): string;

package/dist/exit.d.ts

@@ -0,0 +1,9 @@
+export declare const EXIT_GRACE_MS = 1000;
+export interface ExitDeps {
+    setExitCode: (code: number) => void;
+    exit: (code: number) => void;
+    setTimer: (fn: () => void, ms: number) => {
+        unref: () => void;
+    };
+}
+export declare function settleExit(code: number, deps?: Partial<ExitDeps>): void;

package/dist/extensions.d.ts

@@ -0,0 +1,34 @@
+export interface SkillDef {
+    name: string;
+    description: string;
+    dir: string;
+    file: string;
+}
+export interface CommandDef {
+    name: string;
+    description?: string;
+    argumentHint?: string;
+    body: string;
+}
+export interface AgentDef {
+    name: string;
+    description: string;
+    tools?: string[];
+    model?: string;
+    prompt: string;
+    maxSteps?: number;
+    /** Run this agent concurrently with sibling task calls even when its tools can write. */
+    parallel?: boolean;
+}
+export interface ExtensionRoots {
+    cwd: string;
+    home: string;
+    userHome: string;
+}
+export declare function parseFrontmatter(text: string): {
+    data: Record<string, string | string[]>;
+    body: string;
+};
+export declare function loadSkills(r: ExtensionRoots): SkillDef[];
+export declare function loadCommands(r: ExtensionRoots): CommandDef[];
+export declare function loadAgentDefs(r: ExtensionRoots): AgentDef[];

package/dist/{ghBotCli-IBCZIWT5.js → ghBotCli-TSLRORJJ.js}

@@ -1,32 +1,32 @@
 #!/usr/bin/env node
 import {
   createRuntime
-} from "./chunk-TVALKHFB.js";
-import "./chunk-QZKLZELZ.js";
-import "./chunk-M7CALSP3.js";
-import "./chunk-45SDLMTV.js";
+} from "./chunk-R72OV7RF.js";
+import "./chunk-OK2USAXX.js";
+import "./chunk-ZEPTUKNW.js";
+import "./chunk-JXM6REER.js";
 import "./chunk-PSO7R5AD.js";
 import {
   LOOPBACK_BIND,
   parseCliArgs
-} from "./chunk-KEMYIGCP.js";
-import "./chunk-O7M3TGIW.js";
-import "./chunk-JL5ZCSP2.js";
-import "./chunk-XBO5GACQ.js";
-import "./chunk-SPRNLS7K.js";
-import "./chunk-7F3IWBPQ.js";
-import "./chunk-QDQU6VY2.js";
-import "./chunk-PUN4HMAG.js";
-import "./chunk-BLOYFIAD.js";
-import "./chunk-L7QI6JN2.js";
+} from "./chunk-6UO5GX55.js";
+import "./chunk-WFZKJY3R.js";
+import "./chunk-H7XJDKJY.js";
+import "./chunk-IYR5PYA3.js";
+import "./chunk-HQW4BROS.js";
+import "./chunk-3I5BW3ZT.js";
+import "./chunk-SVD4LHJC.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
+import "./chunk-6M55UPES.js";
 import {
   ConfigError,
   globalConfigPath,
   readJsonConfig
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/ghBotWebhook.ts
 import { createHmac, timingSafeEqual } from "crypto";
@@ -435,16 +435,17 @@ async function collectGhContext(d, deps) {
 ## diff (truncated)
 ${truncateHeadTailUtf8(diffRes.stdout, 1e5)}`;
   }
-  const comment = truncateUtf8Bytes(d.body, 8192);
+  const sanitizeUntrusted = (s) => s.replace(/<\/untrusted-github>/gi, "&lt;/untrusted-github&gt;");
+  const comment = sanitizeUntrusted(truncateUtf8Bytes(d.body, 8192));
   const context = [
     "<untrusted-github>",
     `## Comment by ${d.author} (${d.repo}#${d.number})`,
     comment,
     "",
-    `## Issue/PR title: ${title}`,
+    `## Issue/PR title: ${sanitizeUntrusted(title)}`,
     "## Issue/PR body",
-    issueBody,
-    diffBlock,
+    sanitizeUntrusted(issueBody),
+    sanitizeUntrusted(diffBlock),
     "</untrusted-github>",
     "",
     "Draft your reply to the comment above following your system rules."

package/dist/ghBotCli.d.ts

@@ -0,0 +1,9 @@
+import type { CliArgs } from './args';
+export interface GhBotCliDeps {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out(s?: string): void;
+    err(s?: string): void;
+}
+/** `bccli gh-bot [serve]` — off-by-default; secret dari env accessor per-request. */
+export declare function runGhBotCommand(args: CliArgs, deps: GhBotCliDeps): Promise<number>;

package/dist/ghBotDispatch.d.ts

@@ -0,0 +1,68 @@
+import type { CommentDelivery } from './ghBotWebhook';
+export interface GhBotConfig {
+    enabled: boolean;
+    path: string;
+    secretEnv: string;
+    repos: string[];
+    users: string[];
+    maxBodyBytes: number;
+    maxActive: number;
+    maxQueue: number;
+    stepLimit: number;
+    timeoutMs: number;
+    /** Kapasitas completed-LRU (opsional; default 1000) — dipakai test utk memperkecil. */
+    dedupCap?: number;
+}
+/** Validasi ketat + default aman (off-by-default). */
+export declare function ghBotConfigFrom(raw: unknown): GhBotConfig;
+export type AcceptResult = 'queued' | 'dedup' | 'inflight' | 'filtered' | 'full' | 'closed';
+export interface GhBotHubDeps {
+    out(s: string): void;
+    err(s: string): void;
+    /** SATU signal (deadline ∪ close) diteruskan ke collect+draft+post. */
+    runJob(d: CommentDelivery, signal: AbortSignal): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+}
+export interface CloseSummary {
+    aborted: number;
+    terminationConfirmed: number;
+    terminationUnconfirmed: number;
+}
+/**
+ * Admission atomik (spec §4): filter → cek duplikat (inFlight/LRU) → cek kapasitas →
+ * reservasi dalam satu blok sinkron. `full` TIDAK menyimpan dedup. Worker membersihkan
+ * active/inFlight di finally pada resolve MAUPUN reject (dibungkus Promise.resolve().then
+ * agar throw sinkron pun masuk jalur catch). Job gagal tidak masuk completed-LRU.
+ */
+export declare class GhBotHub {
+    private readonly cfg;
+    private readonly deps;
+    private readonly inFlight;
+    private readonly completed;
+    private readonly completedOrder;
+    private readonly queue;
+    private active;
+    private closed;
+    private closing;
+    private readonly closeController;
+    private readonly closeReasons;
+    private readonly idleWaiters;
+    private readonly dedupCap;
+    /** Akumulasi SEMUA job (di/di luar close) — §9.19: unconfirmed terhitung walau gagal sebelum close. */
+    private unconfirmedTotal;
+    constructor(cfg: GhBotConfig, deps: GhBotHubDeps);
+    accept(delivery: CommentDelivery): AcceptResult;
+    private pump;
+    private pushCompleted;
+    private maybeIdle;
+    whenIdle(): Promise<void>;
+    close(): Promise<CloseSummary>;
+    stats(): {
+        queued: number;
+        active: number;
+        inflight: number;
+        completed: number;
+    };
+}