@kya-os/checkpoint-wasm-runtime 1.0.0

package/dist/adapters.mjs

@@ -0,0 +1,586 @@
+import { base58btc } from 'multiformats/bases/base58';
+import { gunzipSync } from 'zlib';
+
+// src/engine/adapters/did-resolver.ts
+
+// src/engine/adapters/outbound-url-policy.ts
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "metadata", "metadata.google.internal"]);
+var UnsafeOutboundUrl = class extends Error {
+  kind = "UnsafeOutboundUrl";
+};
+function assertSafeHttpsUrl(rawUrl, label = "outbound URL") {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new UnsafeOutboundUrl(`${label} must be a valid URL: ${rawUrl}`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new UnsafeOutboundUrl(`${label} must use https: ${rawUrl}`);
+  }
+  if (parsed.username || parsed.password) {
+    throw new UnsafeOutboundUrl(`${label} must not contain credentials: ${rawUrl}`);
+  }
+  const hostname = normalizeHostname(parsed.hostname);
+  if (!hostname || isBlockedHostname(hostname)) {
+    throw new UnsafeOutboundUrl(`${label} targets a local or private host: ${rawUrl}`);
+  }
+  return rawUrl;
+}
+function normalizeHostname(hostname) {
+  let normalized = hostname.trim().toLowerCase();
+  if (normalized.startsWith("[") && normalized.endsWith("]")) {
+    normalized = normalized.slice(1, -1);
+  }
+  while (normalized.endsWith(".")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function isBlockedHostname(hostname) {
+  if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
+    return true;
+  }
+  const ipv4 = parseIpv4(hostname);
+  if (ipv4) {
+    return isBlockedIpv4(ipv4);
+  }
+  return isBlockedIpv6(hostname);
+}
+function parseIpv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4) return null;
+  const octets = parts.map((part) => {
+    if (!/^\d{1,3}$/.test(part)) return Number.NaN;
+    const value = Number(part);
+    return value >= 0 && value <= 255 ? value : Number.NaN;
+  });
+  if (octets.some(Number.isNaN)) return null;
+  return octets;
+}
+function isBlockedIpv4([a, b]) {
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isBlockedIpv6(hostname) {
+  if (!hostname.includes(":")) return false;
+  const ipv4Mapped = hostname.match(/(?:^|:)ffff:(\d{1,3}(?:\.\d{1,3}){3})$/);
+  if (ipv4Mapped) {
+    const ipv4 = parseIpv4(ipv4Mapped[1]);
+    return ipv4 ? isBlockedIpv4(ipv4) : true;
+  }
+  if (hostname === "::" || hostname === "::1" || hostname === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  const firstSegment = Number.parseInt(hostname.split(":")[0] || "0", 16);
+  if (Number.isNaN(firstSegment)) return true;
+  return (firstSegment & 65024) === 64512 || // unique local fc00::/7
+  (firstSegment & 65472) === 65152 || // link-local fe80::/10
+  (firstSegment & 65280) === 65280;
+}
+
+// src/engine/adapters/util.ts
+function base64UrlDecode(input) {
+  const padded = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = padded.length % 4 === 0 ? "" : "=".repeat(4 - padded.length % 4);
+  return new Uint8Array(Buffer.from(padded + padding, "base64"));
+}
+
+// src/engine/adapters/did-resolver.ts
+var ED25519_PUBLIC_KEY_LENGTH = 32;
+var MalformedDid = class extends Error {
+  kind = "MalformedDid";
+};
+var UnsupportedKeyType = class extends Error {
+  kind = "UnsupportedKeyType";
+};
+var DidNotFound = class extends Error {
+  kind = "DidNotFound";
+};
+var DidResolverTimeout = class extends Error {
+  kind = "DidResolverTimeout";
+};
+var DidResolverError = class extends Error {
+  kind = "DidResolverError";
+};
+var UnsupportedDidMethod = class extends Error {
+  kind = "UnsupportedDidMethod";
+};
+var ED25519_MULTICODEC_PREFIX = [237, 1];
+var DEFAULT_FETCH_TIMEOUT_MS = 3e3;
+var DEFAULT_TTL_MS = 5 * 6e4;
+function makeDidResolver(opts = {}) {
+  const timeoutMs = opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+  const fetchImpl = opts.fetch ?? fetch;
+  const cache = opts.cache ?? /* @__PURE__ */ new Map();
+  const now = opts.now ?? (() => Date.now());
+  return {
+    async resolve(did) {
+      const cached = cache.get(did);
+      if (cached && now() - cached.fetchedAt < ttlMs) {
+        return cached.value;
+      }
+      if (did.startsWith("did:key:")) {
+        const doc = decodeDidKey(did);
+        cache.set(did, { value: doc, fetchedAt: now() });
+        return doc;
+      }
+      if (did.startsWith("did:web:")) {
+        const doc = await resolveDidWeb(did, fetchImpl, timeoutMs);
+        cache.set(did, { value: doc, fetchedAt: now() });
+        return doc;
+      }
+      throw new UnsupportedDidMethod(`Phase 1 supports did:key and did:web only; got: ${did}`);
+    }
+  };
+}
+function decodeDidKey(did) {
+  if (!did.startsWith("did:key:")) {
+    throw new MalformedDid(`expected did:key prefix, got: ${did}`);
+  }
+  const multibaseValue = did.slice("did:key:".length);
+  if (!multibaseValue.startsWith("z")) {
+    throw new MalformedDid(
+      `did:key expects base58btc (multibase 'z' prefix); got: ${multibaseValue[0] ?? "<empty>"}`
+    );
+  }
+  let decoded;
+  try {
+    decoded = base58btc.decode(multibaseValue);
+  } catch (cause) {
+    throw new MalformedDid(`did:key multibase decode failed: ${String(cause)}`);
+  }
+  if (decoded.length < 2 || decoded[0] !== ED25519_MULTICODEC_PREFIX[0] || decoded[1] !== ED25519_MULTICODEC_PREFIX[1]) {
+    const prefixHex = decoded.length >= 2 ? `0x${decoded[0].toString(16).padStart(2, "0")}${decoded[1].toString(16).padStart(2, "0")}` : "<too short>";
+    throw new UnsupportedKeyType(
+      `did:key expects Ed25519 multicodec 0xed01; got ${prefixHex} (only Ed25519 supported in Phase 1)`
+    );
+  }
+  const publicKey = decoded.slice(2);
+  if (publicKey.length !== 32) {
+    throw new MalformedDid(`did:key Ed25519 public key must be 32 bytes; got ${publicKey.length}`);
+  }
+  const vm = {
+    id: `${did}#${multibaseValue}`,
+    // multibase as fragment — mcp-i-core PR #16
+    keyType: "Ed25519",
+    publicKeyBytes: Array.from(publicKey)
+  };
+  return {
+    id: did,
+    verificationMethods: [vm]
+  };
+}
+async function resolveDidWeb(did, fetchImpl, timeoutMs) {
+  const transformedUrl = didWebToUrl(did);
+  let url;
+  try {
+    url = assertSafeHttpsUrl(transformedUrl, "did:web resolution URL");
+  } catch (cause) {
+    if (cause instanceof UnsafeOutboundUrl) {
+      throw new DidResolverError(cause.message);
+    }
+    throw cause;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(url, { signal: controller.signal });
+  } catch (cause) {
+    if (cause instanceof Error && cause.name === "AbortError") {
+      throw new DidResolverTimeout(`did:web fetch timed out after ${timeoutMs}ms: ${url}`);
+    }
+    throw new DidResolverError(`did:web fetch failed: ${url}: ${String(cause)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 404) {
+    throw new DidNotFound(`no DID document at ${url}`);
+  }
+  if (!response.ok) {
+    throw new DidResolverError(`did:web HTTP ${response.status} at ${url}`);
+  }
+  let raw;
+  try {
+    raw = await response.json();
+  } catch (cause) {
+    throw new DidResolverError(`did:web response not valid JSON at ${url}: ${String(cause)}`);
+  }
+  return mapW3CDocToEngineShape(raw, did);
+}
+function didWebToUrl(did) {
+  const path = did.slice("did:web:".length);
+  if (!path) {
+    throw new MalformedDid(`did:web with empty path: ${did}`);
+  }
+  const parts = path.split(":").map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      throw new MalformedDid(`did:web segment contains invalid percent-encoding: ${segment}`);
+    }
+  });
+  if (parts.length === 1) {
+    return `https://${parts[0]}/.well-known/did.json`;
+  }
+  return `https://${parts[0]}/${parts.slice(1).join("/")}/did.json`;
+}
+function mapW3CDocToEngineShape(raw, requestedDid) {
+  if (raw === null || typeof raw !== "object") {
+    throw new DidResolverError(`did:web response must be a JSON object`);
+  }
+  const doc = raw;
+  const id = typeof doc.id === "string" ? doc.id : requestedDid;
+  const w3cMethods = Array.isArray(doc.verificationMethod) ? doc.verificationMethod : [];
+  const verificationMethods = [];
+  for (const entry of w3cMethods) {
+    if (entry === null || typeof entry !== "object") continue;
+    const vm = entry;
+    if (!isEd25519Type(vm.type)) continue;
+    const vmId = typeof vm.id === "string" ? vm.id : void 0;
+    if (!vmId) continue;
+    const pubKey = extractEd25519PublicKey(vm);
+    if (!pubKey) continue;
+    verificationMethods.push({
+      id: vmId,
+      keyType: "Ed25519",
+      publicKeyBytes: Array.from(pubKey)
+    });
+  }
+  return { id, verificationMethods };
+}
+function isEd25519Type(type) {
+  return type === "Ed25519VerificationKey2020" || type === "Ed25519VerificationKey2018";
+}
+function extractEd25519PublicKey(vm) {
+  if (typeof vm.publicKeyMultibase === "string") {
+    const mb = vm.publicKeyMultibase;
+    if (!mb.startsWith("z")) return null;
+    try {
+      const decoded = base58btc.decode(mb);
+      if (decoded.length === 34 && decoded[0] === ED25519_MULTICODEC_PREFIX[0] && decoded[1] === ED25519_MULTICODEC_PREFIX[1]) {
+        return decoded.slice(2);
+      }
+      if (decoded.length === 32) return decoded;
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  if (vm.publicKeyJwk && typeof vm.publicKeyJwk === "object") {
+    const jwk = vm.publicKeyJwk;
+    if (jwk.kty !== "OKP" || jwk.crv !== "Ed25519") return null;
+    if (typeof jwk.x !== "string") return null;
+    let decoded;
+    try {
+      decoded = base64UrlDecode(jwk.x);
+    } catch {
+      return null;
+    }
+    if (decoded.length !== ED25519_PUBLIC_KEY_LENGTH) {
+      return null;
+    }
+    return decoded;
+  }
+  return null;
+}
+var StatusListUnavailable = class extends Error {
+  kind = "StatusListUnavailable";
+};
+var MalformedStatusList = class extends Error {
+  kind = "MalformedStatusList";
+};
+var StatusListTimeout = class extends Error {
+  kind = "StatusListTimeout";
+};
+var DEFAULT_FETCH_TIMEOUT_MS2 = 3e3;
+var DEFAULT_TTL_MS2 = 3e4;
+function makeStatusListCache(opts = {}) {
+  const timeoutMs = opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS2;
+  const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS2;
+  const fetchImpl = opts.fetch ?? fetch;
+  const cache = opts.cache ?? /* @__PURE__ */ new Map();
+  const now = opts.now ?? (() => Date.now());
+  return {
+    async fetch(url) {
+      const cached = cache.get(url);
+      if (cached && now() - cached.fetchedAt < ttlMs) {
+        return cached.indices;
+      }
+      const indices = await fetchAndDecode(url, fetchImpl, timeoutMs);
+      cache.set(url, { indices, fetchedAt: now() });
+      return indices;
+    }
+  };
+}
+async function fetchAndDecode(url, fetchImpl, timeoutMs) {
+  let safeUrl;
+  try {
+    safeUrl = assertSafeHttpsUrl(url, "status list URL");
+  } catch (cause) {
+    if (cause instanceof UnsafeOutboundUrl) {
+      throw new StatusListUnavailable(cause.message);
+    }
+    throw cause;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(safeUrl, { signal: controller.signal });
+  } catch (cause) {
+    if (cause instanceof Error && cause.name === "AbortError") {
+      throw new StatusListTimeout(`status list fetch timed out after ${timeoutMs}ms: ${url}`);
+    }
+    throw new StatusListUnavailable(`status list fetch failed: ${url}: ${String(cause)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new StatusListUnavailable(`status list HTTP ${response.status} at ${url}`);
+  }
+  let vc;
+  try {
+    vc = await response.json();
+  } catch (cause) {
+    throw new MalformedStatusList(
+      `status list response not valid JSON at ${url}: ${String(cause)}`
+    );
+  }
+  const encoded = extractEncodedList(vc);
+  return enumerateRevokedIndices(encoded);
+}
+function extractEncodedList(vc) {
+  if (vc === null || typeof vc !== "object") {
+    throw new MalformedStatusList("status list VC must be a JSON object");
+  }
+  const obj = vc;
+  const subject = obj.credentialSubject;
+  if (subject === null || typeof subject !== "object") {
+    throw new MalformedStatusList("status list VC missing credentialSubject");
+  }
+  const encoded = subject.encodedList;
+  if (typeof encoded !== "string") {
+    throw new MalformedStatusList("status list VC missing credentialSubject.encodedList string");
+  }
+  return encoded;
+}
+function enumerateRevokedIndices(encodedList) {
+  let bytes;
+  try {
+    const compressed = base64UrlDecode(encodedList);
+    bytes = new Uint8Array(gunzipSync(compressed));
+  } catch (cause) {
+    throw new MalformedStatusList(`status list bitstring decode failed: ${String(cause)}`);
+  }
+  const indices = [];
+  for (let byteIndex = 0; byteIndex < bytes.length; byteIndex += 1) {
+    const byte = bytes[byteIndex];
+    if (byte === 0) continue;
+    for (let bit = 0; bit < 8; bit += 1) {
+      const mask = 1 << 7 - bit;
+      if ((byte & mask) !== 0) {
+        indices.push(byteIndex * 8 + bit);
+      }
+    }
+  }
+  return indices;
+}
+
+// src/engine/adapters/reputation-oracle.ts
+var DEFAULT_FETCH_TIMEOUT_MS3 = 1500;
+var DEFAULT_TTL_MS3 = 1e4;
+var DEFAULT_BASELINE = 1;
+function makeReputationOracle(opts = {}) {
+  const argusUrl = opts.argusUrl;
+  const timeoutMs = opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS3;
+  const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS3;
+  const fetchImpl = opts.fetch ?? fetch;
+  const baseline = opts.baselineWhenUnreachable ?? DEFAULT_BASELINE;
+  const cache = opts.cache ?? /* @__PURE__ */ new Map();
+  const now = opts.now ?? (() => Date.now());
+  const log = opts.logger ?? (() => {
+  });
+  return {
+    async score(agentDid) {
+      const cached = cache.get(agentDid);
+      if (cached && now() - cached.fetchedAt < ttlMs) {
+        return cached.value;
+      }
+      if (!argusUrl) {
+        return baseline;
+      }
+      const value = await fetchAndValidate(argusUrl, agentDid, fetchImpl, timeoutMs, baseline, log);
+      cache.set(agentDid, { value, fetchedAt: now() });
+      return value;
+    }
+  };
+}
+async function fetchAndValidate(argusUrl, agentDid, fetchImpl, timeoutMs, baseline, log) {
+  const url = `${argusUrl.replace(/\/$/, "")}/v1/reputation?agent=${encodeURIComponent(agentDid)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(url, { signal: controller.signal });
+  } catch (cause) {
+    if (cause instanceof Error && cause.name === "AbortError") {
+      log(
+        `[reputation-oracle] Argus timed out after ${timeoutMs}ms (${agentDid}); using baseline ${baseline}`
+      );
+    } else {
+      log(
+        `[reputation-oracle] Argus fetch failed (${agentDid}): ${String(cause)}; using baseline ${baseline}`
+      );
+    }
+    return baseline;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    log(
+      `[reputation-oracle] Argus HTTP ${response.status} (${agentDid}); using baseline ${baseline}`
+    );
+    return baseline;
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (cause) {
+    log(
+      `[reputation-oracle] Argus response not JSON (${agentDid}): ${String(cause)}; using baseline ${baseline}`
+    );
+    return baseline;
+  }
+  if (body === null || typeof body !== "object") {
+    log(
+      `[reputation-oracle] Argus response not an object (${agentDid}); using baseline ${baseline}`
+    );
+    return baseline;
+  }
+  const score = body.score;
+  if (typeof score !== "number" || !Number.isFinite(score)) {
+    log(
+      `[reputation-oracle] Argus score not a finite number (${agentDid}): ${String(score)}; using baseline ${baseline}`
+    );
+    return baseline;
+  }
+  if (score < 0 || score > 1) {
+    log(
+      `[reputation-oracle] Argus score out of range (${agentDid}): ${score}; using baseline ${baseline}`
+    );
+    return baseline;
+  }
+  return score;
+}
+
+// src/engine/adapters/policy-evaluator.ts
+var DEFAULT_FETCH_TIMEOUT_MS4 = 2e3;
+var DEFAULT_TTL_MS4 = 6e4;
+var PERMIT_BY_DEFAULT_POLICY = { reputationThreshold: 0 };
+function makePolicyEvaluator(opts = {}) {
+  const dashboardUrl = opts.dashboardUrl;
+  const timeoutMs = opts.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS4;
+  const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS4;
+  const fetchImpl = opts.fetch ?? fetch;
+  const fallbackPolicy = opts.defaultPolicy ?? PERMIT_BY_DEFAULT_POLICY;
+  const cache = opts.cache ?? /* @__PURE__ */ new Map();
+  const now = opts.now ?? (() => Date.now());
+  const log = opts.logger ?? (() => {
+  });
+  return {
+    async evaluate(input) {
+      const policy = await getOrFetchPolicy(
+        input.tenantHost,
+        dashboardUrl,
+        fetchImpl,
+        timeoutMs,
+        fallbackPolicy,
+        cache,
+        ttlMs,
+        now,
+        log
+      );
+      return computeDecision(policy, input);
+    }
+  };
+}
+function computeDecision(policy, input) {
+  if (input.reputation < policy.reputationThreshold) {
+    return {
+      kind: "Block",
+      reason: {
+        kind: "LowReputation",
+        score: input.reputation,
+        threshold: policy.reputationThreshold
+      }
+    };
+  }
+  return { kind: "Permit" };
+}
+async function getOrFetchPolicy(tenantHost, dashboardUrl, fetchImpl, timeoutMs, fallbackPolicy, cache, ttlMs, now, log) {
+  const cached = cache.get(tenantHost);
+  if (cached && now() - cached.fetchedAt < ttlMs) {
+    return cached.policy;
+  }
+  const cacheFallback = () => {
+    cache.set(tenantHost, { policy: fallbackPolicy, fetchedAt: now() });
+    return fallbackPolicy;
+  };
+  if (!dashboardUrl) {
+    return cacheFallback();
+  }
+  const url = `${dashboardUrl.replace(/\/$/, "")}/api/policy?tenant=${encodeURIComponent(tenantHost)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetchImpl(url, { signal: controller.signal });
+  } catch (cause) {
+    log(`[policy-evaluator] fetch failed (${tenantHost}): ${String(cause)}; using fallback`);
+    return cacheFallback();
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    log(`[policy-evaluator] dashboard HTTP ${response.status} (${tenantHost}); using fallback`);
+    return cacheFallback();
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (cause) {
+    log(
+      `[policy-evaluator] dashboard response not JSON (${tenantHost}): ${String(cause)}; using fallback`
+    );
+    return cacheFallback();
+  }
+  const parsed = parseTenantPolicy(body);
+  if (!parsed) {
+    log(`[policy-evaluator] dashboard response malformed (${tenantHost}); using fallback`);
+    return cacheFallback();
+  }
+  cache.set(tenantHost, { policy: parsed, fetchedAt: now() });
+  return parsed;
+}
+function parseTenantPolicy(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const threshold = raw.reputationThreshold;
+  if (typeof threshold !== "number" || !Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+    return null;
+  }
+  return { reputationThreshold: threshold };
+}
+
+// src/engine/adapters/clock.ts
+function makeSystemClock() {
+  return { nowUnix: () => Math.floor(Date.now() / 1e3) };
+}
+function makeFixedClock(unixSeconds) {
+  return { nowUnix: () => unixSeconds };
+}
+
+export { DidNotFound, DidResolverError, DidResolverTimeout, MalformedDid, MalformedStatusList, StatusListTimeout, StatusListUnavailable, UnsupportedDidMethod, UnsupportedKeyType, decodeDidKey, makeDidResolver, makeFixedClock, makePolicyEvaluator, makeReputationOracle, makeStatusListCache, makeSystemClock };
+//# sourceMappingURL=adapters.mjs.map
+//# sourceMappingURL=adapters.mjs.map