infinicode 2.8.56 → 2.8.58

package/dist/cli.js

@@ -305,6 +305,7 @@ program
     .option('--token <token>', 'shared bearer token peers must present')
     .option('--seed <url...>', 'peer base URL(s) to connect to on start')
     .option('--auto-update', 'accept auto-updates announced by a hub/relay')
+    .option('--update-poll-ms <ms>', 'hub/relay npm-release polling interval (default 60000)')
     .option('--supervised', 'this node runs under a supervisor (systemd/pm2/Task Scheduler) — let /update restart it to activate a new version')
     .option('--tailscale', 'auto-discover + connect peers over Tailscale')
     .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')

package/dist/commands/serve.d.ts

@@ -8,6 +8,7 @@ export interface ServeOptions {
     token?: string;
     seed?: string[];
     autoUpdate?: boolean;
+    updatePollMs?: string;
     hub?: boolean;
     tailscale?: boolean;
     tag?: string;

package/dist/commands/serve.js

@@ -156,6 +156,7 @@ export async function serve(config, opts) {
             token,
             heartbeatMs: (fed.heartbeatSec ?? 30) * 1000,
             autoUpdate: opts.autoUpdate ?? fed.autoUpdate,
+            updatePollMs: opts.updatePollMs ? Number(opts.updatePollMs) : fed.updatePollMs,
             applyConfig,
             autoPullConfig: role === 'satellite',
             dashboard: opts.dashboard,

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

@@ -43,6 +43,8 @@ export interface FederationConfig {
     heartbeatSec?: number;
     /** Accept + apply auto-updates announced by a hub/relay. */
     autoUpdate?: boolean;
+    /** Hub/relay npm-release polling interval in milliseconds (default 60000). */
+    updatePollMs?: number;
     /** Node runs under a process supervisor — allow `/update` to exit-for-restart. */
     supervised?: boolean;
     /** Zero-config LAN discovery: broadcast + auto-connect peers on this subnet. */

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

@@ -54,6 +54,8 @@ export interface FederationOptions {
     /** Base URLs of peers to connect to on start (static seeds). */
     seeds?: string[];
     autoUpdate?: boolean;
+    /** Hub/relay npm-release polling interval. Defaults to one minute. */
+    updatePollMs?: number;
     /** Satellite: how to apply an incoming shared config (register providers etc.). */
     applyConfig?: (cfg: SharedConfig) => void | Promise<void>;
     /** Satellite: auto-pull shared config from any hub/relay we connect to. */
@@ -133,6 +135,7 @@ export declare class Federation {
     /** nodeIds we're currently dialing back after an inbound heartbeat/hello. */
     private inboundConnecting;
     private configPullTimer?;
+    private updatePollTimer?;
     readonly configSync: ConfigSync;
     readonly autoUpdate: AutoUpdate;
     readonly compute: ComputeRouter;
@@ -259,6 +262,8 @@ export declare class Federation {
     private maybeAutoPull;
     /** Satellite: re-pull from the first connected hub/relay (periodic refresh). */
     private autoPullFromHub;
+    /** Fetch npm's latest tag, announce it to satellites, then update this hub. */
+    private pollNpmRelease;
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     discoverAndConnect(tag?: string): Promise<number>;
     /**

package/dist/kernel/federation/federation.js

@@ -3,7 +3,7 @@ import { DASHBOARD_HTML } from './dashboard-html.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 { AutoUpdate, compareVersions } from './auto-update.js';
 import { performSelfUpdate } from './self-update.js';
 import { ComputeRouter } from './compute-router.js';
 import { TelemetryCollector, loadFromSnapshot, selfNodeStatus, nodeStatusFromPeer } from './telemetry.js';
@@ -32,6 +32,7 @@ export class Federation {
     /** nodeIds we're currently dialing back after an inbound heartbeat/hello. */
     inboundConnecting = new Set();
     configPullTimer;
+    updatePollTimer;
     configSync;
     autoUpdate;
     compute = new ComputeRouter();
@@ -134,6 +135,15 @@ export class Federation {
         if (options.autoPullConfig && options.configPullMs !== 0) {
             this.configPullTimer = setInterval(() => void this.autoPullFromHub(), options.configPullMs ?? 30_000);
         }
+        // The hub owns release discovery. Satellites never poll npm: they only
+        // trust signed mesh announcements from a hub/relay. This makes npm publish
+        // -> fleet update a real loop, while retaining the --auto-update opt-in.
+        if (options.autoUpdate && (identity.role === 'hub' || identity.role === 'relay')) {
+            const pollMs = Math.max(30_000, options.updatePollMs ?? 60_000);
+            void this.pollNpmRelease();
+            this.updatePollTimer = setInterval(() => void this.pollNpmRelease(), pollMs);
+            logger.info(`[federation] npm release watcher enabled (every ${Math.round(pollMs / 1000)}s)`);
+        }
         logger.info(`[federation] node ${identity.displayName} (${identity.role}) online on :${port}`);
     }
     // ── Inbound RPC ────────────────────────────────────────────────────────────
@@ -172,7 +182,10 @@ export class Federation {
                 return reply(env, 'ack', self);
             case 'update.announce': {
                 const peer = this.mesh?.get(env.from);
-                await this.autoUpdate.onAnnounce(env.data, peer?.role ?? 'peer');
+                // Acknowledge immediately. npm can take minutes on a Pi, while the
+                // sender's RPC timeout is intentionally short; the update continues
+                // in the background and exits the supervised mesh process on success.
+                void this.autoUpdate.onAnnounce(env.data, peer?.role ?? 'peer');
                 return reply(env, 'ack', self);
             }
             case 'role.get':
@@ -625,6 +638,30 @@ export class Federation {
         if (hub)
             await this.maybeAutoPull(hub);
     }
+    /** Fetch npm's latest tag, announce it to satellites, then update this hub. */
+    async pollNpmRelease() {
+        try {
+            const response = await fetch('https://registry.npmjs.org/infinicode/latest', {
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw new Error(`npm registry ${response.status}`);
+            const payload = await response.json();
+            const version = typeof payload.version === 'string' ? payload.version.trim() : '';
+            if (!/^\d+(?:\.\d+){1,3}(?:[-+][A-Za-z0-9.-]+)?$/.test(version)) {
+                throw new Error('npm registry returned an invalid version');
+            }
+            await this.mesh?.announceUpdate({ version, channel: 'npm' });
+            const current = this.autoUpdate.currentVersion();
+            if (compareVersions(version, current) > 0) {
+                this.deps.logger.info(`[federation] npm release ${version} announced to fleet; updating ${current} -> ${version}`);
+                await this.autoUpdate.onAnnounce({ version, channel: 'npm' }, this.deps.identity.role);
+            }
+        }
+        catch (err) {
+            this.deps.logger.warn(`[federation] npm release check failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     async discoverAndConnect(tag) {
         const port = this.deps.options.port ?? DEFAULT_MESH_PORT;
@@ -752,6 +789,8 @@ export class Federation {
         this.lan?.stop();
         if (this.configPullTimer)
             clearInterval(this.configPullTimer);
+        if (this.updatePollTimer)
+            clearInterval(this.updatePollTimer);
         if (this.telemetryTimer)
             clearInterval(this.telemetryTimer);
         this.mesh?.stop();

package/dist/kernel/federation/peer-mesh.d.ts

@@ -10,7 +10,7 @@
  * manage (satellites are accept-only). A satellite never dials us.
  */
 import type { Logger } from '../types.js';
-import type { FederationEnvelope, NodeIdentity, PeerInfo, StreamFrame } from './types.js';
+import type { FederationEnvelope, NodeIdentity, PeerInfo, StreamFrame, UpdateAnnounce } from './types.js';
 import { MeshClient } from './transport-http.js';
 export interface PeerMeshOptions {
     self: NodeIdentity;
@@ -38,6 +38,8 @@ export declare class PeerMesh {
     connected(): PeerInfo[];
     /** Discover + attach a peer at a base URL (manifest probe + open its stream). */
     connect(url: string): Promise<PeerInfo | null>;
+    /** Send a hub/relay version announcement to every currently connected peer. */
+    announceUpdate(announce: UpdateAnnounce): Promise<void>;
     private openStream;
     start(): void;
     private tick;

package/dist/kernel/federation/peer-mesh.js

@@ -22,6 +22,11 @@ export class PeerMesh {
     async connect(url) {
         try {
             const manifest = await this.opts.client.fetchManifest(url);
+            // A hub may discover or seed its own advertised address. Never add self
+            // as a peer: it duplicates the hub in fleet status and can create a
+            // pointless self-stream/update loop.
+            if (manifest.nodeId === this.opts.self.nodeId)
+                return null;
             const peer = {
                 nodeId: manifest.nodeId,
                 displayName: manifest.displayName,
@@ -48,6 +53,17 @@ export class PeerMesh {
             return null;
         }
     }
+    /** Send a hub/relay version announcement to every currently connected peer. */
+    async announceUpdate(announce) {
+        await Promise.all(this.connected().map(async (peer) => {
+            try {
+                await this.opts.client.rpc(peer.url, envelope('update.announce', this.opts.self.nodeId, announce, { to: peer.nodeId }));
+            }
+            catch (err) {
+                this.opts.logger.warn(`[federation] update announce to ${peer.displayName} failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }));
+    }
     openStream(peer) {
         this.streams.get(peer.nodeId)?.(); // close any prior
         const stop = this.opts.client.openStream(peer.url, f => {

package/dist/kernel/federation/self-update.js

@@ -35,7 +35,22 @@ export async function performSelfUpdate(opts = {}) {
     try {
         // Use npm.cmd on Windows so we never need a shell (no injection surface).
         const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-        const res = await execa(bin, ['install', '-g', spec], { all: true, timeout: 300_000 });
+        const args = ['install', '-g', spec];
+        let res;
+        try {
+            res = await execa(bin, args, { all: true, timeout: 300_000 });
+        }
+        catch (err) {
+            const message = String(err.all ?? err.message ?? err);
+            const unprivileged = process.platform !== 'win32' && process.getuid?.() !== 0;
+            if (!unprivileged || !/\bEACCES\b|permission denied/i.test(message))
+                throw err;
+            // RoboPark systemd services normally run as root. This fallback also
+            // supports an operator-launched satellite when sudo is intentionally
+            // configured non-interactively; it never prompts or shells out.
+            info('[update] global npm directory is root-owned; retrying with sudo -n…');
+            res = await execa('sudo', ['-n', bin, ...args], { all: true, timeout: 300_000 });
+        }
         const tail = String(res.all ?? res.stdout ?? '').split('\n').filter(Boolean).slice(-2).join(' ').trim();
         info(`[update] installed ${spec}${tail ? ' — ' + tail : ''}`);
     }

package/dist/robopark/robot-runtime.js

@@ -8,7 +8,7 @@
  * it exits unexpectedly.
  */
 import { spawn } from 'node:child_process';
-import { existsSync, createWriteStream, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -50,8 +50,10 @@ function runtimeLog(label, foreground) {
     mkdirSync(logDir, { recursive: true });
     return [
         'ignore',
-        createWriteStream(join(logDir, `${label}.log`), { flags: 'a' }),
-        createWriteStream(join(logDir, `${label}.err.log`), { flags: 'a' }),
+        // spawn() accepts file descriptors, but not WriteStreams before their
+        // asynchronous open event. openSync makes detached startup reliable.
+        openSync(join(logDir, `${label}.log`), 'a'),
+        openSync(join(logDir, `${label}.err.log`), 'a'),
     ];
 }
 async function waitForVision() {
@@ -76,6 +78,7 @@ export async function roboparkRobotRuntime(opts) {
     const cli = roboparkCliPath();
     const children = [];
     let stopping = false;
+    let recycling = false;
     const infinicode = await resolveInfinicodeBin();
     if (!infinicode)
         throw new Error('could not resolve infinicode CLI');
@@ -84,7 +87,7 @@ export async function roboparkRobotRuntime(opts) {
         command: infinicode.node,
         args: [infinicode.script, 'serve', '--role', 'satellite', '--name', opts.name,
             '--port', port, '--token', opts.token, '--seed', opts.hubUrl,
-            network === 'tailscale' ? '--tailscale' : '--lan', '--auto-update'],
+            network === 'tailscale' ? '--tailscale' : '--lan', '--auto-update', '--supervised'],
     });
     if (opts.vision !== false) {
         children.push({
@@ -114,11 +117,64 @@ export async function roboparkRobotRuntime(opts) {
             entry.child = undefined;
             if (stopping)
                 return;
+            // A clean mesh exit is how /update signals that npm replaced this
+            // package. Reload every child so the robot runs one coherent release.
+            if (entry.label === 'mesh' && code === 0) {
+                void recycleAfterMeshUpdate();
+                return;
+            }
+            if (recycling)
+                return;
             console.error(chalk.yellow(`  ${entry.label} exited (${signal ?? code ?? 'unknown'}); restarting in 5s`));
             setTimeout(() => { if (!stopping)
                 start(entry); }, RESTART_DELAY_MS);
         });
     };
+    const stopChild = async (entry) => {
+        const child = entry.child;
+        if (!child)
+            return;
+        await new Promise(resolve => {
+            const timer = setTimeout(resolve, 5_000);
+            child.once('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+    };
+    const recycleAfterMeshUpdate = async () => {
+        if (stopping || recycling)
+            return;
+        recycling = true;
+        console.log(chalk.dim('  mesh updated; restarting RoboVision and preview on the new package...'));
+        await Promise.all([...children.filter(entry => entry.label !== 'mesh'), preview].map(stopChild));
+        if (stopping)
+            return;
+        start(children[0]);
+        if (opts.vision !== false) {
+            start(children[1]);
+            if (!await waitForVision()) {
+                console.error(chalk.red('  RoboVision did not recover after the mesh update; retrying in 5s'));
+                // Stop the partially restarted stack before retrying. Otherwise a
+                // second mesh child would collide with the existing listener.
+                await Promise.all([...children, preview].map(stopChild));
+                recycling = false;
+                setTimeout(() => { if (!stopping)
+                    void recycleAfterMeshUpdate(); }, RESTART_DELAY_MS);
+                return;
+            }
+        }
+        start(preview);
+        recycling = false;
+        console.log(chalk.green('  robot runtime updated and healthy'));
+    };
     console.log(chalk.bold('\n  robopark robot up'));
     console.log(chalk.dim('  ' + '─'.repeat(52)));
     console.log(`  robot:     ${chalk.cyan(opts.name)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.56",
+  "version": "2.8.58",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",
@@ -74,7 +74,6 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@anthropic-ai/claude-code": "^2.1.207",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",