infinicode 1.0.0 → 2.1.0

package/dist/kernel/kernel.js

@@ -0,0 +1,223 @@
+/**
+ * OpenKernel — Public Kernel API
+ *
+ * kernel.execute() / pause() / resume() / cancel() / status()
+ * kernel.subscribe() / registerWorker() / registerProvider()
+ * kernel.registerPlugin() / registerPolicy()
+ *
+ * This is the single entry point. Harnesses, CLIs, n8n, bots all go through here.
+ */
+import { EventBus } from './event-bus.js';
+import { ProviderManager } from './provider-manager.js';
+import { CapabilityRouter } from './router.js';
+import { WorkerRuntime } from './worker-runtime.js';
+import { Scheduler } from './scheduler.js';
+import { CheckpointEngine } from './checkpoint-engine.js';
+import { MissionEngine } from './mission-engine.js';
+import { Orchestrator } from './orchestrator.js';
+import { PluginManager } from './plugin-manager.js';
+import { PolicyEngine } from './policies.js';
+import { VerificationEngine } from './verification-engine.js';
+import { RecoveryManager } from './recovery-manager.js';
+import { ConsoleLogger } from './logger.js';
+import { ALL_BUILTIN_WORKERS } from './workers/builtin-workers.js';
+import { KernelCommandRegistry } from './command-system.js';
+export class Kernel {
+    eventBus;
+    providerManager;
+    router;
+    workerRuntime;
+    scheduler;
+    checkpoints;
+    missionEngine;
+    orchestrator;
+    plugins;
+    policies;
+    verification;
+    recovery;
+    logger;
+    /** Canonical OpenKernel slash-command surface (/status, /workers, /goal …). */
+    commands;
+    missions = new Map();
+    constructor(options = {}) {
+        this.logger = options.logger ?? new ConsoleLogger();
+        this.eventBus = new EventBus();
+        this.providerManager = new ProviderManager(this.eventBus, this.logger);
+        this.router = new CapabilityRouter(this.logger);
+        this.scheduler = new Scheduler(this.eventBus, this.logger);
+        this.checkpoints = new CheckpointEngine(this.eventBus, this.logger, options.storageDir);
+        this.policies = new PolicyEngine();
+        this.verification = new VerificationEngine({
+            eventBus: this.eventBus,
+            providerManager: this.providerManager,
+            logger: this.logger,
+        });
+        const workerCtx = {
+            eventBus: this.eventBus,
+            router: this.router,
+            providerManager: this.providerManager,
+            policies: this.policies,
+            logger: this.logger,
+        };
+        this.workerRuntime = new WorkerRuntime(workerCtx);
+        this.recovery = new RecoveryManager({
+            eventBus: this.eventBus,
+            providerManager: this.providerManager,
+            workerRuntime: this.workerRuntime,
+            router: this.router,
+            logger: this.logger,
+        });
+        this.missionEngine = new MissionEngine({
+            eventBus: this.eventBus,
+            scheduler: this.scheduler,
+            checkpoints: this.checkpoints,
+            policies: this.policies,
+            verification: this.verification,
+            logger: this.logger,
+        });
+        this.orchestrator = new Orchestrator({
+            eventBus: this.eventBus,
+            missionEngine: this.missionEngine,
+            scheduler: this.scheduler,
+            workerRuntime: this.workerRuntime,
+            checkpoints: this.checkpoints,
+            providerManager: this.providerManager,
+            router: this.router,
+            verification: this.verification,
+            recovery: this.recovery,
+            logger: this.logger,
+        });
+        this.plugins = new PluginManager(this.eventBus, this.logger);
+        this.commands = new KernelCommandRegistry(this);
+        if (options.loadBuiltinWorkers ?? true) {
+            for (const handler of ALL_BUILTIN_WORKERS) {
+                this.workerRuntime.registerHandler(handler);
+            }
+        }
+    }
+    async execute(input) {
+        const mission = this.missionEngine.create(input);
+        this.missions.set(mission.id, mission);
+        try {
+            await this.orchestrator.run(mission, input);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.missionEngine.fail(mission, message);
+            throw err;
+        }
+        return mission;
+    }
+    async pause(missionId) {
+        const mission = this.missions.get(missionId);
+        if (!mission)
+            throw new Error(`Mission not found: ${missionId}`);
+        this.orchestrator.pauseMission(missionId);
+        this.missionEngine.pause(mission);
+    }
+    async resume(missionId) {
+        const mission = this.missions.get(missionId);
+        if (!mission)
+            throw new Error(`Mission not found: ${missionId}`);
+        this.orchestrator.resumeMission(missionId);
+        this.missionEngine.resume(mission);
+        // continue execution
+        await this.orchestrator.run(mission, {
+            description: mission.description,
+            goal: mission.goal,
+        });
+        return mission;
+    }
+    async cancel(missionId) {
+        const mission = this.missions.get(missionId);
+        if (!mission)
+            return;
+        this.orchestrator.cancelMission(missionId);
+        this.missionEngine.cancel(mission);
+    }
+    async status(missionId) {
+        const mission = this.missions.get(missionId);
+        if (!mission)
+            throw new Error(`Mission not found: ${missionId}`);
+        return mission.status;
+    }
+    /**
+     * Execute a canonical OpenKernel slash-command (e.g. "/status", "/goal build X").
+     * The same registry backs the CLI console and the notification plugins.
+     */
+    async command(input) {
+        return this.commands.execute(input);
+    }
+    /** Reset a mission's failed/skipped tasks and re-run them. */
+    async retry(missionId) {
+        const mission = this.missions.get(missionId);
+        if (!mission)
+            throw new Error(`Mission not found: ${missionId}`);
+        for (const task of mission.tasks) {
+            if (task.status === 'FAILED' || task.status === 'SKIPPED') {
+                task.status = 'PENDING';
+                task.attempts = 0;
+                task.error = undefined;
+                task.output = undefined;
+                task.startedAt = undefined;
+                task.completedAt = undefined;
+            }
+        }
+        this.orchestrator.resumeMission(missionId);
+        await this.orchestrator.run(mission, {
+            description: mission.description,
+            goal: mission.goal,
+        });
+        return mission;
+    }
+    subscribe(types, handler) {
+        return this.eventBus.on(types, handler);
+    }
+    subscribeAll(handler) {
+        return this.eventBus.onAll(handler);
+    }
+    registerWorker(definition) {
+        this.workerRuntime.registerWorker(definition);
+    }
+    registerProvider(providerId, provider) {
+        this.providerManager.register(providerId, provider);
+    }
+    async registerPlugin(plugin) {
+        await this.plugins.registerWithContext(plugin, this);
+    }
+    registerPolicy(policy) {
+        this.policies.register(policy);
+    }
+    /** Set the default policy used for routing when a mission doesn't specify one. */
+    setDefaultPolicy(name) {
+        this.workerRuntime.setDefaultPolicy(name);
+    }
+    getMission(missionId) {
+        return this.missions.get(missionId);
+    }
+    listMissions() {
+        return [...this.missions.values()];
+    }
+    /** Emit a NOTIFICATION event that plugins (Telegram/Discord/Slack) can consume. */
+    notify(message, missionId) {
+        this.eventBus.emit({
+            type: 'NOTIFICATION',
+            timestamp: Date.now(),
+            missionId,
+            data: { message },
+        });
+    }
+    listPlugins() {
+        return this.plugins.listPlugins();
+    }
+    getEventHistory() {
+        return this.eventBus.getHistory();
+    }
+    destroy() {
+        this.providerManager.destroy();
+        this.plugins.destroy();
+    }
+}
+export function createKernel(options) {
+    return new Kernel(options ?? {});
+}

