infinicode 2.1.0 → 2.2.1

package/README.md

@@ -109,10 +109,12 @@ 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
+# verify the mesh — ask any running node for its peers (self + connected)
+curl http://localhost:47913/fed/nodes
 ```
 
+Set your cloud provider keys + policy **once on the hub**; every satellite auto-sources them (over `--seed`/`--lan`/`--tailscale`) and registers the providers + models live, no restart.
+
 Drive the fleet from an MCP host — register the control server (spawn / dispatch / follow / role / voice / mesh-map tools):
 
 ```jsonc

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.1.0';
+const VERSION = '2.2.1';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,

package/dist/commands/mcp.js

@@ -12,7 +12,7 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { buildKernelFromConfig } from '../kernel/setup.js';
+import { buildKernelFromConfig, registerCloudProviders } from '../kernel/setup.js';
 import { Federation, GoalLoop, loadOrCreateIdentity, serveMcpStdio, SilentLogger, } from '../kernel/index.js';
 function pkgVersion() {
     try {
@@ -51,21 +51,39 @@ export async function mcpCommand(config, opts) {
         };
     };
     const applyConfig = (cfg) => {
-        if (cfg.cloudProviders)
-            config.set('cloudProviders', cfg.cloudProviders);
-        if (cfg.policy)
+        let live = 0;
+        if (cfg.cloudProviders) {
+            const providers = cfg.cloudProviders;
+            config.set('cloudProviders', providers);
+            live = registerCloudProviders(kernel, providers); // live → models available now
+        }
+        if (cfg.policy) {
             config.set('policy', cfg.policy);
+            kernel.setDefaultPolicy(cfg.policy);
+        }
         if (cfg.defaultModel)
             config.set('defaultModel', cfg.defaultModel);
-        stderrLogger.info(`applied shared config (rev ${cfg.revision})`);
+        stderrLogger.info(`sourced shared config from hub (rev ${cfg.revision}) — ${live} provider(s) live`);
     };
     const federation = new Federation({
         kernel,
         identity,
         describe,
         logger: stderrLogger,
-        options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig },
+        options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig, autoPullConfig: role === 'satellite' },
     });
+    // Hub/peer/relay: publish local providers + policy for satellites to source.
+    const sharedFromConf = () => ({
+        cloudProviders: config.get('cloudProviders'),
+        policy: config.get('policy'),
+        defaultModel: config.get('defaultModel'),
+    });
+    if (role !== 'satellite') {
+        federation.publishConfig(sharedFromConf());
+        for (const key of ['cloudProviders', 'policy', 'defaultModel']) {
+            config.onDidChange(key, () => federation.publishConfig(sharedFromConf()));
+        }
+    }
     try {
         await federation.start();
     }

package/dist/commands/serve.js

