blindseal 0.0.0-stage → 0.5.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 VaultMCP contributors
+Copyright (c) 2026 Blindseal contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/attest-QLIE2OSQ.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import {
+  makeLayer0Result,
+  runLayer0,
+  runLayer1
+} from "./chunk-XV57KLEO.js";
+import {
+  openAudit
+} from "./chunk-PQ457W6T.js";
+import "./chunk-PDX44BCA.js";
+
+// src/cli/attest.ts
+import { createHash, randomBytes } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { spawnSync } from "child_process";
+import os from "os";
+import path from "path";
+
+// src/chain/solana.ts
+var CHAIN_ID_SOLANA_MAINNET = 1;
+var SYSTEM_PROGRAM = "11111111111111111111111111111111";
+var TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var RECIPIENT_KEYS = ["recipient", "to", "destination", "dest", "receiver", "toPubkey", "toAddress"];
+var AMOUNT_KEYS = ["amount", "lamports", "value", "tokenAmount", "quantity"];
+var MINT_KEYS = ["mint", "token", "tokenMint", "mintAddress"];
+var AUTHORITY_KEYS = ["authority", "owner", "from", "source", "payer", "fromPubkey", "signer"];
+var PROGRAM_KEYS = ["program", "programId", "programAddress"];
+var TRANSFER_TOOL = /(?:^|_|\b)(?:transfer|send|pay|spl[_-]?transfer|transfer[_-]?checked)(?:_|\b|$)/i;
+function firstString(obj, keys) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === "string" && v.length > 0) return v;
+    if (typeof v === "number" && Number.isFinite(v)) return String(v);
+    if (typeof v === "bigint") return v.toString();
+  }
+  return void 0;
+}
+function parseSolanaAction(toolName, args, opts = {}) {
+  if (!args || typeof args !== "object") return null;
+  const a = args;
+  const amount = firstString(a, AMOUNT_KEYS);
+  const recipient = firstString(a, RECIPIENT_KEYS);
+  const explicitProgram = firstString(a, PROGRAM_KEYS);
+  const looksLikeTransfer = TRANSFER_TOOL.test(toolName);
+  if (!looksLikeTransfer && !explicitProgram) return null;
+  if (recipient === void 0 && amount === void 0 && explicitProgram === void 0) return null;
+  const mint = firstString(a, MINT_KEYS);
+  const sourceAuthority = firstString(a, AUTHORITY_KEYS);
+  void opts;
+  const chainId = CHAIN_ID_SOLANA_MAINNET;
+  const targetProgram = explicitProgram ?? (mint ? TOKEN_PROGRAM : SYSTEM_PROGRAM);
+  const instruction = typeof a.instruction === "string" && a.instruction || typeof a.method === "string" && a.method || (mint ? "transferChecked" : "transfer");
+  return {
+    chain: "solana",
+    chainId,
+    targetProgram,
+    instruction,
+    recipient: recipient ?? "",
+    mint: mint ?? "",
+    amount: amount ?? "",
+    sourceAuthority: sourceAuthority ?? ""
+  };
+}
+
+// src/cli/attest.ts
+var HELP = `blindseal attest \u2014 screen a tool call, record the decision, prove it
+
+Usage:
+  blindseal attest <toolcall.json> --out <attestation.json> --target-program <program id> [flags]
+
+Flags
+  --out <file>               where to write attestation.json (default ./attestation.json)
+  --target-program <id>      the gated program the action targets (base58)
+  --instruction <16 hex>     instruction discriminator (default: transfer-gate gated_transfer)
+  --expiry <slot>            expirySlot (default 2000000000)
+  --prover <path>            prover binary (default crates/prover/target/release/blindseal-prover)
+  --audit-dir <dir>          audit base dir (default ~/.blindseal)
+  --help, -h                 this help
+
+Only clean verdicts are attested. The decision is appended to the hash-chained audit log first.
+`;
+var GATED_TRANSFER_DISC = "0x981894646560fc2b";
+function parse(argv) {
+  const o = { out: "attestation.json", instruction: GATED_TRANSFER_DISC, expiry: "2000000000", auditDir: path.join(os.homedir(), ".blindseal") };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") o.help = true;
+    else if (a === "--out") o.out = argv[++i];
+    else if (a === "--target-program") o.targetProgram = argv[++i];
+    else if (a === "--instruction") o.instruction = argv[++i];
+    else if (a === "--expiry") o.expiry = argv[++i];
+    else if (a === "--prover") o.prover = argv[++i];
+    else if (a === "--audit-dir") o.auditDir = argv[++i];
+    else if (a.startsWith("--")) throw new Error(`unknown flag: ${a}`);
+    else o.file = a;
+  }
+  return o;
+}
+function findProver(explicit) {
+  if (explicit) return explicit;
+  let dir = process.cwd();
+  for (let i = 0; i < 7; i++) {
+    const c = path.join(dir, "crates/prover/target/release/blindseal-prover");
+    if (existsSync(c)) return c;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("prover binary not found; build crates/prover or pass --prover");
+}
+async function runAttestCli(argv) {
+  let o;
+  try {
+    o = parse(argv);
+  } catch (e) {
+    process.stderr.write(`blindseal attest: ${e.message}
+${HELP}`);
+    return 2;
+  }
+  if (o.help || !o.file) {
+    process.stdout.write(HELP);
+    return o.help ? 0 : 2;
+  }
+  if (!o.targetProgram) {
+    process.stderr.write("blindseal attest: --target-program is required\n");
+    return 2;
+  }
+  const raw = readFileSync(o.file, "utf8");
+  const call = JSON.parse(raw);
+  const payload = JSON.stringify({ tool: call.toolName, args: call.args });
+  const payloadHash = "0x" + createHash("sha256").update(payload).digest("hex");
+  const l0 = runLayer0(payload);
+  const result = l0.fired ? makeLayer0Result(l0) : runLayer1(payload);
+  const verdict = result.verdict;
+  const decisionId = "d_" + randomBytes(8).toString("hex");
+  const audit = openAudit(o.auditDir);
+  const entry = audit.chain.append({ decisionId, verdict, payloadHash });
+  process.stdout.write(`decision ${decisionId}: ${verdict} (audit #${entry.index} ${entry.hash.slice(0, 18)}\u2026)
+`);
+  if (verdict !== "clean") {
+    process.stderr.write(`blindseal attest: verdict is ${verdict} (${result.detectedPatterns.join(", ")}); no attestation for a non-clean call
+`);
+    return 1;
+  }
+  const action = parseSolanaAction(call.toolName, call.args);
+  if (!action) {
+    process.stderr.write("blindseal attest: the call is not a recognizable on-chain action\n");
+    return 1;
+  }
+  if (!action.recipient || !action.amount || !action.sourceAuthority) {
+    process.stderr.write("blindseal attest: action needs recipient, amount and source authority\n");
+    return 1;
+  }
+  const prover = findProver(o.prover);
+  const tmpPayload = path.join(os.tmpdir(), `blindseal-payload-${decisionId}.json`);
+  writeFileSync(tmpPayload, payload);
+  const args = [
+    "--payload",
+    tmpPayload,
+    "--out",
+    o.out,
+    "--decision-id",
+    decisionId,
+    "--chain-id",
+    String(action.chainId),
+    "--target-program",
+    o.targetProgram,
+    "--source-authority",
+    action.sourceAuthority,
+    "--recipient",
+    action.recipient,
+    "--mint",
+    action.mint,
+    "--amount",
+    action.amount,
+    "--instruction",
+    o.instruction,
+    "--expiry",
+    o.expiry
+  ];
+  process.stdout.write(`proving (this takes a while on CPU)\u2026
+`);
+  const r = spawnSync(prover, args, { stdio: "inherit" });
+  if (r.status !== 0) {
+    process.stderr.write(`blindseal attest: prover exited ${r.status}
+`);
+    return 1;
+  }
+  process.stdout.write(`attestation written: ${o.out} (decision ${decisionId}, payloadHash ${payloadHash})
+`);
+  return 0;
+}
+export {
+  runAttestCli
+};

package/dist/audit-C756XFXR.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import {
+  openAudit
+} from "./chunk-PQ457W6T.js";
+import "./chunk-PDX44BCA.js";
+
+// src/cli/audit.ts
+import { writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+var HELP = `blindseal audit \u2014 the hash-chained decision log
+
+Usage:
+  blindseal audit verify [--dir <dir>]
+  blindseal audit disclose --from <index> --to <index> [--out <file>] [--dir <dir>]
+
+Flags
+  --dir <dir>     audit base dir (default ~/.blindseal)
+  --out <file>    write the disclosure here (default disclosure-<from>-<to>.json)
+  --help, -h      this help
+`;
+async function runAuditCli(argv) {
+  const sub = argv[0];
+  if (!sub || sub === "--help" || sub === "-h") {
+    process.stdout.write(HELP);
+    return sub ? 0 : 2;
+  }
+  let dir = path.join(os.homedir(), ".blindseal"), from, to, out;
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dir") dir = argv[++i];
+    else if (a === "--from") from = Number.parseInt(argv[++i], 10);
+    else if (a === "--to") to = Number.parseInt(argv[++i], 10);
+    else if (a === "--out") out = argv[++i];
+    else {
+      process.stderr.write(`blindseal audit: unknown flag ${a}
+${HELP}`);
+      return 2;
+    }
+  }
+  const audit = openAudit(dir);
+  if (sub === "verify") {
+    const head = audit.chain.head();
+    if (!head) {
+      process.stdout.write("audit: empty chain (nothing recorded yet)\n");
+      return 0;
+    }
+    const r = audit.chain.verify();
+    process.stdout.write(`audit: ${r.ok ? "INTACT" : "BROKEN"} \u2014 ${r.checkedTo - r.checkedFrom + 1} entries, head #${head.index} ${head.hash}${r.ok ? "" : ` (broken at #${r.brokenAt})`}
+`);
+    return r.ok ? 0 : 1;
+  }
+  if (sub === "disclose") {
+    if (from === void 0 || to === void 0 || Number.isNaN(from) || Number.isNaN(to) || from > to) {
+      process.stderr.write("blindseal audit disclose: --from and --to (indices, from \u2264 to) are required\n");
+      return 2;
+    }
+    const d = audit.disclose(from, to);
+    const file = out ?? `disclosure-${from}-${to}.json`;
+    writeFileSync(file, JSON.stringify(d, null, 2) + "\n");
+    process.stdout.write(`disclosure written: ${file} (${d.entries.length} entries, signer ${d.signerPubkey.slice(0, 16)}\u2026)
+`);
+    return 0;
+  }
+  process.stderr.write(`blindseal audit: unknown subcommand ${sub}
+${HELP}`);
+  return 2;
+}
+export {
+  runAuditCli
+};

package/dist/audit-view.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-PDX44BCA.js";
+
+// src/cli/audit-view.ts
+import { readFileSync, existsSync } from "fs";
+var HELP = `blindseal-audit \u2014 pretty-print the Blindseal audit JSONL
+
+Usage:
+  blindseal-audit [path]                  default: $BLINDSEAL_AUDIT_LOG or /tmp/blindseal-audit.jsonl
+  blindseal-audit -                       read from stdin
+  blindseal-audit --type capability       filter by event type (detection|capability|manifest)
+  blindseal-audit --verdict malicious     filter by verdict (clean|suspicious|malicious)
+  blindseal-audit --tool read_file        filter by tool name
+  blindseal-audit --since 1h              only events newer than 1h (s/m/h/d)
+  blindseal-audit --raw                   one line per event, no color (for grep/jq pipelines)
+`;
+var HAS_TTY = process.stdout.isTTY && !process.env.NO_COLOR;
+function color(s, code) {
+  if (!HAS_TTY) return s;
+  return `\x1B[${code}m${s}\x1B[0m`;
+}
+var dim = (s) => color(s, "2;37");
+var red = (s) => color(s, "31");
+var yellow = (s) => color(s, "33");
+var green = (s) => color(s, "32");
+var cyan = (s) => color(s, "36");
+var bold = (s) => color(s, "1");
+function verdictPaint(v) {
+  if (v === "malicious") return red(bold("malicious"));
+  if (v === "suspicious") return yellow("suspicious");
+  if (v === "clean") return green("clean");
+  return dim(v ?? "?");
+}
+function actionPaint(a) {
+  if (a === "block") return red(bold("block"));
+  if (a === "warn") return yellow("warn");
+  if (a === "allow") return green("allow");
+  return dim(a ?? "?");
+}
+function statusPaint(s) {
+  if (s === "drift") return red(bold("drift"));
+  if (s === "first-seen") return cyan("first-seen");
+  if (s === "unchanged") return dim("unchanged");
+  return dim(s ?? "?");
+}
+function parseSince(raw) {
+  const m = /^(\d+)([smhd])$/.exec(raw);
+  if (!m) return void 0;
+  const n = Number(m[1]);
+  const unit = m[2];
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return Date.now() - n * mult;
+}
+function parseArgs(argv) {
+  const filter = {};
+  let path;
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") help = true;
+    else if (a === "--type") filter.type = argv[++i];
+    else if (a === "--verdict") filter.verdict = argv[++i];
+    else if (a === "--tool") filter.tool = argv[++i];
+    else if (a === "--since") {
+      const next = argv[++i] ?? "";
+      filter.sinceMs = parseSince(next);
+    } else if (a === "--raw") filter.raw = true;
+    else if (a && !a.startsWith("--")) path = a;
+  }
+  return { filter, path, help };
+}
+function loadSource(path) {
+  if (path === "-") return readStdin();
+  const resolved = path ?? process.env.BLINDSEAL_AUDIT_LOG ?? "/tmp/blindseal-audit.jsonl";
+  if (!existsSync(resolved)) {
+    throw new Error(`audit log not found: ${resolved}`);
+  }
+  return readFileSync(resolved, "utf8");
+}
+function readStdin() {
+  const chunks = [];
+  const fd = 0;
+  const buf = Buffer.alloc(64 * 1024);
+  try {
+    for (; ; ) {
+      const { readFileSync: _rfs } = __require("fs");
+      try {
+        return _rfs("/dev/stdin", "utf8");
+      } catch {
+        break;
+      }
+    }
+  } catch {
+  }
+  const fs = __require("fs");
+  let total = 0;
+  try {
+    for (; ; ) {
+      const n = fs.readSync(fd, buf, 0, buf.length, null);
+      if (n === 0) break;
+      chunks.push(buf.slice(0, n));
+      total += n;
+      if (total > 100 * 1024 * 1024) break;
+    }
+  } catch {
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function passesFilter(row, f) {
+  if (f.type && row.type !== f.type) return false;
+  if (f.verdict && row.verdict !== f.verdict) return false;
+  if (f.tool && row.toolName !== f.tool) return false;
+  if (f.sinceMs && row.ts < f.sinceMs) return false;
+  return true;
+}
+function fmtTs(ts) {
+  const d = new Date(ts);
+  return d.toISOString().replace("T", " ").replace(/\..+/, "");
+}
+function renderRow(row, raw) {
+  if (raw) return JSON.stringify(row);
+  const t = dim(fmtTs(row.ts));
+  if (row.type === "detection") {
+    const v = verdictPaint(row.verdict);
+    const L = row.layer != null ? `L${row.layer}` : "L?";
+    const m = row.mutated ? red("mut") : dim("-");
+    const tool = cyan(row.toolName ?? "?");
+    const preview = (row.contentPreview ?? "").slice(0, 80).replace(/\n/g, " ");
+    const patterns = row.patterns && row.patterns.length > 0 ? dim(` [${row.patterns.slice(0, 3).join(",")}]`) : "";
+    return `${t}  ${dim("det")}  ${L}  ${v}  ${tool}  mode=${row.mode ?? "?"}  ${m}${patterns}
+         ${dim("\u2514")} ${preview}`;
+  }
+  if (row.type === "capability") {
+    const a = actionPaint(row.action);
+    const tool = cyan(row.toolName ?? "?");
+    const sources = row.taintSources && row.taintSources.length > 0 ? dim(` \u2190 ${row.taintSources.slice(0, 3).join(",")}`) : "";
+    const args = (row.argsPreview ?? "").slice(0, 80).replace(/\n/g, " ");
+    return `${t}  ${dim("cap")}  --  ${a}      ${tool}${sources}
+         ${dim("\u2514")} ${args}`;
+  }
+  if (row.type === "manifest") {
+    const s = statusPaint(row.status);
+    const fp = dim((row.fingerprint ?? "").slice(0, 12));
+    const changes = row.changes && row.changes.length > 0 ? "\n         " + row.changes.map((c) => dim("\u2514 ") + yellow(c)).join("\n         ") : "";
+    return `${t}  ${dim("mfs")}  --  ${s}  ${fp}${changes}`;
+  }
+  return JSON.stringify(row);
+}
+function summarize(rows) {
+  const byType = { detection: 0, capability: 0, manifest: 0 };
+  const byVerdict = { clean: 0, suspicious: 0, malicious: 0 };
+  const byAction = { allow: 0, warn: 0, block: 0 };
+  const byManifest = { "first-seen": 0, unchanged: 0, drift: 0 };
+  const tools = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    byType[r.type] = (byType[r.type] ?? 0) + 1;
+    if (r.verdict) byVerdict[r.verdict] = (byVerdict[r.verdict] ?? 0) + 1;
+    if (r.action) byAction[r.action] = (byAction[r.action] ?? 0) + 1;
+    if (r.status) byManifest[r.status] = (byManifest[r.status] ?? 0) + 1;
+    if (r.toolName) tools.set(r.toolName, (tools.get(r.toolName) ?? 0) + 1);
+  }
+  const topTools = [...tools.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+  const lines = [];
+  lines.push("");
+  lines.push(dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  lines.push(bold("summary"));
+  lines.push(`  events:   ${rows.length}`);
+  lines.push(
+    `  by type:  detection=${byType.detection}  capability=${byType.capability}  manifest=${byType.manifest}`
+  );
+  lines.push(
+    `  verdicts: ${green(`clean=${byVerdict.clean}`)}  ${yellow(`suspicious=${byVerdict.suspicious}`)}  ${red(`malicious=${byVerdict.malicious}`)}`
+  );
+  lines.push(
+    `  actions:  ${green(`allow=${byAction.allow}`)}  ${yellow(`warn=${byAction.warn}`)}  ${red(`block=${byAction.block}`)}`
+  );
+  lines.push(
+    `  manifest: ${cyan(`first-seen=${byManifest["first-seen"]}`)}  ${dim(`unchanged=${byManifest.unchanged}`)}  ${red(`drift=${byManifest.drift}`)}`
+  );
+  if (topTools.length > 0) {
+    lines.push(`  top tools: ${topTools.map(([t, n]) => `${cyan(t)}:${n}`).join("  ")}`);
+  }
+  return lines.join("\n");
+}
+function parseJsonl(raw) {
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      rows.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return rows;
+}
+function render(rows, filter) {
+  const matched = rows.filter((r) => passesFilter(r, filter));
+  const lines = matched.map((r) => renderRow(r, filter.raw ?? false));
+  if (filter.raw) return lines.join("\n");
+  return lines.join("\n") + "\n" + summarize(matched);
+}
+function main() {
+  const argv = process.argv.slice(2);
+  const { filter, path, help } = parseArgs(argv);
+  if (help) {
+    process.stdout.write(HELP);
+    process.exit(0);
+  }
+  let raw;
+  try {
+    raw = loadSource(path);
+  } catch (err) {
+    process.stderr.write(`blindseal-audit: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(2);
+  }
+  const rows = parseJsonl(raw);
+  process.stdout.write(render(rows, filter) + "\n");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+export {
+  parseJsonl,
+  render
+};