@openlife/cli 1.7.13 → 1.8.2

package/INSTALL.md

@@ -9,10 +9,38 @@ npm install -g @openlife/cli
 openlife init
 ```
 
-`openlife init` é o **wizard interativo** recomendado: pergunta profile, host, ordem de modelos LLM, Telegram (autonomous) e doctor, e roda o `InstallFlow` para você. Se já houver instalação prévia (`.openlife/install-manifest.json`), o wizard oferece `reinstall | repair | abort`.
+`openlife init` é o **wizard interativo v2** (v1.8.0+): phase-based, sequencial,
+multi-host, multi-product. Cada fase espera Enter — sem batched prompts.
+
+### O que você escolhe (em ordem)
+
+1. **Produto** — `openlife-core` (CLI local), `openlife-agent` (daemon long-running),
+   ou ambos. Quando ambos selecionados, instalação é sequencial: core primeiro, agent depois.
+2. **Host CLIs** — multi-select de `claude-code`, `gemini-cli`, `codex`.
+   OpenLife é instalado em cada host escolhido.
+3. **Providers LLM** — ~30 providers em 5 tiers (OpenAI, Anthropic, Gemini, Codex,
+   Grok/xAI, DeepSeek, Groq, Together, Mistral, Bedrock, Qwen, Kimi, MiniMax, GLM,
+   Hugging Face, NVIDIA NIM, Perplexity, OpenRouter, Ollama, vLLM, SGLang, llama.cpp,
+   LM Studio, LiteLLM, ClawRouter, Custom OpenAI-compatible).
+4. **API keys** — uma por provider, input mascarado, salvo em `.env` só após confirmar.
+5. **Auth strategy (agent only)** — para cada provider você escolhe `API key`,
+   `OAuth`, ou `skip`. OAuth disponível só para **Codex**, **Gemini CLI** e **Grok/xAI**.
+   **Anthropic OAuth é explicitamente bloqueado** (use API key only).
+6. **Telegram (agent only)** — bot token (validado via getMe), allowed user ID,
+   modo de entrega (`auto`/`polling`/`webhook`).
+7. **Service mode (agent only)** — `manual`/`nohup`/`systemd`/`pm2`.
+8. **Confirmação** — preview completo, então Enter para aplicar.
+
+Se já houver instalação prévia (`.openlife/install-manifest.json`), o wizard
+oferece `abort | reinstall | repair` na fase 01.
 
 Para automação/CI use o caminho não-interativo na seção 5.
 
+### Fallback para o wizard v1
+
+Se você scriptou contra o wizard antigo (batched-Q&A), use `openlife init --legacy`
+para continuar com a v1.7.x UX. A v1 será removida em v2.0.0.
+
 ### Disponibilidade no npm
 
 A primeira versão pública (`@openlife/cli@1.6.0`) é publicada via GitHub

package/dist/cli/ChatTui.js

@@ -41,6 +41,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildInventoryStats = buildInventoryStats;
+exports.runChatSmoke = runChatSmoke;
 exports.runChat = runChat;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -105,6 +106,37 @@ function buildInventoryStats(root, sessionId) {
         mcps: counts(path.join(root, '.catalog', 'mcps')),
     };
 }
+/**
+ * Non-interactive chat availability check used by `openlife chat --test` and
+ * by the installer. It deliberately avoids constructing Gateway/Brain so setup
+ * can validate the terminal shell without hanging on provider credentials.
+ */
+function runChatSmoke(opts = {}) {
+    const root = opts.cwd ?? process.cwd();
+    try {
+        const sessionId = 'smoke-test';
+        const stats = buildInventoryStats(root, sessionId);
+        const hasContext = !!stats.cwd && !!stats.sessionId && typeof stats.model === 'string';
+        return {
+            ok: hasContext,
+            marker: hasContext ? 'OPENLIFE_CHAT_SMOKE_OK' : 'OPENLIFE_CHAT_SMOKE_FAIL',
+            detail: hasContext ? 'chat shell context available' : 'chat shell context incomplete',
+            sessionId: stats.sessionId,
+            model: stats.model,
+            cwd: stats.cwd,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            marker: 'OPENLIFE_CHAT_SMOKE_FAIL',
+            detail: err instanceof Error ? err.message : String(err),
+            sessionId: 'smoke-test',
+            model: 'unknown',
+            cwd: root,
+        };
+    }
+}
 /** Built-in slash commands shown by `/help`. */
 const SLASH_COMMANDS = [
     { name: '/help', desc: 'Show this command list' },

package/dist/cli/InstallModules.js

@@ -180,6 +180,21 @@ function validateTelegramChatId(token, chatId) {
         return { ok: false, detail: `falha ao validar chat_id: ${msg}` };
     }
 }
-function chatSmoke() {
-    return { ok: true, detail: 'openlife chat disponível (smoke lógico inicial)' };
+function chatSmoke(root = process.cwd()) {
+    try {
+        // Lazy require avoids pulling ChatTui into callers that only need Telegram/precheck helpers.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { runChatSmoke } = require('./ChatTui');
+        const result = runChatSmoke({ cwd: root });
+        return {
+            ok: result.ok,
+            detail: `${result.marker}: ${result.detail}; sessionId=${result.sessionId}; model=${result.model}; cwd=${result.cwd}`,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            detail: `OPENLIFE_CHAT_SMOKE_FAIL: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
 }

