@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/cli/wizard/types.js

@@ -0,0 +1,109 @@
+/**
+ * 0.3.7 wizard — pure types + step state machine.
+ *
+ * The wizard walks the user through a small, ordered sequence of
+ * decisions. Each step has its own decision shape; together they fill
+ * in a `WizardDraft` that the Done step commits to disk.
+ *
+ * Why a typed Step enum + draft (instead of one giant async function
+ * with awaits in sequence)? Three reasons:
+ *
+ *   1. **Esc backs out one step at a time.** A reducer transition lets
+ *      us model "back" cleanly (Step.Provider → Step.Theme) without
+ *      unwinding an async stack.
+ *   2. **The runner is testable.** Driving the reducer with synthetic
+ *      events (`pick`, `back`, `abort`) lets us assert the wizard ends
+ *      in a known terminal state without simulating a real TTY.
+ *   3. **The shape lifts straight from peer references.**
+ *      `openSrc/codex/codex-rs/tui/src/onboarding/onboarding_screen.rs`
+ *      uses the same Step enum + per-step state pattern; we copy the
+ *      pattern, not the code.
+ */
+/** Ordered list — used by the runner to compute "next" and "previous". */
+export const STEP_ORDER = [
+    'welcome',
+    'theme',
+    'provider',
+    'apiKey',
+    'model',
+    'mcp',
+    'agentMd',
+    'done',
+];
+export function initWizardState() {
+    return {
+        currentStep: 'welcome',
+        draft: {},
+        warnings: [],
+        committed: false,
+        aborted: false,
+    };
+}
+/**
+ * Compute the next step. Pure — used by `reduceWizard` and exposed for
+ * tests + the runner's progress indicator ("step 3 of 7").
+ */
+export function nextStep(current) {
+    const idx = STEP_ORDER.indexOf(current);
+    if (idx < 0 || idx === STEP_ORDER.length - 1)
+        return undefined;
+    return STEP_ORDER[idx + 1];
+}
+export function prevStep(current) {
+    const idx = STEP_ORDER.indexOf(current);
+    if (idx <= 0)
+        return undefined;
+    return STEP_ORDER[idx - 1];
+}
+/**
+ * Pure reducer. Every wizard transition must go through here so the
+ * test suite can replay the same event sequence the runner emits.
+ *
+ * Contract:
+ *   - `advance` applies the patch into the draft and steps forward;
+ *     a no-op when called on the Done step.
+ *   - `back` rewinds one step; a no-op on the first step.
+ *   - `abort` lands the wizard in a terminal state with `aborted: true`
+ *     and the draft preserved (caller may inspect for partial intent).
+ *   - `warn` appends an advisory; doesn't move the step pointer.
+ *   - `commit` flips `committed: true` on the Done step only.
+ *
+ * The reducer never throws — bad inputs are silently ignored so a
+ * stray key event doesn't crash the wizard mid-render.
+ */
+export function reduceWizard(state, event) {
+    if (state.aborted || state.committed)
+        return state;
+    switch (event.kind) {
+        case 'advance': {
+            const after = nextStep(state.currentStep);
+            if (!after)
+                return state;
+            return {
+                ...state,
+                currentStep: after,
+                draft: { ...state.draft, ...event.patch },
+            };
+        }
+        case 'back': {
+            const before = prevStep(state.currentStep);
+            if (!before)
+                return state;
+            return { ...state, currentStep: before };
+        }
+        case 'abort':
+            return { ...state, aborted: true };
+        case 'warn':
+            return {
+                ...state,
+                warnings: [
+                    ...state.warnings,
+                    { step: state.currentStep, message: event.message },
+                ],
+            };
+        case 'commit':
+            if (state.currentStep !== 'done')
+                return state;
+            return { ...state, committed: true };
+    }
+}

package/dist/config/config.d.ts

