@fungi.computer/veil 0.2.1 → 0.4.0

package/dist/provider-egress.js

@@ -1,8 +1,33 @@
+import { z } from "zod";
 import { VeilError } from "./index.js";
 const CAMEL_BASE = "https://stream.camelai.com/v1";
 const PARALLEL_BASE = "https://api.parallel.ai";
 const GATEWAY_ORIGIN = "https://gateway.ai.cloudflare.com";
 const CLOUDFLARE_API_ORIGIN = "https://api.cloudflare.com";
+const HELIUS_BASE = "https://mainnet.helius-rpc.com/";
+const OFAC_SDN = "https://sanctionslistservice.ofac.treas.gov/api/PublicationPreview/exports/SDN.XML";
+const OFAC_DOWNLOAD_ORIGIN = "https://wc2h-sls-prod-public-published.s3.us-gov-west-1.amazonaws.com";
+// Single read-only JSON-RPC calls used by the finalized holdings/lock reader.
+// Zod owns JSON envelope decoding; the holdings owner owns params and results.
+const snapshotCall = z
+    .object({
+    jsonrpc: z.literal("2.0"),
+    id: z.union([z.string(), z.number()]),
+    method: z.enum([
+        "getAccountInfo",
+        "getMultipleAccounts",
+        "getProgramAccounts",
+        "getTokenSupply",
+        "getSlot",
+    ]),
+    params: z.array(z.unknown()).optional(),
+})
+    .strict();
+function snapshotRoute(route) {
+    return (route === "solana-rpc" ||
+        route === "solana-rpc-fallback" ||
+        route === "sanctions-screen");
+}
 const present = (value) => {
     const trimmed = value?.trim();
     return trimmed === undefined || trimmed === "" ? undefined : trimmed;
@@ -18,6 +43,34 @@ function gatewayScope(env) {
 /** The destination and credential for a route; `undefined` if either is missing. */
 function target(env, route) {
     switch (route) {
+        case "solana-rpc":
+        case "solana-rpc-fallback": {
+            const primary = route === "solana-rpc";
+            const raw = present(primary ? env.SOLANA_RPC_URL : env.SOLANA_RPC_FALLBACK_URL);
+            const credential = present(primary ? env.SOLANA_RPC_API_KEY : env.SOLANA_RPC_FALLBACK_API_KEY);
+            if (raw === undefined || credential === undefined)
+                return undefined;
+            if (!URL.canParse(raw))
+                return undefined;
+            const base = new URL(raw);
+            if (base.protocol !== "https:" ||
+                base.username ||
+                base.password ||
+                base.port ||
+                base.pathname !== "/" ||
+                base.search ||
+                base.hash)
+                return undefined;
+            if (primary
+                ? base.href !== HELIUS_BASE
+                : !/^[a-z0-9-]+\.solana-mainnet\.quiknode\.pro$/u.test(base.hostname))
+                return undefined;
+            return { base, credential };
+        }
+        case "sanctions-screen":
+            return present(env.SANCTIONS_SDN_URL) === OFAC_SDN
+                ? { base: new URL(OFAC_SDN) }
+                : undefined;
         case "camel": {
             const credential = present(env.CAMEL_API_KEY);
             return credential === undefined
@@ -67,6 +120,8 @@ function within(url, base) {
 }
 /** Replace whatever credential the caller sent with this route's own. */
 function authorize(route, headers, credential) {
+    if (credential === undefined)
+        throw new VeilError("unavailable");
     for (const name of [
         "authorization",
         "x-api-key",
@@ -75,6 +130,11 @@ function authorize(route, headers, credential) {
     ])
         headers.delete(name);
     switch (route) {
+        case "solana-rpc":
+        case "solana-rpc-fallback":
+        case "sanctions-screen":
+            // These doors construct their own headers and URL below.
+            return;
         case "camel":
         case "ai-gateway-logs":
             headers.set("authorization", `Bearer ${credential}`);
@@ -87,6 +147,130 @@ function authorize(route, headers, credential) {
             return;
     }
 }
+/** A bounded body, before JSON decoding or returning a provider response. */
+async function boundedText(message, limit) {
+    const reader = message.body?.getReader();
+    if (reader === undefined)
+        return "";
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            const chunk = part.value;
+            if (!(chunk instanceof Uint8Array))
+                throw new VeilError("unavailable");
+            size += chunk.byteLength;
+            if (size > limit)
+                throw new VeilError("unavailable");
+            chunks.push(chunk);
+        }
+        return await new Blob(chunks).text();
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
+/** Fixed, non-streaming snapshot doors never return upstream headers or URLs. */
+async function fetchSnapshot(route, resolved, request, transport) {
+    try {
+        const url = new URL(request.url);
+        if (url.href !== resolved.base.href)
+            throw new VeilError("denied");
+        const screening = route === "sanctions-screen";
+        if (request.method !== (screening ? "GET" : "POST"))
+            throw new VeilError("denied");
+        let body;
+        if (!screening) {
+            body = await boundedText(request, 64 * 1024);
+            let envelope;
+            try {
+                envelope = JSON.parse(body);
+            }
+            catch {
+                throw new VeilError("denied");
+            }
+            if (!snapshotCall.safeParse(envelope).success)
+                throw new VeilError("denied");
+        }
+        const destination = new URL(resolved.base);
+        const key = resolved.credential;
+        if (!screening) {
+            if (key === undefined)
+                throw new VeilError("unavailable");
+            if (route === "solana-rpc")
+                destination.searchParams.set("api-key", key);
+            else
+                destination.pathname = `/${encodeURIComponent(key)}/`;
+        }
+        const init = {
+            method: request.method,
+            headers: screening
+                ? { accept: "application/xml" }
+                : {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                },
+            signal: request.signal,
+            redirect: "manual",
+        };
+        if (body !== undefined)
+            init.body = body;
+        let response = await transport(new Request(destination, init));
+        // OFAC publishes a signed S3 download URL. Only this anonymous GET door
+        // may follow that one observed 302; the next response must succeed.
+        if (screening && response.status === 302) {
+            const location = response.headers.get("location");
+            await response.body?.cancel();
+            if (location === null ||
+                location.length > 8192 ||
+                !URL.canParse(location))
+                throw new VeilError("unavailable");
+            const download = new URL(location);
+            if (download.origin !== OFAC_DOWNLOAD_ORIGIN ||
+                download.username !== "" ||
+                download.password !== "" ||
+                !download.pathname.startsWith("/Published/") ||
+                !download.pathname.endsWith("/SDN.XML") ||
+                download.hash !== "")
+                throw new VeilError("unavailable");
+            request.signal.throwIfAborted();
+            response = await transport(new Request(download, {
+                method: "GET",
+                headers: { accept: "application/xml" },
+                signal: request.signal,
+                redirect: "manual",
+            }));
+        }
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new VeilError("unavailable");
+        }
+        const text = await boundedText(response, 64 * 1024 * 1024);
+        if (key !== undefined &&
+            [key, encodeURIComponent(key), JSON.stringify(key).slice(1, -1)].some((echo) => text.includes(echo)))
+            throw new VeilError("unavailable");
+        return new Response(text, {
+            status: response.status,
+            headers: {
+                "content-type": screening ? "application/xml" : "application/json",
+            },
+        });
+    }
+    catch (error) {
+        // Even aborted transports can include a credential-bearing URL in errors.
+        if (error instanceof VeilError)
+            throw error;
+        throw new VeilError("unavailable");
+    }
+}
 /**
  * The provider-key door. `fetch` is the transport the authorized request is
  * finally sent on (a test double, or the Hub's telemetry-wrapped fetch).
@@ -94,9 +278,13 @@ function authorize(route, headers, credential) {
 export function createProviderEgress(env, options = {}) {
     const transport = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
     return {
-        /** Whether this route's credential is configured; reveals no value. */
+        /** Whether required custody/configuration is present; reveals no value. */
         credentialed(route) {
             switch (route) {
+                case "solana-rpc":
+                case "solana-rpc-fallback":
+                case "sanctions-screen":
+                    return target(env, route) !== undefined;
                 case "camel":
                     return present(env.CAMEL_API_KEY) !== undefined;
                 case "parallel":
@@ -116,9 +304,9 @@ export function createProviderEgress(env, options = {}) {
         /**
          * Send a credential-free request to a route. Refuses (`denied`) any
          * destination outside the route and (`unavailable`) a route with no
-         * credential. Redirects are never followed, so a redirect cannot carry
-         * the key to another origin (workerd has no `error` mode; `manual` hands
-         * the 3xx back instead).
+         * credential. Credentialed routes never follow redirects (workerd has no
+         * `error` mode; `manual` hands the 3xx back instead). Only the anonymous
+         * sanctions GET may follow one pinned OFAC government-S3 302.
          */
         async fetch(route, input, init) {
             const resolved = target(env, route);
@@ -134,6 +322,8 @@ export function createProviderEgress(env, options = {}) {
             }
             if (!within(new URL(request.url), resolved.base))
                 throw new VeilError("denied");
+            if (snapshotRoute(route))
+                return fetchSnapshot(route, resolved, request, transport);
             const headers = new Headers(request.headers);
             authorize(route, headers, resolved.credential);
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/veil",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Team-authorized credential custody and provider access",
   "type": "module",
@@ -23,6 +23,10 @@
       "types": "./dist/model-credentials.d.ts",
       "import": "./dist/model-credentials.js"
     },
+    "./credential-store": {
+      "types": "./dist/credential-store.d.ts",
+      "import": "./dist/credential-store.js"
+    },
     "./model-keys": {
       "types": "./dist/model-keys.d.ts",
       "import": "./dist/model-keys.js"
@@ -78,6 +82,10 @@
     "./owned-infrastructure": {
       "types": "./dist/owned-infrastructure.d.ts",
       "import": "./dist/owned-infrastructure.js"
+    },
+    "./connections": {
+      "types": "./dist/connections/index.d.ts",
+      "import": "./dist/connections/index.js"
     }
   },
   "files": [
@@ -87,6 +95,8 @@
   ],
   "dependencies": {
     "@fungi.computer/cairn": "0.1.0",
+    "@fungi.computer/forage": "0.3.1",
+    "@modelcontextprotocol/client": "2.0.0",
     "@nangohq/node": "0.71.6",
     "effect": "4.0.2",
     "http-parser-js": "0.5.10",
@@ -94,6 +104,7 @@
     "zod": "4.4.3"
   },
   "devDependencies": {
+    "@fungi.computer/watchdog": "0.1.0",
     "@types/node": "24.13.3",
     "typescript": "5.9.3",
     "vitest": "4.1.11"