infinicode 1.0.0 → 2.1.0

package/dist/kernel/federation/federation.js

@@ -0,0 +1,378 @@
+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 { LanBeacon } from './lan-discovery.js';
+import { DEFAULT_MESH_PORT } from './types.js';
+export class Federation {
+    deps;
+    server;
+    client;
+    mesh;
+    bridge;
+    telemetry = new TelemetryCollector();
+    telemetryTimer;
+    lastHw;
+    unsub;
+    lan;
+    /** nodeIds we're currently dialing via LAN discovery (dedup guard). */
+    lanConnecting = new Set();
+    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;
+    }
+    /**
+     * Start zero-config LAN discovery: broadcast a beacon on the local subnet and
+     * auto-connect to any peer we hear (no --seed / Tailscale needed). Continuous —
+     * new nodes that come online later are picked up too. Idempotent.
+     */
+    startLanDiscovery(tag, discoveryPort) {
+        if (this.lan)
+            return;
+        const { identity, logger, options } = this.deps;
+        this.lan = new LanBeacon({
+            nodeId: identity.nodeId,
+            name: identity.displayName,
+            role: identity.role,
+            meshPort: options.port ?? DEFAULT_MESH_PORT,
+            tag,
+            auth: !!options.token,
+            discoveryPort,
+            logger,
+            onPeer: ({ nodeId, url, name }) => {
+                if (nodeId === identity.nodeId)
+                    return; // self
+                if (this.mesh?.get(nodeId))
+                    return; // already connected
+                if (this.lanConnecting.has(nodeId))
+                    return; // dial in flight
+                this.lanConnecting.add(nodeId);
+                void this.mesh
+                    ?.connect(url)
+                    .then(p => {
+                    if (p)
+                        logger.info(`[federation] lan discovered ${p.displayName ?? name} @ ${url}`);
+                })
+                    .catch(() => { })
+                    .finally(() => this.lanConnecting.delete(nodeId));
+            },
+        });
+        this.lan.start();
+    }
+    // ── 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();
+        this.lan?.stop();
+        if (this.telemetryTimer)
+            clearInterval(this.telemetryTimer);
+        this.mesh?.stop();
+        await this.server?.stop();
+    }
+}

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

@@ -0,0 +1,33 @@
+/**
+ * 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 { LanBeacon, DEFAULT_LAN_DISCOVERY_PORT } from './lan-discovery.js';
+export type { LanBeaconOptions, DiscoveredLanPeer } from './lan-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,24 @@
+/**
+ * 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 { LanBeacon, DEFAULT_LAN_DISCOVERY_PORT } from './lan-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/lan-discovery.d.ts

@@ -0,0 +1,43 @@
+import type { Logger } from '../types.js';
+export declare const DEFAULT_LAN_DISCOVERY_PORT = 47915;
+export interface DiscoveredLanPeer {
+    nodeId: string;
+    name: string;
+    role: string;
+    url: string;
+    address: string;
+    tag?: string;
+}
+export interface LanBeaconOptions {
+    nodeId: string;
+    name: string;
+    role: string;
+    /** The mesh (HTTP+SSE) port this node advertises. */
+    meshPort: number;
+    /** Only match peers carrying this tag (mirrors Tailscale --tag). */
+    tag?: string;
+    /** Whether this node's mesh requires a token (informational only). */
+    auth?: boolean;
+    /** UDP port to broadcast/listen on (default 47915). */
+    discoveryPort?: number;
+    /** Broadcast cadence (default 5s). */
+    intervalMs?: number;
+    logger?: Logger;
+    /** Called when a *different* node's beacon is heard. */
+    onPeer: (peer: DiscoveredLanPeer) => void;
+}
+/** Periodically broadcasts a discovery beacon and reports peers it hears. */
+export declare class LanBeacon {
+    private opts;
+    private sock?;
+    private timer?;
+    private readonly port;
+    private readonly intervalMs;
+    private stopped;
+    constructor(opts: LanBeaconOptions);
+    start(): void;
+    private beaconPayload;
+    private broadcast;
+    private onMessage;
+    stop(): void;
+}

package/dist/kernel/federation/lan-discovery.js

