@verax-ai/body 0.2.0 → 0.2.1

package/dist/cli.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runApprove } from "./approve-cli.js";
+import { runDemo } from "./demo.js";
 import { desktopMain } from "./desktop.js";
 import { doctorExit, runDoctor } from "./doctor.js";
 import { runHalt } from "./halt.js";
@@ -18,6 +19,7 @@ Usage: verax <command> [options]
 
   (no command)         serve MCP over Streamable HTTP at /mcp on VERAX_BIND (default 127.0.0.1:8787)
   doctor [--json]      check the configuration this process would run with
+  demo [--keep]        run a loopback body against a temporary ledger and print what it recorded
   approve <args>       approve a waiting request from this machine
   operator <args>      enrol an operator and manage their passkeys
   reconcile <args>     compare the ledger against a statement
@@ -62,6 +64,14 @@ if (argv[0] === "--version" || argv[0] === "-v") {
     process.stdout.write(`${version()}\n`);
     process.exit(0);
 }
+if (argv[0] === "demo") {
+    process.exit(await runDemo(argv, process.env, {
+        stdout: process.stdout,
+        stderr: process.stderr,
+        stdin: process.stdin,
+        isTTY: Boolean(process.stdin.isTTY),
+    }));
+}
 if (argv[0] === "approve") {
     process.exit(await runApprove(argv));
 }

package/dist/demo.d.ts

@@ -0,0 +1,11 @@
+export type DemoIo = {
+    stdout: {
+        write(s: string): unknown;
+    };
+    stderr: {
+        write(s: string): unknown;
+    };
+    stdin: NodeJS.ReadableStream;
+    isTTY: boolean;
+};
+export declare function runDemo(argv: string[], env: NodeJS.ProcessEnv, io: DemoIo): Promise<number>;

package/dist/demo.js

