@dvmkit/sdk 0.1.0-rc.1 → 0.1.0-rc.3

package/dist/{tempo-session-store-FTEEGZXA.js → chunk-RU7SXHLO.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-YG7G4DPZ.js";
 import {
   withPostgresTransactionRecovery
-} from "./chunk-H25M54MI.js";
+} from "./chunk-C3MTFLC6.js";
 import {
   withSdkInitLock
 } from "./chunk-S3XAHZQY.js";
@@ -461,6 +461,7 @@ function acceptanceVoucherAmount(acceptance, key, current, next) {
   const authorized = isRecord(current) ? asBigInt(current.highestVoucherAmount) : void 0;
   return authorized !== void 0 && authorized >= acceptance.cumulativeAmount ? acceptance.cumulativeAmount : void 0;
 }
+
 export {
   PostgresTempoSessionStore,
   assertMonotonicTransition

package/dist/{chunk-7IH5SG2A.js → chunk-TKA6ZP4M.js}

@@ -1,32 +1,9 @@
 import {
-  initCallerLoggers,
+  initCallerLoggers
+} from "./chunk-66HGCPBU.js";
+import {
   redactUrl
-} from "./chunk-KXWROQGK.js";
-
-// src/sdk/server/job-store.ts
-function accumulateAskedTopUp(prior, ask) {
-  const poisoned = (reason) => ({
-    micro: UNCAPPABLE_ASK_TOTAL,
-    currency: prior.currency,
-    reason: prior.reason ?? reason
-  });
-  if (prior.micro === UNCAPPABLE_ASK_TOTAL) {
-    return { micro: prior.micro, currency: prior.currency, reason: prior.reason };
-  }
-  if (ask.micro === void 0) return poisoned("ask_unpriceable");
-  if (prior.micro === void 0) {
-    return { micro: ask.micro, currency: ask.currency, reason: prior.reason };
-  }
-  if (prior.currency !== ask.currency) return poisoned("ask_currency_switch");
-  return { micro: prior.micro + ask.micro, currency: prior.currency, reason: prior.reason };
-}
-var UNCAPPABLE_ASK_TOTAL = -1;
-function isReceiptIssuingStore(store) {
-  return "claimReceiptSeq" in store && "saveReceipt" in store;
-}
-function isStreamableJobStore(store) {
-  return "appendOutgoing" in store && "recordInbound" in store && "verifyAndCredit" in store && "getVerifiedInbound" in store && "subscribeMessages" in store && "subscribeNotifications" in store && "getCounters" in store && "getMessages" in store && "cancelJob" in store && "initStreaming" in store;
-}
+} from "./chunk-FUJ36YDV.js";
 
 // src/sdk/step-cache.ts
 var StepCache = class _StepCache {
@@ -223,6 +200,34 @@ function isYieldMessage(msg) {
   return msg.type === "prompt" || msg.type === "payment-request" || msg.type === "working" || msg.type === "complete" || msg.type === "cancel";
 }
 
+// src/sdk/server/job-store.ts
+function accumulateAskedTopUp(prior, ask) {
+  const poisoned = (reason) => ({
+    micro: UNCAPPABLE_ASK_TOTAL,
+    currency: prior.currency,
+    reason: prior.reason ?? reason
+  });
+  if (prior.micro === UNCAPPABLE_ASK_TOTAL) {
+    return { micro: prior.micro, currency: prior.currency, reason: prior.reason };
+  }
+  if (ask.micro === void 0) return poisoned("ask_unpriceable");
+  if (prior.micro === void 0) {
+    return { micro: ask.micro, currency: ask.currency, reason: prior.reason };
+  }
+  if (prior.currency !== ask.currency) return poisoned("ask_currency_switch");
+  return { micro: prior.micro + ask.micro, currency: prior.currency, reason: prior.reason };
+}
+var UNCAPPABLE_ASK_TOTAL = -1;
+function isReceiptIssuingStore(store) {
+  return "claimReceiptSeq" in store && "saveReceipt" in store;
+}
+function isStreamableJobStore(store) {
+  return "appendOutgoing" in store && "recordInbound" in store && "verifyAndCredit" in store && "getVerifiedInbound" in store && "subscribeMessages" in store && "subscribeNotifications" in store && "getCounters" in store && "getMessages" in store && "cancelJob" in store && "initStreaming" in store;
+}
+function isStaleJobReapable(store) {
+  return "findStaleJobs" in store && "cancelStaleJob" in store;
+}
+
 // src/sdk/server/memory-job-store.ts
 var MemoryJobStore = class {
   data = /* @__PURE__ */ new Map();
@@ -646,6 +651,17 @@ function createConsoleLogger(jobId) {
     }
   };
 }
