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

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/kernel/federation/federation.js

@@ -61,6 +61,7 @@ export class Federation {
             logger,
             getManifest: () => buildManifest(identity, this.deps.describe()),
             getNodes: () => this.nodeStatuses(),
+            runCommand: (input) => this.deps.kernel.command(input),
             onRpc: (env, remote) => this.onRpc(env, remote),
         });
         await this.server.start();

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

@@ -9,6 +9,9 @@ export interface MeshServerOptions {
     getManifest: () => NodeManifest;
     /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
     getNodes?: () => unknown;
+    /** Optional: run a kernel slash-command on this node (POST /fed/command).
+     *  Powers the in-TUI mesh command palette. */
+    runCommand?: (input: string) => Promise<unknown>;
     onRpc: RpcHandler;
     logger: Logger;
 }

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

@@ -78,6 +78,31 @@ export class MeshServer {
             this.openStream(req, res);
             return;
         }
+        if (req.method === 'POST' && url.startsWith('/fed/command')) {
+            if (!this.opts.runCommand) {
+                res.writeHead(404).end('no command handler');
+                return;
+            }
+            this.readBody(req)
+                .then(async (body) => {
+                let input = '';
+                try {
+                    input = JSON.parse(body).input ?? '';
+                }
+                catch {
+                    res.writeHead(400).end('bad json');
+                    return;
+                }
+                const result = await this.opts.runCommand(input);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(result ?? { ok: false, text: 'no result' }));
+            })
+                .catch(err => {
+                this.opts.logger.warn(`[federation] command error: ${err instanceof Error ? err.message : String(err)}`);
+                res.writeHead(500).end('command failed');
+            });
+            return;
+        }
         if (req.method === 'POST' && url.startsWith('/fed/rpc')) {
             this.readBody(req)
                 .then(async (body) => {

package/package.json

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