infinicode 1.0.0 → 2.1.0

package/dist/cli.js

@@ -5,24 +5,25 @@ import Conf from 'conf';
 import { setupMaster } from './commands/setup.js';
 import { runAgent } from './commands/run.js';
 import { showStatus } from './commands/status.js';
-import { listModels } from './commands/models.js';
-const VERSION = '1.0.0';
+import { listModels, pullAllModels } from './commands/models.js';
+import { missionRun, missionStatus, missionList, missionResume, missionCancel } from './commands/mission.js';
+import { SAMPLE_MISSIONS } from './kernel/sample-missions.js';
+import { kernelSetupWizard } from './commands/kernel-setup.js';
+import { workersList, workersEdit, workersReset } from './commands/workers.js';
+import { providersList, providersAdd, providersRemove, providersTest } from './commands/providers.js';
+import { consoleRepl, consoleRun } from './commands/console.js';
+import { serve } from './commands/serve.js';
+import { mcpCommand } from './commands/mcp.js';
+import { DEFAULT_CONFIG } from './kernel/config-schema.js';
+const VERSION = '2.1.0';
 const config = new Conf({
     projectName: 'infinicode',
-    defaults: {
-        masterUrl: 'http://localhost:11434',
-        defaultModel: 'qwen2.5-coder:14b',
-        theme: 'infini'
-    }
+    defaults: DEFAULT_CONFIG,
 });
 const program = new Command();
-console.log(chalk.cyan(`
-  ⚡ ${chalk.bold('INFINICODE')} v${VERSION}
-  ${chalk.dim('AI Coding Agent • Powered by Ollama')}
-`));
 program
     .name('infinicode')
-    .description('AI coding agent powered by your local Ollama')
+    .description('AI coding agent powered by the OpenKernel execution runtime')
     .version(VERSION);
 // Quick connect command
 program
@@ -31,8 +32,10 @@ program
     .description('Quick connect to Ollama master (e.g., infinicode connect 192.168.1.100)')
     .option('-p, --port <port>', 'Ollama port', '11434')
     .option('-m, --model <model>', 'Default model', 'qwen2.5-coder:14b')
+    .option('--tailscale <host>', 'Tailscale fallback host/IP for the same Ollama master')
+    .option('--tailscale-port <port>', 'Tailscale fallback Ollama port')
     .action(async (masterIp, options) => {
-    await setupMaster(masterIp, options.port, options.model, config);
+    await setupMaster(masterIp, options.port, options.model, config, options.tailscale, options.tailscalePort);
 });
 // Setup wizard
 program
@@ -59,25 +62,24 @@ program
             name: 'model',
             message: 'Default model:',
             default: 'qwen2.5-coder:14b'
+        },
+        {
+            type: 'input',
+            name: 'tailscaleIp',
+            message: 'Tailscale fallback IP/host (optional):',
+            default: ''
         }
     ]);
-    await setupMaster(answers.masterIp, answers.port, answers.model, config);
+    await setupMaster(answers.masterIp, answers.port, answers.model, config, answers.tailscaleIp || undefined);
 });
-// Run the agent (main command)
+// Run the agent (main command) — launches the infinicode TUI with the full provider pool
 program
     .command('run', { isDefault: true })
     .alias('r')
-    .description('Start the coding agent')
-    .option('-m, --model <model>', 'Model to use')
-    .option('--no-tui', 'Disable TUI, use simple mode')
+    .description('Start the infinicode TUI (full provider pool: Ollama + cloud providers)')
+    .option('-m, --model <model>', 'Override the default model')
     .action(async (options) => {
-    const masterUrl = config.get('masterUrl');
-    const model = options.model || config.get('defaultModel');
-    if (!masterUrl || masterUrl === 'http://localhost:11434') {
-        console.log(chalk.yellow('\n⚠️  No master configured. Using localhost.'));
-        console.log(chalk.dim('  Run: infinicode connect <master-ip>\n'));
-    }
-    await runAgent(masterUrl, model, options.tui !== false, config);
+    await runAgent(config.get('masterUrl'), options.model ?? config.get('defaultModel'), true, config);
 });
 // Status command
 program
@@ -91,7 +93,12 @@ program
     .command('models')
     .alias('m')
     .description('List available models on master')