+function createStdoutLogger(context) {
+  const emit = (sink, level) => (message, data) => {
+    sink(JSON.stringify({ level, msg: message, ...context, ...data }));
+  };
+  return {
+    debug: emit(console.debug.bind(console), "debug"),
+    info: emit(console.info.bind(console), "info"),
+    warn: emit(console.warn.bind(console), "warn"),
+    error: emit(console.error.bind(console), "error")
+  };
+}
 function createNoopLogger() {
   const noop2 = () => {
   };
@@ -695,20 +711,6 @@ function rawContext() {
   return storage.getStore();
 }
 
-// src/observability/datasets.ts
-var SPANS_DATASETS = [
-  { name: "platform", retentionDays: 90 },
-  { name: "cashu", retentionDays: 90 },
-  { name: "lightning", retentionDays: 90 },
-  { name: "stripe", retentionDays: 90 },
-  { name: "x402", retentionDays: 90 },
-  { name: "tempo", retentionDays: 90 },
-  { name: "isolate", retentionDays: 90 },
-  { name: "audit", retentionDays: 365 },
-  { name: "cron", retentionDays: 30 }
-];
-var DATASET_NAMES = new Set(SPANS_DATASETS.map((d) => d.name));
-
 // src/observability/with-span.ts
 import { hostname } from "os";
 
@@ -850,6 +852,20 @@ async function withSpan(opts, fn) {
   }
 }
 
+// src/observability/datasets.ts
+var SPANS_DATASETS = [
+  { name: "platform", retentionDays: 90 },
+  { name: "cashu", retentionDays: 90 },
+  { name: "lightning", retentionDays: 90 },
+  { name: "stripe", retentionDays: 90 },
+  { name: "x402", retentionDays: 90 },
+  { name: "tempo", retentionDays: 90 },
+  { name: "isolate", retentionDays: 90 },
+  { name: "audit", retentionDays: 365 },
+  { name: "cron", retentionDays: 30 }
+];
+var DATASET_NAMES = new Set(SPANS_DATASETS.map((d) => d.name));
+
 // src/observability/loggers.ts
 var noop = () => {
 };
