@kinqs/brainrouter-cli 0.3.6 → 0.3.8

package/dist/runtime/cronParser.js

@@ -0,0 +1,122 @@
+/**
+ * Minimal 5-field cron parser — `minute hour dom month dow`.
+ *
+ * Vendored intentionally (no node-cron) to keep the dependency surface
+ * small and the semantics predictable. Supports `*`, comma lists,
+ * ranges (`1-5`), and steps (`15`, `0-30/10`). No seconds, no Quartz
+ * extensions, no `@reboot` macros.
+ */
+const FIELD_RANGES = [
+    { min: 0, max: 59 }, // minute
+    { min: 0, max: 23 }, // hour
+    { min: 1, max: 31 }, // day of month
+    { min: 1, max: 12 }, // month
+    { min: 0, max: 7 }, // day of week (0 or 7 = Sunday)
+];
+function parseField(raw, min, max) {
+    if (raw.length === 0)
+        return undefined;
+    const out = new Set();
+    for (const part of raw.split(',')) {
+        if (!part)
+            return undefined;
+        let step = 1;
+        let range = part;
+        const slash = part.indexOf('/');
+        if (slash >= 0) {
+            const s = Number(part.slice(slash + 1));
+            if (!Number.isInteger(s) || s < 1)
+                return undefined;
+            step = s;
+            range = part.slice(0, slash);
+        }
+        let lo;
+        let hi;
+        if (range === '*' || range === '') {
+            lo = min;
+            hi = max;
+        }
+        else if (range.includes('-')) {
+            const [a, b] = range.split('-');
+            lo = Number(a);
+            hi = Number(b);
+            if (!Number.isInteger(lo) || !Number.isInteger(hi))
+                return undefined;
+        }
+        else {
+            const v = Number(range);
+            if (!Number.isInteger(v))
+                return undefined;
+            lo = v;
+            hi = v;
+        }
+        if (lo < min || hi > max || lo > hi)
+            return undefined;
+        for (let i = lo; i <= hi; i += step)
+            out.add(i);
+    }
+    return out.size > 0 ? out : undefined;
+}
+export function parseCron(expr) {
+    if (typeof expr !== 'string')
+        return undefined;
+    const trimmed = expr.trim();
+    if (!trimmed)
+        return undefined;
+    const fields = trimmed.split(/\s+/);
+    if (fields.length !== 5)
+        return undefined;
+    const parsed = fields.map((f, i) => parseField(f, FIELD_RANGES[i].min, FIELD_RANGES[i].max));
+    if (parsed.some((p) => !p))
+        return undefined;
+    const [minute, hour, dom, month, dowRaw] = parsed;
+    // Normalize dow: 7 → 0 so Sunday has one representation.
+    const dow = new Set();
+    for (const v of dowRaw)
+        dow.add(v === 7 ? 0 : v);
+    return { minute, hour, dom, month, dow, raw: trimmed };
+}
+/**
+ * First firing instant strictly AFTER `after`. Walks the calendar
+ * forward, jumping months/days when fields don't match instead of
+ * scanning minute-by-minute.
+ */
+export function nextCronFire(cron, after) {
+    const d = new Date(after.getTime());
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    const domRestricted = cron.dom.size !== 31;
+    const dowRestricted = cron.dow.size !== 7;
+    // Safety cap — 8 years of day-level iterations is plenty; if we exhaust
+    // it the expression is effectively impossible (e.g. Feb 30).
+    for (let i = 0; i < 366 * 8; i++) {
+        if (!cron.month.has(d.getMonth() + 1)) {
+            d.setDate(1);
+            d.setMonth(d.getMonth() + 1);
+            d.setHours(0, 0, 0, 0);
+            continue;
+        }
+        const domOk = cron.dom.has(d.getDate());
+        const dowOk = cron.dow.has(d.getDay());
+        // Vixie-cron semantics: when both dom and dow are restricted, EITHER
+        // match counts. Otherwise both must match (the unrestricted field is
+        // effectively `*` and always matches).
+        const dateMatches = domRestricted && dowRestricted ? (domOk || dowOk) : (domOk && dowOk);
+        if (!dateMatches) {
+            d.setDate(d.getDate() + 1);
+            d.setHours(0, 0, 0, 0);
+            continue;
+        }
+        if (!cron.hour.has(d.getHours())) {
+            d.setHours(d.getHours() + 1);
+            d.setMinutes(0, 0, 0);
+            continue;
+        }
+        if (!cron.minute.has(d.getMinutes())) {
+            d.setMinutes(d.getMinutes() + 1, 0, 0);
+            continue;
+        }
+        return d;
+    }
+    throw new Error(`cron next-fire search exhausted for "${cron.raw}"`);
+}

