@verax-ai/body 0.1.0 → 0.1.2

package/dist/doctor.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { indexCoverage, listPieceFiles } from "@verax-ai/proxy";
 import { loadConfig, isLoopbackHost } from "./config.js";
 import { pidAlive, readLockFile } from "./unlock.js";
 const SECRET_RE = /sk-|-----BEGIN|Bearer |eyJ[A-Za-z0-9_-]{10,}\./;
@@ -263,7 +264,51 @@ function heartbeatMaxMs(env) {
 }
 function evidenceChecks(stateDir, env) {
     const checks = [];
-    const src = countJsonl(join(stateDir, "decisions.jsonl"));
+    let pieces;
+    try {
+        pieces = listPieceFiles(stateDir);
+    }
+    catch (err) {
+        checks.push({ id: "ledger-manifest", level: "fail", detail: err.message });
+        return checks;
+    }
+    const srcLines = pieces.reduce((s, p) => s + countJsonl(p.decisions).lines, 0);
+    const decisionN = pieces.reduce((s, p) => s + (p.closed ? p.n : countJsonl(p.decisions).lines), 0);
+    if (decisionN > 0) {
+        const known = new Set(pieces.map((p) => p.id));
+        const cov = indexCoverage(stateDir);
+        if (cov === null) {
+            checks.push({
+                id: "ledger-index",
+                level: "fail",
+                detail: `index names 0 of ${decisionN} decisions; the next open rebuilds it, a running body misses the rest until then`,
+            });
+        }
+        else {
+            const ghost = [...cov.pieces].find((id) => !known.has(id));
+            if (ghost !== undefined) {
+                checks.push({
+                    id: "ledger-index",
+                    level: "fail",
+                    detail: `index names piece ${ghost} that the manifest does not`,
+                });
+            }
+            else if (cov.refs === decisionN) {
+                checks.push({
+                    id: "ledger-index",
+                    level: "ok",
+                    detail: `index names ${decisionN} of ${decisionN} decisions`,
+                });
+            }
+            else {
+                checks.push({
+                    id: "ledger-index",
+                    level: "fail",
+                    detail: `index names ${cov.refs} of ${decisionN} decisions; the next open rebuilds it, a running body misses the rest until then`,
+                });
+            }
+        }
+    }
     const hbPath = join(stateDir, "heartbeat.json");
     let hb = null;
     if (existsSync(hbPath)) {
@@ -274,7 +319,7 @@ function evidenceChecks(stateDir, env) {
             hb = null;
         }
     }
-    if (src.lines > 0 || hb) {
+    if (srcLines > 0 || hb) {
         if (!hb || typeof hb.atMs !== "number") {
             checks.push({
                 id: "heartbeat",
@@ -297,46 +342,58 @@ function evidenceChecks(stateDir, env) {
             });
         }
     }
-    // Both halves of the evidence are mirrored, so both are compared: an effects
-    // copy that quietly drops rows is the same silence as a missing decision copy.
-    const srcEffects = countJsonl(join(stateDir, "effects.jsonl"));
-    const copy = countJsonl(join(stateDir, "evidence-copy", "decisions.jsonl"));
-    const copyEffects = countJsonl(join(stateDir, "evidence-copy", "effects.jsonl"));
-    const anything = src.lines > 0 ||
-        srcEffects.lines > 0 ||
-        copy.lines > 0 ||
-        copyEffects.lines > 0 ||
-        copy.corrupt ||
-        copyEffects.corrupt;
-    if (anything) {
+    // Each piece is mirrored on its own, so a short copy on one piece is a fail
+    // even when another piece's copy still matches.
+    let anything = false;
+    let fail = null;
+    let decisionLines = 0;
+    let effectLines = 0;
+    for (const piece of pieces) {
+        const src = countJsonl(piece.decisions);
+        const srcEffects = countJsonl(piece.effects);
+        const copy = countJsonl(piece.copyDecisions);
+        const copyEffects = countJsonl(piece.copyEffects);
+        decisionLines += src.lines;
+        effectLines += srcEffects.lines;
+        const pieceAnything = src.lines > 0 ||
+            srcEffects.lines > 0 ||
+            copy.lines > 0 ||
+            copyEffects.lines > 0 ||
+            copy.corrupt ||
+            copyEffects.corrupt;
+        if (!pieceAnything)
+            continue;
+        anything = true;
+        if (fail)
+            continue;
         if (copy.corrupt || copyEffects.corrupt) {
-            checks.push({
+            fail = {
                 id: "evidence-copy",
                 level: "fail",
-                detail: `evidence-copy/${copy.corrupt ? "decisions" : "effects"}.jsonl is corrupt`,
-            });
+                detail: `evidence-copy piece ${piece.id} ${copy.corrupt ? "decisions" : "effects"}.jsonl is corrupt`,
+            };
         }
         else if (copy.lines < src.lines) {
-            checks.push({
+            fail = {
                 id: "evidence-copy",
                 level: "fail",
-                detail: `evidence copy is stale: ${copy.lines} lines behind source ${src.lines}`,
-            });
+                detail: `evidence copy is stale on piece ${piece.id}: ${copy.lines} lines behind source ${src.lines}`,
+            };
         }
         else if (copyEffects.lines < srcEffects.lines) {
-            checks.push({
+            fail = {
                 id: "evidence-copy",
                 level: "fail",
-                detail: `evidence copy is stale on effects: ${copyEffects.lines} effect line(s) behind source ${srcEffects.lines}`,
-            });
-        }
-        else {
-            checks.push({
-                id: "evidence-copy",
-                level: "ok",
-                detail: `evidence copy has ${copy.lines} decision line(s) and ${copyEffects.lines} effect line(s)`,
-            });
+                detail: `evidence copy is stale on piece ${piece.id} effects: ${copyEffects.lines} effect line(s) behind source ${srcEffects.lines}`,
+            };
         }
     }
+    if (anything) {
+        checks.push(fail ?? {
+            id: "evidence-copy",
+            level: "ok",
+            detail: `evidence copy has ${decisionLines} decision line(s) and ${effectLines} effect line(s)`,
+        });
+    }
     return checks;
 }

package/dist/downstream.d.ts

@@ -0,0 +1,28 @@
+import type { Principal, ToolCall, ToolResult } from "@verax-ai/proxy";
+export type DownstreamToolFn = (call: ToolCall, principal: Principal, ref?: string) => Promise<ToolResult>;
+export type DownstreamSpec = {
+    prefix: string;
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+};
+export type DownstreamTool = {
+    name: string;
+    fn: DownstreamToolFn;
+};
+export type DownstreamSession = {
+    prefix: string;
+    tools: readonly DownstreamTool[];
+    close(): Promise<void>;
+};
+export declare class DownstreamCallError extends Error {
+    readonly prefix: string;
+    readonly tool: string;
+    constructor(prefix: string, tool: string, cause?: unknown);
+}
+export declare function prefixedName(prefix: string, childName: string): string;
+export declare function extraToolNameOk(name: string): boolean;
+export declare function parseDownstreamJson(raw: string): DownstreamSpec;
+export declare function openDownstream(spec: DownstreamSpec): Promise<DownstreamSession>;

package/dist/downstream.js

@@ -0,0 +1,183 @@
+import { Readable } from "node:stream";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+const PREFIX_RE = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
+const CHILD_TOOL_RE = /^[A-Za-z][A-Za-z0-9._-]{0,63}$/;
+/** Prefixed name a caller may put on extraTools: `prefix.childName`. */
+const EXTRA_NAME_RE = /^[A-Za-z][A-Za-z0-9_-]{0,31}\.[A-Za-z][A-Za-z0-9._-]{0,63}$/;
+export class DownstreamCallError extends Error {
+    prefix;
+    tool;
+    constructor(prefix, tool, cause) {
+        const detail = cause instanceof Error ? cause.message : "call-failed";
+        super(`downstream-call-failed:${prefix}.${tool}:${detail}`);
+        this.name = "DownstreamCallError";
+        this.prefix = prefix;
+        this.tool = tool;
+        if (cause !== undefined)
+            this.cause = cause;
+    }
+}
+export function prefixedName(prefix, childName) {
+    return `${prefix}.${childName}`;
+}
+export function extraToolNameOk(name) {
+    return EXTRA_NAME_RE.test(name);
+}
+export function parseDownstreamJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("downstream-json-invalid");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("downstream-json-not-object");
+    }
+    const rec = parsed;
+    if (typeof rec.prefix !== "string" || !PREFIX_RE.test(rec.prefix)) {
+        throw new Error("downstream-prefix-invalid");
+    }
+    if (typeof rec.command !== "string" || rec.command.trim() === "") {
+        throw new Error("downstream-command-invalid");
+    }
+    const spec = { prefix: rec.prefix, command: rec.command };
+    if (rec.args !== undefined) {
+        if (!Array.isArray(rec.args) || rec.args.some((a) => typeof a !== "string")) {
+            throw new Error("downstream-args-invalid");
+        }
+        spec.args = rec.args;
+    }
+    if (rec.cwd !== undefined) {
+        if (typeof rec.cwd !== "string" || rec.cwd === "") {
+            throw new Error("downstream-cwd-invalid");
+        }
+        spec.cwd = rec.cwd;
+    }
+    if (rec.env !== undefined) {
+        if (rec.env === null || typeof rec.env !== "object" || Array.isArray(rec.env)) {
+            throw new Error("downstream-env-invalid");
+        }
+        const env = {};
+        for (const [k, v] of Object.entries(rec.env)) {
+            if (typeof v !== "string")
+                throw new Error("downstream-env-invalid");
+            env[k] = v;
+        }
+        spec.env = env;
+    }
+    if (rec.timeoutMs !== undefined) {
+        if (typeof rec.timeoutMs !== "number" || !Number.isInteger(rec.timeoutMs) || rec.timeoutMs <= 0) {
+            throw new Error("downstream-timeout-invalid");
+        }
+        spec.timeoutMs = rec.timeoutMs;
+    }
+    return spec;
+}
+// The SDK result is a union (current shape with an index signature, or the
+// legacy { toolResult } shape), so it is narrowed here rather than trusted.
+function asTextResult(raw) {
+    const rec = raw !== null && typeof raw === "object" ? raw : {};
+    const content = [];
+    const items = Array.isArray(rec.content) ? rec.content : [];
+    for (const item of items) {
+        if (item !== null &&
+            typeof item === "object" &&
+            item.type === "text" &&
+            typeof item.text === "string") {
+            content.push({ type: "text", text: item.text });
+            continue;
+        }
+        content.push({ type: "text", text: JSON.stringify(item) });
+    }
+    return {
+        content: content.length > 0 ? content : [{ type: "text", text: "" }],
+        isError: rec.isError === true,
+    };
+}
+async function shut(client, transport) {
+    await client.close().catch(() => undefined);
+    await transport.close().catch(() => undefined);
+}
+export async function openDownstream(spec) {
+    if (!PREFIX_RE.test(spec.prefix)) {
+        throw new Error("downstream-prefix-invalid");
+    }
+    if (spec.command.trim() === "") {
+        throw new Error("downstream-command-invalid");
+    }
+    const timeoutMs = spec.timeoutMs ?? 10_000;
+    // Safe inherit + operator overlay. Not process.env: that would copy
+    // VERAX_* tokens the body already holds.
+    const env = { ...getDefaultEnvironment(), ...(spec.env ?? {}) };
+    const transport = new StdioClientTransport({
+        command: spec.command,
+        args: spec.args,
+        cwd: spec.cwd,
+        env,
+        stderr: "pipe",
+    });
+    // The SDK types the pipe as Stream; only a Readable can be drained.
+    const stderr = transport.stderr;
+    if (stderr instanceof Readable)
+        stderr.resume();
+    const client = new Client({ name: "verax-downstream", version: "0.0.0" });
+    let listed;
+    try {
+        await client.connect(transport);
+        listed = await client.listTools();
+    }
+    catch (err) {
+        await shut(client, transport);
+        throw err;
+    }
+    const tools = [];
+    const seen = new Set();
+    for (const tool of listed.tools) {
+        if (!CHILD_TOOL_RE.test(tool.name)) {
+            await shut(client, transport);
+            throw new Error(`downstream-child-name-invalid:${tool.name}`);
+        }
+        const name = prefixedName(spec.prefix, tool.name);
+        if (seen.has(name)) {
+            await shut(client, transport);
+            throw new Error(`downstream-name-collision:${name}`);
+        }
+        seen.add(name);
+        const childName = tool.name;
+        tools.push({
+            name,
+            fn: async (call) => {
+                let raw;
+                try {
+                    // Mutation check: stub this call and the allow test expecting
+                    // "pong":true from the child goes red.
+                    raw = await client.callTool({ name: childName, arguments: call.arguments }, undefined, { timeout: timeoutMs });
+                }
+                catch (err) {
+                    throw new DownstreamCallError(spec.prefix, childName, err);
+                }
+                const result = asTextResult(raw);
+                if (result.isError) {
+                    throw new DownstreamCallError(spec.prefix, childName, textOf(result) || "isError");
+                }
+                return result;
+            },
+        });
+    }
+    let closed = false;
+    return {
+        prefix: spec.prefix,
+        tools,
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            await shut(client, transport);
+        },
+    };
+}
+function textOf(result) {
+    return result.content.map((c) => c.text).join("");
+}

