infinicode 1.0.0 → 2.0.0

package/dist/commands/mission.js

@@ -0,0 +1,301 @@
+/**
+ * infinicode mission command — drives the OpenKernel runtime.
+ *
+ * Usage:
+ *   infinicode mission run --goal "..." [--task "..." --cap coding ...]
+ *   infinicode mission status <id>
+ *   infinicode mission list
+ *   infinicode mission resume <id>
+ *   infinicode mission cancel <id>
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { buildKernelFromConfig } from '../kernel/setup.js';
+import { SAMPLE_MISSIONS } from '../kernel/sample-missions.js';
+function parseCapabilities(raw) {
+    if (!raw)
+        return ['reasoning'];
+    return raw.split(',').map(s => s.trim()).filter(Boolean);
+}
+export async function missionRun(config, opts) {
+    const kernel = buildKernelFromConfig(config);
+    let input;
+    if (opts.sample) {
+        const sample = SAMPLE_MISSIONS[opts.sample];
+        if (!sample) {
+            console.log(chalk.red(`Unknown sample: ${opts.sample}`));
+            console.log(chalk.dim(`Available: ${Object.keys(SAMPLE_MISSIONS).join(', ')}`));
+            process.exit(1);
+        }
+        input = sample;
+        console.log(chalk.dim(`Using sample mission: ${chalk.cyan(opts.sample)}`));
+    }
+    else {
+        const tasks = (opts.task ?? []).map((desc, i) => ({
+            description: desc,
+            capabilities: parseCapabilities(opts.cap?.[i] ?? opts.cap?.[0] ?? 'coding'),
+            input: { prompt: desc },
+        }));
+        if (tasks.length === 0) {
+            console.log(chalk.yellow('No --task provided; running a single goal-driven task.'));
+            tasks.push({
+                description: opts.goal,
+                capabilities: ['reasoning', 'coding'],
+                input: { prompt: opts.goal },
+            });
+        }
+        input = {
+            name: opts.name,
+            description: opts.description ?? opts.goal,
+            goal: opts.goal,
+            policy: opts.policy,
+            tasks,
+        };
+    }
+    const spinner = ora('Starting mission...').start();
+    // Renders are serialized through a queue so the routing animation for one
+    // task never interleaves with another task's spinner (missions run tasks in
+    // parallel, but their visualization plays back in event order).
+    let chain = Promise.resolve();
+    const enqueue = (fn) => {
+        chain = chain.then(fn).catch(() => { });
+    };
+    const line = (s) => {
+        if (spinner.isSpinning)
+            spinner.stop();
+        console.log(s);
+    };
+    const unsub = kernel.subscribeAll((event) => {
+        switch (event.type) {
+            case 'MISSION_STARTED':
+                enqueue(() => line(`${chalk.green('✔')} Mission started: ${chalk.cyan(String(event.missionId))}`));
+                break;
+            case 'ROUTING_DECISION':
+                enqueue(() => animateRouting(spinner, event.data));
+                break;
+            case 'TASK_STARTED': {
+                const model = event.data && typeof event.data === 'object' && 'modelId' in event.data
+                    ? event.data.modelId : '?';
+                enqueue(() => {
+                    spinner.start(`${chalk.dim('task ' + (event.taskId ?? '?'))} executing on ${chalk.cyan(String(model))}`);
+                });
+                break;
+            }
+            case 'TASK_COMPLETED':
+                enqueue(() => line(`${chalk.green('✔')} ${chalk.dim('task ' + (event.taskId ?? '?'))} completed`));
+                break;
+            case 'TASK_FAILED':
+                enqueue(() => line(`${chalk.red('✖')} ${chalk.dim('task ' + (event.taskId ?? '?'))} failed: ${String(event.data && typeof event.data === 'object' && 'error' in event.data ? event.data.error : '')}`));
+                break;
+            case 'MISSION_COMPLETED':
+                enqueue(() => line(chalk.green('✔ Mission completed')));
+                break;
+            case 'MISSION_FAILED':
+                enqueue(() => line(chalk.red('✖ Mission failed')));
+                break;
+            case 'PROVIDER_HEALTH':
+                // silent
+                break;
+            default:
+                if (process.env.OPENKERNEL_DEBUG === '1') {
+                    enqueue(() => line(chalk.dim(`event ${event.type}`)));
+                }
+        }
+    });
+    try {
+        const mission = await kernel.execute(input);
+        await chain;
+        if (spinner.isSpinning)
+            spinner.stop();
+        unsub();
+        console.log(chalk.bold('\nMission Result'));
+        console.log(chalk.dim('-'.repeat(50)));
+        console.log(`  ID:          ${chalk.cyan(mission.id)}`);
+        console.log(`  Status:      ${formatMissionStatus(mission.status)}`);
+        console.log(`  Tasks:       ${mission.tasks.length}`);
+        const completed = mission.tasks.filter(t => t.status === 'COMPLETED').length;
+        console.log(`  Completed:   ${completed}/${mission.tasks.length}`);
+        console.log(`  Checkpoints: ${mission.checkpoints.length}`);
+        for (const task of mission.tasks) {
+            console.log(chalk.dim(`\n  ── Task ${task.id} ──`));
+            console.log(`  description: ${task.description}`);
+            console.log(`  status:      ${formatTaskStatus(task.status)}`);
+            if (task.providerId && task.modelId) {
+                console.log(`  model:       ${chalk.cyan(task.providerId + '/' + task.modelId)}`);
+            }
+            if (task.output?.content) {
+                const preview = task.output.content.slice(0, 400);
+                console.log(chalk.dim('  output:'));
+                console.log(chalk.dim('  ─────────────────────────────────────'));
+                for (const line of preview.split('\n')) {
+                    console.log('  ' + line);
+                }
+                if (task.output.content.length > 400) {
+                    console.log(chalk.dim(`  … (${task.output.content.length - 400} more chars)`));
+                }
+                console.log(chalk.dim('  ─────────────────────────────────────'));
+            }
+            if (task.error) {
+                console.log(`  error: ${chalk.red(task.error)}`);
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        await chain.catch(() => { });
+        unsub();
+        if (spinner.isSpinning)
+            spinner.stop();
+        console.log(chalk.red('✖ Mission execution failed'));
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    finally {
+        kernel.destroy();
+    }
+}
+const GOLD = '#FFD86B';
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+function candidateLabel(c) {
+    return `${c.providerId}/${c.modelId}`;
+}
+/**
+ * Animate the orchestrator's routing choice: a short "slot machine" over the
+ * ranked candidates, landing on and highlighting the chosen model in gold.
+ */
+async function animateRouting(spinner, data) {
+    if (!data || !data.chosen)
+        return;
+    if (spinner.isSpinning)
+        spinner.stop();
+    if (data.locked) {
+        console.log('  ' + chalk.hex(GOLD)('🔒 ') +
+            chalk.dim(`${data.workerType} · ${data.mode} locked → `) +
+            chalk.hex(GOLD).bold(candidateLabel(data.chosen)));
+        return;
+    }
+    const cands = data.candidates.length ? data.candidates : [data.chosen];
+    const interactive = !!process.stdout.isTTY && !process.env.CI;
+    if (interactive && cands.length > 1) {
+        const ticks = Math.min(16, 6 + cands.length * 2);
+        for (let i = 0; i < ticks; i++) {
+            const c = cands[i % cands.length];
+            process.stdout.write(`\r  ${chalk.hex(GOLD)('⚡')} routing ${chalk.dim(data.workerType)} … ${chalk.cyan(candidateLabel(c))}\x1b[K`);
+            await sleep(50 + i * 8);
+        }
+        process.stdout.write('\r\x1b[K');
+    }
+    console.log(`  ${chalk.hex(GOLD)('⚡')} ${chalk.bold('routing')} ${chalk.dim(data.workerType)} ${chalk.dim('· mode=' + data.mode)}`);
+    cands.forEach((c, idx) => {
+        const stats = `score=${c.score.toFixed(2)} bench=${c.benchmarkScore} ${c.providerType}`;
+        if (idx === 0) {
+            console.log('  ' + chalk.hex(GOLD).bold(`◆ ${candidateLabel(c)}`) + '  ' + chalk.hex(GOLD)(stats) + chalk.hex(GOLD)('  ◄ chosen'));
+        }
+        else {
+            console.log('    ' + chalk.dim(`${candidateLabel(c)}  ${stats}`));
+        }
+    });
+}
+export async function missionStatus(config, missionId) {
+    // Status reads from checkpoint storage
+    const kernel = buildKernelFromConfig(config);
+    const mission = kernel.getMission(missionId);
+    if (!mission) {
+        console.log(chalk.yellow(`Mission ${missionId} not found in this session.`));
+        console.log(chalk.dim('  (Missions live in-memory for Phase 1; checkpoints persist to .openkernel/checkpoints)'));
+        return;
+    }
+    console.log(chalk.bold('\nMission Status'));
+    console.log(chalk.dim('-'.repeat(40)));
+    console.log(`  ID:      ${chalk.cyan(mission.id)}`);
+    console.log(`  Name:    ${mission.name}`);
+    console.log(`  Status:  ${formatMissionStatus(mission.status)}`);
+    console.log(`  Goal:    ${mission.goal}`);
+    console.log(`  Tasks:   ${mission.tasks.length}`);
+    console.log();
+}
+export async function missionList(config) {
+    const kernel = buildKernelFromConfig(config);
+    const missions = kernel.listMissions();
+    if (missions.length === 0) {
+        console.log(chalk.yellow('No missions in this session.'));
+        return;
+    }
+    console.log(chalk.bold('\nMissions'));
+    console.log(chalk.dim('-'.repeat(60)));
+    for (const m of missions) {
+        console.log(`  ${chalk.cyan(m.id)}  ${formatMissionStatus(m.status)}  ${m.name}`);
+    }
+    console.log();
+}
+export async function missionResume(config, missionId) {
+    const kernel = buildKernelFromConfig(config);
+    const mission = kernel.getMission(missionId);
+    if (!mission) {
+        console.log(chalk.yellow(`Mission ${missionId} not found in this session.`));
+        console.log(chalk.dim('  (Missions are in-memory; only checkpoints persist across restarts.)'));
+        return;
+    }
+    if (mission.status !== 'PAUSED' && mission.status !== 'WAITING') {
+        console.log(chalk.yellow(`Mission ${missionId} is ${mission.status}; only PAUSED or WAITING missions can be resumed.`));
+        return;
+    }
+    console.log(chalk.dim(`Resuming mission ${chalk.cyan(missionId)}...`));
+    try {
+        const resumed = await kernel.resume(missionId);
+        console.log(chalk.green(`✓ Mission resumed — status: ${formatMissionStatus(resumed.status)}`));
+        for (const task of resumed.tasks) {
+            console.log(chalk.dim(`  ── Task ${task.id} ──  ${formatTaskStatus(task.status)}`));
+            if (task.output?.content) {
+                const preview = task.output.content.slice(0, 300);
+                console.log(chalk.dim(`  ${preview}${task.output.content.length > 300 ? '…' : ''}`));
+            }
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`Resume failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+    finally {
+        kernel.destroy();
+    }
+}
+export async function missionCancel(config, missionId) {
+    const kernel = buildKernelFromConfig(config);
+    const mission = kernel.getMission(missionId);
+    if (!mission) {
+        console.log(chalk.yellow(`Mission ${missionId} not found in this session.`));
+        return;
+    }
+    await kernel.cancel(missionId);
+    console.log(chalk.green(`✓ Mission ${missionId} cancelled — status: ${formatMissionStatus(kernel.getMission(missionId)?.status ?? 'CANCELLED')}`));
+    kernel.destroy();
+}
+function formatMissionStatus(s) {
+    const map = {
+        NEW: chalk.dim('NEW'),
+        PLANNING: chalk.yellow('PLANNING'),
+        READY: chalk.blue('READY'),
+        RUNNING: chalk.cyan('RUNNING'),
+        VERIFYING: chalk.magenta('VERIFYING'),
+        WAITING: chalk.yellow('WAITING'),
+        PAUSED: chalk.yellow('PAUSED'),
+        FAILED: chalk.red('FAILED'),
+        COMPLETED: chalk.green('COMPLETED'),
+        CANCELLED: chalk.red('CANCELLED'),
+    };
+    return map[s] ?? s;
+}
+function formatTaskStatus(s) {
+    const map = {
+        PENDING: chalk.dim('PENDING'),
+        QUEUED: chalk.blue('QUEUED'),
+        RUNNING: chalk.cyan('RUNNING'),
+        VERIFYING: chalk.magenta('VERIFYING'),
+        COMPLETED: chalk.green('COMPLETED'),
+        FAILED: chalk.red('FAILED'),
+        SKIPPED: chalk.yellow('SKIPPED'),
+    };
+    return map[s] ?? s;
+}

package/dist/commands/models.d.ts

@@ -1,2 +1,4 @@
 import type Conf from 'conf';
-export declare function listModels(config: Conf<any>): Promise<void>;
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+export declare function listModels(config: Conf<InfinicodeConfig>): Promise<void>;
+export declare function pullAllModels(config: Conf<InfinicodeConfig>): Promise<void>;

package/dist/commands/models.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import ora from 'ora';
+import { buildKernelFromConfig } from '../kernel/setup.js';
 function formatSize(bytes) {
     const gb = bytes / (1024 ** 3);
     if (gb >= 1)
@@ -7,70 +8,125 @@ function formatSize(bytes) {
     const mb = bytes / (1024 ** 2);
     return `${mb.toFixed(0)} MB`;
 }
+function partitionModels(models) {
+    const codingModels = [];
+    const otherModels = [];
+    for (const model of models) {
+        const name = model.id.toLowerCase();
+        if (name.includes('code') || name.includes('coder') || name.includes('stral')) {
+            codingModels.push(model);
+        }
+        else {
+            otherModels.push(model);
+        }
+    }
+    return { codingModels, otherModels };
+}
 export async function listModels(config) {
-    const masterUrl = config.get('masterUrl');
     const defaultModel = config.get('defaultModel');
-    console.log(chalk.bold('\n⚡ Available Models'));
-    console.log(chalk.dim(`  Master: ${masterUrl}`));
-    console.log(chalk.dim('─'.repeat(50)));
-    const spinner = ora('Fetching models...').start();
+    const kernel = buildKernelFromConfig(config);
+    const spinner = ora('Discovering models across all providers...').start();
+    // Give health checks a moment to populate
+    await new Promise(r => setTimeout(r, 1500));
+    let models = [];
     try {
-        const response = await fetch(`${masterUrl}/api/tags`, {
-            signal: AbortSignal.timeout(10000)
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        const data = await response.json();
-        spinner.stop();
-        const models = data.models || [];
-        if (models.length === 0) {
-            console.log(chalk.yellow('\n  No models installed.'));
-            console.log(chalk.dim('\n  Recommended models for coding:'));
-            console.log(chalk.cyan('    ollama pull qwen2.5-coder:14b'));
-            console.log(chalk.cyan('    ollama pull deepseek-coder-v2:16b'));
-            console.log(chalk.cyan('    ollama pull codestral:22b'));
-            console.log();
-            return;
-        }
-        // Categorize models
-        const codingModels = [];
-        const otherModels = [];
-        for (const m of models) {
-            const name = m.name.toLowerCase();
-            if (name.includes('code') || name.includes('coder') || name.includes('stral')) {
-                codingModels.push(m);
-            }
-            else {
-                otherModels.push(m);
-            }
-        }
-        // Display coding models first
+        models = await kernel.providerManager.getAvailableModels();
+    }
+    catch {
+        // continue with empty
+    }
+    if (models.length === 0) {
+        spinner.fail('No models available — no healthy providers.');
+        console.log(chalk.dim('  Check that Ollama is running or a cloud provider API key is set.'));
+        console.log(chalk.dim('  Run: infinicode providers test'));
+        kernel.destroy();
+        return;
+    }
+    spinner.succeed(`Found ${models.length} models across healthy providers`);
+    const byProvider = new Map();
+    for (const m of models) {
+        const list = byProvider.get(m.providerId) ?? [];
+        list.push(m);
+        byProvider.set(m.providerId, list);
+    }
+    console.log(chalk.bold('\nAvailable Models'));
+    console.log(chalk.dim('-'.repeat(60)));
+    for (const [providerId, providerModels] of byProvider) {
+        console.log(chalk.bold(`\n  ${chalk.cyan(providerId)} (${providerModels.length})`));
+        const { codingModels, otherModels } = partitionModels(providerModels);
         if (codingModels.length > 0) {
-            console.log(chalk.bold('\n  💻 Coding Models:'));
-            for (const m of codingModels) {
-                const isDefault = m.name === defaultModel || m.name.startsWith(defaultModel.split(':')[0]);
-                const marker = isDefault ? chalk.green('★') : ' ';
-                const size = formatSize(m.size);
-                console.log(`  ${marker} ${chalk.cyan(m.name.padEnd(30))} ${chalk.dim(size)}`);
+            console.log(chalk.dim('    Coding:'));
+            for (const model of codingModels.slice(0, 20)) {
+                const isDefault = model.id === defaultModel || model.id.startsWith(defaultModel.split(':')[0]);
+                const marker = isDefault ? chalk.green('*') : ' ';
+                const ctx = model.contextLength >= 1000 ? `${Math.round(model.contextLength / 1000)}k` : `${model.contextLength}`;
+                const sizeMeta = model.metadata?.size;
+                const sizeStr = sizeMeta ? ` ${chalk.dim(formatSize(sizeMeta))}` : '';
+                console.log(`    ${marker} ${model.id.padEnd(42)} ${chalk.dim(`ctx=${ctx}`)}${sizeStr}`);
             }
         }
         if (otherModels.length > 0) {
-            console.log(chalk.bold('\n  🤖 Other Models:'));
-            for (const m of otherModels) {
-                const isDefault = m.name === defaultModel;
-                const marker = isDefault ? chalk.green('★') : ' ';
-                const size = formatSize(m.size);
-                console.log(`  ${marker} ${chalk.cyan(m.name.padEnd(30))} ${chalk.dim(size)}`);
+            console.log(chalk.dim('    Other:'));
+            for (const model of otherModels.slice(0, 10)) {
+                const isDefault = model.id === defaultModel;
+                const marker = isDefault ? chalk.green('*') : ' ';
+                const ctx = model.contextLength >= 1000 ? `${Math.round(model.contextLength / 1000)}k` : `${model.contextLength}`;
+                const sizeMeta = model.metadata?.size;
+                const sizeStr = sizeMeta ? ` ${chalk.dim(formatSize(sizeMeta))}` : '';
+                console.log(`    ${marker} ${model.id.padEnd(42)} ${chalk.dim(`ctx=${ctx}`)}${sizeStr}`);
+            }
+            if (otherModels.length > 10) {
+                console.log(chalk.dim(`    ... and ${otherModels.length - 10} more`));
             }
         }
-        console.log(chalk.dim(`\n  Total: ${models.length} models`));
-        console.log(chalk.dim(`  ★ = current default\n`));
     }
-    catch (error) {
-        spinner.fail('Failed to fetch models');
-        console.log(chalk.red(`\n  ✗ Could not reach ${masterUrl}`));
-        console.log(chalk.dim('  Is Ollama running?\n'));
-        process.exit(1);
+    console.log(chalk.dim(`\n  Total: ${models.length} models from ${byProvider.size} provider(s)`));
+    console.log(chalk.dim('  * = current default\n'));
+    kernel.destroy();
+}
+export async function pullAllModels(config) {
+    const masterUrl = config.get('masterUrl');
+    const tailscaleMasterUrl = config.get('tailscaleMasterUrl');
+    const candidates = [
+        masterUrl,
+        ...(tailscaleMasterUrl && tailscaleMasterUrl !== masterUrl ? [tailscaleMasterUrl] : []),
+    ];
+    let models = [];
+    for (const candidate of candidates) {
+        try {
+            const response = await fetch(`${candidate}/api/tags`, {
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const data = (await response.json());
+            models = data.models ?? [];
+            break;
+        }
+        catch {
+            // try next
+        }
+    }
+    if (models.length === 0) {
+        console.log(chalk.red('\nCould not reach any configured Ollama master.'));
+        return;
+    }
+    console.log(chalk.bold('\nPulling Models'));
+    console.log(chalk.dim('-'.repeat(50)));
+    console.log(chalk.dim(`  Count: ${models.length}`));
+    console.log();
+    const { execa } = await import('execa');
+    const pulled = [];
+    for (const [index, model] of models.entries()) {
+        const spinner = ora(`[${index + 1}/${models.length}] Pulling ${model.name}...`).start();
+        try {
+            await execa('ollama', ['pull', model.name], { stdio: 'inherit' });
+            pulled.push(model.name);
+            spinner.succeed(`Pulled ${model.name}`);
+        }
+        catch {
+            spinner.fail(`Failed to pull ${model.name}`);
+        }
     }
+    console.log(chalk.green(`\nPulled ${pulled.length}/${models.length} models successfully.`));
 }

package/dist/commands/providers.d.ts

@@ -0,0 +1,6 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+export declare function providersList(config: Conf<InfinicodeConfig>): Promise<void>;
+export declare function providersAdd(config: Conf<InfinicodeConfig>): Promise<void>;
+export declare function providersRemove(config: Conf<InfinicodeConfig>, id: string): Promise<void>;
+export declare function providersTest(config: Conf<InfinicodeConfig>, id?: string): Promise<void>;

package/dist/commands/providers.js

@@ -0,0 +1,95 @@
+/**
+ * infinicode providers — view + edit cloud provider credentials.
+ *
+ *   infinicode providers             list configured providers
+ *   infinicode providers add          add a new cloud provider (interactive)
+ *   infinicode providers remove <id> remove a provider
+ *   infinicode providers test [id]   test connection to one or all providers
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { FREE_PROVIDERS, getProviderPreset, toCloudProviderConfig } from '../kernel/free-providers.js';
+import { testOllamaProvider, testCloudProvider, testProviderInteractive } from '../kernel/provider-discovery.js';
+export async function providersList(config) {
+    const cloud = config.get('cloudProviders') ?? [];
+    console.log(chalk.bold('\nConfigured Providers'));
+    console.log(chalk.dim('-'.repeat(60)));
+    // Ollama
+    const ollamaURL = config.get('masterUrl');
+    console.log(`  ${chalk.cyan('ollama')}  ${ollamaURL}`);
+    if (config.get('tailscaleMasterUrl')) {
+        console.log(chalk.dim(`           tailscale fallback: ${config.get('tailscaleMasterUrl')}`));
+    }
+    if (cloud.length === 0) {
+        console.log(chalk.dim('\n  No cloud providers configured.'));
+    }
+    else {
+        console.log();
+        for (const p of cloud) {
+            const status = p.enabled ? chalk.green('✓') : chalk.yellow('○');
+            console.log(`  ${status} ${chalk.cyan(p.id.padEnd(12))} ${p.name}`);
+            console.log(chalk.dim(`       ${p.baseURL}`));
+        }
+    }
+    console.log(chalk.dim(`\n  Run ${chalk.cyan('infinicode providers add')} to add a cloud provider.`));
+    console.log(chalk.dim(`  Run ${chalk.cyan('infinicode providers test')} to test connections.\n`));
+}
+export async function providersAdd(config) {
+    const existing = new Set((config.get('cloudProviders') ?? []).map(p => p.id));
+    const choices = FREE_PROVIDERS.map(p => ({
+        name: `${p.name} — ${p.notes ?? ''}${existing.has(p.id) ? chalk.dim(' (already configured)') : ''}`,
+        value: p.id,
+        short: p.name,
+    }));
+    const { presetId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'presetId',
+            message: 'Which cloud provider?',
+            choices,
+            pageSize: 10,
+        },
+    ]);
+    const preset = getProviderPreset(presetId);
+    if (!preset)
+        return;
+    console.log(chalk.dim(`\n  Get a free API key at: ${chalk.cyan(preset.keyUrl)}`));
+    const { apiKey } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: `API key for ${preset.name}:`,
+            mask: '*',
+        },
+    ]);
+    const cfg = toCloudProviderConfig(preset, apiKey);
+    const result = await testProviderInteractive(preset.name, () => testCloudProvider(cfg));
+    cfg.enabled = result.ok;
+    const cloud = config.get('cloudProviders') ?? [];
+    const filtered = cloud.filter(p => p.id !== presetId);
+    filtered.push(cfg);
+    config.set('cloudProviders', filtered);
+    console.log(chalk.green(`\n  ✓ ${preset.name} ${result.ok ? 'added + enabled' : 'added (disabled — test failed, set API key later with `infinicode providers add`)'}.`));
+}
+export async function providersRemove(config, id) {
+    const cloud = config.get('cloudProviders') ?? [];
+    const next = cloud.filter(p => p.id !== id);
+    if (next.length === cloud.length) {
+        console.log(chalk.yellow(`No provider named "${id}" configured.`));
+        return;
+    }
+    config.set('cloudProviders', next);
+    console.log(chalk.green(`✓ Removed ${id}.`));
+}
+export async function providersTest(config, id) {
+    // Test Ollama
+    if (!id || id === 'ollama') {
+        await testProviderInteractive('Ollama', () => testOllamaProvider(config.get('masterUrl'), config.get('tailscaleMasterUrl')));
+    }
+    const cloud = config.get('cloudProviders') ?? [];
+    for (const p of cloud) {
+        if (id && id !== p.id)
+            continue;
+        await testProviderInteractive(p.name, () => testCloudProvider(p));
+    }
+}

package/dist/commands/run.d.ts

@@ -1,2 +1,3 @@
 import type Conf from 'conf';
-export declare function runAgent(masterUrl: string, model: string, useTui: boolean, config: Conf<any>): Promise<void>;
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+export declare function runAgent(_masterUrl: string, _model: string, _useTui: boolean, config: Conf<InfinicodeConfig>): Promise<void>;