infinicode 2.2.0 → 2.2.2

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

package/dist/commands/run.js

@@ -26,10 +26,21 @@ import { SilentLogger } from '../kernel/index.js';
 import { openAICompatBaseURL } from '../kernel/provider-url.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROMPT_ANIMATION_MAX_FRAMES = Math.min(ASCII_VIDEO_FRAMES.length, ASCII_VIDEO_FPS * 3);
-function resolveInfinicodeCommand() {
+/**
+ * Locate the bundled TUI binary, or null if it isn't shipped in this install.
+ * IMPORTANT: never fall back to spawning `infinicode` itself — that re-enters
+ * this default command and creates an infinite launch loop (the npm package
+ * ships the CLI/kernel only, without the large platform-specific TUI binary).
+ */
+function resolveTuiBinary() {
     const rootDir = resolve(__dirname, '..', '..');
-    const bundled = join(rootDir, 'bin', 'infinicode-tui.exe');
-    return existsSync(bundled) ? bundled : 'infinicode';
+    const names = process.platform === 'win32' ? ['infinicode-tui.exe'] : ['infinicode-tui'];
+    for (const name of names) {
+        const p = join(rootDir, 'bin', name);
+        if (existsSync(p))
+            return p;
+    }
+    return null;
 }
 function fitPromptFrameToTerminal(frame) {
     const columns = Math.max(1, (process.stdout.columns ?? 120) - 1);
@@ -345,27 +356,27 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     }
     console.log(chalk.dim('-'.repeat(40)));
     await renderPromptAnimation();
+    const tuiBinary = resolveTuiBinary();
+    if (!tuiBinary) {
+        console.log(chalk.yellow('\ninfinicode TUI is not bundled in this install.'));
+        console.log(chalk.dim('The npm package ships the kernel + device-mesh CLI only — the TUI binary is'));
+        console.log(chalk.dim('large and platform-specific, so it is not published. Use these instead:'));
+        console.log(chalk.cyan('  infinicode serve --hub          ') + chalk.dim('# run this device as a mesh node'));
+        console.log(chalk.cyan('  infinicode mcp                  ') + chalk.dim('# MCP control server for a harness'));
+        console.log(chalk.cyan('  infinicode mission run ...      ') + chalk.dim('# headless mission execution'));
+        console.log(chalk.cyan('  infinicode console              ') + chalk.dim('# slash-command console'));
+        console.log(chalk.dim('\nTo use the TUI, build it from source and place it in bin/ (infinicode-tui[.exe]).'));
+        process.exit(1);
+    }
     const { execa } = await import('execa');
-    const infinicodeCommand = resolveInfinicodeCommand();
     try {
-        if (infinicodeCommand === 'infinicode') {
-            await execa('which', ['infinicode']).catch(() => execa('where', ['infinicode']));
-        }
-        await execa(infinicodeCommand, [], {
+        await execa(tuiBinary, [], {
             stdio: 'inherit',
             env: process.env,
         });
     }
     catch (e) {
         const err = e;
-        if (err.code === 'ENOENT') {
-            console.log(chalk.yellow('\ninfinicode TUI binary not found.'));
-            console.log(chalk.dim('\nThe TUI requires the infinicode binary in bin/ or on PATH.'));
-            console.log(chalk.dim('Build from source:'));
-            console.log(chalk.cyan('  pnpm build'));
-            console.log();
-            process.exit(1);
-        }
         if (err.exitCode) {
             process.exit(err.exitCode);
         }

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/dist/kernel/federation/transport-http.d.ts

@@ -36,6 +36,8 @@ export declare class MeshClient {
     private opts;
     constructor(opts?: MeshClientOptions);
     private headers;
+    /** Normalize a base URL so a trailing slash doesn't produce `//fed/...` (→ 404). */
+    private base;
     fetchManifest(baseUrl: string): Promise<NodeManifest>;
     rpc(baseUrl: string, env: FederationEnvelope): Promise<FederationEnvelope>;
     /**

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

@@ -152,8 +152,12 @@ export class MeshClient {
             h['authorization'] = `Bearer ${this.opts.token}`;
         return h;
     }
+    /** Normalize a base URL so a trailing slash doesn't produce `//fed/...` (→ 404). */
+    base(baseUrl) {
+        return baseUrl.replace(/\/+$/, '');
+    }
     async fetchManifest(baseUrl) {
-        const res = await fetch(`${baseUrl}/fed/manifest`, {
+        const res = await fetch(`${this.base(baseUrl)}/fed/manifest`, {
             headers: this.headers(),
             signal: AbortSignal.timeout(this.opts.timeoutMs ?? 5000),
         });
@@ -162,7 +166,7 @@ export class MeshClient {
         return (await res.json());
     }
     async rpc(baseUrl, env) {
-        const res = await fetch(`${baseUrl}/fed/rpc`, {
+        const res = await fetch(`${this.base(baseUrl)}/fed/rpc`, {
             method: 'POST',
             headers: this.headers(),
             body: JSON.stringify(env),
@@ -180,7 +184,7 @@ export class MeshClient {
         const ctrl = new AbortController();
         (async () => {
             try {
-                const res = await fetch(`${baseUrl}/fed/stream`, {
+                const res = await fetch(`${this.base(baseUrl)}/fed/stream`, {
                     headers: this.headers(),
                     signal: ctrl.signal,
                 });

package/package.json

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