infinicode 2.3.2 → 2.3.4

package/.opencode/plugins/mesh-commands.tsx

@@ -0,0 +1,139 @@
+/** @jsxImportSource @opentui/solid */
+/**
+ * infinicode — mesh command palette
+ *
+ * Adds the OpenKernel mesh/kernel slash-commands natively to the TUI's `/`
+ * command palette. Each command is dispatched to a LOCAL mesh node over HTTP
+ * (POST /fed/command → kernel.command()), so the same command surface exposed by
+ * `infinicode serve`'s console and the CLI is available right inside the TUI.
+ *
+ * The local node is started (or reused) by `infinicode run`, which injects:
+ *   INFINICODE_MESH_URL   e.g. http://127.0.0.1:47913
+ *   INFINICODE_MESH_TOKEN optional bearer token
+ *
+ * Argless commands (/nodes, /running, /activity, /whoami, /mesh-help) run
+ * immediately and show output in an alert. Arg-taking commands (/node, /build,
+ * /follow, /dispatch, /goal, /mission, /role) open a prompt first.
+ */
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { createBindingLookup } from "@opentui/keymap/extras"
+
+type CommandResult = { ok?: boolean; text?: string; data?: unknown }
+
+const meshUrl = () => (process.env.INFINICODE_MESH_URL ?? "http://127.0.0.1:47913").replace(/\/+$/, "")
+const meshToken = () => process.env.INFINICODE_MESH_TOKEN
+
+/** POST a slash-command to the local mesh node and return its CommandResult. */
+async function send(input: string): Promise<CommandResult> {
+  const token = meshToken()
+  try {
+    const res = await fetch(`${meshUrl()}/fed/command`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(token ? { authorization: `Bearer ${token}` } : {}),
+      },
+      body: JSON.stringify({ input }),
+      signal: AbortSignal.timeout(30_000),
+    })
+    if (!res.ok) return { ok: false, text: `mesh error ${res.status} — is a node running? (infinicode serve)` }
+    return (await res.json()) as CommandResult
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    return { ok: false, text: `no local mesh node reachable at ${meshUrl()} (${msg})` }
+  }
+}
+
+/** Render a CommandResult in a scrollable alert dialog. */
+function show(api: TuiPluginApi, title: string, res: CommandResult): void {
+  const DialogAlert = api.ui.DialogAlert
+  const message = (res.text && res.text.trim()) || (res.ok ? "(no output)" : "command failed")
+  api.ui.dialog.setSize("large")
+  api.ui.dialog.replace(() => (
+    <DialogAlert title={title} message={message} onConfirm={() => api.ui.dialog.clear()} />
+  ))
+}
+
+/** Run a fixed slash-command now and show the result. */
+function runNow(api: TuiPluginApi, title: string, input: string): void {
+  api.ui.toast({ variant: "info", title: "mesh", message: `${input} …`, duration: 1200 })
+  void send(input).then((res) => show(api, title, res))
+}
+
+/** Open a prompt, then dispatch `<slash> <entered args>`. */
+function runWithArgs(
+  api: TuiPluginApi,
+  title: string,
+  slash: string,
+  placeholder: string,
+): void {
+  const DialogPrompt = api.ui.DialogPrompt
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <DialogPrompt
+      title={title}
+      value=""
+      placeholder={placeholder}
+      onConfirm={(args: string) => {
+        api.ui.dialog.clear()
+        const input = args && args.trim() ? `${slash} ${args.trim()}` : slash
+        api.ui.toast({ variant: "info", title: "mesh", message: `${input} …`, duration: 1200 })
+        void send(input).then((res) => show(api, title, res))
+      }}
+      onCancel={() => api.ui.dialog.clear()}
+    />
+  ))
+}
+
+interface Spec {
+  name: string
+  slashName: string
+  title: string
+  /** if set, prompt for args first with this placeholder; else run immediately */
+  arg?: string
+  /** the underlying kernel slash-command (defaults to `/${slashName}`) */
+  cmd?: string
+}
+
+const SPECS: Spec[] = [
+  { name: "mesh_nodes", slashName: "nodes", title: "Mesh nodes" },
+  { name: "mesh_running", slashName: "running", title: "Running tasks" },
+  { name: "mesh_activity", slashName: "activity", title: "Mesh activity" },
+  { name: "mesh_whoami", slashName: "whoami", title: "This node" },
+  { name: "mesh_help", slashName: "mesh-help", title: "Mesh commands", cmd: "/help" },
+  { name: "mesh_node", slashName: "node", title: "Node control", arg: "<node> <message>", cmd: "/node" },
+  { name: "mesh_build", slashName: "build", title: "Phased build", arg: "<node> <goal>", cmd: "/build" },
+  { name: "mesh_dispatch", slashName: "dispatch", title: "Dispatch task", arg: "<node> <task>", cmd: "/dispatch" },
+  { name: "mesh_follow", slashName: "follow", title: "Follow run", arg: "<run-id>", cmd: "/follow" },
+  { name: "mesh_goal", slashName: "goal", title: "New goal", arg: "<goal description>", cmd: "/goal" },
+  { name: "mesh_mission", slashName: "mission", title: "Mission", arg: "<mission description>", cmd: "/mission" },
+  { name: "mesh_role", slashName: "role", title: "Set role", arg: "<role>", cmd: "/role" },
+]
+
+const tui: TuiPlugin = async (api, options) => {
+  if (options?.enabled === false) return
+  const keys = createBindingLookup({})
+
+  api.keymap.registerLayer({
+    commands: SPECS.map((s) => ({
+      name: s.name,
+      title: s.title,
+      category: "Mesh",
+      namespace: "palette" as const,
+      slashName: s.slashName,
+      run() {
+        const cmd = s.cmd ?? `/${s.slashName}`
+        if (s.arg) runWithArgs(api, s.title, cmd, s.arg)
+        else runNow(api, s.title, cmd)
+      },
+    })),
+    bindings: keys.gather("mesh.global", SPECS.map((s) => s.name)),
+  })
+}
+
+const plugin: TuiPluginModule & { id: string } = {
+  id: "infinicode-mesh-commands",
+  tui,
+}
+
+export default plugin

