@kinqs/brainrouter-cli 0.3.6 → 0.3.7

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,20 @@
+import type { CommandContext } from './_context.js';
+/**
+ * `/init` slash command — 0.3.7 redesign.
+ *
+ * Two behaviours under one verb, picked by the first argument:
+ *
+ *   - `/init` (bare) — re-run the onboarding wizard inside the REPL.
+ *     The REPL already owns the readline, so the wizard reuses it
+ *     (`ownsReadline: false`). Aborting at any step leaves disk
+ *     untouched.
+ *   - `/init agentmd` — back-compat alias for the 0.3.6 behaviour
+ *     that only scaffolded AGENT.md (the wizard now folds this in as
+ *     its final step, but users with muscle memory keep the lever).
+ *
+ * The auto-trigger on REPL start (when no `~/.config/brainrouter/config.json`
+ * exists) calls `runWizard` directly from `index.ts` with
+ * `ownsReadline: true`. That's a separate entry point — this slash
+ * handler is only for the in-REPL invocation.
+ */
+export declare function tryHandleInitCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/init.js

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import { initAgentMd } from '../../prompt/initAgentMd.js';
+import { runWizard } from '../ink/runWizard.js';
+/**
+ * `/init` slash command — 0.3.7 redesign.
+ *
+ * Two behaviours under one verb, picked by the first argument:
+ *
+ *   - `/init` (bare) — re-run the onboarding wizard inside the REPL.
+ *     The REPL already owns the readline, so the wizard reuses it
+ *     (`ownsReadline: false`). Aborting at any step leaves disk
+ *     untouched.
+ *   - `/init agentmd` — back-compat alias for the 0.3.6 behaviour
+ *     that only scaffolded AGENT.md (the wizard now folds this in as
+ *     its final step, but users with muscle memory keep the lever).
+ *
+ * The auto-trigger on REPL start (when no `~/.config/brainrouter/config.json`
+ * exists) calls `runWizard` directly from `index.ts` with
+ * `ownsReadline: true`. That's a separate entry point — this slash
+ * handler is only for the in-REPL invocation.
+ */
+export async function tryHandleInitCommand(ctx) {
+    const { command, args, agent, repl } = ctx;
+    if (command !== '/init')
+        return false;
+    // Back-compat: explicit subcommand keeps the 0.3.6 one-shot behaviour.
+    if (args[0]?.toLowerCase() === 'agentmd' || args[0]?.toLowerCase() === 'agent') {
+        const result = initAgentMd(agent.workspaceRoot);
+        if (result.status === 'created') {
+            console.log(chalk.green(`\n✓ Created ${result.path}`));
+            console.log(chalk.gray('  Edit it to describe your project — any AGENT.md-aware agent will read it.\n'));
+        }
+        else {
+            console.log(chalk.yellow(`\nFile already exists: ${result.path}`));
+            console.log(chalk.gray('  Run `/init agentmd --overwrite` if you really want to start fresh (TODO).\n'));
+        }
+        return true;
+    }
+    // Wizard mode. Ink owns stdin while the wizard is mounted; once it
+    // unmounts the REPL's readline resumes naturally because we kept the
+    // process.stdin handle around (Ink restores raw mode on exit).
+    try {
+        const result = await runWizard({
+            workspaceRoot: agent.workspaceRoot,
+        });
+        if (result.config?.llm) {
+            // Live-update the in-flight agent so the next turn uses the new
+            // model / endpoint without forcing a restart. Keep the wrapper's
+            // existing MCP connection — switching MCP needs a restart for
+            // now (next item on the polish list).
+            const llm = result.config.llm;
+            agent.setModel(llm.model);
+            // The agent's internal openai client cached the endpoint at
+            // construction time — repl users may need a fresh CLI process
+            // for endpoint changes to fully take effect.
+            console.log(chalk.gray('  (note: endpoint / API-key changes apply on the next CLI restart)\n'));
+        }
+        repl.refreshPromptForMode();
+    }
+    catch (err) {
+        console.error(chalk.red(`\n/init failed: ${err?.message ?? err}\n`));
+    }
+    return true;
+}

package/dist/cli/commands/login.d.ts

@@ -0,0 +1,13 @@
+import type { CommandContext } from './_context.js';
+/**
+ * `/login` slash command — 0.3.7 redesign on the new internal picker.
+ *
+ * Opens a small modal that picks a transport (stdio / local-http /
+ * remote-http), gathers fields via the framed text prompt, runs a
+ * single 5s reachability probe, and saves the profile. Probe failure
+ * offers "save anyway / try a different transport / cancel".
+ *
+ * The legacy `brainrouter login` subcommand stays for users who
+ * scripted it.
+ */
+export declare function tryHandleLoginCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/login.js

