@fidacy/mcp 0.1.5 → 0.1.6

package/dist/core.js

@@ -1,157 +1,416 @@
-import { randomUUID } from "node:crypto";
-import { loadOrGenerateKeyPair, publicKeyPem, sign } from "./signing.js";
-import { stableStringify } from "./util.js";
-import { FileAuditStore } from "./audit-store.js";
-// Pure mandate evaluation. Returns the first violated rule, or null if allowed.
-export function evaluate(mandate, req, spentSoFar) {
-    const now = Date.now();
-    if (mandate.revoked)
-        return "mandate_revoked";
-    if (now < Date.parse(mandate.window.notBefore))
-        return "before_mandate_window";
-    if (now > Date.parse(mandate.window.notAfter))
-        return "after_mandate_window";
-    if (req.currency !== mandate.allow.currency)
-        return `currency_not_allowed:${req.currency}`;
-    if (req.amount <= 0)
-        return "non_positive_amount";
-    if (req.amount > mandate.allow.perTxMax)
-        return `per_tx_cap_exceeded:${req.amount}>${mandate.allow.perTxMax}`;
-    if (spentSoFar + req.amount > mandate.allow.maxTotal)
-        return `total_cap_exceeded:${spentSoFar + req.amount}>${mandate.allow.maxTotal}`;
-    const payeeOk = mandate.allow.payees.includes("*") || mandate.allow.payees.includes(req.payee);
-    if (!payeeOk)
-        return `payee_not_in_allowlist:${req.payee}`;
-    const catOk = mandate.allow.categories.includes("*") || mandate.allow.categories.includes(req.category);
-    if (!catOk)
-        return `category_not_allowed:${req.category}`;
-    return null;
+// ../firewall/dist/util.js
+function stableStringify(obj) {
+  if (obj === null || typeof obj !== "object")
+    return JSON.stringify(obj);
+  if (Array.isArray(obj))
+    return "[" + obj.map(stableStringify).join(",") + "]";
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
 }
-// Reference core: real Ed25519 grants + durable hash-chained audit. Ships a demo
-// mandate so the firewall runs out of the box. Swap for HttpFidacyCore in prod.
-export class DevFidacyCore {
-    priv;
-    pubPem;
-    mandate;
-    store;
-    spent = 0;
-    claimedInvoices = new Set();
-    constructor() {
-        const kp = loadOrGenerateKeyPair();
-        this.priv = kp.privateKey;
-        this.pubPem = publicKeyPem(kp.publicKey);
-        if (kp.ephemeral)
-            console.error("[fidacy] dev mode: ephemeral signing key. Production: set FIDACY_SIGNING_KEY_B64, or FIDACY_MODE=http + FIDACY_API_URL + FIDACY_API_KEY to use the live core.");
-        this.mandate = this.loadMandate();
-        this.store = new FileAuditStore(process.env.FIDACY_AUDIT_PATH ?? "./fidacy-audit.log");
-    }
-    loadMandate() {
-        if (process.env.FIDACY_MANDATE_JSON)
-            return JSON.parse(process.env.FIDACY_MANDATE_JSON);
-        const subject = process.env.FIDACY_SUBJECT ?? "agent:demo";
-        return {
-            id: "mandate:demo",
-            subject,
-            version: "ap2.v0.2.0",
-            allow: {
-                payees: (process.env.FIDACY_ALLOW_PAYEES ?? "supplier:acme,supplier:globex").split(","),
-                categories: (process.env.FIDACY_ALLOW_CATEGORIES ?? "invoice,subscription").split(","),
-                currency: process.env.FIDACY_CURRENCY ?? "USD",
-                maxTotal: Number(process.env.FIDACY_MAX_TOTAL ?? 10000),
-                perTxMax: Number(process.env.FIDACY_PER_TX_MAX ?? 2500),
-            },
-            window: {
-                notBefore: process.env.FIDACY_NOT_BEFORE ?? new Date(Date.now() - 3600_000).toISOString(),
-                notAfter: process.env.FIDACY_NOT_AFTER ?? new Date(Date.now() + 30 * 86400_000).toISOString(),
-            },
-            revoked: false,
-        };
-    }
-    async getMandate() {
-        return this.mandate;
-    }
-    async decide(req, subject) {
-        const decisionId = randomUUID();
-        const ts = new Date().toISOString();
-        const violated = evaluate(this.mandate, req, this.spent);
-        if (violated) {
-            const decision = { decisionId, status: "DENY", subject, mandateId: this.mandate.id, request: req, violatedRule: violated, ts };
-            this.store.append(decision);
-            return decision;
-        }
-        // Invoice-anchored dedup. When the request carries an invoiceRef, the firewall
-        // enforces one ALLOW per (subject, invoiceRef): a second authorization for the
-        // same invoice, at ANY amount and with ANY idempotency key, is DENIED here.
-        // This is stateful, so it runs after the pure mandate evaluation, not inside it.
-        if (req.invoiceRef) {
-            const k = `${subject}|${req.invoiceRef}`;
-            if (this.claimedInvoices.has(k)) {
-                const decision = { decisionId, status: "DENY", subject, mandateId: this.mandate.id, request: req, violatedRule: `duplicate_invoice:${req.invoiceRef}`, ts };
-                this.store.append(decision);
-                return decision;
-            }
-            this.claimedInvoices.add(k);
-        }
-        const grantPayload = { decisionId, subject, payee: req.payee, amount: req.amount, currency: req.currency, exp: Date.now() + 120_000, ...(req.invoiceRef ? { invoiceRef: req.invoiceRef } : {}) };
-        const grantBody = Buffer.from(stableStringify(grantPayload), "utf8").toString("base64url");
-        const grant = `${grantBody}.${sign(this.priv, grantBody)}`;
-        const decision = { decisionId, status: "ALLOW", subject, mandateId: this.mandate.id, request: req, grant, ts };
-        this.spent += req.amount;
-        this.store.append(decision);
-        return decision;
-    }
-    async getProof(decisionId) {
-        const record = this.store.find(decisionId);
-        if (!record)
-            return null;
-        return { record, chainIntact: this.store.intact(), verifiedAgainstPublicKey: this.pubPem };
-    }
-    publicKey() {
-        return this.pubPem;
-    }
+
+// ../firewall/dist/signing.js
+import crypto from "node:crypto";
+function loadOrGenerateKeyPair() {
+  const b64 = process.env.FIDACY_SIGNING_KEY_B64;
+  if (b64) {
+    const pem = Buffer.from(b64, "base64").toString("utf8");
+    const privateKey2 = crypto.createPrivateKey(pem);
+    const publicKey2 = crypto.createPublicKey(privateKey2);
+    return { privateKey: privateKey2, publicKey: publicKey2, ephemeral: false };
+  }
+  const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519");
+  return { privateKey, publicKey, ephemeral: true };
 }
-// Production core: delegates to your backend over HTTP. Implement three
-// endpoints in the Fidacy core and the MCP layer needs zero changes.
-export class HttpFidacyCore {
-    baseUrl;
-    apiKey;
-    subjectPub;
-    constructor(baseUrl, apiKey, subjectPub = "") {
-        this.baseUrl = baseUrl;
-        this.apiKey = apiKey;
-        this.subjectPub = subjectPub;
-    }
-    async call(path, body) {
-        const res = await fetch(`${this.baseUrl}${path}`, {
-            method: "POST",
-            headers: { "content-type": "application/json", authorization: `Bearer ${this.apiKey}` },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok)
-            throw new Error(`fidacy core ${path} -> ${res.status}`);
-        return (await res.json());
+function publicKeyPem(publicKey) {
+  return publicKey.export({ type: "spki", format: "pem" }).toString();
+}
+function sign(privateKey, message) {
+  return crypto.sign(null, Buffer.from(message, "utf8"), privateKey).toString("base64url");
+}
+function sha256(input) {
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+
+// ../firewall/dist/audit-store.js
+import fs from "node:fs";
+var FileAuditStore = class {
+  path;
+  chain = [];
+  constructor(path) {
+    this.path = path;
+    this.load();
+  }
+  load() {
+    if (!fs.existsSync(this.path))
+      return;
+    try {
+      const raw = fs.readFileSync(this.path, "utf8");
+      const parsed = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim())
+          continue;
+        parsed.push(JSON.parse(line));
+      }
+      this.chain = parsed;
+      if (!this.intact())
+        throw new Error("audit chain integrity broken");
+    } catch (err) {
+      this.chain = [];
+      try {
+        const quarantine = `${this.path}.corrupt-${Date.now()}`;
+        fs.renameSync(this.path, quarantine);
+        console.error(`[fidacy] audit log at ${this.path} is unreadable/tampered (${err.message}); quarantined to ${quarantine}, starting a fresh chain.`);
+      } catch {
+        console.error(`[fidacy] audit log at ${this.path} is unreadable/tampered and could not be quarantined; starting a fresh in-memory chain.`);
+      }
     }
-    async getMandate(subject) {
-        return this.call("/v1/mandate/get", { subject });
+  }
+  head() {
+    return this.chain.length ? this.chain[this.chain.length - 1].hash : "GENESIS";
+  }
+  append(decision) {
+    const prevHash = this.head();
+    const seq = this.chain.length;
+    const ts = decision.ts;
+    const digest = sha256(stableStringify({ decisionId: decision.decisionId, status: decision.status, request: decision.request, violatedRule: decision.violatedRule ?? null }));
+    const hash = sha256(`${prevHash}|${digest}|${seq}|${ts}`);
+    const record2 = { seq, decisionId: decision.decisionId, status: decision.status, subject: decision.subject, digest, prevHash, hash, ts };
+    fs.appendFileSync(this.path, JSON.stringify(record2) + "\n");
+    this.chain.push(record2);
+    return record2;
+  }
+  find(decisionId) {
+    return this.chain.find((r) => r.decisionId === decisionId);
+  }
+  intact() {
+    let prev = "GENESIS";
+    for (const r of this.chain) {
+      const expected = sha256(`${prev}|${r.digest}|${r.seq}|${r.ts}`);
+      if (expected !== r.hash || r.prevHash !== prev)
+        return false;
+      prev = r.hash;
     }
-    async decide(req, subject) {
-        return this.call("/v1/decide", { req, subject });
+    return true;
+  }
+};
+
+// ../firewall/dist/evaluate.js
+function evaluate(mandate, req, spentSoFar) {
+  const now = Date.now();
+  if (mandate.revoked)
+    return "mandate_revoked";
+  if (now < Date.parse(mandate.window.notBefore))
+    return "before_mandate_window";
+  if (now > Date.parse(mandate.window.notAfter))
+    return "after_mandate_window";
+  if (req.currency !== mandate.allow.currency)
+    return `currency_not_allowed:${req.currency}`;
+  if (req.amount <= 0)
+    return "non_positive_amount";
+  if (req.amount > mandate.allow.perTxMax)
+    return `per_tx_cap_exceeded:${req.amount}>${mandate.allow.perTxMax}`;
+  if (spentSoFar + req.amount > mandate.allow.maxTotal)
+    return `total_cap_exceeded:${spentSoFar + req.amount}>${mandate.allow.maxTotal}`;
+  const payeeOk = mandate.allow.payees.includes("*") || mandate.allow.payees.includes(req.payee);
+  if (!payeeOk)
+    return `payee_not_in_allowlist:${req.payee}`;
+  const catOk = mandate.allow.categories.includes("*") || mandate.allow.categories.includes(req.category);
+  if (!catOk)
+    return `category_not_allowed:${req.category}`;
+  return null;
+}
+
+// ../firewall/dist/core.js
+import { randomUUID } from "node:crypto";
+function canonInvoice(ref) {
+  if (typeof ref !== "string")
+    return "";
+  return ref.normalize("NFC").replace(/[\s\u200B\u200C\u200D\uFEFF]+/g, "").toLowerCase();
+}
+function validateRequest(req) {
+  if (!req || typeof req !== "object")
+    return "invalid_request";
+  if (typeof req.amount !== "number" || !Number.isFinite(req.amount) || req.amount <= 0)
+    return "invalid_amount";
+  if (typeof req.payee !== "string" || req.payee.length === 0)
+    return "invalid_payee";
+  if (typeof req.currency !== "string" || req.currency.length === 0)
+    return "invalid_currency";
+  return null;
+}
+function requireHttpsBase(raw) {
+  const trimmed = String(raw ?? "").replace(/\/+$/, "");
+  let u;
+  try {
+    u = new URL(trimmed);
+  } catch {
+    throw new Error("FIDACY_API_URL is not a valid URL");
+  }
+  const localHttp = u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]");
+  if (u.protocol !== "https:" && !localHttp) {
+    throw new Error("FIDACY_API_URL must be https:// (the API key is sent to it)");
+  }
+  return trimmed;
+}
+var DevFidacyCore = class {
+  priv;
+  pubPem;
+  mandate;
+  store;
+  spent = 0;
+  claimedInvoices = /* @__PURE__ */ new Set();
+  onDecision;
+  constructor(opts) {
+    const kp = loadOrGenerateKeyPair();
+    this.priv = kp.privateKey;
+    this.pubPem = publicKeyPem(kp.publicKey);
+    if (kp.ephemeral)
+      console.error("[fidacy] dev mode: ephemeral signing key. Production: set FIDACY_SIGNING_KEY_B64, or FIDACY_MODE=http + FIDACY_API_URL + FIDACY_API_KEY to use the live core.");
+    this.mandate = opts.mandate;
+    this.store = new FileAuditStore(opts.auditLogPath ?? "./fidacy-audit.log");
+    this.onDecision = opts.onDecision;
+  }
+  async getMandate() {
+    return this.mandate;
+  }
+  async decide(req, subject) {
+    const decisionId = randomUUID();
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const invalid = validateRequest(req);
+    if (invalid) {
+      const decision2 = { decisionId, status: "DENY", subject, mandateId: this.mandate.id, request: req, violatedRule: invalid, ts };
+      this.store.append(decision2);
+      this.onDecision?.(decision2);
+      return decision2;
     }
-    async getProof(decisionId) {
-        return this.call("/v1/audit/proof", { decisionId });
+    const violated = evaluate(this.mandate, req, this.spent);
+    if (violated) {
+      const decision2 = { decisionId, status: "DENY", subject, mandateId: this.mandate.id, request: req, violatedRule: violated, ts };
+      this.store.append(decision2);
+      this.onDecision?.(decision2);
+      return decision2;
     }
-    publicKey() {
-        return this.subjectPub;
+    const invoice = canonInvoice(req.invoiceRef);
+    if (invoice) {
+      const k = `${subject}|${invoice}`;
+      if (this.claimedInvoices.has(k)) {
+        const decision2 = { decisionId, status: "DENY", subject, mandateId: this.mandate.id, request: req, violatedRule: `duplicate_invoice:${invoice}`, ts };
+        this.store.append(decision2);
+        this.onDecision?.(decision2);
+        return decision2;
+      }
+      this.claimedInvoices.add(k);
     }
+    const grantPayload = { decisionId, subject, payee: req.payee, amount: req.amount, currency: req.currency, exp: Date.now() + 12e4, ...req.invoiceRef ? { invoiceRef: req.invoiceRef } : {} };
+    const grantBody = Buffer.from(stableStringify(grantPayload), "utf8").toString("base64url");
+    const grant = `${grantBody}.${sign(this.priv, grantBody)}`;
+    const decision = { decisionId, status: "ALLOW", subject, mandateId: this.mandate.id, request: req, grant, ts };
+    this.spent += req.amount;
+    this.store.append(decision);
+    this.onDecision?.(decision);
+    return decision;
+  }
+  async getProof(decisionId) {
+    const record2 = this.store.find(decisionId);
+    if (!record2)
+      return null;
+    return { record: record2, chainIntact: this.store.intact(), verifiedAgainstPublicKey: this.pubPem };
+  }
+  publicKey() {
+    return this.pubPem;
+  }
+};
+var HttpFidacyCore = class {
+  apiKey;
+  subjectPub;
+  baseUrl;
+  // Enforce https before any key-bearing request — a hostile FIDACY_API_URL would
+  // otherwise exfiltrate the API key in the Authorization header.
+  constructor(baseUrl, apiKey, subjectPub = "") {
+    this.apiKey = apiKey;
+    this.subjectPub = subjectPub;
+    this.baseUrl = requireHttpsBase(baseUrl);
+  }
+  async call(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${this.apiKey}` },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok)
+      throw new Error(`fidacy core ${path} -> ${res.status}`);
+    return await res.json();
+  }
+  async getMandate(subject) {
+    return this.call("/v1/mandate/get", { subject });
+  }
+  async decide(req, subject) {
+    return this.call("/v1/decide", { req, subject });
+  }
+  async getProof(decisionId) {
+    return this.call("/v1/audit/proof", { decisionId });
+  }
+  publicKey() {
+    return this.subjectPub;
+  }
+};
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+function configDir() {
+  return process.env.FIDACY_CONFIG_DIR ?? join(homedir(), ".fidacy");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function auditLogPath() {
+  if (process.env.FIDACY_AUDIT_PATH) return process.env.FIDACY_AUDIT_PATH;
+  const dir = join(configDir(), "audit");
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  } catch {
+  }
+  return join(dir, "audit.log");
+}
+function readConfig() {
+  const p = configPath();
+  if (!existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(p, "utf8"));
+    if (!raw || typeof raw.anon_id !== "string") return null;
+    return {
+      anon_id: raw.anon_id,
+      tier: raw.tier === "paid" ? "paid" : "free",
+      api_key: typeof raw.api_key === "string" ? raw.api_key : null,
+      mandate: raw.mandate
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveMandateRules(cfg) {
+  const m = cfg?.mandate ?? {};
+  const envList = (v) => v === void 0 ? void 0 : v.split(",").map((s) => s.trim()).filter(Boolean);
+  const envNum = (v) => v === void 0 || v === "" ? void 0 : Number(v);
+  return {
+    payees: envList(process.env.FIDACY_ALLOW_PAYEES) ?? m.payees ?? [],
+    categories: envList(process.env.FIDACY_ALLOW_CATEGORIES) ?? m.categories ?? ["*"],
+    currency: process.env.FIDACY_CURRENCY ?? m.currency ?? "USD",
+    perTxMax: envNum(process.env.FIDACY_PER_TX_MAX) ?? m.perTxMax ?? 2500,
+    maxTotal: envNum(process.env.FIDACY_MAX_TOTAL) ?? m.maxTotal ?? 1e4
+  };
 }
-export function makeCore() {
-    if ((process.env.FIDACY_MODE ?? "dev") === "http") {
-        const url = process.env.FIDACY_API_URL;
-        const key = process.env.FIDACY_API_KEY;
-        if (!url || !key)
-            throw new Error("FIDACY_MODE=http requires FIDACY_API_URL and FIDACY_API_KEY");
-        return new HttpFidacyCore(url, key, process.env.FIDACY_PUBLIC_KEY_PEM ?? "");
+
+// src/telemetry.ts
+var CLIENT_VERSION = "0.1.5";
+function telemetryEnabled() {
+  const v = (process.env.FIDACY_DISABLE_TELEMETRY ?? "").trim().toLowerCase();
+  return !(v === "1" || v === "true" || v === "yes");
+}
+function endpoint() {
+  const base = (process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com").replace(/\/$/, "");
+  return `${base}/v1/telemetry`;
+}
+var anonIdCache = null;
+function anonId() {
+  if (anonIdCache) return anonIdCache;
+  anonIdCache = readConfig()?.anon_id ?? null;
+  return anonIdCache;
+}
+var buffer = [];
+var flushTimer = null;
+function resultOf(status, violatedRule) {
+  if (status === "ALLOW") return "allow";
+  const r = violatedRule ?? "";
+  if (r.startsWith("per_tx_cap") || r.startsWith("total_cap")) return "deny_cap";
+  if (r.startsWith("payee_not_in_allowlist")) return "deny_payee";
+  return "deny_scope";
+}
+function record(type, result) {
+  if (!telemetryEnabled()) return;
+  buffer.push({ type, ts: (/* @__PURE__ */ new Date()).toISOString(), client_version: CLIENT_VERSION, ...result ? { result } : {} });
+  if (!flushTimer) {
+    flushTimer = setTimeout(() => {
+      void flush();
+    }, 2e3);
+    if (typeof flushTimer.unref === "function") flushTimer.unref();
+  }
+}
+var recordDecision = (status, violatedRule) => record("decision", resultOf(status, violatedRule));
+async function flush() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  if (!telemetryEnabled() || buffer.length === 0) return;
+  const id = anonId();
+  if (!id) {
+    buffer = [];
+    return;
+  }
+  const events = buffer;
+  buffer = [];
+  try {
+    await fetch(endpoint(), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ anon_id: id, events })
+    });
+  } catch {
+  }
+}
+
+// src/core.ts
+function buildMandate() {
+  if (process.env.FIDACY_MANDATE_JSON) {
+    try {
+      const parsed = JSON.parse(process.env.FIDACY_MANDATE_JSON);
+      if (parsed && typeof parsed === "object" && parsed.allow && parsed.window) return parsed;
+      console.error("[fidacy] FIDACY_MANDATE_JSON is missing allow/window; ignoring it and using the safe default mandate.");
+    } catch (err) {
+      console.error(`[fidacy] FIDACY_MANDATE_JSON is not valid JSON (${err.message}); ignoring it and using the safe default mandate.`);
     }
-    return new DevFidacyCore();
+  }
+  const subject = process.env.FIDACY_SUBJECT ?? "agent:demo";
+  const rules = resolveMandateRules(readConfig());
+  return {
+    id: "mandate:local",
+    subject,
+    version: "ap2.v0.2.0",
+    allow: {
+      payees: rules.payees,
+      categories: rules.categories,
+      currency: rules.currency,
+      maxTotal: rules.maxTotal,
+      perTxMax: rules.perTxMax
+    },
+    window: {
+      notBefore: process.env.FIDACY_NOT_BEFORE ?? new Date(Date.now() - 36e5).toISOString(),
+      notAfter: process.env.FIDACY_NOT_AFTER ?? new Date(Date.now() + 30 * 864e5).toISOString()
+    },
+    revoked: false
+  };
+}
+function makeCore() {
+  if ((process.env.FIDACY_MODE ?? "dev") === "http") {
+    const url = process.env.FIDACY_API_URL;
+    const key = process.env.FIDACY_API_KEY;
+    if (!url || !key) throw new Error("FIDACY_MODE=http requires FIDACY_API_URL and FIDACY_API_KEY");
+    return new HttpFidacyCore(url, key, process.env.FIDACY_PUBLIC_KEY_PEM ?? "");
+  }
+  return new DevFidacyCore({
+    mandate: buildMandate(),
+    auditLogPath: auditLogPath(),
+    onDecision: (d) => recordDecision(d.status, d.violatedRule)
+  });
 }
-//# sourceMappingURL=core.js.map
+export {
+  makeCore
+};