infinicode 2.0.0 → 2.1.0

package/README.md

@@ -90,6 +90,46 @@ infinicode mission status <id>
 infinicode mission list
 ```
 
+### As a device mesh (multi-device, new in v2)
+
+Install infinicode on every machine — laptop, workstation, Raspberry&nbsp;Pi — and they become one fleet. Spawn AI agents on any device from any device (no SSH), stream activity/hardware back, and drive it all from an MCP host like Claude Code or InfiniBot.
+
+```bash
+# install on each device
+npm install -g infinicode
+
+# same LAN — zero config: each node broadcasts a UDP beacon and auto-connects
+infinicode serve --hub --lan                         # your main machine
+infinicode serve --role satellite --lan              # a Pi / other box
+
+# across LAN + remote — auto-discover over Tailscale
+infinicode serve --hub --tailscale
+infinicode serve --role satellite --tailscale --tag tag:robopark
+
+# or point at exact peers
+infinicode serve --role satellite --seed http://192.168.1.20:47913
+
+# verify the mesh
+infinicode x /nodes
+```
+
+Drive the fleet from an MCP host — register the control server (spawn / dispatch / follow / role / voice / mesh-map tools):
+
+```jsonc
+// ~/.claude.json
+{ "mcpServers": { "infinicode": { "command": "infinicode", "args": ["mcp", "--lan"] } } }
+```
+
+Link a node onto an **InfiniBot** neural-mesh map (no InfiniBot changes needed):
+
+```bash
+infinicode serve --hub --gateway ws://<infinibot-host>:18789 --gateway-token <token>
+```
+
+Discovery options: `--lan` (same subnet, zero-config UDP broadcast, port 47915), `--tailscale` (LAN+remote), `--seed <url>` (exact) — they combine. Full guide: `docs/user-manual.html`; design deep-dive: `docs/federation-architecture.html`.
+
+> The Windows TUI binaries are not shipped in the npm package (they're large and platform-specific), so `infinicode run` needs a local TUI build; the mesh commands (`serve`, `mcp`, `mission`, `console`) run everywhere as pure Node.
+
 ### As a library
 
 ```ts

package/dist/cli.js

@@ -15,7 +15,7 @@ import { consoleRepl, consoleRun } from './commands/console.js';
 import { serve } from './commands/serve.js';
 import { mcpCommand } from './commands/mcp.js';
 import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.0.0';
+const VERSION = '2.1.0';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -287,7 +287,9 @@ program
     .option('--seed <url...>', 'peer base URL(s) to connect to on start')
     .option('--auto-update', 'accept auto-updates announced by a hub/relay')
     .option('--tailscale', 'auto-discover + connect peers over Tailscale')
-    .option('--tag <tag>', 'only discover peers carrying this Tailscale ACL tag')
+    .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')
+    .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
+    .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
     .option('--gateway <url>', 'link to an InfiniBot gateway (ws://host:18789) — appear on its neural-mesh map')
     .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
     .option('--gateway-password <password>', 'auth password for the InfiniBot gateway')
@@ -304,7 +306,9 @@ program
     .option('--token <token>', 'shared bearer token peers must present')
     .option('--seed <url...>', 'peer base URL(s) to connect to on start')
     .option('--tailscale', 'auto-discover + connect peers over Tailscale')
-    .option('--tag <tag>', 'only discover peers carrying this Tailscale ACL tag')
+    .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')
+    .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
+    .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
     .action(async (opts) => {
     await mcpCommand(config, opts);
 });

package/dist/commands/mcp.d.ts

@@ -8,5 +8,7 @@ export interface McpOptions {
     seed?: string[];
     tailscale?: boolean;
     tag?: string;
+    lan?: boolean;
+    lanPort?: string;
 }
 export declare function mcpCommand(config: Conf<InfinicodeConfig>, opts: McpOptions): Promise<void>;

package/dist/commands/mcp.js

