infinicode 2.2.1 → 2.2.3

package/dist/cli.js

@@ -14,8 +14,9 @@ import { providersList, providersAdd, providersRemove, providersTest } from './c
 import { consoleRepl, consoleRun } from './commands/console.js';
 import { serve } from './commands/serve.js';
 import { mcpCommand } from './commands/mcp.js';
+import { installTui } from './commands/install-tui.js';
 import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.2.1';
+const VERSION = '2.2.3';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -296,6 +297,16 @@ program
     .action(async (opts) => {
     await serve(config, opts);
 });
+// ── infinicode: install the TUI binary into this install ───────────────────
+program
+    .command('install-tui')
+    .description('Download/copy the TUI binary into this install so bare `infinicode` can launch it')
+    .option('--from <path>', 'copy the TUI binary from a local path')
+    .option('--url <url>', 'download the TUI binary from a URL (or set INFINICODE_TUI_URL)')
+    .option('--force', 'reinstall even if a TUI binary is already present')
+    .action(async (opts) => {
+    await installTui({ ...opts, url: opts.url ?? process.env.INFINICODE_TUI_URL });
+});
 // ── OpenKernel: MCP control server (stdio) ─────────────────────────────────
 program
     .command('mcp')

package/dist/commands/install-tui.d.ts

@@ -0,0 +1,6 @@
+export interface InstallTuiOptions {
+    from?: string;
+    url?: string;
+    force?: boolean;
+}
+export declare function installTui(opts: InstallTuiOptions): Promise<void>;

package/dist/commands/install-tui.js

@@ -0,0 +1,96 @@
+/**
+ * infinicode install-tui — fetch the TUI binary into this install's bin/.
+ *
+ * The npm package ships the kernel + device-mesh CLI only (the TUI binary is
+ * large + platform-specific, so it is not published). This command puts the
+ * right TUI binary in place so bare `infinicode` can launch it:
+ *
+ *   infinicode install-tui                       # auto-find a local copy (repo / OneDrive)
+ *   infinicode install-tui --from C:\path\tui.exe
+ *   infinicode install-tui --url https://host/infinicode-tui.exe
+ *
+ * It never fails the way the old launcher did (no loop) — it either installs the
+ * binary or prints exactly how to provide one.
+ */
+import { existsSync, copyFileSync, mkdirSync, renameSync, chmodSync, statSync, createWriteStream } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import chalk from 'chalk';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Platform-specific TUI binary filename. */
+function tuiName() {
+    return process.platform === 'win32' ? 'infinicode-tui.exe' : 'infinicode-tui';
+}
+/** This install's bin/ dir (<pkg>/dist/commands → <pkg>/bin). */
+function targetBinDir() {
+    return resolve(__dirname, '..', '..', 'bin');
+}
+/** Common local locations to copy an existing TUI binary from. */
+function localCandidates(name, explicit) {
+    const home = homedir();
+    return [
+        explicit,
+        join(process.cwd(), 'bin', name),
+        join(home, 'OneDrive', 'Desktop', 'infinicode-main', 'bin', name),
+        join(home, 'Desktop', 'infinicode-main', 'bin', name),
+    ].filter((p) => Boolean(p));
+}
+async function download(url, dest) {
+    console.log(chalk.dim(`  downloading ${url} …`));
+    const res = await fetch(url, { redirect: 'follow' });
+    if (!res.ok || !res.body)
+        throw new Error(`download failed: HTTP ${res.status}`);
+    const tmp = `${dest}.download`;
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(tmp));
+    renameSync(tmp, dest);
+}
+function finalize(dest) {
+    if (process.platform !== 'win32') {
+        try {
+            chmodSync(dest, 0o755);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    const mb = (statSync(dest).size / 1024 / 1024).toFixed(1);
+    console.log(chalk.green(`  ✓ TUI installed → ${dest} (${mb} MB)`));
+    console.log(chalk.dim('  run it with: ') + chalk.cyan('infinicode'));
+}
+export async function installTui(opts) {
+    const name = tuiName();
+    const binDir = targetBinDir();
+    const dest = join(binDir, name);
+    console.log(chalk.bold('\n  infinicode · install TUI'));
+    console.log(chalk.dim('  ' + '-'.repeat(40)));
+    if (existsSync(dest) && !opts.force) {
+        console.log(chalk.green(`  ✓ already installed → ${dest}`));
+        console.log(chalk.dim('  reinstall with --force'));
+        return;
+    }
+    mkdirSync(binDir, { recursive: true });
+    // 1. Explicit URL (hosted release / mirror).
+    if (opts.url) {
+        await download(opts.url, dest);
+        finalize(dest);
+        return;
+    }
+    // 2. Copy from an explicit --from path or a known local/OneDrive location.
+    const src = localCandidates(name, opts.from).find(p => existsSync(p));
+    if (src) {
+        copyFileSync(src, dest);
+        console.log(chalk.dim(`  copied from ${src}`));
+        finalize(dest);
+        return;
+    }
+    // 3. Nothing found — tell the user exactly how to provide one.
+    console.log(chalk.yellow(`  no ${name} found to install.`));
+    console.log(chalk.dim('  provide one of:'));
+    console.log(chalk.cyan(`    infinicode install-tui --from "<path to ${name}>"`));
+    console.log(chalk.cyan(`    infinicode install-tui --url  "https://…/${name}"`));
+    console.log(chalk.dim('  (or set env INFINICODE_TUI_URL and re-run)'));
+    process.exit(1);
+}

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,29 @@ 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 get the TUI on this machine, run:'));
+        console.log(chalk.cyan('  infinicode install-tui          ') + chalk.dim('# auto-find a local copy (repo/OneDrive)'));
+        console.log(chalk.cyan('  infinicode install-tui --url <url>') + chalk.dim(' # or download from a hosted binary'));
+        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/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.1",
+  "version": "2.2.3",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",