package/dist/runtime/mcpClient.js

@@ -23,7 +23,7 @@ export class McpClientWrapper {
     identity = 'unknown';
     serverName;
     constructor() {
-        this.client = new Client({ name: 'brainrouter-cli', version: '0.3.5' }, { capabilities: {} });
+        this.client = new Client({ name: 'brainrouter-cli', version: '0.3.8' }, { capabilities: {} });
     }
     /** Whether this wrapper has an active MCP transport. */
     isConnected() {
@@ -139,16 +139,11 @@ export class McpClientWrapper {
             if (llmConfig?.model && !mergedEnv.BRAINROUTER_LLM_MODEL) {
                 mergedEnv.BRAINROUTER_LLM_MODEL = llmConfig.model;
             }
-            // Loud diagnostic: if NO LLM key reached the child, server-side
-            // memory extraction is dead — every sensory capture will pile up
-            // un-extracted. Print a yellow banner so the user knows BEFORE they
-            // see "0 records" in every briefing.
-            if (!mergedEnv.BRAINROUTER_LLM_API_KEY) {
-                console.warn('\n⚠️  No LLM API key reached the MCP child. Sensory turns will be ' +
-                    'captured but cognitive extraction (the thing that makes them ' +
-                    'searchable) will fail silently. Set OPENAI_API_KEY or ' +
-                    'BRAINROUTER_LLM_API_KEY before starting brainrouter.\n');
-            }
+            // (Previously: a loud console.warn here if no LLM API key reached the
+            // MCP child. That message landed above the Ink banner and looked like a
+            // CLI error even though it was a server-side concern. Server-side
+            // extraction failures should surface through MCP's own status channel —
+            // not by the CLI second-guessing what the server needs.)
             // Spawn the MCP child with cwd set to the MCP package directory if we
             // can find it from the first arg (typically
             // `node /path/to/BrainRouter/brainrouter/dist/index.js`). The child
@@ -179,6 +174,14 @@ export class McpClientWrapper {
                 args: serverConfig.args ?? [],
                 env: mergedEnv,
                 cwd: childCwd,
+                // The MCP child is a separate process with its own concerns (its own
+                // dotenv, its own auth failures, its own platform warnings). Inheriting
+                // its stderr meant every `[BrainRouter] FATAL …`, every dotenv banner,
+                // every SQLite ExperimentalWarning leaked above our Ink chat banner
+                // and looked like the CLI was crashing. Pipe it so the SDK owns the
+                // stream; the CLI can surface a single graceful "MCP unreachable" line
+                // through its own offline-mode flow instead.
+                stderr: 'pipe',
             });
             await this.client.connect(this.transport);
             this.connected = true;

package/dist/runtime/mcpPool.d.ts

@@ -0,0 +1,170 @@
+import { McpClientWrapper } from './mcpClient.js';
+import type { LLMConfig, ServerConfig } from '../config/config.js';
+/**
+ * 0.3.7 — Multi-MCP support. Wraps a `Map<serverId, McpClientWrapper>`
+ * and exposes the same public API as a single wrapper (`isConnected`,
+ * `getIdentity`, `getServerName`, `listTools`, `callTool`, `close`),
+ * so existing call-sites that hold an `mcpClient` reference keep
+ * working unchanged.
+ *
+ * Pattern lifted from Claude Code's `.mcp.json` model (see
+ * `openSrc/claude-code/CHANGELOG.md` — concurrent startup at line 688,
+ * tool prefixing at line 1515, graceful degradation at line 189). Our
+ * shape:
+ *
+ *   - All configured servers attempt connection concurrently on boot,
+ *     each with a 5s timeout. Offline ones do NOT block others.
+ *   - Tools surface to the agent with `mcp_<serverId>_<toolName>`
+ *     prefix (Claude Code style).
+ *   - `callTool` accepts BOTH the prefixed form (the canonical name
+ *     the LLM sees in the tool inventory) AND the raw form (back-compat
+ *     for the existing system prompt and skills that hardcode
+ *     `memory_recall` etc.). Raw form routes to the unique server
+ *     providing that tool name; collision (two servers expose the same
+ *     unprefixed name) returns a helpful error pointing at the
+ *     prefixed form.
+ *
+ * Future versions may drop the raw-name fallback once skills and
+ * prompts are migrated to prefixed names; the pool then becomes the
+ * pure Claude Code shape. Until then the dual-name resolution is a
+ * transition aid documented in CHANGELOG `[0.3.7]`.
+ */
+export type McpServerStatus = {
+    serverId: string;
+    identity: 'brainrouter' | 'third-party' | 'unknown';
+    /** 'connected' once the underlying wrapper reports isConnected. */
+    status: 'connected' | 'connecting' | 'offline' | 'failed';
+    /** Filled after the first successful listTools (used by /mcp list). */
+    toolCount?: number;
+    /** Per-server error message when status === 'failed'. */
+    error?: string;
+};
+/**
+ * Choose which configured MCP profiles should connect for a normal CLI run.
+ *
+ * BrainRouter profiles are special: users may store several BrainRouter MCPs
+ * (local, staging, remote, self-hosted), but only one should be active at a
+ * time because the BrainRouter MCP is the memory/brain plane. Third-party MCPs
+ * are additive tools, so they all connect concurrently.
+ *
+ * `requestedProfile` is the explicit escape hatch (`--profile <name>`): it
+ * scopes the run to exactly that profile, matching the existing single-server
+ * mode.
+ */
+export declare function selectMcpServerIds(servers: Record<string, ServerConfig>, activeServer?: string, requestedProfile?: string): string[];
+/**
+ * 0.3.8-R5 — Single-underscore `mcp_<server>_<tool>` is the canonical
+ * tool-name shape across the CLI. Any legacy double-underscore
+ * `mcp__<server>__<tool>` form that arrives at the pool boundary
+ * (e.g. through an external surface or older skill) is collapsed here
+ * so downstream code can assume one convention.
+ */
+export declare function normalizeMcpToolName(name: string): string;
+export declare class McpClientPool {
+    /** serverId → connected wrapper. */
+    private clients;
+    /** serverId → status entry (kept even for failed/offline servers so /mcp can render them). */
+    private statuses;
+    /**
+     * Unprefixed tool name → owning serverId. Sentinel `__COLLISION__`
+     * marks tool names exposed by multiple servers (must be addressed
+     * via the prefixed form).
+     */
+    private toolToServer;
+    /** Prefixed form (`mcp_<serverId>_<tool>`) → `{serverId, tool}` for fast dispatch. */
+    private prefixedToServer;
+    /** LLM config from the last connectAll — needed for reconnect calls. */
+    private currentLlmConfig?;
+    /** Raw server configs from the last connectAll — needed for /mcp reconnect <id>. */
+    private serverConfigs;
+    /** serverId → prefix used in tool names. Brainrouter servers get "brainrouter"; others keep their config key. */
+    private prefixIds;
+    /** Reverse: prefixId → serverId (needed to dispatch `mcp_brainrouter_X` back to the real key). */
+    private prefixToServerId;
+    private getPrefixId;
+    private assignPrefixId;
+    /**
+     * Connect to every entry in `servers` concurrently. Each connect
+     * gets its own timeout; offline servers don't block the others.
+     * Returns the status array after all connects settle.
+     */
+    connectAll(servers: Record<string, ServerConfig>, llmConfig?: LLMConfig, options?: {
+        timeoutMs?: number;
+        onStatusChange?: (s: McpServerStatus) => void;
+    }): Promise<McpServerStatus[]>;
+    /**
+     * Connect a single server. Used both by `connectAll` and by
+     * `/mcp connect <id>` for late-joining servers. Idempotent — if
+     * the server is already connected, closes the previous wrapper first.
+     */
+    connectOne(serverId: string, config: ServerConfig, llmConfig?: LLMConfig, timeoutMs?: number): Promise<void>;
+    /** Tear down a single server. Removes it from the pool and rebuilds the tool index. */
+    disconnectOne(serverId: string): Promise<void>;
+    /** Reconnect: close + connect again using the stashed config. */
+    reconnectOne(serverId: string): Promise<void>;
+    /**
+     * Walk every connected client and rebuild the tool→server indices.
+     * Called after every connect / disconnect / reconnect so the
+     * dispatch path stays correct without re-fetching tools on every
+     * `callTool`.
+     */
+    private refreshToolIndex;
+    /**
+     * Concatenated tool list across every connected server, with names
+     * prefixed `mcp_<serverId>_<toolName>` (Claude Code style). The
+     * agent calls this once per turn and hands it to the LLM.
+     */
+    listTools(): Promise<{
+        tools: any[];
+    }>;
+    /**
+     * Route a tool call to the right server. Accepts both name forms:
+     *
+     *   - `mcp_<serverId>_<tool>` — the canonical form the LLM sees
+     *     in the inventory. Stripped + dispatched directly.
+     *   - `<tool>` raw form — back-compat for prompts/skills that
+     *     hardcode `memory_recall`-style names. Routed to the unique
+     *     server providing that tool. Returns a helpful error if two
+     *     servers expose the same name (caller must use the prefix).
+     */
+    callTool(name: string, args: Record<string, any>): Promise<any>;
+    /** Internal — map a name (prefixed OR raw) to a concrete server + tool. */
+    private resolveToolCall;
+    /** True iff at least one server is connected. */
+    isConnected(): boolean;
+    /**
+     * Identity precedence: any connected `brainrouter` > any connected
+     * `third-party` > `unknown`. The CLI banner + offline prompt swap
+     * branch on this — "BrainRouter is offline" makes sense only when
+     * we expected one and didn't get one.
+     */
+    getIdentity(): 'brainrouter' | 'third-party' | 'unknown';
+    /**
+     * Human-readable summary for the banner/statusline. Single-server
+     * pools render just the server name; multi-server pools render
+     * a count + the first few names.
+     */
+    getServerName(): string | undefined;
+    /**
+     * Look up a wrapper by serverId. Used by `/mcp tools <server>` and
+     * similar commands that want to talk to one specific server.
+     */
+    getClient(serverId: string): McpClientWrapper | undefined;
+    /**
+     * Find the connected wrapper whose identity is 'brainrouter'. Some
+     * code paths (memory capture, working-memory offload) specifically
+     * need the canonical brain regardless of how many third-party MCPs
+     * the user added.
+     */
+    getBrainrouterClient(): McpClientWrapper | undefined;
+    /** Server id for the currently connected BrainRouter MCP, if one is active. */
+    getActiveBrainrouterServerId(): string | undefined;
+    /** Status snapshot for every server the pool has tried to connect to. */
+    getStatuses(): McpServerStatus[];
+    /** Status for one server (returns undefined if the pool has never seen it). */
+    getStatus(serverId: string): McpServerStatus | undefined;
+    /** List of serverIds currently held by the pool (connected or not). */
+    getServerIds(): string[];
+    /** Close every wrapper. Used on CLI exit. */
+    close(): Promise<void>;
+}