@@ -81,6 +81,10 @@ export async function mcpCommand(config, opts) {
         const n = await federation.discoverAndConnect(opts.tag).catch(() => 0);
         stderrLogger.info(`tailscale discovery connected ${n} peer(s)`);
     }
+    if (opts.lan ?? fed.lan) {
+        federation.startLanDiscovery(opts.tag, opts.lanPort ? parseInt(opts.lanPort, 10) : fed.lanPort);
+        stderrLogger.info('LAN auto-discovery on (udp broadcast)');
+    }
     // Proactive autonomy: a goal loop the MCP host can populate (add_goal/…).
     const autonomy = new GoalLoop({ kernel, logger: stderrLogger });
     autonomy.start();

package/dist/commands/serve.d.ts

@@ -11,6 +11,8 @@ export interface ServeOptions {
     hub?: boolean;
     tailscale?: boolean;
     tag?: string;
+    lan?: boolean;
+    lanPort?: string;
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;

package/dist/commands/serve.js

@@ -95,6 +95,11 @@ export async function serve(config, opts) {
         const n = await federation.discoverAndConnect(opts.tag).catch(() => 0);
         console.log(chalk.green(`  ✓ tailscale discovery connected ${n} peer(s)`));
     }
+    // Optional: zero-config LAN discovery — auto-connect peers on this subnet.
+    if (opts.lan ?? fed.lan) {
+        federation.startLanDiscovery(opts.tag, opts.lanPort ? parseInt(opts.lanPort, 10) : fed.lanPort);
+        console.log(chalk.green(`  ✓ LAN auto-discovery on (udp broadcast) — peers on this subnet connect automatically`));
+    }
     // Optional: log this node into an InfiniBot gateway so it renders live on the
     // neural-mesh map + hardware panels (no InfiniBot changes needed).
     let connector;

package/dist/kernel/config-schema.d.ts

@@ -37,6 +37,10 @@ export interface FederationConfig {
     heartbeatSec?: number;
     /** Accept + apply auto-updates announced by a hub/relay. */
     autoUpdate?: boolean;
+    /** Zero-config LAN discovery: broadcast + auto-connect peers on this subnet. */
+    lan?: boolean;
+    /** UDP discovery port for LAN discovery (default 47915). */
+    lanPort?: number;
 }
 export interface InfinicodeConfig {
     masterUrl: string;

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

@@ -54,6 +54,9 @@ export declare class Federation {
     private telemetryTimer?;
     private lastHw?;
     private unsub?;
+    private lan?;
+    /** nodeIds we're currently dialing via LAN discovery (dedup guard). */
+    private lanConnecting;
     readonly configSync: ConfigSync;
     readonly autoUpdate: AutoUpdate;
     readonly compute: ComputeRouter;
@@ -109,6 +112,12 @@ export declare class Federation {
     connect(url: string): Promise<import("./types.js").PeerInfo | null>;
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     discoverAndConnect(tag?: string): Promise<number>;
+    /**
+     * 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?: string, discoveryPort?: number): void;
     /** Neutral node-status list (self + peers) — feeds the mesh map. */
     nodeStatuses(): NodeStatus[];
     peers(): import("./types.js").PeerInfo[];

package/dist/kernel/federation/federation.js

@@ -9,6 +9,7 @@ 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;
@@ -20,6 +21,9 @@ export class Federation {
     telemetryTimer;
     lastHw;
     unsub;
+    lan;
+    /** nodeIds we're currently dialing via LAN discovery (dedup guard). */
+    lanConnecting = new Set();
     configSync;
     autoUpdate;
     compute = new ComputeRouter();
@@ -285,6 +289,44 @@ export class Federation {
         }
         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() {
@@ -327,6 +369,7 @@ export class Federation {
     async stop() {
         this.unsub?.();
         this.bridge?.stop();
+        this.lan?.stop();
         if (this.telemetryTimer)
             clearInterval(this.telemetryTimer);
         this.mesh?.stop();

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

@@ -25,6 +25,8 @@ 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';

package/dist/kernel/federation/index.js

@@ -18,6 +18,7 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",