-    .action(async () => {
+    .option('--pull-all', 'Pull every model returned by the selected master')
+    .action(async (options) => {
+    if (options.pullAll) {
+        await pullAllModels(config);
+        return;
+    }
     await listModels(config);
 });
 // Config commands
@@ -135,32 +142,174 @@ program
     }
     console.log();
 });
-// Passthrough to opencode
+// ── OpenKernel: mission command ──────────────────────────────────────────
+const missionCmd = program
+    .command('mission')
+    .alias('k')
+    .description('OpenKernel mission-driven execution');
+missionCmd
+    .command('run')
+    .description('Execute a mission through the kernel')
+    .option('-g, --goal <goal>', 'Mission goal (required unless --sample)')
+    .option('-n, --name <name>', 'Mission name')
+    .option('-d, --description <desc>', 'Mission description')
+    .option('-t, --task <desc...>', 'Task description (repeatable)')
+    .option('-c, --cap <caps...>', 'Capabilities per task (comma-separated, repeatable)')
+    .option('-p, --policy <policy>', 'Policy name (free-first, fastest, highest-quality, local-first, privacy-first, balanced, offline)')
+    .option('-s, --sample <name>', 'Run a built-in sample mission (overrides other options)')
+    .action(async (opts) => {
+    if (!opts.sample && !opts.goal) {
+        console.log(chalk.red('Error: --goal is required unless --sample is provided'));
+        process.exit(1);
+    }
+    await missionRun(config, { goal: opts.goal ?? '', ...opts });
+});
+missionCmd
+    .command('samples')
+    .description('List built-in sample missions')
+    .action(() => {
+    console.log(chalk.bold('\nSample Missions'));
+    console.log(chalk.dim('-'.repeat(40)));
+    for (const [name, m] of Object.entries(SAMPLE_MISSIONS)) {
+        console.log(`  ${chalk.cyan(name)}  ${chalk.dim(m.description)}`);
+    }
+    console.log();
+});
+missionCmd
+    .command('status <missionId>')
+    .description('Show mission status')
+    .action(async (missionId) => {
+    await missionStatus(config, missionId);
+});
+missionCmd
+    .command('list')
+    .description('List missions in this session')
+    .action(async () => {
+    await missionList(config);
+});
+missionCmd
+    .command('resume <missionId>')
+    .description('Resume a paused mission')
+    .action(async (missionId) => {
+    await missionResume(config, missionId);
+});
+missionCmd
+    .command('cancel <missionId>')
+    .description('Cancel a running mission')
+    .action(async (missionId) => {
+    await missionCancel(config, missionId);
+});
+// ── OpenKernel: friendly setup wizard ──────────────────────────────────────
 program
