infinicode 2.3.4 → 2.3.6

package/dist/kernel/agents/backends/cli-backend.d.ts

@@ -0,0 +1,37 @@
+import type { AgentBackend, BackendId, BackendRunContext, BackendRunResult, BackendTask } from './types.js';
+/** Accumulator threaded through per-line parsing. */
+export interface CliParsed {
+    sessionId?: string;
+    content?: string;
+    isError?: boolean;
+}
+export interface CliBackendSpec {
+    id: BackendId;
+    displayName: string;
+    /** Binary name looked up on PATH (overridable via `binEnv`). */
+    bin: string;
+    /** argv for a fresh run. `prompt` already includes any role preamble. */
+    runArgs(prompt: string, task: BackendTask): string[];
+    /** argv to continue an existing session with a new message. */
+    resumeArgs?(sessionId: string, message: string, task: BackendTask): string[];
+    /** Parse one output line (or the whole raw output, as a fallback) into `acc`. */
+    parseLine(line: string, acc: CliParsed): void;
+    /** Extra process env. */
+    env?: NodeJS.ProcessEnv;
+    /** Env var overriding the binary path (e.g. INFINICODE_CLAUDE_BIN). */
+    binEnv?: string;
+    /** Env var of extra whitespace-split args appended to every invocation. */
+    extraArgsEnv?: string;
+}
+export declare class CliAgentBackend implements AgentBackend {
+    private spec;
+    readonly id: BackendId;
+    readonly displayName: string;
+    constructor(spec: CliBackendSpec);
+    private resolveBin;
+    available(): boolean;
+    private extraArgs;
+    run(task: BackendTask, ctx: BackendRunContext): Promise<BackendRunResult>;
+    send(sessionId: string, message: string, ctx: BackendRunContext): Promise<BackendRunResult>;
+    private exec;
+}

package/dist/kernel/agents/backends/cli-backend.js

@@ -0,0 +1,132 @@
+/**
+ * OpenKernel — Generic CLI agent backend
+ *
+ * Runs a third-party coding CLI (Claude Code / Codex / OpenCode) as the executor
+ * for a dispatched mesh task. Spawns the process, streams every stdout/stderr
+ * line up the mesh as a frame, and parses the CLI's output into a session id +
+ * final text so the run can be followed and (later) messaged again.
+ *
+ * A `CliBackendSpec` captures the per-CLI differences (binary, argv, parsing);
+ * everything else — spawning, streaming, cancellation — is shared here.
+ */
+import { spawn } from 'node:child_process';
+import { findExecutable } from './detect.js';
+export class CliAgentBackend {
+    spec;
+    id;
+    displayName;
+    constructor(spec) {
+        this.spec = spec;
+        this.id = spec.id;
+        this.displayName = spec.displayName;
+    }
+    resolveBin() {
+        const override = this.spec.binEnv ? process.env[this.spec.binEnv] : undefined;
+        if (override)
+            return override;
+        return findExecutable(this.spec.bin);
+    }
+    available() {
+        return this.resolveBin() !== null;
+    }
+    extraArgs() {
+        const raw = this.spec.extraArgsEnv ? process.env[this.spec.extraArgsEnv] : undefined;
+        return raw ? raw.split(/\s+/).filter(Boolean) : [];
+    }
+    async run(task, ctx) {
+        const prompt = task.prompt && ctx.rolePreamble ? `${ctx.rolePreamble}\n\n${task.prompt}` : task.prompt;
+        const argv = task.sessionId && this.spec.resumeArgs
+            ? this.spec.resumeArgs(task.sessionId, prompt, task)
+            : this.spec.runArgs(prompt, task);
+        return this.exec([...argv, ...this.extraArgs()], ctx);
+    }
+    async send(sessionId, message, ctx) {
+        const msg = ctx.rolePreamble ? `${ctx.rolePreamble}\n\n${message}` : message;
+        const task = { prompt: msg, sessionId };
+        const argv = this.spec.resumeArgs
+            ? this.spec.resumeArgs(sessionId, msg, task)
+            : this.spec.runArgs(msg, task);
+        return this.exec([...argv, ...this.extraArgs()], ctx);
+    }
+    exec(argv, ctx) {
+        return new Promise(resolve => {
+            const bin = this.resolveBin();
+            if (!bin) {
+                resolve({ status: 'failed', error: `${this.spec.bin} not found on PATH` });
+                return;
+            }
+            const child = spawn(bin, argv, {
+                cwd: ctx.cwd ?? process.cwd(),
+                env: { ...process.env, ...this.spec.env },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const acc = {};
+            let stdoutBuf = '';
+            let rawAll = '';
+            let stderrTail = '';
+            let settled = false;
+            const onAbort = () => {
+                try {
+                    child.kill();
+                }
+                catch { /* already gone */ }
+            };
+            ctx.signal?.addEventListener('abort', onAbort, { once: true });
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                ctx.signal?.removeEventListener('abort', onAbort);
+                resolve(result);
+            };
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                rawAll += chunk;
+                stdoutBuf += chunk;
+                let nl;
+                while ((nl = stdoutBuf.indexOf('\n')) >= 0) {
+                    const line = stdoutBuf.slice(0, nl).replace(/\r$/, '');
+                    stdoutBuf = stdoutBuf.slice(nl + 1);
+                    if (!line.trim())
+                        continue;
+                    try {
+                        this.spec.parseLine(line, acc);
+                    }
+                    catch { /* tolerant parsing */ }
+                    ctx.onFrame({ kind: 'log', text: line });
+                }
+            });
+            child.stderr.setEncoding('utf8');
+            child.stderr.on('data', (chunk) => {
+                stderrTail = (stderrTail + chunk).slice(-2000);
+                const trimmed = chunk.replace(/\s+$/, '');
+                if (trimmed)
+                    ctx.onFrame({ kind: 'log', text: trimmed });
+            });
+            child.on('error', err => finish({ status: 'failed', error: err.message }));
+            child.on('close', code => {
+                // Flush a trailing partial line.
+                if (stdoutBuf.trim()) {
+                    try {
+                        this.spec.parseLine(stdoutBuf.trim(), acc);
+                    }
+                    catch { /* ignore */ }
+                }
+                // Fallback for CLIs that pretty-print one multi-line JSON object.
+                if (!acc.content && !acc.sessionId && rawAll.trim()) {
+                    try {
+                        this.spec.parseLine(rawAll.trim(), acc);
+                    }
+                    catch { /* ignore */ }
+                }
+                const ok = !acc.isError && (code === 0 || !!acc.content);
+                finish({
+                    status: ok ? 'completed' : 'failed',
+                    sessionId: acc.sessionId,
+                    content: acc.content,
+                    error: ok ? undefined : (stderrTail.trim() || acc.content || `${this.spec.bin} exited with code ${code}`),
+                });
+            });
+        });
+    }
+}

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

@@ -0,0 +1,5 @@
+/** Absolute path to `bin` on PATH, or null if not found. */
+export declare function findExecutable(bin: string): string | null;
+export declare function hasExecutable(bin: string): boolean;
+/** Test hook — forget cached lookups. */
+export declare function clearExecutableCache(): void;

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';