@spinabot/brigade 1.22.1 → 1.24.0

package/dist/ui/onboarding.js

@@ -25,9 +25,12 @@ import { upsertApiKeyProfile, upsertApiKeyRefProfile, upsertOAuthProfile, upsert
 import { DEFAULT_AGENT_ID, resolveAuthProfilesPath, resolveModelsPath } from "../config/paths.js";
 import { saveConfig } from "../core/config.js";
 import { readClaudeCliLogin, readCodexCliLogin } from "../integrations/cli-login.js";
+import { isClaudeCliAvailable } from "../agents/claude-cli/availability.js";
+import { CLAUDE_CLI_DEFAULT_MODEL, CLAUDE_CLI_MODELS } from "../agents/claude-cli/catalog.js";
+import { hasBrigadeClaudeLogin, writeBrigadeClaudeCredential } from "../agents/claude-cli/claude-config.js";
 import { writeCustomProviderToModelsJson } from "../integrations/custom-provider.js";
 import { discoverOllamaModels, writeOllamaToModelsJson } from "../integrations/ollama.js";
-import { findProvider, PROVIDERS, readProviderEnvKey, resolveProviderEnvVarSource, } from "../providers/catalog.js";
+import { findProvider, PROVIDERS, readProviderEnvKey, resolveProviderEnvVarSource, routesToCustomProvider, } from "../providers/catalog.js";
 import { validateApiKeyOnline } from "../providers/validate-key.js";
 import { renderBrandHeader } from "./brand.js";
 import { brand, selectListTheme } from "./theme.js";
@@ -194,6 +197,19 @@ export async function runOnboarding(tui, authStorage, modelRegistry, opts = {})
                 step = "model";
                 continue;
             }
+            // claude-cli backend — no key + no browser flow: the `claude` binary
+            // authenticates with its OWN login. Validate the binary is installed
+            // and logged in; if not, guide the operator to run `claude` once. Models
+            // are synthesized, so nothing is written to models.json.
+            if (providerInfo?.id === "claude-cli") {
+                const result = await ensureClaudeCli(tui, authStorage);
+                if (result === "back") {
+                    step = "provider";
+                    continue;
+                }
+                step = "model";
+                continue;
+            }
             // CLI-login reuse — if the provider can adopt an already-logged-in
             // vendor CLI's token on this machine (Claude Code, Codex), offer the
             // one-keystroke "reuse this login" path FIRST. "other" means no CLI
@@ -233,7 +249,12 @@ export async function runOnboarding(tui, authStorage, modelRegistry, opts = {})
             // Custom (catalog-defined) providers — a key + a known
             // Anthropic-compatible endpoint (GLM, Kimi, Qwen, MiniMax, DeepSeek).
             // Paste the key, register the endpoint + models into models.json, done.
