@polderlabs/bizar 6.2.5 → 7.0.0

package/packages/sdk/tests/federation/orchestrator.test.ts

@@ -0,0 +1,176 @@
+/**
+ * federation/orchestrator.test.ts — F-038 orchestrator smoke tests.
+ *
+ * Covers the end-to-end `createFederation()` flow:
+ *   - sign() produces a signed envelope.
+ *   - receive() admits a fresh signed envelope.
+ *   - PII redaction applies on sign() (soc2 mode).
+ *   - status() returns the documented snapshot shape.
+ *   - Two-instance roundtrip with shared HMAC secret.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  createFederation,
+  type FederationHandle,
+} from "../../src/federation/index.js";
+
+describe("federation/orchestrator — single-instance flow", () => {
+  let dir: string;
+  let handle: FederationHandle;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "bizar-fed-"));
+    handle = createFederation({
+      nodeId: "node-A",
+      secret: "shared-secret",
+      auditPath: join(dir, "audit.log"),
+      budgetPath: join(dir, "budget.json"),
+    });
+    handle.services.trust.setAllowlisted("node-B", true);
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("sign() produces a signed envelope with non-empty signature", () => {
+    const env = handle.sign({
+      targetNodeId: "node-B",
+      sessionId: "s1",
+      messageType: "heartbeat",
+      payload: "ping",
+    });
+    expect(env.hmacSignature).toMatch(/^[0-9a-f]{64}$/);
+    expect(env.nonce).toMatch(/^[0-9a-f-]{36}$/);
+    expect(env.sourceNodeId).toBe("node-A");
+    expect(env.targetNodeId).toBe("node-B");
+  });
+
+  test("receive() admits a fresh signed envelope from an allowlisted peer", () => {
+    const peer = createFederation({
+      nodeId: "node-B",
+      secret: "shared-secret",
+      auditPath: join(dir, "audit-B.log"),
+      budgetPath: join(dir, "budget-B.json"),
+    });
+    const sent = peer.sign({
+      targetNodeId: "node-A",
+      sessionId: "s1",
+      messageType: "heartbeat",
+      payload: "hello",
+    });
+    const r = handle.receive(sent);
+    expect(r.hmacValid).toBe(true);
+    expect(r.trusted).toBe(true);
+    expect(r.policyAllowed).toBe(true);
+    expect(r.rejectionReason).toBeUndefined();
+  });
+
+  test("receive() rejects an envelope from a non-allowlisted peer", () => {
+    const peer = createFederation({
+      nodeId: "node-X",
+      secret: "shared-secret",
+      auditPath: join(dir, "audit-X.log"),
+      budgetPath: join(dir, "budget-X.json"),
+    });
+    const sent = peer.sign({
+      targetNodeId: "node-A",
+      sessionId: "s1",
+      messageType: "heartbeat",
+      payload: "hello",
+    });
+    const r = handle.receive(sent);
+    expect(r.hmacValid).toBe(true);
+    expect(r.trusted).toBe(false);
+    expect(r.rejectionReason).toMatch(/trust/);
+  });
+
+  test("receive() rejects a tampered envelope", () => {
+    const peer = createFederation({
+      nodeId: "node-B",
+      secret: "shared-secret",
+      auditPath: join(dir, "audit-B.log"),
+      budgetPath: join(dir, "budget-B.json"),
+    });
+    const sent = peer.sign({
+      targetNodeId: "node-A",
+      sessionId: "s1",
+      messageType: "heartbeat",
+      payload: "hello",
+    });
+    const tampered = { ...sent, payload: "tampered" };
+    const r = handle.receive(tampered);
+    expect(r.hmacValid).toBe(false);
+    expect(r.rejectionReason).toMatch(/hmac/);
+  });
+
+  test("PII redaction applies on sign() under soc2 mode", () => {
+    const env = handle.sign({
+      targetNodeId: "node-B",
+      sessionId: "s1",
+      messageType: "context-share",
+      payload: "contact alice@example.com",
+    });
+    expect(env.payload).not.toContain("alice@example.com");
+    expect(env.payload).toContain("[REDACTED:email]");
+    expect(env.piiScanResult.scanned).toBe(true);
+    expect(env.piiScanResult.piiFound).toBe(true);
+  });
+
+  test("skipPii disables redaction", () => {
+    const env = handle.sign({
+      targetNodeId: "node-B",
+      sessionId: "s1",
+      messageType: "context-share",
+      payload: "contact alice@example.com",
+      skipPii: true,
+    });
+    expect(env.payload).toBe("contact alice@example.com");
+  });
+
+  test("setPiiMode / getPiiMode round-trip", () => {
+    expect(handle.getPiiMode()).toBe("soc2");
+    handle.setPiiMode("gdpr");
+    expect(handle.getPiiMode()).toBe("gdpr");
+    expect(() => handle.setPiiMode("nope" as never)).toThrow();
+  });
+
+  test("status() returns the documented snapshot shape", () => {
+    const snap = handle.status();
+    expect(snap.nodeId).toBe("node-A");
+    expect(snap.auditPath).toContain("audit.log");
+    expect(snap.budget.path).toContain("budget.json");
+    expect(Array.isArray(snap.budget.perPeer)).toBe(true);
+    expect(typeof snap.nonceCacheSize).toBe("number");
+    expect(typeof snap.auditSizeBytes).toBe("number");
+  });
+
+  test("constructor requires nodeId + secret", () => {
+    expect(() => createFederation({ nodeId: "", secret: "x" } as never)).toThrow(/nodeId/);
+    expect(() => createFederation({ nodeId: "x", secret: "" } as never)).toThrow(/secret/);
+  });
+
+  test("nonce replay is rejected on second delivery", () => {
+    const peer = createFederation({
+      nodeId: "node-B",
+      secret: "shared-secret",
+      auditPath: join(dir, "audit-B.log"),
+      budgetPath: join(dir, "budget-B.json"),
+    });
+    const sent = peer.sign({
+      targetNodeId: "node-A",
+      sessionId: "s1",
+      messageType: "heartbeat",
+      payload: "hello",
+    });
+    const r1 = handle.receive(sent);
+    const r2 = handle.receive(sent);
+    expect(r1.hmacValid).toBe(true);
+    expect(r2.hmacValid).toBe(false);
+    if (r2.rejectionReason) expect(r2.rejectionReason).toMatch(/nonce_replay/);
+  });
+});

package/packages/sdk/tests/federation/pii.test.ts

@@ -0,0 +1,106 @@
+/**
+ * federation/pii.test.ts — F-038 PII pipeline tests.
+ *
+ * Covers:
+ *   - soc2 mode redacts emails + SSNs + IPs, blocks credit cards.
+ *   - gdpr mode also redacts names + addresses.
+ *   - hipaa mode is the strictest (redacts everything sensitive).
+ *   - permissive mode only blocks the highest-severity categories.
+ *   - PiiPipeline class wrapper setMode / process flow.
+ */
+
+import { describe, test, expect } from "vitest";
+import {
+  PII_MODES,
+  PiiPipeline,
+  apply,
+  isPiiMode,
+  type PiiMode,
+} from "../../src/federation/pii.js";
+
+describe("federation/pii — apply() per mode", () => {
+  test("soc2 redacts emails + IPs + SSNs, blocks credit cards", () => {
+    const r = apply("contact alice@example.com or 192.168.1.1, SSN 123-45-6789, CC 4111-1111-1111-1111", "soc2");
+    expect(r.blocked).toBe(true);
+    // Even though we blocked CC, the transformed text is empty.
+    expect(r.transformed).toBe("");
+    expect(r.detections.length).toBeGreaterThanOrEqual(3);
+  });
+
+  test("soc2 non-CC text returns redacted output", () => {
+    const r = apply("contact alice@example.com from 10.0.0.1", "soc2");
+    expect(r.blocked).toBe(false);
+    expect(r.transformed).toContain("[REDACTED:email]");
+    expect(r.transformed).toContain("[REDACTED:ip_address]");
+    expect(r.transformed).not.toContain("alice@example.com");
+    expect(r.transformed).not.toContain("10.0.0.1");
+  });
+
+  test("gdpr redacts emails, IPs, names, addresses", () => {
+    const r = apply("Dr. Alice Smith at alice@example.com from 10 Downing St", "gdpr");
+    expect(r.transformed).toContain("[REDACTED:email]");
+    expect(r.transformed).not.toContain("alice@example.com");
+  });
+
+  test("hipaa is the strictest — emails + SSNs + IPs + phones redacted", () => {
+    const r = apply("call 555-123-4567 or email alice@example.com, SSN 123-45-6789", "hipaa");
+    expect(r.transformed).not.toContain("alice@example.com");
+    expect(r.transformed).not.toContain("123-45-6789");
+    expect(r.transformed).not.toContain("555-123-4567");
+  });
+
+  test("permissive passes emails + IPs but blocks AWS keys + private keys + github tokens", () => {
+    const clean = apply("contact alice@example.com from 10.0.0.1", "permissive");
+    expect(clean.blocked).toBe(false);
+    expect(clean.transformed).toContain("alice@example.com");
+    expect(clean.transformed).toContain("10.0.0.1");
+
+    const awsKey = apply("AWS key: AKIAIOSFODNN7EXAMPLE", "permissive");
+    expect(awsKey.blocked).toBe(true);
+
+    const priv = apply("-----BEGIN RSA PRIVATE KEY-----", "permissive");
+    expect(priv.blocked).toBe(true);
+
+    const gh = apply("github token: ghp_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "permissive");
+    expect(gh.blocked).toBe(true);
+  });
+
+  test("unknown mode throws", () => {
+    expect(() => apply("text", "unknown" as unknown as PiiMode)).toThrow(/unknown mode/);
+  });
+
+  test("each declared mode is accepted by isPiiMode", () => {
+    for (const m of PII_MODES) {
+      expect(isPiiMode(m)).toBe(true);
+    }
+    expect(isPiiMode(null)).toBe(false);
+    expect(isPiiMode("xx")).toBe(false);
+  });
+});
+
+describe("federation/pii — PiiPipeline class", () => {
+  test("defaults to soc2 mode", () => {
+    const p = new PiiPipeline();
+    expect(p.getMode()).toBe("soc2");
+  });
+
+  test("setMode accepts the 4 documented modes", () => {
+    const p = new PiiPipeline();
+    for (const m of PII_MODES) {
+      p.setMode(m);
+      expect(p.getMode()).toBe(m);
+    }
+  });
+
+  test("setMode throws on unknown mode", () => {
+    const p = new PiiPipeline();
+    expect(() => p.setMode("nope" as unknown as PiiMode)).toThrow(/unknown mode/);
+  });
+
+  test("process() returns the same shape as apply()", () => {
+    const p = new PiiPipeline({ mode: "gdpr" });
+    const r = p.process("alice@example.com");
+    expect(r.transformed).toContain("[REDACTED:email]");
+    expect(r.mode).toBe("gdpr");
+  });
+});

package/packages/sdk/tests/federation/policy.test.ts

@@ -0,0 +1,140 @@
+/**
+ * federation/policy.test.ts — F-038 PolicyEngine tests.
+ *
+ * Covers:
+ *   - maxHops enforcement: hopCount >= maxHops denies.
+ *   - Action allowlist: unknown + disallowed message kinds denied.
+ *   - Peer blocklist: blocked source node denied.
+ *   - Budget validation: missing + invalid budget denied.
+ *   - Runtime mutators: allowMessageType / denyMessageType / setBlocked.
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import { PolicyEngine, DEFAULT_MAX_HOPS } from "../../src/federation/policy.js";
+import {
+  emptyScanResult,
+  type EnvelopeBudget,
+  type FederationEnvelope,
+} from "../../src/federation/envelope.js";
+
+function makeEnvelope(overrides: Partial<FederationEnvelope> = {}): FederationEnvelope {
+  return {
+    envelopeId: "env-1",
+    sourceNodeId: "node-A",
+    targetNodeId: "node-B",
+    sessionId: "sess-1",
+    messageType: "heartbeat",
+    payload: null,
+    timestamp: new Date().toISOString(),
+    nonce: "nonce-1",
+    hmacSignature: "sig-1",
+    piiScanResult: emptyScanResult(),
+    hopCount: 0,
+    ...overrides,
+  };
+}
+
+const defaultBudget: EnvelopeBudget = { maxTokens: 1000, maxUsd: 1.0, maxHops: 3 };
+
+describe("federation/policy — enforce()", () => {
+  let engine: PolicyEngine;
+
+  beforeEach(() => {
+    engine = new PolicyEngine();
+  });
+
+  test("admits a fresh envelope with default budget", () => {
+    const e = makeEnvelope();
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(true);
+  });
+
+  test("denies when hopCount >= maxHops", () => {
+    const e = makeEnvelope({ hopCount: 3 });
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("max_hops_exceeded");
+  });
+
+  test("denies when hopCount exceeds the engine ceiling (default 3)", () => {
+    const e = makeEnvelope({ hopCount: 4, budget: { maxTokens: 10, maxUsd: 1, maxHops: 100 } });
+    const r = engine.enforce(e, { maxTokens: 10, maxUsd: 1, maxHops: 100 });
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("max_hops_exceeded");
+  });
+
+  test("admits hopCount=2 with maxHops=3 budget", () => {
+    const e = makeEnvelope({ hopCount: 2 });
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(true);
+  });
+
+  test("denies unknown message kind", () => {
+    const e = makeEnvelope({ messageType: "not-a-kind" as never });
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("message_type_not_allowed");
+  });
+
+  test("denies message kind outside the configured allowlist", () => {
+    const strict = new PolicyEngine({ allowedMessageTypes: ["heartbeat"] });
+    const e = makeEnvelope({ messageType: "agent-spawn" });
+    const r = strict.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("message_type_not_allowed");
+  });
+
+  test("denies peer in the blocklist", () => {
+    const strict = new PolicyEngine({ peerBlocklist: ["node-A"] });
+    const e = makeEnvelope();
+    const r = strict.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("peer_blocked");
+  });
+
+  test("denies when budget is missing", () => {
+    const r = engine.enforce(makeEnvelope(), undefined);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("budget_missing");
+  });
+
+  test("denies when budget has invalid maxHops", () => {
+    const r = engine.enforce(makeEnvelope(), { maxTokens: 1, maxUsd: 1, maxHops: Number.NaN });
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("budget_invalid");
+  });
+});
+
+describe("federation/policy — runtime mutators", () => {
+  test("allowMessageType / denyMessageType mutate the allowlist", () => {
+    const engine = new PolicyEngine({ allowedMessageTypes: ["heartbeat"] });
+    const e = makeEnvelope({ messageType: "agent-spawn" });
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(false);
+    engine.allowMessageType("agent-spawn");
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(true);
+    engine.denyMessageType("heartbeat");
+    expect(engine.enforce(makeEnvelope({ messageType: "heartbeat" }), defaultBudget).allowed).toBe(false);
+  });
+
+  test("setBlocked mutates the blocklist", () => {
+    const engine = new PolicyEngine();
+    const e = makeEnvelope();
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(true);
+    engine.setBlocked("node-A", true);
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(false);
+    engine.setBlocked("node-A", false);
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(true);
+  });
+
+  test("DEFAULT_MAX_HOPS is 3 per spec", () => {
+    expect(DEFAULT_MAX_HOPS).toBe(3);
+  });
+
+  test("engine ceiling override is respected", () => {
+    const strict = new PolicyEngine({ maxHops: 1 });
+    const e = makeEnvelope({ hopCount: 1 });
+    const r = strict.enforce(e, { maxTokens: 10, maxUsd: 1, maxHops: 99 });
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("max_hops_exceeded");
+  });
+});

package/packages/sdk/tests/federation/trust.test.ts

@@ -0,0 +1,124 @@
+/**
+ * federation/trust.test.ts — F-038 TrustEvaluator tests.
+ *
+ * Covers:
+ *   - evaluate() allows allowlisted peer with fresh envelope.
+ *   - evaluate() denies non-allowlisted peer.
+ *   - evaluate() denies too-old envelope.
+ *   - recordOutcome() updates the recent fail rate.
+ *   - Low score (high fail rate) triggers denial.
+ *   - setAllowlisted mutates the runtime allowlist.
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import {
+  MAX_TRUST_AGE_MS,
+  MIN_TRUST_SCORE,
+  TrustEvaluator,
+  type PeerState,
+} from "../../src/federation/trust.js";
+import {
+  emptyScanResult,
+  type FederationEnvelope,
+} from "../../src/federation/envelope.js";
+
+function makeEnvelope(overrides: Partial<FederationEnvelope> = {}): FederationEnvelope {
+  return {
+    envelopeId: "env-1",
+    sourceNodeId: "node-A",
+    targetNodeId: "node-B",
+    sessionId: "sess-1",
+    messageType: "heartbeat",
+    payload: null,
+    timestamp: new Date().toISOString(),
+    nonce: "nonce-1",
+    hmacSignature: "sig-1",
+    piiScanResult: emptyScanResult(),
+    ...overrides,
+  };
+}
+
+function allowlistedPeer(nodeId = "node-A"): PeerState {
+  return { nodeId, allowlisted: true, recentFailRate: 0, lastSeenMs: Date.now() };
+}
+
+describe("federation/trust — evaluate()", () => {
+  let te: TrustEvaluator;
+
+  beforeEach(() => {
+    te = new TrustEvaluator({ allowlist: ["node-A"] });
+  });
+
+  test("allows an allowlisted peer with a fresh envelope", () => {
+    const r = te.evaluate(makeEnvelope(), allowlistedPeer());
+    expect(r.allowed).toBe(true);
+    expect(r.score).toBeGreaterThanOrEqual(MIN_TRUST_SCORE);
+  });
+
+  test("denies a non-allowlisted peer", () => {
+    const peer: PeerState = { nodeId: "node-X", allowlisted: false, recentFailRate: 0 };
+    const r = te.evaluate(makeEnvelope(), peer);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.reason).toMatch(/allowlist/);
+  });
+
+  test("denies an envelope older than MAX_TRUST_AGE_MS", () => {
+    const old = makeEnvelope({
+      timestamp: new Date(Date.now() - MAX_TRUST_AGE_MS - 1000).toISOString(),
+    });
+    const r = te.evaluate(old, allowlistedPeer());
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.reason).toMatch(/too_old/);
+  });
+
+  test("denies when score falls below MIN_TRUST_SCORE (high fail rate)", () => {
+    te.recordOutcome("node-A", false);
+    te.recordOutcome("node-A", false);
+    te.recordOutcome("node-A", false);
+    te.recordOutcome("node-A", false);
+    const peer = te.getPeerState("node-A");
+    const r = te.evaluate(makeEnvelope(), peer);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.reason).toMatch(/score_below_floor/);
+  });
+
+  test("allows when only successes are recorded", () => {
+    for (let i = 0; i < 5; i++) te.recordOutcome("node-A", true);
+    const peer = te.getPeerState("node-A");
+    expect(peer.recentFailRate).toBe(0);
+    const r = te.evaluate(makeEnvelope(), peer);
+    expect(r.allowed).toBe(true);
+  });
+});
+
+describe("federation/trust — runtime mutations", () => {
+  test("setAllowlisted adds a new peer at runtime", () => {
+    const te = new TrustEvaluator({ allowlist: [] });
+    expect(te.isAllowlisted("node-A")).toBe(false);
+    te.setAllowlisted("node-A", true);
+    expect(te.isAllowlisted("node-A")).toBe(true);
+  });
+
+  test("setAllowlisted(false) removes a peer at runtime", () => {
+    const te = new TrustEvaluator({ allowlist: ["node-A"] });
+    expect(te.isAllowlisted("node-A")).toBe(true);
+    te.setAllowlisted("node-A", false);
+    expect(te.isAllowlisted("node-A")).toBe(false);
+  });
+
+  test("getPeerState returns default zeros for an unknown peer", () => {
+    const te = new TrustEvaluator();
+    const peer = te.getPeerState("never-seen");
+    expect(peer.allowlisted).toBe(false);
+    expect(peer.recentFailRate).toBe(0);
+    expect(peer.lastSeenMs).toBeUndefined();
+  });
+
+  test("computeScore is in [0, 1] for the corner cases", () => {
+    const te = new TrustEvaluator({ allowlist: ["node-A"] });
+    const env = makeEnvelope();
+    expect(te.computeScore(env, { nodeId: "node-A", allowlisted: true, recentFailRate: 0 })).toBeLessThanOrEqual(1);
+    expect(te.computeScore(env, { nodeId: "node-A", allowlisted: true, recentFailRate: 1 })).toBeGreaterThanOrEqual(0);
+    expect(te.computeScore(env, { nodeId: "node-A", allowlisted: false, recentFailRate: 0 })).toBe(0);
+  });
+});