infinicode 1.0.0 → 2.1.0

package/dist/kernel/federation/role-context.d.ts

@@ -0,0 +1,5 @@
+import type { RoleContext } from './types.js';
+export declare function loadRole(storageDir?: string): RoleContext | null;
+export declare function saveRole(role: Omit<RoleContext, 'updatedAt'>, storageDir?: string): RoleContext;
+/** Render a role context as a system-preamble line for task prompts. */
+export declare function rolePreamble(ctx: RoleContext | null): string | undefined;

package/dist/kernel/federation/role-context.js

@@ -0,0 +1,45 @@
+/**
+ * OpenKernel — Role Context
+ *
+ * A device's persistent identity + server-architecture brief. Loaded on every
+ * task run so a spawned agent is proactive and context-aware without being
+ * re-briefed ("you are RoboPanda; camera+mic on GPIO; part of the RoboPark
+ * mesh; report scene events to the hub"). Stored as JSON under the kernel dir.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+function roleFile(storageDir) {
+    return join(storageDir, 'role.json');
+}
+export function loadRole(storageDir = join(process.cwd(), '.openkernel')) {
+    const file = roleFile(storageDir);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveRole(role, storageDir = join(process.cwd(), '.openkernel')) {
+    const ctx = { ...role, updatedAt: Date.now() };
+    try {
+        if (!existsSync(storageDir))
+            mkdirSync(storageDir, { recursive: true });
+        writeFileSync(roleFile(storageDir), JSON.stringify(ctx, null, 2));
+    }
+    catch {
+        // non-fatal
+    }
+    return ctx;
+}
+/** Render a role context as a system-preamble line for task prompts. */
+export function rolePreamble(ctx) {
+    if (!ctx)
+        return undefined;
+    const parts = [`You are ${ctx.role}.`];
+    if (ctx.architecture)
+        parts.push(ctx.architecture);
+    return parts.join(' ');
+}

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

@@ -0,0 +1,21 @@
+import type { HardwareSnapshot, NodeIdentity, NodeStatus, PeerInfo } from './types.js';
+export declare class TelemetryCollector {
+    private lastCpu;
+    private lastNet;
+    private cpuTimes;
+    private cpuPercent;
+    /** Per-core % from a single snapshot (approximate, no per-core delta kept). */
+    private perCore;
+    private network;
+    collect(): HardwareSnapshot;
+}
+/** A 0–100 load figure derived from a snapshot (used by the compute router). */
+export declare function loadFromSnapshot(hw: HardwareSnapshot | undefined): number;
+/** Build the neutral NodeStatus entry the mesh map renders. */
+export declare function nodeStatusFromPeer(peer: PeerInfo): NodeStatus;
+/** Local node's own status entry. */
+export declare function selfNodeStatus(identity: NodeIdentity, hw: HardwareSnapshot, manifest: {
+    version: string;
+    capabilities: NodeStatus['capabilities'];
+    commands: string[];
+}): NodeStatus;

package/dist/kernel/federation/telemetry.js

