infinicode 2.3.5 → 2.3.6

package/dist/kernel/agents/backends/detect.js

@@ -0,0 +1,40 @@
+/**
+ * OpenKernel — Executable detection
+ *
+ * Dependency-free `which`: scan PATH (honoring PATHEXT on Windows) so a backend
+ * can advertise availability without spawning `--version`. Results are cached —
+ * a device's installed CLIs don't change mid-process.
+ */
+import { existsSync } from 'node:fs';
+import { join, delimiter } from 'node:path';
+const cache = new Map();
+/** Absolute path to `bin` on PATH, or null if not found. */
+export function findExecutable(bin) {
+    const cached = cache.get(bin);
+    if (cached !== undefined)
+        return cached;
+    const dirs = (process.env.PATH ?? '').split(delimiter).filter(Boolean);
+    const exts = process.platform === 'win32'
+        ? ['', ...(process.env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)]
+        : [''];
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            for (const cased of new Set([ext, ext.toLowerCase(), ext.toUpperCase()])) {
+                const full = join(dir, bin + cased);
+                if (existsSync(full)) {
+                    cache.set(bin, full);
+                    return full;
+                }
+            }
+        }
+    }
+    cache.set(bin, null);
+    return null;
+}
+export function hasExecutable(bin) {
+    return findExecutable(bin) !== null;
+}
+/** Test hook — forget cached lookups. */
+export function clearExecutableCache() {
+    cache.clear();
+}

package/dist/kernel/agents/backends/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OpenKernel — Agent Backends public API
+ *
+ * Pluggable executors for dispatched mesh tasks: the native kernel plus
+ * third-party coding CLIs (Claude Code / Codex / OpenCode).
+ */
+export type { AgentBackend, BackendId, BackendTask, BackendFrame, BackendRunContext, BackendRunResult, } from './types.js';
+export { CliAgentBackend } from './cli-backend.js';
+export type { CliBackendSpec, CliParsed } from './cli-backend.js';
+export { AgentBackendRegistry, createDefaultBackendRegistry, CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC, } from './registry.js';
+export { findExecutable, hasExecutable, clearExecutableCache } from './detect.js';

package/dist/kernel/agents/backends/index.js

@@ -0,0 +1,3 @@
+export { CliAgentBackend } from './cli-backend.js';
+export { AgentBackendRegistry, createDefaultBackendRegistry, CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC, } from './registry.js';
+export { findExecutable, hasExecutable, clearExecutableCache } from './detect.js';

package/dist/kernel/agents/backends/parse-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OpenKernel — Backend output parsing helpers
+ *
+ * Third-party CLIs emit different JSON shapes (and different versions change
+ * them), so parsing is deliberately defensive: try JSON, pull the common
+ * fields, and always fall back to raw text. Nothing here throws.
+ */
+export declare function tryJson(line: string): Record<string, unknown> | null;
+export declare function str(v: unknown): string | undefined;
+/** Append a line to an accumulating text body. */
+export declare function appendLine(acc: string | undefined, line: string): string;
+/**
+ * Pull assistant text out of a wide range of JSON event shapes:
+ * Anthropic/Claude content arrays, plain `content` strings, and the usual
+ * `text`/`response`/`result`/`message` fields other CLIs use.
+ */
+export declare function extractText(obj: Record<string, unknown>): string | undefined;
+/** Common session-id keys across the CLIs, plus a bare-UUID fallback. */
+export declare function extractSessionId(obj: Record<string, unknown>): string | undefined;
+export declare function sessionIdFromText(line: string): string | undefined;

package/dist/kernel/agents/backends/parse-utils.js

