@spotlightjs/spotlight 4.5.1 → 4.7.0

package/dist/server/utils/cors.js

@@ -0,0 +1,195 @@
+;
+!function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "4dd6e253-0d5e-4edb-bdeb-58750d0d4592", e._sentryDebugIdIdentifier = "sentry-dbid-4dd6e253-0d5e-4edb-bdeb-58750d0d4592");
+  } catch (e2) {
+  }
+}();
+import dns from "node:dns/promises";
+import net from "node:net";
+import os__default from "node:os";
+import "../../_virtual/_sentry-release-injection-file.js";
+const dnsCache = /* @__PURE__ */ new Map();
+const pendingResolutions = /* @__PURE__ */ new Map();
+const MIN_TTL_SECONDS = 60 * 60;
+const DEFAULT_TTL_MS = 60 * 60 * 1e3;
+const FAILURE_TTL_MS = 5 * 60 * 1e3;
+let machineIPsCache = null;
+let machineIPsCacheTime = 0;
+const MACHINE_IPS_CACHE_TTL_MS = 60 * 1e3;
+function getMachineIPs() {
+  const now = Date.now();
+  if (machineIPsCache && now - machineIPsCacheTime < MACHINE_IPS_CACHE_TTL_MS) {
+    return machineIPsCache;
+  }
+  const ips = /* @__PURE__ */ new Set();
+  const interfaces = os__default.networkInterfaces();
+  for (const name in interfaces) {
+    const addresses = interfaces[name];
+    if (addresses) {
+      for (const addr of addresses) {
+        ips.add(addr.address);
+      }
+    }
+  }
+  machineIPsCache = ips;
+  machineIPsCacheTime = now;
+  return ips;
+}
+function isIPAddress(hostname) {
+  const cleanHostname = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  return net.isIP(cleanHostname) !== 0;
+}
+function isLocalMachineIP(ip) {
+  const cleanIP = ip.startsWith("[") && ip.endsWith("]") ? ip.slice(1, -1) : ip;
+  const machineIPs = getMachineIPs();
+  return machineIPs.has(cleanIP);
+}
+async function resolveHostname(hostname) {
+  const dnsAddresses = [];
+  const hostsFileAddresses = [];
+  let minTtl;
+  const [resolve4Result, resolve6Result, lookupResult] = await Promise.allSettled([
+    dns.resolve4(hostname, { ttl: true }),
+    dns.resolve6(hostname, { ttl: true }),
+    dns.lookup(hostname, { all: true })
+  ]);
+  const dnsSucceeded = resolve4Result.status === "fulfilled" || resolve6Result.status === "fulfilled";
+  if (resolve4Result.status === "fulfilled") {
+    for (const record of resolve4Result.value) {
+      dnsAddresses.push({ address: record.address, ttl: record.ttl });
+      if (record.ttl !== void 0) {
+        minTtl = minTtl === void 0 ? record.ttl : Math.min(minTtl, record.ttl);
+      }
+    }
+  }
+  if (resolve6Result.status === "fulfilled") {
+    for (const record of resolve6Result.value) {
+      dnsAddresses.push({ address: record.address, ttl: record.ttl });
+      if (record.ttl !== void 0) {
+        minTtl = minTtl === void 0 ? record.ttl : Math.min(minTtl, record.ttl);
+      }
+    }
+  }
+  if (!dnsSucceeded && lookupResult.status === "fulfilled") {
+    const lookupAddresses = Array.isArray(lookupResult.value) ? lookupResult.value : [lookupResult.value];
+    for (const record of lookupAddresses) {
+      hostsFileAddresses.push(record.address);
+    }
+  }
+  return { dnsAddresses, hostsFileAddresses, minTtl };
+}
+async function resolveAndCacheHostname(hostname) {
+  try {
+    const { dnsAddresses, hostsFileAddresses, minTtl } = await resolveHostname(hostname);
+    const hostsLocal = hostsFileAddresses.some((addr) => isLocalMachineIP(addr));
+    if (hostsLocal) {
+      dnsCache.set(hostname, {
+        isLocal: true,
+        expiresAt: Date.now() + DEFAULT_TTL_MS
+      });
+      return true;
+    }
+    const dnsLocal = dnsAddresses.some((result) => isLocalMachineIP(result.address));
+    if (dnsLocal) {
+      if (minTtl !== void 0 && minTtl < MIN_TTL_SECONDS) {
+        dnsCache.set(hostname, {
+          isLocal: false,
+          expiresAt: Date.now() + FAILURE_TTL_MS
+        });
+        return false;
+      }
+      const cacheTtl2 = minTtl !== void 0 ? minTtl * 1e3 : DEFAULT_TTL_MS;
+      dnsCache.set(hostname, {
+        isLocal: true,
+        expiresAt: Date.now() + cacheTtl2
+      });
+      return true;
+    }
+    const cacheTtl = minTtl !== void 0 ? minTtl * 1e3 : DEFAULT_TTL_MS;
+    dnsCache.set(hostname, {
+      isLocal: false,
+      expiresAt: Date.now() + cacheTtl
+    });
+    return false;
+  } catch {
+    dnsCache.set(hostname, {
+      isLocal: false,
+      expiresAt: Date.now() + FAILURE_TTL_MS
+    });
+    return false;
+  }
+}
+async function isHostnameLocal(hostname) {
+  const cached = dnsCache.get(hostname);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.isLocal;
+  }
+  const pending = pendingResolutions.get(hostname);
+  if (pending) {
+    return pending;
+  }
+  const resolution = resolveAndCacheHostname(hostname);
+  pendingResolutions.set(hostname, resolution);
+  try {
+    return await resolution;
+  } finally {
+    pendingResolutions.delete(hostname);
+  }
+}
+function isSpotlightOrigin(url, hostname) {
+  if (hostname === "spotlightjs.com" || hostname.endsWith(".spotlightjs.com")) {
+    return url.protocol === "https:" && (url.port === "" || url.port === "443");
+  }
+  return false;
+}
+function normalizeAllowedOrigins(allowedOrigins) {
+  const fullOrigins = /* @__PURE__ */ new Set();
+  const domains = /* @__PURE__ */ new Set();
+  for (const entry of allowedOrigins) {
+    const normalized = entry.toLowerCase();
+    if (normalized.includes("://")) {
+      fullOrigins.add(normalized.replace(/\/$/, ""));
+    } else {
+      domains.add(normalized);
+    }
+  }
+  return { fullOrigins, domains };
+}
+function isCustomAllowedOrigin(origin, hostname, normalized) {
+  if (normalized.domains.has(hostname)) {
+    return true;
+  }
+  const normalizedOrigin = origin.toLowerCase().replace(/\/$/, "");
+  return normalized.fullOrigins.has(normalizedOrigin);
+}
+async function isAllowedOrigin(origin, normalizedAllowedOrigins) {
+  if (!origin) {
+    return false;
+  }
+  try {
+    const url = new URL(origin);
+    const hostname = url.hostname.toLowerCase();
+    if (hostname === "localhost") {
+      return true;
+    }
+    if (isSpotlightOrigin(url, hostname)) {
+      return true;
+    }
+    if (normalizedAllowedOrigins && isCustomAllowedOrigin(origin, hostname, normalizedAllowedOrigins)) {
+      return true;
+    }
+    if (isIPAddress(hostname)) {
+      return isLocalMachineIP(hostname);
+    }
+    return isHostnameLocal(hostname);
+  } catch {
+    return false;
+  }
+}
+export {
+  isAllowedOrigin,
+  normalizeAllowedOrigins
+};
+//# sourceMappingURL=cors.js.map