@@ -0,0 +1,138 @@
+/**
+ * OpenKernel — Telemetry Collector
+ *
+ * Produces a HardwareSnapshot on the same shape InfiniBot uses, so the MOLTFED
+ * adapter can forward it verbatim to `hardware.snapshot` and light up InfiniBot's
+ * hardware panels + neural-mesh viz. Pure `node:os` — no native deps, safe on a Pi.
+ *
+ * CPU % is a delta between ticks; network is a byte-rate delta. Call collect()
+ * on a fixed cadence (~1 Hz) so deltas are meaningful.
+ */
+import os from 'node:os';
+export class TelemetryCollector {
+    lastCpu = null;
+    lastNet = new Map();
+    cpuTimes() {
+        let idle = 0;
+        let total = 0;
+        for (const c of os.cpus()) {
+            idle += c.times.idle;
+            total += c.times.user + c.times.nice + c.times.sys + c.times.idle + c.times.irq;
+        }
+        return { idle, total };
+    }
+    cpuPercent() {
+        const cur = this.cpuTimes();
+        if (!this.lastCpu) {
+            this.lastCpu = cur;
+            const load = os.loadavg()[0];
+            return Math.min(100, Math.round((load / os.cpus().length) * 100));
+        }
+        const idleDiff = cur.idle - this.lastCpu.idle;
+        const totalDiff = cur.total - this.lastCpu.total;
+        this.lastCpu = cur;
+        if (totalDiff <= 0)
+            return 0;
+        return Math.max(0, Math.min(100, Math.round((1 - idleDiff / totalDiff) * 100)));
+    }
+    /** Per-core % from a single snapshot (approximate, no per-core delta kept). */
+    perCore() {
+        return os.cpus().map(c => {
+            const t = c.times;
+            const total = t.user + t.nice + t.sys + t.idle + t.irq;
+            return total > 0 ? Math.round((1 - t.idle / total) * 100) : 0;
+        });
+    }
+    network() {
+        // node:os doesn't expose byte counters; report interface presence with
+        // zeroed rates by default. A platform collector can override later.
+        const ifaces = os.networkInterfaces();
+        const out = [];
+        for (const [name, addrs] of Object.entries(ifaces)) {
+            if (!addrs || addrs.every(a => a.internal))
+                continue;
+            const prev = this.lastNet.get(name);
+            const now = Date.now();
+            // Without kernel counters we can't compute a true rate; keep 0 but retain
+            // the hook so a native collector can populate rx/tx deltas.
+            out.push({ name, rxBytesPerSec: 0, txBytesPerSec: 0 });
+            this.lastNet.set(name, { rx: prev?.rx ?? 0, tx: prev?.tx ?? 0, at: now });
+        }
+        return { interfaces: out };
+    }
+    collect() {
+        const total = os.totalmem();
+        const free = os.freemem();
+        const used = total - free;
+        const la = os.loadavg();
+        return {
+            cpu: {
+                percent: this.cpuPercent(),
+                perCorePercent: this.perCore(),
+                loadAvg: [la[0], la[1], la[2]],
+                cores: os.cpus().length,
+                model: os.cpus()[0]?.model ?? 'unknown',
+            },
+            memory: {
+                totalBytes: total,
+                usedBytes: used,
+                freeBytes: free,
+                percent: total > 0 ? Math.round((used / total) * 100) : 0,
+            },
+            gpu: null, // populated by an optional platform GPU probe later
+            disk: { mounts: [] },
+            network: this.network(),
+            system: {
+                hostname: os.hostname(),
+                platform: os.platform(),
+                arch: os.arch(),
+                uptimeSec: Math.round(os.uptime()),
+                kernelRelease: os.release(),
+            },
+            processes: [],
+            timestamp: Date.now(),
+        };
+    }
+}
+/** A 0–100 load figure derived from a snapshot (used by the compute router). */
+export function loadFromSnapshot(hw) {
+    if (!hw)
+        return 50; // unknown → mid
+    // Blend CPU% and memory% so a memory-bound Pi isn't picked for heavy work.
+    return Math.round(hw.cpu.percent * 0.7 + hw.memory.percent * 0.3);
+}
+/** Build the neutral NodeStatus entry the mesh map renders. */
+export function nodeStatusFromPeer(peer) {
+    return {
+        nodeId: peer.nodeId,
+        displayName: peer.displayName,
+        role: peer.role,
+        platform: peer.manifest?.platform ?? 'unknown',
+        deviceFamily: peer.manifest?.deviceFamily,
+        modelIdentifier: peer.manifest?.modelIdentifier,
+        version: peer.manifest?.version ?? peer.version ?? '?',
+        capabilities: peer.manifest?.capabilities ?? [],
+        commands: peer.manifest?.commands ?? [],
+        connected: peer.connected,
+        connectedAtMs: peer.connected ? peer.lastSeenAt : undefined,
+        load: loadFromSnapshot(peer.hardware),
+        lastSeenAt: peer.lastSeenAt,
+    };
+}
+/** Local node's own status entry. */
+export function selfNodeStatus(identity, hw, manifest) {
+    return {
+        nodeId: identity.nodeId,
+        displayName: identity.displayName,
+        role: identity.role,
+        platform: hw.system.platform,
+        modelIdentifier: hw.cpu.model,
+        version: manifest.version,
+        capabilities: manifest.capabilities,
+        commands: manifest.commands,
+        connected: true,
+        connectedAtMs: Date.now(),
+        load: loadFromSnapshot(hw),
+        lastSeenAt: Date.now(),
+    };
+}

