@elizaos/plugin-elizacloud 2.0.0-alpha.7 → 2.0.0-beta.1

package/dist/routes/cloud-billing-routes.js

@@ -0,0 +1,807 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cloud/base-url.ts
+function isLoopbackHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || normalized.startsWith("127.");
+}
+function trimApiPath(pathname) {
+  const normalized = pathname.trim().replace(/\/+$/, "");
+  if (!normalized)
+    return "";
+  if (normalized === "/api/v1")
+    return "";
+  if (normalized.endsWith("/api/v1")) {
+    return normalized.slice(0, -"/api/v1".length);
+  }
+  return normalized;
+}
+function normalizeCloudSiteUrl(rawUrl) {
+  const envOverride = process.env.ELIZAOS_CLOUD_BASE_URL?.trim();
+  const candidate = envOverride || rawUrl?.trim() || DEFAULT_CLOUD_SITE_URL;
+  try {
+    const parsed = new URL(candidate);
+    const pathname = trimApiPath(parsed.pathname);
+    const host = parsed.hostname.toLowerCase();
+    const preserveLocalOrigin = isLoopbackHost(host);
+    parsed.hash = "";
+    parsed.search = "";
+    if (!preserveLocalOrigin) {
+      parsed.protocol = "https:";
+      parsed.port = "";
+    }
+    parsed.pathname = pathname;
+    if (LEGACY_CLOUD_HOST_ALIASES.has(host)) {
+      parsed.hostname = "www.elizacloud.ai";
+      parsed.pathname = "";
+    }
+    return parsed.toString().replace(/\/{1,1024}$/, "");
+  } catch {
+    const safeCandidate = candidate.length > 8192 ? candidate.slice(0, 8192) : candidate;
+    return safeCandidate.replace(/\/{1,1024}$/, "");
+  }
+}
+function resolveCloudApiBaseUrl(rawUrl) {
+  return `${normalizeCloudSiteUrl(rawUrl)}/api/v1`;
+}
+var DEFAULT_CLOUD_SITE_URL = "https://www.elizacloud.ai", LEGACY_CLOUD_HOST_ALIASES;
+var init_base_url = __esm(() => {
+  LEGACY_CLOUD_HOST_ALIASES = new Set([
+    "elizacloud.ai",
+    "www.elizacloud.ai"
+  ]);
+});
+
+// src/cloud/validate-url.ts
+import dns from "node:dns";
+import net from "node:net";
+import { promisify } from "node:util";
+function normalizeHostLike(value) {
+  return value.trim().toLowerCase().replace(/^\[|\]$/g, "");
+}
+function decodeIpv6MappedHex(mapped) {
+  const parts = mapped.split(":");
+  if (parts.length < 1 || parts.length > 2)
+    return null;
+  const parsed = parts.map((part) => {
+    if (!/^[0-9a-f]{1,4}$/i.test(part))
+      return Number.NaN;
+    return Number.parseInt(part, 16);
+  });
+  if (parsed.some((value) => !Number.isFinite(value)))
+    return null;
+  const [hi, lo] = parsed.length === 1 ? [0, parsed[0]] : parsed;
+  const octets = [hi >> 8, hi & 255, lo >> 8, lo & 255];
+  return octets.join(".");
+}
+function canonicalizeIpv6(ip) {
+  try {
+    return new URL(`http://[${ip}]/`).hostname.replace(/^\[|\]$/g, "");
+  } catch {
+    return null;
+  }
+}
+function normalizeIpForPolicy(ip) {
+  const base = normalizeHostLike(ip).split("%")[0];
+  if (!base)
+    return base;
+  let normalized = base;
+  if (net.isIP(normalized) === 6) {
+    normalized = canonicalizeIpv6(normalized) ?? normalized;
+  }
+  let mapped = null;
+  if (normalized.startsWith("::ffff:")) {
+    mapped = normalized.slice("::ffff:".length);
+  } else if (normalized.startsWith("0:0:0:0:0:ffff:")) {
+    mapped = normalized.slice("0:0:0:0:0:ffff:".length);
+  }
+  if (!mapped)
+    return normalized;
+  if (net.isIP(mapped) === 4)
+    return mapped;
+  return decodeIpv6MappedHex(mapped) ?? normalized;
+}
+function cidrV4(base, prefix) {
+  const parsed = parseIpv4ToInt(base);
+  if (parsed === null) {
+    throw new Error(`Invalid CIDR base IPv4 address: ${base}`);
+  }
+  const shift = 32 - prefix;
+  const mask = shift === 32 ? 0 : 4294967295 << shift >>> 0;
+  return { base: parsed & mask, mask };
+}
+function parseIpv4ToInt(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return null;
+  let value = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part))
+      return null;
+    const octet = Number.parseInt(part, 10);
+    if (!Number.isInteger(octet) || octet < 0 || octet > 255)
+      return null;
+    value = value << 8 | octet;
+  }
+  return value >>> 0;
+}
+function isBlockedIpv4(ip) {
+  const asInt = parseIpv4ToInt(ip);
+  if (asInt === null)
+    return true;
+  return BLOCKED_IPV4_CIDRS.some((cidr) => (asInt & cidr.mask) === cidr.base);
+}
+function isBlockedIpv6(ip) {
+  const normalized = ip.toLowerCase();
+  return normalized === "::" || normalized === "::1" || /^fe[89ab][0-9a-f]:/.test(normalized) || /^f[cd][0-9a-f]{2}:/i.test(normalized) || normalized.startsWith("ff");
+}
+function isBlockedIp(ip) {
+  const normalized = normalizeIpForPolicy(ip);
+  const family = net.isIP(normalized);
+  if (family === 4)
+    return isBlockedIpv4(normalized);
+  if (family === 6)
+    return isBlockedIpv6(normalized);
+  return false;
+}
+async function validateCloudBaseUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return `Invalid cloud base URL: "${rawUrl}"`;
+  }
+  if (parsed.protocol !== "https:") {
+    return `Cloud base URL must use HTTPS, got "${parsed.protocol}" in "${rawUrl}"`;
+  }
+  const hostname = normalizeHostLike(parsed.hostname);
+  if (!hostname) {
+    return `Invalid cloud base URL: "${rawUrl}"`;
+  }
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
+    return `Cloud base URL "${rawUrl}" points to a blocked local hostname.`;
+  }
+  if (true) {
+    return null;
+  }
+  if (isBlockedIp(hostname)) {
+    return `Cloud base URL "${rawUrl}" points to a blocked address.`;
+  }
+  try {
+    const results = await dnsLookupAll(hostname, { all: true });
+    const addresses = Array.isArray(results) ? results : [results];
+    for (const entry of addresses) {
+      const ip = typeof entry === "string" ? entry : entry.address;
+      if (isBlockedIp(ip)) {
+        return `Cloud base URL "${rawUrl}" resolves to ${ip}, ` + "which is a blocked internal/metadata address.";
+      }
+    }
+  } catch {
+    return `Cloud base URL "${rawUrl}" could not be resolved via DNS.`;
+  }
+  return null;
+}
+var dnsLookupAll, BLOCKED_IPV4_CIDRS;
+var init_validate_url = __esm(() => {
+  dnsLookupAll = promisify(dns.lookup);
+  BLOCKED_IPV4_CIDRS = [
+    cidrV4("0.0.0.0", 8),
+    cidrV4("10.0.0.0", 8),
+    cidrV4("172.16.0.0", 12),
+    cidrV4("192.168.0.0", 16),
+    cidrV4("100.64.0.0", 10),
+    cidrV4("127.0.0.0", 8),
+    cidrV4("169.254.0.0", 16),
+    cidrV4("192.0.0.0", 24),
+    cidrV4("198.18.0.0", 15),
+    cidrV4("192.0.2.0", 24),
+    cidrV4("198.51.100.0", 24),
+    cidrV4("203.0.113.0", 24),
+    cidrV4("224.0.0.0", 4),
+    cidrV4("240.0.0.0", 4)
+  ];
+});
+
+// src/cloud/cloud-api-key.ts
+function normalizeCloudSecret(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function resolveRuntimeCloudApiKey(runtime) {
+  const fromSetting = runtime?.getSetting?.("ELIZAOS_CLOUD_API_KEY");
+  if (typeof fromSetting === "string") {
+    return normalizeCloudSecret(fromSetting);
+  }
+  const fromSecrets = runtime?.character?.secrets?.ELIZAOS_CLOUD_API_KEY;
+  return typeof fromSecrets === "string" ? normalizeCloudSecret(fromSecrets) : null;
+}
+function resolveCloudApiBaseUrl2(rawBaseUrl) {
+  const candidate = normalizeCloudSecret(rawBaseUrl ?? process.env.ELIZAOS_CLOUD_BASE_URL) ?? DEFAULT_CLOUD_API_BASE_URL;
+  try {
+    const parsed = new URL(candidate);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    parsed.hash = "";
+    parsed.search = "";
+    const normalizedBase = parsed.toString().replace(/\/+$/, "");
+    return normalizedBase.endsWith("/api/v1") ? normalizedBase : `${normalizedBase}/api/v1`;
+  } catch {
+    return null;
+  }
+}
+function resolveCloudApiKey(config, runtime) {
+  return normalizeCloudSecret(config?.cloud?.apiKey ?? resolveRuntimeCloudApiKey(runtime) ?? process.env.ELIZAOS_CLOUD_API_KEY);
+}
+var DEFAULT_CLOUD_API_BASE_URL = "https://elizacloud.ai/api/v1";
+
+// src/lib/http.ts
+function scrubStackFields(value) {
+  if (value instanceof Error) {
+    return { error: value.message || "Internal error" };
+  }
+  if (Array.isArray(value)) {
+    return value.map(scrubStackFields);
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+      if (key === "stack" || key === "stackTrace")
+        continue;
+      out[key] = scrubStackFields(nested);
+    }
+    return out;
+  }
+  return value;
+}
+function sendJson(res, body, status = 200) {
+  if (res.headersSent)
+    return;
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(scrubStackFields(body)));
+}
+function sendJsonError(res, message, status = 400) {
+  sendJson(res, { error: message }, status);
+}
+async function readRequestBody(req, options) {
+  const maxBytes = options.maxBytes ?? 1048576;
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    size += buffer.length;
+    if (size > maxBytes) {
+      if (options.destroyOnTooLarge)
+        req.destroy();
+      throw new Error(options.tooLargeMessage ?? "Request body too large");
+    }
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0)
+    return null;
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function readJsonBody(req, res, options = {}) {
+  const cached = req.body;
+  if (cached !== undefined) {
+    if (options.requireObject !== false && (!cached || typeof cached !== "object" || Array.isArray(cached))) {
+      sendJsonError(res, "Request body must be a JSON object", 400);
+      return null;
+    }
+    return cached;
+  }
+  let raw;
+  try {
+    raw = await readRequestBody(req, options);
+  } catch (error) {
+    sendJsonError(res, error instanceof Error ? error.message : "Failed to read request body", 413);
+    return null;
+  }
+  if (!raw?.trim()) {
+    const empty = {};
+    req.body = empty;
+    return empty;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    sendJsonError(res, "Invalid JSON in request body", 400);
+    return null;
+  }
+  if (options.requireObject !== false && (!parsed || typeof parsed !== "object" || Array.isArray(parsed))) {
+    sendJsonError(res, "Request body must be a JSON object", 400);
+    return null;
+  }
+  req.body = parsed;
+  return parsed;
+}
+
+// src/routes/cloud-billing-routes.ts
+function cryptoStatusCacheKey(baseUrl, headers) {
+  return `${baseUrl}|${headers.Authorization ?? ""}`;
+}
+async function fetchCryptoStatusCached(baseUrl, headers) {
+  const now = Date.now();
+  const cacheKey = cryptoStatusCacheKey(baseUrl, headers);
+  const cached = cryptoStatusCache.get(cacheKey);
+  if (cached && cached.expiresAt > now) {
+    return cached.value;
+  }
+  const response = await fetchUpstream(`${baseUrl}/api/crypto/status`, "GET", headers, undefined).catch(() => null);
+  if (!response?.ok) {
+    return cached?.value ?? null;
+  }
+  const value = await readJsonResponse(response).catch(() => ({}));
+  cryptoStatusCache.set(cacheKey, {
+    value,
+    expiresAt: now + CRYPTO_STATUS_CACHE_MS
+  });
+  return value;
+}
+function resolveCloudBaseUrl(config) {
+  return normalizeCloudSiteUrl(config.cloud?.baseUrl);
+}
+function normalizeCloudApiKey(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toUpperCase() === "[REDACTED]") {
+    return null;
+  }
+  return trimmed;
+}
+function resolveProxyApiKey(state) {
+  const cloudAuth = state.runtime ? state.runtime.getService("CLOUD_AUTH") : null;
+  const runtimeApiKey = cloudAuth?.isAuthenticated() === true ? normalizeCloudApiKey(cloudAuth.getApiKey?.()) : null;
+  return runtimeApiKey ?? resolveCloudApiKey(state.config, state.runtime);
+}
+function buildAuthHeaders(config, apiKeyOverride) {
+  const serviceKey = config.cloud?.serviceKey?.trim();
+  const apiKey = normalizeCloudApiKey(apiKeyOverride) ?? resolveCloudApiKey(config);
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  if (serviceKey) {
+    headers["X-Service-Key"] = serviceKey;
+  }
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : undefined;
+}
+function readBody(req) {
+  const preParsedBody = req.body;
+  if (preParsedBody !== undefined) {
+    return Promise.resolve(typeof preParsedBody === "string" ? preParsedBody : JSON.stringify(preParsedBody));
+  }
+  if (req.readableEnded) {
+    return Promise.resolve(undefined);
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : undefined));
+    req.on("error", reject);
+  });
+}
+async function fetchUpstream(url, method, headers, body) {
+  let currentUrl = url;
+  let currentMethod = method;
+  let currentBody = body;
+  for (let redirectCount = 0;redirectCount <= MAX_REDIRECTS; redirectCount += 1) {
+    const response = await fetch(currentUrl, {
+      method: currentMethod,
+      headers,
+      body: currentBody,
+      redirect: "manual",
+      signal: AbortSignal.timeout(PROXY_TIMEOUT_MS)
+    });
+    if (response.status < 300 || response.status >= 400) {
+      return response;
+    }
+    const location = response.headers.get("location");
+    if (!location) {
+      throw Object.assign(new Error("redirect"), { code: "REDIRECT" });
+    }
+    const nextUrl = new URL(location, currentUrl).toString();
+    const currentOrigin = normalizeCloudSiteUrl(new URL(currentUrl).origin);
+    const nextOrigin = normalizeCloudSiteUrl(new URL(nextUrl).origin);
+    if (new URL(currentUrl).origin !== new URL(nextUrl).origin && currentOrigin !== nextOrigin) {
+      throw Object.assign(new Error("redirect"), { code: "REDIRECT" });
+    }
+    currentUrl = nextUrl;
+    if (currentMethod !== "GET" && currentMethod !== "HEAD" && (response.status === 301 || response.status === 302 || response.status === 303)) {
+      currentMethod = "GET";
+      currentBody = undefined;
+    }
+  }
+  throw Object.assign(new Error("redirect"), { code: "REDIRECT" });
+}
+async function readJsonResponse(response) {
+  return response.json().catch(async () => ({
+    success: response.ok,
+    error: await response.text().catch(() => "Billing request failed")
+  }));
+}
+function buildRedirectUrl(baseUrl, pathname, params) {
+  const url = new URL(pathname, `${baseUrl}/`);
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
+function normalizeCryptoNetwork(value) {
+  if (!value)
+    return;
+  const normalized = value.trim().toUpperCase();
+  switch (normalized) {
+    case "BSC":
+    case "BEP20":
+      return "BEP20";
+    case "ETH":
+    case "ERC20":
+      return "ERC20";
+    case "MATIC":
+    case "POLYGON":
+      return "POLYGON";
+    case "SOL":
+    case "SOLANA":
+      return "SOL";
+    case "BASE":
+      return "BASE";
+    case "ARB":
+    case "ARBITRUM":
+      return "ARB";
+    case "OP":
+    case "OPTIMISM":
+      return "OP";
+    case "TRON":
+    case "TRC20":
+      return "TRC20";
+    default:
+      return;
+  }
+}
+function mapBillingSummary(payload, baseUrl, cryptoStatus) {
+  const source = isRecord(payload) ? payload : {};
+  const organization = isRecord(source.organization) ? source.organization : {};
+  const pricing = isRecord(source.pricing) ? source.pricing : {};
+  const crypto = isRecord(cryptoStatus) ? cryptoStatus : {};
+  const balance = readNumber(organization.creditBalance) ?? 0;
+  return {
+    success: source.success ?? true,
+    balance,
+    currency: "USD",
+    topUpUrl: `${baseUrl}/dashboard/settings?tab=billing`,
+    embeddedCheckoutEnabled: false,
+    hostedCheckoutEnabled: true,
+    cryptoEnabled: readBoolean(crypto.enabled) ?? readBoolean(pricing.x402Enabled) ?? false,
+    low: balance < 2,
+    critical: balance < 0.5,
+    hasPaymentMethod: readBoolean(organization.hasPaymentMethod) ?? false,
+    autoTopUpEnabled: readBoolean(organization.autoTopUpEnabled) ?? false,
+    autoTopUpAmount: readNumber(organization.autoTopUpAmount),
+    autoTopUpThreshold: readNumber(organization.autoTopUpThreshold),
+    minimumTopUp: readNumber(pricing.minimumTopUp)
+  };
+}
+function mapPaymentMethods(payload) {
+  const source = isRecord(payload) ? payload : {};
+  const organization = isRecord(source.organization) ? source.organization : {};
+  const hasPaymentMethod = readBoolean(organization.hasPaymentMethod) ?? false;
+  return {
+    success: true,
+    data: hasPaymentMethod ? [
+      {
+        id: "stripe-default",
+        type: "card",
+        label: "Saved payment method",
+        brand: "Card",
+        isDefault: true
+      }
+    ] : []
+  };
+}
+function mapBillingHistory(payload) {
+  const source = isRecord(payload) ? payload : {};
+  const rawTransactions = Array.isArray(source.transactions) ? source.transactions : [];
+  return {
+    success: true,
+    data: rawTransactions.filter(isRecord).map((item, index) => ({
+      id: readString(item.id) ?? `txn-${index}`,
+      kind: readString(item.type),
+      provider: readString(item.stripe_payment_intent_id) ? "stripe" : undefined,
+      status: (readNumber(item.amount) ?? 0) >= 0 ? "credited" : "usage",
+      amount: readNumber(item.amount) ?? 0,
+      currency: "USD",
+      description: readString(item.description),
+      createdAt: readString(item.created_at) ?? new Date().toISOString()
+    })),
+    total: readNumber(source.total),
+    period: source.period
+  };
+}
+function mapCheckoutResponse(payload) {
+  const source = isRecord(payload) ? payload : {};
+  return {
+    success: true,
+    provider: "stripe",
+    mode: "hosted",
+    checkoutUrl: readString(source.url) ?? readString(source.checkoutUrl),
+    sessionId: readString(source.sessionId)
+  };
+}
+function mapCryptoQuoteResponse(payload, amountUsd, payCurrency, network) {
+  const source = isRecord(payload) ? payload : {};
+  return {
+    success: true,
+    provider: "oxapay",
+    invoiceId: readString(source.paymentId) ?? readString(source.trackId),
+    trackId: readString(source.trackId),
+    network,
+    currency: payCurrency,
+    amount: readString(source.creditsToAdd) ?? String(amountUsd),
+    amountUsd,
+    paymentLinkUrl: readString(source.payLink),
+    expiresAt: readString(source.expiresAt)
+  };
+}
+function parseJsonBody(body) {
+  if (!body)
+    return {};
+  const parsed = JSON.parse(body);
+  return isRecord(parsed) ? parsed : {};
+}
+async function forwardSummary(baseUrl, headers) {
+  const summaryResponse = await fetchUpstream(`${baseUrl}/api/v1/credits/summary`, "GET", headers, undefined);
+  const summaryPayload = await readJsonResponse(summaryResponse);
+  if (!summaryResponse.ok) {
+    return { status: summaryResponse.status, payload: summaryPayload };
+  }
+  const cryptoPayload = await fetchCryptoStatusCached(baseUrl, headers) ?? {};
+  return {
+    status: summaryResponse.status,
+    payload: mapBillingSummary(summaryPayload, baseUrl, cryptoPayload)
+  };
+}
+function sendJsonWithRetry(res, payload, status) {
+  if (status === 429 && isRecord(payload)) {
+    const retryAfter = readNumber(payload.retryAfter);
+    if (retryAfter && retryAfter > 0) {
+      res.setHeader("Retry-After", String(Math.ceil(retryAfter)));
+    }
+  }
+  sendJson(res, payload, status);
+}
+function mirrorPaymentHeaders(res, upstreamResponse) {
+  for (const header of [
+    "PAYMENT-REQUIRED",
+    "Payment-Required",
+    "PAYMENT-RESPONSE",
+    "Payment-Response",
+    "Access-Control-Expose-Headers"
+  ]) {
+    const value = upstreamResponse.headers.get(header);
+    if (value) {
+      res.setHeader(header, value);
+    }
+  }
+}
+function isAllowedAppMoneyPath(pathname) {
+  const appMoneyPath = /^\/api\/cloud\/billing\/apps\/[^/]+\/(charges|earnings|monetization)(?:\/|$)/;
+  return appMoneyPath.test(pathname);
+}
+function mapBillingProxyPath(pathname) {
+  if (pathname === "/api/cloud/billing/x402")
+    return "/api/v1/x402";
+  if (pathname.startsWith("/api/cloud/billing/x402/")) {
+    return pathname.replace("/api/cloud/billing/x402", "/api/v1/x402");
+  }
+  if (pathname === "/api/cloud/billing/app-credits") {
+    return "/api/v1/app-credits";
+  }
+  if (pathname.startsWith("/api/cloud/billing/app-credits/")) {
+    return pathname.replace("/api/cloud/billing/app-credits", "/api/v1/app-credits");
+  }
+  if (pathname === "/api/cloud/billing/affiliates") {
+    return "/api/v1/affiliates";
+  }
+  if (pathname.startsWith("/api/cloud/billing/affiliates/")) {
+    return pathname.replace("/api/cloud/billing/affiliates", "/api/v1/affiliates");
+  }
+  if (pathname === "/api/cloud/billing/redemptions") {
+    return "/api/v1/redemptions";
+  }
+  if (pathname.startsWith("/api/cloud/billing/redemptions/")) {
+    return pathname.replace("/api/cloud/billing/redemptions", "/api/v1/redemptions");
+  }
+  if (isAllowedAppMoneyPath(pathname)) {
+    return pathname.replace("/api/cloud/billing/apps", "/api/v1/apps");
+  }
+  return null;
+}
+async function forwardBillingProxy(req, res, method, baseUrl, headers, upstreamPath, search) {
+  let body;
+  if (method !== "GET" && method !== "HEAD") {
+    body = await readBody(req);
+  }
+  const upstreamResponse = await fetchUpstream(`${baseUrl}${upstreamPath}${search}`, method, headers, body);
+  const responseData = await readJsonResponse(upstreamResponse);
+  mirrorPaymentHeaders(res, upstreamResponse);
+  sendJsonWithRetry(res, responseData, upstreamResponse.status);
+}
+async function handleCloudBillingRoute(req, res, pathname, method, state) {
+  if (!pathname.startsWith("/api/cloud/billing"))
+    return false;
+  const apiKey = resolveProxyApiKey(state);
+  if (!apiKey) {
+    sendJsonError(res, "Not connected to Eliza Cloud. Please log in first.", 401);
+    return true;
+  }
+  const baseUrl = resolveCloudBaseUrl(state.config);
+  const urlError = await validateCloudBaseUrl(baseUrl);
+  if (urlError) {
+    sendJsonError(res, urlError, 502);
+    return true;
+  }
+  const headers = buildAuthHeaders(state.config, apiKey);
+  const fullUrl = new URL(req.url ?? pathname, "http://localhost");
+  const proxiedMoneyPath = mapBillingProxyPath(pathname);
+  if (proxiedMoneyPath) {
+    await forwardBillingProxy(req, res, method, baseUrl, headers, proxiedMoneyPath, fullUrl.search);
+    return true;
+  }
+  if (pathname === "/api/cloud/billing/summary" && method === "GET") {
+    const { status, payload } = await forwardSummary(baseUrl, headers);
+    sendJsonWithRetry(res, payload, status);
+    return true;
+  }
+  if (pathname === "/api/cloud/billing/payment-methods" && method === "GET") {
+    const summaryResponse = await fetchUpstream(`${baseUrl}/api/v1/credits/summary`, "GET", headers, undefined);
+    const summaryPayload = await readJsonResponse(summaryResponse);
+    sendJsonWithRetry(res, summaryResponse.ok ? mapPaymentMethods(summaryPayload) : summaryPayload, summaryResponse.status);
+    return true;
+  }
+  if (pathname === "/api/cloud/billing/history" && method === "GET") {
+    const upstreamUrl = `${baseUrl}/api/credits/transactions${fullUrl.search}`;
+    const historyResponse = await fetchUpstream(upstreamUrl, "GET", headers, undefined);
+    const historyPayload = await readJsonResponse(historyResponse);
+    sendJsonWithRetry(res, historyResponse.ok ? mapBillingHistory(historyPayload) : historyPayload, historyResponse.status);
+    return true;
+  }
+  if (pathname === "/api/cloud/billing/checkout" && method === "POST") {
+    const body2 = await readBody(req);
+    const requestBody = parseJsonBody(body2);
+    const amountUsd = readNumber(requestBody.amountUsd);
+    if (!amountUsd || amountUsd <= 0) {
+      sendJsonError(res, "Invalid top-up amount", 400);
+      return true;
+    }
+    const upstreamBody = JSON.stringify({
+      credits: amountUsd,
+      success_url: buildRedirectUrl(baseUrl, "/dashboard/billing/success", {
+        from: "eliza"
+      }),
+      cancel_url: buildRedirectUrl(baseUrl, "/dashboard/settings", {
+        from: "eliza",
+        tab: "billing",
+        canceled: "1"
+      })
+    });
+    const checkoutResponse = await fetchUpstream(`${baseUrl}/api/v1/credits/checkout`, "POST", headers, upstreamBody);
+    const checkoutPayload = await readJsonResponse(checkoutResponse);
+    sendJsonWithRetry(res, checkoutResponse.ok ? mapCheckoutResponse(checkoutPayload) : checkoutPayload, checkoutResponse.status);
+    return true;
+  }
+  if (pathname === "/api/cloud/billing/crypto/quote" && method === "POST") {
+    const body2 = await readBody(req);
+    const requestBody = parseJsonBody(body2);
+    const amountUsd = readNumber(requestBody.amountUsd);
+    if (!amountUsd || amountUsd <= 0) {
+      sendJsonError(res, "Invalid top-up amount", 400);
+      return true;
+    }
+    const payCurrency = readString(requestBody.currency)?.trim().toUpperCase() ?? "USDC";
+    const network = normalizeCryptoNetwork(readString(requestBody.network));
+    const upstreamBody = JSON.stringify({
+      amount: amountUsd,
+      payCurrency,
+      network
+    });
+    const cryptoResponse = await fetchUpstream(`${baseUrl}/api/crypto/payments`, "POST", headers, upstreamBody);
+    const cryptoPayload = await readJsonResponse(cryptoResponse);
+    sendJsonWithRetry(res, cryptoResponse.ok ? mapCryptoQuoteResponse(cryptoPayload, amountUsd, payCurrency, network) : cryptoPayload, cryptoResponse.status);
+    return true;
+  }
+  if (pathname.startsWith("/api/cloud/billing/credits/")) {
+    let body2;
+    if (method !== "GET" && method !== "HEAD") {
+      body2 = await readBody(req);
+    }
+    const upstreamPath = pathname.replace("/api/cloud/billing/credits", "/api/v1/credits");
+    const upstreamResponse2 = await fetchUpstream(`${baseUrl}${upstreamPath}${fullUrl.search}`, method, headers, body2);
+    const responseData2 = await readJsonResponse(upstreamResponse2);
+    sendJsonWithRetry(res, responseData2, upstreamResponse2.status);
+    return true;
+  }
+  if (pathname.startsWith("/api/cloud/billing/crypto/") && pathname !== "/api/cloud/billing/crypto/quote") {
+    let body2;
+    if (method !== "GET" && method !== "HEAD") {
+      body2 = await readBody(req);
+    }
+    const upstreamPath = pathname.replace("/api/cloud/billing/crypto", "/api/crypto");
+    const upstreamResponse2 = await fetchUpstream(`${baseUrl}${upstreamPath}${fullUrl.search}`, method, headers, body2);
+    const responseData2 = await readJsonResponse(upstreamResponse2);
+    sendJsonWithRetry(res, responseData2, upstreamResponse2.status);
+    return true;
+  }
+  let body;
+  if (method !== "GET" && method !== "HEAD") {
+    body = await readBody(req);
+  }
+  const billingPath = pathname.replace("/api/cloud/billing", "/api/v1/billing");
+  const upstreamResponse = await fetchUpstream(`${baseUrl}${billingPath}${fullUrl.search}`, method, headers, body);
+  const responseData = await readJsonResponse(upstreamResponse);
+  sendJsonWithRetry(res, responseData, upstreamResponse.status);
+  return true;
+}
+var PROXY_TIMEOUT_MS = 15000, MAX_BODY_BYTES = 1048576, MAX_REDIRECTS = 4, CRYPTO_STATUS_CACHE_MS = 60000, cryptoStatusCache;
+var init_cloud_billing_routes = __esm(() => {
+  init_base_url();
+  init_validate_url();
+  cryptoStatusCache = new Map;
+});
+init_cloud_billing_routes();
+
+export {
+  handleCloudBillingRoute
+};
+
+//# debugId=8585E844C10AB24464756E2164756E21