package/dist/server/utils/cors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.js","sources":["../../../src/server/utils/cors.ts"],"sourcesContent":["import dns from \"node:dns/promises\";\nimport net from \"node:net\";\nimport os from \"node:os\";\n\n/**\n * DNS Resolution Cache Entry\n */\ninterface CacheEntry {\n  isLocal: boolean;\n  expiresAt: number;\n}\n\n/**\n * DNS Resolution Result with optional TTL\n */\ninterface DnsResult {\n  address: string;\n  ttl?: number;\n}\n\n/**\n * Cache for DNS resolution results.\n * Key: lowercase hostname\n * Value: { isLocal, expiresAt }\n */\nconst dnsCache = new Map<string, CacheEntry>();\n\n/**\n * In-flight DNS resolutions for request coalescing.\n * Prevents duplicate DNS lookups when multiple requests come in\n * for the same hostname before the first one completes.\n */\nconst pendingResolutions = new Map<string, Promise<boolean>>();\n\n/**\n * TTL Constants (in milliseconds)\n *\n * DNS Rebinding Attack Protection:\n * ================================\n * A DNS rebinding attack works by:\n * 1. Attacker controls evil.com with a short TTL\n * 2. User visits evil.com, which initially resolves to attacker's server\n * 3. Attacker's page loads malicious JavaScript\n * 4. Attacker rebinds evil.com to 127.0.0.1\n * 5. JavaScript makes requests to evil.com (now 127.0.0.1), bypassing same-origin policy\n *\n * Our mitigation: Reject DNS records with TTL < 1 hour.\n * This means an attacker would need to set a TTL >= 1 hour, making their\n * site inaccessible for that duration after rebinding. This makes the attack\n * impractical for real-world exploitation.\n */\nconst MIN_TTL_SECONDS = 60 * 60; // 1 hour - reject DNS records with lower TTL\nconst DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour - used when DNS doesn't provide TTL (e.g., /etc/hosts)\nconst FAILURE_TTL_MS = 5 * 60 * 1000; // 5 minutes - cache failed lookups to avoid hammering DNS\n\n/**\n * DNS resolution notes:\n * We use both resolve4/6 AND lookup because:\n * - dns.resolve4/6: Queries DNS servers directly, can return TTL\n * - dns.lookup: Uses OS resolver (getaddrinfo), checks /etc/hosts first, then DNS\n *\n * A hostname in /etc/hosts won't be found by resolve4/6, hence we need both.\n * We can only trust lookup results when DNS (resolve4/6) fails - that means\n * the result came from /etc/hosts rather than DNS.\n */\n\n/**\n * Cache for machine's own IP addresses.\n * Refreshed periodically as network interfaces can change.\n */\nlet machineIPsCache: Set<string> | null = null;\nlet machineIPsCacheTime = 0;\nconst MACHINE_IPS_CACHE_TTL_MS = 60 * 1000; // 1 minute - refresh periodically for network changes\n\n/**\n * Get all IP addresses assigned to this machine's network interfaces.\n * This includes:\n * - Loopback (127.0.0.1, ::1)\n * - Local/private IPs (192.168.x.x, 10.x.x.x, etc.)\n * - VPN IPs (e.g., Tailscale 100.x.x.x, Zerotier IPs)\n *\n * Results are cached for 1 minute to handle network changes while\n * avoiding repeated system calls.\n */\nfunction getMachineIPs(): Set<string> {\n  const now = Date.now();\n  if (machineIPsCache && now - machineIPsCacheTime < MACHINE_IPS_CACHE_TTL_MS) {\n    return machineIPsCache;\n  }\n\n  const ips = new Set<string>();\n  const interfaces = os.networkInterfaces();\n\n  for (const name in interfaces) {\n    const addresses = interfaces[name];\n    if (addresses) {\n      for (const addr of addresses) {\n        ips.add(addr.address);\n      }\n    }\n  }\n\n  machineIPsCache = ips;\n  machineIPsCacheTime = now;\n  return ips;\n}\n\n/**\n * Check if a string is an IP address (IPv4 or IPv6).\n */\nfunction isIPAddress(hostname: string): boolean {\n  // Handle bracketed IPv6 (e.g., [::1])\n  const cleanHostname = hostname.startsWith(\"[\") && hostname.endsWith(\"]\") ? hostname.slice(1, -1) : hostname;\n  return net.isIP(cleanHostname) !== 0;\n}\n\n/**\n * Check if an IP address belongs to this machine.\n * See getMachineIPs() for details on what IPs are considered local.\n */\nfunction isLocalMachineIP(ip: string): boolean {\n  // Handle bracketed IPv6\n  const cleanIP = ip.startsWith(\"[\") && ip.endsWith(\"]\") ? ip.slice(1, -1) : ip;\n  const machineIPs = getMachineIPs();\n  return machineIPs.has(cleanIP);\n}\n\n/**\n * Resolution result with source information for trust decisions.\n */\ninterface ResolutionResult {\n  /** Addresses from dns.resolve4/6() with TTL */\n  dnsAddresses: DnsResult[];\n  /** Addresses from dns.lookup() when DNS failed - these are from /etc/hosts */\n  hostsFileAddresses: string[];\n  /** Minimum TTL from DNS results (seconds) */\n  minTtl?: number;\n}\n\n/**\n * Resolve a hostname to IP addresses using both DNS and OS resolver.\n *\n * Why both dns.resolve() and dns.lookup()?\n * - dns.resolve4/6: Direct DNS query, returns TTL when available\n * - dns.lookup: Uses OS resolver (getaddrinfo), which reads /etc/hosts\n *\n * A hostname in /etc/hosts won't be found by resolve4/6, hence we need both.\n *\n * Trust model:\n * - If dns.resolve() succeeds → result is from DNS, needs TTL validation\n * - If dns.resolve() fails but dns.lookup() succeeds → result is from /etc/hosts, trusted\n *\n * We can only trust lookup results when DNS failed, because lookup also queries\n * DNS servers (via the OS resolver) if the hostname isn't in /etc/hosts.\n */\nasync function resolveHostname(hostname: string): Promise<ResolutionResult> {\n  const dnsAddresses: DnsResult[] = [];\n  const hostsFileAddresses: string[] = [];\n  let minTtl: number | undefined;\n\n  // Run all resolution methods in parallel for efficiency\n  const [resolve4Result, resolve6Result, lookupResult] = await Promise.allSettled([\n    dns.resolve4(hostname, { ttl: true }),\n    dns.resolve6(hostname, { ttl: true }),\n    dns.lookup(hostname, { all: true }),\n  ]);\n\n  const dnsSucceeded = resolve4Result.status === \"fulfilled\" || resolve6Result.status === \"fulfilled\";\n\n  // Process IPv4 DNS results (with TTL)\n  if (resolve4Result.status === \"fulfilled\") {\n    for (const record of resolve4Result.value) {\n      dnsAddresses.push({ address: record.address, ttl: record.ttl });\n      if (record.ttl !== undefined) {\n        minTtl = minTtl === undefined ? record.ttl : Math.min(minTtl, record.ttl);\n      }\n    }\n  }\n\n  // Process IPv6 DNS results (with TTL)\n  if (resolve6Result.status === \"fulfilled\") {\n    for (const record of resolve6Result.value) {\n      dnsAddresses.push({ address: record.address, ttl: record.ttl });\n      if (record.ttl !== undefined) {\n        minTtl = minTtl === undefined ? record.ttl : Math.min(minTtl, record.ttl);\n      }\n    }\n  }\n\n  // Process OS resolver results - ONLY trusted if DNS failed\n  // If DNS succeeded, lookup would return the same DNS result (not trusted separately)\n  // If DNS failed but lookup succeeded, it must be from /etc/hosts (trusted)\n  if (!dnsSucceeded && lookupResult.status === \"fulfilled\") {\n    const lookupAddresses = Array.isArray(lookupResult.value) ? lookupResult.value : [lookupResult.value];\n    for (const record of lookupAddresses) {\n      hostsFileAddresses.push(record.address);\n    }\n  }\n\n  return { dnsAddresses, hostsFileAddresses, minTtl };\n}\n\n/**\n * Perform the actual DNS resolution and cache the result.\n * This is separated from isHostnameLocal to enable request coalescing.\n */\nasync function resolveAndCacheHostname(hostname: string): Promise<boolean> {\n  try {\n    const { dnsAddresses, hostsFileAddresses, minTtl } = await resolveHostname(hostname);\n\n    // First check /etc/hosts addresses (trusted - DNS failed, so these must be from hosts file)\n    // These are under local control and don't need TTL validation\n    const hostsLocal = hostsFileAddresses.some(addr => isLocalMachineIP(addr));\n    if (hostsLocal) {\n      // /etc/hosts entry resolves to local - cache and allow\n      dnsCache.set(hostname, {\n        isLocal: true,\n        expiresAt: Date.now() + DEFAULT_TTL_MS,\n      });\n      return true;\n    }\n\n    // Check DNS addresses (need TTL validation for rebinding protection)\n    const dnsLocal = dnsAddresses.some(result => isLocalMachineIP(result.address));\n\n    if (dnsLocal) {\n      // DNS rebinding protection: reject records with TTL < 1 hour\n      if (minTtl !== undefined && minTtl < MIN_TTL_SECONDS) {\n        // Low TTL is suspicious - reject and cache as non-local\n        dnsCache.set(hostname, {\n          isLocal: false,\n          expiresAt: Date.now() + FAILURE_TTL_MS,\n        });\n        return false;\n      }\n\n      // DNS resolves to local with safe TTL\n      const cacheTtl = minTtl !== undefined ? minTtl * 1000 : DEFAULT_TTL_MS;\n      dnsCache.set(hostname, {\n        isLocal: true,\n        expiresAt: Date.now() + cacheTtl,\n      });\n      return true;\n    }\n\n    // Not a local address - cache the negative result\n    const cacheTtl = minTtl !== undefined ? minTtl * 1000 : DEFAULT_TTL_MS;\n    dnsCache.set(hostname, {\n      isLocal: false,\n      expiresAt: Date.now() + cacheTtl,\n    });\n    return false;\n  } catch {\n    // DNS resolution failed - cache the failure briefly\n    dnsCache.set(hostname, {\n      isLocal: false,\n      expiresAt: Date.now() + FAILURE_TTL_MS,\n    });\n    return false;\n  }\n}\n\n/**\n * Check if a hostname resolves to this machine, with DNS rebinding protection.\n *\n * Returns true if the hostname resolves to a local IP AND has a safe TTL.\n * DNS records with TTL < 1 hour are rejected to prevent rebinding attacks.\n * Results are cached to avoid repeated DNS lookups.\n *\n * Uses request coalescing: if multiple requests come in for the same hostname\n * before the first resolution completes, they all share the same promise.\n */\nasync function isHostnameLocal(hostname: string): Promise<boolean> {\n  // Check cache first\n  const cached = dnsCache.get(hostname);\n  if (cached && cached.expiresAt > Date.now()) {\n    return cached.isLocal;\n  }\n\n  // Check if there's already an in-flight resolution for this hostname\n  const pending = pendingResolutions.get(hostname);\n  if (pending) {\n    return pending;\n  }\n\n  // Start a new resolution and track it\n  const resolution = resolveAndCacheHostname(hostname);\n  pendingResolutions.set(hostname, resolution);\n\n  try {\n    return await resolution;\n  } finally {\n    pendingResolutions.delete(hostname);\n  }\n}\n\n/**\n * Check if an origin is from spotlightjs.com (HTTPS only, default port).\n */\nfunction isSpotlightOrigin(url: URL, hostname: string): boolean {\n  if (hostname === \"spotlightjs.com\" || hostname.endsWith(\".spotlightjs.com\")) {\n    return url.protocol === \"https:\" && (url.port === \"\" || url.port === \"443\");\n  }\n  return false;\n}\n\n/**\n * Pre-normalized allowed origins for efficient matching.\n * Call normalizeAllowedOrigins() once at server startup to create this structure.\n */\nexport interface NormalizedAllowedOrigins {\n  /** Full origins (lowercased, trailing slash removed) for exact matching */\n  fullOrigins: Set<string>;\n  /** Plain domains (lowercased) for permissive matching */\n  domains: Set<string>;\n}\n\n/**\n * Normalize and classify allowed origins for efficient matching.\n * Call this once at server startup, then pass the result to isAllowedOrigin().\n *\n * @param allowedOrigins - Raw list of allowed origins/domains from config\n * @returns Pre-normalized structure for O(1) lookups\n */\nexport function normalizeAllowedOrigins(allowedOrigins: string[]): NormalizedAllowedOrigins {\n  const fullOrigins = new Set<string>();\n  const domains = new Set<string>();\n\n  for (const entry of allowedOrigins) {\n    const normalized = entry.toLowerCase();\n    if (normalized.includes(\"://\")) {\n      // Full origin - normalize by removing trailing slash\n      fullOrigins.add(normalized.replace(/\\/$/, \"\"));\n    } else {\n      // Plain domain\n      domains.add(normalized);\n    }\n  }\n\n  return { fullOrigins, domains };\n}\n\n/**\n * Check if an origin matches an entry in the pre-normalized allowed origins.\n *\n * Supports two formats:\n * - Full origins (e.g., \"https://ngrok.io:443\") - exact match required\n * - Plain domains (e.g., \"myapp.local\") - matches any protocol/port\n *\n * @param origin - The origin to check (e.g., \"https://myapp.local:3000\")\n * @param hostname - The lowercase hostname from the origin URL\n * @param normalized - Pre-normalized allowed origins\n */\nfunction isCustomAllowedOrigin(origin: string, hostname: string, normalized: NormalizedAllowedOrigins): boolean {\n  // Check plain domain match first (more common case)\n  if (normalized.domains.has(hostname)) {\n    return true;\n  }\n\n  // Check full origin match\n  const normalizedOrigin = origin.toLowerCase().replace(/\\/$/, \"\");\n  return normalized.fullOrigins.has(normalizedOrigin);\n}\n\n/**\n * Clear the DNS cache, pending resolutions, and machine IPs cache. Useful for testing.\n */\nexport function clearDnsCache(): void {\n  dnsCache.clear();\n  pendingResolutions.clear();\n  machineIPsCache = null;\n  machineIPsCacheTime = 0;\n}\n\n/**\n * Get the current DNS cache size. Useful for testing.\n */\nexport function getDnsCacheSize(): number {\n  return dnsCache.size;\n}\n\n/**\n * Validates if an origin should be allowed to access the Sidecar.\n *\n * Allowed origins:\n * - localhost (RFC 6761 reserved name, always trusted)\n * - Any origin whose hostname resolves to this machine's IPs (with TTL >= 1h)\n * - https://spotlightjs.com and subdomains (HTTPS only, default port)\n * - Custom origins/domains from the normalizedAllowedOrigins list\n *\n * For DNS rebinding protection details, see the TTL Constants section above.\n *\n * @param origin - The origin to validate\n * @param normalizedAllowedOrigins - Optional pre-normalized allowed origins (from normalizeAllowedOrigins())\n * @returns Promise<boolean> - true if the origin is allowed, false otherwise\n */\nexport async function isAllowedOrigin(\n  origin: string,\n  normalizedAllowedOrigins?: NormalizedAllowedOrigins,\n): Promise<boolean> {\n  if (!origin) {\n    return false;\n  }\n\n  try {\n    const url = new URL(origin);\n    const hostname = url.hostname.toLowerCase();\n\n    // Fast path: localhost is always allowed (RFC 6761 reserved name)\n    // This is safe because \"localhost\" is guaranteed to resolve to loopback\n    // and cannot be registered as a public domain name.\n    if (hostname === \"localhost\") {\n      return true;\n    }\n\n    // Fast path: spotlightjs.com domains (no DNS lookup needed)\n    if (isSpotlightOrigin(url, hostname)) {\n      return true;\n    }\n\n    // Fast path: Check custom allowed origins (no DNS lookup needed)\n    if (normalizedAllowedOrigins && isCustomAllowedOrigin(origin, hostname, normalizedAllowedOrigins)) {\n      return true;\n    }\n\n    // Fast path: If hostname is already an IP address, check directly\n    if (isIPAddress(hostname)) {\n      return isLocalMachineIP(hostname);\n    }\n\n    // Resolve hostname and check if it's local (with caching and TTL validation)\n    return isHostnameLocal(hostname);\n  } catch {\n    // Invalid URL\n    return false;\n  }\n}\n"],"names":["os","cacheTtl"],"mappings":"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"}