-    .command('opencode [args...]')
-    .description('Run opencode directly with Ollama config injected')
-    .allowUnknownOption()
-    .action(async (args) => {
-    const { execa } = await import('execa');
-    const masterUrl = config.get('masterUrl');
-    process.env.LOCAL_ENDPOINT = `${masterUrl}/v1`;
-    process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
-        providers: {
-            anthropic: { disabled: true },
-            openai: { disabled: true },
-            gemini: { disabled: true },
-            local: { apiKey: 'not-needed' }
-        }
-    });
-    try {
-        await execa('opencode', args, {
-            stdio: 'inherit',
-            env: process.env
-        });
+    .command('kernel-setup')
+    .alias('ks')
+    .description('Friendly interactive setup wizard — providers + worker models + policy')
+    .action(async () => {
+    await kernelSetupWizard(config);
+});
+// ── OpenKernel: worker model preferences ──────────────────────────────────
+const workersCmd = program
+    .command('workers')
+    .alias('w')
+    .description('View + edit per-worker model preferences');
+workersCmd
+    .command('list', { isDefault: true })
+    .description('Show current worker model pins')
+    .action(async () => {
+    await workersList(config);
+});
+workersCmd
+    .command('edit')
+    .alias('e')
+    .description('Interactively pick a model for each worker type')
+    .action(async () => {
+    await workersEdit(config);
+});
+workersCmd
+    .command('reset')
+    .description('Clear all worker pins (router decides for every worker type)')
+    .action(async () => {
+    await workersReset(config);
+});
+// ── OpenKernel: providers ──────────────────────────────────────────────────
+const providersCmd = program
+    .command('providers')
+    .alias('p')
+    .description('View + edit cloud provider credentials');
+providersCmd
+    .command('list', { isDefault: true })
+    .description('List configured providers')
+    .action(async () => {
+    await providersList(config);
+});
+providersCmd
+    .command('add')
+    .description('Add a cloud provider (Groq, OpenRouter, GitHub, NVIDIA, HF, Gemini)')
+    .action(async () => {
+    await providersAdd(config);
+});
+providersCmd
+    .command('remove <id>')
+    .description('Remove a cloud provider')
+    .action(async (id) => {
+    await providersRemove(config, id);
+});
+providersCmd
+    .command('test [id]')
+    .description('Test connection to one or all providers')
+    .action(async (id) => {
+    await providersTest(config, id);
+});
+// ── OpenKernel: command console ────────────────────────────────────────────
+program
+    .command('console [command...]')
+    .alias('x')
+    .description('Interactive OpenKernel command console (/status, /workers, /goal …). Pass a /command to run once and exit.')
+    .action(async (command) => {
+    const joined = (command ?? []).join(' ').trim();
+    if (joined) {
+        await consoleRun(config, joined);
     }
-    catch (e) {
-        if (e.exitCode)
-            process.exit(e.exitCode);
+    else {
+        await consoleRepl(config);
     }
 });
+// ── OpenKernel: federation mesh node ───────────────────────────────────────
+program
+    .command('serve')
+    .description('Run this device as a federation mesh node (LAN + Tailscale)')
+    .option('--role <role>', 'node role: hub | peer | satellite | relay')
+    .option('--hub', 'shorthand for --role hub')
+    .option('--name <name>', 'friendly node name (defaults to hostname)')
+    .option('--port <port>', 'mesh listen port (default 47913)')
+    .option('--host <host>', 'bind host (default 0.0.0.0)')
+    .option('--token <token>', 'shared bearer token peers must present')
+    .option('--seed <url...>', 'peer base URL(s) to connect to on start')
+    .option('--auto-update', 'accept auto-updates announced by a hub/relay')
+    .option('--tailscale', 'auto-discover + connect peers over Tailscale')
+    .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')
+    .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
+    .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
+    .option('--gateway <url>', 'link to an InfiniBot gateway (ws://host:18789) — appear on its neural-mesh map')
+    .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
+    .option('--gateway-password <password>', 'auth password for the InfiniBot gateway')
+    .action(async (opts) => {
+    await serve(config, opts);
+});
+// ── OpenKernel: MCP control server (stdio) ─────────────────────────────────
+program
+    .command('mcp')
+    .description('Run the MCP control server (stdio) + a mesh node — spawn/dispatch/role/voice/map tools for any MCP host')
+    .option('--role <role>', 'node role: hub | peer | satellite | relay')
+    .option('--name <name>', 'friendly node name')
+    .option('--mesh-port <port>', 'in-process mesh port (default: serve port + 1)')
+    .option('--token <token>', 'shared bearer token peers must present')
+    .option('--seed <url...>', 'peer base URL(s) to connect to on start')
+    .option('--tailscale', 'auto-discover + connect peers over Tailscale')
+    .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')
+    .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
+    .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
+    .action(async (opts) => {
+    await mcpCommand(config, opts);
+});
 program.parse();

package/dist/commands/console.d.ts

@@ -0,0 +1,6 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/setup.js';
+/** One-shot: run a single command against a fresh kernel and exit. */
+export declare function consoleRun(config: Conf<InfinicodeConfig>, command: string): Promise<void>;
+/** Interactive REPL over a persistent kernel. */
+export declare function consoleRepl(config: Conf<InfinicodeConfig>): Promise<void>;

package/dist/commands/console.js

@@ -0,0 +1,111 @@
+/**
+ * infinicode console — interactive OpenKernel command console.
+ *
+ * Exposes the canonical OpenKernel slash-command surface (/status, /workers,
+ * /logs, /pause, /resume, /retry, /models, /providers, /checkpoints, /goal …)
+ * over a live kernel. The SAME registry backs the notification plugins, so what
+ * you type here behaves identically to a Telegram/Discord command.
+ *
+ *   infinicode console                 REPL (type /help)
+ *   infinicode console /status         one-shot dispatch, prints result, exits
+ *   infinicode console /goal build X   run a goal, print the result
+ */
+import chalk from 'chalk';
+import readline from 'node:readline';
+import { buildKernelFromConfig } from '../kernel/setup.js';
+import { SilentLogger } from '../kernel/index.js';
+/** Commands whose output depends on provider health being probed first. */
+const PROVIDER_DEPENDENT = new Set(['status', 'providers', 'p', 'models', 'm']);
+/**
+ * Wait until every provider has been health-checked once (or a timeout).
+ * Health checks are kicked off at registration and run in the background, so a
+ * one-shot command would otherwise read a "0 healthy" snapshot before they land.
+ */
+async function waitForProviders(kernel, timeoutMs = 3500) {
+    const start = Date.now();
+    const total = kernel.providerManager.listInfos().length;
+    while (Date.now() - start < timeoutMs) {
+        const checked = kernel.providerManager.listInfos().filter(p => p.lastCheckedAt).length;
+        if (total > 0 && checked >= total)
+            return;
+        await new Promise(r => setTimeout(r, 150));
+    }
+}
+function render(result) {
+    const mark = result.ok ? chalk.green('✔') : chalk.red('✖');
+    const body = result.text.split('\n');
+    console.log(`${mark} ${body[0] ?? ''}`);
+    for (const line of body.slice(1))
+        console.log('  ' + line);
+}
+/** One-shot: run a single command against a fresh kernel and exit. */
+export async function consoleRun(config, command) {
+    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+    try {
+        const name = command.trim().replace(/^\//, '').split(/\s+/)[0]?.toLowerCase();
+        if (name && PROVIDER_DEPENDENT.has(name))
+            await waitForProviders(kernel);
+        const result = await kernel.command(command);
+        render(result);
+        process.exitCode = result.ok ? 0 : 1;
+    }
+    finally {
+        kernel.destroy();
+    }
+}
+/** Interactive REPL over a persistent kernel. */
+export async function consoleRepl(config) {
+    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+    console.log(chalk.bold('\nOpenKernel Console'));
+    console.log(chalk.dim('Type a /command (e.g. /status, /goal build a todo app). /help lists all. Ctrl-C or /exit to quit.\n'));
+    // Mirror live kernel events dimmed above the prompt so long-running missions
+    // (/goal, /retry) stream progress instead of going silent.
+    const unsub = kernel.subscribeAll((event) => {
+        if (event.type === 'PROVIDER_HEALTH')
+            return;
+        const tag = event.taskId ? `${event.missionId}/${event.taskId}` : event.missionId ?? '';
+        process.stdout.write(chalk.dim(`  · ${event.type}${tag ? ' ' + tag : ''}\n`));
+    });
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.hex('#FFD86B')('openkernel› '),
+    });
+    const shutdown = () => {
+        unsub();
+        rl.close();
+        kernel.destroy();
+    };
+    // Process lines one at a time. Input is paused while a command runs so a
+    // fast paste (or piped stdin) can't race /exit ahead of a pending command.
+    let chain = Promise.resolve();
+    rl.prompt();
+    rl.on('line', (raw) => {
+        const input = raw.trim();
+        chain = chain.then(async () => {
+            if (!input)
+                return rl.prompt();
+            if (input === '/exit' || input === '/quit' || input === 'exit' || input === 'quit') {
+                shutdown();
+                return;
+            }
+            rl.pause();
+            try {
+                const result = await kernel.command(input);
+                render(result);
+            }
+            catch (err) {
+                console.log(chalk.red(`✖ ${err instanceof Error ? err.message : String(err)}`));
+            }
+            rl.resume();
+            rl.prompt();
+        });
+    });
+    rl.on('close', () => {
+        console.log(chalk.dim('\nbye.'));
+        process.exit(0);
+    });
+    await new Promise(() => {
+        /* keep process alive until rl closes */
+    });
+}

package/dist/commands/kernel-setup.d.ts

@@ -0,0 +1,3 @@
+import type Conf from 'conf';
+import type { InfinicodeConfig } from '../kernel/config-schema.js';
+export declare function kernelSetupWizard(config: Conf<InfinicodeConfig>): Promise<void>;