infinicode 1.0.0 → 2.0.0

package/dist/kernel/federation/federation.js

@@ -0,0 +1,335 @@
+import { MeshServer, MeshClient } from './transport-http.js';
+import { PeerMesh } from './peer-mesh.js';
+import { EventBridge } from './event-bridge.js';
+import { ConfigSync } from './config-sync.js';
+import { AutoUpdate } from './auto-update.js';
+import { ComputeRouter } from './compute-router.js';
+import { TelemetryCollector, loadFromSnapshot, selfNodeStatus, nodeStatusFromPeer } from './telemetry.js';
+import { buildManifest } from './node-identity.js';
+import { envelope, reply, frame, newId } from './protocol.js';
+import { loadRole, saveRole, rolePreamble } from './role-context.js';
+import { discoverTailscalePeers } from './discovery.js';
+import { DEFAULT_MESH_PORT } from './types.js';
+export class Federation {
+    deps;
+    server;
+    client;
+    mesh;
+    bridge;
+    telemetry = new TelemetryCollector();
+    telemetryTimer;
+    lastHw;
+    unsub;
+    configSync;
+    autoUpdate;
+    compute = new ComputeRouter();
+    /** Local subscribers to the merged mesh frame stream (for MCP stream_activity). */
+    frameSubs = new Set();
+    /** Recent frames for catch-up. */
+    frameHistory = [];
+    /** Runs received + executing on THIS node (async handoff). */
+    runs = new Map();
+    /** Runs WE dispatched → which peer holds them (for follow_task). */
+    dispatchedRuns = new Map();
+    constructor(deps) {
+        this.deps = deps;
+        this.client = new MeshClient({ token: deps.options.token });
+        this.configSync = new ConfigSync({ logger: deps.logger, apply: deps.options.applyConfig });
+        this.autoUpdate = new AutoUpdate({
+            version: deps.options.version,
+            logger: deps.logger,
+            enabled: deps.options.autoUpdate,
+        });
+    }
+    get identity() {
+        return this.deps.identity;
+    }
+    async start() {
+        const { logger, options, identity } = this.deps;
+        const port = options.port ?? DEFAULT_MESH_PORT;
+        this.server = new MeshServer({
+            port,
+            host: options.host,
+            token: options.token,
+            logger,
+            getManifest: () => buildManifest(identity, this.deps.describe()),
+            onRpc: (env, remote) => this.onRpc(env, remote),
+        });
+        await this.server.start();
+        this.mesh = new PeerMesh({
+            self: identity,
+            client: this.client,
+            logger,
+            heartbeatMs: options.heartbeatMs,
+            getLoad: () => loadFromSnapshot(this.lastHw),
+            onFrame: (peerId, f) => this.ingestFrame(peerId, f),
+            onPeerChange: () => this.emitLocal('nd', frame('nd', identity.nodeId, this.nodeStatuses())),
+        });
+        this.mesh.start();
+        // Bridge local kernel events → mesh stream (coalesced, animation-friendly).
+        this.bridge = new EventBridge({
+            nodeId: identity.nodeId,
+            emit: f => this.server?.broadcast(f),
+        });
+        this.unsub = this.deps.kernel.subscribeAll(e => this.bridge?.handle(e));
+        // Telemetry heartbeat → stream a HardwareSnapshot on a fixed cadence.
+        const telMs = options.telemetryMs ?? 1000;
+        this.telemetryTimer = setInterval(() => {
+            this.lastHw = this.telemetry.collect();
+            this.server?.broadcast(frame('hw', identity.nodeId, this.lastHw));
+        }, telMs);
+        // Connect to seed peers.
+        for (const url of options.seeds ?? [])
+            void this.mesh.connect(url);
+        logger.info(`[federation] node ${identity.displayName} (${identity.role}) online on :${port}`);
+    }
+    // ── Inbound RPC ────────────────────────────────────────────────────────────
+    async onRpc(env, _remote) {
+        const self = this.deps.identity.nodeId;
+        switch (env.kind) {
+            case 'heartbeat':
+                return reply(env, 'ack', self, { load: loadFromSnapshot(this.lastHw) });
+            case 'hello':
+                return reply(env, 'welcome', self, buildManifest(this.deps.identity, this.deps.describe()));
+            case 'task.dispatch': {
+                // Non-blocking handoff: register the run, ack with a runId immediately,
+                // execute in the background, and let the caller follow it.
+                const task = env.data;
+                const runId = newId();
+                this.runs.set(runId, { runId, status: 'running', description: task.description, startedAt: Date.now() });
+                void this.runTaskAsync(runId, task);
+                return reply(env, 'task.accepted', self, { runId });
+            }
+            case 'task.status': {
+                const runId = env.data.runId;
+                const rec = this.runs.get(runId);
+                return reply(env, 'task.result', self, rec ?? { runId, status: 'failed', description: '', error: 'unknown run', startedAt: 0 });
+            }
+            case 'command': {
+                const input = env.data?.input ?? '';
+                const result = await this.deps.kernel.command(input);
+                return reply(env, 'command.result', self, result);
+            }
+            case 'config.request':
+                return reply(env, 'config.offer', self, this.configSync.offer());
+            case 'config.offer':
+                await this.configSync.receive(env.data);
+                return reply(env, 'ack', self);
+            case 'update.announce': {
+                const peer = this.mesh?.get(env.from);
+                await this.autoUpdate.onAnnounce(env.data, peer?.role ?? 'peer');
+                return reply(env, 'ack', self);
+            }
+            case 'role.get':
+                return reply(env, 'ack', self, this.getRole());
+            case 'role.set': {
+                const r = env.data;
+                const saved = saveRole(r);
+                return reply(env, 'ack', self, saved);
+            }
+            default:
+                return reply(env, 'ack', self);
+        }
+    }
+    // ── Role context ───────────────────────────────────────────────────────────
+    getRole() {
+        return loadRole();
+    }
+    setRole(role) {
+        return saveRole(role);
+    }
+    async getRoleOf(nodeId) {
+        const peer = this.mesh?.get(nodeId);
+        if (!peer)
+            throw new Error(`unknown peer: ${nodeId}`);
+        const res = await this.client.rpc(peer.url, envelope('role.get', this.deps.identity.nodeId, {}, { to: nodeId }));
+        return res.data ?? null;
+    }
+    async setRoleOf(nodeId, role) {
+        const peer = this.mesh?.get(nodeId);
+        if (!peer)
+            throw new Error(`unknown peer: ${nodeId}`);
+        const res = await this.client.rpc(peer.url, envelope('role.set', this.deps.identity.nodeId, role, { to: nodeId }));
+        return res.data;
+    }
+    /** Execute a dispatched task on THIS node via the local kernel. */
+    async runTask(task) {
+        // Inject this device's persistent role so the spawned agent is context-aware.
+        const localRole = loadRole();
+        const preamble = rolePreamble(localRole);
+        const prompt = preamble ? `${preamble}\n\n${task.prompt}` : task.prompt;
+        const mission = await this.deps.kernel.execute({
+            description: task.description,
+            goal: task.description,
+            tasks: [{
+                    description: task.description,
+                    capabilities: task.capabilities.length ? task.capabilities : ['reasoning'],
+                    input: { prompt, context: { role: task.role ?? localRole?.role, architecture: localRole?.architecture, ...task.context } },
+                }],
+        });
+        return {
+            missionId: mission.id,
+            status: mission.status,
+            outputs: mission.tasks.map(t => ({ status: t.status, content: t.output?.content, error: t.error })),
+        };
+    }
+    /** Run a dispatched task in the background, updating its RunRecord + streaming. */
+    async runTaskAsync(runId, task) {
+        const rec = this.runs.get(runId);
+        if (!rec)
+            return;
+        const nodeId = this.deps.identity.nodeId;
+        this.server?.broadcast(frame('ev', nodeId, { k: 'RUN_STARTED', run: runId, desc: task.description }));
+        try {
+            const result = await this.runTask(task);
+            rec.status = result.status === 'COMPLETED' ? 'completed' : 'failed';
+            rec.missionId = result.missionId;
+            rec.outputs = result.outputs;
+            rec.completedAt = Date.now();
+        }
+        catch (err) {
+            rec.status = 'failed';
+            rec.error = err instanceof Error ? err.message : String(err);
+            rec.completedAt = Date.now();
+        }
+        this.server?.broadcast(frame('ev', nodeId, { k: 'RUN_COMPLETED', run: runId, status: rec.status }));
+    }
+    // ── Outbound operations ──────────────────────────────────────────────────
+    /**
+     * Hand a task to the best-fit connected peer (compute-routed) or a named one.
+     * Non-blocking by default — returns a runId to follow. Pass wait to block
+     * until the run finishes (short tasks).
+     */
+    async dispatch(task, need, opts) {
+        if (!this.mesh)
+            return null;
+        const peers = this.mesh.connected();
+        const target = this.compute.best(peers, {
+            capabilities: task.capabilities,
+            preferNodeId: need?.preferNodeId,
+            preferName: need?.preferName,
+        });
+        if (!target) {
+            this.deps.logger.warn('[federation] no capable peer for dispatch');
+            return null;
+        }
+        const res = await this.client.rpc(target.url, envelope('task.dispatch', this.deps.identity.nodeId, task, { to: target.nodeId }));
+        const runId = res.data.runId;
+        this.dispatchedRuns.set(runId, target.nodeId);
+        let record = { runId, status: 'running', description: task.description, startedAt: Date.now() };
+        if (opts?.wait) {
+            record = await this.awaitRun(runId, opts.timeoutMs ?? 120_000);
+        }
+        return { peerId: target.nodeId, runId, record };
+    }
+    /** Query a dispatched run's current record (from whichever peer holds it). */
+    async followRun(runId) {
+        const local = this.runs.get(runId);
+        if (local)
+            return { record: local, frames: this.recentFrames(50) };
+        const peerId = this.dispatchedRuns.get(runId);
+        const peer = peerId ? this.mesh?.get(peerId) : undefined;
+        if (!peer)
+            return null;
+        const res = await this.client.rpc(peer.url, envelope('task.status', this.deps.identity.nodeId, { runId }, { to: peer.nodeId }));
+        return { record: res.data, frames: this.recentFrames(50) };
+    }
+    /** Poll a run until it finishes or the timeout elapses. */
+    async awaitRun(runId, timeoutMs = 120_000) {
+        const start = Date.now();
+        for (;;) {
+            const followed = await this.followRun(runId);
+            const rec = followed?.record;
+            if (rec && rec.status !== 'running')
+                return rec;
+            if (Date.now() - start > timeoutMs) {
+                return rec ?? { runId, status: 'failed', description: '', error: 'follow timeout', startedAt: start };
+            }
+            await new Promise(r => setTimeout(r, 500));
+        }
+    }
+    /** Run a slash-command on a specific peer. */
+    async runCommandOn(nodeId, input) {
+        const peer = this.mesh?.get(nodeId);
+        if (!peer)
+            throw new Error(`unknown peer: ${nodeId}`);
+        const res = await this.client.rpc(peer.url, envelope('command', this.deps.identity.nodeId, { input }, { to: nodeId }));
+        return res.data;
+    }
+    /** Hub: publish shared config (providers/API keys/policy) to the fleet. */
+    publishConfig(cfg) {
+        return this.configSync.publish(cfg);
+    }
+    /** Satellite: pull shared config from a peer (usually the hub). */
+    async pullConfig(nodeId) {
+        const peer = this.mesh?.get(nodeId);
+        if (!peer)
+            return false;
+        const res = await this.client.rpc(peer.url, envelope('config.request', this.deps.identity.nodeId, {}, { to: nodeId }));
+        if (res.kind === 'config.offer')
+            return this.configSync.receive(res.data);
+        return false;
+    }
+    async connect(url) {
+        return this.mesh?.connect(url) ?? null;
+    }
+    /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
+    async discoverAndConnect(tag) {
+        const port = this.deps.options.port ?? DEFAULT_MESH_PORT;
+        const urls = await discoverTailscalePeers({ port, tag, logger: this.deps.logger });
+        let connected = 0;
+        for (const url of urls) {
+            const peer = await this.mesh?.connect(url);
+            if (peer && peer.nodeId !== this.deps.identity.nodeId)
+                connected++;
+        }
+        return connected;
+    }
+    // ── Views ────────────────────────────────────────────────────────────────
+    /** Neutral node-status list (self + peers) — feeds the mesh map. */
+    nodeStatuses() {
+        const d = this.deps.describe();
+        const self = selfNodeStatus(this.deps.identity, this.lastHw ?? this.telemetry.collect(), {
+            version: d.version,
+            capabilities: d.capabilities,
+            commands: d.commands,
+        });
+        const peers = (this.mesh?.list() ?? []).map(nodeStatusFromPeer);
+        return [self, ...peers];
+    }
+    peers() {
+        return this.mesh?.list() ?? [];
+    }
+    /** Latest local hardware snapshot (for the MOLTFED connector / panels). */
+    latestHardware() {
+        return this.lastHw;
+    }
+    /** Subscribe to the merged mesh frame stream (local + peer frames). */
+    onFrames(sub) {
+        this.frameSubs.add(sub);
+        return () => this.frameSubs.delete(sub);
+    }
+    recentFrames(n = 100) {
+        return this.frameHistory.slice(-n);
+    }
+    ingestFrame(peerId, f) {
+        this.frameHistory.push({ peerId, f });
+        if (this.frameHistory.length > 500)
+            this.frameHistory.shift();
+        for (const s of this.frameSubs)
+            s(peerId, f);
+    }
+    emitLocal(_t, f) {
+        // local status changes are also streamed to connected harnesses
+        this.server?.broadcast(f);
+        this.ingestFrame(this.deps.identity.nodeId, f);
+    }
+    async stop() {
+        this.unsub?.();
+        this.bridge?.stop();
+        if (this.telemetryTimer)
+            clearInterval(this.telemetryTimer);
+        this.mesh?.stop();
+        await this.server?.stop();
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * OpenKernel — Federation public API
+ *
+ * Neutral, transport-agnostic device mesh: peer discovery + heartbeats, remote
+ * task dispatch, live activity/telemetry streaming, API/config sharing, auto
+ * update, and a MOLTFED adapter for zero-change InfiniBot interop.
+ */
+export * from './types.js';
+export { Federation } from './federation.js';
+export type { FederationOptions, FederationDeps, DispatchTask } from './federation.js';
+export { createFederationPlugin } from './federation-plugin.js';
+export type { FederationPlugin, FederationPluginOptions } from './federation-plugin.js';
+export { loadOrCreateIdentity, buildManifest, totalMemoryBytes } from './node-identity.js';
+export type { IdentityOptions, ManifestInputs } from './node-identity.js';
+export { TelemetryCollector, loadFromSnapshot, nodeStatusFromPeer, selfNodeStatus } from './telemetry.js';
+export { MeshServer, MeshClient } from './transport-http.js';
+export type { MeshServerOptions, MeshClientOptions, RpcHandler } from './transport-http.js';
+export { PeerMesh } from './peer-mesh.js';
+export type { PeerMeshOptions } from './peer-mesh.js';
+export { EventBridge } from './event-bridge.js';
+export { ConfigSync } from './config-sync.js';
+export { AutoUpdate, compareVersions } from './auto-update.js';
+export { ComputeRouter } from './compute-router.js';
+export type { ComputeCandidate, ComputeNeed } from './compute-router.js';
+export { loadRole, saveRole, rolePreamble } from './role-context.js';
+export { discoverTailscalePeers, tailscaleAvailable } from './discovery.js';
+export type { DiscoverOptions } from './discovery.js';
+export { envelope, reply, frame, frameToSSE, parseSSE, newId } from './protocol.js';
+export * as moltfed from './moltfed-adapter.js';
+export { MoltfedConnector } from './moltfed-connector.js';
+export type { MoltfedConnectorOptions, WsLike, WsFactory, DeviceAuth } from './moltfed-connector.js';

package/dist/kernel/federation/index.js

@@ -0,0 +1,23 @@
+/**
+ * OpenKernel — Federation public API
+ *
+ * Neutral, transport-agnostic device mesh: peer discovery + heartbeats, remote
+ * task dispatch, live activity/telemetry streaming, API/config sharing, auto
+ * update, and a MOLTFED adapter for zero-change InfiniBot interop.
+ */
+export * from './types.js';
+export { Federation } from './federation.js';
+export { createFederationPlugin } from './federation-plugin.js';
+export { loadOrCreateIdentity, buildManifest, totalMemoryBytes } from './node-identity.js';
+export { TelemetryCollector, loadFromSnapshot, nodeStatusFromPeer, selfNodeStatus } from './telemetry.js';
+export { MeshServer, MeshClient } from './transport-http.js';
+export { PeerMesh } from './peer-mesh.js';
+export { EventBridge } from './event-bridge.js';
+export { ConfigSync } from './config-sync.js';
+export { AutoUpdate, compareVersions } from './auto-update.js';
+export { ComputeRouter } from './compute-router.js';
+export { loadRole, saveRole, rolePreamble } from './role-context.js';
+export { discoverTailscalePeers, tailscaleAvailable } from './discovery.js';
+export { envelope, reply, frame, frameToSSE, parseSSE, newId } from './protocol.js';
+export * as moltfed from './moltfed-adapter.js';
+export { MoltfedConnector } from './moltfed-connector.js';

package/dist/kernel/federation/moltfed-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenKernel — MOLTFED Adapter (InfiniBot interop)
+ *
+ * Translates infinicode's NEUTRAL federation shapes into the message shapes
+ * InfiniBot already consumes, so an infinicode node lights up InfiniBot's
+ * neural-mesh map + hardware panels with ZERO InfiniBot changes:
+ *
+ *   NodeStatus[]      → nodes.status  { ts, nodes:[…] }
+ *   HardwareSnapshot  → hardware.snapshot  (same shape — passthrough)
+ *   StreamFrame (ev)  → agent broadcast event (activity panel / map animation)
+ *
+ * This module only builds payloads. The actual WebSocket connector that logs
+ * into an InfiniBot gateway and ships these is added in the integration step;
+ * keeping the mapping here means that connector is a thin transport shim.
+ */
+import type { HardwareSnapshot, NodeStatus, StreamFrame } from './types.js';
+/** InfiniBot `nodes.status` / `node.list` response shape. */
+export declare function toNodesStatus(statuses: NodeStatus[]): {
+    ts: number;
+    nodes: Array<Record<string, unknown>>;
+};
+/** InfiniBot `hardware.snapshot` payload (shape already matches). */
+export declare function toHardwareSnapshot(nodeId: string, hw: HardwareSnapshot): Record<string, unknown>;
+/** Map a compact activity/routing frame to an InfiniBot-style `agent` event. */
+export declare function toAgentEvent(f: StreamFrame): Record<string, unknown> | null;
+/** Build the full set of InfiniBot-bound messages for a periodic push. */
+export declare function buildMoltfedBatch(statuses: NodeStatus[], selfId: string, hw?: HardwareSnapshot): Array<{
+    method: string;
+    params: unknown;
+}>;

package/dist/kernel/federation/moltfed-adapter.js

@@ -0,0 +1,52 @@
+/** InfiniBot `nodes.status` / `node.list` response shape. */
+export function toNodesStatus(statuses) {
+    return {
+        ts: Date.now(),
+        nodes: statuses.map(s => ({
+            nodeId: s.nodeId,
+            displayName: s.displayName,
+            platform: s.platform,
+            deviceFamily: s.deviceFamily,
+            modelIdentifier: s.modelIdentifier,
+            version: s.version,
+            caps: s.capabilities,
+            commands: s.commands,
+            connected: s.connected,
+            connectedAtMs: s.connectedAtMs,
+            paired: true,
+            // extra infinicode fields are ignored by InfiniBot but useful to richer UIs
+            role: s.role,
+            load: s.load,
+        })),
+    };
+}
+/** InfiniBot `hardware.snapshot` payload (shape already matches). */
+export function toHardwareSnapshot(nodeId, hw) {
+    return { nodeId, snapshot: hw };
+}
+/** Map a compact activity/routing frame to an InfiniBot-style `agent` event. */
+export function toAgentEvent(f) {
+    if (f.t !== 'ev' && f.t !== 'rt')
+        return null;
+    const d = (f.d ?? {});
+    return {
+        source: 'infinicode',
+        nodeId: f.n,
+        seq: f.s,
+        ts: f.ts,
+        kind: d.k,
+        missionId: d.m,
+        taskId: d.task,
+        workerId: d.w,
+        data: d.d,
+    };
+}
+/** Build the full set of InfiniBot-bound messages for a periodic push. */
+export function buildMoltfedBatch(statuses, selfId, hw) {
+    const out = [
+        { method: 'nodes.status', params: toNodesStatus(statuses) },
+    ];
+    if (hw)
+        out.push({ method: 'hardware.snapshot', params: toHardwareSnapshot(selfId, hw) });
+    return out;
+}

package/dist/kernel/federation/moltfed-connector.d.ts

@@ -0,0 +1,98 @@
+/**
+ * OpenKernel — MOLTFED / InfiniBot Gateway Connector
+ *
+ * Logs an infinicode node into an InfiniBot gateway over WebSocket and streams
+ * it onto InfiniBot's neural-mesh map + hardware panels — WITHOUT editing
+ * InfiniBot. It speaks InfiniBot's gateway protocol (observed in InfiniBot
+ * src/mcp/server.ts):
+ *
+ *   1. open ws://<host>:18789
+ *   2. optionally receive event `connect.challenge` → nonce
+ *   3. send { type:'req', id, method:'connect', params:{ minProtocol, client,
+ *      auth, role, scopes, device } }
+ *   4. receive `hello-ok` → connected
+ *   5. push request frames: { type:'req', id, method, params }
+ *
+ * Auth is PLUGGABLE (token/password by default; a device-signer can be supplied
+ * for gateways that require signed device identity). Push method names are
+ * CONFIGURABLE so this adapts to a gateway's exact method registry without code
+ * changes. The WebSocket impl is injectable for testing.
+ *
+ * NOTE: verify end-to-end against a live InfiniBot gateway; the frame shapes
+ * here mirror the observed protocol but a given gateway version may differ.
+ */
+import type { Logger } from '../types.js';
+import type { NodeStatus, HardwareSnapshot, StreamFrame } from './types.js';
+/** Minimal browser-style WebSocket surface (Node global WebSocket / ws both fit). */
+export interface WsLike {
+    send(data: string): void;
+    close(): void;
+    onopen: ((ev?: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((ev?: unknown) => void) | null;
+    onerror: ((ev?: unknown) => void) | null;
+}
+export type WsFactory = (url: string) => WsLike;
+export interface DeviceAuth {
+    id: string;
+    publicKey: string;
+    /** Sign the connect payload (nonce-bound). Return a signature string. */
+    sign: (payload: unknown, nonce: string | null, signedAt: number) => string;
+}
+export interface MoltfedConnectorOptions {
+    gatewayUrl: string;
+    token?: string;
+    password?: string;
+    client?: {
+        id: string;
+        version: string;
+        platform: string;
+        mode: string;
+    };
+    role?: string;
+    scopes?: string[];
+    device?: DeviceAuth;
+    minProtocol?: number;
+    maxProtocol?: number;
+    pushIntervalMs?: number;
+    logger: Logger;
+    /** Data sources — usually bound to a Federation instance. */
+    getNodeStatuses: () => NodeStatus[];
+    getHardware: () => HardwareSnapshot | undefined;
+    subscribeFrames: (cb: (peerId: string, f: StreamFrame) => void) => () => void;
+    /** Gateway method names (defaults chosen to match observed InfiniBot usage). */
+    methodNodes?: string;
+    methodHardware?: string;
+    methodAgent?: string;
+    /** Injectable WS constructor for tests; defaults to global WebSocket. */
+    wsFactory?: WsFactory;
+}
+export declare class MoltfedConnector {
+    private opts;
+    private ws;
+    private connected;
+    private nonce;
+    private connectId;
+    private connectSent;
+    private pushTimer?;
+    private connectTimer?;
+    private unsubFrames?;
+    private stopped;
+    private reconnectAttempts;
+    constructor(opts: MoltfedConnectorOptions);
+    get isConnected(): boolean;
+    start(): void;
+    private open;
+    private onMessage;
+    private buildConnectFrame;
+    private sendConnect;
+    private onConnected;
+    private pushSnapshot;
+    /** Send a request frame (fire-and-forget; gateway acks via res). */
+    request(method: string, params: unknown): void;
+    private scheduleReconnect;
+    private stopPush;
+    stop(): void;
+}