@fiscalmindset/blindfold 0.4.0

package/dist/lib/proxy.mjs

@@ -0,0 +1,1078 @@
+// src/proxy.ts
+import http from "node:http";
+import crypto from "node:crypto";
+import fs4 from "node:fs";
+import net from "node:net";
+
+// src/constants.ts
+var SENTINEL = "__BLINDFOLD__";
+var CONTRACT_TAIL = "blindfold-proxy";
+var CONTRACT_VERSION = "0.5.6";
+
+// src/env.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/keychain.ts
+import { spawnSync } from "node:child_process";
+var SERVICE = "blindfold";
+var isWin = process.platform === "win32";
+function has(cmd) {
+  const finder = isWin ? "where" : "which";
+  const r = spawnSync(finder, [cmd], { stdio: "ignore" });
+  return r.status === 0;
+}
+var WIN_CS = `
+using System;
+using System.Runtime.InteropServices;
+public static class BFCred {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  public struct CREDENTIAL {
+    public UInt32 Flags; public UInt32 Type;
+    [MarshalAs(UnmanagedType.LPWStr)] public string TargetName;
+    [MarshalAs(UnmanagedType.LPWStr)] public string Comment;
+    public System.Runtime.InteropServices.ComTypes.FILETIME LastWritten;
+    public UInt32 CredentialBlobSize; public IntPtr CredentialBlob; public UInt32 Persist;
+    public UInt32 AttributeCount; public IntPtr Attributes;
+    [MarshalAs(UnmanagedType.LPWStr)] public string TargetAlias;
+    [MarshalAs(UnmanagedType.LPWStr)] public string UserName;
+  }
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern bool CredWriteW(ref CREDENTIAL c, UInt32 f);
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern bool CredReadW(string t, UInt32 ty, UInt32 f, out IntPtr c);
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern bool CredDeleteW(string t, UInt32 ty, UInt32 f);
+  [DllImport("advapi32.dll")] public static extern void CredFree(IntPtr c);
+}
+`;
+var PS_HEADER = `$ErrorActionPreference='Stop'
+Add-Type -TypeDefinition @"
+${WIN_CS}
+"@
+`;
+function winPS(op, target, secret) {
+  let body;
+  if (op === "set") {
+    body = `$b=[System.Text.Encoding]::UTF8.GetBytes($env:BF_SECRET);$p=[Runtime.InteropServices.Marshal]::AllocHGlobal($b.Length);[Runtime.InteropServices.Marshal]::Copy($b,0,$p,$b.Length);$c=New-Object BFCred+CREDENTIAL;$c.Type=1;$c.TargetName=$env:BF_TARGET;$c.UserName=$env:BF_TARGET;$c.CredentialBlobSize=$b.Length;$c.CredentialBlob=$p;$c.Persist=2;$ok=[BFCred]::CredWriteW([ref]$c,0);[Runtime.InteropServices.Marshal]::FreeHGlobal($p);if($ok){[Console]::Out.Write('BFOK')}`;
+  } else if (op === "get") {
+    body = `$ptr=[IntPtr]::Zero;if([BFCred]::CredReadW($env:BF_TARGET,1,0,[ref]$ptr)){$c=[Runtime.InteropServices.Marshal]::PtrToStructure($ptr,[BFCred+CREDENTIAL]);$n=[int]$c.CredentialBlobSize;$b=New-Object byte[] $n;[Runtime.InteropServices.Marshal]::Copy([IntPtr]$c.CredentialBlob,$b,0,$n);[BFCred]::CredFree($ptr);[Console]::Out.Write([System.Text.Encoding]::UTF8.GetString($b))}else{exit 1}`;
+  } else {
+    body = `if([BFCred]::CredDeleteW($env:BF_TARGET,1,0)){[Console]::Out.Write('BFOK')}`;
+  }
+  const env = { ...process.env, BF_TARGET: target };
+  if (secret !== void 0) env.BF_SECRET = secret;
+  const r = spawnSync(
+    "powershell",
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", "-"],
+    { input: PS_HEADER + body, env, encoding: "utf8" }
+  );
+  return { status: r.status, stdout: typeof r.stdout === "string" ? r.stdout : "" };
+}
+function winTarget(account) {
+  return `${SERVICE}:${account}`;
+}
+function keychainAvailable() {
+  if (process.platform === "darwin") return has("security");
+  if (process.platform === "linux") return has("secret-tool");
+  if (isWin) return has("powershell");
+  return false;
+}
+function keychainGet(account) {
+  if (process.platform === "darwin") {
+    const r = spawnSync("security", ["find-generic-password", "-a", account, "-s", SERVICE, "-w"], { encoding: "utf8" });
+    if (r.status === 0 && typeof r.stdout === "string") return r.stdout.replace(/\n$/, "");
+    return null;
+  }
+  if (process.platform === "linux") {
+    const r = spawnSync("secret-tool", ["lookup", "service", SERVICE, "account", account], { encoding: "utf8" });
+    if (r.status === 0 && r.stdout) return r.stdout.replace(/\n$/, "");
+    return null;
+  }
+  if (isWin) {
+    const r = winPS("get", winTarget(account));
+    if (r.status === 0 && r.stdout) return r.stdout.replace(/\r?\n$/, "");
+    return null;
+  }
+  return null;
+}
+
+// src/env.ts
+var HERE = path.dirname(fileURLToPath(import.meta.url));
+var SRC_RELATIVE_ROOT = path.resolve(HERE, "..", "..", "..");
+var _repoRoot = null;
+function repoRoot() {
+  if (_repoRoot) return _repoRoot;
+  let dir = process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (fs.existsSync(path.join(dir, ".env")) || fs.existsSync(path.join(dir, ".blindfold")) || fs.existsSync(path.join(dir, ".git"))) {
+      _repoRoot = dir;
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  _repoRoot = SRC_RELATIVE_ROOT;
+  return _repoRoot;
+}
+function homeDir() {
+  return path.join(os.homedir(), ".blindfold");
+}
+function configPath() {
+  return path.join(homeDir(), "config.json");
+}
+function stateDir() {
+  const override = process.env.BLINDFOLD_STATE_DIR;
+  if (override && override.trim()) return path.resolve(override.trim());
+  const home = homeDir();
+  if (!fs.existsSync(home)) {
+    try {
+      const legacy = path.join(repoRoot(), ".blindfold");
+      if (fs.existsSync(legacy) && fs.statSync(legacy).isDirectory()) {
+        fs.cpSync(legacy, home, { recursive: true });
+      } else {
+        fs.mkdirSync(home, { recursive: true });
+      }
+    } catch {
+      try {
+        fs.mkdirSync(home, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  return home;
+}
+function assertSafeOverrideUrl(raw, label) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    throw new Error(`${label} is not a valid URL: ${raw}`);
+  }
+  const isLocal = ["localhost", "127.0.0.1", "::1", "[::1]"].includes(u.hostname);
+  if (u.protocol !== "https:" && !isLocal) {
+    throw new Error(`${label} must be https (got ${u.protocol}//${u.hostname}); refusing to trust an insecure endpoint`);
+  }
+}
+function withFileLockSync(target, fn) {
+  const lockPath = `${target}.lock`;
+  const deadline = Date.now() + 1e4;
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  const sleep = (ms) => {
+    try {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    } catch {
+    }
+  };
+  for (; ; ) {
+    try {
+      const fd = fs.openSync(lockPath, "wx");
+      fs.writeSync(fd, String(process.pid));
+      fs.closeSync(fd);
+      break;
+    } catch (e) {
+      if (e?.code !== "EEXIST") throw e;
+      try {
+        const st = fs.statSync(lockPath);
+        if (Date.now() - st.mtimeMs > 1e4) {
+          fs.rmSync(lockPath, { force: true });
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) throw new Error(`timed out acquiring lock ${lockPath}`);
+      sleep(25);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    fs.rmSync(lockPath, { force: true });
+  }
+}
+function loadEnvFromFile(envPath = path.join(repoRoot(), ".env")) {
+  if (!fs.existsSync(envPath)) return;
+  const text = fs.readFileSync(envPath, "utf8");
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    let val = line.slice(eq + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    if (process.env[key] === void 0) process.env[key] = val;
+  }
+}
+function loadHomeConfig() {
+  try {
+    const cfg = configPath();
+    if (fs.existsSync(cfg)) {
+      const obj = JSON.parse(fs.readFileSync(cfg, "utf8"));
+      for (const [k, v] of Object.entries(obj)) {
+        if (k === "T3N_API_KEY_STORE") continue;
+        if (typeof v === "string" && process.env[k] === void 0) process.env[k] = v;
+      }
+    }
+  } catch {
+  }
+  loadEnvFromFile(path.join(homeDir(), ".env"));
+  if (process.env.T3N_API_KEY === void 0 && process.env.DID && keychainAvailable()) {
+    const k = keychainGet(process.env.DID);
+    if (k) process.env.T3N_API_KEY = k;
+  }
+}
+function loadBlindfoldEnv() {
+  loadEnvFromFile();
+  loadHomeConfig();
+  const t3nApiKey = process.env.T3N_API_KEY ?? "";
+  const did = process.env.DID ?? "";
+  const port = Number.parseInt(process.env.BLINDFOLD_PORT ?? "8787", 10);
+  const t3EnvRaw = (process.env.BLINDFOLD_T3_ENV ?? "testnet").toLowerCase();
+  const t3Env = t3EnvRaw === "production" ? "production" : "testnet";
+  const t3BaseUrl = (process.env.T3_BASE_URL ?? process.env.BLINDFOLD_BASE_URL ?? "").trim();
+  if (t3BaseUrl) {
+    assertSafeOverrideUrl(t3BaseUrl, process.env.T3_BASE_URL ? "T3_BASE_URL" : "BLINDFOLD_BASE_URL");
+  }
+  const mock = process.env.BLINDFOLD_MOCK === "1";
+  return { t3nApiKey, did, port, t3Env, t3BaseUrl, mock };
+}
+function assertRealReady(env) {
+  if (env.mock) return;
+  const missing = [];
+  if (!env.t3nApiKey) missing.push("T3N_API_KEY");
+  if (!env.did) missing.push("DID");
+  if (missing.length > 0) {
+    throw new Error(
+      `Missing required env: ${missing.join(", ")}. Claim them at https://docs.terminal3.io/developers/adk/get-started/prerequisites/request-test-tokens, then put them in .env. Or set BLINDFOLD_MOCK=1 to use mock mode for the demo only.`
+    );
+  }
+}
+
+// src/log.ts
+var HEADER_BLOCKLIST = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "x-api-key",
+  "cookie",
+  "set-cookie"
+]);
+function safeLog(level, obj) {
+  const safe = typeof obj === "string" ? { msg: obj } : redact(obj);
+  const line = JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), level, ...safe });
+  process.stderr.write(line + "\n");
+}
+function redact(input) {
+  const out = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (k === "headers" && v && typeof v === "object") {
+      out[k] = redactHeaders(v);
+    } else if (HEADER_BLOCKLIST.has(k.toLowerCase())) {
+      out[k] = "[redacted]";
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function redactHeaders(h) {
+  if (Array.isArray(h)) {
+    return h.map(([k, v]) => [k, HEADER_BLOCKLIST.has(k.toLowerCase()) ? "[redacted]" : v]);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(h)) {
+    out[k] = HEADER_BLOCKLIST.has(k.toLowerCase()) ? "[redacted]" : String(v);
+  }
+  return out;
+}
+
+// src/t3-client.ts
+import { createHash, randomBytes } from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+var T3_TIMEOUT_MS = Number(process.env.BLINDFOLD_T3_TIMEOUT_MS) || 3e4;
+var T3TimeoutError = class extends Error {
+};
+function withDeadline(promise, label, ms = T3_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new T3TimeoutError(`T3 ${label} timed out after ${ms}ms`)), ms);
+    if (typeof timer.unref === "function") timer.unref();
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+function egressCachePath() {
+  return process.env.BLINDFOLD_EGRESS_CACHE ?? path2.join(stateDir(), "egress-hosts.json");
+}
+function loadEgressHosts(did) {
+  try {
+    const all = JSON.parse(fs2.readFileSync(egressCachePath(), "utf8"));
+    return Array.isArray(all[did]) ? all[did] : [];
+  } catch {
+    return [];
+  }
+}
+function saveEgressHosts(did, hosts) {
+  const p = egressCachePath();
+  withFileLockSync(p, () => {
+    let all = {};
+    try {
+      all = JSON.parse(fs2.readFileSync(p, "utf8"));
+    } catch {
+    }
+    const existing = Array.isArray(all[did]) ? all[did] : [];
+    all[did] = Array.from(/* @__PURE__ */ new Set([...existing, ...hosts])).sort();
+    fs2.mkdirSync(path2.dirname(p), { recursive: true });
+    fs2.writeFileSync(p, JSON.stringify(all, null, 2));
+  });
+}
+var sdkCache = null;
+async function loadSdk() {
+  if (sdkCache) return sdkCache;
+  try {
+    const mod = await import("@terminal3/t3n-sdk");
+    sdkCache = mod;
+    return mod;
+  } catch {
+    throw new Error(
+      "@terminal3/t3n-sdk not installed. Run `npm install @terminal3/t3n-sdk` for REAL T3 mode, or set BLINDFOLD_MOCK=1 to keep using mock mode."
+    );
+  }
+}
+async function openT3Client(env) {
+  if (env.mock) return openMockClient();
+  assertRealReady(env);
+  return openRealClient(env);
+}
+async function openRealClient(env) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(env.t3nApiKey)) {
+    throw new Error("T3N_API_KEY must be a 0x-prefixed 32-byte hex (secp256k1 private key).");
+  }
+  if (!/^did:t3n:[0-9a-fA-F]+$/.test(env.did)) {
+    throw new Error('DID must look like "did:t3n:<hex>".');
+  }
+  const sdk = await loadSdk();
+  sdk.setEnvironment(env.t3Env);
+  const baseUrl = env.t3BaseUrl || sdk.NODE_URLS[env.t3Env];
+  const wasmComponent = await sdk.loadWasmComponent();
+  const address = sdk.eth_get_address(env.t3nApiKey);
+  const t3n = new sdk.T3nClient({
+    baseUrl,
+    wasmComponent,
+    handlers: { EthSign: sdk.metamask_sign(address, void 0, env.t3nApiKey) }
+  });
+  await t3n.handshake();
+  await t3n.authenticate(sdk.createEthAuthInput(address));
+  const tenant = new sdk.TenantClient({
+    environment: env.t3Env,
+    baseUrl,
+    tenantDid: env.did,
+    t3n
+  });
+  const seedSecret = async (name, value) => {
+    await tenant.executeControl("map-entry-set", {
+      map_name: tenant.canonicalName("secrets"),
+      key: name,
+      value
+    });
+    safeLog("info", { msg: "seeded", name });
+  };
+  const registerContract = async (wasm) => {
+    const r = await tenant.contracts.register({
+      tail: CONTRACT_TAIL,
+      version: CONTRACT_VERSION,
+      wasm
+    });
+    return {
+      contractId: r.contract_id ?? r.contractId ?? "(unknown)"
+    };
+  };
+  const invokeForward = async (req) => {
+    const raw = await withDeadline(tenant.contracts.execute(CONTRACT_TAIL, {
+      version: CONTRACT_VERSION,
+      functionName: "forward",
+      input: req
+    }), "forward");
+    if (typeof raw.status === "number" && Array.isArray(raw.headers)) {
+      return { status: raw.status, headers: raw.headers, body: raw.body ?? "" };
+    }
+    return {
+      status: raw.code ?? 502,
+      headers: [["content-type", "application/json"]],
+      body: raw.body ?? ""
+    };
+  };
+  const decodeSecret = (v) => {
+    if (typeof v === "string") return v;
+    if (Array.isArray(v)) return Buffer.from(v).toString("utf8");
+    if (v && typeof v === "object") {
+      const o = v;
+      if (typeof o.value === "string") return o.value;
+      if (Array.isArray(o.value)) return Buffer.from(o.value).toString("utf8");
+      const entry = o.entry;
+      if (entry && typeof entry.value === "string") return entry.value;
+    }
+    return "";
+  };
+  const releaseSecret = async (name) => {
+    try {
+      const r = await withDeadline(tenant.contracts.execute(CONTRACT_TAIL, {
+        version: CONTRACT_VERSION,
+        functionName: "release-to-tenant",
+        input: { secret_key: name }
+      }), "release-to-tenant");
+      if (r && r.ok && r.value) return r.value;
+    } catch (e) {
+      if (e instanceof T3TimeoutError) throw e;
+    }
+    const direct = decodeSecret(
+      await withDeadline(tenant.executeControl("map-entry-get", {
+        map_name: tenant.canonicalName("secrets"),
+        key: name
+      }), "map-entry-get")
+    );
+    if (!direct) throw new Error(`secret "${name}" not found in the secrets map`);
+    return direct;
+  };
+  const me = async () => {
+    const info = await tenant.tenant.me();
+    return { tenant: String(info.tenant ?? ""), status: info.status };
+  };
+  const agentAuthUpdate = async (agentDid, hosts, functions) => {
+    let ucv = "0.1.0";
+    if (typeof sdk.getScriptVersion === "function") {
+      try {
+        const v = await sdk.getScriptVersion(baseUrl, "tee:user/contracts");
+        if (typeof v === "string" && /^\d/.test(v)) ucv = v;
+      } catch {
+      }
+    }
+    const didHex = env.did.replace(/^did:t3n:/, "");
+    const revoking = functions.length === 0 && hosts.length === 0;
+    const scripts = [{
+      scriptName: `z:${didHex}:${CONTRACT_TAIL}`,
+      versionReq: `>=${CONTRACT_VERSION}`,
+      functions: revoking ? ["forward"] : functions,
+      allowedHosts: revoking ? [] : hosts
+    }];
+    await t3n.execute({
+      script_name: "tee:user/contracts",
+      script_version: ucv,
+      function_name: "agent-auth-update",
+      input: { agents: [{ agentDid, scripts }] }
+    });
+  };
+  const grantEgress = async (hosts, opts) => {
+    const prev = opts?.replace ? [] : loadEgressHosts(env.did);
+    const merged = Array.from(/* @__PURE__ */ new Set([...prev, ...hosts])).sort();
+    await agentAuthUpdate(env.did, merged, ["forward", "release-to-tenant"]);
+    saveEgressHosts(env.did, merged);
+    return merged;
+  };
+  const setAgentGrant = (agentDid, hosts, functions) => agentAuthUpdate(agentDid, hosts, functions);
+  const verifySecret = async (name) => {
+    try {
+      const value = await releaseSecret(name);
+      return { present: true, length: value.length, fingerprint: createHash("sha256").update(value).digest("hex").slice(0, 8) };
+    } catch {
+      return { present: false, length: 0, fingerprint: "" };
+    }
+  };
+  const getBalance = async () => {
+    const page = await withDeadline(tenant.token.getUsage(), "token.getUsage");
+    const b = page.balance ?? {};
+    return {
+      available: Number(b.available ?? 0),
+      reserved: Number(b.reserved ?? 0),
+      creditExhausted: Boolean(b.credit_exhausted),
+      storageDeposit: b.storage_deposit != null ? Number(b.storage_deposit) : void 0
+    };
+  };
+  return {
+    close: async () => {
+    },
+    seedSecret,
+    invokeForward,
+    registerContract,
+    releaseSecret,
+    me,
+    grantEgress,
+    setAgentGrant,
+    verifySecret,
+    getBalance,
+    isReal: true
+  };
+}
+function openMockClient() {
+  return {
+    close: async () => {
+    },
+    async seedSecret(name, value) {
+      if (!value || value.length === 0) throw new Error(`secret ${name} is empty`);
+      safeLog("info", { msg: "mock-seed (value dropped, length only)", name, length: value.length });
+    },
+    async registerContract(wasm) {
+      safeLog("info", { msg: "mock-register-contract", wasmBytes: wasm.byteLength });
+      return { contractId: "mock-contract-1" };
+    },
+    async invokeForward(req) {
+      safeLog("info", {
+        msg: "mock-forward",
+        method: req.method,
+        url: schemeAndHost(req.url),
+        secret_key: req.secret_key
+      });
+      const body = `{"mock":true,"note":"Blindfold mock mode \u2014 no real call made.","echo":{"url":${JSON.stringify(req.url)}}}`;
+      return { status: 200, headers: [["content-type", "application/json"]], body };
+    },
+    async releaseSecret(name) {
+      safeLog("info", { msg: "mock-release", name });
+      return `mock-released:${name}`;
+    },
+    async me() {
+      return { tenant: "did:t3n:mock", status: "active" };
+    },
+    async grantEgress(hosts) {
+      safeLog("info", { msg: "mock-grant-egress", hosts });
+      return hosts;
+    },
+    async setAgentGrant(agentDid, hosts, functions) {
+      safeLog("info", { msg: "mock-set-agent-grant", agentDid, hosts, functions });
+    },
+    async verifySecret(name) {
+      return { present: true, length: 0, fingerprint: `mock-${name}`.slice(0, 8) };
+    },
+    async getBalance() {
+      return { available: 1e9, reserved: 0, creditExhausted: false, mock: true };
+    },
+    isReal: false
+  };
+}
+function schemeAndHost(url) {
+  try {
+    const u = new URL(url);
+    return `${u.protocol}//${u.host}`;
+  } catch {
+    return "<bad-url>";
+  }
+}
+
+// src/usage-log.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+function defaultLogPath() {
+  return process.env.BLINDFOLD_USAGE_LOG ?? path3.join(stateDir(), "usage.jsonl");
+}
+var USAGE_MAX_BYTES = Number(process.env.BLINDFOLD_USAGE_MAX_BYTES) || 10 * 1024 * 1024;
+function rotateIfNeeded(p) {
+  try {
+    const size = fs3.statSync(p).size;
+    if (size < USAGE_MAX_BYTES) return;
+    if (fs3.existsSync(`${p}.1`)) fs3.renameSync(`${p}.1`, `${p}.2`);
+    fs3.renameSync(p, `${p}.1`);
+  } catch {
+  }
+}
+var ensuredDirs = /* @__PURE__ */ new Set();
+var ROTATE_CHECK_EVERY = 500;
+var writesSinceRotateCheck = ROTATE_CHECK_EVERY;
+function logUsage(event) {
+  const p = defaultLogPath();
+  try {
+    const dir = path3.dirname(p);
+    if (!ensuredDirs.has(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+      ensuredDirs.add(dir);
+    }
+    if (++writesSinceRotateCheck >= ROTATE_CHECK_EVERY) {
+      writesSinceRotateCheck = 0;
+      rotateIfNeeded(p);
+    }
+    fs3.appendFile(p, JSON.stringify(event) + "\n", () => {
+    });
+  } catch {
+  }
+}
+function providerForUpstream(upstream) {
+  try {
+    const u = new URL(upstream);
+    const h = u.hostname;
+    if (h.endsWith("openai.com")) return "openai";
+    if (h.endsWith("anthropic.com")) return "anthropic";
+    if (h.endsWith("googleapis.com")) return "google";
+    if (h.endsWith("x.ai")) return "xai";
+    if (h.endsWith("groq.com")) return "groq";
+    return h;
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/providers.ts
+function amzDate(now = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${now.getUTCFullYear()}${p(now.getUTCMonth() + 1)}${p(now.getUTCDate())}T${p(now.getUTCHours())}${p(now.getUTCMinutes())}${p(now.getUTCSeconds())}Z`;
+}
+var awsRegion = () => process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+var awsAccessKeyId = () => process.env.AWS_ACCESS_KEY_ID || "";
+function stripPrefix(path4, prefix) {
+  const rest = path4.slice(prefix.length - 1);
+  return rest.startsWith("/") ? rest : `/${rest}`;
+}
+var PROVIDERS = [
+  // ---- LLM providers (OpenAI-shaped, bearer). Back-compatible. --------------
+  { id: "openai", prefix: "/v1/", upstream: (p) => `https://api.openai.com${p}`, auth: () => ({ scheme: "bearer" }) },
+  { id: "openai", prefix: "/openai/", upstream: (p) => `https://api.openai.com${stripPrefix(p, "/openai/")}`, auth: () => ({ scheme: "bearer" }) },
+  // Anthropic REQUIRES the anthropic-version header on the raw REST API.
+  { id: "anthropic", prefix: "/anthropic/", upstream: (p) => `https://api.anthropic.com${stripPrefix(p, "/anthropic/")}`, auth: () => ({ scheme: "bearer" }), defaultHeaders: { "anthropic-version": "2023-06-01" } },
+  { id: "xai", prefix: "/x/", upstream: (p) => `https://api.x.ai${stripPrefix(p, "/x/")}`, auth: () => ({ scheme: "bearer" }) },
+  { id: "groq", prefix: "/groq/", upstream: (p) => `https://api.groq.com/openai${stripPrefix(p, "/groq/")}`, auth: () => ({ scheme: "bearer" }) },
+  // ---- LLM: Google Gemini (native API — key rides in `x-goog-api-key`). ------
+  // Not OpenAI-shaped and NOT `Authorization: Bearer`. The sentinel is planted
+  // in Google's provider-specific header and swapped for the sealed key inside
+  // the enclave — proving Blindfold handles a provider's real auth convention,
+  // not just the one bearer shape.
+  {
+    id: "gemini",
+    prefix: "/gemini/",
+    upstream: (p) => `https://generativelanguage.googleapis.com${stripPrefix(p, "/gemini/")}`,
+    secretKey: "gemini_api_key",
+    auth: () => ({ scheme: "bearer" }),
+    sentinelHeader: { name: "x-goog-api-key", prefix: "" }
+  },
+  // ---- Payments: Stripe (bearer; pins the API version so behaviour is stable). -----
+  {
+    id: "stripe",
+    prefix: "/stripe/",
+    upstream: (p) => `https://api.stripe.com${stripPrefix(p, "/stripe/")}`,
+    secretKey: "stripe_secret_key",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: { "stripe-version": "2024-06-20", "content-type": "application/x-www-form-urlencoded" }
+  },
+  // ---- Dev infra: GitHub. GitHub REJECTS requests with no User-Agent (403),
+  //      and best practice is to pin the REST API version + set the Accept type.
+  {
+    id: "github",
+    prefix: "/github/",
+    upstream: (p) => `https://api.github.com${stripPrefix(p, "/github/")}`,
+    secretKey: "github_token",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: {
+      accept: "application/vnd.github+json",
+      "x-github-api-version": "2022-11-28",
+      "user-agent": "blindfold"
+    }
+  },
+  // ---- Email: SendGrid (bearer; JSON v3 API). -------------------------------
+  {
+    id: "sendgrid",
+    prefix: "/sendgrid/",
+    upstream: (p) => `https://api.sendgrid.com${stripPrefix(p, "/sendgrid/")}`,
+    secretKey: "sendgrid_api_key",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: { "content-type": "application/json" }
+  },
+  // ---- Comms: Slack (bearer bot token; Web API wants JSON+charset on POST). --
+  {
+    id: "slack",
+    prefix: "/slack/",
+    upstream: (p) => `https://slack.com/api${stripPrefix(p, "/slack/")}`,
+    secretKey: "slack_bot_token",
+    auth: () => ({ scheme: "bearer" }),
+    defaultHeaders: { "content-type": "application/json; charset=utf-8" }
+  },
+  // ---- Telephony: Twilio (HTTP Basic — base64 computed IN the enclave). -----
+  // Username = Account SID (not secret; also appears in the URL path). The
+  // sealed secret is the Auth Token. A generic proxy CANNOT do this: the
+  // base64 must be computed after the secret is joined, inside TDX.
+  {
+    id: "twilio",
+    prefix: "/twilio/",
+    upstream: (p) => `https://api.twilio.com${stripPrefix(p, "/twilio/")}`,
+    secretKey: "twilio_auth_token",
+    auth: () => ({ scheme: "basic", username: process.env.TWILIO_ACCOUNT_SID || "" }),
+    defaultHeaders: { "content-type": "application/x-www-form-urlencoded" }
+  },
+  // ---- Cloud: AWS SES (SigV4 — secret SIGNS, never transmitted). ------------
+  {
+    id: "aws-ses",
+    prefix: "/aws/ses/",
+    upstream: (p) => `https://email.${awsRegion()}.amazonaws.com${stripPrefix(p, "/aws/ses/")}`,
+    secretKey: "aws_secret_access_key",
+    auth: () => ({ scheme: "sigv4", access_key_id: awsAccessKeyId(), region: awsRegion(), service: "ses", amz_date: amzDate() })
+  },
+  // ---- Cloud: AWS S3 (SigV4). -----------------------------------------------
+  {
+    id: "aws-s3",
+    prefix: "/aws/s3/",
+    upstream: (p) => `https://s3.${awsRegion()}.amazonaws.com${stripPrefix(p, "/aws/s3/")}`,
+    secretKey: "aws_secret_access_key",
+    auth: () => ({ scheme: "sigv4", access_key_id: awsAccessKeyId(), region: awsRegion(), service: "s3", amz_date: amzDate() })
+  },
+  // ---- Webhook: Discord. The SECRET IS THE URL — the enclave substitutes the
+  //      sealed webhook URL for the sentinel, so the agent POSTs to /discord
+  //      with only a JSON body and never holds the URL. Needs egress for
+  //      discord.com (`blindfold grant --host discord.com`).
+  {
+    id: "discord",
+    prefix: "/discord",
+    upstream: () => SENTINEL,
+    // enclave replaces this with the sealed webhook URL
+    secretKey: "webhook_discord_url",
+    auth: () => ({ scheme: "webhook" })
+  }
+];
+function resolveProvider(path4) {
+  const def = PROVIDERS.filter((d) => path4.startsWith(d.prefix)).sort((a, b) => b.prefix.length - a.prefix.length)[0];
+  if (!def) return null;
+  return {
+    id: def.id,
+    upstream: def.upstream(path4),
+    secretKey: def.secretKey,
+    auth: def.auth(),
+    sentinelHeader: def.sentinelHeader,
+    defaultHeaders: def.defaultHeaders
+  };
+}
+
+// src/proxy.ts
+var MAX_BODY_BYTES = Number(process.env.BLINDFOLD_MAX_BODY_BYTES) || 5 * 1024 * 1024;
+var BODY_IDLE_MS = Number(process.env.BLINDFOLD_BODY_IDLE_MS) || 3e4;
+var MAX_INFLIGHT = Number(process.env.BLINDFOLD_MAX_INFLIGHT) || 64;
+var inflight = 0;
+var PayloadTooLargeError = class extends Error {
+};
+function tokenMatches(provided, expected) {
+  const a = Buffer.from(provided);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) return false;
+  return crypto.timingSafeEqual(a, b);
+}
+var PROXY_TOKEN_HEADER = "x-blindfold-token";
+function isSocketLive(socketPath) {
+  return new Promise((resolve) => {
+    if (!fs4.existsSync(socketPath)) {
+      resolve(false);
+      return;
+    }
+    const c = net.connect(socketPath);
+    const done = (live) => {
+      try {
+        c.destroy();
+      } catch {
+      }
+      resolve(live);
+    };
+    c.once("connect", () => done(true));
+    c.once("error", () => done(false));
+    c.setTimeout(500, () => done(false));
+  });
+}
+async function startProxy(opts = {}) {
+  const env = loadBlindfoldEnv();
+  const port = opts.port ?? env.port ?? 8787;
+  const secretKey = opts.secretKey ?? "openai_api_key";
+  const token = (opts.token ?? process.env.BLINDFOLD_PROXY_TOKEN ?? "").trim() || void 0;
+  const socketPath = opts.socket?.trim() || void 0;
+  if (socketPath && await isSocketLive(socketPath)) {
+    throw new Error(`a Blindfold proxy is already listening on ${socketPath} \u2014 stop it first, or use a different --socket path`);
+  }
+  const t3 = await openT3Client(env);
+  const server = http.createServer((req, res) => {
+    handle(req, res, t3, secretKey, env, token).catch((e) => {
+      if (e instanceof PayloadTooLargeError) {
+        if (!res.headersSent) res.writeHead(413, { "content-type": "text/plain", "connection": "close" });
+        res.end("request body too large");
+        req.destroy();
+        return;
+      }
+      safeLog("error", { msg: "proxy_unhandled", error: e.message });
+      if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain" });
+      res.end("internal proxy error");
+    });
+  });
+  return await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    let prevUmask;
+    const onListening = () => {
+      let url;
+      let bound = 0;
+      if (socketPath) {
+        try {
+          fs4.chmodSync(socketPath, 384);
+        } catch {
+        }
+        if (prevUmask !== void 0) {
+          try {
+            process.umask(prevUmask);
+          } catch {
+          }
+        }
+        url = `unix:${socketPath}`;
+      } else {
+        bound = server.address().port;
+        url = `http://127.0.0.1:${bound}`;
+      }
+      safeLog("info", { msg: "proxy_listening", url, mock: env.mock });
+      resolve({
+        url,
+        port: bound,
+        token,
+        socket: socketPath,
+        close: async () => {
+          await new Promise((r) => server.close(() => r()));
+          if (socketPath) {
+            try {
+              fs4.rmSync(socketPath, { force: true });
+            } catch {
+            }
+          }
+          await t3.close();
+        }
+      });
+    };
+    if (socketPath) {
+      try {
+        fs4.rmSync(socketPath, { force: true });
+      } catch {
+      }
+      prevUmask = process.umask(127);
+      server.listen(socketPath, onListening);
+    } else {
+      server.listen(port, "127.0.0.1", onListening);
+    }
+  });
+}
+async function handle(req, res, t3, secretKey, env, token) {
+  if (req.url === "/health") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ ok: true, mock: env.mock, auth: Boolean(token) }));
+    return;
+  }
+  if (token) {
+    const provided = String(req.headers[PROXY_TOKEN_HEADER] ?? "");
+    if (!provided || !tokenMatches(provided, token)) {
+      safeLog("warn", { msg: "proxy_unauthorized", path: req.url });
+      res.writeHead(401, { "content-type": "text/plain" });
+      res.end(`unauthorized: missing or invalid ${PROXY_TOKEN_HEADER} header`);
+      return;
+    }
+  }
+  const provider = resolveProvider(req.url ?? "/");
+  if (!provider) {
+    res.writeHead(404, { "content-type": "text/plain" });
+    res.end(`no upstream mapping for ${req.url}`);
+    return;
+  }
+  const upstream = provider.upstream;
+  const providerSecretKey = provider.secretKey ?? secretKey;
+  const body = await readBody(req, MAX_BODY_BYTES);
+  const agentSuppliedAuth = Object.keys(req.headers).some((k) => k.toLowerCase() === "authorization");
+  const headers = forwardableHeaders(req.headers);
+  if (provider.auth.scheme === "bearer") {
+    const sh = provider.sentinelHeader ?? { name: "authorization", prefix: "Bearer " };
+    removeHeader(headers, "authorization");
+    ensureHeader(headers, sh.name, `${sh.prefix}${SENTINEL}`);
+  } else {
+    removeHeader(headers, "authorization");
+  }
+  for (const [name, value] of Object.entries(provider.defaultHeaders ?? {})) {
+    if (!headers.some(([k]) => k.toLowerCase() === name.toLowerCase())) {
+      headers.push([name, value]);
+    }
+  }
+  let outboundUrl = upstream;
+  let outboundBody = body.length ? body.toString("utf8") : void 0;
+  const contentType = (headers.find(([k]) => k.toLowerCase() === "content-type")?.[1] ?? "").toLowerCase();
+  if (provider.auth.scheme !== "webhook" && outboundBody && contentType.includes("application/x-www-form-urlencoded")) {
+    const u = new URL(outboundUrl);
+    for (const [k, v] of new URLSearchParams(outboundBody)) u.searchParams.append(k, v);
+    outboundUrl = u.toString();
+    outboundBody = void 0;
+    safeLog("info", { msg: "form_body_to_query", provider: provider.id });
+  }
+  const forwardReq = {
+    method: req.method ?? "GET",
+    url: outboundUrl,
+    headers,
+    body: outboundBody,
+    secret_key: providerSecretKey,
+    auth: provider.auth
+  };
+  safeLog("info", {
+    msg: "proxy_forward",
+    method: forwardReq.method,
+    upstream: upstream.replace(/\?.*$/, "")
+  });
+  if (inflight >= MAX_INFLIGHT) {
+    safeLog("warn", { msg: "proxy_saturated", inflight, max: MAX_INFLIGHT });
+    if (!res.headersSent) res.writeHead(503, { "content-type": "text/plain", "retry-after": "1" });
+    res.end("proxy saturated: too many concurrent enclave calls \u2014 retry shortly");
+    return;
+  }
+  const startedAt = Date.now();
+  let result;
+  inflight++;
+  try {
+    result = await t3.invokeForward(forwardReq);
+  } catch (e) {
+    const { status, body: body2 } = explainForwardError(e);
+    safeLog("error", { msg: "proxy_forward_failed", status, provider: provider.id, error: e.message });
+    if (!res.headersSent) res.writeHead(status, { "content-type": "application/json" });
+    res.end(body2);
+    return;
+  } finally {
+    inflight--;
+  }
+  const latency = Date.now() - startedAt;
+  logUsage({
+    t: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: env.mock ? "mock" : "real",
+    provider: provider.id || providerForUpstream(upstream),
+    method: forwardReq.method,
+    path: req.url ?? "/",
+    upstream: upstream.replace(/\?.*$/, ""),
+    status: result.status,
+    latency_ms: latency,
+    agent_supplied_auth: agentSuppliedAuth,
+    auth_scheme: provider.auth.scheme,
+    sentinel_in_outbound: forwardReq.headers.some(([k, v]) => k.toLowerCase() === "authorization" && v.includes(SENTINEL)),
+    via: "proxy",
+    secret_key: providerSecretKey
+  });
+  res.writeHead(result.status, headersFromTuple(result.headers));
+  const bodyBytes = typeof result.body === "string" ? Buffer.from(result.body, "utf8") : Buffer.from(result.body);
+  res.end(bodyBytes);
+}
+function readBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let aborted = false;
+    let timer;
+    const fail = (e) => {
+      aborted = true;
+      clearTimeout(timer);
+      reject(e);
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        if (!aborted) fail(new Error(`request body read timed out after ${BODY_IDLE_MS}ms`));
+      }, BODY_IDLE_MS);
+    };
+    arm();
+    req.on("data", (c) => {
+      if (aborted) return;
+      arm();
+      size += c.length;
+      if (size > maxBytes) {
+        fail(new PayloadTooLargeError(`request body exceeds ${maxBytes} bytes`));
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => {
+      clearTimeout(timer);
+      if (!aborted) resolve(Buffer.concat(chunks));
+    });
+    req.on("error", (e) => {
+      if (!aborted) fail(e);
+    });
+  });
+}
+var STRIPPED = /* @__PURE__ */ new Set(["host", "content-length", "connection", "transfer-encoding"]);
+function forwardableHeaders(h) {
+  const out = [];
+  for (const [k, v] of Object.entries(h)) {
+    if (v === void 0) continue;
+    if (STRIPPED.has(k.toLowerCase())) continue;
+    out.push([k, Array.isArray(v) ? v.join(", ") : v]);
+  }
+  return out;
+}
+function ensureHeader(h, name, value) {
+  const lower = name.toLowerCase();
+  const idx = h.findIndex(([k]) => k.toLowerCase() === lower);
+  if (idx >= 0) h[idx] = [name, value];
+  else h.push([name, value]);
+}
+function removeHeader(h, name) {
+  const lower = name.toLowerCase();
+  for (let i = h.length - 1; i >= 0; i--) {
+    if (h[i][0].toLowerCase() === lower) h.splice(i, 1);
+  }
+}
+function headersFromTuple(t) {
+  const out = {};
+  for (const [k, v] of t) out[k] = v;
+  return out;
+}
+function explainForwardError(err) {
+  const msg = err?.message ?? String(err);
+  if (err instanceof T3TimeoutError) {
+    return {
+      status: 504,
+      body: JSON.stringify({
+        error: "blindfold_forward_failed",
+        status: 504,
+        code: "t3_timeout",
+        detail: msg,
+        hint: "The T3 node did not respond within the deadline (BLINDFOLD_T3_TIMEOUT_MS). It may be slow or unreachable; retry, or point T3_BASE_URL at a healthy node."
+      }, null, 2)
+    };
+  }
+  let status = Number(msg.match(/HTTP (\d{3})/)?.[1]) || 502;
+  let code = "";
+  let detail = msg;
+  let requestId = "";
+  const jsonM = msg.match(/\((\{.*\})\)\s*$/);
+  if (jsonM && jsonM[1]) {
+    try {
+      const o = JSON.parse(jsonM[1]);
+      code = o.code ?? "";
+      detail = o.detail ?? detail;
+      requestId = o.request_id ?? "";
+    } catch {
+    }
+  }
+  let hint = "";
+  if (/egress_denied|authorised_hosts|allowlist/i.test(detail)) {
+    const host = detail.match(/host '([^']+)'/)?.[1];
+    hint = `Egress is not authorized${host ? ` for '${host}'` : ""}. Run: blindfold grant --host ${host ?? "<host>"} \u2014 list every host you use in ONE command (grant replaces the allowlist unless merged).`;
+    if (status < 400) status = 403;
+  } else if (/fuel_per_minute|too_many_requests|rate limit/i.test(detail)) {
+    hint = "Rate limited by the testnet per-minute compute quota (fuel_per_minute). Retry in ~60s and space calls out \u2014 this is not an outage.";
+    status = 429;
+  } else if (/cannot read map|:secrets/i.test(detail)) {
+    hint = "The contract isn't authorized to read your secrets map (common right after publishing a new contract id). Run: blindfold init (re-grants the secrets read ACL).";
+  } else if (/parse_payload|expected value at line/i.test(detail)) {
+    hint = "The T3 host egress parses request bodies as JSON. For form-encoded APIs (Stripe/Twilio), send params in the query string with an empty body.";
+    if (status < 400) status = 400;
+  } else if (/secret .* not found|not found in the secrets map/i.test(detail)) {
+    hint = "That sealed secret name doesn't exist. Seal it: blindfold register --name <name> --from-env <ENV_VAR>.";
+  }
+  const payload = {
+    error: "blindfold_forward_failed",
+    status,
+    code: code || void 0,
+    detail,
+    request_id: requestId || void 0,
+    hint: hint || void 0
+  };
+  return { status, body: JSON.stringify(payload, null, 2) };
+}
+export {
+  PROXY_TOKEN_HEADER,
+  startProxy
+};