package/dist/kernel/federation/transport-http.d.ts

@@ -0,0 +1,44 @@
+import type { Logger } from '../types.js';
+import type { FederationEnvelope, NodeManifest, StreamFrame } from './types.js';
+export type RpcHandler = (env: FederationEnvelope, remote: string) => Promise<FederationEnvelope | void>;
+export interface MeshServerOptions {
+    host?: string;
+    port: number;
+    /** Optional shared token; requests must present it as Bearer auth. */
+    token?: string;
+    getManifest: () => NodeManifest;
+    onRpc: RpcHandler;
+    logger: Logger;
+}
+export declare class MeshServer {
+    private opts;
+    private server?;
+    private sse;
+    private seq;
+    constructor(opts: MeshServerOptions);
+    get streamCount(): number;
+    start(): Promise<void>;
+    /** Push a frame to every connected stream subscriber. */
+    broadcast(frame: StreamFrame): void;
+    private authOk;
+    private handle;
+    private openStream;
+    private readBody;
+    stop(): Promise<void>;
+}
+export interface MeshClientOptions {
+    token?: string;
+    timeoutMs?: number;
+}
+export declare class MeshClient {
+    private opts;
+    constructor(opts?: MeshClientOptions);
+    private headers;
+    fetchManifest(baseUrl: string): Promise<NodeManifest>;
+    rpc(baseUrl: string, env: FederationEnvelope): Promise<FederationEnvelope>;
+    /**
+     * Open an SSE stream to a peer. Returns a stop() fn. Reconnection is the
+     * caller's job (peer-mesh handles it on heartbeat failure).
+     */
+    openStream(baseUrl: string, onFrame: (f: StreamFrame) => void, onClose?: () => void): () => void;
+}

package/dist/kernel/federation/transport-http.js

