infinicode 2.8.63 → 2.8.64

package/dist/kernel/federation/federation.js

@@ -400,6 +400,28 @@ export class Federation {
      * until the run finishes (short tasks).
      */
     async dispatch(task, need, opts) {
+        const self = this.deps.identity;
+        const requestedSelf = need?.preferNodeId === self.nodeId ||
+            need?.preferName?.toLowerCase() === self.displayName.toLowerCase();
+        if (requestedSelf) {
+            const localCaps = new Set(this.describeWithBackends().capabilities);
+            if (!task.capabilities.every(capability => localCaps.has(capability))) {
+                this.deps.logger.warn('[federation] local node lacks a required dispatch capability');
+                return null;
+            }
+            const runId = newId();
+            this.runs.set(runId, {
+                runId,
+                status: 'running',
+                description: task.description,
+                startedAt: Date.now(),
+            });
+            void this.runTaskAsync(runId, task);
+            const record = opts?.wait
+                ? await this.awaitRun(runId, opts.timeoutMs ?? 120_000)
+                : this.runs.get(runId);
+            return { peerId: self.nodeId, runId, record };
+        }
         if (!this.mesh)
             return null;
         const peers = this.mesh.connected();

package/dist/robopark/discovery.d.ts

@@ -56,7 +56,9 @@ export declare function readInfinicodeFederation(): {
     port?: number;
 };
 /** Build the full discovered context for this environment. */
-export declare function discoverContext(): Promise<DiscoveredContext>;
+export declare function discoverContext(options?: {
+    lan?: boolean;
+}): Promise<DiscoveredContext>;
 /** Generate a random token for mesh auth or scheduler enrollment. */
 export declare function generateToken(length?: number): string;
 export {};

package/dist/robopark/discovery.js

@@ -8,6 +8,7 @@
  *   - Running infinicode nodes → reuse mesh identity + token
  */
 import { execa } from 'execa';
+import dgram from 'node:dgram';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir, hostname } from 'node:os';
 import { join } from 'node:path';
@@ -45,11 +46,42 @@ export async function discoverTailscale() {
         .filter(p => p.ip !== 'unknown');
 }
 /** Scan LAN UDP beacons on the default mesh discovery port. */
-export async function discoverLan(port = 47915, timeoutMs = 3000) {
-    // LAN discovery currently relies on the infinicode beacon protocol.
-    // For auto-setup we reuse Tailscale when available; LAN fallback is a TODO
-    // once the beacon protocol is stable enough to parse here.
-    return [];
+export async function discoverLan(port = 47915, timeoutMs = 6000) {
+    return new Promise(resolve => {
+        const peers = new Map();
+        const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                socket.close();
+            }
+            catch { /* already closed */ }
+            resolve([...peers.values()]);
+        };
+        socket.on('message', (buffer, remote) => {
+            try {
+                const beacon = JSON.parse(buffer.toString('utf8'));
+                if (beacon.t !== 'ICMESH1' || !beacon.nodeId || !Number.isInteger(beacon.meshPort))
+                    return;
+                peers.set(beacon.nodeId, {
+                    name: beacon.name ?? beacon.nodeId,
+                    ip: remote.address,
+                    tags: beacon.tag ? [beacon.tag] : undefined,
+                    online: true,
+                    source: 'lan',
+                });
+            }
+            catch {
+                // Ignore unrelated UDP traffic on the discovery port.
+            }
+        });
+        socket.once('error', finish);
+        socket.bind({ port, exclusive: false });
+        setTimeout(finish, timeoutMs).unref();
+    });
 }
 /** Read a Tailscale auth key from common locations. */
 export function findTailscaleAuthKey() {
@@ -115,8 +147,12 @@ export function readInfinicodeFederation() {
     return {};
 }
 /** Build the full discovered context for this environment. */
-export async function discoverContext() {
-    const peers = await discoverTailscale();
+export async function discoverContext(options = {}) {
+    const [tailnetPeers, lanPeers] = await Promise.all([
+        discoverTailscale(),
+        options.lan ? discoverLan() : Promise.resolve([]),
+    ]);
+    const peers = [...lanPeers, ...tailnetPeers];
     // Exclude this machine from the fleet tables.
     const selfName = hostname();
     const others = peers.filter(p => p.name !== selfName && p.online);

package/dist/robopark/setup.js

@@ -50,8 +50,8 @@ function commandString(argv) {
     return argv.map(a => /[^a-zA-Z0-9_./:=,-]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a).join(' ');
 }
 export async function roboparkSetup(config, opts) {
-    const ctx = await discoverContext();
     const role = opts.role ?? 'control';
+    const ctx = await discoverContext({ lan: role === 'robot' && !opts.tailscale });
     const token = opts.token ?? ctx.meshToken ?? generateToken();
     const port = opts.port ? parseInt(opts.port, 10) : DEFAULT_MESH_PORT;
     const name = opts.name ?? ctx.localName;
@@ -140,11 +140,37 @@ async function setupRobot(config, opts, ctx, internal) {
     }
     const network = opts.tailscale ? 'tailscale' : 'lan';
     const networkFlag = network === 'tailscale' ? '--tailscale' : '--lan';
-    const hubUrl = opts.hub ?? (ctx.hub ? `http://${ctx.hub.ip}:${internal.port}` : undefined);
+    let hubUrl = opts.hub ?? (ctx.hub ? `http://${ctx.hub.ip}:${internal.port}` : undefined);
     if (!hubUrl) {
         console.log(chalk.red('  ✗ no hub discovered. Pass --hub http://HUB_IP:47913'));
         return;
     }
+    if (network === 'lan') {
+        const reachable = async (url) => {
+            try {
+                const response = await fetch(`${url.replace(/\/+$/, '')}/fed/status`, {
+                    headers: { Authorization: `Bearer ${internal.token}` },
+                    signal: AbortSignal.timeout(2500),
+                });
+                return response.ok;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (!await reachable(hubUrl)) {
+            const discovered = ctx.hub?.source === 'lan'
+                ? `http://${ctx.hub.ip}:${internal.port}`
+                : undefined;
+            if (!discovered || !await reachable(discovered)) {
+                console.log(chalk.red(`  ✗ hub is unreachable from this robot: ${hubUrl}`));
+                console.log(chalk.dim('  verify the hub is running with --lan, then rerun setup'));
+                return;
+            }
+            console.log(chalk.yellow(`  âš  supplied hub unreachable; using LAN-discovered hub ${discovered}`));
+            hubUrl = discovered;
+        }
+    }
     const fed = {
         ...(config.get('federation') ?? {}),
         enabled: true,

package/dist/robopark/stop-all.js

@@ -119,8 +119,9 @@ function stopAllUnix() {
         const fuser = spawnSync('fuser', ['-n', 'tcp', String(port)], { encoding: 'utf8' });
         const pids = [...new Set(`${lsof.stdout ?? ''} ${fuser.stdout ?? ''}`
                 .split(/\s+/)
+                .filter(Boolean)
                 .map(s => Number(s.trim()))
-                .filter(Number.isFinite))];
+                .filter(pid => Number.isFinite(pid) && pid > 1))];
         for (const pid of pids) {
             if (pid === self || killedPids.includes(pid))
                 continue;

package/package.json

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