@@ -5,6 +5,25 @@ export interface ServerConfig {
     env?: Record<string, string>;
     url?: string;
     apiKey?: string;
+    /**
+     * 0.3.6 item 10a: identity tag for distinguishing the BrainRouter cloud
+     * brain ("our MCP") from third-party MCPs the user might attach (GitHub,
+     * filesystem, Slack, etc.). Drives status surfaces (banner / statusline /
+     * `/where`) and the offline-mode prompt swap: when "the brain" is down
+     * the user gets a clear signal, not a generic "MCP offline" message.
+     *
+     * Detection priority when this field is unset:
+     *   1. Server profile name starts with `brainrouter` (case-insensitive).
+     *   2. URL hostname matches `*.brainrouter.cloud` or `*.brainrouter.dev`.
+     *   3. (Run-time fallback) first successful `listTools()` includes
+     *      both `memory_recall` AND `list_skills` — the BrainRouter signature
+     *      pair. See `detectMcpIdentity` in `runtime/mcpClient.ts`.
+     *
+     * Explicit values always win — if the user marks a third-party MCP as
+     * `identity: 'brainrouter'`, that's their call (e.g. they're running a
+     * local fork that exposes the same tool surface).
+     */
+    identity?: 'brainrouter' | 'third-party';
 }
 export interface LLMConfig {
     provider: 'openai';
@@ -18,5 +37,38 @@ export interface Config {
     llm?: LLMConfig;
 }
 export declare function getConfigPath(): string;
+/**
+ * Read the existing config.json or exit with a clear error. The CLI owns
+ * READS of this file — writes are the user's job (via `brainrouter login`,
+ * `brainrouter config`, or direct edit). Auto-fabricating a default config
+ * was a holdover from the monorepo dev story; it only ever produced a
+ * broken stdio profile pointing at a sibling `brainrouter/` package that
+ * doesn't exist outside the monorepo, so npm-installed users got a config
+ * file they had to fix anyway.
+ *
+ * Setup commands (login / config) that need to BUILD a fresh config from
+ * scratch should call `loadOrInitConfig` instead — it returns an empty
+ * skeleton when no file exists rather than exiting.
+ */
 export declare function loadConfig(): Config;
+/**
+ * Pick the best API key from the environment for a given endpoint.
+ * Order: provider-specific envKey (matched against `PROVIDER_CATALOG`
+ * by endpoint), then `OPENAI_API_KEY` (most common default), then the
+ * generic `BRAINROUTER_LLM_API_KEY`. Returns undefined if nothing is
+ * set so the caller can choose how to surface that.
+ *
+ * Kept here (vs imported from `cli/wizard/providers.ts`) so non-CLI
+ * callers — the MCP child env propagation, future SDK clients — can
+ * use it without dragging in the wizard surface.
+ */
+export declare function backfillApiKeyFromEnv(endpoint: string | undefined): string | undefined;
+/**
+ * Setup-wizard variant of `loadConfig`. Returns the existing config when
+ * one is on disk, or an empty skeleton when none exists yet. Used by
+ * `brainrouter login` and `brainrouter config` so a first-run user can
+ * BUILD their config interactively without hitting the strict
+ * "no config — run setup" error from `loadConfig`.
+ */
+export declare function loadOrInitConfig(): Config;
 export declare function saveConfig(config: Config): void;

package/dist/config/config.js

@@ -1,46 +1,110 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { DatabaseSync } from 'node:sqlite';
 const CONFIG_DIR = path.join(os.homedir(), '.config', 'brainrouter');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 export function getConfigPath() {
     return CONFIG_FILE;
 }
+/**
+ * Read the existing config.json or exit with a clear error. The CLI owns
+ * READS of this file — writes are the user's job (via `brainrouter login`,
+ * `brainrouter config`, or direct edit). Auto-fabricating a default config
+ * was a holdover from the monorepo dev story; it only ever produced a
+ * broken stdio profile pointing at a sibling `brainrouter/` package that
+ * doesn't exist outside the monorepo, so npm-installed users got a config
+ * file they had to fix anyway.
+ *
+ * Setup commands (login / config) that need to BUILD a fresh config from
+ * scratch should call `loadOrInitConfig` instead — it returns an empty
+ * skeleton when no file exists rather than exiting.
+ */
 export function loadConfig() {
-    let config;
     if (!fs.existsSync(CONFIG_FILE)) {
-        config = createDefaultConfig();
+        console.error(`No BrainRouter config found at ${CONFIG_FILE}.`);
+        console.error(`Run \`brainrouter login\` to connect to a hosted MCP server, or \`brainrouter config\` to set one up.`);
+        process.exit(1);
     }
-    else {
-        try {
-            const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
-            const parsed = JSON.parse(raw);
-            // Backfill standard properties if missing
-            if (!parsed.servers)
-                parsed.servers = {};
-            if (!parsed.activeServer)
-                parsed.activeServer = 'default';
-            config = parsed;
-        }
-        catch (error) {
-            console.error(`Warning: Failed to parse config file at ${CONFIG_FILE}. Using default config.`);
-            config = createDefaultConfig();
-        }
+    let parsed;
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        console.error(`Error: Failed to parse config file at ${CONFIG_FILE}: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`Fix the file by hand, or delete it and run \`brainrouter config\` to recreate.`);
+        process.exit(1);
     }
-    // Auto-resolve placeholder API keys if possible
-    resolveDefaultApiKey(config);
+    if (!parsed.servers)
+        parsed.servers = {};
+    if (!parsed.activeServer)
+        parsed.activeServer = '';
     // The default config writes `llm.apiKey: ''` so it never appears as a
     // secret in the committed file. Backfill from the standard env vars at
     // load time so every downstream consumer (callOpenAI, mcpClient env
     // propagation, the cognitive extractor LLM runner) sees a real value
     // instead of the empty string.
-    if (config.llm && !config.llm.apiKey.trim()) {
-        const envKey = process.env.OPENAI_API_KEY || process.env.BRAINROUTER_LLM_API_KEY;
-        if (envKey)
-            config.llm.apiKey = envKey;
+    //
+    // 0.3.7 — provider-specific fallback. Pre-0.3.7 we only checked
+    // OPENAI_API_KEY / BRAINROUTER_LLM_API_KEY, which silently broke
+    // users with config.llm.endpoint pointing at DeepSeek / OpenRouter /
+    // Gemini / etc. who had the *correct* provider key in their shell
+    // (DEEPSEEK_API_KEY, OPENROUTER_API_KEY, GEMINI_API_KEY, …). Now we
+    // match the saved endpoint to a provider entry and try ITS envKey
+    // FIRST, then fall through to the generic vars.
+    if (parsed.llm && !parsed.llm.apiKey.trim()) {
+        parsed.llm.apiKey = backfillApiKeyFromEnv(parsed.llm.endpoint) ?? '';
+    }
+    return parsed;
+}
+/**
+ * Pick the best API key from the environment for a given endpoint.
+ * Order: provider-specific envKey (matched against `PROVIDER_CATALOG`
+ * by endpoint), then `OPENAI_API_KEY` (most common default), then the
+ * generic `BRAINROUTER_LLM_API_KEY`. Returns undefined if nothing is
+ * set so the caller can choose how to surface that.
+ *
+ * Kept here (vs imported from `cli/wizard/providers.ts`) so non-CLI
+ * callers — the MCP child env propagation, future SDK clients — can
+ * use it without dragging in the wizard surface.
+ */
+export function backfillApiKeyFromEnv(endpoint) {
+    // Provider-specific env vars in order of catalog precedence. Hardcoded
+    // here so this function stays free of the wizard import (which pulls
+    // in chalk, ink picker types, etc.). Keep in lockstep with
+    // `cli/wizard/providers.ts → PROVIDER_CATALOG`.
+    const PROVIDER_ENV_BY_ENDPOINT = [
+        { endpoint: 'https://api.openai.com/v1', envKey: 'OPENAI_API_KEY' },
+        { endpoint: 'https://api.deepseek.com/v1', envKey: 'DEEPSEEK_API_KEY' },
+        { endpoint: 'https://openrouter.ai/api/v1', envKey: 'OPENROUTER_API_KEY' },
+        { endpoint: 'https://generativelanguage.googleapis.com/v1beta/openai', envKey: 'GEMINI_API_KEY' },
+        { endpoint: 'https://api.anthropic.com/v1', envKey: 'ANTHROPIC_API_KEY' },
+        { endpoint: 'http://localhost:1234/v1', envKey: 'LMSTUDIO_API_KEY' },
+        { endpoint: 'http://localhost:11434/v1', envKey: 'OLLAMA_API_KEY' },
+    ];
+    if (endpoint) {
+        const trimmed = endpoint.replace(/\/$/, '');
+        const match = PROVIDER_ENV_BY_ENDPOINT.find((p) => p.endpoint === trimmed);
+        if (match) {
+            const value = process.env[match.envKey];
+            if (value && value.trim())
+                return value.trim();
+        }
     }
-    return config;
+    return process.env.OPENAI_API_KEY?.trim() || process.env.BRAINROUTER_LLM_API_KEY?.trim() || undefined;
+}
+/**
+ * Setup-wizard variant of `loadConfig`. Returns the existing config when
+ * one is on disk, or an empty skeleton when none exists yet. Used by
+ * `brainrouter login` and `brainrouter config` so a first-run user can
+ * BUILD their config interactively without hitting the strict
+ * "no config — run setup" error from `loadConfig`.
+ */
+export function loadOrInitConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return { activeServer: '', servers: {} };
+    }
+    return loadConfig();
 }
 export function saveConfig(config) {
     try {
@@ -53,53 +117,3 @@ export function saveConfig(config) {
         console.error(`Error: Failed to save config to ${CONFIG_FILE}:`, error instanceof Error ? error.message : error);
     }
 }
-function createDefaultConfig() {
-    // Derive path to the default local MCP server dist relative to this module.
-    // After build: brainrouter-cli/dist/config/config.js → walk three levels up
-    // to the monorepo root, then into the sibling `brainrouter/` package
-    // (formerly `mcp/`) which is the MCP server.
-    const defaultMcpPath = path.resolve(import.meta.dirname, '..', '..', '..', 'brainrouter', 'dist', 'index.js');
-    const config = {
-        activeServer: 'default',
-        servers: {
-            default: {
-                type: 'stdio',
-                command: 'node',
-                args: [defaultMcpPath, '--root', './'],
-                env: {
-                    BRAINROUTER_API_KEY: 'br_admin_key_placeholder'
-                }
-            }
-        },
-        llm: {
-            provider: 'openai',
-            apiKey: '',
-            model: 'gpt-4o-mini',
-            endpoint: 'https://api.openai.com/v1'
-        }
-    };
-    saveConfig(config);
-    return config;
-}
-function resolveDefaultApiKey(config) {
-    const defaultServer = config.servers.default;
-    if (defaultServer &&
-        defaultServer.type === 'stdio' &&
-        defaultServer.env &&
-        defaultServer.env.BRAINROUTER_API_KEY === 'br_admin_key_placeholder') {
-        const dbPath = process.env.BRAINROUTER_MEMORY_DB || path.join(os.homedir(), '.brainrouter', 'memory.db');
-        if (fs.existsSync(dbPath)) {
-            try {
-                const db = new DatabaseSync(dbPath);
-                const row = db.prepare("SELECT api_key FROM users WHERE is_admin = 1 LIMIT 1").get();
-                if (row && row.api_key) {
-                    defaultServer.env.BRAINROUTER_API_KEY = row.api_key;
-                    saveConfig(config);
-                }
-            }
-            catch (error) {
-                // ignore errors
-            }
-        }
-    }
-}