infinicode 1.0.0 → 2.0.0

package/dist/commands/setup.js

@@ -1,54 +1,57 @@
 import chalk from 'chalk';
 import ora from 'ora';
-export async function setupMaster(masterIp, port, model, config) {
-    const masterUrl = `http://${masterIp}:${port}`;
-    console.log(chalk.bold('\n⚡ Infinicode Setup'));
-    console.log(chalk.dim('─'.repeat(40)));
-    console.log(`  Master: ${chalk.cyan(masterUrl)}`);
-    console.log(`  Model:  ${chalk.cyan(model)}`);
+function buildMasterUrl(host, port) {
+    if (host.startsWith('http://') || host.startsWith('https://')) {
+        return host;
+    }
+    return `http://${host}:${port}`;
+}
+async function testOllama(masterUrl) {
+    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();
+    return data.models || [];
+}
+export async function setupMaster(masterIp, port, model, config, tailscaleMasterIp, tailscalePort = port) {
+    const masterUrl = buildMasterUrl(masterIp, port);
+    const tailscaleMasterUrl = tailscaleMasterIp ? buildMasterUrl(tailscaleMasterIp, tailscalePort) : undefined;
+    console.log(chalk.bold('\nInfinicode Setup'));
+    console.log(chalk.dim('-'.repeat(40)));
+    console.log(`  LAN Master:       ${chalk.cyan(masterUrl)}`);
+    if (tailscaleMasterUrl) {
+        console.log(`  Tailscale Master: ${chalk.cyan(tailscaleMasterUrl)}`);
+    }
+    console.log(`  Model:            ${chalk.cyan(model)}`);
     console.log();
-    const spinner = ora('Testing connection...').start();
+    let models;
+    const spinner = ora('Testing LAN connection...').start();
     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.succeed('Connected to Ollama');
-        // Save config
-        config.set('masterUrl', masterUrl);
-        config.set('defaultModel', model);
-        // Show available models
-        console.log(chalk.bold('\nAvailable models:'));
-        const models = data.models || [];
-        if (models.length === 0) {
-            console.log(chalk.yellow('  No models found. Pull one with:'));
-            console.log(chalk.dim(`  ollama pull ${model}`));
-        }
-        else {
-            for (const m of models.slice(0, 10)) {
-                const isDefault = m.name === model || m.name.startsWith(model.split(':')[0]);
-                console.log(`  ${isDefault ? chalk.green('●') : chalk.dim('○')} ${m.name}`);
-            }
-            if (models.length > 10) {
-                console.log(chalk.dim(`  ... and ${models.length - 10} more`));
-            }
+        models = await testOllama(masterUrl);
+        spinner.succeed('Connected to Ollama over LAN');
+    }
+    catch {
+        spinner.fail('LAN connection failed');
+    }
+    if (tailscaleMasterUrl) {
+        const tailscaleSpinner = ora('Testing Tailscale fallback...').start();
+        try {
+            const tailscaleModels = await testOllama(tailscaleMasterUrl);
+            tailscaleSpinner.succeed('Tailscale fallback is reachable');
+            models ??= tailscaleModels;
         }
-        // Check if default model exists
-        const hasModel = models.some(m => m.name === model || m.name.startsWith(model.split(':')[0]));
-        if (!hasModel && models.length > 0) {
-            console.log(chalk.yellow(`\n⚠️  Model '${model}' not found.`));
-            console.log(chalk.dim(`  Available: ${models.slice(0, 3).map(m => m.name).join(', ')}`));
-            console.log(chalk.dim(`  Pull it: ollama pull ${model}`));
+        catch {
+            tailscaleSpinner.warn('Tailscale fallback saved, but not reachable right now');
         }
-        console.log(chalk.green('\n✓ Configuration saved!'));
-        console.log(chalk.dim('\nRun `infinicode` or `ic` to start coding.\n'));
     }
-    catch (error) {
-        spinner.fail('Connection failed');
-        console.log(chalk.red(`\n✗ Could not connect to ${masterUrl}`));
+    if (!models) {
+        console.log(chalk.red(`\nCould not connect to ${masterUrl}`));
+        if (tailscaleMasterUrl) {
+            console.log(chalk.red(`Could not connect to ${tailscaleMasterUrl}`));
+        }
         console.log(chalk.dim('\nMake sure Ollama is running with network access:'));
         console.log(chalk.cyan('  OLLAMA_HOST=0.0.0.0:11434 ollama serve'));
         console.log(chalk.dim('\nOr via systemd:'));
@@ -57,4 +60,34 @@ export async function setupMaster(masterIp, port, model, config) {
         console.log(chalk.cyan('  sudo systemctl restart ollama\n'));
         process.exit(1);
     }
+    config.set('masterUrl', masterUrl);
+    config.set('defaultModel', model);
+    if (tailscaleMasterUrl) {
+        config.set('tailscaleMasterUrl', tailscaleMasterUrl);
+    }
+    else {
+        config.delete('tailscaleMasterUrl');
+    }
+    console.log(chalk.bold('\nAvailable models:'));
+    if (models.length === 0) {
+        console.log(chalk.yellow('  No models found. Pull one with:'));
+        console.log(chalk.dim(`  ollama pull ${model}`));
+    }
+    else {
+        for (const m of models.slice(0, 10)) {
+            const isDefault = m.name === model || m.name.startsWith(model.split(':')[0]);
+            console.log(`  ${isDefault ? chalk.green('*') : chalk.dim('-')} ${m.name}`);
+        }
+        if (models.length > 10) {
+            console.log(chalk.dim(`  ... and ${models.length - 10} more`));
+        }
+    }
+    const hasModel = models.some(m => m.name === model || m.name.startsWith(model.split(':')[0]));
+    if (!hasModel && models.length > 0) {
+        console.log(chalk.yellow(`\nModel '${model}' not found.`));
+        console.log(chalk.dim(`  Available: ${models.slice(0, 3).map(m => m.name).join(', ')}`));
+        console.log(chalk.dim(`  Pull it: ollama pull ${model}`));
+    }
+    console.log(chalk.green('\nConfiguration saved.'));
+    console.log(chalk.dim('\nRun `infinicode` or `ic` to start coding.\n'));
 }

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -1,40 +1,56 @@
 import chalk from 'chalk';
 import ora from 'ora';
+import { buildKernelFromConfig } from '../kernel/setup.js';
 export async function showStatus(config) {
     const masterUrl = config.get('masterUrl');
     const defaultModel = config.get('defaultModel');
-    console.log(chalk.bold('\n⚡ Infinicode Status'));
-    console.log(chalk.dim('─'.repeat(40)));
-    console.log(`  Master URL:    ${chalk.cyan(masterUrl)}`);
-    console.log(`  Default Model: ${chalk.cyan(defaultModel)}`);
-    const spinner = ora('Checking connection...').start();
+    const policy = config.get('policy') ?? 'balanced';
+    console.log(chalk.bold('\nInfinicode Status'));
+    console.log(chalk.dim('-'.repeat(50)));
+    console.log(`  Default Model:  ${chalk.cyan(defaultModel)}`);
+    console.log(`  Policy:         ${chalk.cyan(policy)}`);
+    console.log(`  Ollama master:  ${chalk.cyan(masterUrl)}`);
+    if (config.get('tailscaleMasterUrl')) {
+        console.log(`  Tailscale:      ${chalk.cyan(config.get('tailscaleMasterUrl'))}`);
+    }
+    console.log();
+    const kernel = buildKernelFromConfig(config);
+    const spinner = ora('Checking all providers...').start();
     try {
-        const response = await fetch(`${masterUrl}/api/tags`, {
-            signal: AbortSignal.timeout(5000)
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        const data = await response.json();
-        spinner.succeed('Ollama connected');
-        const models = data.models || [];
-        console.log(`  Models:        ${chalk.green(models.length)} available`);
-        // Check if default model is available
-        const hasDefault = models.some(m => m.name === defaultModel || m.name.startsWith(defaultModel.split(':')[0]));
-        if (hasDefault) {
-            console.log(`  Status:        ${chalk.green('● Ready')}`);
-        }
-        else {
-            console.log(`  Status:        ${chalk.yellow('● Missing model')}`);
-            console.log(chalk.yellow(`\n  ⚠️  Default model '${defaultModel}' not found.`));
-            console.log(chalk.dim(`  Pull it: ollama pull ${defaultModel}`));
-        }
+        // Give the token-verified health checks a moment to complete.
+        await new Promise(r => setTimeout(r, 3000));
+        await printProviderHealth(kernel);
+        spinner.succeed('Provider check complete');
     }
-    catch (error) {
-        spinner.fail('Connection failed');
-        console.log(`  Status:        ${chalk.red('● Offline')}`);
-        console.log(chalk.red(`\n  ✗ Could not reach ${masterUrl}`));
-        console.log(chalk.dim('  Is Ollama running with OLLAMA_HOST=0.0.0.0?'));
+    catch (err) {
+        spinner.fail('Provider check failed');
+        console.error(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        kernel.destroy();
     }
     console.log();
 }
+async function printProviderHealth(kernel) {
+    const infos = kernel.providerManager.listInfos();
+    if (infos.length === 0) {
+        console.log(chalk.yellow('  No providers registered.'));
+        return;
+    }
+    console.log(chalk.bold('\n  Providers'));
+    console.log(chalk.dim('  ' + '-'.repeat(46)));
+    for (const p of infos) {
+        const status = p.healthy ? chalk.green('●') : chalk.red('○');
+        const latency = p.latencyMs ? `${p.latencyMs}ms` : '-';
+        const sr = p.successRate !== undefined ? `${(p.successRate * 100).toFixed(0)}%` : '-';
+        const quota = p.quotaRemaining !== undefined ? `q=${p.quotaRemaining}` : '';
+        console.log(`  ${status} ${chalk.cyan(p.id.padEnd(12))} ${(p.name ?? '').padEnd(18)} ${chalk.dim(`lat=${latency} ok=${sr} ${quota}`)}`);
+        if (p.error) {
+            console.log(chalk.dim(`       error: ${p.error}`));
+        }
+    }
+    const healthy = infos.filter(p => p.healthy).length;
+    console.log(chalk.dim(`\n  ${healthy}/${infos.length} providers healthy`));
+    const workerModels = kernel.workerRuntime.listRegisteredDefinitions();
+    console.log(chalk.dim(`  ${workerModels.length} worker types registered`));
+}

package/dist/commands/workers.d.ts

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

package/dist/commands/workers.js

@@ -0,0 +1,103 @@
+/**
+ * infinicode workers — view + edit per-worker model preferences.
+ *
+ *   infinicode workers              list current pins
+ *   infinicode workers edit          interactive editor (arrow-key)
+ *   infinicode workers reset         clear all pins (router decides)
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { WORKER_TYPES_ORDER, WORKER_DESCRIPTIONS } from '../kernel/config-schema.js';
+import { discoverAllModels, modelLabel, suggestModelForWorker } from '../kernel/provider-discovery.js';
+import ora from 'ora';
+export async function workersList(config) {
+    const workerModels = config.get('workerModels') ?? {};
+    console.log(chalk.bold('\nWorker Model Preferences'));
+    console.log(chalk.dim('-'.repeat(60)));
+    for (const type of WORKER_TYPES_ORDER) {
+        const pref = workerModels[type];
+        const desc = WORKER_DESCRIPTIONS[type];
+        if (pref) {
+            console.log(`  ${chalk.cyan(type.padEnd(14))} ${chalk.green(pref.providerId + '/' + pref.modelId)}`);
+        }
+        else {
+            console.log(`  ${chalk.cyan(type.padEnd(14))} ${chalk.dim('auto  (router decides)')}`);
+        }
+        console.log(chalk.dim(`  ${''.padEnd(14)} ${desc}`));
+    }
+    const pinned = Object.keys(workerModels).length;
+    console.log(chalk.dim(`\n  ${pinned}/${WORKER_TYPES_ORDER.length} pinned. Run ${chalk.cyan('infinicode workers edit')} to change.\n`));
+}
+export async function workersEdit(config) {
+    console.log(chalk.bold('\nWorker Model Editor'));
+    console.log(chalk.dim('  Pick a model for each worker type. Choose "auto" to let the router decide.\n'));
+    const spinner = ora('Discovering models...').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. Make sure Ollama or a cloud provider is reachable.'));
+        return;
+    }
+    const current = config.get('workerModels') ?? {};
+    const next = { ...current };
+    for (const type of WORKER_TYPES_ORDER) {
+        const suggestion = suggestModelForWorker(type, discovered);
+        const currentKey = current[type] ? `${current[type].providerId}/${current[type].modelId}` : '';
+        const suggestedKey = suggestion ? `${suggestion.providerId}/${suggestion.model.id}` : '';
+        const options = [
+            { name: chalk.dim('— auto (router decides) —'), value: null, short: 'auto' },
+        ];
+        const seen = new Set();
+        for (const dm of discovered) {
+            const key = `${dm.providerId}/${dm.model.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const marker = key === suggestedKey ? chalk.green(' (recommended)') : '';
+            options.push({ name: modelLabel(dm) + marker, value: key, short: key });
+        }
+        const { pick } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'pick',
+                message: `${chalk.cyan(type.padEnd(14))} ${chalk.dim(WORKER_DESCRIPTIONS[type])}`,
+                choices: options,
+                default: currentKey || suggestedKey || null,
+                pageSize: 12,
+            },
+        ]);
+        if (pick) {
+            const [providerId, ...modelParts] = pick.split('/');
+            next[type] = { providerId, modelId: modelParts.join('/') };
+        }
+        else {
+            delete next[type];
+        }
+    }
+    config.set('workerModels', next);
+    const pinned = Object.keys(next).length;
+    console.log(chalk.green(`\n  ✓ Saved. ${pinned}/${WORKER_TYPES_ORDER.length} worker types pinned.\n`));
+}
+export async function workersReset(config) {
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Clear all worker model pins? (router will decide for every worker type)',
+            default: false,
+        },
+    ]);
+    if (!confirm)
+        return;
+    config.set('workerModels', {});
+    console.log(chalk.green('✓ All worker pins cleared. The router will decide.'));
+}

package/dist/kernel/autonomy/goal-loop.d.ts

@@ -0,0 +1,49 @@
+import type { Capability, KernelLike, Logger } from '../types.js';
+export type GoalTrigger = {
+    kind: 'interval';
+    everyMs: number;
+} | {
+    kind: 'idle';
+    afterMs: number;
+} | {
+    kind: 'once';
+};
+export interface Goal {
+    id: string;
+    prompt: string;
+    capabilities: Capability[];
+    trigger: GoalTrigger;
+    enabled: boolean;
+    runCount: number;
+    lastRunAt?: number;
+    running: boolean;
+}
+export interface GoalInput {
+    prompt: string;
+    capabilities?: Capability[];
+    trigger: GoalTrigger;
+}
+export interface GoalLoopDeps {
+    kernel: KernelLike;
+    logger: Logger;
+    /** Tick cadence for evaluating triggers (default 1s). */
+    tickMs?: number;
+}
+export declare class GoalLoop {
+    private deps;
+    private goals;
+    private timer?;
+    private unsub?;
+    private lastActivity;
+    private readonly tickMs;
+    constructor(deps: GoalLoopDeps);
+    add(input: GoalInput): Goal;
+    remove(id: string): boolean;
+    setEnabled(id: string, enabled: boolean): void;
+    list(): Goal[];
+    start(): void;
+    private tick;
+    private shouldRun;
+    private run;
+    stop(): void;
+}

package/dist/kernel/autonomy/goal-loop.js

@@ -0,0 +1,113 @@
+/**
+ * OpenKernel — Autonomy Goal Loop
+ *
+ * Native proactive capability: a node runs goals unattended on triggers —
+ * every N seconds, after an idle period, or once at start — executing each via
+ * the local kernel with this device's persistent role injected. This is what
+ * makes a Pi "wake up and do its job" without a human in the loop.
+ *
+ * Deliberately small: setInterval-based (no cron dependency), an overlap guard
+ * per goal, and idle detection off the kernel EventBus.
+ */
+import { nanoid } from 'nanoid';
+import { loadRole, rolePreamble } from '../federation/role-context.js';
+export class GoalLoop {
+    deps;
+    goals = new Map();
+    timer;
+    unsub;
+    lastActivity = Date.now();
+    tickMs;
+    constructor(deps) {
+        this.deps = deps;
+        this.tickMs = deps.tickMs ?? 1000;
+    }
+    add(input) {
+        const goal = {
+            id: `goal_${nanoid(8)}`,
+            prompt: input.prompt,
+            capabilities: input.capabilities ?? ['reasoning'],
+            trigger: input.trigger,
+            enabled: true,
+            runCount: 0,
+            running: false,
+        };
+        this.goals.set(goal.id, goal);
+        this.deps.logger.info(`[autonomy] goal added ${goal.id} (${goal.trigger.kind})`);
+        return goal;
+    }
+    remove(id) {
+        return this.goals.delete(id);
+    }
+    setEnabled(id, enabled) {
+        const g = this.goals.get(id);
+        if (g)
+            g.enabled = enabled;
+    }
+    list() {
+        return [...this.goals.values()];
+    }
+    start() {
+        if (this.timer)
+            return;
+        // Idle detection: any kernel event counts as activity.
+        this.unsub = this.deps.kernel.subscribeAll(() => { this.lastActivity = Date.now(); });
+        this.timer = setInterval(() => void this.tick(), this.tickMs);
+        this.deps.logger.info('[autonomy] goal loop started');
+    }
+    async tick() {
+        const now = Date.now();
+        for (const goal of this.goals.values()) {
+            if (!goal.enabled || goal.running)
+                continue;
+            if (this.shouldRun(goal, now))
+                void this.run(goal);
+        }
+    }
+    shouldRun(goal, now) {
+        switch (goal.trigger.kind) {
+            case 'once':
+                return goal.runCount === 0;
+            case 'interval':
+                return goal.lastRunAt === undefined || now - goal.lastRunAt >= goal.trigger.everyMs;
+            case 'idle': {
+                const idleFor = now - this.lastActivity;
+                // Fire when idle long enough, but not more than once per idle window.
+                const cooled = goal.lastRunAt === undefined || now - goal.lastRunAt >= goal.trigger.afterMs;
+                return idleFor >= goal.trigger.afterMs && cooled;
+            }
+        }
+    }
+    async run(goal) {
+        goal.running = true;
+        goal.lastRunAt = Date.now();
+        goal.runCount++;
+        const role = loadRole();
+        const preamble = rolePreamble(role);
+        const prompt = preamble ? `${preamble}\n\n${goal.prompt}` : goal.prompt;
+        this.deps.logger.info(`[autonomy] running goal ${goal.id} (#${goal.runCount})`);
+        try {
+            await this.deps.kernel.execute({
+                description: goal.prompt.slice(0, 80),
+                goal: goal.prompt,
+                tasks: [{
+                        description: goal.prompt.slice(0, 80),
+                        capabilities: goal.capabilities,
+                        input: { prompt, context: { proactive: true, role: role?.role } },
+                    }],
+            });
+        }
+        catch (err) {
+            this.deps.logger.warn(`[autonomy] goal ${goal.id} failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            goal.running = false;
+        }
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.unsub?.();
+    }
+}

package/dist/kernel/autonomy/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * OpenKernel — Autonomy public API
+ *
+ * Proactive, unattended execution: goals that fire on interval/idle/once
+ * triggers, each run with the device's persistent role context.
+ */
+export { GoalLoop } from './goal-loop.js';
+export type { Goal, GoalInput, GoalTrigger, GoalLoopDeps } from './goal-loop.js';

package/dist/kernel/autonomy/index.js

@@ -0,0 +1,7 @@
+/**
+ * OpenKernel — Autonomy public API
+ *
+ * Proactive, unattended execution: goals that fire on interval/idle/once
+ * triggers, each run with the device's persistent role context.
+ */
+export { GoalLoop } from './goal-loop.js';

package/dist/kernel/browser/browser-controller.d.ts

@@ -0,0 +1,57 @@
+/**
+ * OpenKernel — Browser Controller
+ *
+ * Default browser layer: Playwright.
+ *   Browser Worker → Browser Controller → DOM → Page → Events
+ *
+ * Playwright is an optional peer dependency. If unavailable, the controller
+ * falls back to a fetch-based read-only mode (no JS execution, no events).
+ * The worker handler detects which mode is active and adapts.
+ */
+import type { Artifact } from '../types.js';
+export interface BrowserAction {
+    type: 'navigate' | 'click' | 'type' | 'extract' | 'screenshot' | 'evaluate' | 'wait' | 'scroll';
+    selector?: string;
+    url?: string;
+    text?: string;
+    script?: string;
+    ms?: number;
+}
+export interface BrowserActionResult {
+    ok: boolean;
+    url?: string;
+    title?: string;
+    text?: string;
+    html?: string;
+    markdown?: string;
+    screenshotPath?: string;
+    error?: string;
+}
+export interface BrowserControllerOptions {
+    headless?: boolean;
+    /** Override browser choice; default chromium. */
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    /** Default navigation timeout ms. */
+    timeoutMs?: number;
+    /** Working directory for screenshots. */
+    screenshotDir?: string;
+}
+export declare class BrowserController {
+    private playwright;
+    private browser;
+    private page;
+    private mode;
+    private opts;
+    constructor(opts?: BrowserControllerOptions);
+    init(): Promise<void>;
+    getMode(): 'playwright' | 'fetch' | 'unavailable';
+    runAction(action: BrowserAction): Promise<BrowserActionResult>;
+    close(): Promise<void>;
+    private ensurePage;
+    private runPlaywright;
+    private runFetch;
+}
+export declare function htmlToMarkdown(html: string): string;
+export declare function stripHtml(html: string): string;
+export declare function extractTitle(html: string): string;
+export declare function actionArtifacts(results: BrowserActionResult[]): Artifact[];