infinicode 2.3.5 → 2.4.0

package/dist/commands/serve.js

@@ -11,10 +11,25 @@
  */
 import chalk from 'chalk';
 import { readFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { buildKernelFromConfig, registerCloudProviders } from '../kernel/setup.js';
-import { Federation, MoltfedConnector, loadOrCreateIdentity } from '../kernel/index.js';
+import { Federation, MoltfedConnector, loadOrCreateIdentity, loadRole } from '../kernel/index.js';
+import { runMaintenanceTask, loadLastMaintenanceTask } from './maintain.js';
+/** ws(s):// gateway URL -> http(s):// base, for the plain-HTTP command poll
+ *  (the WS RPC channel is fire-and-forget, no request/response tracking —
+ *  simpler to poll a raw route than extend that channel to support it). */
+function httpBaseFromWsUrl(wsUrl) {
+    try {
+        const u = new URL(wsUrl);
+        u.protocol = u.protocol === 'wss:' ? 'https:' : 'http:';
+        return u.origin;
+    }
+    catch {
+        return null;
+    }
+}
 function pkgVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -24,12 +39,45 @@ function pkgVersion() {
         return '0.0.0';
     }
 }
+/** Read-only kernel commands — the only ones an unauthenticated, network-exposed
+ *  node will run. Control commands require a token (see commandGate below). */
+const READ_ONLY_COMMANDS = new Set([
+    '/status', '/nodes', '/activity', '/running', '/agents',
+    '/health', '/help', '/who', '/role', '/hardware', '/peers',
+]);
+function isLoopback(host) {
+    return host === '127.0.0.1' || host === 'localhost' || host === '::1';
+}
 export async function serve(config, opts) {
     const fed = config.get('federation') ?? {};
     const role = (opts.hub ? 'hub' : opts.role ?? fed.role ?? 'peer');
     const port = opts.port ? parseInt(opts.port, 10) : fed.port ?? 47913;
     const seeds = [...(fed.seeds ?? []), ...(opts.seed ?? [])];
-    const token = opts.token ?? fed.token;
+    const bindHost = opts.host ?? fed.host ?? '0.0.0.0';
+    let token = opts.token ?? fed.token;
+    // Secure-by-default: a control dashboard exposed on a routable interface with
+    // no token is a wide-open remote. If the operator asked for the dashboard but
+    // set no token, mint a session token so the surface isn't unauthenticated.
+    if (opts.dashboard && !token && !isLoopback(bindHost)) {
+        token = randomBytes(9).toString('base64url');
+        console.log(chalk.yellow(`  ⚠ dashboard exposed on ${bindHost} without --token — generated a session token.`));
+        console.log(chalk.yellow(`    peers must now connect with  --token ${token}`));
+    }
+    // Keep a network-exposed, tokenless node read-only: it will answer status/map
+    // queries but refuse control commands until a token is set. Loopback-only or
+    // token-protected nodes are trusted and run everything.
+    const trusted = Boolean(token) || isLoopback(bindHost);
+    const commandGate = (input) => {
+        if (trusted)
+            return { ok: true };
+        const name = input.trim().split(/\s+/)[0]?.toLowerCase() ?? '';
+        if (READ_ONLY_COMMANDS.has(name))
+            return { ok: true };
+        return {
+            ok: false,
+            reason: 'this node is network-exposed without a token — only read-only commands are allowed. Restart with --token <secret> to enable control commands.',
+        };
+    };
     const kernel = buildKernelFromConfig(config);
     const identity = loadOrCreateIdentity({ role, displayName: opts.name ?? fed.displayName });
     // Manifest inputs are read live from the kernel so the map shows real caps.
@@ -61,7 +109,26 @@ export async function serve(config, opts) {
             config.set('defaultModel', cfg.defaultModel);
         console.log(chalk.green(`  ✓ sourced shared config from hub (rev ${cfg.revision}) — ${live} provider(s) live`));
     };
-    const federation = new 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 = () => ({
+        cloudProviders: config.get('cloudProviders'),
+        policy: config.get('policy'),
+        defaultModel: config.get('defaultModel'),
+    });
+    // Dashboard "Apply config to fleet" / POST /fed/apply → re-publish shared
+    // config to every connected satellite right now (cross-process nudge: the
+    // serve daemon holds the mesh; the CLI can't reach satellites directly).
+    let federation;
+    const onApply = () => {
+        if (role === 'satellite') {
+            return { ok: false, text: 'this node is a satellite — it sources config from its hub, it does not publish.' };
+        }
+        const cfg = federation.publishConfig(sharedFromConf());
+        const n = federation.peers().filter(p => p.role === 'satellite').length;
+        return { ok: true, text: `published config rev ${cfg.revision} to the fleet (${n} satellite peer${n === 1 ? '' : 's'})` };
+    };
+    federation = new Federation({
         kernel,
         identity,
         describe,
@@ -75,17 +142,13 @@ export async function serve(config, opts) {
             autoUpdate: opts.autoUpdate ?? fed.autoUpdate,
             applyConfig,
             autoPullConfig: role === 'satellite',
+            dashboard: opts.dashboard,
+            onApply,
+            commandGate,
         },
     });
     // 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 = () => ({
-        cloudProviders: config.get('cloudProviders'),
-        policy: config.get('policy'),
-        defaultModel: config.get('defaultModel'),
-    });
     if (role !== 'satellite') {
         federation.publishConfig(sharedFromConf());
         for (const key of ['cloudProviders', 'policy', 'defaultModel']) {
@@ -101,6 +164,15 @@ export async function serve(config, opts) {
         console.log(`  auth:   ${chalk.green('token required')}`);
     console.log();
     await federation.start();
+    // Control dashboard link — prefer a reachable host over the 0.0.0.0 wildcard.
+    if (opts.dashboard) {
+        const uiHost = isLoopback(bindHost) || bindHost === '0.0.0.0' ? 'localhost' : bindHost;
+        const url = `http://${uiHost}:${port}/${token ? `?token=${token}` : ''}`;
+        console.log(chalk.bold(`  dashboard: ${chalk.cyan(url)}`));
+        if (!token)
+            console.log(chalk.dim('    (no token — anyone who can reach this port can control the fleet; add --token to lock it)'));
+        console.log();
+    }
     // Connect to seeds. Satellites auto-source shared config from any hub/relay
     // they connect to (handled inside federation.connect()).
     for (const url of seeds) {
@@ -119,7 +191,13 @@ export async function serve(config, opts) {
         console.log(chalk.green(`  ✓ LAN auto-discovery on (udp broadcast) — peers on this subnet connect automatically`));
     }
     // Optional: log this node into an InfiniBot gateway so it renders live on the
-    // neural-mesh map + hardware panels (no InfiniBot changes needed).
+    // fleet map + hardware panels via the infinibot-plugin-infinicode plugin.
+    // NOTE: these method names target that plugin's registered gateway methods,
+    // NOT InfiniBot's core nodes.status/hardware.snapshot/agent.event — those
+    // are claimed for InfiniBot's own paired-device list and internal satellite
+    // protocol respectively, and agent.event doesn't exist on the core gateway
+    // at all. Without the plugin installed on the target gateway, these pushes
+    // are harmless no-ops (unknown method).
     let connector;
     if (opts.gateway) {
         connector = new MoltfedConnector({
@@ -131,12 +209,75 @@ export async function serve(config, opts) {
             getNodeStatuses: () => federation.nodeStatuses(),
             getHardware: () => federation.latestHardware(),
             subscribeFrames: (cb) => federation.onFrames(cb),
+            methodNodes: 'infinicode.push.status',
+            methodHardware: 'infinicode.push.hardware',
+            methodAgent: 'infinicode.push.event',
         });
         connector.start();
         console.log(chalk.green(`  ✓ linking to InfiniBot gateway ${opts.gateway}`));
     }
+    // Optional: poll for on-demand commands queued from the InfiniBot Fleet
+    // view (e.g. "run maintenance now"). Plain HTTP GET against the plugin's
+    // own route — separate from the WS push channel above, which has no
+    // request/response tracking. No-op (empty list) until the operator
+    // actually queues something, so this is cheap to leave running.
+    let commandPoll;
+    const httpBase = opts.gateway ? httpBaseFromWsUrl(opts.gateway) : null;
+    if (httpBase) {
+        const pollUrl = `${httpBase}/plugins/infinicode/commands?nodeId=${encodeURIComponent(identity.nodeId)}`;
+        commandPoll = setInterval(() => {
+            void (async () => {
+                let commands;
+                try {
+                    const res = await fetch(pollUrl, { signal: AbortSignal.timeout(5000) });
+                    if (!res.ok)
+                        return;
+                    const body = await res.json();
+                    commands = body.commands ?? [];
+                }
+                catch {
+                    return; // gateway/plugin unreachable this cycle — try again next tick
+                }
+                if (!commands.length)
+                    return;
+                // The trigger carries no task content by design — replay ONLY the
+                // task this device already ran locally (cron/CLI), never anything
+                // network-supplied. See loadLastMaintenanceTask.
+                const cached = loadLastMaintenanceTask();
+                for (const cmd of commands) {
+                    if (cmd.kind !== 'run-last-maintenance')
+                        continue;
+                    if (!cached) {
+                        console.log(chalk.yellow('  ⚠ "run now" received but no maintenance task has ever run on this device — run `infinicode maintain "..."` once first'));
+                        connector?.request('infinicode.push.report', {
+                            nodeId: identity.nodeId,
+                            role: loadRole()?.role ?? identity.nodeId,
+                            site: loadRole()?.site,
+                            taskName: 'run-now (no task configured)',
+                            startedAt: Date.now(),
+                            finishedAt: Date.now(),
+                            durationMs: 0,
+                            ok: false,
+                            summary: 'no maintenance task has run on this device yet — run `infinicode maintain "..."` once to establish one',
+                        });
+                        continue;
+                    }
+                    console.log(chalk.cyan(`  ▸ re-running last maintenance task: ${cached.taskName ?? cached.taskPrompt.slice(0, 60)}`));
+                    const report = await runMaintenanceTask(kernel, cached.taskPrompt, {
+                        nodeId: identity.nodeId,
+                        role: loadRole(),
+                        taskName: cached.taskName,
+                    });
+                    connector?.request('infinicode.push.report', report);
+                    console.log(report.ok ? chalk.green('    ✓ done') : chalk.red('    ✗ failed'));
+                }
+            })();
+        }, 10_000);
+    }
     const shutdown = async () => {
         console.log(chalk.dim('\n  stopping mesh…'));
+        if (commandPoll)
+            clearInterval(commandPoll);
         connector?.stop();
         await federation.stop();
         kernel.destroy();

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

@@ -0,0 +1,41 @@
+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;
+    /** A directly-spawnable target — on Windows unwraps the npm shim to the real
+     *  executable so `spawn` (array args, no shell) works and multi-line prompts
+     *  survive intact. */
+    private resolveSpawn;
+    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,140 @@
+/**
+ * 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, resolveSpawnTarget } 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);
+    }
+    /** A directly-spawnable target — on Windows unwraps the npm shim to the real
+     *  executable so `spawn` (array args, no shell) works and multi-line prompts
+     *  survive intact. */
+    resolveSpawn() {
+        const override = this.spec.binEnv ? process.env[this.spec.binEnv] : undefined;
+        return resolveSpawnTarget(this.spec.bin, override);
+    }
+    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, ...(task.args ?? []), ...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 target = this.resolveSpawn();
+            if (!target) {
+                resolve({ status: 'failed', error: `${this.spec.bin} not found on PATH` });
+                return;
+            }
+            const child = spawn(target.command, [...target.prefixArgs, ...argv], {
+                cwd: ctx.cwd ?? process.cwd(),
+                env: { ...process.env, ...this.spec.env },
+                stdio: ['ignore', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+            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,17 @@
+/** 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;
+/** A directly-spawnable target: a command plus fixed leading args (e.g. node + a .js). */
+export interface SpawnTarget {
+    command: string;
+    prefixArgs: string[];
+}
+/**
+ * Resolve `bin` (or an explicit `override` path) to a directly-spawnable target.
+ * Non-Windows and real `.exe`/`.com` hits pass through untouched; Windows npm
+ * shims are unwrapped to the executable they delegate to. Returns null when
+ * nothing is found.
+ */
+export declare function resolveSpawnTarget(bin: string, override?: string): SpawnTarget | null;

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

@@ -0,0 +1,140 @@
+/**
+ * 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, readFileSync } from 'node:fs';
+import { join, delimiter, dirname } 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();
+}
+function substVars(token, dir) {
+    // sh launcher uses $basedir; cmd shim uses %dp0% / %~dp0%. Both = shim dir.
+    let t = token
+        .replace(/\$\{basedir\}|\$basedir/g, dir)
+        .replace(/%~?dp0%\\?|%dp0%\\?/gi, dir + '\\');
+    if (process.platform === 'win32')
+        t = t.replace(/\//g, '\\').replace(/\\{2,}/g, '\\');
+    return t;
+}
+function tokenizeShellish(s) {
+    const out = [];
+    let cur = '';
+    let quoted = false;
+    let has = false;
+    for (const ch of s) {
+        if (ch === '"') {
+            quoted = !quoted;
+            has = true;
+            continue;
+        }
+        if (!quoted && /\s/.test(ch)) {
+            if (has) {
+                out.push(cur);
+                cur = '';
+                has = false;
+            }
+            continue;
+        }
+        cur += ch;
+        has = true;
+    }
+    if (has)
+        out.push(cur);
+    return out;
+}
+function mapCommand(token) {
+    // A bare `node` / `node.exe` invocation → the running interpreter, which is
+    // guaranteed present and avoids a second PATH lookup.
+    const base = token.replace(/\\/g, '/').split('/').pop()?.toLowerCase();
+    if (base === 'node' || base === 'node.exe')
+        return process.execPath;
+    return token;
+}
+/**
+ * Read an npm shim and extract the real executable it invokes.
+ * Handles the `#!/bin/sh` launcher (`exec "<prog>" [args] "$@"`) and the simple
+ * `.cmd` form (`"<prog>" [args] %*`). Returns a SpawnTarget or null.
+ */
+function unwrapNpmShim(shimPath) {
+    let text;
+    try {
+        text = readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const dir = dirname(shimPath);
+    // sh launcher: the operative line is `exec <prog> [fixed args] "$@"`.
+    const sh = text.match(/^\s*exec\s+(.*?)\s+"\$@"\s*$/m);
+    if (sh) {
+        const toks = tokenizeShellish(sh[1]).map(t => substVars(t, dir)).filter(Boolean);
+        if (toks.length) {
+            const [cmd, ...rest] = toks;
+            return { command: mapCommand(cmd), prefixArgs: rest };
+        }
+    }
+    // .cmd shim: the last line ending in `%*` carries the quoted target + args.
+    for (const line of text.split(/\r?\n/).reverse()) {
+        if (!/%\*/.test(line))
+            continue;
+        const quoted = [...line.matchAll(/"([^"]*)"/g)]
+            .map(m => substVars(m[1], dir))
+            .filter(t => t && !t.includes('%'));
+        if (quoted.length) {
+            const [cmd, ...rest] = quoted;
+            return { command: mapCommand(cmd), prefixArgs: rest };
+        }
+    }
+    return null;
+}
+/**
+ * Resolve `bin` (or an explicit `override` path) to a directly-spawnable target.
+ * Non-Windows and real `.exe`/`.com` hits pass through untouched; Windows npm
+ * shims are unwrapped to the executable they delegate to. Returns null when
+ * nothing is found.
+ */
+export function resolveSpawnTarget(bin, override) {
+    const hit = override || findExecutable(bin);
+    if (!hit)
+        return null;
+    if (process.platform !== 'win32')
+        return { command: hit, prefixArgs: [] };
+    const lower = hit.toLowerCase();
+    if (lower.endsWith('.exe') || lower.endsWith('.com'))
+        return { command: hit, prefixArgs: [] };
+    const unwrapped = unwrapNpmShim(hit);
+    if (unwrapped && existsSync(unwrapped.command))
+        return unwrapped;
+    return { command: hit, prefixArgs: [] };
+}

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;