@@ -1025,11 +1041,16 @@ export {
   UNCAPPABLE_ASK_TOTAL,
   isReceiptIssuingStore,
   isStreamableJobStore,
+  isStaleJobReapable,
   MemoryJobStore,
   createConsoleLogger,
+  createStdoutLogger,
   createNoopLogger,
+  randomTraceId,
   withTraceContext,
+  currentContext,
   pinDimension,
+  setEmitter,
   withSpan,
   loggers,
   initLoggers,

package/dist/chunk-TVI4V7GF.js

@@ -0,0 +1,283 @@
+// src/sdk/env.ts
+function envFlag(value) {
+  return value === "1" || value === "true";
+}
+
+// src/sdk/server/ssrf.ts
+import { lookup } from "dns/promises";
+import { isIPv4, isIPv6 } from "net";
+import { Agent } from "undici";
+var SSRFError = class extends Error {
+  code = "ssrf_blocked";
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+};
+async function assertSafeUrl(url, opts) {
+  await resolveAndValidate(url, opts);
+}
+async function createPinnedFetch(url, opts) {
+  const validated = await resolveAndValidate(url, opts);
+  const baseFetch = opts?.baseFetch ?? fetch;
+  const initialUrl = new URL(url);
+  const agents = [];
+  const targets = /* @__PURE__ */ new Map();
+  const createTarget = (next) => {
+    if (next.kind === "literal") return {};
+    const agent = new Agent({
+      connect: { lookup: buildPinnedLookup(next.addresses) }
+    });
+    agents.push(agent);
+    return { agent };
+  };
+  targets.set(initialUrl.origin, createTarget(validated));
+  const targetFor = async (requestUrl) => {
+    const parsed = new URL(requestUrl);
+    const existing = targets.get(parsed.origin);
+    if (existing) return existing;
+    const target = createTarget(await resolveAndValidate(parsed.href, opts));
+    targets.set(parsed.origin, target);
+    return target;
+  };
+  const pinnedFetch = async (input, init) => {
+    let request = new Request(input, init);
+    let redirects = 0;
+    for (; ; ) {
+      const target = await targetFor(request.url);
+      const response = await baseFetch(
+        request,
+        target.agent ? { redirect: "manual", dispatcher: target.agent } : { redirect: "manual" }
+      );
+      if (!isRedirect(response.status) || request.redirect === "manual") return response;
+      const location = response.headers.get("location");
+      if (location === null) return response;
+      await discardResponse(response);
+      if (request.redirect === "error") {
+        throw new TypeError("fetch failed: redirect mode is set to error");
+      }
+      if (redirects >= MAX_PINNED_REDIRECTS) {
+        throw new TypeError("fetch failed: maximum redirect count exceeded");
+      }
+      request = requestForRedirect(request, new URL(location, request.url), response.status);
+      redirects += 1;
+      opts?.onRedirectFollowed?.();
+    }
+  };
+  return {
+    fetch: pinnedFetch,
+    address: validated.address,
+    family: validated.family,
+    close: async () => {
+      await Promise.all(agents.map((agent) => agent.close()));
+    }
+  };
+}
+var MAX_PINNED_REDIRECTS = 20;
+function isRedirect(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+async function discardResponse(response) {
+  await response.body?.cancel().catch(() => void 0);
+}
+function requestForRedirect(request, target, status) {
+  const headers = new Headers(request.headers);
+  if (new URL(request.url).origin !== target.origin) {
+    headers.delete("authorization");
+    headers.delete("cookie");
+    headers.delete("proxy-authorization");
+    headers.delete("host");
+  }
+  const method = request.method.toUpperCase();
+  const switchToGet = status === 303 && method !== "HEAD" || (status === 301 || status === 302) && method === "POST";
+  if (switchToGet) {
+    headers.delete("content-length");
+    headers.delete("content-type");
+    return redirectRequest(target, request, headers, "GET");
+  }
+  if (method !== "GET" && method !== "HEAD") {
+    throw new TypeError("fetch failed: cannot safely replay a request body across this redirect");
+  }
+  return redirectRequest(target, request, headers, method);
+}
+function redirectRequest(target, request, headers, method) {
+  return new Request(target, {
+    method,
+    headers,
+    signal: request.signal,
+    redirect: request.redirect,
+    cache: request.cache,
+    credentials: request.credentials,
+    integrity: request.integrity,
+    keepalive: request.keepalive,
+    mode: request.mode,
+    referrer: request.referrer,
+    referrerPolicy: request.referrerPolicy
+  });
+}
+function buildPinnedLookup(addresses) {
+  return ((_hostname, options, cb) => {
+    if (options.all === false) {
+      const first = addresses[0];
+      cb(
+        null,
+        first.address,
+        first.family
+      );
+    } else {
+      cb(
+        null,
+        addresses
+      );
+    }
+  });
+}
+async function resolveAndValidate(url, opts) {
+  const resolver = opts?.resolver ?? defaultResolver;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new SSRFError("invalid_url", `url is not a valid URL: ${url}`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new SSRFError("insecure_scheme", `url must be https; got ${parsed.protocol}`);
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host === "") {
+    throw new SSRFError("invalid_url", "url has no host");
+  }
+  if (HOSTNAME_DENYLIST_EXACT.has(host) || matchesExtraExact(host, opts?.extraHostnamesExact)) {
+    throw new SSRFError("private_address", `url host "${host}" is on the SSRF denylist`);
+  }
+  for (const suffix of HOSTNAME_DENYLIST_SUFFIX) {
+    if (host === suffix.slice(1) || host.endsWith(suffix)) {
+      throw new SSRFError(
+        "private_address",
+        `url host "${host}" matches denied suffix "${suffix}"`
+      );
+    }
+  }
+  if (opts?.extraHostnameSuffixes) {
+    for (const suffix of opts.extraHostnameSuffixes) {
+      const s = suffix.toLowerCase();
+      if (host === s.slice(1) || host.endsWith(s)) {
+        throw new SSRFError("private_address", `url host "${host}" matches denied suffix "${s}"`);
+      }
+    }
+  }
+  const stripped = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  if (isIPv4(stripped) || isIPv6(stripped)) {
+    if (isUnsafeAddress(stripped, opts)) {
+      throw new SSRFError(
+        "private_address",
+        `url host "${stripped}" is in a blocked address range`
+      );
+    }
+    return { kind: "literal", address: stripped, family: isIPv4(stripped) ? 4 : 6 };
+  }
+  let addresses;
+  try {
+    addresses = await resolver(host);
+  } catch (err) {
+    throw new SSRFError(
+      "dns_failed",
+      `url host "${host}" failed DNS resolution: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (addresses.length === 0) {
+    throw new SSRFError("dns_failed", `url host "${host}" resolved to no addresses`);
+  }
+  for (const { address } of addresses) {
+    if (isUnsafeAddress(address, opts)) {
+      throw new SSRFError(
+        "private_address",
+        `url host "${host}" resolves to blocked address "${address}"`
+      );
+    }
+  }
+  const validated = addresses.map((a) => ({ address: a.address, family: a.family }));
+  const first = validated[0];
+  return { kind: "resolved", address: first.address, family: first.family, addresses: validated };
+}
+var HOSTNAME_DENYLIST_EXACT = /* @__PURE__ */ new Set([
+  "localhost",
+  "ip6-localhost",
+  "ip6-loopback",
+  "metadata.google.internal",
+  "metadata"
+]);
+var HOSTNAME_DENYLIST_SUFFIX = [".internal", ".local", ".localhost", ".lan"];
+async function defaultResolver(host) {
+  return lookup(host, { all: true });
+}
+function matchesExtraExact(host, extras) {
+  if (!extras) return false;
+  for (const entry of extras) {
+    if (entry.toLowerCase() === host) return true;
+  }
+  return false;
+}
+function isUnsafeAddress(address, opts) {
+  if (isIPv4(address)) {
+    if (isUnsafeIPv4(address)) return true;
+    return opts?.extraUnsafeIPv4?.(address) === true;
+  }
+  if (isIPv6(address)) {
+    if (isUnsafeIPv6(address)) return true;
+    return opts?.extraUnsafeIPv6?.(address) === true;
+  }
+  return true;
+}
+function isUnsafeIPv4(address) {
+  const parts = address.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((p) => !Number.isFinite(p) || p < 0 || p > 255)) {
+    return true;
+  }
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 0 && (c === 0 || c === 2)) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a >= 224 && a <= 239) return true;
+  if (a >= 240) return true;
+  return false;
+}
+function isUnsafeIPv6(address) {
+  const lower = address.toLowerCase();
+  if (lower === "::1") return true;
+  if (lower === "::") return true;
+  if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) {
+    return true;
+  }
+  if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
+  if (lower.startsWith("::ffff:")) {
+    const tail = lower.slice("::ffff:".length);
+    if (isIPv4(tail)) return isUnsafeIPv4(tail);
+    const m = /^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(tail);
+    if (m) {
+      const high = parseInt(m[1], 16);
+      const low = parseInt(m[2], 16);
+      const a = high >> 8 & 255;
+      const b = high & 255;
+      const c = low >> 8 & 255;
+      const d = low & 255;
+      return isUnsafeIPv4(`${a.toString()}.${b.toString()}.${c.toString()}.${d.toString()}`);
+    }
+  }
+  if (lower.startsWith("ff")) return true;
+  return false;
+}
+
+export {
+  envFlag,
+  SSRFError,
+  assertSafeUrl,
+  createPinnedFetch
+};