@@ -0,0 +1,207 @@
+/**
+ * OpenKernel — Federation Transport (HTTP + SSE)
+ *
+ * Dependency-free transport built on node:http (server) + global fetch (client).
+ *
+ *   POST /fed/rpc      → receive a FederationEnvelope, return a reply envelope
+ *   GET  /fed/stream   → SSE: server pushes compact StreamFrames to a peer
+ *   GET  /fed/manifest → this node's manifest (cheap discovery probe)
+ *
+ * This directionality is deliberate: a hub OPENS the connection to a satellite
+ * (GET /stream to receive its activity/telemetry, POST /rpc to send tasks). The
+ * satellite is accept-only and never dials out — matching the secure one-way
+ * network model. A WebSocket/MOLTFED transport can be added behind the same
+ * MeshClient/MeshServer shape later for deep InfiniBot-fabric interop.
+ */
+import { createServer } from 'node:http';
+import { frameToSSE, parseSSE } from './protocol.js';
+export class MeshServer {
+    opts;
+    server;
+    sse = new Map();
+    seq = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get streamCount() {
+        return this.sse.size;
+    }
+    async start() {
+        this.server = createServer((req, res) => this.handle(req, res));
+        await new Promise((resolve, reject) => {
+            this.server.once('error', reject);
+            this.server.listen(this.opts.port, this.opts.host ?? '0.0.0.0', () => {
+                this.server.off('error', reject);
+                resolve();
+            });
+        });
+        this.opts.logger.info(`[federation] mesh listening on ${this.opts.host ?? '0.0.0.0'}:${this.opts.port}`);
+    }
+    /** Push a frame to every connected stream subscriber. */
+    broadcast(frame) {
+        if (this.sse.size === 0)
+            return;
+        const payload = frameToSSE(frame);
+        for (const client of this.sse.values()) {
+            try {
+                client.res.write(payload);
+            }
+            catch {
+                this.sse.delete(client.id);
+            }
+        }
+    }
+    authOk(req) {
+        if (!this.opts.token)
+            return true;
+        const h = req.headers['authorization'];
+        return typeof h === 'string' && h === `Bearer ${this.opts.token}`;
+    }
+    handle(req, res) {
+        const url = req.url ?? '/';
+        if (!this.authOk(req)) {
+            res.writeHead(401).end('unauthorized');
+            return;
+        }
+        const remote = req.socket.remoteAddress ?? 'unknown';
+        if (req.method === 'GET' && url.startsWith('/fed/manifest')) {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify(this.opts.getManifest()));
+            return;
+        }
+        if (req.method === 'GET' && url.startsWith('/fed/stream')) {
+            this.openStream(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.startsWith('/fed/rpc')) {
+            this.readBody(req)
+                .then(async (body) => {
+                let env;
+                try {
+                    env = JSON.parse(body);
+                }
+                catch {
+                    res.writeHead(400).end('bad envelope');
+                    return;
+                }
+                const out = await this.opts.onRpc(env, remote);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(out ?? { ok: true }));
+            })
+                .catch(err => {
+                this.opts.logger.warn(`[federation] rpc error: ${err instanceof Error ? err.message : String(err)}`);
+                res.writeHead(500).end('rpc failed');
+            });
+            return;
+        }
+        res.writeHead(404).end('not found');
+    }
+    openStream(req, res) {
+        res.writeHead(200, {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+            connection: 'keep-alive',
+        });
+        res.write(': connected\n\n');
+        const id = `sse_${++this.seq}`;
+        this.sse.set(id, { id, res });
+        this.opts.logger.info(`[federation] stream subscriber ${id} (${this.sse.size} total)`);
+        req.on('close', () => {
+            this.sse.delete(id);
+        });
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', chunk => {
+                data += chunk;
+                if (data.length > 8_000_000)
+                    reject(new Error('body too large'));
+            });
+            req.on('end', () => resolve(data));
+            req.on('error', reject);
+        });
+    }
+    async stop() {
+        for (const c of this.sse.values()) {
+            try {
+                c.res.end();
+            }
+            catch { /* ignore */ }
+        }
+        this.sse.clear();
+        if (this.server) {
+            await new Promise(resolve => this.server.close(() => resolve()));
+            this.server = undefined;
+        }
+    }
+}
+export class MeshClient {
+    opts;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    headers() {
+        const h = { 'content-type': 'application/json' };
+        if (this.opts.token)
+            h['authorization'] = `Bearer ${this.opts.token}`;
+        return h;
+    }
+    async fetchManifest(baseUrl) {
+        const res = await fetch(`${baseUrl}/fed/manifest`, {
+            headers: this.headers(),
+            signal: AbortSignal.timeout(this.opts.timeoutMs ?? 5000),
+        });
+        if (!res.ok)
+            throw new Error(`manifest ${res.status}`);
+        return (await res.json());
+    }
+    async rpc(baseUrl, env) {
+        const res = await fetch(`${baseUrl}/fed/rpc`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(env),
+            signal: AbortSignal.timeout(this.opts.timeoutMs ?? 30_000),
+        });
+        if (!res.ok)
+            throw new Error(`rpc ${res.status}`);
+        return (await res.json());
+    }
+    /**
+     * Open an SSE stream to a peer. Returns a stop() fn. Reconnection is the
+     * caller's job (peer-mesh handles it on heartbeat failure).
+     */
+    openStream(baseUrl, onFrame, onClose) {
+        const ctrl = new AbortController();
+        (async () => {
+            try {
+                const res = await fetch(`${baseUrl}/fed/stream`, {
+                    headers: this.headers(),
+                    signal: ctrl.signal,
+                });
+                if (!res.ok || !res.body)
+                    throw new Error(`stream ${res.status}`);
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
+                let buf = '';
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buf += decoder.decode(value, { stream: true });
+                    const { frames, rest } = parseSSE(buf);
+                    buf = rest;
+                    for (const f of frames)
+                        onFrame(f);
+                }
+            }
+            catch {
+                // aborted or dropped
+            }
+            finally {
+                onClose?.();
+            }
+        })();
+        return () => ctrl.abort();
+    }
+}

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

