@botconnector/bccli 0.4.0 → 0.4.2

package/dist/ghBotRunner.d.ts

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+import type { AgentEvent } from './agent';
+import { type CommentDelivery } from './ghBotWebhook';
+export interface GhDeps {
+    /** ASYNC (spawn, bukan spawnSync), argv array tanpa shell; stdin opsional utk `--input -`
+     *  (EPIPE ditangani); signal → child di-kill; settle sekali via close/error. */
+    spawn(argv: string[], opts?: {
+        signal?: AbortSignal;
+        stdin?: string;
+    }): Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+/** Instruksi draf — system prompt murni (tanpa data konteks). */
+export declare function ghSystemPrompt(): string;
+export interface CreateGhSpawnOptions {
+    spawnImpl?: typeof spawn;
+    killGraceMs?: number;
+    hardMs?: number;
+}
+/**
+ * Spawn async dgn settle HANYA dari `close` (KECUALI hard-timeout force-settle),
+ * eskalasi `kill('SIGKILL')` eksplisit, marker SELALU ikut di hard-timeout, dan
+ * cleanup listener/pipe di settle (data telat aman). Lihat spec §6.4.
+ */
+export declare function createGhSpawn(cmd?: string, o?: CreateGhSpawnOptions): GhDeps['spawn'];
+/**
+ * Konteks di-pra-kumpulkan: selalu issue view; bila isPR → pr view + pr diff.
+ * SEMUA gh command membawa --repo dari delivery tervalidasi (tanpa cwd).
+ * Data masuk blok <untrusted-github>; komentar 8KB, issue body 64KB, diff 100KB (byte UTF-8).
+ */
+export declare function collectGhContext(d: CommentDelivery, deps: {
+    gh: GhDeps;
+    signal: AbortSignal;
+}): Promise<{
+    ok: true;
+    context: string;
+} | {
+    ok: false;
+    reason: string;
+}>;
+export type DraftStopReason = 'done' | 'aborted' | 'stepLimit' | 'budgetExceeded' | 'error' | 'none';
+/** Kolektor event agent: text append; textReplace MENGGANTI; stopReason = event terminal terakhir. */
+export declare function createDraftCollector(): {
+    onEvent(e: AgentEvent): void;
+    result(): {
+        text: string;
+        stopReason: DraftStopReason;
+    };
+};
+/**
+ * Sukses HANYA stopReason 'done' + teks non-kosong; selain itu gagal (tanpa post).
+ * dispose SELALU di finally.
+ */
+export declare function runDraft(context: string, signal: AbortSignal, deps: {
+    createAgent(): {
+        run(prompt: string, signal: AbortSignal): Promise<{
+            text: string;
+            stopReason: DraftStopReason;
+        }>;
+        dispose(): Promise<void> | void;
+    };
+    system: string;
+}): Promise<{
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    reason: string;
+}>;
+/** Post komentar via stdin JSON — hasil TERSTRUKTUR (koreksi review #1). */
+export declare function postReply(d: CommentDelivery, text: string, deps: {
+    gh: GhDeps;
+    signal: AbortSignal;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+}>;

package/dist/ghBotServe.d.ts

@@ -0,0 +1,21 @@
+import { type GhBotConfig, type CloseSummary } from './ghBotDispatch';
+import type { Provider } from './provider';
+import { type GhDeps } from './ghBotRunner';
+export interface GhBotServeOptions {
+    port?: number;
+    host?: string;
+    config: GhBotConfig;
+    /** Aksesor per-request (rotasi secret tanpa restart — spec §3). */
+    getSecret: () => string | undefined;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    fetch?: typeof globalThis.fetch;
+    gh?: GhDeps;
+    out?: (s?: string) => void;
+    err?: (s?: string) => void;
+}
+export interface GhBotHandle {
+    port: number;
+    close(): Promise<CloseSummary>;
+}
+export declare function startGhBot(opts: GhBotServeOptions): Promise<GhBotHandle>;

package/dist/ghBotWebhook.d.ts

@@ -0,0 +1,45 @@
+/** Header wajib GitHub webhook delivery. */
+export declare const GITHUB_HEADERS: readonly ['x-hub-signature-256', 'x-hub-delivery', 'x-hub-event'];
+export interface CommentDelivery {
+    delivery: string;
+    event: string;
+    action: string;
+    repo: string;
+    number: number;
+    isPR: boolean;
+    author: string;
+    authorType: string;
+    body: string;
+}
+export type VerifyOutcome = {
+    ok: true;
+    delivery: CommentDelivery;
+} | {
+    ok: false;
+    status: 400 | 401 | 405 | 413 | 415 | 503;
+    message: string;
+};
+/** 'sha256=<hex>' atas byte mentah — dipakai verifikasi dan fixture test. */
+export declare function signBody(rawBody: Buffer, secret: string): string;
+declare const HARD_TIMEOUT_MARKER = "<child did not close after termination>";
+export { HARD_TIMEOUT_MARKER };
+/**
+ * Urutan persis spec §3: method → content-type → size (byte) → header wajib →
+ * secret (aksesor per-request) → HMAC atas Buffer MENTAH → decode UTF-8 fatal →
+ * parse → tipe-guard field event. HMAC selalu sebelum decode/parse.
+ */
+export declare function verifyAndParse(rawBody: Buffer, headers: Record<string, string | undefined>, opts: {
+    method: string;
+    contentType: string | undefined;
+    maxBodyBytes: number;
+    getSecret: () => string | undefined;
+}, jsonParse?: (text: string) => unknown): VerifyOutcome;
+/**
+ * '/bccli <task>' → task trim; '/bccli' tanpa task → null (tanpa balasan);
+ * prefix lain / komentar biasa → null.
+ */
+export declare function extractCommand(body: string): string | null;
+/** Potong di batas code point dengan budget byte UTF-8 — tak pernah membelah karakter. */
+export declare function truncateUtf8Bytes(text: string, maxBytes: number, marker?: string): string;
+/** 60% kepala + 40% ekor dalam SATU budget byte, dengan marker di tengah. */
+export declare function truncateHeadTailUtf8(text: string, maxBytes: number, marker?: string): string;

package/dist/hooks.d.ts

@@ -0,0 +1,27 @@
+export type HookEvent = 'PreToolUse' | 'PostToolUse' | 'SessionStart' | 'Stop';
+export interface HookRule {
+    /** Glob over the tool name ('*' matches everything, omitted = every tool). Tool events only. */
+    match?: string;
+    command: string;
+}
+export type HooksConfig = Partial<Record<HookEvent, HookRule[]>>;
+export interface HookOutcome {
+    /** PreToolUse only: the tool call is denied with this message instead of running. */
+    blocked?: string;
+    warnings: string[];
+}
+export interface HookRunOptions {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    timeoutMs?: number;
+}
+/**
+ * Runs the configured hooks for one event, in order. A PreToolUse hook that exits
+ * with code 2 blocks the tool call (Claude Code semantics); any other failure is a
+ * non-blocking warning. Hooks receive BCCLI_HOOK_EVENT/TOOL/INPUT/OUTPUT env vars.
+ */
+export declare function runHooks(hooks: HooksConfig | undefined, event: HookEvent, payload?: {
+    tool?: string;
+    input?: unknown;
+    output?: string;
+}, opts?: HookRunOptions): Promise<HookOutcome>;

package/dist/i18n/id.d.ts

@@ -0,0 +1 @@
+export declare const ID: Record<string, string>;

package/dist/i18n.d.ts

@@ -0,0 +1,16 @@
+export type Lang = 'en' | 'id';
+export declare const LANGS: readonly Lang[];
+export declare function parseLang(value: string | undefined): Lang | undefined;
+export declare function setLanguage(lang: Lang): void;
+export declare function getLanguage(): Lang;
+/** Locale for dates and numbers, matching the UI language. */
+export declare const locale: () => string;
+/**
+ * User-facing text. The English sentence is the key; Indonesian lives in i18n/id.ts.
+ * Placeholders are `{name}`. Text the model reads (tool results, prompts) is plain English and does not go through here.
+ */
+export declare function t(en: string, params?: Record<string, string | number>): string;
+/** `--lang x` or `--lang=x` from raw argv, so even argument errors can be shown in the right language. */
+export declare function langFromArgv(argv: string[]): Lang | undefined;
+/** --lang, then BCCLI_LANG, then the `language` of the global config, then English. */
+export declare function resolveLanguage(argv: string[], env: NodeJS.ProcessEnv, fromConfig?: string): Lang;

package/dist/{integrationCli-P75R2VSC.js → integrationCli-HXCSEWH2.js}

@@ -5,10 +5,10 @@ import {
   loadConfig,
   readCredentials,
   resolveModel
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/integrationCli.ts
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";

package/dist/integrationCli.d.ts

@@ -0,0 +1,9 @@
+import type { CliArgs } from './args';
+export interface IntegrationDeps {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out: (s: string) => void;
+    err: (s: string) => void;
+    fetch: typeof globalThis.fetch;
+}
+export declare function runIntegrationCommand(args: CliArgs, deps: IntegrationDeps): Promise<number>;

package/dist/keybinds.d.ts

@@ -0,0 +1,22 @@
+export type KeybindAction = 'thinking' | 'toolOutput' | 'pasteImage';
+export declare const KEYBIND_ACTIONS: KeybindAction[];
+export declare const DEFAULT_KEYBINDS: Record<KeybindAction, string>;
+export declare function defaultKeybinds(): Record<KeybindAction, Keybind>;
+export interface Keybind {
+    /** The normalized spec, for display in notices and /help. */
+    spec: string;
+    ctrl: boolean;
+    meta: boolean;
+    /** Lowercase single letter. */
+    key: string;
+}
+/**
+ * Parses "ctrl+t" / "alt+x" / "ctrl+alt+o". A modifier is required: a bare letter
+ * would fire while the user types. Returns undefined for anything else so the
+ * caller can produce a localized ConfigError.
+ */
+export declare function parseKeybind(raw: string): Keybind | undefined;
+export declare function matchKeybind(kb: Keybind, input: string, key: {
+    ctrl?: boolean;
+    meta?: boolean;
+}): boolean;

package/dist/{login-SYIQP46J.js → login-RYESFZG6.js}

@@ -4,10 +4,10 @@ import {
   readLine,
   readSecret,
   runLogin
-} from "./chunk-BNA74HPN.js";
-import "./chunk-7F3IWBPQ.js";
-import "./chunk-LACUWBWS.js";
-import "./chunk-UZWJQF67.js";
+} from "./chunk-TIMSYZIR.js";
+import "./chunk-3I5BW3ZT.js";
+import "./chunk-RX4UQX43.js";
+import "./chunk-3WHI4LN3.js";
 export {
   defaultLoginDeps,
   readLine,

package/dist/login.d.ts

@@ -0,0 +1,19 @@
+export declare function readSecret(prompt: string): Promise<string>;
+/** Prompt TANPA masking (kode otorisasi harus terlihat saat di-paste). Ctrl+C -> exit 130. */
+export declare function readLine(prompt: string): Promise<string>;
+import type { CliArgs } from './args';
+import type { ABORT } from './oauthLogin';
+export interface LoginDeps {
+    out(s: string): void;
+    err(s: string): void;
+    env: NodeJS.ProcessEnv;
+    isTTY: boolean;
+    open(url: string): void;
+    readLine(prompt: string): Promise<string | typeof ABORT>;
+    saveCredential(id: string, key: string): void;
+    removeCredential(id: string): boolean;
+    fetch: typeof fetch;
+    legacyAdd(providerId: string, cwd: string): Promise<number>;
+}
+export declare function defaultLoginDeps(): LoginDeps;
+export declare function runLogin(providerId: string, cwd: string, args: CliArgs, deps: LoginDeps): Promise<number>;

package/dist/lsp.d.ts

@@ -0,0 +1,50 @@
+export declare function languageIdFor(file: string): string;
+export declare function useShellForLsp(command: string, platform?: NodeJS.Platform): boolean;
+export interface LspServer {
+    extensions: string[];
+    command: string;
+    args?: string[];
+}
+export interface LspDiagnostic {
+    line: number;
+    character: number;
+    severity: number;
+    message: string;
+}
+interface LspRawDiagnostic {
+    range?: {
+        start?: {
+            line?: number;
+            character?: number;
+        };
+    };
+    severity?: number;
+    message?: string;
+}
+/** The JSON-RPC messages this one-shot client cares about. */
+export interface LspMessage {
+    id?: number;
+    method?: string;
+    result?: unknown;
+    params?: {
+        uri?: string;
+        diagnostics?: LspRawDiagnostic[];
+    };
+}
+export declare function encodeLsp(msg: unknown): Buffer;
+/** Content-Length framed JSON-RPC reader; survives messages split across chunks. */
+export declare function createLspParser(onMessage: (msg: LspMessage) => void): {
+    push(chunk: Buffer): void;
+};
+/**
+ * Open one file with one LSP server, wait for its first publishDiagnostics (or the timeout),
+ * then shut it down. A one-shot client on purpose: no long-lived servers to manage yet.
+ */
+export declare function getDiagnostics(opts: {
+    server: LspServer;
+    cwd: string;
+    file: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<LspDiagnostic[]>;
+export {};

package/dist/mcp/catalog.d.ts

@@ -0,0 +1,14 @@
+import type { McpServerConfig } from './config';
+export interface CatalogInput {
+    key: string;
+    label: string;
+    secret?: boolean;
+}
+export interface CatalogEntry {
+    name: string;
+    description: string;
+    config: McpServerConfig;
+    inputs?: CatalogInput[];
+}
+export declare const CATALOG: CatalogEntry[];
+export declare function fillTemplate(config: McpServerConfig, values: Record<string, string>): McpServerConfig;

package/dist/mcp/config.d.ts

@@ -0,0 +1,36 @@
+export type McpServerConfig = {
+    type?: 'stdio';
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+} | {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+    auth?: 'oauth';
+};
+export interface McpServerSpec {
+    name: string;
+    config: McpServerConfig;
+    source: 'global' | 'project';
+}
+/**
+ * Claude Code-style environment expansion at connect time: ${VAR} reads from the
+ * parent environment, ${VAR:-default} falls back when unset, and an unset variable
+ * without a default stays literal. This lets a server pull a secret from the parent
+ * env ("API_KEY": "${MY_KEY}") without pasting the value into mcp.json, while the
+ * stdio child still only receives the whitelist plus the resolved config env.
+ */
+export declare function expandEnvVars(config: McpServerConfig, env: NodeJS.ProcessEnv): McpServerConfig;
+export declare const globalMcpPath: (home: string) => string;
+export declare const projectMcpPath: (cwd: string) => string;
+export declare function readMcpFile(path: string): Record<string, McpServerConfig>;
+export declare function addGlobalServer(home: string, name: string, config: McpServerConfig): void;
+export declare function removeGlobalServer(home: string, name: string): void;
+export declare function projectTrust(home: string, cwd: string, name: string, config: McpServerConfig): boolean | undefined;
+export declare function setProjectTrust(home: string, cwd: string, name: string, allowed: boolean, config: McpServerConfig): void;
+/** Global servers always; project servers only after a recorded yes. A project server never shadows a global one. */
+export declare function serversToStart(home: string, cwd: string): {
+    start: McpServerSpec[];
+    needTrust: McpServerSpec[];
+};

package/dist/mcp/manager.d.ts

@@ -0,0 +1,52 @@
+import type { Tool } from '../tools/types';
+import type { McpServerSpec } from './config';
+export interface McpContentItem {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    resource?: {
+        uri?: string;
+        text?: string;
+    };
+}
+export declare function formatMcpContent(content: McpContentItem[] | undefined): {
+    output: string;
+    images?: {
+        mediaType: string;
+        data: string;
+        path: string;
+    }[];
+};
+/** Safe env for spawned MCP servers: whitelist from the parent + the server's own config.env. */
+export declare function mcpChildEnv(extra?: Record<string, string>): Record<string, string>;
+export interface McpServerState {
+    name: string;
+    source: 'global' | 'project';
+    status: 'starting' | 'ready' | 'error';
+    error?: string;
+    tools: number;
+}
+/** OpenAI function names: [A-Za-z0-9_-], max 64 chars, unique. */
+export declare function mcpToolName(server: string, tool: string, taken: Set<string>): string;
+export declare class McpManager {
+    private readonly opts;
+    private readonly servers;
+    private readonly taken;
+    constructor(opts?: {
+        connectTimeoutMs?: number;
+        onChange?: () => void;
+        onToolsRemoved?: (names: string[]) => void;
+        /** Config home for the OAuth token store; enables authProvider on http servers. */
+        home?: string;
+        /** Overrides how the OAuth consent page is opened (tests inject a fake browser). */
+        open?: (url: URL) => void | Promise<void>;
+    });
+    start(specs: McpServerSpec[]): Promise<void>;
+    add(spec: McpServerSpec): Promise<void>;
+    private wrap;
+    remove(name: string): Promise<void>;
+    tools(): Tool[];
+    states(): McpServerState[];
+    stop(): Promise<void>;
+}

package/dist/mcp/oauth.d.ts

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+import { type OAuthClientProvider, type OAuthDiscoveryState } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
+import type { FetchLike } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { McpServerConfig } from './config';
+export interface OAuthStorage {
+    client?: OAuthClientInformationMixed;
+    tokens?: OAuthTokens;
+    codeVerifier?: string;
+    discovery?: OAuthDiscoveryState;
+}
+export type OAuthStore = Record<string, OAuthStorage>;
+export declare const oauthStorePath: (home: string) => string;
+export declare function hasStoredTokens(home: string, serverUrl: string): boolean;
+export declare function clearTokens(home: string, serverUrl: string): boolean;
+/**
+ * The browser is opened through a direct argv hand-off: on Windows `cmd /c start` re-parses
+ * its own command line, so an authorization URL from the MCP server could smuggle a second
+ * command with `&`. rundll32 plus `shell: false` never gives the URL to a shell, and only
+ * http(s) is ever opened (no `file:`/custom protocol handlers).
+ */
+export declare function openCommand(url: URL, platform: NodeJS.Platform): {
+    command: string;
+    args: string[];
+} | undefined;
+/** Opens a URL in the user's browser (best effort; callers should also print the URL). */
+export declare function defaultOpen(url: URL, deps?: {
+    platform?: NodeJS.Platform;
+    spawn?: typeof spawn;
+}): void;
+export interface FileOAuthProviderOptions {
+    home: string;
+    serverUrl: string;
+    redirectUrl?: string | URL;
+    open?: (url: URL) => void | Promise<void>;
+}
+/**
+ * File-backed OAuthClientProvider: client registration, tokens, PKCE verifier and
+ * discovery state per MCP server URL, stored in ~/.bccli/mcp-oauth.json (mode 600).
+ */
+export declare class FileOAuthProvider implements OAuthClientProvider {
+    private readonly opts;
+    constructor(opts: FileOAuthProviderOptions);
+    /**
+     * Always defined: MCP SDK treats a missing redirectUrl as a non-interactive
+     * (client_credentials) flow and would try a token exchange without a code.
+     */
+    get redirectUrl(): string | URL;
+    get clientMetadata(): OAuthClientMetadata;
+    private entry;
+    private patch;
+    clientInformation(): OAuthClientInformationMixed | undefined;
+    saveClientInformation(clientInformation: OAuthClientInformationMixed): void;
+    tokens(): OAuthTokens | undefined;
+    saveTokens(tokens: OAuthTokens): void;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    redirectToAuthorization(authorizationUrl: URL): void | Promise<void>;
+    saveDiscoveryState(state: OAuthDiscoveryState): void;
+    discoveryState(): OAuthDiscoveryState | undefined;
+    invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier' | 'discovery'): void;
+}
+/** Parses the loopback callback URL; an OAuth error response throws. */
+export declare function parseCallback(input: string | URL): {
+    code: string;
+    state?: string;
+};
+/**
+ * Runs the MCP OAuth 2.1 (PKCE) flow for one http server: starts a loopback callback
+ * server, hands the SDK auth() orchestrator the FileOAuthProvider, opens the browser,
+ * waits for the code, exchanges it, and stores the tokens. Throws on deny/failure.
+ */
+export declare function authorizeMcpServer(spec: {
+    name: string;
+    config: Extract<McpServerConfig, {
+        type?: 'http';
+    }>;
+}, deps: {
+    home: string;
+    open?: (url: URL) => void | Promise<void>;
+    fetchFn?: FetchLike;
+}): Promise<void>;

package/dist/{mcpCli-QUV5SD64.js → mcpCli-SETTCL3K.js}

@@ -2,30 +2,30 @@
 import {
   CATALOG,
   fillTemplate
-} from "./chunk-BQ2IGPBR.js";
+} from "./chunk-NQOGVP3I.js";
 import {
   authorizeMcpServer,
   clearTokens
-} from "./chunk-7F3IWBPQ.js";
+} from "./chunk-3I5BW3ZT.js";
 import {
   addGlobalServer,
   globalMcpPath,
   readMcpFile,
   removeGlobalServer
-} from "./chunk-L7QI6JN2.js";
+} from "./chunk-6M55UPES.js";
 import {
   bccliHome
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/mcpCli.ts
 async function runMcpCommand(args, deps) {
   const home = bccliHome(deps.env);
   const [action = "list", name] = args.subArgs;
   if (action === "serve") {
-    const { runMcpServe } = await import("./serve-6QLBJUYW.js");
+    const { runMcpServe } = await import("./serve-K5AH4MGO.js");
     return runMcpServe(args, deps);
   }
   const installed = readMcpFile(globalMcpPath(home));

package/dist/mcpCli.d.ts

@@ -0,0 +1,3 @@
+import type { CliArgs } from './args';
+import type { CliDeps } from './providerCli';
+export declare function runMcpCommand(args: CliArgs, deps: CliDeps): Promise<number>;

package/dist/mcpServer/serve.d.ts

@@ -0,0 +1,8 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { CliArgs } from '../args';
+import type { CliDeps } from '../providerCli';
+export interface McpServeDeps extends CliDeps {
+    /** Test seam: replaces the stdio transport (pass an InMemoryTransport half). */
+    transport?: Transport;
+}
+export declare function runMcpServe(args: CliArgs, deps: McpServeDeps): Promise<number>;

package/dist/mcpServer/server.d.ts

@@ -0,0 +1,19 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type FetchToolOptions } from '../tools/fetch';
+export interface McpServerDeps {
+    /** BotConnector API base, e.g. https://api.botconnector.id/v1 (no trailing slash). */
+    baseUrl: string;
+    /** Bearer key for paid endpoints (bc_chat); never logged or echoed. */
+    apiKey: string;
+    /** Default model id for bc_chat (provider prefix already stripped). */
+    defaultModel: string;
+    /** Injectable for tests; defaults to global fetch. */
+    fetchFn?: typeof fetch;
+    /** Injectable clock for the catalog cache; defaults to Date.now. */
+    now?: () => number;
+    /** Keenable endpoint for bc_search fallback; undefined = the public keyless endpoint. */
+    keenableURL?: string;
+    /** Passed to createFetchTool (DNS lookup / page fetch injection for tests). */
+    fetchTool?: FetchToolOptions;
+}
+export declare function createMcpServer(deps: McpServerDeps): McpServer;

package/dist/models.d.ts

@@ -0,0 +1,13 @@
+import { type Config } from './config';
+export interface ModelGroup {
+    providerId: string;
+    providerName: string;
+    models: string[];
+    error?: string;
+}
+export declare function listAllModels(config: Config, env?: NodeJS.ProcessEnv, opts?: {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    only?: string;
+    keyOverride?: string;
+}): Promise<ModelGroup[]>;

package/dist/{modelsCli-TRRB5LX4.js → modelsCli-OP7CDZC7.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import {
   listAllModels
-} from "./chunk-XBO5GACQ.js";
-import "./chunk-SPRNLS7K.js";
-import "./chunk-PUN4HMAG.js";
-import "./chunk-BLOYFIAD.js";
+} from "./chunk-IYR5PYA3.js";
+import "./chunk-HQW4BROS.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
 import {
   loadConfig,
   resolveModel
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/modelsCli.ts
 async function runModelsCommand(args, deps) {

package/dist/modelsCli.d.ts

@@ -0,0 +1,15 @@
+import type { CliArgs } from './args';
+export interface ModelsDeps {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out(line: string): void;
+    err(line: string): void;
+    fetch?: typeof fetch;
+}
+/**
+ * `bccli models [provider|provider/model]`.
+ * No argument keeps the old behavior: list the models of the active provider.
+ * A provider id (or a full model ref, whose provider part is used) lists exactly
+ * that provider, even when it is keyless or comes from the project config.
+ */
+export declare function runModelsCommand(args: CliArgs, deps: ModelsDeps): Promise<number>;