@openlife/cli 1.7.13 → 1.8.2

package/dist/cli/install/ProvidersCatalog.js

@@ -0,0 +1,320 @@
+"use strict";
+// src/cli/install/ProvidersCatalog.ts
+// Hermes-parity provider catalog — ~30 providers organized in 5 tiers.
+//
+// Each row carries:
+//  - id (machine-readable, matches ProviderId in types.ts)
+//  - label (display name)
+//  - description (1-liner shown in the multiselect)
+//  - envVar (which .env var holds the credential, when api-key strategy)
+//  - oauthCli (which CLI binary handles `<cli> login`, when oauth strategy)
+//  - tier (organizational grouping for the multiselect header)
+//  - tags (filter chips: 'cloud' | 'local' | 'router' | 'oauth' | 'oss')
+//
+// To add a new provider: append the row here, add the ProviderId to types.ts,
+// and (if it collects API keys) wire the env var in InstallModules.API_KEY_ENV_MAP.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIER_LABELS = exports.PROVIDERS_CATALOG = void 0;
+exports.getProvider = getProvider;
+exports.providersByTier = providersByTier;
+exports.oauthProviders = oauthProviders;
+exports.PROVIDERS_CATALOG = Object.freeze([
+    // ── Tier 1: first-class, ship-it-now providers ────────────────────────
+    {
+        id: 'openai-api',
+        label: 'OpenAI API',
+        description: 'GPT-5.5, GPT-5.4-mini, embeddings (api.openai.com)',
+        envVar: 'OPENAI_API_KEY',
+        oauthCli: '',
+        tier: 'tier-1',
+        tags: ['cloud'],
+        blurb: 'Direct API — fastest setup, paid per-token',
+    },
+    {
+        id: 'anthropic',
+        label: 'Anthropic',
+        description: 'Claude Opus 4.7, Sonnet 4.6, Haiku 4.5 (api.anthropic.com)',
+        envVar: 'ANTHROPIC_API_KEY',
+        oauthCli: '',
+        tier: 'tier-1',
+        tags: ['cloud'],
+        blurb: 'Direct API — Claude family. OAuth NOT supported (use API key only)',
+    },
+    {
+        id: 'gemini-api',
+        label: 'Google Gemini API',
+        description: 'Gemini 3.1 Pro/Flash (generativelanguage.googleapis.com)',
+        envVar: 'GEMINI_API_KEY',
+        oauthCli: '',
+        tier: 'tier-1',
+        tags: ['cloud'],
+        blurb: 'Direct API — generous free tier, multimodal',
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        description: 'Unified gateway to 200+ models (openrouter.ai)',
+        envVar: 'OPENROUTER_API_KEY',
+        oauthCli: '',
+        tier: 'tier-1',
+        tags: ['cloud', 'router'],
+        blurb: 'Single key, every model — pay-as-you-go aggregation',
+    },
+    {
+        id: 'ollama',
+        label: 'Ollama (local)',
+        description: 'Run llama, qwen, mistral, etc. locally (localhost:11434)',
+        envVar: '',
+        oauthCli: '',
+        tier: 'tier-1',
+        tags: ['local', 'oss'],
+        blurb: 'Local inference — no API key needed, GPU/CPU on your machine',
+    },
+    // ── Tier 2: CLI-based and popular alternatives ────────────────────────
+    {
+        id: 'openai-cli',
+        label: 'OpenAI Codex (OAuth)',
+        description: 'OAuth login via @openai/codex CLI — uses Plus/Pro subscription',
+        envVar: '',
+        oauthCli: 'codex',
+        tier: 'tier-2',
+        tags: ['cloud', 'oauth'],
+        blurb: 'Browser OAuth — reuses your ChatGPT Plus/Pro session, no API costs',
+    },
+    {
+        id: 'gemini-cli',
+        label: 'Google Gemini CLI (OAuth)',
+        description: 'OAuth login via gemini-cli — uses Google account quota',
+        envVar: '',
+        oauthCli: 'gemini',
+        tier: 'tier-2',
+        tags: ['cloud', 'oauth'],
+        blurb: 'Browser OAuth — uses your Google account, generous free tier',
+    },
+    {
+        id: 'xai',
+        label: 'xAI Grok',
+        description: 'Grok 4, Grok-vision (api.x.ai) — API key OR device-auth OAuth',
+        envVar: 'XAI_API_KEY',
+        oauthCli: 'grok',
+        tier: 'tier-2',
+        tags: ['cloud', 'oauth'],
+        blurb: 'Direct API or browser OAuth — Grok models, X integration',
+    },
+    {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        description: 'DeepSeek-V3, DeepSeek-Coder (api.deepseek.com)',
+        envVar: 'DEEPSEEK_API_KEY',
+        oauthCli: '',
+        tier: 'tier-2',
+        tags: ['cloud'],
+        blurb: 'Strong coder models, competitive pricing',
+    },
+    {
+        id: 'groq',
+        label: 'Groq',
+        description: 'Ultra-fast inference on LPUs (api.groq.com)',
+        envVar: 'GROQ_API_KEY',
+        oauthCli: '',
+        tier: 'tier-2',
+        tags: ['cloud'],
+        blurb: 'Lowest-latency inference, llama/mixtral on LPU hardware',
+    },
+    {
+        id: 'together',
+        label: 'Together AI',
+        description: 'Open-source models at scale (api.together.xyz)',
+        envVar: 'TOGETHER_API_KEY',
+        oauthCli: '',
+        tier: 'tier-2',
+        tags: ['cloud', 'oss'],
+        blurb: 'Hosted OSS models — llama, mixtral, deepseek, qwen, etc.',
+    },
+    {
+        id: 'mistral',
+        label: 'Mistral AI',
+        description: 'Mistral Large, Codestral (api.mistral.ai)',
+        envVar: 'MISTRAL_API_KEY',
+        oauthCli: '',
+        tier: 'tier-2',
+        tags: ['cloud'],
+        blurb: 'European AI lab — strong general + coder models',
+    },
+    // ── Tier 3: enterprise / specialty / regional ─────────────────────────
+    {
+        id: 'bedrock',
+        label: 'AWS Bedrock',
+        description: 'Claude, Llama, Titan via AWS (bedrock.amazonaws.com)',
+        envVar: 'AWS_ACCESS_KEY_ID',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud', 'enterprise'],
+        blurb: 'Enterprise — AWS billing, VPC integration, multi-model',
+    },
+    {
+        id: 'qwen',
+        label: 'Alibaba Qwen',
+        description: 'Qwen2.5, Qwen-VL (dashscope.aliyuncs.com)',
+        envVar: 'DASHSCOPE_API_KEY',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud'],
+        blurb: 'Alibaba models — strong multilingual + Chinese performance',
+    },
+    {
+        id: 'kimi',
+        label: 'Moonshot Kimi',
+        description: 'Kimi-k2, long-context (api.moonshot.cn)',
+        envVar: 'MOONSHOT_API_KEY',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud'],
+        blurb: 'Moonshot — 2M context window, Chinese-strong',
+    },
+    {
+        id: 'minimax',
+        label: 'MiniMax',
+        description: 'abab6.5 (api.minimax.chat)',
+        envVar: 'MINIMAX_API_KEY',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud'],
+        blurb: 'MiniMax — multimodal, agent-friendly',
+    },
+    {
+        id: 'glm',
+        label: 'Zhipu GLM',
+        description: 'GLM-4, ChatGLM (open.bigmodel.cn)',
+        envVar: 'ZHIPU_API_KEY',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud'],
+        blurb: 'Zhipu AI — GLM family, multilingual',
+    },
+    {
+        id: 'huggingface',
+        label: 'Hugging Face',
+        description: 'Inference API + Endpoints (api-inference.huggingface.co)',
+        envVar: 'HF_TOKEN',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud', 'oss'],
+        blurb: 'Any HF model via serverless inference or dedicated endpoints',
+    },
+    {
+        id: 'nvidia-nim',
+        label: 'NVIDIA NIM',
+        description: 'NVIDIA-hosted optimized inference (integrate.api.nvidia.com)',
+        envVar: 'NVIDIA_API_KEY',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud', 'enterprise'],
+        blurb: 'NVIDIA Inference Microservices — optimized for NVIDIA stack',
+    },
+    {
+        id: 'perplexity',
+        label: 'Perplexity',
+        description: 'Sonar models w/ real-time web search (api.perplexity.ai)',
+        envVar: 'PERPLEXITY_API_KEY',
+        oauthCli: '',
+        tier: 'tier-3',
+        tags: ['cloud'],
+        blurb: 'Web-grounded models — search-augmented responses',
+    },
+    // ── Tier 4: local / self-hosted / DIY ─────────────────────────────────
+    {
+        id: 'vllm',
+        label: 'vLLM (self-hosted)',
+        description: 'OpenAI-compatible server, self-hosted (vllm.ai)',
+        envVar: 'VLLM_BASE_URL',
+        oauthCli: '',
+        tier: 'tier-4',
+        tags: ['local', 'oss'],
+        blurb: 'High-throughput inference server — bring your own GPUs',
+    },
+    {
+        id: 'sglang',
+        label: 'SGLang (self-hosted)',
+        description: 'Fast structured-generation server (sgl-project.github.io)',
+        envVar: 'SGLANG_BASE_URL',
+        oauthCli: '',
+        tier: 'tier-4',
+        tags: ['local', 'oss'],
+        blurb: 'Structured output + RadixAttention — self-hosted',
+    },
+    {
+        id: 'llamacpp',
+        label: 'llama.cpp server',
+        description: 'GGUF inference w/ OpenAI-compat endpoint (github.com/ggml-org/llama.cpp)',
+        envVar: 'LLAMACPP_BASE_URL',
+        oauthCli: '',
+        tier: 'tier-4',
+        tags: ['local', 'oss'],
+        blurb: 'CPU/GPU GGUF inference — tiny footprint',
+    },
+    {
+        id: 'lmstudio',
+        label: 'LM Studio',
+        description: 'Desktop local-LLM app w/ OpenAI server (lmstudio.ai)',
+        envVar: 'LMSTUDIO_BASE_URL',
+        oauthCli: '',
+        tier: 'tier-4',
+        tags: ['local'],
+        blurb: 'Desktop app — easiest local LLM setup',
+    },
+    // ── Tier 5: routers / gateways / custom ───────────────────────────────
+    {
+        id: 'litellm',
+        label: 'LiteLLM Proxy',
+        description: 'Unified proxy for 100+ providers (litellm.ai)',
+        envVar: 'LITELLM_BASE_URL',
+        oauthCli: '',
+        tier: 'tier-5',
+        tags: ['router', 'oss'],
+        blurb: 'Self-hosted proxy — one endpoint, every provider',
+    },
+    {
+        id: 'clawrouter',
+        label: 'ClawRouter',
+        description: 'OpenAI-compatible router (clawrouter.ai)',
+        envVar: 'CLAWROUTER_API_KEY',
+        oauthCli: '',
+        tier: 'tier-5',
+        tags: ['cloud', 'router'],
+        blurb: 'Cloud router — multi-provider failover',
+    },
+    {
+        id: 'custom-openai',
+        label: 'Custom OpenAI-compatible',
+        description: 'Any provider exposing the /v1/chat/completions API',
+        envVar: 'CUSTOM_OPENAI_BASE_URL',
+        oauthCli: '',
+        tier: 'tier-5',
+        tags: ['custom'],
+        blurb: 'Bring your own endpoint — any OpenAI-API-compatible server',
+    },
+]);
+exports.TIER_LABELS = Object.freeze({
+    'tier-1': '⭐ Tier 1 — First-class (start here)',
+    'tier-2': '🔥 Tier 2 — Popular alternatives',
+    'tier-3': '🏢 Tier 3 — Enterprise & regional',
+    'tier-4': '💻 Tier 4 — Local & self-hosted',
+    'tier-5': '🔀 Tier 5 — Routers & custom',
+});
+/** Lookup by id — throws on unknown id (catches catalog desync at runtime). */
+function getProvider(id) {
+    const found = exports.PROVIDERS_CATALOG.find(p => p.id === id);
+    if (!found) {
+        throw new Error(`PROVIDER_NOT_IN_CATALOG: ${id} — add a row to ProvidersCatalog.ts`);
+    }
+    return found;
+}
+/** All providers belonging to a tier — used to render the multiselect. */
+function providersByTier(tier) {
+    return exports.PROVIDERS_CATALOG.filter(p => p.tier === tier);
+}
+/** OAuth-capable providers — used in the agent profile auth-strategy phase. */
+function oauthProviders() {
+    return exports.PROVIDERS_CATALOG.filter(p => !!p.oauthCli);
+}