package/dist/inputs-read.d.ts

@@ -1,3 +1,10 @@
+/**
+ * The inputs documents behind these decisions, keyed by ref, each checked
+ * against the hash its decision recorded. inputs.jsonl is written in the
+ * same order as decisions.jsonl, so the rows for a window of decisions sit
+ * near its end: the file is read from there, and the read stops once every
+ * ref has been seen. The newest row for a ref is the one that counts.
+ */
 export declare function matchingInputs(stateDir: string, decisions: {
     claims: {
         ref: string | null;

package/dist/inputs-read.js

@@ -1,57 +1,64 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { canonical } from "@cedulon/core";
+import { listPieceFiles, readLedgerTail } from "@verax-ai/proxy";
 function sha256Canonical(value) {
     return createHash("sha256").update(canonical(value), "utf8").digest("hex");
 }
+/**
+ * The inputs documents behind these decisions, keyed by ref, each checked
+ * against the hash its decision recorded. inputs.jsonl is written in the
+ * same order as decisions.jsonl, so the rows for a window of decisions sit
+ * near its end: the file is read from there, and the read stops once every
+ * ref has been seen. The newest row for a ref is the one that counts.
+ */
 export async function matchingInputs(stateDir, decisions) {
-    let text;
-    try {
-        text = await readFile(join(stateDir, "inputs.jsonl"), "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return {};
-        throw err;
-    }
-    const byRef = new Map();
-    for (const line of text.split("\n")) {
-        if (line === "")
-            continue;
-        const row = JSON.parse(line);
-        if (typeof row.ref === "string")
-            byRef.set(row.ref, row.inputs);
+    const wanted = new Map();
+    for (const d of decisions) {
+        if (d.claims.ref && typeof d.claims.inputsHash === "string")
+            wanted.set(d.claims.ref, d.claims.inputsHash);
     }
     const out = {};
-    for (const d of decisions) {
-        const ref = d.claims.ref;
-        if (!ref || typeof d.claims.inputsHash !== "string")
-            continue;
-        const doc = byRef.get(ref);
-        if (doc !== undefined && sha256Canonical(doc) === d.claims.inputsHash) {
-            out[ref] = doc;
-        }
+    if (wanted.size === 0)
+        return out;
+    const seen = new Set();
+    const pieces = [...listPieceFiles(stateDir)].reverse();
+    for (const piece of pieces) {
+        if (seen.size === wanted.size)
+            break;
+        await readLedgerTail(piece.inputs, (row) => {
+            if (typeof row.ref !== "string" || seen.has(row.ref))
+                return "skip";
+            const hash = wanted.get(row.ref);
+            if (hash === undefined)
+                return "skip";
+            seen.add(row.ref);
+            if (sha256Canonical(row.inputs) === hash)
+                out[row.ref] = row.inputs;
+            return seen.size === wanted.size ? "stop" : "skip";
+        });
     }
     return out;
 }
 export async function inputsPrincipal(stateDir, ref) {
-    let text;
-    try {
-        text = await readFile(join(stateDir, "inputs.jsonl"), "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return null;
-        throw err;
-    }
     let found = null;
-    for (const line of text.split("\n")) {
-        if (line === "")
-            continue;
-        const row = JSON.parse(line);
-        if (row.ref === ref)
-            found = row.inputs?.principal ?? null;
+    for (const piece of listPieceFiles(stateDir)) {
+        let text;
+        try {
+            text = await readFile(piece.inputs, "utf8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        for (const line of text.split("\n")) {
+            if (line === "")
+                continue;
+            const row = JSON.parse(line);
+            if (row.ref === ref)
+                found = row.inputs?.principal ?? null;
+        }
     }
     if (!found || typeof found.brain !== "string")
         return null;

package/dist/no-bypass-scan.js

@@ -26,6 +26,9 @@ const CREATE_REQUIRE = /\bcreateRequire\b/;
 const CONCAT_TOOLS = /["']\.\/to["']\s*\+\s*["']ols/;
 const CHILD = /\bchild_process\b/;
 const WORKER = /\bworker_threads\b/;
+// The SDK stdio client transport spawns a process without naming
+// child_process in this tree. Only src/downstream.ts may use it.
+const SDK_STDIO = /client\/stdio\.js|\bStdioClientTransport\b/;
 function lineAt(text, index) {
     return text.slice(0, index).split(/\n/).length;
 }
@@ -51,6 +54,8 @@ export function scanNoBypass(base = pkgRoot, extra = []) {
         const wiring = rel === "src/wiring.ts";
         // Desktop supervises issuer/body/panel. It is not a tool-call path.
         const desktop = rel === "src/desktop.ts";
+        // The downstream spike attaches one stdio MCP server. Not a tool-call path.
+        const downstream = rel === "src/downstream.ts";
         const originalLines = text.split(/\r?\n/);
         for (const match of text.matchAll(DYNAMIC_IMPORT)) {
             const index = match.index ?? 0;
@@ -89,6 +94,8 @@ export function scanNoBypass(base = pkgRoot, extra = []) {
                 push("child_process");
             if (WORKER.test(line))
                 push("worker_threads");
+            if (SDK_STDIO.test(line) && !downstream)
+                push("sdk-stdio-spawn");
         }
     }
     return hits;