@@ -0,0 +1,72 @@
+/**
+ * OpenKernel — Backend output parsing helpers
+ *
+ * Third-party CLIs emit different JSON shapes (and different versions change
+ * them), so parsing is deliberately defensive: try JSON, pull the common
+ * fields, and always fall back to raw text. Nothing here throws.
+ */
+export function tryJson(line) {
+    const s = line.trim();
+    if (!s || (s[0] !== '{' && s[0] !== '['))
+        return null;
+    try {
+        const v = JSON.parse(s);
+        return v && typeof v === 'object' ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function str(v) {
+    return typeof v === 'string' && v.length ? v : undefined;
+}
+/** Append a line to an accumulating text body. */
+export function appendLine(acc, line) {
+    return acc ? `${acc}\n${line}` : line;
+}
+/**
+ * Pull assistant text out of a wide range of JSON event shapes:
+ * Anthropic/Claude content arrays, plain `content` strings, and the usual
+ * `text`/`response`/`result`/`message` fields other CLIs use.
+ */
+export function extractText(obj) {
+    const msg = obj.message;
+    const content = (msg?.content ?? obj.content);
+    if (Array.isArray(content)) {
+        const parts = content
+            .map(c => (c && typeof c === 'object' && c.type === 'text'
+            ? str(c.text)
+            : undefined))
+            .filter((t) => !!t);
+        if (parts.length)
+            return parts.join('');
+    }
+    if (typeof content === 'string' && content.length)
+        return content;
+    for (const k of ['text', 'response', 'result', 'output', 'answer']) {
+        const t = str(obj[k]);
+        if (t)
+            return t;
+    }
+    if (msg) {
+        const t = str(msg.text) ?? str(msg.content);
+        if (t)
+            return t;
+    }
+    return undefined;
+}
+const UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+/** Common session-id keys across the CLIs, plus a bare-UUID fallback. */
+export function extractSessionId(obj) {
+    return (str(obj.session_id) ??
+        str(obj.sessionID) ??
+        str(obj.sessionId) ??
+        str(obj.thread_id) ??
+        str(obj.conversation_id) ??
+        str(obj.session) ??
+        str(obj.id));
+}
+export function sessionIdFromText(line) {
+    const m = line.match(UUID_RE);
+    return m ? m[0] : undefined;
+}

package/dist/kernel/agents/backends/registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenKernel — Agent Backend registry + built-in CLI specs
+ *
+ * Holds the executors a node can route a task to. 'kernel' (the native path) is
+ * always present and handled inline by the Federation manager; the CLI backends
+ * are advertised only when their binary is actually installed, so the mesh's
+ * compute-router won't send a `claude` task to a node without Claude Code.
+ *
+ * Each CLI is invoked in headless / non-interactive mode. Flags are the stable
+ * public ones for each tool; a device can override the binary or append args via
+ * env (INFINICODE_<CLI>_BIN / INFINICODE_<CLI>_ARGS) without a code change.
+ */
+import type { AgentBackend, BackendId } from './types.js';
+import { type CliBackendSpec } from './cli-backend.js';
+declare const CLAUDE_SPEC: CliBackendSpec;
+declare const OPENCODE_SPEC: CliBackendSpec;
+declare const CODEX_SPEC: CliBackendSpec;
+export declare class AgentBackendRegistry {
+    private map;
+    register(backend: AgentBackend): this;
+    get(id: BackendId): AgentBackend | undefined;
+    /** True if this node can run `id` (the native kernel, or an installed CLI). */
+    has(id: BackendId): boolean;
+    all(): AgentBackend[];
+    /** Backend ids runnable here — 'kernel' plus every installed CLI. */
+    availableIds(): BackendId[];
+}
+/** Registry seeded with the built-in CLI backends (availability checked lazily). */
+export declare function createDefaultBackendRegistry(): AgentBackendRegistry;
+export { CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC };

package/dist/kernel/agents/backends/registry.js

@@ -0,0 +1,140 @@
+import { CliAgentBackend } from './cli-backend.js';
+import { tryJson, extractText, extractSessionId, sessionIdFromText } from './parse-utils.js';
+// ── Claude Code ──────────────────────────────────────────────────────────────
+// `claude -p` = headless print mode. stream-json emits JSONL: a system/init
+// object carrying session_id, assistant messages, then a terminal `result`.
+const CLAUDE_SPEC = {
+    id: 'claude',
+    displayName: 'Claude Code',
+    bin: 'claude',
+    binEnv: 'INFINICODE_CLAUDE_BIN',
+    extraArgsEnv: 'INFINICODE_CLAUDE_ARGS',
+    runArgs: prompt => [
+        '-p', prompt,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--dangerously-skip-permissions',
+    ],
+    resumeArgs: (sessionId, message) => [
+        '--resume', sessionId,
+        '-p', message,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--dangerously-skip-permissions',
+    ],
+    parseLine: (line, acc) => {
+        const obj = tryJson(line);
+        if (!obj)
+            return;
+        const sid = extractSessionId(obj);
+        if (sid)
+            acc.sessionId = sid;
+        if (obj.type === 'result') {
+            const t = extractText(obj);
+            if (t)
+                acc.content = t;
+            if (obj.is_error === true)
+                acc.isError = true;
+            if (typeof obj.subtype === 'string' && obj.subtype !== 'success')
+                acc.isError = true;
+        }
+    },
+};
+// ── OpenCode ─────────────────────────────────────────────────────────────────
+// `opencode run "<task>" --format json` — non-interactive, resumable by session.
+const OPENCODE_SPEC = {
+    id: 'opencode',
+    displayName: 'OpenCode',
+    bin: 'opencode',
+    binEnv: 'INFINICODE_OPENCODE_BIN',
+    extraArgsEnv: 'INFINICODE_OPENCODE_ARGS',
+    runArgs: (prompt, task) => [
+        'run', prompt,
+        '--format', 'json',
+        ...(task.model ? ['--model', task.model] : []),
+        '--dangerously-skip-permissions',
+    ],
+    resumeArgs: (sessionId, message, task) => [
+        'run', message,
+        '--format', 'json',
+        '--session', sessionId,
+        ...(task.model ? ['--model', task.model] : []),
+        '--dangerously-skip-permissions',
+    ],
+    parseLine: (line, acc) => {
+        const obj = tryJson(line);
+        if (!obj)
+            return;
+        const sid = extractSessionId(obj);
+        if (sid)
+            acc.sessionId ??= sid;
+        const t = extractText(obj);
+        if (t)
+            acc.content = t;
+        if (obj.error)
+            acc.isError = true;
+    },
+};
+// ── Codex ────────────────────────────────────────────────────────────────────
+// `codex exec "<prompt>"` = non-interactive. Output shape varies by version, so
+// parse defensively: JSON when present, otherwise accumulate text + sniff a UUID.
+const CODEX_SPEC = {
+    id: 'codex',
+    displayName: 'Codex',
+    bin: 'codex',
+    binEnv: 'INFINICODE_CODEX_BIN',
+    extraArgsEnv: 'INFINICODE_CODEX_ARGS',
+    runArgs: prompt => ['exec', prompt],
+    resumeArgs: (sessionId, message) => ['exec', 'resume', sessionId, message],
+    parseLine: (line, acc) => {
+        const obj = tryJson(line);
+        if (obj) {
+            const sid = extractSessionId(obj);
+            if (sid)
+                acc.sessionId ??= sid;
+            const t = extractText(obj);
+            if (t)
+                acc.content = t;
+            if (obj.error || obj.is_error === true)
+                acc.isError = true;
+            return;
+        }
+        const sid = sessionIdFromText(line);
+        if (sid)
+            acc.sessionId ??= sid;
+        acc.content = acc.content ? `${acc.content}\n${line}` : line;
+    },
+};
+export class AgentBackendRegistry {
+    map = new Map();
+    register(backend) {
+        this.map.set(backend.id, backend);
+        return this;
+    }
+    get(id) {
+        return this.map.get(id);
+    }
+    /** True if this node can run `id` (the native kernel, or an installed CLI). */
+    has(id) {
+        if (id === 'kernel')
+            return true;
+        const b = this.map.get(id);
+        return !!b && b.available();
+    }
+    all() {
+        return [...this.map.values()];
+    }
+    /** Backend ids runnable here — 'kernel' plus every installed CLI. */
+    availableIds() {
+        const cli = this.all().filter(b => b.available()).map(b => b.id);
+        return ['kernel', ...cli];
+    }
+}
+/** Registry seeded with the built-in CLI backends (availability checked lazily). */
+export function createDefaultBackendRegistry() {
+    return new AgentBackendRegistry()
+        .register(new CliAgentBackend(CLAUDE_SPEC))
+        .register(new CliAgentBackend(OPENCODE_SPEC))
+        .register(new CliAgentBackend(CODEX_SPEC));
+}
+export { CLAUDE_SPEC, OPENCODE_SPEC, CODEX_SPEC };

package/dist/kernel/agents/backends/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * OpenKernel — Agent Backend types
+ *
+ * A backend is *who actually runs a dispatched task* on a node. The mesh's
+ * default backend is the local kernel (`kernel.execute`), but a node can also
+ * run a third-party coding CLI — Claude Code, Codex, OpenCode — as the executor.
+ * That is what lets a task dispatched across the mesh be fulfilled by a real
+ * external agent, and (with a persisted session id) lets those agents be
+ * messaged again later.
+ *
+ * Everything here is transport-agnostic: the Federation manager owns spawning +
+ * streaming; a backend just knows how to drive one CLI and parse its output.
+ */
+import type { Capability } from '../../types.js';
+/** Identifier of a backend. 'kernel' is the built-in native path. */
+export type BackendId = 'kernel' | 'claude' | 'codex' | 'opencode' | (string & {});
+/** A unit of work handed to a backend. */
+export interface BackendTask {
+    prompt: string;
+    capabilities?: Capability[];
+    /** Optional model hint (provider/model or a CLI-native model id). */
+    model?: string;
+    /** Resume an existing CLI session instead of starting fresh. */
+    sessionId?: string;
+}
+/** A streamed activity fragment emitted while a backend runs. */
+export interface BackendFrame {
+    kind: 'log' | 'event' | 'output' | 'error';
+    text?: string;
+    data?: unknown;
+}
+/** Context passed to a backend run — where to stream, how to cancel. */
+export interface BackendRunContext {
+    runId: string;
+    /** Called for each activity fragment (streamed up the mesh SSE feed). */
+    onFrame: (frame: BackendFrame) => void;
+    /** Abort the underlying process. */
+    signal?: AbortSignal;
+    /** Working directory for the spawned CLI (defaults to process.cwd()). */
+    cwd?: string;
+    /** Persistent device role, prepended to the prompt so the agent is in-character. */
+    rolePreamble?: string;
+}
+/** Terminal result of a backend run. */
+export interface BackendRunResult {
+    status: 'completed' | 'failed';
+    /** The CLI's native session id — enables resume + later messaging. */
+    sessionId?: string;
+    /** Final assistant text, if captured. */
+    content?: string;
+    error?: string;
+}
+/** Drives one executor (a CLI or the native kernel). */
+export interface AgentBackend {
+    id: BackendId;
+    displayName: string;
+    /** True when this backend can run here (e.g. the CLI is on PATH). Sync + cheap. */
+    available(): boolean;
+    /** Run a task to completion, streaming frames along the way. */
+    run(task: BackendTask, ctx: BackendRunContext): Promise<BackendRunResult>;
+    /** Send a follow-up message into an existing session (mailbox — slice 2). */
+    send?(sessionId: string, message: string, ctx: BackendRunContext): Promise<BackendRunResult>;
+    /** Best-effort stop of a running session. */
+    stop?(sessionId: string): Promise<void>;
+}

package/dist/kernel/agents/backends/types.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/agents/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * OpenKernel — Agents public API
+ *
+ * How a task actually gets run on a node: the native kernel, or a third-party
+ * coding CLI acting as the executor (so a mesh-dispatched task can be fulfilled
+ * by Claude Code, Codex, or OpenCode).
+ */
+export * from './backends/index.js';

package/dist/kernel/agents/index.js

@@ -0,0 +1,8 @@
+/**
+ * OpenKernel — Agents public API
+ *
+ * How a task actually gets run on a node: the native kernel, or a third-party
+ * coding CLI acting as the executor (so a mesh-dispatched task can be fulfilled
+ * by Claude Code, Codex, or OpenCode).
+ */
+export * from './backends/index.js';

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

@@ -16,7 +16,8 @@ import { ConfigSync } from './config-sync.js';
 import { AutoUpdate } from './auto-update.js';
 import { ComputeRouter, type ComputeNeed } from './compute-router.js';
 import { type ManifestInputs } from './node-identity.js';
-import { type RoleContext, type RunRecord } from './types.js';
+import { type AgentHandle, type RoleContext, type RunRecord } from './types.js';
+import { AgentBackendRegistry, type BackendId } from '../agents/index.js';
 export interface DispatchTask {
     description: string;
     capabilities: Capability[];
@@ -26,6 +27,13 @@ export interface DispatchTask {
     /** When true, the receiving node auto-plans the goal into phases (a phased
      *  build) instead of running it as one atomic task. */
     autoPlan?: boolean;
+    /** Which executor should run this on the receiving node: 'kernel' (native,
+     *  default) or an installed CLI backend ('claude' | 'codex' | 'opencode'). */
+    agent?: BackendId;
+    /** Resume a specific CLI session on the receiving node instead of a fresh run. */
+    sessionId?: string;
+    /** Model hint passed to a CLI backend (provider/model or a CLI-native id). */
+    model?: string;
 }
 export interface FederationOptions {
     version: string;
@@ -50,6 +58,9 @@ export interface FederationDeps {
     describe: () => ManifestInputs;
     logger: Logger;
     options: FederationOptions;
+    /** Executors this node can run dispatched tasks on. Defaults to the native
+     *  kernel plus any installed coding CLIs (Claude Code / Codex / OpenCode). */
+    backends?: AgentBackendRegistry;
 }
 export declare class Federation {
     private deps;
@@ -70,6 +81,8 @@ export declare class Federation {
     readonly configSync: ConfigSync;
     readonly autoUpdate: AutoUpdate;
     readonly compute: ComputeRouter;
+    /** Executors available on this node (native kernel + installed CLIs). */
+    readonly backends: AgentBackendRegistry;
     /** Local subscribers to the merged mesh frame stream (for MCP stream_activity). */
     private frameSubs;
     /** Recent frames for catch-up. */
@@ -90,6 +103,13 @@ export declare class Federation {
     private runTask;
     /** Run a dispatched task in the background, updating its RunRecord + streaming. */
     private runTaskAsync;
+    /**
+     * Execute a dispatched task with a third-party CLI backend (Claude Code /
+     * Codex / OpenCode) instead of the native kernel. The backend's activity
+     * streams up the same mesh SSE feed (log/ev frames), and its native session id
+     * is captured on the RunRecord so the run can be followed and later messaged.
+     */
+    private runViaBackend;
     /**
      * Hand a task to the best-fit connected peer (compute-routed) or a named one.
      * Non-blocking by default — returns a runId to follow. Pass wait to block
@@ -122,6 +142,30 @@ export declare class Federation {
     awaitRun(runId: string, timeoutMs?: number): Promise<RunRecord>;
     /** Run a slash-command on a specific peer. */
     runCommandOn(nodeId: string, input: string): Promise<unknown>;
+    /**
+     * CLI agent sessions on THIS node — any run that used a CLI backend and
+     * captured a session id. Live while running, dormant (still resumable) once
+     * complete. Deduped by session, newest kept, so a session that's been messaged
+     * several times shows once.
+     */
+    localAgents(): AgentHandle[];
+    /** All messageable CLI agent sessions across the mesh (local + peers). */
+    agents(): Promise<AgentHandle[]>;
+    /** Resolve an address (`nodeId/sessionId`, a sessionId, or a runId) to a handle. */
+    private resolveAgent;
+    /**
+     * Message a CLI agent session — wherever it lives on the mesh. Resumes that
+     * exact session with the text (so the agent keeps its context) and returns a
+     * runId to follow the reply. This is how one CLI agent talks to another.
+     */
+    sendTo(address: string, text: string, opts?: {
+        wait?: boolean;
+        timeoutMs?: number;
+    }): Promise<{
+        runId: string;
+        nodeId: string;
+        record?: RunRecord;
+    } | null>;
     /** Hub: publish shared config (providers/API keys/policy) to the fleet. */
     publishConfig(cfg: Omit<SharedConfig, 'revision' | 'updatedAt'>): SharedConfig;
     /** Satellite: pull shared config from a peer (usually the hub). */
@@ -147,6 +191,15 @@ export declare class Federation {
      * new nodes that come online later are picked up too. Idempotent.
      */
     startLanDiscovery(tag?: string, discoveryPort?: number): void;
+    /** Backend ids this node can execute tasks with ('kernel' + installed CLIs). */
+    availableBackends(): BackendId[];
+    /**
+     * The manifest inputs augmented with `backend:<id>` capability tags for each
+     * installed executor. This lets the compute-router match a task that asks for
+     * a specific agent (e.g. capabilities:['backend:claude']) to a node that
+     * actually has that CLI — without changing the caller's describe().
+     */
+    private describeWithBackends;
     /** Neutral node-status list (self + peers) — feeds the mesh map. */
     nodeStatuses(): NodeStatus[];
     peers(): PeerInfo[];