package/dist/cli/install/WizardIO.js

@@ -0,0 +1,271 @@
+"use strict";
+// src/cli/install/WizardIO.ts
+// Sequential I/O surface for the Install Wizard 2.0.
+//
+// Core principle: every prompt waits for an explicit Enter. No batching, no
+// silent defaults. Tests inject a CannedIO; production uses the readline-based
+// implementation.
+//
+// Reuses MatrixTheme for visual consistency with ChatTui / ConfigTui.
+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.CannedIO = exports.ReadlineWizardIO = void 0;
+const readline = __importStar(require("readline"));
+const MatrixTheme_1 = require("../MatrixTheme");
+/**
+ * Production IO — wraps node:readline. Renders with Matrix theme when stdout
+ * supports color; otherwise plain text.
+ */
+class ReadlineWizardIO {
+    rl;
+    ownsInterface;
+    constructor(rl) {
+        if (rl) {
+            this.rl = rl;
+            this.ownsInterface = false;
+        }
+        else {
+            this.rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            this.ownsInterface = true;
+        }
+    }
+    close() {
+        if (this.ownsInterface)
+            this.rl.close();
+    }
+    header(line) {
+        const color = (0, MatrixTheme_1.supportsColor)() ? MatrixTheme_1.MATRIX.head : '';
+        const reset = (0, MatrixTheme_1.supportsColor)() ? MatrixTheme_1.ANSI.reset : '';
+        process.stdout.write(`\n${color}━━━ ${line} ━━━${reset}\n\n`);
+    }
+    print(line) {
+        const color = (0, MatrixTheme_1.supportsColor)() ? MatrixTheme_1.MATRIX.body : '';
+        const reset = (0, MatrixTheme_1.supportsColor)() ? MatrixTheme_1.ANSI.reset : '';
+        process.stdout.write(`${color}${line}${reset}\n`);
+    }
+    hint(line) {
+        process.stdout.write(`${(0, MatrixTheme_1.paint)(line, MatrixTheme_1.MATRIX.tail)}\n`);
+    }
+    warn(line) {
+        process.stdout.write(`${(0, MatrixTheme_1.paint)('⚠ ' + line, MatrixTheme_1.MATRIX.warn)}\n`);
+    }
+    err(line) {
+        process.stdout.write(`${(0, MatrixTheme_1.paint)('✗ ' + line, MatrixTheme_1.MATRIX.err)}\n`);
+    }
+    divider() {
+        const w = Math.min(process.stdout.columns || 60, 60);
+        process.stdout.write(`${(0, MatrixTheme_1.paint)('─'.repeat(w), MatrixTheme_1.MATRIX.tail)}\n`);
+    }
+    ask(prompt) {
+        return new Promise((resolve) => {
+            this.rl.question(prompt, (answer) => resolve(answer));
+        });
+    }
+    async text(prompt, defaultValue) {
+        const suffix = defaultValue !== undefined && defaultValue !== ''
+            ? (0, MatrixTheme_1.paint)(` [${defaultValue}]`, MatrixTheme_1.MATRIX.tail)
+            : '';
+        const promptStr = `${(0, MatrixTheme_1.paint)(prompt, MatrixTheme_1.MATRIX.body)}${suffix}${(0, MatrixTheme_1.paint)(': ', MatrixTheme_1.MATRIX.head)}`;
+        const raw = (await this.ask(promptStr)).trim();
+        if (!raw && defaultValue !== undefined)
+            return defaultValue;
+        return raw;
+    }
+    /**
+     * Masked input — disables echo, accumulates chars manually, prints * per
+     * character. Falls back to plain text() when stdin is not a TTY (CI/piped).
+     */
+    async secret(prompt) {
+        if (!process.stdin.isTTY) {
+            // CI / piped — accept the pasted value as-is.
+            return this.text(prompt);
+        }
+        return new Promise((resolve) => {
+            const promptStr = `${(0, MatrixTheme_1.paint)(prompt, MatrixTheme_1.MATRIX.body)}${(0, MatrixTheme_1.paint)(': ', MatrixTheme_1.MATRIX.head)}`;
+            process.stdout.write(promptStr);
+            let value = '';
+            const previousRaw = process.stdin.isRaw === true;
+            try {
+                process.stdin.setRawMode(true);
+            }
+            catch { /* ignore */ }
+            process.stdin.resume();
+            process.stdin.setEncoding('utf-8');
+            const onData = (chunk) => {
+                for (const ch of chunk) {
+                    const code = ch.charCodeAt(0);
+                    // Enter (13 or 10)
+                    if (code === 13 || code === 10) {
+                        process.stdin.removeListener('data', onData);
+                        try {
+                            process.stdin.setRawMode(previousRaw);
+                        }
+                        catch { /* ignore */ }
+                        process.stdin.pause();
+                        process.stdout.write('\n');
+                        resolve(value.trim());
+                        return;
+                    }
+                    // Ctrl-C
+                    if (code === 3) {
+                        process.stdin.removeListener('data', onData);
+                        try {
+                            process.stdin.setRawMode(previousRaw);
+                        }
+                        catch { /* ignore */ }
+                        process.stdin.pause();
+                        process.stdout.write('\n');
+                        process.exit(130);
+                        return;
+                    }
+                    // Backspace
+                    if (code === 127 || code === 8) {
+                        if (value.length > 0) {
+                            value = value.slice(0, -1);
+                            process.stdout.write('\b \b');
+                        }
+                        continue;
+                    }
+                    // Printable char — append and echo asterisk
+                    if (code >= 32) {
+                        value += ch;
+                        process.stdout.write('*');
+                    }
+                }
+            };
+            process.stdin.on('data', onData);
+        });
+    }
+    async yesNo(prompt, defaultYes = false) {
+        const hint = defaultYes ? '[Y/n]' : '[y/N]';
+        const promptStr = `${(0, MatrixTheme_1.paint)(prompt, MatrixTheme_1.MATRIX.body)} ${(0, MatrixTheme_1.paint)(hint, MatrixTheme_1.MATRIX.tail)}${(0, MatrixTheme_1.paint)(': ', MatrixTheme_1.MATRIX.head)}`;
+        const raw = (await this.ask(promptStr)).trim().toLowerCase();
+        if (!raw)
+            return defaultYes;
+        if (raw === 'y' || raw === 'yes' || raw === 's' || raw === 'sim')
+            return true;
+        if (raw === 'n' || raw === 'no' || raw === 'não' || raw === 'nao')
+            return false;
+        return defaultYes;
+    }
+    async choice(prompt, options, defaultIndex = 0) {
+        this.print(prompt);
+        for (let i = 0; i < options.length; i++) {
+            const marker = i === defaultIndex ? (0, MatrixTheme_1.paint)('▶', MatrixTheme_1.MATRIX.head) : ' ';
+            const num = (0, MatrixTheme_1.paint)(`${i + 1})`, MatrixTheme_1.MATRIX.body);
+            this.print(`  ${marker} ${num} ${options[i]}`);
+        }
+        const promptStr = `${(0, MatrixTheme_1.paint)(`Choice [${defaultIndex + 1}]`, MatrixTheme_1.MATRIX.body)}${(0, MatrixTheme_1.paint)(': ', MatrixTheme_1.MATRIX.head)}`;
+        const raw = (await this.ask(promptStr)).trim();
+        if (!raw)
+            return defaultIndex;
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isNaN(parsed) || parsed < 1 || parsed > options.length) {
+            this.warn(`Invalid choice — must be 1..${options.length}. Using default (${defaultIndex + 1}).`);
+            return defaultIndex;
+        }
+        return parsed - 1;
+    }
+    async pause(prompt = 'Press Enter to continue') {
+        const promptStr = `${(0, MatrixTheme_1.paint)(`▸ ${prompt}…`, MatrixTheme_1.MATRIX.tail)}`;
+        await this.ask(promptStr);
+    }
+}
+exports.ReadlineWizardIO = ReadlineWizardIO;
+/**
+ * Test seam — feeds canned answers from a FIFO queue. Each prompt method
+ * shifts one answer off. Empty queue throws so tests fail loudly on
+ * forgotten answers.
+ */
+class CannedIO {
+    queue;
+    transcript = [];
+    constructor(answers) {
+        this.queue = [...answers];
+    }
+    header(line) { this.transcript.push(`[header] ${line}`); }
+    print(line) { this.transcript.push(`[print] ${(0, MatrixTheme_1.stripAnsi)(line)}`); }
+    hint(line) { this.transcript.push(`[hint] ${line}`); }
+    warn(line) { this.transcript.push(`[warn] ${line}`); }
+    err(line) { this.transcript.push(`[err] ${line}`); }
+    divider() { this.transcript.push(`[divider]`); }
+    close() { }
+    next(kind) {
+        if (this.queue.length === 0) {
+            throw new Error(`CANNED_IO_EXHAUSTED: wizard asked for "${kind}" but the queue is empty`);
+        }
+        return this.queue.shift();
+    }
+    async text(prompt, _defaultValue) {
+        this.transcript.push(`[text] ${prompt}`);
+        const v = this.next('text');
+        if (typeof v !== 'string')
+            throw new Error(`CANNED_IO_TYPE: expected string for text, got ${typeof v}`);
+        return v;
+    }
+    async secret(prompt) {
+        this.transcript.push(`[secret] ${prompt}`);
+        const v = this.next('secret');
+        if (typeof v !== 'string')
+            throw new Error(`CANNED_IO_TYPE: expected string for secret, got ${typeof v}`);
+        return v;
+    }
+    async yesNo(prompt, _defaultYes) {
+        this.transcript.push(`[yesNo] ${prompt}`);
+        const v = this.next('yesNo');
+        if (typeof v !== 'boolean')
+            throw new Error(`CANNED_IO_TYPE: expected boolean for yesNo, got ${typeof v}`);
+        return v;
+    }
+    async choice(prompt, _options, _defaultIndex) {
+        this.transcript.push(`[choice] ${prompt}`);
+        const v = this.next('choice');
+        if (typeof v !== 'number')
+            throw new Error(`CANNED_IO_TYPE: expected number for choice, got ${typeof v}`);
+        return v;
+    }
+    async pause(_prompt) {
+        this.transcript.push(`[pause]`);
+        // Pause consumes one boolean from the queue — usually `true` to continue.
+        // This makes test queues predictable: every Enter in the wizard = one entry.
+        const v = this.next('pause');
+        if (typeof v !== 'boolean')
+            throw new Error(`CANNED_IO_TYPE: expected boolean for pause, got ${typeof v}`);
+    }
+    remaining() {
+        return this.queue.length;
+    }
+}
+exports.CannedIO = CannedIO;

package/dist/cli/install/types.js

@@ -0,0 +1,17 @@
+"use strict";
+// src/cli/install/types.ts
+// Shared types for the Install Wizard 2.0 (phase-based, sequential, multi-host).
+//
+// Replaces the old single-host, batched-Q&A model in InstallWizard.ts with:
+//  - 2 install profiles (openlife-core | openlife-agent) installable separately or sequentially
+//  - Multi-host selection (claude-code | gemini-cli | codex — pick 1..N)
+//  - Per-provider auth strategy in agent profile (api-key | oauth | skip)
+//  - ~30 providers in tier-organized catalog
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAUTH_ENABLED_PROVIDERS = void 0;
+/** Providers where OAuth is permitted as an auth strategy. */
+exports.OAUTH_ENABLED_PROVIDERS = Object.freeze([
+    'openai-cli', // Codex
+    'gemini-cli', // Gemini CLI
+    'xai', // Grok device-auth
+]);