@@ -13,7 +13,7 @@ import chalk from 'chalk';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { buildKernelFromConfig } from '../kernel/setup.js';
+import { buildKernelFromConfig, registerCloudProviders } from '../kernel/setup.js';
 import { Federation, MoltfedConnector, loadOrCreateIdentity } from '../kernel/index.js';
 function pkgVersion() {
     try {
@@ -44,15 +44,22 @@ export async function serve(config, opts) {
             providers: kernel.providerManager.listInfos().map(p => p.id),
         };
     };
-    // Satellite: persist shared config locally so providers/keys survive a restart.
+    // Satellite: persist shared config AND hot-apply it to the running kernel so
+    // the hub's providers + their models are available immediately (no restart).
     const applyConfig = (cfg) => {
-        if (cfg.cloudProviders)
-            config.set('cloudProviders', cfg.cloudProviders);
-        if (cfg.policy)
+        let live = 0;
+        if (cfg.cloudProviders) {
+            const providers = cfg.cloudProviders;
+            config.set('cloudProviders', providers);
+            live = registerCloudProviders(kernel, providers); // live registration → models appear now
+        }
+        if (cfg.policy) {
             config.set('policy', cfg.policy);
+            kernel.setDefaultPolicy(cfg.policy);
+        }
         if (cfg.defaultModel)
             config.set('defaultModel', cfg.defaultModel);
-        console.log(chalk.green(`  ✓ applied shared config (rev ${cfg.revision}) — restart to load new providers`));
+        console.log(chalk.green(`  ✓ sourced shared config from hub (rev ${cfg.revision}) — ${live} provider(s) live`));
     };
     const federation = new Federation({
         kernel,
@@ -67,8 +74,22 @@ export async function serve(config, opts) {
             heartbeatMs: (fed.heartbeatSec ?? 30) * 1000,
             autoUpdate: opts.autoUpdate ?? fed.autoUpdate,
             applyConfig,
+            autoPullConfig: role === 'satellite',
         },
     });
+    // Hub/peer/relay: publish this machine's providers + policy so satellites can
+    // auto-source them. Re-publish when the local config changes (live).
+    const sharedFromConf = () => ({
+        cloudProviders: config.get('cloudProviders'),
+        policy: config.get('policy'),
+        defaultModel: config.get('defaultModel'),
+    });
+    if (role !== 'satellite') {
+        federation.publishConfig(sharedFromConf());
+        for (const key of ['cloudProviders', 'policy', 'defaultModel']) {
+            config.onDidChange(key, () => federation.publishConfig(sharedFromConf()));
+        }
+    }
     console.log(chalk.bold(`\n  infinicode mesh node`));
     console.log(chalk.dim('  ' + '-'.repeat(46)));
     console.log(`  node:   ${chalk.cyan(identity.displayName)} ${chalk.dim('(' + identity.nodeId + ')')}`);
@@ -78,17 +99,12 @@ export async function serve(config, opts) {
         console.log(`  auth:   ${chalk.green('token required')}`);
     console.log();
     await federation.start();
-    // Connect to seeds and, as a satellite, pull shared config from the first hub.
+    // Connect to seeds. Satellites auto-source shared config from any hub/relay
+    // they connect to (handled inside federation.connect()).
     for (const url of seeds) {
         const peer = await federation.connect(url);
-        if (peer) {
+        if (peer)
             console.log(chalk.green(`  ✓ connected to ${peer.displayName} @ ${url}`));
-            if (role === 'satellite') {
-                const applied = await federation.pullConfig(peer.nodeId).catch(() => false);
-                if (applied)
-                    console.log(chalk.green(`  ✓ pulled shared config from ${peer.displayName}`));
-            }
-        }
     }
     // Optional: auto-discover peers over Tailscale (no --seed needed).
     if (opts.tailscale) {

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

@@ -11,7 +11,7 @@
  * (heartbeat / task.dispatch / command / config / update).
  */
 import type { Capability, KernelLike, Logger } from '../types.js';
-import type { HardwareSnapshot, NodeIdentity, NodeStatus, SharedConfig, StreamFrame } from './types.js';
+import type { HardwareSnapshot, NodeIdentity, NodeStatus, PeerInfo, SharedConfig, StreamFrame } from './types.js';
 import { ConfigSync } from './config-sync.js';
 import { AutoUpdate } from './auto-update.js';
 import { ComputeRouter, type ComputeNeed } from './compute-router.js';
@@ -36,6 +36,10 @@ export interface FederationOptions {
     autoUpdate?: boolean;
     /** 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. */
+    autoPullConfig?: boolean;
+    /** Satellite: how often to re-pull shared config (ms, default 30000; 0 disables). */
+    configPullMs?: number;
 }
 export interface FederationDeps {
     kernel: KernelLike;
@@ -57,6 +61,9 @@ export declare class Federation {
     private lan?;
     /** nodeIds we're currently dialing via LAN discovery (dedup guard). */
     private lanConnecting;
+    /** nodeIds we're currently dialing back after an inbound heartbeat/hello. */
+    private inboundConnecting;
+    private configPullTimer?;
     readonly configSync: ConfigSync;
     readonly autoUpdate: AutoUpdate;
     readonly compute: ComputeRouter;
@@ -109,7 +116,19 @@ export declare class Federation {
     publishConfig(cfg: Omit<SharedConfig, 'revision' | 'updatedAt'>): SharedConfig;
     /** Satellite: pull shared config from a peer (usually the hub). */
     pullConfig(nodeId: string): Promise<boolean>;
-    connect(url: string): Promise<import("./types.js").PeerInfo | null>;
+    connect(url: string): Promise<PeerInfo | null>;
+    /**
+     * Register an inbound peer that dialed US (learned from its heartbeat/hello),
+     * so dispatch works regardless of who connected first. The hub dials the
+     * sender back (→ full manifest + stream), making a satellite that only
+     * `--seed`s the hub visible + dispatchable. Gated: a satellite never dials
+     * back (accept-only, never dials home).
+     */
+    private learnInboundPeer;
+    /** Satellite: pull shared config from a freshly-connected hub/relay. */
+    private maybeAutoPull;
+    /** Satellite: re-pull from the first connected hub/relay (periodic refresh). */
+    private autoPullFromHub;
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     discoverAndConnect(tag?: string): Promise<number>;
     /**
@@ -120,7 +139,7 @@ export declare class Federation {
     startLanDiscovery(tag?: string, discoveryPort?: number): void;
     /** Neutral node-status list (self + peers) — feeds the mesh map. */
     nodeStatuses(): NodeStatus[];
-    peers(): import("./types.js").PeerInfo[];
+    peers(): PeerInfo[];
     /** Latest local hardware snapshot (for the MOLTFED connector / panels). */
     latestHardware(): HardwareSnapshot | undefined;
     /** Subscribe to the merged mesh frame stream (local + peer frames). */

package/dist/kernel/federation/federation.js

@@ -24,6 +24,9 @@ export class Federation {
     lan;
     /** nodeIds we're currently dialing via LAN discovery (dedup guard). */
     lanConnecting = new Set();
+    /** nodeIds we're currently dialing back after an inbound heartbeat/hello. */
+    inboundConnecting = new Set();
+    configPullTimer;
     configSync;
     autoUpdate;
     compute = new ComputeRouter();
@@ -57,6 +60,7 @@ export class Federation {
             token: options.token,
             logger,
             getManifest: () => buildManifest(identity, this.deps.describe()),
+            getNodes: () => this.nodeStatuses(),
             onRpc: (env, remote) => this.onRpc(env, remote),
         });
         await this.server.start();
@@ -66,6 +70,7 @@ export class Federation {
             logger,
             heartbeatMs: options.heartbeatMs,
             getLoad: () => loadFromSnapshot(this.lastHw),
+            selfPort: port,
             onFrame: (peerId, f) => this.ingestFrame(peerId, f),
             onPeerChange: () => this.emitLocal('nd', frame('nd', identity.nodeId, this.nodeStatuses())),
         });
@@ -82,18 +87,25 @@ export class Federation {
             this.lastHw = this.telemetry.collect();
             this.server?.broadcast(frame('hw', identity.nodeId, this.lastHw));
         }, telMs);
-        // Connect to seed peers.
+        // Connect to seed peers (via this.connect so satellites auto-pull config).
         for (const url of options.seeds ?? [])
-            void this.mesh.connect(url);
+            void this.connect(url);
+        // Satellite: periodically re-pull shared config so hub changes (new
+        // providers/keys/policy) propagate without a reconnect.
+        if (options.autoPullConfig && options.configPullMs !== 0) {
+            this.configPullTimer = setInterval(() => void this.autoPullFromHub(), options.configPullMs ?? 30_000);
+        }
         logger.info(`[federation] node ${identity.displayName} (${identity.role}) online on :${port}`);
     }
     // ── Inbound RPC ────────────────────────────────────────────────────────────
-    async onRpc(env, _remote) {
+    async onRpc(env, remote) {
         const self = this.deps.identity.nodeId;
         switch (env.kind) {
             case 'heartbeat':
+                this.learnInboundPeer(env, remote);
                 return reply(env, 'ack', self, { load: loadFromSnapshot(this.lastHw) });
             case 'hello':
+                this.learnInboundPeer(env, remote);
                 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,
@@ -275,7 +287,54 @@ export class Federation {
         return false;
     }
     async connect(url) {
-        return this.mesh?.connect(url) ?? null;
+        const peer = (await this.mesh?.connect(url)) ?? null;
+        if (peer)
+            await this.maybeAutoPull(peer);
+        return peer;
+    }
+    /**
+     * Register an inbound peer that dialed US (learned from its heartbeat/hello),
+     * so dispatch works regardless of who connected first. The hub dials the
+     * sender back (→ full manifest + stream), making a satellite that only
+     * `--seed`s the hub visible + dispatchable. Gated: a satellite never dials
+     * back (accept-only, never dials home).
+     */
+    learnInboundPeer(env, remote) {
+        if (this.deps.identity.role === 'satellite')
+            return; // accept-only
+        const from = env.from;
+        if (!from || from === this.deps.identity.nodeId)
+            return;
+        if (this.mesh?.get(from))
+            return; // already tracked
+        if (this.inboundConnecting.has(from))
+            return; // dial in flight
+        const port = env.data?.port;
+        const ip = normalizeIp(remote);
+        if (!port || !ip)
+            return;
+        const url = `http://${ip}:${port}`;
+        this.inboundConnecting.add(from);
+        this.deps.logger.info(`[federation] learned inbound peer ${from} → dialing back ${url}`);
+        void this.connect(url)
+            .catch(() => { })
+            .finally(() => this.inboundConnecting.delete(from));
+    }
+    /** Satellite: pull shared config from a freshly-connected hub/relay. */
+    async maybeAutoPull(peer) {
+        if (!this.deps.options.autoPullConfig)
+            return;
+        if (peer.role !== 'hub' && peer.role !== 'relay')
+            return;
+        const applied = await this.pullConfig(peer.nodeId).catch(() => false);
+        if (applied)
+            this.deps.logger.info(`[federation] pulled shared config from ${peer.displayName}`);
+    }
+    /** Satellite: re-pull from the first connected hub/relay (periodic refresh). */
+    async autoPullFromHub() {
+        const hub = (this.mesh?.connected() ?? []).find(p => p.role === 'hub' || p.role === 'relay');
+        if (hub)
+            await this.maybeAutoPull(hub);
     }
     /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
     async discoverAndConnect(tag) {
@@ -283,7 +342,7 @@ export class Federation {
         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);
+            const peer = await this.connect(url);
             if (peer && peer.nodeId !== this.deps.identity.nodeId)
                 connected++;
         }
@@ -315,8 +374,7 @@ export class Federation {
                 if (this.lanConnecting.has(nodeId))
                     return; // dial in flight
                 this.lanConnecting.add(nodeId);
-                void this.mesh
-                    ?.connect(url)
+                void this.connect(url)
                     .then(p => {
                     if (p)
                         logger.info(`[federation] lan discovered ${p.displayName ?? name} @ ${url}`);
@@ -370,9 +428,24 @@ export class Federation {
         this.unsub?.();
         this.bridge?.stop();
         this.lan?.stop();
+        if (this.configPullTimer)
+            clearInterval(this.configPullTimer);
         if (this.telemetryTimer)
             clearInterval(this.telemetryTimer);
         this.mesh?.stop();
         await this.server?.stop();
     }
 }
+/** Strip IPv6-mapped prefixes so an inbound remoteAddress becomes a diallable IPv4 host. */
+function normalizeIp(remote) {
+    if (!remote)
+        return null;
+    let ip = remote.trim();
+    if (ip === '::1')
+        return '127.0.0.1';
+    if (ip.startsWith('::ffff:'))
+        ip = ip.slice(7);
+    if (ip.includes(':'))
+        return null; // raw IPv6 — skip (use --lan/--tailscale to dial proactively)
+    return ip;
+}

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

@@ -23,6 +23,8 @@ export interface PeerMeshOptions {
     onPeerChange?: () => void;
     /** Current local load 0–100, sent with heartbeats. */
     getLoad: () => number;
+    /** Our own mesh port — advertised in heartbeats so hubs can dial us back. */
+    selfPort?: number;
 }
 export declare class PeerMesh {
     private opts;

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

@@ -34,6 +34,11 @@ export class PeerMesh {
             };
             this.peers.set(peer.nodeId, peer);
             this.openStream(peer);
+            // Immediate heartbeat so the peer learns us (nodeId + port) right away —
+            // lets a hub register + dial us back without waiting a full heartbeat cycle.
+            void this.opts.client
+                .rpc(url, envelope('heartbeat', this.opts.self.nodeId, { load: this.opts.getLoad(), port: this.opts.selfPort }, { to: peer.nodeId }))
+                .catch(() => { });
             this.opts.logger.info(`[federation] connected to ${peer.displayName} (${peer.nodeId}) @ ${url}`);
             this.opts.onPeerChange?.();
             return peer;
@@ -67,7 +72,7 @@ export class PeerMesh {
         await Promise.all(this.list().map(async (peer) => {
             const t0 = Date.now();
             try {
-                await this.opts.client.rpc(peer.url, envelope('heartbeat', this.opts.self.nodeId, { load: this.opts.getLoad() }, { to: peer.nodeId }));
+                await this.opts.client.rpc(peer.url, envelope('heartbeat', this.opts.self.nodeId, { load: this.opts.getLoad(), port: this.opts.selfPort }, { to: peer.nodeId }));
                 peer.latencyMs = Date.now() - t0;
                 peer.lastSeenAt = Date.now();
                 if (!peer.connected) {

package/dist/kernel/federation/transport-http.d.ts

@@ -7,6 +7,8 @@ export interface MeshServerOptions {
     /** Optional shared token; requests must present it as Bearer auth. */
     token?: string;
     getManifest: () => NodeManifest;
+    /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
+    getNodes?: () => unknown;
     onRpc: RpcHandler;
     logger: Logger;
 }

package/dist/kernel/federation/transport-http.js

@@ -69,6 +69,11 @@ export class MeshServer {
             res.end(JSON.stringify(this.opts.getManifest()));
             return;
         }
+        if (req.method === 'GET' && url.startsWith('/fed/nodes')) {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify(this.opts.getNodes?.() ?? []));
+            return;
+        }
         if (req.method === 'GET' && url.startsWith('/fed/stream')) {
             this.openStream(req, res);
             return;

package/dist/kernel/setup.d.ts

@@ -6,8 +6,15 @@
 import type Conf from 'conf';
 import { Kernel } from '../kernel/index.js';
 import type { Logger } from '../kernel/index.js';
-import type { InfinicodeConfig } from './config-schema.js';
+import type { InfinicodeConfig, CloudProviderConfig } from './config-schema.js';
 export type { InfinicodeConfig, CloudProviderConfig, WorkerModelPref } from './config-schema.js';
+/**
+ * Register (or re-register) cloud providers on a live kernel from config.
+ * Used at build time and for satellite hot-apply of hub-shared config, so new
+ * providers + their models become available without a restart. Returns the
+ * count of enabled providers registered.
+ */
+export declare function registerCloudProviders(kernel: Kernel, cloudProviders: CloudProviderConfig[]): number;
 export declare function buildKernelFromConfig(config: Conf<InfinicodeConfig>, options?: {
     logger?: Logger;
 }): Kernel;

package/dist/kernel/setup.js

@@ -1,20 +1,13 @@
 import { Kernel, OllamaProvider, OpenAICompatibleProvider, GeminiProvider } from '../kernel/index.js';
 import { getProviderPreset } from './free-providers.js';
-export function buildKernelFromConfig(config, options) {
-    const masterUrl = config.get('masterUrl');
-    const tailscaleMasterUrl = config.get('tailscaleMasterUrl');
-    const defaultModel = config.get('defaultModel');
-    const ollamaOptions = {
-        id: 'ollama',
-        name: 'Ollama',
-        baseURL: masterUrl,
-        fallbackURL: tailscaleMasterUrl,
-        defaultModel,
-    };
-    const kernel = new Kernel({ loadBuiltinWorkers: true, logger: options?.logger });
-    kernel.registerProvider('ollama', new OllamaProvider(ollamaOptions));
-    // Register cloud providers
-    const cloudProviders = config.get('cloudProviders') ?? [];
+/**
+ * Register (or re-register) cloud providers on a live kernel from config.
+ * Used at build time and for satellite hot-apply of hub-shared config, so new
+ * providers + their models become available without a restart. Returns the
+ * count of enabled providers registered.
+ */
+export function registerCloudProviders(kernel, cloudProviders) {
+    let n = 0;
     for (const cfg of cloudProviders) {
         if (!cfg.enabled)
             continue;
@@ -28,6 +21,7 @@ export function buildKernelFromConfig(config, options) {
                 knownModels: preset?.knownModels ?? [],
             };
             kernel.registerProvider(cfg.id, new GeminiProvider(geminiOptions));
+            n++;
             continue;
         }
         const options = {
@@ -39,7 +33,25 @@ export function buildKernelFromConfig(config, options) {
             knownModels: preset?.knownModels ?? [],
         };
         kernel.registerProvider(cfg.id, new OpenAICompatibleProvider(options));
+        n++;
     }
+    return n;
+}
+export function buildKernelFromConfig(config, options) {
+    const masterUrl = config.get('masterUrl');
+    const tailscaleMasterUrl = config.get('tailscaleMasterUrl');
+    const defaultModel = config.get('defaultModel');
+    const ollamaOptions = {
+        id: 'ollama',
+        name: 'Ollama',
+        baseURL: masterUrl,
+        fallbackURL: tailscaleMasterUrl,
+        defaultModel,
+    };
+    const kernel = new Kernel({ loadBuiltinWorkers: true, logger: options?.logger });
+    kernel.registerProvider('ollama', new OllamaProvider(ollamaOptions));
+    // Register cloud providers
+    registerCloudProviders(kernel, config.get('cloudProviders') ?? []);
     // Apply per-worker model pins — the worker runtime honors them when routing.
     const workerModels = config.get('workerModels') ?? {};
     if (workerModels && Object.keys(workerModels).length > 0) {

package/package.json

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