package/dist/server/utils/docker-compose-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Get compose files from COMPOSE_FILE environment variable
+ * Returns an array of file paths if the variable is set, null otherwise
+ */
+export declare function getComposeFilesFromEnv(): string[] | null;
+/**
+ * Find the compose file in the current directory by trying all combinations
+ * of base names and extensions.
+ */
+export declare function findComposeFile(): string | null;
+/**
+ * Find the override file for a given compose file.
+ * Docker Compose looks for an override file with the same base name and extension.
+ * For example: docker-compose.yml -> docker-compose.override.yml
+ */
+export declare function findOverrideFile(composeFile: string): string | null;
+/**
+ * Parse compose file and extract service names
+ */
+export declare function getDockerComposeServices(filePath: string): string[];

package/dist/server/utils/docker-compose-parser.js

@@ -0,0 +1,70 @@
+;
+!function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "27b39d5b-e60f-435f-945d-efc94ca1a964", e._sentryDebugIdIdentifier = "sentry-dbid-27b39d5b-e60f-435f-945d-efc94ca1a964");
+  } catch (e2) {
+  }
+}();
+import { accessSync, constants, readFileSync } from "node:fs";
+import { delimiter } from "node:path";
+import { parse } from "yaml";
+import { logger } from "../logger.js";
+import "../../_virtual/_sentry-release-injection-file.js";
+const COMPOSE_FILE_BASE_NAMES = ["docker-compose", "compose"];
+const COMPOSE_FILE_EXTENSIONS = [".yml", ".yaml"];
+function getComposeFilesFromEnv() {
+  const composeFileEnv = process.env.COMPOSE_FILE;
+  if (!composeFileEnv) {
+    return null;
+  }
+  const files = composeFileEnv.split(delimiter).map((f) => f.trim()).filter(Boolean);
+  return files.length > 0 ? files : null;
+}
+function findComposeFile() {
+  for (const baseName of COMPOSE_FILE_BASE_NAMES) {
+    for (const ext of COMPOSE_FILE_EXTENSIONS) {
+      const fileName = `${baseName}${ext}`;
+      try {
+        accessSync(fileName, constants.R_OK);
+        return fileName;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function findOverrideFile(composeFile) {
+  const ext = composeFile.endsWith(".yaml") ? ".yaml" : ".yml";
+  const baseName = composeFile.replace(/\.(yaml|yml)$/, "");
+  const overrideFile = `${baseName}.override${ext}`;
+  try {
+    accessSync(overrideFile, constants.R_OK);
+    return overrideFile;
+  } catch {
+    return null;
+  }
+}
+function getDockerComposeServices(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parse(content);
+    if (!parsed || typeof parsed !== "object" || !("services" in parsed)) {
+      logger.error(`Invalid compose file: ${filePath} - missing 'services' key`);
+      return [];
+    }
+    const services = parsed.services;
+    return Object.keys(services);
+  } catch (error) {
+    logger.error(`Failed to parse compose file: ${filePath}`);
+    logger.error(error);
+    return [];
+  }
+}
+export {
+  findComposeFile,
+  findOverrideFile,
+  getComposeFilesFromEnv,
+  getDockerComposeServices
+};
+//# sourceMappingURL=docker-compose-parser.js.map

package/dist/server/utils/docker-compose-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-compose-parser.js","sources":["../../../src/server/utils/docker-compose-parser.ts"],"sourcesContent":["import { constants, accessSync, readFileSync } from \"node:fs\";\nimport { delimiter } from \"node:path\";\nimport { parse as parseYaml } from \"yaml\";\nimport { logger } from \"../logger.ts\";\n\nconst COMPOSE_FILE_BASE_NAMES = [\"docker-compose\", \"compose\"] as const;\nconst COMPOSE_FILE_EXTENSIONS = [\".yml\", \".yaml\"] as const;\n\n/**\n * Get compose files from COMPOSE_FILE environment variable\n * Returns an array of file paths if the variable is set, null otherwise\n */\nexport function getComposeFilesFromEnv(): string[] | null {\n  const composeFileEnv = process.env.COMPOSE_FILE;\n  if (!composeFileEnv) {\n    return null;\n  }\n\n  // Split by platform-specific path delimiter (: on Unix, ; on Windows)\n  const files = composeFileEnv\n    .split(delimiter)\n    .map(f => f.trim())\n    .filter(Boolean);\n\n  return files.length > 0 ? files : null;\n}\n\n/**\n * Find the compose file in the current directory by trying all combinations\n * of base names and extensions.\n */\nexport function findComposeFile(): string | null {\n  for (const baseName of COMPOSE_FILE_BASE_NAMES) {\n    for (const ext of COMPOSE_FILE_EXTENSIONS) {\n      const fileName = `${baseName}${ext}`;\n      try {\n        accessSync(fileName, constants.R_OK);\n        return fileName;\n      } catch {\n        // File doesn't exist or isn't readable, continue searching\n      }\n    }\n  }\n  return null;\n}\n\n/**\n * Find the override file for a given compose file.\n * Docker Compose looks for an override file with the same base name and extension.\n * For example: docker-compose.yml -> docker-compose.override.yml\n */\nexport function findOverrideFile(composeFile: string): string | null {\n  // Extract extension from the original file to maintain consistency\n  const ext = composeFile.endsWith(\".yaml\") ? \".yaml\" : \".yml\";\n  const baseName = composeFile.replace(/\\.(yaml|yml)$/, \"\");\n  const overrideFile = `${baseName}.override${ext}`;\n\n  try {\n    accessSync(overrideFile, constants.R_OK);\n    return overrideFile;\n  } catch {\n    // File doesn't exist or isn't readable\n    return null;\n  }\n}\n\n/**\n * Parse compose file and extract service names\n */\nexport function getDockerComposeServices(filePath: string): string[] {\n  try {\n    const content = readFileSync(filePath, \"utf-8\");\n    const parsed = parseYaml(content);\n\n    if (!parsed || typeof parsed !== \"object\" || !(\"services\" in parsed)) {\n      logger.error(`Invalid compose file: ${filePath} - missing 'services' key`);\n      return [];\n    }\n\n    const services = parsed.services as Record<string, unknown>;\n    return Object.keys(services);\n  } catch (error) {\n    logger.error(`Failed to parse compose file: ${filePath}`);\n    logger.error(error);\n    return [];\n  }\n}\n"],"names":["parseYaml"],"mappings":";;;;;;;;;;;;;AAKA,MAAM,0BAA0B,CAAC,kBAAkB,SAAS;AAC5D,MAAM,0BAA0B,CAAC,QAAQ,OAAO;AAMzC,SAAS,yBAA0C;AACxD,QAAM,iBAAiB,QAAQ,IAAI;AACnC,MAAI,CAAC,gBAAgB;AACnB,WAAO;AAAA,EACT;AAGA,QAAM,QAAQ,eACX,MAAM,SAAS,EACf,IAAI,CAAA,MAAK,EAAE,KAAA,CAAM,EACjB,OAAO,OAAO;AAEjB,SAAO,MAAM,SAAS,IAAI,QAAQ;AACpC;AAMO,SAAS,kBAAiC;AAC/C,aAAW,YAAY,yBAAyB;AAC9C,eAAW,OAAO,yBAAyB;AACzC,YAAM,WAAW,GAAG,QAAQ,GAAG,GAAG;AAClC,UAAI;AACF,mBAAW,UAAU,UAAU,IAAI;AACnC,eAAO;AAAA,MACT,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,iBAAiB,aAAoC;AAEnE,QAAM,MAAM,YAAY,SAAS,OAAO,IAAI,UAAU;AACtD,QAAM,WAAW,YAAY,QAAQ,iBAAiB,EAAE;AACxD,QAAM,eAAe,GAAG,QAAQ,YAAY,GAAG;AAE/C,MAAI;AACF,eAAW,cAAc,UAAU,IAAI;AACvC,WAAO;AAAA,EACT,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAKO,SAAS,yBAAyB,UAA4B;AACnE,MAAI;AACF,UAAM,UAAU,aAAa,UAAU,OAAO;AAC9C,UAAM,SAASA,MAAU,OAAO;AAEhC,QAAI,CAAC,UAAU,OAAO,WAAW,YAAY,EAAE,cAAc,SAAS;AACpE,aAAO,MAAM,yBAAyB,QAAQ,2BAA2B;AACzE,aAAO,CAAA;AAAA,IACT;AAEA,UAAM,WAAW,OAAO;AACxB,WAAO,OAAO,KAAK,QAAQ;AAAA,EAC7B,SAAS,OAAO;AACd,WAAO,MAAM,iCAAiC,QAAQ,EAAE;AACxD,WAAO,MAAM,KAAK;AAClB,WAAO,CAAA;AAAA,EACT;AACF;"}

package/dist/server/utils/docker-compose.d.ts

@@ -0,0 +1,30 @@
+export declare const DOCKER_MIN_VERSION = "20.10.0";
+export declare const DOCKER_HOST_INTERNAL = "host.docker.internal";
+export declare const DOCKER_HOST_GATEWAY = "host-gateway";
+interface DockerComposeConfig {
+    composeFiles: string[];
+    command: string[];
+    serviceNames: string[];
+}
+/**
+ * Detect if Docker is installed and check its version
+ */
+export declare function detectDocker(): {
+    version: string;
+    valid: boolean;
+} | null;
+/**
+ * Build the Docker Compose command with Spotlight environment injection
+ */
+export declare function buildDockerComposeCommand(config: DockerComposeConfig): {
+    cmdArgs: string[];
+    stdin: string;
+};
+/**
+ * Detect and configure Docker Compose
+ *
+ * This function orchestrates the detection of Docker, Docker Compose,
+ * compose files, and services to build a complete configuration.
+ */
+export declare function detectDockerCompose(): DockerComposeConfig | null;
+export {};

package/dist/server/utils/docker-compose.js

@@ -0,0 +1,140 @@
+;
+!function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9ad90655-f477-4509-801c-7553667734cb", e._sentryDebugIdIdentifier = "sentry-dbid-9ad90655-f477-4509-801c-7553667734cb");
+  } catch (e2) {
+  }
+}();
+import { execSync } from "node:child_process";
+import semver from "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js";
+import { stringify } from "yaml";
+import { logger } from "../logger.js";
+import { getComposeFilesFromEnv, findComposeFile, findOverrideFile, getDockerComposeServices } from "./docker-compose-parser.js";
+import "../../_virtual/_sentry-release-injection-file.js";
+const DOCKER_MIN_VERSION = "20.10.0";
+const DOCKER_HOST_INTERNAL = "host.docker.internal";
+const DOCKER_HOST_GATEWAY = "host-gateway";
+function tryExec(command) {
+  try {
+    return execSync(command, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function detectDocker() {
+  const version = tryExec("docker --version");
+  if (!version) {
+    return null;
+  }
+  const match = version.match(/Docker version ([\d.]+)/);
+  if (!match) {
+    return null;
+  }
+  const versionNumber = match[1];
+  const valid = semver.gte(versionNumber, DOCKER_MIN_VERSION);
+  return { version: versionNumber, valid };
+}
+function detectComposeCommand() {
+  const composePluginVersion = tryExec("docker compose version --short");
+  const composeStandaloneVersion = tryExec("docker-compose version --short");
+  if (!composePluginVersion && !composeStandaloneVersion) {
+    return null;
+  }
+  if (!composePluginVersion) {
+    return { command: ["docker-compose"], version: composeStandaloneVersion };
+  }
+  if (!composeStandaloneVersion) {
+    return { command: ["docker", "compose"], version: composePluginVersion };
+  }
+  const pluginVer = composePluginVersion.replace(/^v/, "");
+  const standaloneVer = composeStandaloneVersion.replace(/^v/, "");
+  if (semver.gt(standaloneVer, pluginVer)) {
+    return { command: ["docker-compose"], version: composeStandaloneVersion };
+  }
+  return { command: ["docker", "compose"], version: composePluginVersion };
+}
+function generateSpotlightOverrideYaml(serviceNames) {
+  const services = {};
+  for (const serviceName of serviceNames) {
+    services[serviceName] = {
+      environment: ["SENTRY_SPOTLIGHT", "NEXT_PUBLIC_SENTRY_SPOTLIGHT", "SENTRY_TRACES_SAMPLE_RATE"],
+      extra_hosts: [`${DOCKER_HOST_INTERNAL}:${DOCKER_HOST_GATEWAY}`]
+    };
+  }
+  return stringify({ services });
+}
+function buildDockerComposeCommand(config) {
+  const cmdArgs = [...config.command];
+  for (const file of config.composeFiles) {
+    cmdArgs.push("-f", file);
+  }
+  cmdArgs.push("-f", "-");
+  cmdArgs.push("up");
+  const stdin = generateSpotlightOverrideYaml(config.serviceNames);
+  return { cmdArgs, stdin };
+}
+function detectDockerCompose() {
+  const docker = detectDocker();
+  if (!docker) {
+    logger.debug("Docker is not installed or not in PATH");
+    return null;
+  }
+  if (!docker.valid) {
+    logger.error(`Docker version ${docker.version} does not meet the minimum required version ${DOCKER_MIN_VERSION}`);
+    return null;
+  }
+  logger.debug(`Detected Docker version ${docker.version}`);
+  const compose = detectComposeCommand();
+  if (!compose) {
+    logger.debug("Docker Compose is not installed or not in PATH");
+    return null;
+  }
+  logger.debug(`Detected Docker Compose version ${compose.version} (${compose.command.join(" ")})`);
+  const composeFilesFromEnv = getComposeFilesFromEnv();
+  let composeFiles;
+  if (composeFilesFromEnv) {
+    composeFiles = composeFilesFromEnv;
+    logger.debug(`Using COMPOSE_FILE environment variable: ${composeFiles.join(", ")}`);
+  } else {
+    const composeFile = findComposeFile();
+    if (!composeFile) {
+      logger.debug("No compose file found in current directory");
+      return null;
+    }
+    logger.debug(`Found compose file: ${composeFile}`);
+    composeFiles = [composeFile];
+    const overrideFile = findOverrideFile(composeFile);
+    if (overrideFile) {
+      logger.debug(`Found override file: ${overrideFile}`);
+      composeFiles.push(overrideFile);
+    }
+  }
+  const serviceNamesSet = /* @__PURE__ */ new Set();
+  for (const file of composeFiles) {
+    const services = getDockerComposeServices(file);
+    for (const service of services) {
+      serviceNamesSet.add(service);
+    }
+  }
+  const serviceNames = Array.from(serviceNamesSet);
+  if (serviceNames.length === 0) {
+    logger.debug("No services found in compose file(s)");
+    return null;
+  }
+  logger.debug(`Found ${serviceNames.length} service(s): ${serviceNames.join(", ")}`);
+  return {
+    composeFiles,
+    command: compose.command,
+    serviceNames
+  };
+}
+export {
+  DOCKER_HOST_GATEWAY,
+  DOCKER_HOST_INTERNAL,
+  DOCKER_MIN_VERSION,
+  buildDockerComposeCommand,
+  detectDocker,
+  detectDockerCompose
+};
+//# sourceMappingURL=docker-compose.js.map

package/dist/server/utils/docker-compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-compose.js","sources":["../../../src/server/utils/docker-compose.ts"],"sourcesContent":["import { execSync } from \"node:child_process\";\nimport semver from \"semver\";\nimport { stringify as stringifyYaml } from \"yaml\";\nimport { logger } from \"../logger.ts\";\nimport {\n  findComposeFile,\n  findOverrideFile,\n  getComposeFilesFromEnv,\n  getDockerComposeServices,\n} from \"./docker-compose-parser.ts\";\n\n// minimum version of Docker required to use host.docker.internal on linux\n/// https://docs.docker.com/engine/release-notes/20.10/#bug-fixes-and-enhancements-1\nexport const DOCKER_MIN_VERSION = \"20.10.0\";\nexport const DOCKER_HOST_INTERNAL = \"host.docker.internal\";\nexport const DOCKER_HOST_GATEWAY = \"host-gateway\";\n\ninterface DockerComposeConfig {\n  composeFiles: string[]; // Array of compose files\n  command: string[];\n  serviceNames: string[];\n}\n\n/**\n * Execute a command and return the output, or null if it fails\n */\nfunction tryExec(command: string): string | null {\n  try {\n    return execSync(command, { encoding: \"utf-8\", stdio: [\"pipe\", \"pipe\", \"pipe\"] }).trim();\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Detect if Docker is installed and check its version\n */\nexport function detectDocker(): { version: string; valid: boolean } | null {\n  const version = tryExec(\"docker --version\");\n  if (!version) {\n    return null;\n  }\n\n  const match = version.match(/Docker version ([\\d.]+)/);\n  if (!match) {\n    return null;\n  }\n\n  const versionNumber = match[1];\n  const valid = semver.gte(versionNumber, DOCKER_MIN_VERSION);\n\n  return { version: versionNumber, valid };\n}\n\n/**\n * Detect which compose command to use and its version\n * Follows the logic from sentry/self-hosted\n */\nfunction detectComposeCommand(): { command: string[]; version: string } | null {\n  const composePluginVersion = tryExec(\"docker compose version --short\");\n  const composeStandaloneVersion = tryExec(\"docker-compose version --short\");\n\n  if (!composePluginVersion && !composeStandaloneVersion) {\n    return null;\n  }\n\n  if (!composePluginVersion) {\n    return { command: [\"docker-compose\"], version: composeStandaloneVersion! };\n  }\n\n  if (!composeStandaloneVersion) {\n    return { command: [\"docker\", \"compose\"], version: composePluginVersion! };\n  }\n\n  // Use standalone if it's newer, otherwise prefer plugin\n  const pluginVer = composePluginVersion.replace(/^v/, \"\");\n  const standaloneVer = composeStandaloneVersion.replace(/^v/, \"\");\n\n  if (semver.gt(standaloneVer, pluginVer)) {\n    return { command: [\"docker-compose\"], version: composeStandaloneVersion };\n  }\n\n  return { command: [\"docker\", \"compose\"], version: composePluginVersion };\n}\n\n/**\n * Generate the override YAML for injecting Spotlight environment variables\n */\nfunction generateSpotlightOverrideYaml(serviceNames: string[]): string {\n  const services: Record<string, { environment: string[]; extra_hosts: string[] }> = {};\n  // Pass environment variables without values to inherit from parent process (run.ts)\n  // so the values set in run.ts are propagated correctly\n  for (const serviceName of serviceNames) {\n    services[serviceName] = {\n      environment: [\"SENTRY_SPOTLIGHT\", \"NEXT_PUBLIC_SENTRY_SPOTLIGHT\", \"SENTRY_TRACES_SAMPLE_RATE\"],\n      extra_hosts: [`${DOCKER_HOST_INTERNAL}:${DOCKER_HOST_GATEWAY}`],\n    };\n  }\n\n  return stringifyYaml({ services });\n}\n\n/**\n * Build the Docker Compose command with Spotlight environment injection\n */\nexport function buildDockerComposeCommand(config: DockerComposeConfig): {\n  cmdArgs: string[];\n  stdin: string;\n} {\n  const cmdArgs = [...config.command];\n\n  // Add -f for each compose file\n  for (const file of config.composeFiles) {\n    cmdArgs.push(\"-f\", file);\n  }\n\n  // Add our Spotlight override last\n  cmdArgs.push(\"-f\", \"-\");\n  cmdArgs.push(\"up\");\n\n  const stdin = generateSpotlightOverrideYaml(config.serviceNames);\n\n  return { cmdArgs, stdin };\n}\n\n/**\n * Detect and configure Docker Compose\n *\n * This function orchestrates the detection of Docker, Docker Compose,\n * compose files, and services to build a complete configuration.\n */\nexport function detectDockerCompose(): DockerComposeConfig | null {\n  const docker = detectDocker();\n  if (!docker) {\n    logger.debug(\"Docker is not installed or not in PATH\");\n    return null;\n  }\n\n  if (!docker.valid) {\n    logger.error(`Docker version ${docker.version} does not meet the minimum required version ${DOCKER_MIN_VERSION}`);\n    return null;\n  }\n\n  logger.debug(`Detected Docker version ${docker.version}`);\n\n  const compose = detectComposeCommand();\n  if (!compose) {\n    logger.debug(\"Docker Compose is not installed or not in PATH\");\n    return null;\n  }\n\n  logger.debug(`Detected Docker Compose version ${compose.version} (${compose.command.join(\" \")})`);\n\n  // First check if COMPOSE_FILE env is set\n  const composeFilesFromEnv = getComposeFilesFromEnv();\n  let composeFiles: string[];\n\n  if (composeFilesFromEnv) {\n    // Use files from COMPOSE_FILE env variable\n    composeFiles = composeFilesFromEnv;\n    logger.debug(`Using COMPOSE_FILE environment variable: ${composeFiles.join(\", \")}`);\n  } else {\n    // Use existing findComposeFile() + findOverrideFile() logic\n    const composeFile = findComposeFile();\n    if (!composeFile) {\n      logger.debug(\"No compose file found in current directory\");\n      return null;\n    }\n\n    logger.debug(`Found compose file: ${composeFile}`);\n\n    composeFiles = [composeFile];\n\n    // Check for override file (only when COMPOSE_FILE is not set)\n    const overrideFile = findOverrideFile(composeFile);\n    if (overrideFile) {\n      logger.debug(`Found override file: ${overrideFile}`);\n      composeFiles.push(overrideFile);\n    }\n  }\n\n  // Parse services from all compose files using the refactored function\n  const serviceNamesSet = new Set<string>();\n  for (const file of composeFiles) {\n    const services = getDockerComposeServices(file);\n    for (const service of services) {\n      serviceNamesSet.add(service);\n    }\n  }\n\n  const serviceNames = Array.from(serviceNamesSet);\n  if (serviceNames.length === 0) {\n    logger.debug(\"No services found in compose file(s)\");\n    return null;\n  }\n\n  logger.debug(`Found ${serviceNames.length} service(s): ${serviceNames.join(\", \")}`);\n\n  return {\n    composeFiles,\n    command: compose.command,\n    serviceNames,\n  };\n}\n"],"names":["stringifyYaml"],"mappings":"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"}

package/dist/server/utils/eventContainer.d.ts

@@ -0,0 +1,34 @@
+import { ParsedEnvelope } from '../parser/index.ts';
+/**
+ * Container for events that flow through the sidecar
+ * Provides lazy parsing only when needed (in debug mode)
+ */
+export declare class EventContainer {
+    private contentType;
+    private data;
+    private senderUserAgent?;
+    private parsedEnvelope;
+    private isParsed;
+    constructor(contentType: string, data: Buffer, senderUserAgent?: string);
+    /**
+     * Get the content type of the event
+     */
+    getContentType(): string;
+    /**
+     * Get the raw data buffer
+     */
+    getData(): Buffer;
+    /**
+     * Get parsed envelope data (lazy parsing)
+     */
+    getParsedEnvelope(): ParsedEnvelope;
+    /**
+     * Get a summary of the event types in this container
+     * Returns null if not a parseable envelope
+     */
+    getEventTypes(): string[] | null;
+    /**
+     * Get a formatted string of event types for logging
+     */
+    getEventTypesString(): string;
+}

package/dist/server/utils/eventContainer.js

@@ -0,0 +1,80 @@
+;
+!function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "ec6850ef-32dd-43f1-83d6-2cea9fb32ec9", e._sentryDebugIdIdentifier = "sentry-dbid-ec6850ef-32dd-43f1-83d6-2cea9fb32ec9");
+  } catch (e2) {
+  }
+}();
+import "../parser/helpers.js";
+import { processEnvelope } from "../parser/processEnvelope.js";
+import "../../_virtual/_sentry-release-injection-file.js";
+class EventContainer {
+  contentType;
+  data;
+  senderUserAgent;
+  parsedEnvelope = null;
+  isParsed = false;
+  constructor(contentType, data, senderUserAgent) {
+    this.contentType = contentType;
+    this.data = data;
+    this.senderUserAgent = senderUserAgent;
+  }
+  /**
+   * Get the content type of the event
+   */
+  getContentType() {
+    return this.contentType;
+  }
+  /**
+   * Get the raw data buffer
+   */
+  getData() {
+    return this.data;
+  }
+  /**
+   * Get parsed envelope data (lazy parsing)
+   */
+  getParsedEnvelope() {
+    if (!this.isParsed) {
+      this.parsedEnvelope = processEnvelope(
+        {
+          contentType: this.contentType,
+          data: this.data
+        },
+        this.senderUserAgent
+      );
+      this.isParsed = true;
+    }
+    return this.parsedEnvelope;
+  }
+  /**
+   * Get a summary of the event types in this container
+   * Returns null if not a parseable envelope
+   */
+  getEventTypes() {
+    const envelope = this.getParsedEnvelope();
+    if (!envelope) return null;
+    const eventTypes = [];
+    for (const item of envelope.envelope[1]) {
+      if (item[0].type) {
+        eventTypes.push(item[0].type);
+      }
+    }
+    return eventTypes;
+  }
+  /**
+   * Get a formatted string of event types for logging
+   */
+  getEventTypesString() {
+    const types = this.getEventTypes();
+    if (!types || types.length === 0) {
+      return this.contentType === "application/x-sentry-envelope" ? "envelope" : this.contentType;
+    }
+    return types.join("+");
+  }
+}
+export {
+  EventContainer
+};
+//# sourceMappingURL=eventContainer.js.map

