infinicode 2.2.0 → 2.2.1

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

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

@@ -61,6 +61,8 @@ 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;
@@ -115,6 +117,14 @@ export declare class Federation {
     /** Satellite: pull shared config from a peer (usually the hub). */
     pullConfig(nodeId: string): Promise<boolean>;
     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). */

package/dist/kernel/federation/federation.js

@@ -24,6 +24,8 @@ 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;
@@ -68,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())),
         });
@@ -95,12 +98,14 @@ export class Federation {
         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,
@@ -287,6 +292,34 @@ export class Federation {
             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)
@@ -403,3 +436,16 @@ export class Federation {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.2.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",