@@ -0,0 +1,135 @@
+/**
+ * OpenKernel — LAN Peer Discovery (UDP broadcast)
+ *
+ * Zero-config, dependency-free same-subnet discovery. Each node periodically
+ * broadcasts a tiny beacon (nodeId, name, role, mesh port, optional tag) over
+ * UDP; any node that hears a beacon learns a peer's mesh URL and connects. No
+ * --seed, no Tailscale needed on a shared LAN.
+ *
+ * Broadcast packets are NOT forwarded by routers, so this stays within the local
+ * subnet by design — discovery only ever reaches physically co-located, trusted
+ * machines. Actual mesh RPC is still gated by the shared --token if one is set.
+ */
+import dgram from 'node:dgram';
+import os from 'node:os';
+export const DEFAULT_LAN_DISCOVERY_PORT = 47915;
+const MAGIC = 'ICMESH1';
+/** Periodically broadcasts a discovery beacon and reports peers it hears. */
+export class LanBeacon {
+    opts;
+    sock;
+    timer;
+    port;
+    intervalMs;
+    stopped = false;
+    constructor(opts) {
+        this.opts = opts;
+        this.port = opts.discoveryPort ?? DEFAULT_LAN_DISCOVERY_PORT;
+        this.intervalMs = opts.intervalMs ?? 5000;
+    }
+    start() {
+        const sock = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+        this.sock = sock;
+        sock.on('error', err => {
+            this.opts.logger?.debug?.(`[federation] lan discovery socket error: ${err.message}`);
+        });
+        sock.on('message', (buf, rinfo) => this.onMessage(buf, rinfo));
+        sock.bind(this.port, () => {
+            try {
+                sock.setBroadcast(true);
+            }
+            catch {
+                /* some platforms disallow; best-effort */
+            }
+            this.broadcast();
+            this.timer = setInterval(() => this.broadcast(), this.intervalMs);
+            this.opts.logger?.info?.(`[federation] lan discovery listening on udp/${this.port}`);
+        });
+    }
+    beaconPayload() {
+        const wire = {
+            t: MAGIC,
+            v: 1,
+            nodeId: this.opts.nodeId,
+            name: this.opts.name,
+            role: this.opts.role,
+            meshPort: this.opts.meshPort,
+            tag: this.opts.tag,
+            auth: this.opts.auth,
+        };
+        return Buffer.from(JSON.stringify(wire));
+    }
+    broadcast() {
+        if (this.stopped || !this.sock)
+            return;
+        const msg = this.beaconPayload();
+        for (const addr of broadcastAddresses()) {
+            this.sock.send(msg, this.port, addr, err => {
+                if (err)
+                    this.opts.logger?.debug?.(`[federation] lan beacon send ${addr} failed: ${err.message}`);
+            });
+        }
+    }
+    onMessage(buf, rinfo) {
+        let data;
+        try {
+            data = JSON.parse(buf.toString('utf8'));
+        }
+        catch {
+            return;
+        }
+        if (!data || data.t !== MAGIC)
+            return;
+        if (typeof data.nodeId !== 'string' || typeof data.meshPort !== 'number')
+            return;
+        if (data.nodeId === this.opts.nodeId)
+            return; // ignore our own beacon
+        if (this.opts.tag && data.tag !== this.opts.tag)
+            return; // tag filter
+        const address = rinfo.address;
+        this.opts.onPeer({
+            nodeId: data.nodeId,
+            name: data.name ?? data.nodeId,
+            role: data.role ?? 'peer',
+            url: `http://${address}:${data.meshPort}`,
+            address,
+            tag: data.tag,
+        });
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        try {
+            this.sock?.close();
+        }
+        catch {
+            /* ignore */
+        }
+        this.sock = undefined;
+    }
+}
+/** Limited broadcast + each interface's directed broadcast address (IPv4). */
+function broadcastAddresses() {
+    const addrs = new Set(['255.255.255.255']);
+    for (const list of Object.values(os.networkInterfaces())) {
+        for (const ni of list ?? []) {
+            // Node 20 reports family as 'IPv4'; guard the numeric form defensively.
+            if (ni.family !== 'IPv4' && ni.family !== 4)
+                continue;
+            if (ni.internal)
+                continue;
+            const b = directedBroadcast(ni.address, ni.netmask);
+            if (b)
+                addrs.add(b);
+        }
+    }
+    return [...addrs];
+}
+function directedBroadcast(ip, mask) {
+    const ipp = ip.split('.').map(Number);
+    const mp = mask.split('.').map(Number);
+    if (ipp.length !== 4 || mp.length !== 4 || [...ipp, ...mp].some(n => Number.isNaN(n)))
+        return null;
+    return ipp.map((o, i) => (o & mp[i]) | (~mp[i] & 0xff)).join('.');
+}

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;
+}>;