@@ -0,0 +1,179 @@
+import chalk from 'chalk';
+import { saveConfig } from '../../config/config.js';
+import { McpClientWrapper } from '../../runtime/mcpClient.js';
+import { maskApiKey } from '../wizard/providers.js';
+// 0.3.7 — picker / prompt moved to Ink (see commands/config.ts for the
+// full rationale on why the raw-stdout primitives were retired).
+import { runPicker, runTextField } from '../ink/runPicker.js';
+const pickFromList = runPicker;
+const promptText = runTextField;
+import { buildTheme } from '../theme.js';
+import { readPreferences } from '../../state/preferencesStore.js';
+import { editLlm, promptBrainrouterApiKey } from './config.js';
+/**
+ * `/login` slash command — 0.3.7 redesign on the new internal picker.
+ *
+ * Opens a small modal that picks a transport (stdio / local-http /
+ * remote-http), gathers fields via the framed text prompt, runs a
+ * single 5s reachability probe, and saves the profile. Probe failure
+ * offers "save anyway / try a different transport / cancel".
+ *
+ * The legacy `brainrouter login` subcommand stays for users who
+ * scripted it.
+ */
+export async function tryHandleLoginCommand(ctx) {
+    if (ctx.command !== '/login')
+        return false;
+    const theme = buildTheme(readPreferences(ctx.agent.workspaceRoot).theme === 'mono' ? 'mono' : readPreferences(ctx.agent.workspaceRoot).theme === 'light' ? 'light' : 'dark');
+    while (true) {
+        const transport = await pickFromList({
+            theme,
+            title: '/login — MCP profile',
+            subtitle: 'Pick how this CLI reaches the BrainRouter MCP.',
+            rows: [
+                { id: 'local-stdio', label: 'Local stdio', value: 'brainrouter-mcp', description: 'No HTTP server needed' },
+                { id: 'local-http', label: 'Local HTTP', value: 'localhost:3747', description: 'Connect to a brainrouter-mcp HTTP server running locally' },
+                { id: 'remote-http', label: 'Remote HTTP', value: 'custom URL', description: 'Hosted MCP server (URL + optional key)' },
+            ],
+        });
+        if (transport.kind !== 'pick') {
+            console.log(chalk.yellow('\n  /login cancelled.\n'));
+            return true;
+        }
+        let serverConfig;
+        let profileName = '';
+        if (transport.id === 'local-stdio') {
+            serverConfig = { type: 'stdio', command: 'brainrouter-mcp', args: [], identity: 'brainrouter' };
+            profileName = 'local-stdio';
+        }
+        else if (transport.id === 'local-http') {
+            // 0.3.7 — collect the BrainRouter API key even for local-http.
+            // brainrouter-mcp HTTP servers can require auth (BRAINROUTER_API_KEY
+            // set in their server.env). Pre-fill from the env var; blank is OK
+            // for unauthenticated dev servers.
+            const apiKey = await promptBrainrouterApiKey(theme, 'local', ctx.config.servers['local-http']?.apiKey);
+            if (apiKey === undefined) {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            serverConfig = {
+                type: 'http',
+                url: 'http://localhost:3747/mcp',
+                apiKey: apiKey || undefined,
+                identity: 'brainrouter',
+            };
+            profileName = 'local-http';
+        }
+        else {
+            const urlResult = await promptText({
+                theme,
+                title: 'Remote MCP URL',
+                subtitle: 'Paste the full URL (e.g. https://brainrouter.example.com/mcp).',
+                prefilled: ctx.config.servers['remote']?.url ?? '',
+                placeholder: 'https://...',
+                validate: (raw) => {
+                    const v = raw.trim();
+                    if (!v)
+                        return 'URL required';
+                    try {
+                        new URL(v);
+                    }
+                    catch {
+                        return 'not a valid URL';
+                    }
+                    return undefined;
+                },
+            });
+            if (urlResult.kind !== 'accept') {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            const url = urlResult.text.trim();
+            const apiKey = await promptBrainrouterApiKey(theme, 'remote', ctx.config.servers['remote']?.apiKey);
+            if (apiKey === undefined) {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            serverConfig = { type: 'http', url, apiKey: apiKey || undefined, identity: 'brainrouter' };
+            profileName = 'remote';
+        }
+        const probe = await probeMcpProfile(serverConfig, profileName);
+        if (!probe.ok) {
+            const choice = await pickFromList({
+                theme,
+                title: 'MCP probe failed',
+                subtitle: probe.error,
+                rows: [
+                    { id: 'save', label: 'Save anyway', description: 'Persist the profile; run /mcp reconnect once the server is up' },
+                    { id: 'retry', label: 'Try a different transport', description: 'Re-open the picker' },
+                    { id: 'cancel', label: 'Cancel', description: 'Discard — nothing written' },
+                ],
+            });
+            if (choice.kind !== 'pick' || choice.id === 'cancel') {
+                console.log(chalk.yellow('\n  /login cancelled.\n'));
+                return true;
+            }
+            if (choice.id === 'retry')
+                continue;
+        }
+        else {
+            console.log(chalk.green(`\n  ✓ Probe succeeded (${probe.latencyMs}ms).`));
+        }
+        ctx.config.servers[profileName] = serverConfig;
+        ctx.config.activeServer = profileName;
+        saveConfig(ctx.config);
+        const apiKeyDisplay = serverConfig.apiKey ? maskApiKey(serverConfig.apiKey) : '(no key)';
+        console.log(chalk.green(`  ✓ MCP profile "${profileName}" saved as active. ${apiKeyDisplay}`));
+        console.log(chalk.gray('    Run /mcp reconnect to pick up the new transport without restarting.\n'));
+        // 0.3.7 — follow-on LLM credential step. Pre-0.3.7 `/login`
+        // *only* handled the MCP profile; users who wanted to refresh
+        // their LLM API key in the same flow had to bounce out to
+        // `/config` or `/init`. Now we offer it inline.
+        //
+        // Always offer (per user direction); default-No when LLM
+        // creds are already populated, default-Yes when missing.
+        const hasLlm = Boolean(ctx.config.llm?.apiKey?.trim()) && Boolean(ctx.config.llm?.endpoint);
+        const promptSubtitle = hasLlm
+            ? `Current: ${ctx.config.llm?.model ?? '(unset)'} @ ${ctx.config.llm?.endpoint ?? '(no endpoint)'} · key ${maskApiKey(ctx.config.llm?.apiKey ?? '')}`
+            : 'No LLM credentials saved yet — set them now so the next turn works.';
+        const llmChoice = await pickFromList({
+            theme,
+            title: 'Update LLM credentials?',
+            subtitle: promptSubtitle,
+            rows: hasLlm ? [
+                { id: 'skip', label: 'Skip — keep current LLM config', description: 'Press ENTER to exit /login' },
+                { id: 'update', label: 'Update LLM', description: 'Switch provider / paste a new key / change model' },
+            ] : [
+                { id: 'update', label: 'Set LLM now', description: 'Provider → API key → Model' },
+                { id: 'skip', label: 'Skip — set up later via /config', description: 'Exit /login without LLM config' },
+            ],
+            initialCursor: 0,
+        });
+        if (llmChoice.kind === 'pick' && llmChoice.id === 'update') {
+            const ok = await editLlm(ctx);
+            if (!ok) {
+                console.log(chalk.yellow('  /login — LLM step cancelled; MCP profile saved.\n'));
+            }
+        }
+        return true;
+    }
+}
+async function probeMcpProfile(serverConfig, name) {
+    const wrapper = new McpClientWrapper();
+    const start = Date.now();
+    try {
+        await Promise.race([
+            wrapper.connect(serverConfig, undefined, name),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timed out after 5s')), 5_000)),
+        ]);
+        await wrapper.close();
+        return { ok: true, latencyMs: Date.now() - start };
+    }
+    catch (err) {
+        try {
+            await wrapper.close();
+        }
+        catch { /* ignore */ }
+        return { ok: false, error: String(err?.message ?? err) };
+    }
+}

package/dist/cli/commands/mcp.d.ts

@@ -1,17 +1,19 @@
 /**
- * 0.3.6 item 11: `/mcp` slash-command surface. Scope-limited foundation —
- * the full multi-MCP federation (parallel cross-MCP tool calls, MCP
- * marketplace, capability tiers) is deferred to 0.4.0. What ships here:
+ * `/mcp` slash-command surface. 0.3.7 multi-MCP rewrite — third-party
+ * MCPs connect concurrently while BrainRouter MCP profiles are mutually
+ * exclusive so exactly one brain is active at a time.
  *
- *   /mcp           — show status of the active MCP (alias for /mcp list)
- *   /mcp list      — list every configured profile with identity + status
- *   /mcp reconnect — reconnect the currently-active profile
- *   /mcp tools     — list MCP tools grouped by namespace (pre-Item-11
- *                    `/mcp` no-arg behaviour, moved here verbatim)
+ *   /mcp                    — alias for /mcp list
+ *   /mcp list               — every configured profile + per-server status
+ *   /mcp tools [server]     — MCP tools grouped by `mcp__<server>__*`
+ *                             namespace; pass a server id to scope
+ *   /mcp connect <name>     — connect a configured server that's idle/offline
+ *   /mcp disconnect <name>  — close one server's transport (config preserved)
+ *   /mcp reconnect [name]   — reconnect ONE (when name given) or the selected pool
  *
- * The reconnect path leans on `mcpClient.close()` + `mcpClient.connect()`
- * with the same config the CLI launched against — no plumbing required
- * for the user beyond typing the command.
+ * Backwards-compat: `/mcp reconnect` with no arg reconnects the same
+ * selected set used at boot: all third-party MCPs plus the active
+ * BrainRouter MCP. Pass an explicit name to target one.
  */
 import type { CommandContext } from './_context.js';
 export declare function tryHandleMcpCommand(ctx: CommandContext): Promise<boolean>;