package/dist/kernel/logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenKernel — Logger
+ */
+import type { Logger } from './types.js';
+export declare class ConsoleLogger implements Logger {
+    private prefix;
+    constructor(prefix?: string);
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+export declare class SilentLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/kernel/logger.js

@@ -0,0 +1,26 @@
+export class ConsoleLogger {
+    prefix;
+    constructor(prefix = 'openkernel') {
+        this.prefix = prefix;
+    }
+    debug(message, ...args) {
+        if (process.env.OPENKERNEL_DEBUG === '1') {
+            console.debug(`[${this.prefix}] ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        console.log(`[${this.prefix}] ${message}`, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(`[${this.prefix}] ${message}`, ...args);
+    }
+    error(message, ...args) {
+        console.error(`[${this.prefix}] ${message}`, ...args);
+    }
+}
+export class SilentLogger {
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * OpenKernel — MCP public API
+ *
+ * North-facing control surface: an MCP server exposing spawn/dispatch/command/
+ * role/voice/map tools over the federation mesh, so any MCP host drives the
+ * fleet with a standard protocol.
+ */
+export { createMcpServer, serveMcpStdio } from './mcp-server.js';
+export type { McpServerDeps } from './mcp-server.js';

package/dist/kernel/mcp/index.js

@@ -0,0 +1,8 @@
+/**
+ * OpenKernel — MCP public API
+ *
+ * North-facing control surface: an MCP server exposing spawn/dispatch/command/
+ * role/voice/map tools over the federation mesh, so any MCP host drives the
+ * fleet with a standard protocol.
+ */
+export { createMcpServer, serveMcpStdio } from './mcp-server.js';

package/dist/kernel/mcp/mcp-server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenKernel — MCP Server
+ *
+ * The north-facing control surface. Any MCP host (InfiniBot, Claude Code,
+ * Cursor…) connects over stdio and drives infinicode's mesh with standard MCP
+ * tools: spawn agents on devices, dispatch by capability, run commands, manage
+ * per-device role context, speak via voice, and get the live mesh map.
+ *
+ * Real-time activity/telemetry for harness animation is served over the
+ * federation SSE endpoint (returned by `stream_info`), keeping tool calls small
+ * and the animation feed lightweight — the same split InfiniBot uses.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { KernelLike, Logger } from '../types.js';
+import type { Federation } from '../federation/index.js';
+import type { GoalLoop } from '../autonomy/index.js';
+export interface McpServerDeps {
+    kernel: KernelLike;
+    federation: Federation;
+    logger: Logger;
+    version: string;
+    /** Optional autonomy loop — enables the goal management tools when present. */
+    autonomy?: GoalLoop;
+}
+export declare function createMcpServer(deps: McpServerDeps): McpServer;
+/** Start the MCP server over stdio (the transport MCP hosts spawn). */
+export declare function serveMcpStdio(deps: McpServerDeps): Promise<McpServer>;

package/dist/kernel/mcp/mcp-server.js

@@ -0,0 +1,178 @@
+/**
+ * OpenKernel — MCP Server
+ *
+ * The north-facing control surface. Any MCP host (InfiniBot, Claude Code,
+ * Cursor…) connects over stdio and drives infinicode's mesh with standard MCP
+ * tools: spawn agents on devices, dispatch by capability, run commands, manage
+ * per-device role context, speak via voice, and get the live mesh map.
+ *
+ * Real-time activity/telemetry for harness animation is served over the
+ * federation SSE endpoint (returned by `stream_info`), keeping tool calls small
+ * and the animation feed lightweight — the same split InfiniBot uses.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+const text = (v) => ({
+    content: [{ type: 'text', text: typeof v === 'string' ? v : JSON.stringify(v, null, 2) }],
+});
+export function createMcpServer(deps) {
+    const { kernel, federation } = deps;
+    const server = new McpServer({ name: 'infinicode', version: deps.version });
+    // ── Mesh map + telemetry ───────────────────────────────────────────────────
+    server.registerTool('list_nodes', {
+        title: 'List mesh nodes',
+        description: 'All devices in the mesh with role, capabilities, connection state, and load.',
+        inputSchema: {},
+    }, async () => text(federation.nodeStatuses()));
+    server.registerTool('node_status', {
+        title: 'Node status',
+        description: 'One node\'s capabilities, commands, and latest hardware snapshot.',
+        inputSchema: { nodeId: z.string().describe('target node id') },
+    }, async ({ nodeId }) => {
+        const status = federation.nodeStatuses().find(s => s.nodeId === nodeId);
+        const peer = federation.peers().find(p => p.nodeId === nodeId);
+        return text({ status, hardware: peer?.hardware });
+    });
+    // ── Spawn + dispatch (parallel agents across devices, no SSH) ───────────────
+    server.registerTool('spawn_agent', {
+        title: 'Spawn agent on a device',
+        description: 'Hand a task to a device\'s local agent (by name or id). Non-blocking: returns a runId immediately — use follow_task to monitor. Pass wait:true to block until done (short tasks). Runs on the target with its persistent role.',
+        inputSchema: {
+            task: z.string().describe('what the agent should do'),
+            device: z.string().optional().describe('target device name or node id'),
+            capabilities: z.array(z.string()).optional().describe('required capabilities, e.g. ["coding"]'),
+            role: z.string().optional().describe('override the role context for this task'),
+            wait: z.boolean().optional().describe('block until the run finishes (default false)'),
+        },
+    }, async ({ task, device, capabilities, role, wait }) => {
+        const t = {
+            description: task.slice(0, 80),
+            prompt: task,
+            capabilities: (capabilities ?? []),
+            role,
+        };
+        const res = await federation.dispatch(t, { preferName: device, preferNodeId: device }, { wait });
+        if (!res)
+            return text({ ok: false, error: 'no capable device online for this task' });
+        return text({ ok: true, peerId: res.peerId, runId: res.runId, status: res.record.status, record: res.record });
+    });
+    server.registerTool('dispatch', {
+        title: 'Dispatch to best device',
+        description: 'Route a task to the best-fit device by capability + load (no device named). Non-blocking; returns a runId. Pass wait:true to block.',
+        inputSchema: {
+            task: z.string(),
+            capabilities: z.array(z.string()).optional(),
+            wait: z.boolean().optional(),
+        },
+    }, async ({ task, capabilities, wait }) => {
+        const res = await federation.dispatch({ description: task.slice(0, 80), prompt: task, capabilities: (capabilities ?? []) }, undefined, { wait });
+        return text(res ? { ok: true, peerId: res.peerId, runId: res.runId, status: res.record.status, record: res.record } : { ok: false, error: 'no capable device' });
+    });
+    server.registerTool('follow_task', {
+        title: 'Follow a run',
+        description: 'Get the current status + result of a dispatched run (by runId), plus recent activity frames for rendering.',
+        inputSchema: { runId: z.string() },
+    }, async ({ runId }) => {
+        const followed = await federation.followRun(runId);
+        if (!followed)
+            return text({ ok: false, error: 'unknown run' });
+        return text({ ok: true, record: followed.record, frames: followed.frames.length });
+    });
+    // ── Commands + lifecycle (local or targeted) ────────────────────────────────
+    server.registerTool('run_command', {
+        title: 'Run a slash command',
+        description: 'Run an OpenKernel slash command locally, or on a specific node.',
+        inputSchema: {
+            input: z.string().describe('e.g. "/status" or "/goal build X"'),
+            nodeId: z.string().optional().describe('target node; omit for local'),
+        },
+    }, async ({ input, nodeId }) => {
+        if (nodeId)
+            return text(await federation.runCommandOn(nodeId, input));
+        return text(await kernel.command(input));
+    });
+    // ── Role context (persistent per-device identity + architecture) ────────────
+    server.registerTool('get_role', {
+        title: 'Get device role',
+        description: 'Read a device\'s persistent role + server-architecture context.',
+        inputSchema: { nodeId: z.string().optional().describe('target node; omit for local') },
+    }, async ({ nodeId }) => text(nodeId ? await federation.getRoleOf(nodeId) : federation.getRole()));
+    server.registerTool('set_role', {
+        title: 'Set device role',
+        description: 'Persist a device\'s role + architecture so spawned agents are proactive and context-aware.',
+        inputSchema: {
+            role: z.string().describe('e.g. "RoboPanda"'),
+            architecture: z.string().optional().describe('this device\'s job + the wider system'),
+            nodeId: z.string().optional().describe('target node; omit for local'),
+        },
+    }, async ({ role, architecture, nodeId }) => {
+        const payload = { role, architecture };
+        return text(nodeId ? await federation.setRoleOf(nodeId, payload) : federation.setRole(payload));
+    });
+    // ── Voice (LiveKit intent — media plane handles TTS) ────────────────────────
+    server.registerTool('speak', {
+        title: 'Speak (voice mode)',
+        description: 'Emit a voice-mode response intent for the media plane (LiveKit/TTS) to speak in a room.',
+        inputSchema: {
+            text: z.string(),
+            room: z.string().optional().describe('LiveKit room / device to speak on'),
+        },
+    }, async ({ text: say, room }) => {
+        kernel.notify(`[voice${room ? ':' + room : ''}] ${say}`);
+        return text({ ok: true, spoken: say, room });
+    });
+    // ── Autonomy (proactive goals) — only if a goal loop is wired ───────────────
+    if (deps.autonomy) {
+        const auto = deps.autonomy;
+        server.registerTool('add_goal', {
+            title: 'Add a proactive goal',
+            description: 'Give this node a standing goal that runs unattended — every N seconds, after an idle period, or once. Runs with the device\'s role context.',
+            inputSchema: {
+                prompt: z.string().describe('the goal, e.g. "check camera feed for people and greet them"'),
+                everyMs: z.number().optional().describe('interval trigger: run every N ms'),
+                idleMs: z.number().optional().describe('idle trigger: run after N ms of no activity'),
+                once: z.boolean().optional().describe('run exactly once at start'),
+                capabilities: z.array(z.string()).optional(),
+            },
+        }, async ({ prompt, everyMs, idleMs, once, capabilities }) => {
+            const trigger = everyMs
+                ? { kind: 'interval', everyMs }
+                : idleMs
+                    ? { kind: 'idle', afterMs: idleMs }
+                    : { kind: 'once' };
+            void once; // 'once' is the default when no interval/idle given
+            const goal = auto.add({ prompt, capabilities: (capabilities ?? []), trigger });
+            return text({ ok: true, goalId: goal.id, trigger: goal.trigger });
+        });
+        server.registerTool('list_goals', {
+            title: 'List proactive goals',
+            description: 'All standing goals on this node with their triggers + run counts.',
+            inputSchema: {},
+        }, async () => text(auto.list().map(g => ({ id: g.id, prompt: g.prompt, trigger: g.trigger, runCount: g.runCount, enabled: g.enabled }))));
+        server.registerTool('remove_goal', {
+            title: 'Remove a proactive goal',
+            description: 'Stop and remove a standing goal by id.',
+            inputSchema: { goalId: z.string() },
+        }, async ({ goalId }) => text({ ok: auto.remove(goalId) }));
+    }
+    // ── Live activity stream (for harness animation / event rendering) ──────────
+    server.registerTool('stream_info', {
+        title: 'Activity stream info',
+        description: 'Where to connect for the live activity + telemetry feed (SSE), plus a snapshot of recent frames for immediate rendering.',
+        inputSchema: {},
+    }, async () => text({
+        sse: '/fed/stream',
+        note: 'Connect to any mesh node\'s /fed/stream for real-time frames (t=ev|hw|hb|nd|rt|log).',
+        recent: federation.recentFrames(40),
+    }));
+    return server;
+}
+/** Start the MCP server over stdio (the transport MCP hosts spawn). */
+export async function serveMcpStdio(deps) {
+    const server = createMcpServer(deps);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    deps.logger.info('[mcp] stdio server connected');
+    return server;
+}

package/dist/kernel/mission-engine.d.ts

@@ -0,0 +1,42 @@
+import type { Logger, Mission, MissionInput } from './types.js';
+import type { EventBus } from './event-bus.js';
+import type { Scheduler } from './scheduler.js';
+import type { CheckpointEngine } from './checkpoint-engine.js';
+import type { PolicyEngine } from './policies.js';
+import type { VerificationEngine } from './verification-engine.js';
+export interface MissionEngineDeps {
+    eventBus: EventBus;
+    scheduler: Scheduler;
+    checkpoints: CheckpointEngine;
+    policies: PolicyEngine;
+    verification?: VerificationEngine;
+    logger: Logger;
+}
+export declare class MissionEngine {
+    private deps;
+    constructor(deps: MissionEngineDeps);
+    create(input: MissionInput): Mission;
+    plan(mission: Mission, input: MissionInput): Mission;
+    start(mission: Mission): Mission;
+    pause(mission: Mission): Mission;
+    resume(mission: Mission): Mission;
+    cancel(mission: Mission): Mission;
+    complete(mission: Mission): Mission;
+    /**
+     * Mission-level verification during the VERIFYING phase.
+     * Runs the Verification Engine pipeline for every completed task that
+     * has output, then completes the mission only if all checks pass (or
+     * verification is not strict). Returns the aggregated result.
+     */
+    verify(mission: Mission): Promise<{
+        passed: boolean;
+        summary: string;
+    }>;
+    fail(mission: Mission, error: string): Mission;
+    /**
+     * Resync mission state from a checkpoint (crash recovery).
+     */
+    restoreFromCheckpoint(mission: Mission): Mission;
+    private transition;
+    private emit;
+}