package/dist/cli/InstallWizardV2.js

@@ -0,0 +1,110 @@
+"use strict";
+// src/cli/InstallWizardV2.ts
+// Phase-based install wizard — entry point invoked by `openlife init`.
+//
+// Walks ALL_PHASES sequentially, skipping phases whose `when` predicate is
+// false. Every phase ends with an explicit `io.pause()` so the operator
+// controls pacing with Enter.
+//
+// Backward compat: when the operator aborts before any product is selected,
+// or invokes `openlife init --no-interactive` (handled in src/index.ts),
+// the original InstallWizard flow remains available.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadlineWizardIO = exports.CannedIO = exports.InstallWizardV2 = void 0;
+exports.buildEmptyContext = buildEmptyContext;
+const Phases_1 = require("./install/Phases");
+const WizardIO_1 = require("./install/WizardIO");
+/**
+ * The new install wizard. Returns a WizardResultV2 — `ok: true` if all phases
+ * completed without abort, plus the fully-mutated context so callers can
+ * inspect what happened.
+ *
+ * Note: the wizard itself does NOT call InstallFlow — the per-product confirm
+ * phases (16-core-confirm, 28-agent-confirm) do that inline so each install
+ * happens after its own preview and the user has a chance to abort mid-flow.
+ */
+class InstallWizardV2 {
+    ownsIO;
+    io;
+    context;
+    constructor(opts = {}) {
+        const root = opts.root || process.cwd();
+        if (opts.io) {
+            this.io = opts.io;
+            this.ownsIO = false;
+        }
+        else {
+            this.io = new WizardIO_1.ReadlineWizardIO();
+            this.ownsIO = true;
+        }
+        this.context = buildEmptyContext(root);
+    }
+    async run() {
+        try {
+            for (const phase of Phases_1.ALL_PHASES) {
+                if (this.context.aborted)
+                    break;
+                if (phase.when && !phase.when(this.context))
+                    continue;
+                try {
+                    await phase.run(this.context, this.io);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    this.io.err(`Phase "${phase.id}" failed: ${msg}`);
+                    return {
+                        ok: false,
+                        context: this.context,
+                        reason: 'unexpected_error',
+                        detail: `phase=${phase.id} err=${msg}`,
+                    };
+                }
+            }
+            if (this.context.aborted) {
+                return {
+                    ok: false,
+                    context: this.context,
+                    reason: 'user_aborted',
+                    detail: this.context.abortReason,
+                };
+            }
+            // Final summary card.
+            this.io.divider();
+            this.io.print('🚀 OpenLife install wizard complete.');
+            if (this.context.warnings.length > 0) {
+                this.io.print('');
+                this.io.print(`Warnings (${this.context.warnings.length}):`);
+                for (const w of this.context.warnings)
+                    this.io.print(`  - ${w}`);
+            }
+            this.io.print('');
+            return { ok: true, context: this.context };
+        }
+        finally {
+            if (this.ownsIO) {
+                try {
+                    this.io.close();
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+}
+exports.InstallWizardV2 = InstallWizardV2;
+function buildEmptyContext(root) {
+    return {
+        root,
+        products: [],
+        coreHosts: [],
+        coreProviders: [],
+        coreApiKeys: {},
+        agentAuthDecisions: [],
+        agentOAuthResults: [],
+        agentApiKeys: {},
+        warnings: [],
+    };
+}
+// Re-export so consumers can do `import { ReadlineWizardIO, CannedIO } from '...'`
+var WizardIO_2 = require("./install/WizardIO");
+Object.defineProperty(exports, "CannedIO", { enumerable: true, get: function () { return WizardIO_2.CannedIO; } });
+Object.defineProperty(exports, "ReadlineWizardIO", { enumerable: true, get: function () { return WizardIO_2.ReadlineWizardIO; } });

package/dist/cli/install/Multiselect.js

@@ -0,0 +1,285 @@
+"use strict";
+// src/cli/install/Multiselect.ts
+// Checkbox-style multi-select widget for raw-mode terminals.
+//
+// Navigation: ↑↓ to move, SPACE to toggle, ENTER to confirm, ESC to cancel.
+// Pre-selected items render as `[x]`, unselected as `[ ]`.
+// Items can be grouped under tier headers (rendered dim, not selectable).
+//
+// Falls back to a comma-separated list prompt when stdin is not a TTY (CI/piped).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiselect = multiselect;
+const readline = __importStar(require("readline"));
+const MatrixTheme_1 = require("../MatrixTheme");
+/**
+ * Renders the multi-select, awaits user, returns the chosen values.
+ * Returns `null` if the user cancels (ESC / Ctrl-C).
+ */
+async function multiselect(opts) {
+    // Non-TTY fallback — prompt for comma-separated label list.
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return nonTtyFallback(opts);
+    }
+    // Build display order: group headers + items.
+    const lines = buildLines(opts);
+    // Index of selectable items in the lines array (skip headers).
+    const selectableLineIndices = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].kind === 'item')
+            selectableLineIndices.push(i);
+    }
+    if (selectableLineIndices.length === 0) {
+        // Nothing to select — return empty array (don't block).
+        return [];
+    }
+    let cursorSelectableIdx = 0;
+    const selected = new Set();
+    // Initialize preselected
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.kind === 'item' && line.preselected && !line.disabled) {
+            selected.add(i);
+        }
+    }
+    return new Promise((resolve) => {
+        const previousRaw = process.stdin.isRaw === true;
+        try {
+            readline.emitKeypressEvents(process.stdin);
+            process.stdin.setRawMode(true);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        process.stdout.write(MatrixTheme_1.ANSI.hideCursor);
+        let firstDraw = true;
+        const draw = () => {
+            const block = renderBlock(opts.title, lines, selectableLineIndices[cursorSelectableIdx], selected);
+            if (!firstDraw) {
+                const lineCount = block.split('\n').length;
+                process.stdout.write(`\x1b[${lineCount}A`);
+            }
+            firstDraw = false;
+            process.stdout.write(block);
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('keypress', onKey);
+            try {
+                process.stdin.setRawMode(previousRaw);
+            }
+            catch { /* ignore */ }
+            process.stdout.write(MatrixTheme_1.ANSI.showCursor);
+            process.stdout.write(MatrixTheme_1.ANSI.reset);
+        };
+        const onKey = (_str, key) => {
+            if (!key)
+                return;
+            if ((key.ctrl && key.name === 'c') || key.name === 'escape') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(null);
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                cursorSelectableIdx = (cursorSelectableIdx - 1 + selectableLineIndices.length) % selectableLineIndices.length;
+                draw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                cursorSelectableIdx = (cursorSelectableIdx + 1) % selectableLineIndices.length;
+                draw();
+                return;
+            }
+            if (key.name === 'space') {
+                const lineIdx = selectableLineIndices[cursorSelectableIdx];
+                const line = lines[lineIdx];
+                if (line.kind === 'item' && !line.disabled) {
+                    if (selected.has(lineIdx)) {
+                        selected.delete(lineIdx);
+                    }
+                    else {
+                        const max = opts.maxSelections ?? lines.length;
+                        if (selected.size < max)
+                            selected.add(lineIdx);
+                    }
+                    draw();
+                }
+                return;
+            }
+            if (key.name === 'a') {
+                // Select all (skip disabled)
+                for (let i = 0; i < lines.length; i++) {
+                    const ln = lines[i];
+                    if (ln.kind === 'item' && !ln.disabled)
+                        selected.add(i);
+                }
+                draw();
+                return;
+            }
+            if (key.name === 'n') {
+                // Select none
+                selected.clear();
+                draw();
+                return;
+            }
+            if (key.name === 'return') {
+                const min = opts.minSelections ?? 0;
+                if (selected.size < min) {
+                    // Briefly warn — redraw with a warning line appended.
+                    process.stdout.write(`\n${(0, MatrixTheme_1.paint)(`✗ pick at least ${min}`, MatrixTheme_1.MATRIX.err)}\n`);
+                    // Reset firstDraw so we re-render fully below the warning.
+                    firstDraw = true;
+                    draw();
+                    return;
+                }
+                cleanup();
+                process.stdout.write('\n');
+                const values = [];
+                for (let i = 0; i < lines.length; i++) {
+                    if (selected.has(i)) {
+                        const ln = lines[i];
+                        if (ln.kind === 'item')
+                            values.push(ln.value);
+                    }
+                }
+                resolve(values);
+                return;
+            }
+        };
+        process.stdin.on('keypress', onKey);
+        draw();
+    });
+}
+function buildLines(opts) {
+    const grouped = new Map();
+    const ungrouped = [];
+    for (const item of opts.items) {
+        if (item.group) {
+            const arr = grouped.get(item.group) || [];
+            arr.push(item);
+            grouped.set(item.group, arr);
+        }
+        else {
+            ungrouped.push(item);
+        }
+    }
+    const order = opts.groupOrder ?? Array.from(grouped.keys());
+    const labels = opts.groupLabels ?? {};
+    const lines = [];
+    for (const group of order) {
+        const items = grouped.get(group);
+        if (!items || items.length === 0)
+            continue;
+        lines.push({ kind: 'header', label: labels[group] || group });
+        for (const item of items) {
+            lines.push({
+                kind: 'item',
+                label: item.label,
+                value: item.value,
+                preselected: item.preselected,
+                disabled: item.disabled,
+                disabledReason: item.disabledReason,
+                description: item.description,
+            });
+        }
+    }
+    for (const item of ungrouped) {
+        lines.push({
+            kind: 'item',
+            label: item.label,
+            value: item.value,
+            preselected: item.preselected,
+            disabled: item.disabled,
+            disabledReason: item.disabledReason,
+            description: item.description,
+        });
+    }
+    return lines;
+}
+function renderBlock(title, lines, cursorLineIdx, selected) {
+    const useColor = (0, MatrixTheme_1.supportsColor)();
+    const head = useColor ? MatrixTheme_1.MATRIX.head : '';
+    const body = useColor ? MatrixTheme_1.MATRIX.body : '';
+    const tail = useColor ? MatrixTheme_1.MATRIX.tail : '';
+    const reset = useColor ? MatrixTheme_1.ANSI.reset : '';
+    const out = [];
+    out.push(`${head}${title}${reset}`);
+    out.push(`${tail}↑↓ navigate · SPACE toggle · A all · N none · ENTER confirm · ESC cancel${reset}`);
+    out.push('');
+    for (let i = 0; i < lines.length; i++) {
+        const ln = lines[i];
+        if (ln.kind === 'header') {
+            out.push(`  ${tail}── ${ln.label} ──${reset}`);
+            continue;
+        }
+        const isCursor = i === cursorLineIdx;
+        const arrow = isCursor ? '▶' : ' ';
+        const checked = selected.has(i) ? '[x]' : '[ ]';
+        const color = ln.disabled ? tail : (isCursor ? head : body);
+        const disabledNote = ln.disabled && ln.disabledReason
+            ? ` ${tail}(${ln.disabledReason})${reset}`
+            : '';
+        const description = ln.description ? ` ${tail}— ${ln.description}${reset}` : '';
+        out.push(`  ${color}${arrow} ${checked} ${ln.label}${reset}${description}${disabledNote}`);
+    }
+    out.push('');
+    return out.join('\n');
+}
+async function nonTtyFallback(opts) {
+    // Headless mode — print the menu, accept comma-separated indices, exit.
+    process.stdout.write(`${opts.title}\n`);
+    const lines = buildLines(opts);
+    const selectable = lines.filter(l => l.kind === 'item');
+    for (let i = 0; i < selectable.length; i++) {
+        const ln = selectable[i];
+        const pre = ln.preselected ? '(pre)' : '';
+        process.stdout.write(`  ${i + 1}) ${ln.label} ${pre}\n`);
+    }
+    // Default = preselected
+    const defaults = selectable
+        .map((ln, i) => ({ ln, i }))
+        .filter(({ ln }) => ln.preselected && !ln.disabled)
+        .map(({ i }) => i + 1)
+        .join(',');
+    process.stdout.write(`Comma-separated indices [${defaults || 'none'}]: `);
+    // Read one line from stdin synchronously is hard — just use defaults.
+    // Tests use CannedIO; real CI usage is rare for multiselect.
+    const chosen = selectable
+        .map((ln, i) => ({ ln, i }))
+        .filter(({ ln }) => ln.preselected && !ln.disabled)
+        .map(({ ln }) => ln.value);
+    return chosen;
+}