package/dist/cli.js

@@ -16,7 +16,7 @@ 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.3.2';
+const VERSION = '2.3.4';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,
@@ -291,6 +291,7 @@ program
     .option('--lan', 'auto-discover + connect peers on the same LAN via UDP broadcast (no seed/Tailscale needed)')
     .option('--lan-port <port>', 'UDP discovery port for --lan (default 47915)')
     .option('--tag <tag>', 'only discover peers carrying this tag (Tailscale ACL tag or LAN beacon tag)')
+    .option('--console', 'interactive slash-command console on the node (/nodes, /build, /activity …); on by default in a TTY')
     .option('--gateway <url>', 'link to an InfiniBot gateway (ws://host:18789) — appear on its neural-mesh map')
     .option('--gateway-token <token>', 'auth token for the InfiniBot gateway')
     .option('--gateway-password <password>', 'auth password for the InfiniBot gateway')

package/dist/commands/mcp.js

@@ -72,6 +72,8 @@ export async function mcpCommand(config, opts) {
         logger: stderrLogger,
         options: { version, port, token, autoUpdate: fed.autoUpdate, applyConfig, autoPullConfig: role === 'satellite' },
     });
+    // Let the kernel's slash-command surface reach the mesh (/nodes, /node, …).
+    kernel.attachFederation(federation);
     // Hub/peer/relay: publish local providers + policy for satellites to source.
     const sharedFromConf = () => ({
         cloudProviders: config.get('cloudProviders'),

package/dist/commands/run.js

@@ -16,14 +16,14 @@
  */
 import chalk from 'chalk';
 import ora from 'ora';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
 import { ASCII_VIDEO_FPS, ASCII_VIDEO_FRAMES } from '../ascii-video-animation.js';
 import { getProviderPreset } from '../kernel/free-providers.js';
 import { buildKernelFromConfig } from '../kernel/setup.js';
-import { SilentLogger } from '../kernel/index.js';
+import { SilentLogger, Federation, loadOrCreateIdentity } 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);
@@ -309,6 +309,81 @@ function ensureModelInjected(providers, providerId, modelId) {
     if (!p.models[modelId])
         p.models[modelId] = { name: modelId };
 }
+function runPkgVersion() {
+    try {
+        return JSON.parse(readFileSync(join(resolve(__dirname, '..', '..'), 'package.json'), 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Is a mesh node already listening at this URL? (e.g. a separate `infinicode serve`). */
+async function meshAlive(url, token) {
+    try {
+        const res = await fetch(`${url}/fed/manifest`, {
+            headers: token ? { authorization: `Bearer ${token}` } : undefined,
+            signal: AbortSignal.timeout(1500),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Make the TUI a mesh participant so the in-TUI slash commands (/nodes, /build,
+ * /activity …) have a local node to talk to. If a node is already running on the
+ * configured port (a separate `infinicode serve`), point the TUI at THAT one;
+ * otherwise start an in-process node for the session. Best-effort: on any
+ * failure the TUI still launches, just without the live mesh palette.
+ */
+async function startLocalMeshNode(config) {
+    if (process.env.INFINICODE_NO_MESH)
+        return null;
+    const fed = config.get('federation') ?? {};
+    const port = fed.port ?? 47913;
+    const token = fed.token;
+    const url = `http://127.0.0.1:${port}`;
+    try {
+        // Reuse an already-running node (don't double-bind the port).
+        if (await meshAlive(url, token))
+            return { url, token, stop: async () => { } };
+        const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+        const role = (fed.role ?? 'peer');
+        const identity = loadOrCreateIdentity({ role, displayName: fed.displayName });
+        const version = runPkgVersion();
+        const describe = () => {
+            const defs = kernel.workerRuntime.listRegisteredDefinitions();
+            return {
+                version,
+                capabilities: [...new Set(defs.flatMap(d => d.capabilities))],
+                workers: defs.map(d => d.type),
+                commands: kernel.commands.list().map(c => c.name),
+                providers: kernel.providerManager.listInfos().map(p => p.id),
+            };
+        };
+        const federation = new Federation({
+            kernel, identity, describe, logger: new SilentLogger(),
+            options: {
+                version, port, host: fed.host, token, seeds: fed.seeds,
+                autoPullConfig: role === 'satellite',
+            },
+        });
+        kernel.attachFederation(federation);
+        await federation.start();
+        if (fed.lan)
+            federation.startLanDiscovery(undefined, fed.lanPort);
+        for (const s of fed.seeds ?? [])
+            await federation.connect(s).catch(() => undefined);
+        return {
+            url, token,
+            stop: async () => { await federation.stop(); kernel.destroy(); },
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export async function runAgent(_masterUrl, _model, _useTui, config) {
     const masterUrl = await resolveConfiguredMasterUrl(config);
     const masterReachable = await isOllamaReachable(masterUrl);
@@ -316,6 +391,15 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     const cloudProviders = config.get('cloudProviders') ?? [];
     const enabledCloud = cloudProviders.filter(p => p.enabled);
     const policyName = config.get('policy') ?? 'balanced';
+    // Make this TUI session a mesh participant so the in-TUI slash commands
+    // (/nodes, /build, /activity, …) have a local node to talk to. Reuses a
+    // running `infinicode serve` if one is up, else starts an in-process node.
+    const mesh = await startLocalMeshNode(config);
+    if (mesh) {
+        process.env.INFINICODE_MESH_URL = mesh.url;
+        if (mesh.token)
+            process.env.INFINICODE_MESH_TOKEN = mesh.token;
+    }
     // One kernel pass: load every provider's full model catalog (in parallel) and
     // route the default model under the policy.
     const routeSpinner = ora('loading model catalog & routing...').start();
@@ -340,12 +424,23 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     const policy = config.get('policy') ?? 'local-first';
     const pinnedCount = Object.keys(config.get('workerModels') ?? {}).length;
     const routingInfo = `AUTO ${policy} ${providerCount}P ${pinnedCount}pins`;
+    // Runtime TUI plugin that adds the mesh slash-commands (/nodes, /build, …)
+    // to the `/` palette. Shipped in the package at .opencode/plugins; loaded via
+    // a file:// URL so it resolves regardless of the TUI's cwd. Only injected when
+    // a local mesh node is available (else the commands would have nothing to hit).
+    const pluginPaths = [];
+    if (mesh) {
+        const pluginFile = join(resolve(__dirname, '..', '..'), '.opencode', 'plugins', 'mesh-commands.tsx');
+        if (existsSync(pluginFile))
+            pluginPaths.push(pathToFileURL(pluginFile).href);
+    }
     process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
         $schema: 'https://opencode.ai/config.json',
         provider: providers,
         model: modelRef,
         small_model: modelRef,
         enabled_providers: Object.keys(providers),
+        ...(pluginPaths.length > 0 ? { plugin: pluginPaths } : {}),
         agent: {
             build: {
                 model: modelRef,
@@ -392,10 +487,12 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         });
     }
     catch (e) {
+        await mesh?.stop().catch(() => undefined);
         const err = e;
         if (err.exitCode) {
             process.exit(err.exitCode);
         }
         throw e;
     }
+    await mesh?.stop().catch(() => undefined);
 }

package/dist/commands/serve.d.ts

@@ -13,6 +13,7 @@ export interface ServeOptions {
     tag?: string;
     lan?: boolean;
     lanPort?: string;
+    console?: boolean;
     gateway?: string;
     gatewayToken?: string;
     gatewayPassword?: string;

package/dist/commands/serve.js

@@ -77,6 +77,8 @@ export async function serve(config, opts) {
             autoPullConfig: role === 'satellite',
         },
     });
+    // Let the kernel's slash-command surface reach the mesh (/nodes, /node, …).
+    kernel.attachFederation(federation);
     // 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 = () => ({
@@ -133,7 +135,6 @@ export async function serve(config, opts) {
         connector.start();
         console.log(chalk.green(`  ✓ linking to InfiniBot gateway ${opts.gateway}`));
     }
-    console.log(chalk.dim(`\n  mesh online — Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
     const shutdown = async () => {
         console.log(chalk.dim('\n  stopping mesh…'));
         connector?.stop();
@@ -143,6 +144,40 @@ export async function serve(config, opts) {
     };
     process.on('SIGINT', () => void shutdown());
     process.on('SIGTERM', () => void shutdown());
+    // Interactive slash-command console on the live mesh node: type /nodes,
+    // /build <node> <goal>, /activity, /running, /follow <id>, etc. Enabled with
+    // --console (or automatically when stdin is a TTY).
+    if (opts.console ?? process.stdin.isTTY) {
+        const { createInterface } = await import('node:readline');
+        console.log(chalk.dim(`\n  mesh online — slash-command console ready. Type /help or /nodes. Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
+        const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: chalk.cyan('mesh> ') });
+        rl.prompt();
+        rl.on('line', async (line) => {
+            const input = line.trim();
+            if (!input) {
+                rl.prompt();
+                return;
+            }
+            if (input === 'exit' || input === 'quit') {
+                await shutdown();
+                return;
+            }
+            rl.pause();
+            try {
+                const result = await kernel.command(input.startsWith('/') ? input : '/' + input);
+                console.log((result.ok ? chalk.reset : chalk.yellow)(result.text));
+            }
+            catch (err) {
+                console.log(chalk.red(err instanceof Error ? err.message : String(err)));
+            }
+            rl.resume();
+            rl.prompt();
+        });
+        rl.on('close', () => void shutdown());
+    }
+    else {
+        console.log(chalk.dim(`\n  mesh online — Ctrl-C to stop. Peers: ${federation.peers().length}\n`));
+    }
     // Keep the process alive.
     await new Promise(() => { });
 }

package/dist/kernel/capability-map.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenKernel — Capability Normalization
+ *
+ * Harness-friendly capability passing. A phase (from a harness like InfiniBot,
+ * or from the LLM planner) can name what it needs in natural terms — "backend",
+ * "ui", "testing", "devops" — and this maps them onto the kernel's canonical
+ * capability vocabulary so the router/worker-matcher understand them. Unknown
+ * terms fall back to a fuzzy canonical match, then to `reasoning`.
+ */
+import type { Capability } from './types.js';
+/** The kernel's canonical capability vocabulary (mirrors the Capability union). */
+export declare const CANONICAL_CAPABILITIES: Capability[];
+/**
+ * Normalize natural capability names to canonical capabilities. Accepts canonical
+ * names as-is, maps known synonyms, fuzzy-matches by substring, and guarantees a
+ * non-empty result (falls back to `['reasoning']`).
+ */
+export declare function normalizeCapabilities(input?: string[]): Capability[];

package/dist/kernel/capability-map.js

@@ -0,0 +1,84 @@
+/** The kernel's canonical capability vocabulary (mirrors the Capability union). */
+export const CANONICAL_CAPABILITIES = [
+    'coding', 'browser', 'vision', 'terminal', 'planning', 'reasoning', 'filesystem',
+    'search', 'crawl', 'ocr', 'review', 'summarize', 'citations', 'translation',
+    'documentation', 'architecture', 'verification', 'frontend', 'design',
+    'accessibility', 'dataviz', 'animation',
+];
+/** Natural-language / domain terms → canonical capabilities. */
+const SYNONYMS = {
+    // engineering domains
+    backend: ['coding', 'terminal', 'filesystem', 'reasoning'],
+    'back-end': ['coding', 'terminal', 'filesystem', 'reasoning'],
+    server: ['coding', 'terminal', 'filesystem'],
+    api: ['coding', 'reasoning'],
+    ui: ['frontend', 'design'],
+    ux: ['frontend', 'design', 'accessibility'],
+    'front-end': ['frontend', 'design'],
+    web: ['frontend', 'coding'],
+    fullstack: ['coding', 'frontend', 'filesystem'],
+    'full-stack': ['coding', 'frontend', 'filesystem'],
+    mobile: ['frontend', 'coding'],
+    // testing / quality
+    test: ['verification', 'review'],
+    tests: ['verification', 'review'],
+    testing: ['verification', 'review'],
+    qa: ['verification', 'review'],
+    security: ['review', 'reasoning'],
+    audit: ['review', 'reasoning'],
+    // planning / design
+    architect: ['architecture', 'planning', 'reasoning'],
+    plan: ['planning', 'reasoning'],
+    spec: ['planning', 'documentation'],
+    // data / research
+    research: ['search', 'crawl', 'summarize'],
+    data: ['dataviz', 'reasoning'],
+    db: ['coding', 'filesystem'],
+    database: ['coding', 'filesystem'],
+    ml: ['reasoning', 'coding'],
+    ai: ['reasoning', 'coding'],
+    // ops / misc
+    refactor: ['coding', 'review'],
+    debug: ['coding', 'reasoning', 'terminal'],
+    deploy: ['terminal', 'filesystem'],
+    devops: ['terminal', 'filesystem', 'coding'],
+    infra: ['terminal', 'filesystem'],
+    docs: ['documentation', 'summarize'],
+    translate: ['translation'],
+    a11y: ['accessibility'],
+    chart: ['dataviz'],
+    charts: ['dataviz'],
+    animate: ['animation'],
+    scrape: ['crawl', 'search'],
+};
+/**
+ * Normalize natural capability names to canonical capabilities. Accepts canonical
+ * names as-is, maps known synonyms, fuzzy-matches by substring, and guarantees a
+ * non-empty result (falls back to `['reasoning']`).
+ */
+export function normalizeCapabilities(input) {
+    const out = new Set();
+    const canon = new Set(CANONICAL_CAPABILITIES);
+    for (const raw of input ?? []) {
+        const key = String(raw).trim().toLowerCase();
+        if (!key)
+            continue;
+        if (canon.has(key)) {
+            out.add(key);
+            continue;
+        }
+        const mapped = SYNONYMS[key];
+        if (mapped) {
+            for (const c of mapped)
+                out.add(c);
+            continue;
+        }
+        // fuzzy: the term contains (or is contained by) a canonical token
+        const hit = CANONICAL_CAPABILITIES.find(c => key.includes(c) || c.includes(key));
+        if (hit)
+            out.add(hit);
+    }
+    if (out.size === 0)
+        out.add('reasoning');
+    return [...out];
+}

package/dist/kernel/checkpoint-engine.js

@@ -28,6 +28,13 @@ export class CheckpointEngine {
         // cap per-mission checkpoint files to prevent disk exhaustion
         this.pruneMission(mission.id);
         const id = nanoid(12);
+        // Persist the mission's recent event log + working memory so a resumed or
+        // crash-recovered long-running mission keeps its activity trail and context.
+        const logs = this.eventBus
+            .getHistory()
+            .filter(e => e.missionId === mission.id)
+            .slice(-200);
+        const memory = mission.metadata ? structuredClone(mission.metadata) : undefined;
         const checkpoint = {
             id,
             missionId: mission.id,
@@ -35,6 +42,8 @@ export class CheckpointEngine {
             workerStates,
             timestamp: Date.now(),
             reason,
+            logs,
+            memory,
         };
         const file = join(this.dir, `${mission.id}_${id}.json`);
         writeFileSync(file, JSON.stringify(checkpoint, null, 2), 'utf-8');

package/dist/kernel/command-system.d.ts

@@ -12,8 +12,11 @@
  */
 import type { Kernel } from './kernel.js';
 import type { CommandResult } from './types.js';
+import type { Federation } from './federation/federation.js';
 export interface CommandContext {
     kernel: Kernel;
+    /** The mesh node, when the kernel is running under `serve`/`mcp`. */
+    federation?: Federation;
     args: string[];
     raw: string;
 }