infinicode 2.5.1 → 2.6.1

package/dist/kernel/federation/federation.js

@@ -4,6 +4,7 @@ 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 { performSelfUpdate } from './self-update.js';
 import { ComputeRouter } from './compute-router.js';
 import { TelemetryCollector, loadFromSnapshot, selfNodeStatus, nodeStatusFromPeer } from './telemetry.js';
 import { buildManifest } from './node-identity.js';
@@ -58,6 +59,17 @@ export class Federation {
             version: deps.options.version,
             logger: deps.logger,
             enabled: deps.options.autoUpdate,
+            // Apply the announced update (npm install + supervised restart). Only ever
+            // reached for announces from a hub/relay with auto-update enabled — see
+            // AutoUpdate.onAnnounce. Supervision is read from INFINICODE_SUPERVISED.
+            applyUpdate: async (announce) => {
+                await performSelfUpdate({
+                    version: announce.version,
+                    channel: announce.channel === 'git' ? 'git' : 'npm',
+                    currentVersion: deps.options.version,
+                    logger: deps.logger,
+                });
+            },
         });
     }
     get identity() {

package/dist/kernel/federation/self-update.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '../types.js';
+export interface SelfUpdateOptions {
+    /** Target version — 'latest' or a semver like '2.6.1'. Default 'latest'. */
+    version?: string;
+    /** npm package to install. Default 'infinicode' (override via INFINICODE_UPDATE_PKG). */
+    pkg?: string;
+    channel?: 'npm' | 'git' | 'manual';
+    /** The version currently running, for the from→to report. */
+    currentVersion?: string;
+    /** Node runs under a supervisor → safe to exit-for-restart. Falls back to
+     *  INFINICODE_SUPERVISED=1. */
+    supervised?: boolean;
+    /** Schedule a restart after a successful install. Defaults to `supervised`. */
+    restart?: boolean;
+    /** Delay before exiting so the command reply flushes back over the mesh. */
+    restartDelayMs?: number;
+    logger?: Logger;
+}
+export interface SelfUpdateResult {
+    ok: boolean;
+    from?: string;
+    to: string;
+    restarting: boolean;
+    message: string;
+}
+export declare function performSelfUpdate(opts?: SelfUpdateOptions): Promise<SelfUpdateResult>;

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

@@ -0,0 +1,68 @@
+/**
+ * OpenKernel — Self Update
+ *
+ * The apply side of mesh updates: install a newer npm release of this package
+ * globally, then (if the node runs under a process supervisor) exit so the
+ * supervisor relaunches it on the new version. Isolated here so the shell-out
+ * lives in exactly one place — the `/update` command and the AutoUpdate gossip
+ * path both call this, nothing else shells out for updates.
+ *
+ * Restart policy is deliberately conservative: a node only exits-for-restart
+ * when it is explicitly marked supervised (`serve --supervised`, which sets
+ * INFINICODE_SUPERVISED=1). An unsupervised node still installs the new version
+ * on disk but stays up on the old one, and says so — killing a hand-started
+ * process would just take the node offline with nothing to bring it back.
+ */
+import { execa } from 'execa';
+const SAFE_VERSION = /^[A-Za-z0-9._-]+$/; // 'latest', '2.6.1', 'next' — never a shell metachar
+const SAFE_PKG = /^[@A-Za-z0-9._/-]+$/;
+export async function performSelfUpdate(opts = {}) {
+    const version = (opts.version ?? 'latest').trim();
+    const pkg = (opts.pkg ?? process.env.INFINICODE_UPDATE_PKG ?? 'infinicode').trim();
+    const channel = opts.channel ?? 'npm';
+    const supervised = opts.supervised ?? process.env.INFINICODE_SUPERVISED === '1';
+    const restart = opts.restart ?? supervised;
+    const info = (m) => (opts.logger ? opts.logger.info(m) : console.log('  ' + m));
+    const warn = (m) => (opts.logger ? opts.logger.warn(m) : console.log('  ' + m));
+    if (channel !== 'npm') {
+        return { ok: false, to: version, restarting: false, message: `channel "${channel}" is not supported for self-update yet (npm only).` };
+    }
+    if (!SAFE_VERSION.test(version) || !SAFE_PKG.test(pkg)) {
+        return { ok: false, to: version, restarting: false, message: `refused: unsafe update spec "${pkg}@${version}".` };
+    }
+    const spec = `${pkg}@${version}`;
+    info(`[update] installing ${spec} (global)…`);
+    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 tail = String(res.all ?? res.stdout ?? '').split('\n').filter(Boolean).slice(-2).join(' ').trim();
+        info(`[update] installed ${spec}${tail ? ' — ' + tail : ''}`);
+    }
+    catch (err) {
+        const detail = err;
+        const message = (detail.all || detail.shortMessage || detail.message || String(err)).replace(/\s+/g, ' ').slice(0, 300);
+        warn(`[update] npm install failed: ${message}`);
+        return { ok: false, from: opts.currentVersion, to: version, restarting: false, message: `npm install -g ${spec} failed: ${message}` };
+    }
+    let restarting = false;
+    if (restart && supervised) {
+        restarting = true;
+        const delay = opts.restartDelayMs ?? 2000;
+        info(`[update] restarting in ${delay}ms for the supervisor to relaunch on ${version}…`);
+        const timer = setTimeout(() => process.exit(0), delay);
+        timer.unref?.();
+    }
+    else if (restart && !supervised) {
+        warn('[update] installed but NOT restarting — node is not marked supervised (start serve with --supervised). Restart it to activate.');
+    }
+    return {
+        ok: true,
+        from: opts.currentVersion,
+        to: version,
+        restarting,
+        message: restarting
+            ? `updated to ${spec} — restarting now; the supervisor will relaunch on the new version.`
+            : `updated to ${spec} on disk — restart the node to activate${supervised ? '' : ' (not supervised, so no auto-restart)'}.`,
+    };
+}

package/package.json

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