-            if (providerInfo?.custom && providerInfo.baseUrl) {
+            // Also handles the generic "Custom (OpenAI-compatible)" entry, which
+            // has `custom: true` but no pre-set `baseUrl`. `ensureCustomProvider`
+            // prompts for the URL when it's missing. Without this, the generic
+            // custom path falls through to `ensureApiKey`, which never writes
+            // `models.json` — leaving the model unresolvable at gateway startup.
+            if (routesToCustomProvider(providerInfo)) {
                 const r = await ensureCustomProvider(tui, authStorage, modelRegistry, providerInfo);
                 if (r === "back") {
                     step = "provider";
@@ -256,6 +277,17 @@ export async function runOnboarding(tui, authStorage, modelRegistry, opts = {})
         }
         // step === "model"
         renderScreen(tui, "Step 4 of 5 · Default model");
+        // claude-cli models are synthesized (not in the registry), so pick from the
+        // backend's own catalog instead of the registry-backed picker.
+        if (provider === "claude-cli") {
+            const result = await pickClaudeCliModel(tui);
+            if (result === "back") {
+                step = "provider";
+                continue;
+            }
+            modelId = result.modelId;
+            break; // model chosen — exit the wizard loop to persist + finish
+        }
         const result = await pickModel(tui, modelRegistry, findProvider(provider)?.providerId ?? provider);
         if (result === "back") {
             step = "provider"; // go all the way back so they can change provider too
@@ -378,10 +410,22 @@ async function pickProvider(tui) {
         const isBYO = p.custom === true && !p.baseUrl;
         let rank;
         let badge;
-        // A subscription provider stays "log in" (browser-first, multi-account) even
-        // when a CLI login is on disk — reuse is offered as a secondary option inside
-        // the flow. Only a pure CLI-login provider gets the rank-0 "reuse" treatment.
-        if (cliReady && !isSubscription) {
+        // The claude-cli backend: it's `local+noAuth` in the catalog, but it's a
+        // SUBSCRIPTION path, not a local server. Rank it with the subscription tier
+        // and surface it at the very top when the binary is installed + logged in
+        // (the cleanest "no extra-usage" route). Checked BEFORE the generic
+        // cliReady / local branches so it doesn't get the wrong badge.
+        if (p.id === "claude-cli") {
+            const ready = isClaudeCliAvailable() && (readClaudeCliLogin() !== null || hasBrigadeClaudeLogin());
+            rank = ready ? 0 : 2;
+            badge = ready
+                ? "installed + signed in — subscription, no key, no extra-usage"
+                : "your Claude subscription — browser sign-in, no key, no extra-usage";
+        }
+        else if (cliReady && !isSubscription) {
+            // A subscription provider stays "log in" (browser-first, multi-account)
+            // even when a CLI login is on disk — reuse is offered as a secondary
+            // option inside the flow. Only a pure CLI-login provider gets rank-0.
             rank = 0;
             badge = "logged in — reuse, no key";
         }
@@ -970,6 +1014,269 @@ export async function ensureSubscriptionLogin(tui, authStorage, provider) {
         return "ok";
     }
 }
+/** True when EITHER the operator's own `claude` login OR Brigade's managed
+ *  dedicated login is present — the backend can run with either. */
+function claudeCliLoggedIn() {
+    return readClaudeCliLogin() !== null || hasBrigadeClaudeLogin();
+}
+/**
+ * Connect the claude-cli backend end to end — no terminal, no token paste:
+ *   1. Ensure the `claude` binary is installed (offer to `npm i -g` it).
+ *   2. Ensure a login exists — if not, drive the SAME browser OAuth Brigade uses
+ *      for Claude Pro/Max and write the result into Brigade's OWN Claude config
+ *      dir (a dedicated grant, isolated from the operator's personal ~/.claude).
+ * Turns then run on the Claude subscription via the binary (no extra-usage).
+ *
+ * Returns "ok" to proceed to model selection, or "back" to re-pick the provider.
+ */
+export async function ensureClaudeCli(tui, authStorage) {
+    while (true) {
+        renderScreen(tui, "Step 3 of 5 · Connect Claude");
+        // ── 1. binary present? ──
+        if (!isClaudeCliAvailable({ force: true })) {
+            tui.addChild(new Text(`  ${brand.white("Brigade runs on your Claude subscription via the Claude Code engine.")}`, 0, 0));
+            tui.addChild(new Text(brand.dim("  The `claude` command isn't installed yet. Brigade can install it for you."), 0, 0));
+            tui.addChild(new Text("", 0, 0));
+            const choice = new SelectList([
+                { value: "install", label: "Install it now", description: "runs: npm i -g @anthropic-ai/claude-code" },
+                { value: "recheck", label: "I'll install it myself — re-check", description: "" },
+            ], 2, selectListTheme, { minPrimaryColumnWidth: 18, maxPrimaryColumnWidth: 24 });
+            tui.addChild(choice);
+            tui.setFocus(choice);
+            tui.requestRender();
+            let pick;
+            try {
+                const chosen = await new Promise((resolve, reject) => {
+                    choice.onSelect = (item) => resolve(item);
+                    choice.onCancel = () => reject(new Error("back"));
+                });
+                pick = chosen.value === "install" ? "install" : "recheck";
+            }
+            catch {
+                return "back";
+            }
+            if (pick === "install") {
+                renderScreen(tui, "Step 3 of 5 · Connect Claude");
+                const loader = new CancellableLoader(tui, (s) => brand.amber(s), (s) => brand.dim(s), "Installing Claude Code (npm i -g @anthropic-ai/claude-code)…");
+                tui.addChild(loader);
+                tui.requestRender();
+                const ok = await installClaudeCode();
+                loader.stop?.();
+                if (!ok) {
+                    renderScreen(tui, "Step 3 of 5 · Connect Claude");
+                    tui.addChild(new Text(`  ${brand.error("✗")} ${brand.error("Install failed. Run `npm i -g @anthropic-ai/claude-code` manually, then Enter.")}`, 0, 0));
+                    const c = new Input();
+                    tui.addChild(c);
+                    tui.setFocus(c);
+                    tui.requestRender();
+                    try {
+                        await new Promise((res, rej) => {
+                            c.onSubmit = () => res();
+                            c.onEscape = () => rej(new Error("back"));
+                        });
+                    }
+                    catch {
+                        return "back";
+                    }
+                }
+            }
+            continue; // re-loop: re-check install state
+        }
+        // ── 2. login present? ──
+        if (claudeCliLoggedIn()) {
+            tui.addChild(new Text(`  ${brand.amber("✓")} ${brand.dim("Claude is installed and signed in.")}`, 0, 0));
+            tui.addChild(new Text(brand.dim("  Turns run on your Claude subscription — no key, no extra-usage billing."), 0, 0));
+            tui.addChild(new Text("", 0, 0));
+            tui.addChild(new Text(brand.dim("  Enter to continue  ·  Esc to go back"), 0, 0));
+            const confirm = new Input();
+            tui.addChild(confirm);
+            tui.setFocus(confirm);
+            tui.requestRender();
+            try {
+                await new Promise((resolve, reject) => {
+                    confirm.onSubmit = () => resolve();
+                    confirm.onEscape = () => reject(new Error("back"));
+                });
+            }
+            catch {
+                return "back";
+            }
+            return "ok";
+        }
+        // ── 3. no login → drive the browser OAuth ourselves, write Brigade's grant ──
+        tui.addChild(new Text(`  ${brand.white("Sign in to your Claude account")}`, 0, 0));
+        tui.addChild(new Text(brand.dim("  We'll open your browser. Approve it there — no key, no terminal."), 0, 0));
+        tui.addChild(new Text(brand.dim("  Enter to start  ·  Esc to go back"), 0, 0));
+        const start = new Input();
+        tui.addChild(start);
+        tui.setFocus(start);
+        tui.requestRender();
+        try {
+            await new Promise((resolve, reject) => {
+                start.onSubmit = () => resolve();
+                start.onEscape = () => reject(new Error("back"));
+            });
+        }
+        catch {
+            return "back";
+        }
+        tui.removeChild(start);
+        const result = await runClaudeBrowserLogin(tui, authStorage);
+        if (result === "ok") {
+            tui.addChild(new Text("", 0, 0));
+            tui.addChild(new Text(`  ${brand.amber("✓")} Signed in — your Claude subscription is connected.`, 0, 0));
+            tui.requestRender();
+            await delay(600);
+            return "ok";
+        }
+        if (result === "back")
+            return "back";
+        // "retry" → loop shows the sign-in prompt again.
+    }
+}
+/**
+ * Install Claude Code globally via npm. Returns true on success. Best-effort +
+ * bounded; surfaces nothing itself (the caller renders status).
+ */
+async function installClaudeCode() {
+    return await new Promise((resolve) => {
+        try {
+            const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+            const child = spawn(npm, ["install", "-g", "@anthropic-ai/claude-code"], {
+                stdio: "ignore",
+                shell: process.platform === "win32",
+            });
+            const timer = setTimeout(() => {
+                try {
+                    child.kill();
+                }
+                catch {
+                    /* already gone */
+                }
+                resolve(false);
+            }, 180_000);
+            timer.unref?.();
+            child.on("close", (code) => {
+                clearTimeout(timer);
+                resolve(code === 0 && isClaudeCliAvailable({ force: true }));
+            });
+            child.on("error", () => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+/**
+ * Drive Brigade's browser OAuth for Anthropic (the same flow Claude Pro/Max
+ * onboarding uses — pi-ai requests the full Claude Code scopes) and write the
+ * result into Brigade's OWN managed Claude config dir, so the `claude` binary
+ * authenticates + refreshes from Brigade's dedicated grant. Also mirrors the
+ * credential into Brigade's anthropic profile so the HTTP path is available too.
+ *
+ * Returns "ok" on success, "back" on user abort, "retry" on a recoverable error.
+ */
+async function runClaudeBrowserLogin(tui, authStorage) {
+    const oauthProvider = getOAuthProvider("anthropic");
+    if (!oauthProvider) {
+        tui.addChild(new Text(`  ${brand.error("✗")} ${brand.error("Browser sign-in isn't available in this build.")}`, 0, 0));
+        tui.requestRender();
+        await delay(1200);
+        return "back";
+    }
+    const controller = new AbortController();
+    let creds;
+    try {
+        creds = (await oauthProvider.login({
+            onAuth: (info) => {
+                tui.addChild(new Text(`  ${brand.amber("→")} Opening your browser to sign in…`, 0, 0));
+                openSubscriptionBrowser(info.url);
+                tui.addChild(new Text("", 0, 0));
+                tui.addChild(new Text("  " + brand.amber(info.url), 0, 0));
+                tui.addChild(new Text(brand.dim("  If your browser didn't open, copy the link above. Paste the code here if asked."), 0, 0));
+                const waiter = new CancellableLoader(tui, (s) => brand.amber(s), (s) => brand.dim(s), "Waiting for you to authorize…");
+                waiter.onAbort = () => controller.abort();
+                tui.addChild(waiter);
+                tui.setFocus(waiter);
+                tui.requestRender();
+            },
+            onManualCodeInput: () => new Promise((resolve, reject) => {
+                tui.addChild(new Text("", 0, 0));
+                tui.addChild(new Text(brand.dim("  Paste the code or redirect URL, then press Enter  ·  Esc to cancel"), 0, 0));
+                const input = new Input();
+                tui.addChild(input);
+                tui.setFocus(input);
+                tui.requestRender();
+                input.onSubmit = (value) => resolve(sanitizePastedValue(value));
+                input.onEscape = () => reject(new Error("cancelled"));
+            }),
+            onProgress: (msg) => {
+                tui.addChild(new Text(brand.dim("  " + msg), 0, 0));
+                tui.requestRender();
+            },
+            // Anthropic's loopback flow never uses these, but the callback contract
+            // requires them — provide minimal implementations so the type + runtime
+            // are both satisfied.
+            onDeviceCode: () => {
+                /* not used by the anthropic loopback flow */
+            },
+            onPrompt: (p) => new Promise((resolve, reject) => {
+                tui.addChild(new Text("", 0, 0));
+                tui.addChild(new Text(`  ${p.message}`, 0, 0));
+                const input = new Input();
+                tui.addChild(input);
+                tui.setFocus(input);
+                tui.requestRender();
+                input.onSubmit = (value) => {
+                    const v = value.trim();
+                    if (!v && !p.allowEmpty)
+                        return;
+                    resolve(v);
+                };
+                input.onEscape = () => reject(new Error("cancelled"));
+            }),
+            onSelect: (p) => new Promise((resolve) => {
+                const list = new SelectList(p.options.map((o) => ({ value: o.id, label: o.label })), Math.min(p.options.length, 6), selectListTheme, { minPrimaryColumnWidth: 12, maxPrimaryColumnWidth: 28 });
+                tui.addChild(list);
+                tui.setFocus(list);
+                tui.requestRender();
+                list.onSelect = (item) => resolve(item.value);
+                list.onCancel = () => resolve(undefined);
+            }),
+            signal: controller.signal,
+        }));
+    }
+    catch (err) {
+        controller.abort();
+        const reason = err instanceof Error ? err.message : String(err);
+        const softCancel = /^login cancelled$/i.test(reason) || reason === "cancelled" || reason === "back";
+        tui.addChild(new Text(`  ${brand.error("✗")} ${brand.error(softCancel ? "Sign-in cancelled." : "Couldn't finish signing in — check your connection and try again.")}`, 0, 0));
+        tui.requestRender();
+        await delay(1000);
+        return softCancel ? "back" : "retry";
+    }
+    // Write Brigade's dedicated Claude login ONLY into the managed config dir.
+    // The `claude` binary owns this grant from here on: it authenticates AND
+    // refreshes (rotating the refresh token) in-place. We deliberately DON'T
+    // also mirror it into Brigade's anthropic auth-profile — that would create a
+    // SECOND independent refresher (Brigade's HTTP-path backend) for the same
+    // grant, and the two would rotate each other's refresh token to death
+    // (the split-brain failure). Single grant, single owner (the binary).
+    void authStorage; // intentionally unused now — kept for signature stability
+    try {
+        writeBrigadeClaudeCredential({ access: creds.access, refresh: creds.refresh, expires: creds.expires });
+    }
+    catch (err) {
+        tui.addChild(new Text(`  ${brand.error("✗")} ${brand.error(`Couldn't save the login: ${err.message}`)}`, 0, 0));
+        tui.requestRender();
+        await delay(1200);
+        return "retry";
+    }
+    return "ok";
+}
 /**
  * Connect a subscription provider that ALSO has a vendor CLI login on disk
  * (Claude Code / Codex). When such a login exists we present a choice that LEADS
@@ -1022,6 +1329,12 @@ async function ensureCliLogin(tui, authStorage, provider) {
             access: cred.access,
             refresh: cred.refresh,
             expires: cred.expires,
+            // Borrowed from the vendor CLI's on-disk login — mark the family so
+            // `adoptNewerClaudeCliLogin` keeps adopting the CLI's rotations
+            // instead of refreshing (and rotating) a stale shared grant.
+            ...(provider.cliLogin.read === "claude"
+                ? { metadata: { importedFrom: "claude-cli" } }
+                : {}),
         });
         authStorage.set(cred.provider, {
             type: "oauth",
@@ -1085,6 +1398,53 @@ async function ensureCliLogin(tui, authStorage, provider) {
  *   - "back" → user pressed Esc; caller rewinds to the provider picker
  */
 async function ensureCustomProvider(tui, authStorage, modelRegistry, provider) {
+    // Generic custom provider — the catalog entry has `custom: true` but no
+    // pre-set `baseUrl` (it varies per user). Prompt for the URL before the
+    // key-entry loop, then attach it to a shallow copy so the downstream
+    // write path sees a fully resolved provider without mutating the catalog.
+    if (!provider.baseUrl) {
+        let urlError = null;
+        while (true) {
+            renderScreen(tui, `Step 3 of 5 · ${provider.name}`);
+            // Render the error at the TOP of the loop (before the prompt), with the
+            // single requestRender() below. Adding it AFTER requestRender lets the
+            // next iteration's clear() wipe it before it ever paints — a silent
+            // re-prompt with no reason shown. Mirrors the key-entry loop's lastError.
+            if (urlError) {
+                tui.addChild(new Text(`  ${brand.error("✗")} ${brand.error(urlError)}`, 0, 0));
+                tui.addChild(new Text("", 0, 0));
+            }
+            tui.addChild(new Text(`  Enter your OpenAI-compatible base URL.`, 0, 0));
+            tui.addChild(new Text(brand.dim("  Example: https://api.example.com/v1"), 0, 0));
+            tui.addChild(new Text(brand.dim("  Enter to continue  ·  Esc to go back"), 0, 0));
+            tui.addChild(new Text("", 0, 0));
+            const urlInput = new Input();
+            tui.addChild(urlInput);
+            tui.setFocus(urlInput);
+            tui.requestRender();
+            let rawUrl;
+            try {
+                rawUrl = await new Promise((resolve, reject) => {
+                    urlInput.onSubmit = (value) => resolve(value.trim());
+                    urlInput.onEscape = () => reject(new Error("back"));
+                });
+            }
+            catch {
+                return "back";
+            }
+            if (!rawUrl) {
+                urlError = "Enter a base URL, or press Esc to go back.";
+                continue;
+            }
+            // Minimal URL sanity check — must start with http(s)://.
+            if (!/^https?:\/\//i.test(rawUrl)) {
+                urlError = "URL must start with http:// or https://";
+                continue;
+            }
+            provider = { ...provider, baseUrl: rawUrl, api: provider.api ?? "openai-completions" };
+            break;
+        }
+    }
     let lastError = null;
     // If the operator already has this provider's key in their environment (e.g.
     // NVIDIA_API_KEY), OFFER it — confirm-then-validate, never silent-adopt. A
@@ -1278,6 +1638,37 @@ async function pickModel(tui, modelRegistry, providerId) {
         return "back";
     }
 }
+/** Model picker for the claude-cli backend — its models are synthesized (not in
+ *  the registry), so we present the backend's own catalog. */
+async function pickClaudeCliModel(tui) {
+    const items = CLAUDE_CLI_MODELS.map((m) => ({
+        value: m.id,
+        label: m.id,
+        description: m.name,
+    }));
+    // Default first = the catalog default (Sonnet), then the rest as listed.
+    items.sort((a, b) => a.value === CLAUDE_CLI_DEFAULT_MODEL ? -1 : b.value === CLAUDE_CLI_DEFAULT_MODEL ? 1 : 0);
+    const list = new SearchableSelectList(items, 8, selectListTheme, {
+        minPrimaryColumnWidth: 26,
+        maxPrimaryColumnWidth: 38,
+        formatHeader: (q, matchCount, total) => brand.dim(q.length > 0
+            ? `  search: ${q}▌  (${matchCount}/${total})`
+            : `  ${total} models · ↑↓ move · Enter select · Esc back`),
+    });
+    tui.addChild(list);
+    tui.setFocus(list);
+    tui.requestRender();
+    try {
+        const chosen = await new Promise((resolve, reject) => {
+            list.onSelect = (item) => resolve(item);
+            list.onCancel = () => reject(new Error("back"));
+        });
+        return { modelId: chosen.value };
+    }
+    catch {
+        return "back";
+    }
+}
 function renderDone(tui, provider, modelId) {
     const p = findProvider(provider)?.name ?? provider;
     tui.addChild(new Text("", 0, 0));