@astrasyncai/verification-gateway 4.2.1 → 4.4.0

package/dist/adapters/mcp.d.mts

@@ -1,7 +1,44 @@
 import { Request, Response, RequestHandler } from 'express';
-import { a as AccessLevel, G as GatewayConfig, x as VerificationResult } from '../types-r850cOt0.mjs';
+import { a as AccessLevel, G as GatewayConfig, x as VerificationResult } from '../types-C0zfSXMB.mjs';
 import '../metadata-capture.mjs';
 
+/**
+ * X-Astra-Verified-Hop — cross-hop verify-access dedupe marker.
+ *
+ * Header carrying upstream verify-access proof so an inner-hop endpoint can
+ * dedupe (skip verify-access when the same ASTRA-id was already verified a
+ * few ms earlier). Emitted by the MCP adapter toward tool fetches and by the
+ * edge gateway toward the origin at authenticate/authorize depth. Value
+ * format:
+ *
+ *   {astraId};{sessionId};{checkedAt-ms}
+ *
+ * Receivers MUST validate that `checkedAt` is recent (≤ 60s window
+ * recommended) and that `astraId` matches the agent identity claimed on the
+ * inner hop. The header alone is NOT proof-of-identity — it's an UNSIGNED
+ * dedupe advisory: trust it (`trustVerifiedHop`) only where every network
+ * path to the inner hop crosses a stripping gateway or an equivalent trusted
+ * boundary, exactly like the unsigned X-AstraSync-* attestation headers.
+ * Pair with the existing X-Astra-Id auth.
+ */
+declare const MCP_VERIFIED_HOP_HEADER = "X-Astra-Verified-Hop";
+interface VerifiedHopMarker {
+    astraId: string;
+    sessionId?: string;
+    checkedAt: number;
+}
+declare function serializeVerifiedHop(marker: VerifiedHopMarker): string;
+declare function parseVerifiedHop(value: string | undefined | null): VerifiedHopMarker | null;
+/**
+ * Returns true when `marker.astraId` matches the inner-hop's claimed
+ * ASTRA-id AND the marker is recent enough. Inner-hop middleware uses this
+ * to skip a duplicate verify-access call.
+ */
+declare function isVerifiedHopValidFor(marker: VerifiedHopMarker | null, expectedAstraId: string, opts?: {
+    maxAgeMs?: number;
+    now?: number;
+}): boolean;
+
 /**
  * MCP server-side helpers — companion to `transport/mcp.ts` (which handles the
  * agent-side `_meta.astrasync` block).
@@ -31,35 +68,6 @@ import '../metadata-capture.mjs';
  * The Express MCP adapter is in `adapters/mcp.ts` and consumes these.
  */
 