@@ -0,0 +1,356 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { exportJWK, generateKeyPair, SignJWT } from "jose";
+import { verifyLedger } from "@verax-ai/proxy";
+import { runApprove } from "./approve-cli.js";
+import { listen } from "./server.js";
+const NOT_SHOWN = "Not shown here: data masking arrives with a downstream server such as Conarium; statement reconciliation needs a real statement (verax reconcile).";
+const AUDIENCE = "http://127.0.0.1/verax-demo";
+const KID = "demo";
+const TOKEN_TTL_SEC = 5 * 60;
+const DENY_HOST = "blocked.test";
+const EGRESS_HOST = "example.com";
+const SPEND = {
+    amountMinor: 100,
+    currency: "USD",
+    payee: "sample-merchant",
+    reference: "demo-1",
+};
+function redact(text, token) {
+    if (token === "" || !text.includes(token))
+        return text;
+    return text.split(token).join("[token]");
+}
+function shippedPolicyPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    let resolved = null;
+    try {
+        resolved = join(dirname(fileURLToPath(import.meta.resolve("@verax-ai/proxy/package.json"))), "policy", "default.json");
+    }
+    catch {
+        resolved = null;
+    }
+    const candidates = [
+        resolved,
+        join(here, "..", "..", "proxy", "policy", "default.json"),
+        join(here, "..", "..", "@verax-ai", "proxy", "policy", "default.json"),
+    ];
+    for (const path of candidates) {
+        if (path && existsSync(path))
+            return path;
+    }
+    throw new Error("demo: shipped policy file not found");
+}
+/** Shipped default plus message.send egress and a spend rule, written under the temp dir. */
+function writeDemoPolicy(stateDir) {
+    const shipped = JSON.parse(readFileSync(shippedPolicyPath(), "utf8"));
+    const document = {
+        ...shipped,
+        egress: [EGRESS_HOST],
+        rules: [
+            ...shipped.rules,
+            {
+                id: "message-send",
+                tool: "message.send",
+                requires: ["verax:memory"],
+                egress: true,
+                text: "Queueing a message needs the memory scope and a recipient host on the egress list.",
+            },
+            {
+                id: "spend",
+                tool: "spend",
+                requires: ["verax:pay"],
+                mode: "approve",
+                text: "A payment is held for an operator.",
+                spend: {
+                    maxAmountMinor: 5000,
+                    currency: "USD",
+                    payees: [SPEND.payee],
+                    dailyMaxMinor: 10_000,
+                },
+            },
+        ],
+    };
+    const path = join(stateDir, "policy.json");
+    writeFileSync(path, `${JSON.stringify(document, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    return path;
+}
+function closeHttp(server) {
+    if (!server)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        if (typeof server.closeAllConnections === "function")
+            server.closeAllConnections();
+        server.close(() => resolve());
+    });
+}
+async function serveJwks(jwk) {
+    const server = createServer((req, res) => {
+        if (req.method === "GET" && (req.url === "/.well-known/jwks.json" || req.url === "/.well-known/jwks.json/")) {
+            const body = JSON.stringify({ keys: [jwk] });
+            res.writeHead(200, {
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(body),
+            });
+            res.end(body);
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const addr = server.address();
+    if (!addr || typeof addr === "string") {
+        server.close();
+        throw new Error("demo: jwks bind failed");
+    }
+    return { server, issuer: `http://127.0.0.1:${addr.port}` };
+}
+async function mintToken(privateKey, issuer, audience) {
+    const nowSec = Math.floor(Date.now() / 1000);
+    return new SignJWT({ scope: "verax:read verax:memory verax:pay" })
+        .setProtectedHeader({ alg: "ES256", kid: KID })
+        .setSubject("demo-brain")
+        .setIssuer(issuer)
+        .setAudience(audience)
+        .setIssuedAt(nowSec)
+        .setExpirationTime(nowSec + TOKEN_TTL_SEC)
+        .setJti(randomUUID())
+        .sign(privateKey);
+}
+function toolText(result) {
+    const content = result && typeof result === "object" ? result.content : undefined;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => part && typeof part === "object" && "text" in part && typeof part.text === "string"
+        ? part.text
+        : "")
+        .filter((s) => s !== "")
+        .join("\n");
+}
+function parseTagged(text, kind) {
+    const m = new RegExp(`^${kind}:([^:]+):(.+)$`).exec(text.trim());
+    return m ? { code: m[1], ref: m[2] } : null;
+}
+async function readAnswer(stdin) {
+    const ended = stdin.readableEnded;
+    if (ended)
+        return "";
+    return await new Promise((resolve) => {
+        const done = (value) => {
+            stdin.off("data", onData);
+            stdin.off("end", onEnd);
+            stdin.off("error", onErr);
+            resolve(value);
+        };
+        const onData = (chunk) => {
+            done(String(chunk).split(/\r?\n/)[0] ?? "");
+        };
+        const onEnd = () => done("");
+        const onErr = () => done("");
+        stdin.once("data", onData);
+        stdin.once("end", onEnd);
+        stdin.once("error", onErr);
+        if (typeof stdin.resume === "function")
+            stdin.resume();
+    });
+}
+export async function runDemo(argv, env, io) {
+    if (env.NODE_ENV === "production") {
+        io.stderr.write("demo refuses NODE_ENV=production\n");
+        return 1;
+    }
+    const keep = argv.includes("--keep");
+    let stateDir = null;
+    let jwks = null;
+    let body = null;
+    let client = null;
+    let token = "";
+    let cleaned = false;
+    const writeOut = (s) => {
+        io.stdout.write(redact(s, token));
+    };
+    const writeErr = (s) => {
+        io.stderr.write(redact(s, token));
+    };
+    const cleanup = async () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        process.off("SIGINT", onStop);
+        process.off("SIGTERM", onStop);
+        if (client)
+            await client.close().catch(() => undefined);
+        client = null;
+        await closeHttp(body);
+        body = null;
+        await closeHttp(jwks);
+        jwks = null;
+        if (stateDir && !keep) {
+            try {
+                rmSync(stateDir, { recursive: true, force: true });
+            }
+            catch {
+                // OS temp cleanup
+            }
+        }
+    };
+    const onStop = () => {
+        void cleanup();
+    };
+    process.once("SIGINT", onStop);
+    process.once("SIGTERM", onStop);
+    try {
+        stateDir = mkdtempSync(join(tmpdir(), "verax-demo-"));
+        const policyFile = writeDemoPolicy(stateDir);
+        const { privateKey, publicKey } = await generateKeyPair("ES256");
+        const jwk = { ...(await exportJWK(publicKey)), alg: "ES256", use: "sig", kid: KID };
+        const jwksBind = await serveJwks(jwk);
+        jwks = jwksBind.server;
+        const issuer = jwksBind.issuer;
+        const jwksUrl = `${issuer}/.well-known/jwks.json`;
+        body = await listen({
+            issuer,
+            jwksUrl,
+            audience: AUDIENCE,
+            stateDir,
+            bindHost: "127.0.0.1",
+            bindPort: 0,
+            policyFile,
+            tlsTerminated: false,
+        });
+        const addr = body.address();
+        if (!addr || typeof addr === "string")
+            throw new Error("demo: body bind failed");
+        const mcpUrl = `http://127.0.0.1:${addr.port}/mcp`;
+        token = await mintToken(privateKey, issuer, AUDIENCE);
+        client = new Client({ name: "verax-demo", version: "0.0.0" });
+        await client.connect(new StreamableHTTPClientTransport(new URL(mcpUrl), {
+            requestInit: { headers: { authorization: `Bearer ${token}` } },
+        }));
+        writeOut("verax demo\n");
+        writeOut("\n");
+        const put = await client.callTool({
+            name: "memory.put",
+            arguments: {
+                id: "demo-note",
+                body: { text: "loopback demo" },
+                source: { kind: "demo" },
+                validUntilMs: Date.now() + 60 * 60 * 1000,
+            },
+        });
+        if (put.isError)
+            throw new Error(`demo: memory.put ${toolText(put)}`);
+        const got = await client.callTool({ name: "memory.get", arguments: { id: "demo-note" } });
+        if (got.isError)
+            throw new Error(`demo: memory.get ${toolText(got)}`);
+        writeOut("memory.put / memory.get\n");
+        writeOut("  allowed; two signed records\n");
+        writeOut("\n");
+        const sent = await client.callTool({
+            name: "message.send",
+            arguments: { to: `ops@${DENY_HOST}`, text: "demo" },
+        });
+        const denied = parseTagged(toolText(sent), "denied");
+        if (!denied)
+            throw new Error(`demo: message.send ${toolText(sent)}`);
+        writeOut(`message.send -> ops@${DENY_HOST}\n`);
+        writeOut(`  refused ${denied.code} (signed)\n`);
+        writeOut(`  ref ${denied.ref}\n`);
+        writeOut("\n");
+        const spent = await client.callTool({
+            name: "spend",
+            arguments: { ...SPEND },
+        });
+        const held = parseTagged(toolText(spent), "deferred");
+        if (!held)
+            throw new Error(`demo: spend ${toolText(spent)}`);
+        writeOut(`spend ${SPEND.amountMinor} minor ${SPEND.currency} ${SPEND.payee}\n`);
+        writeOut("  held\n");
+        let approved = false;
+        if (io.isTTY) {
+            writeOut("Approve this payment as the operator on this machine? [y/N]\n");
+            const answer = await readAnswer(io.stdin);
+            if (answer.trim().toLowerCase() === "y") {
+                const code = await runApprove(["approve", stateDir, held.ref], (s) => writeErr(s), () => undefined);
+                if (code !== 0)
+                    throw new Error("demo: approve failed");
+                approved = true;
+            }
+        }
+        if (approved) {
+            writeOut("  approved; operator id bound on the record\n");
+        }
+        else if (io.isTTY) {
+            writeOut("  left held\n");
+        }
+        else {
+            writeOut("  no terminal to ask, so it stays held (run this in a terminal to be asked)\n");
+        }
+        writeOut("\n");
+        const explained = await client.callTool({
+            name: "audit.explain",
+            arguments: { ref: denied.ref },
+        });
+        if (explained.isError)
+            throw new Error(`demo: audit.explain ${toolText(explained)}`);
+        let findingCode = "none";
+        let trust = "unread";
+        try {
+            const parsed = JSON.parse(toolText(explained));
+            if (typeof parsed.finding?.code === "string")
+                findingCode = parsed.finding.code;
+            if (typeof parsed.trustRoot?.source === "string")
+                trust = parsed.trustRoot.source;
+        }
+        catch {
+            findingCode = "unparsed";
+        }
+        writeOut("audit.explain of the refuse\n");
+        writeOut(`  finding ${findingCode}\n`);
+        writeOut(`  trust-root ${trust}\n`);
+        if (findingCode === "none" && trust !== "unread") {
+            writeOut("  chain and signatures read back\n");
+        }
+        else {
+            writeOut("  the read-back did not come out clean; see the finding above\n");
+        }
+        writeOut("\n");
+        await client.close().catch(() => undefined);
+        client = null;
+        await closeHttp(body);
+        body = null;
+        await closeHttp(jwks);
+        jwks = null;
+        const counted = await verifyLedger(stateDir);
+        writeOut(`records  ${counted.decisions}\n`);
+        writeOut(`effects  ${counted.effects}\n`);
+        if (keep) {
+            writeOut(`ledger   ${stateDir}\n`);
+            writeOut(`verax verify ${stateDir}\n`);
+        }
+        else {
+            writeOut("ledger   removed on exit (run with --keep to keep it and check it with verax verify)\n");
+        }
+        writeOut("\n");
+        writeOut(`${NOT_SHOWN}\n`);
+        await cleanup();
+        return 0;
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : "fault";
+        writeErr(`demo: ${detail}\n`);
+        await cleanup();
+        return 1;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verax-ai/body",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "Apache-2.0",
   "type": "module",
   "engines": {
@@ -22,8 +22,8 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@verax-ai/inventory": "^0.2.0",
-    "@verax-ai/proxy": "^0.2.0",
+    "@verax-ai/inventory": "^0.2.1",
+    "@verax-ai/proxy": "^0.2.1",
     "jose": "^6.2.11"
   },
   "description": "VERAX body: an MCP server that decides, records and proves what an agent did.",