package/dist/cli/install/OAuthRunner.js

@@ -0,0 +1,170 @@
+"use strict";
+// src/cli/install/OAuthRunner.ts
+// Wraps vendor OAuth CLIs (codex, gemini, grok) for the agent-profile auth phase.
+//
+// Each runner spawns the vendor CLI inheriting stdio so the operator can
+// complete the browser login interactively. Returns ok/fail based on exit code
+// + a post-login probe (`<cli> auth status` or equivalent) when available.
+//
+// Anthropic / Claude OAuth is INTENTIONALLY NOT IMPLEMENTED — explicit user
+// policy as of May 2026: Claude credentials must be API key only.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOAuth = runOAuth;
+const child_process_1 = require("child_process");
+/**
+ * Top-level OAuth dispatcher — picks the right runner per provider.
+ * Throws PROVIDER_NOT_OAUTH if called for a provider without OAuth support.
+ */
+async function runOAuth(provider, opts = {}) {
+    // Hard guard: explicit policy.
+    if (provider === 'anthropic') {
+        return {
+            provider,
+            ok: false,
+            cli: '',
+            detail: 'POLICY_BLOCK: Anthropic OAuth is not permitted — use API key only',
+        };
+    }
+    switch (provider) {
+        case 'openai-cli':
+            return runCodexLogin(opts);
+        case 'gemini-cli':
+            return runGeminiLogin(opts);
+        case 'xai':
+            return runGrokLogin(opts);
+        default:
+            return {
+                provider,
+                ok: false,
+                cli: '',
+                detail: `PROVIDER_NOT_OAUTH: ${provider} does not support OAuth login`,
+            };
+    }
+}
+/**
+ * Codex (OpenAI CLI) — interactive browser login. Reuses ChatGPT Plus/Pro
+ * subscription via OAuth instead of consuming API credits.
+ */
+function runCodexLogin(opts) {
+    const cli = opts.cliPath || 'codex';
+    if (opts.dryRun) {
+        return { provider: 'openai-cli', ok: true, cli, detail: 'dry-run' };
+    }
+    // codex login is interactive — needs inherited stdio so the browser prompt is visible.
+    const loginRes = (0, child_process_1.spawnSync)(cli, ['login'], { stdio: 'inherit' });
+    if (loginRes.status !== 0) {
+        return {
+            provider: 'openai-cli',
+            ok: false,
+            cli,
+            detail: `codex login exited with code ${loginRes.status} (${loginRes.error?.message || 'no error message'})`,
+        };
+    }
+    // Post-login probe — does `codex login status` confirm a session?
+    try {
+        const out = (0, child_process_1.execFileSync)(cli, ['login', 'status'], {
+            encoding: 'utf-8',
+            timeout: 8000,
+        }).trim();
+        if (/logged ?in|signed ?in|active/i.test(out)) {
+            return { provider: 'openai-cli', ok: true, cli, detail: out.slice(0, 200) };
+        }
+        return {
+            provider: 'openai-cli',
+            ok: false,
+            cli,
+            detail: `codex login status did not confirm a session: ${out.slice(0, 200)}`,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        // login succeeded but status probe failed — credit it as ok with a note.
+        return { provider: 'openai-cli', ok: true, cli, detail: `login ok, status probe failed: ${msg}` };
+    }
+}
+/**
+ * Gemini CLI — device-auth OAuth via `gemini login`. Uses the operator's
+ * Google account (not the GEMINI_API_KEY env var).
+ */
+function runGeminiLogin(opts) {
+    const cli = opts.cliPath || 'gemini';
+    if (opts.dryRun) {
+        return { provider: 'gemini-cli', ok: true, cli, detail: 'dry-run' };
+    }
+    const loginRes = (0, child_process_1.spawnSync)(cli, ['login'], { stdio: 'inherit' });
+    if (loginRes.status !== 0) {
+        return {
+            provider: 'gemini-cli',
+            ok: false,
+            cli,
+            detail: `gemini login exited with code ${loginRes.status} (${loginRes.error?.message || 'no error message'})`,
+        };
+    }
+    // Post-login probe
+    try {
+        const out = (0, child_process_1.execFileSync)(cli, ['login', 'status'], {
+            encoding: 'utf-8',
+            timeout: 8000,
+        }).trim();
+        if (/logged ?in|signed ?in|active|authenticated/i.test(out)) {
+            return { provider: 'gemini-cli', ok: true, cli, detail: out.slice(0, 200) };
+        }
+        return {
+            provider: 'gemini-cli',
+            ok: false,
+            cli,
+            detail: `gemini login status did not confirm a session: ${out.slice(0, 200)}`,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { provider: 'gemini-cli', ok: true, cli, detail: `login ok, status probe failed: ${msg}` };
+    }
+}
+/**
+ * xAI Grok — there's no first-party `grok` CLI yet, so this runs the
+ * Grok device-auth flow when available, falling back to instructing the user
+ * to obtain an API key from console.x.ai/team/default/api-keys.
+ *
+ * In practice this currently always reports "manual" — kept as a hook for
+ * when xAI ships an official CLI.
+ */
+function runGrokLogin(opts) {
+    const cli = opts.cliPath || 'grok';
+    if (opts.dryRun) {
+        return { provider: 'xai', ok: true, cli, detail: 'dry-run' };
+    }
+    // Probe whether a `grok` CLI exists with a `login` subcommand.
+    try {
+        const which = (0, child_process_1.spawnSync)(process.platform === 'win32' ? 'where' : 'which', [cli], {
+            encoding: 'utf-8',
+            timeout: 3000,
+        });
+        if (which.status !== 0) {
+            return {
+                provider: 'xai',
+                ok: false,
+                cli,
+                detail: 'xAI device-auth OAuth requires the `grok` CLI which is not installed. Use API key instead (console.x.ai/team/default/api-keys).',
+            };
+        }
+    }
+    catch {
+        return {
+            provider: 'xai',
+            ok: false,
+            cli,
+            detail: 'xAI device-auth OAuth could not be probed. Use API key instead (console.x.ai/team/default/api-keys).',
+        };
+    }
+    const loginRes = (0, child_process_1.spawnSync)(cli, ['login'], { stdio: 'inherit' });
+    if (loginRes.status !== 0) {
+        return {
+            provider: 'xai',
+            ok: false,
+            cli,
+            detail: `grok login exited with code ${loginRes.status}`,
+        };
+    }
+    return { provider: 'xai', ok: true, cli, detail: 'grok login succeeded (no status probe available)' };
+}