-/**
- * Header carrying upstream verify-access proof so an inner-hop REST endpoint
- * can dedupe (skip verify-access when the same ASTRA-id was already verified
- * a few ms earlier). Value format:
- *
- *   {astraId};{sessionId};{checkedAt-ms}
- *
- * Receivers MUST validate that `checkedAt` is recent (≤ 60s window
- * recommended) and that `astraId` matches the agent identity claimed on the
- * inner hop. The header alone is NOT proof-of-identity — it's a dedupe
- * advisory. Pair with the existing X-Astra-Id auth.
- */
-declare const MCP_VERIFIED_HOP_HEADER = "X-Astra-Verified-Hop";
-interface VerifiedHopMarker {
-    astraId: string;
-    sessionId?: string;
-    checkedAt: number;
-}
-declare function serializeVerifiedHop(marker: VerifiedHopMarker): string;
-declare function parseVerifiedHop(value: string | undefined | null): VerifiedHopMarker | null;
-/**
- * Returns true when `marker.astraId` matches the inner-hop's claimed
- * ASTRA-id AND the marker is recent enough. Inner-hop middleware uses this
- * to skip a duplicate verify-access call.
- */
-declare function isVerifiedHopValidFor(marker: VerifiedHopMarker | null, expectedAstraId: string, opts?: {
-    maxAgeMs?: number;
-    now?: number;
-}): boolean;
 /**
  * Output of `parseMcpJsonRpc`. Self-describing so the middleware doesn't have
  * to re-introspect the body to figure out gating.

package/dist/adapters/mcp.d.ts

@@ -1,7 +1,44 @@
 import { Request, Response, RequestHandler } from 'express';
-import { a as AccessLevel, G as GatewayConfig, x as VerificationResult } from '../types-sMxBT-nM.js';
+import { a as AccessLevel, G as GatewayConfig, x as VerificationResult } from '../types-DwSfO7Sb.js';
 import '../metadata-capture.js';
 
+/**
+ * X-Astra-Verified-Hop — cross-hop verify-access dedupe marker.
+ *
+ * Header carrying upstream verify-access proof so an inner-hop endpoint can
+ * dedupe (skip verify-access when the same ASTRA-id was already verified a
+ * few ms earlier). Emitted by the MCP adapter toward tool fetches and by the
+ * edge gateway toward the origin at authenticate/authorize depth. Value
+ * format:
+ *
+ *   {astraId};{sessionId};{checkedAt-ms}
+ *
+ * Receivers MUST validate that `checkedAt` is recent (≤ 60s window
+ * recommended) and that `astraId` matches the agent identity claimed on the
+ * inner hop. The header alone is NOT proof-of-identity — it's an UNSIGNED
+ * dedupe advisory: trust it (`trustVerifiedHop`) only where every network
+ * path to the inner hop crosses a stripping gateway or an equivalent trusted
+ * boundary, exactly like the unsigned X-AstraSync-* attestation headers.
+ * Pair with the existing X-Astra-Id auth.
+ */
+declare const MCP_VERIFIED_HOP_HEADER = "X-Astra-Verified-Hop";
+interface VerifiedHopMarker {
+    astraId: string;
+    sessionId?: string;
+    checkedAt: number;
+}
+declare function serializeVerifiedHop(marker: VerifiedHopMarker): string;
+declare function parseVerifiedHop(value: string | undefined | null): VerifiedHopMarker | null;
+/**
+ * Returns true when `marker.astraId` matches the inner-hop's claimed
+ * ASTRA-id AND the marker is recent enough. Inner-hop middleware uses this
+ * to skip a duplicate verify-access call.
+ */
+declare function isVerifiedHopValidFor(marker: VerifiedHopMarker | null, expectedAstraId: string, opts?: {
+    maxAgeMs?: number;
+    now?: number;
+}): boolean;
+
 /**
  * MCP server-side helpers — companion to `transport/mcp.ts` (which handles the
  * agent-side `_meta.astrasync` block).
@@ -31,35 +68,6 @@ import '../metadata-capture.js';
  * The Express MCP adapter is in `adapters/mcp.ts` and consumes these.
  */
 