package/dist/server/utils/eventContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventContainer.js","sources":["../../../src/server/utils/eventContainer.ts"],"sourcesContent":["import { type ParsedEnvelope, processEnvelope } from \"../parser/index.ts\";\n\n/**\n * Container for events that flow through the sidecar\n * Provides lazy parsing only when needed (in debug mode)\n */\nexport class EventContainer {\n  private contentType: string;\n  private data: Buffer;\n  private senderUserAgent?: string;\n  private parsedEnvelope: ParsedEnvelope | null = null;\n  private isParsed = false;\n\n  constructor(contentType: string, data: Buffer, senderUserAgent?: string) {\n    this.contentType = contentType;\n    this.data = data;\n    this.senderUserAgent = senderUserAgent;\n  }\n\n  /**\n   * Get the content type of the event\n   */\n  getContentType(): string {\n    return this.contentType;\n  }\n\n  /**\n   * Get the raw data buffer\n   */\n  getData(): Buffer {\n    return this.data;\n  }\n\n  /**\n   * Get parsed envelope data (lazy parsing)\n   */\n  getParsedEnvelope(): ParsedEnvelope {\n    // Parse once and cache the result\n    if (!this.isParsed) {\n      this.parsedEnvelope = processEnvelope(\n        {\n          contentType: this.contentType,\n          data: this.data,\n        },\n        this.senderUserAgent,\n      );\n      this.isParsed = true;\n    }\n\n    return this.parsedEnvelope!;\n  }\n\n  /**\n   * Get a summary of the event types in this container\n   * Returns null if not a parseable envelope\n   */\n  getEventTypes(): string[] | null {\n    const envelope = this.getParsedEnvelope();\n    if (!envelope) return null;\n\n    const eventTypes: string[] = [];\n    for (const item of envelope.envelope[1]) {\n      if (item[0].type) {\n        eventTypes.push(item[0].type);\n      }\n    }\n\n    return eventTypes;\n  }\n\n  /**\n   * Get a formatted string of event types for logging\n   */\n  getEventTypesString(): string {\n    const types = this.getEventTypes();\n    if (!types || types.length === 0) {\n      return this.contentType === \"application/x-sentry-envelope\" ? \"envelope\" : this.contentType;\n    }\n    return types.join(\"+\");\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;AAMO,MAAM,eAAe;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA,iBAAwC;AAAA,EACxC,WAAW;AAAA,EAEnB,YAAY,aAAqB,MAAc,iBAA0B;AACvE,SAAK,cAAc;AACnB,SAAK,OAAO;AACZ,SAAK,kBAAkB;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAyB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,UAAkB;AAChB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,oBAAoC;AAElC,QAAI,CAAC,KAAK,UAAU;AAClB,WAAK,iBAAiB;AAAA,QACpB;AAAA,UACE,aAAa,KAAK;AAAA,UAClB,MAAM,KAAK;AAAA,QAAA;AAAA,QAEb,KAAK;AAAA,MAAA;AAEP,WAAK,WAAW;AAAA,IAClB;AAEA,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,gBAAiC;AAC/B,UAAM,WAAW,KAAK,kBAAA;AACtB,QAAI,CAAC,SAAU,QAAO;AAEtB,UAAM,aAAuB,CAAA;AAC7B,eAAW,QAAQ,SAAS,SAAS,CAAC,GAAG;AACvC,UAAI,KAAK,CAAC,EAAE,MAAM;AAChB,mBAAW,KAAK,KAAK,CAAC,EAAE,IAAI;AAAA,MAC9B;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,sBAA8B;AAC5B,UAAM,QAAQ,KAAK,cAAA;AACnB,QAAI,CAAC,SAAS,MAAM,WAAW,GAAG;AAChC,aAAO,KAAK,gBAAgB,kCAAkC,aAAa,KAAK;AAAA,IAClF;AACA,WAAO,MAAM,KAAK,GAAG;AAAA,EACvB;AACF;"}

package/dist/server/utils/extras.d.ts

@@ -0,0 +1,5 @@
+export declare const withTracing: (fn: CallableFunction, spanArgs?: {}) => (...args: unknown[]) => any;
+export declare const getSpotlightURL: (port: number, host?: string) => string;
+export declare function logSpotlightUrl(port: number): void;
+export declare const isValidPort: (...args: unknown[]) => any;
+export declare const isSidecarRunning: (...args: unknown[]) => any;