infinicode 1.0.0 → 2.1.0

package/dist/commands/kernel-setup.js

@@ -0,0 +1,303 @@
+/**
+ * infinicode kernel-setup — friendly interactive wizard.
+ *
+ * Flow:
+ *   1. Ollama master (optional — LAN + Tailscale fallback)
+ *   2. Cloud providers — choose which to set up, enter API key, test, load models
+ *      (Groq, OpenRouter, GitHub Models, NVIDIA, HF, Gemini)
+ *   3. Discover all models across all healthy providers
+ *   4. Per-worker model pinning with arrow-key lists
+ *   5. Pick a default policy
+ *   6. Save + summary
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { WORKER_TYPES_ORDER, WORKER_DESCRIPTIONS } from '../kernel/config-schema.js';
+import { FREE_PROVIDERS, getProviderPreset, toCloudProviderConfig } from '../kernel/free-providers.js';
+import { testOllamaProvider, testCloudProvider, testProviderInteractive, discoverAllModels, modelLabel, suggestAllWorkerModels, } from '../kernel/provider-discovery.js';
+export async function kernelSetupWizard(config) {
+    console.log(chalk.bold.cyan('\n  infinicode Setup\n  ────────────────'));
+    console.log(chalk.dim('  Provider-agnostic AI execution kernel.'));
+    console.log(chalk.dim('  Set up Ollama (optional) + cloud providers, then pick a model per worker type.\n'));
+    await step1Ollama(config);
+    await step2CloudProviders(config);
+    await step3WorkerModels(config);
+    await step4Policy(config);
+    await step5Save(config);
+}
+// ── Step 1: Ollama (optional) ──────────────────────────────────────────────
+async function step1Ollama(config) {
+    console.log(chalk.bold('\n  Step 1 — Ollama master (local inference, optional)'));
+    console.log(chalk.dim('  The kernel prefers local inference when available.'));
+    console.log(chalk.dim('  Skip this if you only want cloud providers.\n'));
+    const current = config.get('masterUrl');
+    const { setupOllama } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'setupOllama',
+            message: `Configure Ollama master? (current: ${chalk.cyan(current)})`,
+            default: true,
+        },
+    ]);
+    if (!setupOllama) {
+        console.log(chalk.dim('  Skipping Ollama — cloud providers only.\n'));
+        return;
+    }
+    const { masterIp, port, model, tailscaleIp } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'masterIp',
+            message: 'Ollama master IP or URL:',
+            default: 'localhost',
+        },
+        {
+            type: 'input',
+            name: 'port',
+            message: 'Port:',
+            default: '11434',
+        },
+        {
+            type: 'input',
+            name: 'model',
+            message: 'Default Ollama model:',
+            default: config.get('defaultModel') ?? 'qwen2.5-coder:14b',
+        },
+        {
+            type: 'input',
+            name: 'tailscaleIp',
+            message: 'Tailscale fallback IP/host (optional):',
+            default: '',
+        },
+    ]);
+    const masterUrl = masterIp.startsWith('http://') || masterIp.startsWith('https://')
+        ? masterIp
+        : `http://${masterIp}:${port}`;
+    const tailscaleMasterUrl = tailscaleIp
+        ? (tailscaleIp.startsWith('http://') || tailscaleIp.startsWith('https://')
+            ? tailscaleIp
+            : `http://${tailscaleIp}:${port}`)
+        : undefined;
+    const spinner = ora('Testing Ollama connection...').start();
+    try {
+        const result = await testOllamaProvider(masterUrl, tailscaleMasterUrl);
+        if (result.ok) {
+            spinner.succeed(`Ollama connected — ${chalk.green(String(result.modelCount))} models, ${result.latencyMs ?? 0}ms`);
+        }
+        else {
+            spinner.warn(`Ollama not reachable, but config saved. You can start it later.`);
+        }
+    }
+    catch {
+        spinner.warn(`Ollama not reachable, but config saved. You can start it later.`);
+    }
+    config.set('masterUrl', masterUrl);
+    config.set('defaultModel', model);
+    if (tailscaleMasterUrl) {
+        config.set('tailscaleMasterUrl', tailscaleMasterUrl);
+    }
+    console.log(chalk.green(`  ✓ Ollama config saved: ${chalk.cyan(masterUrl)}\n`));
+}
+// ── Step 2: Cloud providers ────────────────────────────────────────────────
+async function step2CloudProviders(config) {
+    console.log(chalk.bold('\n  Step 2 — Cloud providers'));
+    console.log(chalk.dim('  Choose which providers to set up. For each: enter API key,'));
+    console.log(chalk.dim('  test connection, load models. More providers = better rotation.\n'));
+    const existing = new Map((config.get('cloudProviders') ?? []).map(p => [p.id, p]));
+    const choices = FREE_PROVIDERS.map(p => {
+        const configured = existing.get(p.id);
+        const status = configured?.enabled
+            ? chalk.green('(configured ✓)')
+            : configured
+                ? chalk.yellow('(disabled)')
+                : chalk.dim('(not set)');
+        return {
+            name: `${p.name} ${status} — ${p.notes ?? ''}`,
+            value: p.id,
+            short: p.name,
+        };
+    });
+    const { selected } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selected',
+            message: 'Select cloud providers to set up (space to toggle, enter to confirm):',
+            choices,
+            default: FREE_PROVIDERS.filter(p => existing.has(p.id) && existing.get(p.id)?.enabled).map(p => p.id),
+            pageSize: 12,
+        },
+    ]);
+    if (selected.length === 0) {
+        console.log(chalk.dim('  No cloud providers selected.\n'));
+        // keep existing
+        return;
+    }
+    const nextProviders = [];
+    for (const presetId of selected) {
+        const preset = getProviderPreset(presetId);
+        if (!preset)
+            continue;
+        console.log(chalk.bold.cyan(`\n  ── ${preset.name} ──────────────────────────────`));
+        console.log(chalk.dim(`  Get a free API key at: ${chalk.cyan(preset.keyUrl)}`));
+        if (preset.notes)
+            console.log(chalk.dim(`  ${preset.notes}`));
+        const existingCfg = existing.get(presetId);
+        const { apiKey } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: `API key for ${preset.name}:`,
+                default: existingCfg?.apiKey ?? '',
+                mask: '*',
+            },
+        ]);
+        if (!apiKey) {
+            const { skip } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'skip',
+                    message: `No key entered — skip ${preset.name}?`,
+                    default: true,
+                },
+            ]);
+            if (skip)
+                continue;
+        }
+        const cfg = toCloudProviderConfig(preset, apiKey);
+        // Test connection + load models
+        const result = await testProviderInteractive(preset.name, () => testCloudProvider(cfg));
+        cfg.enabled = result.ok;
+        if (result.ok) {
+            console.log(chalk.green(`  ✓ ${preset.name} connected — ${result.modelCount} models loaded`));
+        }
+        else {
+            console.log(chalk.yellow(`  ⚠ ${preset.name} test failed, but config saved (enable later with \`infinicode providers test\`)`));
+        }
+        nextProviders.push(cfg);
+    }
+    // keep previously configured providers that weren't re-visited
+    for (const [id, cfg] of existing) {
+        if (!nextProviders.find(p => p.id === id)) {
+            nextProviders.push(cfg);
+        }
+    }
+    config.set('cloudProviders', nextProviders);
+    const enabledCount = nextProviders.filter(p => p.enabled).length;
+    console.log(chalk.green(`\n  ✓ ${enabledCount} cloud provider(s) enabled for rotation.\n`));
+}
+// ── Step 3: Worker model pinning ────────────────────────────────────────────
+async function step3WorkerModels(config) {
+    console.log(chalk.bold('\n  Step 3 — Pick a model for each worker type'));
+    console.log(chalk.dim('  Workers request capabilities, the router picks the model.'));
+    console.log(chalk.dim('  Pinning a model overrides the router for that worker type.\n'));
+    const spinner = ora('Discovering models across all providers...').start();
+    let discovered = [];
+    try {
+        discovered = await discoverAllModels({
+            masterUrl: config.get('masterUrl'),
+            tailscaleMasterUrl: config.get('tailscaleMasterUrl'),
+            cloudProviders: config.get('cloudProviders') ?? [],
+        });
+    }
+    finally {
+        spinner.stop();
+    }
+    if (discovered.length === 0) {
+        console.log(chalk.yellow('  No models discovered — skipping worker pinning.'));
+        console.log(chalk.dim('  The router will use whatever models providers report at runtime.\n'));
+        return;
+    }
+    console.log(chalk.green(`  Found ${discovered.length} models across providers.\n`));
+    const suggestions = suggestAllWorkerModels(discovered);
+    const currentPrefs = config.get('workerModels') ?? {};
+    const workerModels = { ...currentPrefs };
+    for (const type of WORKER_TYPES_ORDER) {
+        const suggestion = suggestions[type];
+        const description = WORKER_DESCRIPTIONS[type];
+        const options = [
+            { name: chalk.dim('— router decides (no pin) —'), value: null, short: 'auto' },
+        ];
+        const valueToKey = (v) => (v ? `${v.providerId}/${v.modelId}` : '');
+        // dedupe by provider/model
+        const seen = new Set();
+        for (const dm of discovered) {
+            const key = `${dm.providerId}/${dm.model.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            options.push({ name: modelLabel(dm), value: key, short: key });
+        }
+        const suggestedKey = suggestion ? `${suggestion.providerId}/${suggestion.modelId}` : null;
+        const currentKey = valueToKey(currentPrefs[type]);
+        const defaultKey = currentKey || suggestedKey || null;
+        const { pick } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'pick',
+                message: `${chalk.cyan(type.padEnd(14))} ${chalk.dim(description)}`,
+                choices: options,
+                default: defaultKey,
+                pageSize: 12,
+            },
+        ]);
+        if (pick) {
+            const [providerId, ...modelParts] = pick.split('/');
+            workerModels[type] = { providerId, modelId: modelParts.join('/') };
+        }
+        else {
+            delete workerModels[type];
+        }
+    }
+    config.set('workerModels', workerModels);
+    const pinnedCount = Object.keys(workerModels).length;
+    console.log(chalk.green(`\n  ✓ ${pinnedCount} worker type(s) pinned.\n`));
+}
+// ── Step 4: Policy ────────────────────────────────────────────────────────────
+async function step4Policy(config) {
+    console.log(chalk.bold('\n  Step 4 — Default routing policy'));
+    console.log(chalk.dim('  Policies decide how the router scores providers + models.\n'));
+    const policyChoices = [
+        { name: 'local-first      — prefer Ollama, fall back to cloud', value: 'local-first' },
+        { name: 'free-first       — prefer free providers across the board', value: 'free-first' },
+        { name: 'fastest          — lowest latency wins', value: 'fastest' },
+        { name: 'highest-quality  — bigger/slower models preferred', value: 'highest-quality' },
+        { name: 'privacy-first    — local only, never send to cloud', value: 'privacy-first' },
+        { name: 'balanced         — mix of all factors', value: 'balanced' },
+        { name: 'offline          — local providers only', value: 'offline' },
+    ];
+    const { policy } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'policy',
+            message: 'Default policy:',
+            choices: policyChoices,
+            default: config.get('policy') ?? 'local-first',
+            pageSize: 10,
+        },
+    ]);
+    config.set('policy', policy);
+    console.log(chalk.green(`  ✓ Policy set to ${chalk.cyan(policy)}\n`));
+}
+// ── Step 5: Save + summary ───────────────────────────────────────────────────
+async function step5Save(config) {
+    console.log(chalk.bold.cyan('\n  Setup complete!\n  ─────────────'));
+    console.log(chalk.dim('  Configuration saved.\n'));
+    const cloud = config.get('cloudProviders') ?? [];
+    const enabledCloud = cloud.filter(p => p.enabled);
+    const workerModels = config.get('workerModels') ?? {};
+    const pinnedCount = Object.keys(workerModels).length;
+    console.log(`  Ollama master:    ${chalk.cyan(config.get('masterUrl'))}`);
+    console.log(`  Default model:    ${chalk.cyan(config.get('defaultModel'))}`);
+    console.log(`  Cloud providers:  ${chalk.green(String(enabledCloud.length))} enabled`);
+    for (const p of enabledCloud) {
+        console.log(`    ${chalk.dim('•')} ${p.name} (${p.id})`);
+    }
+    console.log(`  Worker pins:      ${chalk.green(String(pinnedCount))}/${WORKER_TYPES_ORDER.length}`);
+    console.log(`  Default policy:   ${chalk.cyan(config.get('policy') ?? 'local-first')}`);
+    console.log();
+    console.log(chalk.dim('  Start the TUI:    ') + chalk.cyan('infinicode'));
+    console.log(chalk.dim('  Run a mission:    ') + chalk.cyan('infinicode mission run --sample hello-code'));
+    console.log(chalk.dim('  Edit workers:     ') + chalk.cyan('infinicode workers edit'));
+    console.log(chalk.dim('  Edit providers:   ') + chalk.cyan('infinicode providers'));
+    console.log();
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,14 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/setup.js';
+export interface McpOptions {
+    role?: string;
+    name?: string;
+    meshPort?: string;
+    token?: string;
+    seed?: string[];
+    tailscale?: boolean;
+    tag?: string;
+    lan?: boolean;
+    lanPort?: string;
+}
+export declare function mcpCommand(config: Conf<InfinicodeConfig>, opts: McpOptions): Promise<void>;

package/dist/commands/mcp.js

@@ -0,0 +1,100 @@
+/**
+ * infinicode mcp — run the MCP control server (stdio) + an in-process mesh node.
+ *
+ * This is what an MCP host (InfiniBot, Claude Code, Cursor) spawns. It exposes
+ * the spawn/dispatch/command/role/voice/map tools and joins the device mesh so
+ * those tools reach every device.
+ *
+ *   ~/.claude.json  →  { "mcpServers": { "infinicode": { "command": "infinicode", "args": ["mcp"] } } }
+ *
+ * CRITICAL: stdio MCP uses stdout for the protocol, so EVERY log goes to stderr.
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { buildKernelFromConfig } from '../kernel/setup.js';
+import { Federation, GoalLoop, loadOrCreateIdentity, serveMcpStdio, SilentLogger, } from '../kernel/index.js';
+function pkgVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        return JSON.parse(readFileSync(join(here, '..', '..', 'package.json'), 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Logger that writes ONLY to stderr — safe alongside the stdio MCP channel. */
+const stderrLogger = {
+    debug: () => { },
+    info: (m, ...a) => console.error('[mcp]', m, ...a),
+    warn: (m, ...a) => console.error('[mcp]', m, ...a),
+    error: (m, ...a) => console.error('[mcp]', m, ...a),
+};
+export async function mcpCommand(config, opts) {
+    const fed = config.get('federation') ?? {};
+    const role = (opts.role ?? fed.role ?? 'peer');
+    // Default to 47914 so a co-located `infinicode serve` (47913) doesn't clash.
+    const port = opts.meshPort ? parseInt(opts.meshPort, 10) : (fed.port ?? 47913) + 1;
+    const token = opts.token ?? fed.token;
+    const version = pkgVersion();
+    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+    const identity = loadOrCreateIdentity({ role, displayName: opts.name ?? fed.displayName });
+    const describe = () => {
+        const defs = kernel.workerRuntime.listRegisteredDefinitions();
+        const caps = [...new Set(defs.flatMap(d => d.capabilities))];
+        return {
+            version,
+            capabilities: caps,
+            workers: defs.map(d => d.type),
+            commands: kernel.commands.list().map(c => c.name),
+            providers: kernel.providerManager.listInfos().map(p => p.id),
+        };
+    };
+    const applyConfig = (cfg) => {
+        if (cfg.cloudProviders)
+            config.set('cloudProviders', cfg.cloudProviders);
+        if (cfg.policy)
+            config.set('policy', cfg.policy);
+        if (cfg.defaultModel)
+            config.set('defaultModel', cfg.defaultModel);
+        stderrLogger.info(`applied shared config (rev ${cfg.revision})`);
+    };
+    const federation = new Federation({
+        kernel,
+        identity,
+        describe,
+        logger: stderrLogger,
+        options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig },
+    });
+    try {
+        await federation.start();
+    }
+    catch (err) {
+        stderrLogger.error(`mesh node failed to start on :${port} — ${err instanceof Error ? err.message : String(err)}`);
+        // Continue serving MCP tools; dispatch will report "no peers" until fixed.
+    }
+    // Join the mesh: static seeds + optional Tailscale discovery.
+    const seeds = [...(fed.seeds ?? []), ...(opts.seed ?? [])];
+    for (const url of seeds)
+        await federation.connect(url).catch(() => null);
+    if (opts.tailscale) {
+        const n = await federation.discoverAndConnect(opts.tag).catch(() => 0);
+        stderrLogger.info(`tailscale discovery connected ${n} peer(s)`);
+    }
+    if (opts.lan ?? fed.lan) {
+        federation.startLanDiscovery(opts.tag, opts.lanPort ? parseInt(opts.lanPort, 10) : fed.lanPort);
+        stderrLogger.info('LAN auto-discovery on (udp broadcast)');
+    }
+    // Proactive autonomy: a goal loop the MCP host can populate (add_goal/…).
+    const autonomy = new GoalLoop({ kernel, logger: stderrLogger });
+    autonomy.start();
+    await serveMcpStdio({ kernel, federation, logger: stderrLogger, version, autonomy });
+    const shutdown = async () => {
+        autonomy.stop();
+        await federation.stop();
+        kernel.destroy();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+}

package/dist/commands/mission.d.ts

@@ -0,0 +1,16 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/setup.js';
+export declare function missionRun(config: Conf<InfinicodeConfig>, opts: {
+    goal: string;
+    name?: string;
+    description?: string;
+    task?: string[];
+    cap?: string[];
+    policy?: string;
+    stream?: boolean;
+    sample?: string;
+}): Promise<void>;
+export declare function missionStatus(config: Conf<InfinicodeConfig>, missionId: string): Promise<void>;
+export declare function missionList(config: Conf<InfinicodeConfig>): Promise<void>;
+export declare function missionResume(config: Conf<InfinicodeConfig>, missionId: string): Promise<void>;
+export declare function missionCancel(config: Conf<InfinicodeConfig>, missionId: string): Promise<void>;