-/**
- * Header carrying upstream verify-access proof so an inner-hop REST endpoint
- * can dedupe (skip verify-access when the same ASTRA-id was already verified
- * a few ms earlier). Value format:
- *
- *   {astraId};{sessionId};{checkedAt-ms}
- *
- * Receivers MUST validate that `checkedAt` is recent (≤ 60s window
- * recommended) and that `astraId` matches the agent identity claimed on the
- * inner hop. The header alone is NOT proof-of-identity — it's a dedupe
- * advisory. Pair with the existing X-Astra-Id auth.
- */
-declare const MCP_VERIFIED_HOP_HEADER = "X-Astra-Verified-Hop";
-interface VerifiedHopMarker {
-    astraId: string;
-    sessionId?: string;
-    checkedAt: number;
-}
-declare function serializeVerifiedHop(marker: VerifiedHopMarker): string;
-declare function parseVerifiedHop(value: string | undefined | null): VerifiedHopMarker | null;
-/**
- * Returns true when `marker.astraId` matches the inner-hop's claimed
- * ASTRA-id AND the marker is recent enough. Inner-hop middleware uses this
- * to skip a duplicate verify-access call.
- */
-declare function isVerifiedHopValidFor(marker: VerifiedHopMarker | null, expectedAstraId: string, opts?: {
-    maxAgeMs?: number;
-    now?: number;
-}): boolean;
 /**
  * Output of `parseMcpJsonRpc`. Self-describing so the middleware doesn't have
  * to re-introspect the body to figure out gating.

package/dist/adapters/mcp.js

@@ -31,6 +31,27 @@ __export(mcp_exports, {
 });
 module.exports = __toCommonJS(mcp_exports);
 
+// src/version.ts
+var SDK_VERSION = "4.4.0";
+
+// src/http.ts
+var SDK_USER_AGENT = `astrasync-sdk/${SDK_VERSION}`;
+function withUserAgent(initHeaders) {
+  if (!initHeaders) return { "user-agent": SDK_USER_AGENT };
+  if (initHeaders instanceof Headers) {
+    const copy = new Headers(initHeaders);
+    if (!copy.has("user-agent")) copy.set("user-agent", SDK_USER_AGENT);
+    return copy;
+  }
+  if (Array.isArray(initHeaders)) {
+    const has2 = initHeaders.some(([name]) => name.toLowerCase() === "user-agent");
+    return has2 ? initHeaders : [...initHeaders, ["user-agent", SDK_USER_AGENT]];
+  }
+  const has = Object.keys(initHeaders).some((name) => name.toLowerCase() === "user-agent");
+  return has ? initHeaders : { "user-agent": SDK_USER_AGENT, ...initHeaders };
+}
+var sdkFetch = (input, init) => fetch(input, { ...init, headers: withUserAgent(init?.headers) });
+
 // src/access-levels.ts
 function getTrustLevel(score) {
   if (score >= 80) return "PLATINUM";
@@ -39,9 +60,6 @@ function getTrustLevel(score) {
   return "BRONZE";
 }
 
-// src/version.ts
-var SDK_VERSION = "4.1.0";
-
 // src/well-known.ts
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 var cache = /* @__PURE__ */ new Map();
@@ -52,7 +70,7 @@ function wellKnownUrl(apiBaseUrl) {
 }
 async function fetchWellKnown(apiBaseUrl) {
   const url = wellKnownUrl(apiBaseUrl);
-  const response = await fetch(url, {
+  const response = await sdkFetch(url, {
     method: "GET",
     headers: { Accept: "application/json" },
     signal: AbortSignal.timeout(5e3)
@@ -122,7 +140,7 @@ async function performInitCheck(apiBaseUrl, debug, strictInit, apiKey) {
   initCheckPerformed = true;
   try {
     const probeUrl = `${apiBaseUrl}/agents/verify-access`;
-    const response = await fetch(probeUrl, { method: "HEAD" });
+    const response = await sdkFetch(probeUrl, { method: "HEAD" });
     const contentType = response.headers.get("content-type") ?? "";
     if (contentType.startsWith("text/html")) {
       const message = `[VerificationGateway] apiBaseUrl '${apiBaseUrl}' returned HTML (content-type: ${contentType}). This usually means apiBaseUrl is pointing at a marketing site instead of the API. Expected: 'https://astrasync.ai/api' (prod) or 'https://staging.astrasync.ai/api' (staging).`;
@@ -136,7 +154,7 @@ async function performInitCheck(apiBaseUrl, debug, strictInit, apiKey) {
       );
     }
     if (apiKey) {
-      const selfCheck = await fetch(`${apiBaseUrl}/agents/verify-access/self-check`, {
+      const selfCheck = await sdkFetch(`${apiBaseUrl}/agents/verify-access/self-check`, {
         headers: { Authorization: `Bearer ${apiKey}` }
       });
       if (selfCheck.status === 401) {
@@ -383,7 +401,7 @@ async function callVerifyAccessAPI(config, request) {
     headers["X-API-Key"] = config.apiKey;
   }
   try {
-    const response = await fetch(`${config.apiBaseUrl}/agents/verify-access`, {
+    const response = await sdkFetch(`${config.apiBaseUrl}/agents/verify-access`, {
       method: "POST",
       headers,
       body: JSON.stringify(body),
@@ -626,7 +644,7 @@ async function recordDecision(config, sessionId, decision, reason) {
     headers["Authorization"] = `Bearer ${config.apiKey}`;
     headers["X-API-Key"] = config.apiKey;
   }
-  await fetch(`${config.apiBaseUrl}/agents/verify-access/${sessionId}/decision`, {
+  await sdkFetch(`${config.apiBaseUrl}/agents/verify-access/${sessionId}/decision`, {
     method: "POST",
     headers,
     body: JSON.stringify({ decision, reason })
@@ -644,7 +662,9 @@ var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
   "x-astrasync-signature",
   "x-astrasync-secret",
   "x-hub-signature",
-  "x-hub-signature-256"
+  "x-hub-signature-256",
+  // Short-lived verify dedupe token — must never persist in stored metadata.
+  "x-astra-verified-hop"
 ]);
 var SECRET_HEADER_PREFIXES = ["x-astrasync-", "kya-", "kya_"];
 var CREDENTIAL_HEADER_NAMES = /* @__PURE__ */ new Set([
@@ -669,7 +689,13 @@ var PLATFORM_HEADER_NAMES = /* @__PURE__ */ new Set([
   "x-agent-card-url",
   "x-agent-provider"
 ]);
-var PLATFORM_HEADER_PREFIXES = ["x-goog-", "x-stainless-", "x-anthropic-", "x-openai-"];
+var PLATFORM_HEADER_PREFIXES = [
+  "x-goog-",
+  "x-stainless-",
+  "x-anthropic-",
+  "x-openai-",
+  "sec-ch-"
+];
 var KEY_FORMAT_PREFIXES = [
   "sk-ant-api03",
   "sk-ant-api",
@@ -741,6 +767,7 @@ function sanitizeHeaders(raw) {
   const headers = {};
   const platformHeaders = {};
   let apiKeyFormat;
+  let cookieCount;
   let totalBytes = 0;
   let count = 0;
   if (!raw) return { headers };
@@ -755,6 +782,9 @@ function sanitizeHeaders(raw) {
       if (fmt && !apiKeyFormat) apiKeyFormat = fmt;
       continue;
     }
+    if (name === "cookie") {
+      cookieCount = joined.split(";").filter((s) => s.trim().length > 0).length;
+    }
     if (isSecretHeader(name)) continue;
     let value = joined;
     if (byteLength(value) > MAX_HEADER_VALUE_BYTES) {
@@ -770,6 +800,7 @@ function sanitizeHeaders(raw) {
   const result = { headers };
   if (apiKeyFormat) result.apiKeyFormat = apiKeyFormat;
   if (Object.keys(platformHeaders).length > 0) result.platformHeaders = platformHeaders;
+  if (cookieCount !== void 0) result.cookieCount = cookieCount;
   return result;
 }
 var CONNECTION_HEADER_SOURCES = [
@@ -779,16 +810,28 @@ var CONNECTION_HEADER_SOURCES = [
     ["cf-ipcountry", "x-vercel-ip-country", "cloudfront-viewer-country", "fastly-geo-country"]
   ],
   ["region", ["x-vercel-ip-country-region", "cloudfront-viewer-country-region"]],
+  ["countryRegionName", ["cloudfront-viewer-country-region-name"]],
   ["city", ["x-vercel-ip-city", "cloudfront-viewer-city"]],
+  ["latitude", ["x-vercel-ip-latitude", "cloudfront-viewer-latitude"]],
+  ["longitude", ["x-vercel-ip-longitude", "cloudfront-viewer-longitude"]],
+  ["postalCode", ["x-vercel-ip-postal-code", "cloudfront-viewer-postal-code"]],
   ["asn", ["cloudfront-viewer-asn"]],
   ["tlsVersion", ["cloudfront-viewer-tls"]],
   ["httpVersion", ["cloudfront-viewer-http-version"]],
+  ["timeZone", ["x-vercel-ip-timezone", "cloudfront-viewer-time-zone"]],
+  ["metroCode", ["cloudfront-viewer-metro-code"]],
   // TLS fingerprints can only be computed where TLS terminates. When a CDN
   // terminates TLS in front of the merchant, its fingerprint headers ARE the
   // connection-layer truth — normalising them here is the permanent design.
-  ["tlsFingerprint", ["cf-ja3-hash"]],
-  ["ja4", ["cf-ja4"]]
+  // CloudFront delivers JA3/JA4 only via an origin request policy and only
+  // for HTTPS viewer connections.
+  ["tlsFingerprint", ["cf-ja3-hash", "cloudfront-viewer-ja3-fingerprint"]],
+  ["ja4", ["cf-ja4", "cloudfront-viewer-ja4-fingerprint"]],
+  // Header-structure fingerprint: browser/SDK-distinctive header ordering.
+  ["headerOrder", ["cloudfront-viewer-header-order"]],
+  ["headerCount", ["cloudfront-viewer-header-count"]]
 ];
+var MAX_CONNECTION_VALUE_CHARS = 256;
 function deriveConnectionFromHeaders(headers) {
   if (!headers) return void 0;
   const lower = {};
@@ -801,20 +844,30 @@ function deriveConnectionFromHeaders(headers) {
     for (const source of sources) {
       const value = lower[source]?.trim();
       if (value) {
-        connection[key] = value;
+        connection[key] = value.slice(0, MAX_CONNECTION_VALUE_CHARS);
         break;
       }
     }
   }
+  {
+    const addr = lower["cloudfront-viewer-address"]?.trim();
+    const portMatch = addr?.match(/:(\d+)$/);
+    if (portMatch) connection.sourcePort = portMatch[1];
+    if (!connection.ip && addr) connection.ip = addr.replace(/:\d+$/, "");
+  }
   if (!connection.ip) {
     const xff = lower["x-forwarded-for"];
     const client = xff?.split(",")[0]?.trim();
     if (client) connection.ip = client;
   }
+  if (!connection.tlsCipher) {
+    const cipher = connection.tlsVersion?.split(":")[1];
+    if (cipher) connection.tlsCipher = cipher;
+  }
   return Object.keys(connection).length > 0 ? connection : void 0;
 }
 function buildSdkObservedMetadata(rawHeaders) {
-  const { headers, apiKeyFormat, platformHeaders } = sanitizeHeaders(rawHeaders);
+  const { headers, apiKeyFormat, platformHeaders, cookieCount } = sanitizeHeaders(rawHeaders);
   const flat = {};
   if (rawHeaders) {
     for (const name of Object.keys(rawHeaders)) {
@@ -829,6 +882,7 @@ function buildSdkObservedMetadata(rawHeaders) {
     ...apiKeyFormat && { apiKeyFormat },
     ...platformHeaders && { platformHeaders },
     ...connection && { connection },
+    ...cookieCount !== void 0 && { cookieCount },
     schemaVersion: CAPTURE_SCHEMA_VERSION
   };
 }
@@ -860,7 +914,7 @@ function resolvePollUrl(config, pollUrl) {
 async function pollStepUpStatus(config, approval) {
   if (!approval.pollUrl) return null;
   try {
-    const res = await fetch(resolvePollUrl(config, approval.pollUrl), {
+    const res = await sdkFetch(resolvePollUrl(config, approval.pollUrl), {
       method: "GET",
       signal: AbortSignal.timeout(POLL_REQUEST_TIMEOUT_MS)
     });
@@ -904,7 +958,7 @@ async function awaitStepUpApproval(config, approval) {
   return "timeout";
 }
 
-// src/transport/mcp-server.ts
+// src/verified-hop.ts
 var MCP_VERIFIED_HOP_HEADER = "X-Astra-Verified-Hop";
 var MCP_VERIFIED_HOP_MAX_AGE_MS = 6e4;
 function serializeVerifiedHop(marker) {
@@ -931,6 +985,8 @@ function isVerifiedHopValidFor(marker, expectedAstraId, opts = {}) {
   const now = opts.now ?? Date.now();
   return now - marker.checkedAt <= maxAge && now >= marker.checkedAt;
 }
+
+// src/transport/mcp-server.ts
 function parseMcpJsonRpc(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) return null;
   const obj = body;