@@ -0,0 +1,212 @@
+/**
+ * OpenKernel — Federation Types
+ *
+ * The mesh is provider/harness-agnostic. Everything on the wire is plain JSON:
+ * a small envelope carrying one of a handful of message kinds, plus a compact
+ * "stream frame" format tuned for high-frequency, animation-friendly rendering
+ * in a harness UI (short keys, coalesced telemetry).
+ *
+ * Nothing here is InfiniBot-specific — the MOLTFED adapter translates these
+ * neutral shapes into InfiniBot's message names so its neural-mesh map + hardware
+ * panels light up without any InfiniBot changes.
+ */
+import type { Capability } from '../types.js';
+/** Role of a node in the mesh. Governs connection direction + permissions. */
+export type NodeRole = 'hub' | 'peer' | 'satellite' | 'relay';
+/** Stable identity of a node, persisted to disk so it survives restarts. */
+export interface NodeIdentity {
+    nodeId: string;
+    displayName: string;
+    role: NodeRole;
+    /** Public key (base64) — used for app-layer auth of peers. */
+    publicKey?: string;
+    createdAt: number;
+}
+/** What a node can do — advertised to peers + the harness map. */
+export interface NodeManifest {
+    nodeId: string;
+    displayName: string;
+    role: NodeRole;
+    version: string;
+    platform: string;
+    arch: string;
+    /** e.g. "Raspberry Pi 5", "Windows Workstation". */
+    deviceFamily?: string;
+    modelIdentifier?: string;
+    /** Aggregate capabilities of this node's registered workers. */
+    capabilities: Capability[];
+    /** Worker types this node can run. */
+    workers: string[];
+    /** Slash/MCP commands this node exposes (for click-to-invoke). */
+    commands: string[];
+    /** Provider ids available on this node. */
+    providers: string[];
+    startedAt: number;
+}
+/** A peer known to this node. */
+export interface PeerInfo {
+    nodeId: string;
+    displayName: string;
+    role: NodeRole;
+    /** Base URL we reach this peer at, e.g. http://100.x.y.z:47913 . */
+    url: string;
+    connected: boolean;
+    lastSeenAt: number;
+    latencyMs?: number;
+    manifest?: NodeManifest;
+    /** Latest telemetry snapshot (load used by the compute router). */
+    hardware?: HardwareSnapshot;
+    version?: string;
+}
+export interface HardwareSnapshot {
+    cpu: {
+        percent: number;
+        perCorePercent: number[];
+        loadAvg: [number, number, number];
+        cores: number;
+        model: string;
+    };
+    memory: {
+        totalBytes: number;
+        usedBytes: number;
+        freeBytes: number;
+        percent: number;
+    };
+    gpu: {
+        vendor: string;
+        utilizationPercent: number;
+        vramUsedBytes: number;
+        vramTotalBytes: number;
+        name: string;
+    } | null;
+    disk: {
+        mounts: Array<{
+            path: string;
+            totalBytes: number;
+            usedBytes: number;
+            percent: number;
+        }>;
+    };
+    network: {
+        interfaces: Array<{
+            name: string;
+            rxBytesPerSec: number;
+            txBytesPerSec: number;
+        }>;
+    };
+    system: {
+        hostname: string;
+        platform: string;
+        arch: string;
+        uptimeSec: number;
+        kernelRelease: string;
+    };
+    processes: Array<{
+        pid: number;
+        name: string;
+        cpuPercent: number;
+        memoryBytes: number;
+    }>;
+    timestamp: number;
+}
+/** Node status entry consumed by the mesh map (neutral form of nodes.status). */
+export interface NodeStatus {
+    nodeId: string;
+    displayName: string;
+    role: NodeRole;
+    platform: string;
+    deviceFamily?: string;
+    modelIdentifier?: string;
+    version: string;
+    capabilities: Capability[];
+    commands: string[];
+    connected: boolean;
+    connectedAtMs?: number;
+    /** 0–100 rough load, from the latest hardware snapshot. */
+    load?: number;
+    lastSeenAt: number;
+}
+export type MessageKind = 'hello' | 'welcome' | 'heartbeat' | 'manifest' | 'task.dispatch' | 'task.accepted' | 'task.status' | 'task.result' | 'task.cancel' | 'command' | 'command.result' | 'config.request' | 'config.offer' | 'update.announce' | 'update.request' | 'role.get' | 'role.set' | 'event' | 'telemetry' | 'ack' | 'error';
+/** A dispatched/received task run — tracked for non-blocking handoff + monitoring. */
+export interface RunRecord {
+    runId: string;
+    status: 'running' | 'completed' | 'failed';
+    description: string;
+    missionId?: string;
+    outputs?: Array<{
+        status: string;
+        content?: string;
+        error?: string;
+    }>;
+    error?: string;
+    startedAt: number;
+    completedAt?: number;
+}
+/** Persistent per-device role + server-architecture context. */
+export interface RoleContext {
+    /** e.g. "RoboPanda" — the identity a spawned agent adopts. */
+    role: string;
+    /** Free-text description of this device's job + the wider architecture. */
+    architecture?: string;
+    /** Extra structured context injected into every task run on this node. */
+    extra?: Record<string, unknown>;
+    updatedAt: number;
+}
+/** Signed, routable message envelope. */
+export interface FederationEnvelope<T = unknown> {
+    /** Protocol version for forward-compat. */
+    v: number;
+    /** Message id (for request/response correlation). */
+    id: string;
+    kind: MessageKind;
+    from: string;
+    to?: string;
+    ts: number;
+    /** Correlation id — set on replies to the request's id. */
+    re?: string;
+    data?: T;
+    /** Optional bearer/token for app-layer auth. */
+    auth?: string;
+}
+/**
+ * A minimal, high-frequency frame for the harness to render/animate. Short keys
+ * keep bytes low for smooth 1–10 Hz updates. `t` is a frame type; the harness
+ * switches on it to drive different animations.
+ */
+export interface StreamFrame {
+    /** frame type: ev=event, hw=telemetry, hb=heartbeat, nd=node status, rt=routing */
+    t: 'ev' | 'hw' | 'hb' | 'nd' | 'rt' | 'log';
+    /** origin nodeId */
+    n: string;
+    /** monotonic sequence for gap detection */
+    s: number;
+    /** epoch ms */
+    ts: number;
+    /** compact payload — shape depends on t */
+    d?: unknown;
+}
+/** A shareable slice of config a hub can push to satellites. */
+export interface SharedConfig {
+    /** Cloud providers (id/name/baseURL/apiKey/enabled). */
+    cloudProviders?: Array<Record<string, unknown>>;
+    /** Default policy + model. */
+    policy?: string;
+    defaultModel?: string;
+    /** Free-form extra keys. */
+    extra?: Record<string, unknown>;
+    /** Version/etag so a satellite only re-applies when it changes. */
+    revision: number;
+    updatedAt: number;
+}
+export interface UpdateAnnounce {
+    version: string;
+    /** How to fetch the update (npm tag, url, or "git"). */
+    channel: 'npm' | 'url' | 'git';
+    ref?: string;
+    notes?: string;
+    /** Minimum protocol version the update requires. */
+    minProtocol?: number;
+}
+export declare const FEDERATION_PROTOCOL_VERSION = 1;
+/** Default mesh ports — chosen to sit alongside InfiniBot's 47913/47914. */
+export declare const DEFAULT_MESH_PORT = 47913;

package/dist/kernel/federation/types.js

@@ -0,0 +1,3 @@
+export const FEDERATION_PROTOCOL_VERSION = 1;
+/** Default mesh ports — chosen to sit alongside InfiniBot's 47913/47914. */
+export const DEFAULT_MESH_PORT = 47913;