@error-explorer/node 1.1.1

package/dist/middleware/express.js

@@ -0,0 +1,1597 @@
+import * as os2 from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import * as http from 'http';
+import * as https from 'https';
+
+// src/config/Config.ts
+var DEFAULT_ENDPOINT = "https://error-explorer.com/api/v1/webhook";
+function parseDsn(dsn) {
+  let url;
+  try {
+    url = new URL(dsn);
+  } catch {
+    throw new Error(`Invalid DSN format: ${dsn}. Expected format: https://token@host/path`);
+  }
+  const token = url.username;
+  if (!token) {
+    throw new Error("DSN must contain a token (username part)");
+  }
+  url.username = "";
+  url.password = "";
+  return {
+    token,
+    endpoint: url.toString().replace(/\/$/, "")
+  };
+}
+function detectEnvironment() {
+  return process.env["NODE_ENV"] || "development";
+}
+function getDefaultServerName() {
+  try {
+    return os2.hostname();
+  } catch {
+    return "unknown";
+  }
+}
+function resolveConfig(options) {
+  let token;
+  let endpoint;
+  if (options.dsn) {
+    const parsed = parseDsn(options.dsn);
+    token = parsed.token;
+    endpoint = options.endpoint || parsed.endpoint;
+  } else if (options.token) {
+    token = options.token;
+    endpoint = options.endpoint || DEFAULT_ENDPOINT;
+  } else {
+    throw new Error("Either token or dsn must be provided");
+  }
+  if (!token.startsWith("ee_")) {
+    console.warn('[ErrorExplorer] Token should start with "ee_" prefix');
+  }
+  return {
+    token,
+    endpoint,
+    environment: options.environment || detectEnvironment(),
+    release: options.release || "",
+    serverName: options.serverName || getDefaultServerName(),
+    autoCapture: {
+      uncaughtExceptions: options.autoCapture?.uncaughtExceptions ?? true,
+      unhandledRejections: options.autoCapture?.unhandledRejections ?? true,
+      console: options.autoCapture?.console ?? false
+    },
+    breadcrumbs: {
+      enabled: options.breadcrumbs?.enabled ?? true,
+      maxBreadcrumbs: options.breadcrumbs?.maxBreadcrumbs ?? 50,
+      http: options.breadcrumbs?.http ?? true,
+      console: options.breadcrumbs?.console ?? true
+    },
+    beforeSend: options.beforeSend,
+    ignoreErrors: options.ignoreErrors || [],
+    maxRetries: options.maxRetries ?? 3,
+    timeout: options.timeout ?? 5e3,
+    debug: options.debug ?? false,
+    hmacSecret: options.hmacSecret,
+    exitOnUncaughtException: options.exitOnUncaughtException ?? true
+  };
+}
+function matchesPattern(str, patterns) {
+  return patterns.some((pattern) => {
+    if (typeof pattern === "string") {
+      return str.includes(pattern);
+    }
+    return pattern.test(str);
+  });
+}
+function parseStackTrace(stack) {
+  if (!stack) {
+    return [];
+  }
+  const frames = [];
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const frame = parseStackLine(line);
+    if (frame) {
+      frames.push(frame);
+    }
+  }
+  return frames;
+}
+function parseStackLine(line) {
+  if (!line.trim().startsWith("at ")) {
+    return null;
+  }
+  const content = line.replace(/^\s*at\s+/, "").trim();
+  const withFunctionMatch = content.match(
+    /^(?:async\s+)?(.+?)\s+\((.+?):(\d+):(\d+)\)$/
+  );
+  if (withFunctionMatch) {
+    const [, fn, file, lineNo, colNo] = withFunctionMatch;
+    return createFrame(fn, file, lineNo, colNo);
+  }
+  const anonymousMatch = content.match(/^(.+?):(\d+):(\d+)$/);
+  if (anonymousMatch) {
+    const [, file, lineNo, colNo] = anonymousMatch;
+    return createFrame(void 0, file, lineNo, colNo);
+  }
+  return null;
+}
+function createFrame(fn, file, lineNo, colNo) {
+  const frame = {};
+  if (fn) {
+    frame.function = cleanFunctionName(fn);
+  }
+  if (file) {
+    frame.filename = file;
+    frame.abs_path = path.isAbsolute(file) ? file : void 0;
+    frame.in_app = !file.includes("node_modules") && !file.startsWith("node:");
+    if (frame.in_app && file.includes("/")) {
+      const parts = file.split("/");
+      frame.module = parts[parts.length - 1]?.replace(/\.[^/.]+$/, "");
+    }
+  }
+  if (lineNo) {
+    frame.lineno = parseInt(lineNo, 10);
+  }
+  if (colNo) {
+    frame.colno = parseInt(colNo, 10);
+  }
+  return frame;
+}
+function cleanFunctionName(name) {
+  name = name.replace(/^Object\./, "");
+  name = name.replace(/^Module\./, "");
+  if (name === "<anonymous>") {
+    return "(anonymous)";
+  }
+  return name;
+}
+function getErrorName(error) {
+  if (error instanceof Error) {
+    return error.name || error.constructor.name;
+  }
+  if (typeof error === "object" && error !== null) {
+    const obj = error;
+    if (typeof obj["name"] === "string") {
+      return obj["name"];
+    }
+  }
+  return "Error";
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const obj = error;
+    if (typeof obj["message"] === "string") {
+      return obj["message"];
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  return String(error);
+}
+function getErrorStack(error) {
+  if (error instanceof Error) {
+    return error.stack;
+  }
+  if (typeof error === "object" && error !== null) {
+    const obj = error;
+    if (typeof obj["stack"] === "string") {
+      return obj["stack"];
+    }
+  }
+  return void 0;
+}
+function generateUuid() {
+  return crypto.randomUUID();
+}
+function generateTransactionId() {
+  return `txn_${crypto.randomBytes(12).toString("hex")}`;
+}
+
+// src/context/ProcessContext.ts
+function collectProcessContext() {
+  const memoryUsage = process.memoryUsage();
+  const cpuUsage = process.cpuUsage();
+  return {
+    pid: process.pid,
+    ppid: process.ppid,
+    uptime: process.uptime(),
+    memory: {
+      rss: memoryUsage.rss,
+      heapTotal: memoryUsage.heapTotal,
+      heapUsed: memoryUsage.heapUsed,
+      external: memoryUsage.external,
+      arrayBuffers: memoryUsage.arrayBuffers
+    },
+    cpu: {
+      user: cpuUsage.user,
+      system: cpuUsage.system
+    }
+  };
+}
+var cachedOsContext = null;
+function collectOsContext() {
+  if (cachedOsContext) {
+    return cachedOsContext;
+  }
+  cachedOsContext = {
+    name: os2.platform(),
+    version: os2.release(),
+    arch: os2.arch(),
+    kernel_version: os2.version()
+  };
+  return cachedOsContext;
+}
+function resetOsContext() {
+  cachedOsContext = null;
+}
+
+// src/context/RuntimeContext.ts
+var cachedRuntimeContext = null;
+function collectRuntimeContext() {
+  if (cachedRuntimeContext) {
+    return cachedRuntimeContext;
+  }
+  cachedRuntimeContext = {
+    name: "node",
+    version: process.version
+  };
+  return cachedRuntimeContext;
+}
+function resetRuntimeContext() {
+  cachedRuntimeContext = null;
+}
+var serverContext = {
+  name: void 0,
+  hostname: os2.hostname()
+};
+function getServerContext() {
+  return serverContext;
+}
+function setServerName(name) {
+  serverContext = {
+    ...serverContext,
+    name
+  };
+}
+function resetServerContext() {
+  serverContext = {
+    name: void 0,
+    hostname: os2.hostname()
+  };
+}
+
+// src/context/UserContext.ts
+var UserContextManager = class {
+  user = null;
+  /**
+   * Set user context
+   */
+  setUser(user) {
+    this.user = user;
+  }
+  /**
+   * Get current user context
+   */
+  getUser() {
+    return this.user;
+  }
+  /**
+   * Clear user context
+   */
+  clearUser() {
+    this.user = null;
+  }
+  /**
+   * Reset manager state
+   */
+  reset() {
+    this.user = null;
+  }
+};
+var userContextManager = null;
+function getUserContextManager() {
+  if (!userContextManager) {
+    userContextManager = new UserContextManager();
+  }
+  return userContextManager;
+}
+function resetUserContextManager() {
+  if (userContextManager) {
+    userContextManager.reset();
+  }
+  userContextManager = null;
+}
+
+// src/context/RequestContext.ts
+function extractRequestContext(req) {
+  const headers = {};
+  const sensitiveHeaders = ["authorization", "cookie", "x-api-key", "x-auth-token"];
+  for (const [key, value] of Object.entries(req.headers)) {
+    const lowerKey = key.toLowerCase();
+    if (!sensitiveHeaders.includes(lowerKey)) {
+      headers[key] = value;
+    } else {
+      headers[key] = "[Filtered]";
+    }
+  }
+  const context = {
+    method: req.method,
+    headers,
+    url: getFullUrl(req)
+  };
+  const url = req.url || "";
+  const queryIndex = url.indexOf("?");
+  if (queryIndex !== -1) {
+    context.query_string = url.substring(queryIndex + 1);
+  }
+  const expressReq = req;
+  if (expressReq.body !== void 0) {
+    context.data = sanitizeBody(expressReq.body);
+  }
+  if (expressReq.cookies) {
+    context.cookies = sanitizeCookies(expressReq.cookies);
+  }
+  return context;
+}
+function getFullUrl(req) {
+  const expressReq = req;
+  const path2 = expressReq.originalUrl || req.url || "/";
+  const protocol = req.headers["x-forwarded-proto"] || "http";
+  const host = req.headers.host || "localhost";
+  return `${protocol}://${host}${path2}`;
+}
+function sanitizeBody(body) {
+  if (!body || typeof body !== "object") {
+    return body;
+  }
+  const sensitiveKeys = ["password", "secret", "token", "api_key", "apiKey", "credit_card", "creditCard", "cvv", "ssn"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(body)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveKeys.some((sk) => lowerKey.includes(sk))) {
+      sanitized[key] = "[Filtered]";
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizeBody(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function sanitizeCookies(cookies) {
+  const sensitiveNames = ["session", "sess", "token", "auth", "jwt", "sid"];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(cookies)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveNames.some((sn) => lowerKey.includes(sn))) {
+      sanitized[key] = "[Filtered]";
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+// src/breadcrumbs/BreadcrumbManager.ts
+var BreadcrumbManager = class {
+  breadcrumbs = [];
+  maxBreadcrumbs = 50;
+  /**
+   * Initialize with configuration
+   */
+  init(config) {
+    this.maxBreadcrumbs = config.breadcrumbs.maxBreadcrumbs;
+    this.breadcrumbs = [];
+  }
+  /**
+   * Add a breadcrumb
+   */
+  add(breadcrumb) {
+    const internal = {
+      ...breadcrumb,
+      timestamp: breadcrumb.timestamp ?? Date.now()
+    };
+    this.breadcrumbs.push(internal);
+    if (this.breadcrumbs.length > this.maxBreadcrumbs) {
+      this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
+    }
+  }
+  /**
+   * Get all breadcrumbs (oldest first)
+   */
+  getAll() {
+    return [...this.breadcrumbs];
+  }
+  /**
+   * Get the last N breadcrumbs
+   */
+  getLast(count) {
+    return this.breadcrumbs.slice(-count);
+  }
+  /**
+   * Clear all breadcrumbs
+   */
+  clear() {
+    this.breadcrumbs = [];
+  }
+  /**
+   * Reset manager
+   */
+  reset() {
+    this.breadcrumbs = [];
+    this.maxBreadcrumbs = 50;
+  }
+};
+var breadcrumbManager = null;
+function initBreadcrumbManager(config) {
+  if (!breadcrumbManager) {
+    breadcrumbManager = new BreadcrumbManager();
+  }
+  breadcrumbManager.init(config);
+  return breadcrumbManager;
+}
+function getBreadcrumbManager() {
+  return breadcrumbManager;
+}
+function resetBreadcrumbManager() {
+  if (breadcrumbManager) {
+    breadcrumbManager.reset();
+  }
+  breadcrumbManager = null;
+}
+
+// src/breadcrumbs/ConsoleTracker.ts
+var ConsoleTracker = class {
+  originalMethods = null;
+  started = false;
+  /**
+   * Start tracking console calls
+   */
+  start() {
+    if (this.started) {
+      return;
+    }
+    this.originalMethods = {
+      log: console.log.bind(console),
+      info: console.info.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+      debug: console.debug.bind(console)
+    };
+    const methods = ["log", "info", "warn", "error", "debug"];
+    for (const method of methods) {
+      this.wrapConsoleMethod(method);
+    }
+    this.started = true;
+  }
+  /**
+   * Stop tracking console calls
+   */
+  stop() {
+    if (!this.started || !this.originalMethods) {
+      return;
+    }
+    console.log = this.originalMethods.log;
+    console.info = this.originalMethods.info;
+    console.warn = this.originalMethods.warn;
+    console.error = this.originalMethods.error;
+    console.debug = this.originalMethods.debug;
+    this.originalMethods = null;
+    this.started = false;
+  }
+  /**
+   * Wrap a console method to add breadcrumbs
+   */
+  wrapConsoleMethod(method) {
+    const original = this.originalMethods[method];
+    const self = this;
+    console[method] = function(...args) {
+      self.addBreadcrumb(method, args);
+      original(...args);
+    };
+  }
+  /**
+   * Add a breadcrumb for a console call
+   */
+  addBreadcrumb(method, args) {
+    const manager = getBreadcrumbManager();
+    if (!manager) {
+      return;
+    }
+    const level = this.methodToLevel(method);
+    const message = this.formatArgs(args);
+    manager.add({
+      type: "console",
+      category: `console.${method}`,
+      message,
+      level,
+      data: {
+        arguments: this.serializeArgs(args)
+      }
+    });
+  }
+  /**
+   * Map console method to breadcrumb level
+   */
+  methodToLevel(method) {
+    switch (method) {
+      case "error":
+        return "error";
+      case "warn":
+        return "warning";
+      case "debug":
+        return "debug";
+      default:
+        return "info";
+    }
+  }
+  /**
+   * Format arguments into a string message
+   */
+  formatArgs(args) {
+    return args.map((arg) => {
+      if (typeof arg === "string") {
+        return arg;
+      }
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    }).join(" ").substring(0, 500);
+  }
+  /**
+   * Serialize arguments for data storage
+   */
+  serializeArgs(args) {
+    return args.map((arg) => {
+      if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
+        return arg;
+      }
+      if (arg === null || arg === void 0) {
+        return arg;
+      }
+      if (arg instanceof Error) {
+        return {
+          name: arg.name,
+          message: arg.message
+        };
+      }
+      try {
+        return JSON.parse(JSON.stringify(arg));
+      } catch {
+        return "[Unserializable]";
+      }
+    });
+  }
+  /**
+   * Reset tracker state
+   */
+  reset() {
+    this.stop();
+  }
+};
+var consoleTracker = null;
+function getConsoleTracker() {
+  if (!consoleTracker) {
+    consoleTracker = new ConsoleTracker();
+  }
+  return consoleTracker;
+}
+function resetConsoleTracker() {
+  if (consoleTracker) {
+    consoleTracker.reset();
+  }
+  consoleTracker = null;
+}
+var HttpTracker = class {
+  originalHttpRequest = null;
+  originalHttpsRequest = null;
+  started = false;
+  patchFailed = false;
+  /**
+   * Start tracking HTTP requests
+   */
+  start() {
+    if (this.started || this.patchFailed) {
+      return;
+    }
+    try {
+      this.originalHttpRequest = http.request;
+      this.originalHttpsRequest = https.request;
+      this.wrapRequestMethod(http, "http");
+      this.wrapRequestMethod(https, "https");
+      this.started = true;
+    } catch {
+      this.patchFailed = true;
+      this.originalHttpRequest = null;
+      this.originalHttpsRequest = null;
+    }
+  }
+  /**
+   * Stop tracking HTTP requests
+   */
+  stop() {
+    if (!this.started) {
+      return;
+    }
+    try {
+      if (this.originalHttpRequest) {
+        Object.defineProperty(http, "request", {
+          value: this.originalHttpRequest,
+          writable: true,
+          configurable: true
+        });
+      }
+      if (this.originalHttpsRequest) {
+        Object.defineProperty(https, "request", {
+          value: this.originalHttpsRequest,
+          writable: true,
+          configurable: true
+        });
+      }
+    } catch {
+    }
+    this.originalHttpRequest = null;
+    this.originalHttpsRequest = null;
+    this.started = false;
+  }
+  /**
+   * Wrap a module's request method
+   */
+  wrapRequestMethod(mod, _protocol) {
+    const originalRequest = mod.request.bind(mod);
+    const self = this;
+    const wrappedRequest = function(...args) {
+      const [urlOrOptions, optionsOrCallback, maybeCallback] = args;
+      const { url, method, hostname: hostname3 } = self.parseRequestArgs(
+        urlOrOptions,
+        optionsOrCallback
+      );
+      const startTime = Date.now();
+      const req = originalRequest.apply(mod, args);
+      req.on("response", (res) => {
+        const duration = Date.now() - startTime;
+        self.addBreadcrumb(method, url, hostname3, res.statusCode, duration);
+      });
+      req.on("error", (error) => {
+        const duration = Date.now() - startTime;
+        self.addErrorBreadcrumb(method, url, hostname3, error, duration);
+      });
+      return req;
+    };
+    Object.defineProperty(mod, "request", {
+      value: wrappedRequest,
+      writable: true,
+      configurable: true
+    });
+  }
+  /**
+   * Parse request arguments to extract URL info
+   */
+  parseRequestArgs(urlOrOptions, optionsOrCallback) {
+    let url = "";
+    let method = "GET";
+    let hostname3 = "";
+    if (typeof urlOrOptions === "string") {
+      url = urlOrOptions;
+      try {
+        const parsed = new URL(urlOrOptions);
+        hostname3 = parsed.hostname;
+      } catch {
+        hostname3 = urlOrOptions;
+      }
+    } else if (urlOrOptions instanceof URL) {
+      url = urlOrOptions.toString();
+      hostname3 = urlOrOptions.hostname;
+    } else if (typeof urlOrOptions === "object") {
+      const opts = urlOrOptions;
+      hostname3 = opts.hostname || opts.host || "localhost";
+      const port = opts.port ? `:${opts.port}` : "";
+      const path2 = opts.path || "/";
+      const protocol = opts.protocol || "http:";
+      url = `${protocol}//${hostname3}${port}${path2}`;
+      method = opts.method || "GET";
+    }
+    if (optionsOrCallback && typeof optionsOrCallback === "object" && optionsOrCallback.method) {
+      method = optionsOrCallback.method;
+    }
+    return { url, method: method.toUpperCase(), hostname: hostname3 };
+  }
+  /**
+   * Add a breadcrumb for a successful HTTP request
+   */
+  addBreadcrumb(method, url, hostname3, statusCode, duration) {
+    const manager = getBreadcrumbManager();
+    if (!manager) {
+      return;
+    }
+    manager.add({
+      type: "http",
+      category: "http.client",
+      message: `${method} ${url}`,
+      level: statusCode && statusCode >= 400 ? "warning" : "info",
+      data: {
+        method,
+        url: this.truncateUrl(url),
+        hostname: hostname3,
+        status_code: statusCode,
+        duration_ms: duration
+      }
+    });
+  }
+  /**
+   * Add a breadcrumb for a failed HTTP request
+   */
+  addErrorBreadcrumb(method, url, hostname3, error, duration) {
+    const manager = getBreadcrumbManager();
+    if (!manager) {
+      return;
+    }
+    manager.add({
+      type: "http",
+      category: "http.client",
+      message: `${method} ${url} failed: ${error.message}`,
+      level: "error",
+      data: {
+        method,
+        url: this.truncateUrl(url),
+        hostname: hostname3,
+        error: error.message,
+        duration_ms: duration
+      }
+    });
+  }
+  /**
+   * Truncate URL for storage
+   */
+  truncateUrl(url) {
+    const maxLength = 200;
+    if (url.length <= maxLength) {
+      return url;
+    }
+    return url.substring(0, maxLength) + "...";
+  }
+  /**
+   * Reset tracker state
+   */
+  reset() {
+    this.stop();
+    this.patchFailed = false;
+  }
+};
+var httpTracker = null;
+function getHttpTracker() {
+  if (!httpTracker) {
+    httpTracker = new HttpTracker();
+  }
+  return httpTracker;
+}
+function resetHttpTracker() {
+  if (httpTracker) {
+    httpTracker.reset();
+  }
+  httpTracker = null;
+}
+
+// src/capture/ProcessCapture.ts
+var ProcessCapture = class {
+  handler = null;
+  uncaughtHandler = null;
+  rejectionHandler = null;
+  started = false;
+  exitOnUncaught = true;
+  /**
+   * Start capturing process errors
+   */
+  start(handler, exitOnUncaught = true) {
+    if (this.started) {
+      return;
+    }
+    this.handler = handler;
+    this.exitOnUncaught = exitOnUncaught;
+    this.uncaughtHandler = this.handleUncaughtException.bind(this);
+    this.rejectionHandler = this.handleUnhandledRejection.bind(this);
+    process.on("uncaughtException", this.uncaughtHandler);
+    process.on("unhandledRejection", this.rejectionHandler);
+    this.started = true;
+  }
+  /**
+   * Start only uncaughtException capture
+   */
+  startUncaughtException(handler, exitOnUncaught = true) {
+    if (this.uncaughtHandler) {
+      return;
+    }
+    this.handler = handler;
+    this.exitOnUncaught = exitOnUncaught;
+    this.uncaughtHandler = this.handleUncaughtException.bind(this);
+    process.on("uncaughtException", this.uncaughtHandler);
+  }
+  /**
+   * Start only unhandledRejection capture
+   */
+  startUnhandledRejection(handler) {
+    if (this.rejectionHandler) {
+      return;
+    }
+    this.handler = handler;
+    this.rejectionHandler = this.handleUnhandledRejection.bind(this);
+    process.on("unhandledRejection", this.rejectionHandler);
+  }
+  /**
+   * Stop capturing process errors
+   */
+  stop() {
+    if (this.uncaughtHandler) {
+      process.off("uncaughtException", this.uncaughtHandler);
+      this.uncaughtHandler = null;
+    }
+    if (this.rejectionHandler) {
+      process.off("unhandledRejection", this.rejectionHandler);
+      this.rejectionHandler = null;
+    }
+    this.handler = null;
+    this.started = false;
+  }
+  /**
+   * Handle uncaught exception
+   */
+  handleUncaughtException(error) {
+    if (!this.handler) {
+      return;
+    }
+    const captured = {
+      error,
+      message: error.message,
+      type: "uncaughtException",
+      severity: "critical"
+    };
+    try {
+      this.handler(captured);
+    } catch {
+    }
+    if (this.exitOnUncaught) {
+      setTimeout(() => {
+        process.exit(1);
+      }, 100);
+    }
+  }
+  /**
+   * Handle unhandled rejection
+   */
+  handleUnhandledRejection(reason, promise) {
+    if (!this.handler) {
+      return;
+    }
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    const captured = {
+      error,
+      message: error.message,
+      type: "unhandledRejection",
+      severity: "error",
+      promise
+    };
+    try {
+      this.handler(captured);
+    } catch {
+    }
+  }
+  /**
+   * Reset capture state
+   */
+  reset() {
+    this.stop();
+  }
+};
+var processCapture = null;
+function getProcessCapture() {
+  if (!processCapture) {
+    processCapture = new ProcessCapture();
+  }
+  return processCapture;
+}
+function resetProcessCapture() {
+  if (processCapture) {
+    processCapture.reset();
+  }
+  processCapture = null;
+}
+
+// src/capture/ConsoleCapture.ts
+var ConsoleCapture = class {
+  handler = null;
+  originalConsoleError = null;
+  started = false;
+  /**
+   * Start capturing console.error calls
+   */
+  start(handler) {
+    if (this.started) {
+      return;
+    }
+    this.handler = handler;
+    this.originalConsoleError = console.error.bind(console);
+    const self = this;
+    console.error = function(...args) {
+      self.originalConsoleError(...args);
+      self.handleConsoleError(args);
+    };
+    this.started = true;
+  }
+  /**
+   * Stop capturing console.error
+   */
+  stop() {
+    if (!this.started || !this.originalConsoleError) {
+      return;
+    }
+    console.error = this.originalConsoleError;
+    this.originalConsoleError = null;
+    this.handler = null;
+    this.started = false;
+  }
+  /**
+   * Handle console.error call
+   */
+  handleConsoleError(args) {
+    if (!this.handler) {
+      return;
+    }
+    let error;
+    let message;
+    const firstArg = args[0];
+    if (firstArg instanceof Error) {
+      error = firstArg;
+      message = error.message;
+    } else {
+      message = args.map((arg) => {
+        if (typeof arg === "string") return arg;
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      }).join(" ");
+      error = new Error(message);
+    }
+    const captured = {
+      error,
+      message,
+      type: "unhandledRejection",
+      // Use this type for console errors
+      severity: "error"
+    };
+    try {
+      this.handler(captured);
+    } catch {
+    }
+  }
+  /**
+   * Reset capture state
+   */
+  reset() {
+    this.stop();
+  }
+};
+var consoleCapture = null;
+function getConsoleCapture() {
+  if (!consoleCapture) {
+    consoleCapture = new ConsoleCapture();
+  }
+  return consoleCapture;
+}
+function resetConsoleCapture() {
+  if (consoleCapture) {
+    consoleCapture.reset();
+  }
+  consoleCapture = null;
+}
+var HmacSigner = class {
+  secret;
+  constructor(secret) {
+    this.secret = secret;
+  }
+  /**
+   * Sign a payload with HMAC-SHA256
+   * @param payload - The JSON payload string to sign
+   * @param timestamp - Unix timestamp (defaults to current time)
+   * @returns Hex-encoded signature
+   */
+  sign(payload, timestamp) {
+    const ts = timestamp ?? Math.floor(Date.now() / 1e3);
+    const signedPayload = `${ts}.${payload}`;
+    const hmac = crypto.createHmac("sha256", this.secret);
+    hmac.update(signedPayload);
+    return hmac.digest("hex");
+  }
+  /**
+   * Build headers for a signed request
+   * @param payload - The JSON payload string
+   * @returns Headers object with signature and timestamp
+   */
+  buildHeaders(payload) {
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const signature = this.sign(payload, timestamp);
+    return {
+      "X-Webhook-Signature": signature,
+      "X-Webhook-Timestamp": String(timestamp)
+    };
+  }
+  /**
+   * Verify a signature (useful for testing)
+   * @param payload - The payload that was signed
+   * @param signature - The signature to verify
+   * @param timestamp - The timestamp used in signing
+   * @param maxAge - Maximum age in seconds (default: 5 minutes)
+   */
+  verify(payload, signature, timestamp, maxAge = 300) {
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - timestamp) > maxAge) {
+      return false;
+    }
+    const expected = this.sign(payload, timestamp);
+    return crypto.timingSafeEqual(
+      Buffer.from(signature, "hex"),
+      Buffer.from(expected, "hex")
+    );
+  }
+};
+
+// src/transport/HttpTransport.ts
+var HttpTransport = class {
+  endpoint;
+  token;
+  timeout;
+  maxRetries;
+  hmacSigner = null;
+  debug;
+  constructor(options) {
+    this.endpoint = options.endpoint;
+    this.token = options.token;
+    this.timeout = options.timeout;
+    this.maxRetries = options.maxRetries;
+    this.debug = options.debug ?? false;
+    if (options.hmacSecret) {
+      this.hmacSigner = new HmacSigner(options.hmacSecret);
+    }
+  }
+  /**
+   * Send an event to the Error Explorer API
+   */
+  async send(event) {
+    const payload = JSON.stringify(event);
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const success = await this.doSend(payload);
+        if (success) {
+          if (this.debug) {
+            console.log("[ErrorExplorer] Event sent successfully");
+          }
+          return true;
+        }
+      } catch (error) {
+        lastError = error;
+        if (this.debug) {
+          console.error(`[ErrorExplorer] Send attempt ${attempt + 1} failed:`, error);
+        }
+        if (attempt < this.maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 100);
+        }
+      }
+    }
+    if (this.debug && lastError) {
+      console.error("[ErrorExplorer] All send attempts failed:", lastError);
+    }
+    return false;
+  }
+  /**
+   * Perform the actual HTTP request
+   */
+  doSend(payload) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.endpoint);
+      const isHttps = url.protocol === "https:";
+      const transport = isHttps ? https : http;
+      const headers = {
+        "Content-Type": "application/json",
+        "Content-Length": String(Buffer.byteLength(payload)),
+        "X-Webhook-Token": this.token,
+        "User-Agent": "@error-explorer/node/1.0.0",
+        // Include Host header for proper virtual host routing
+        "Host": url.host
+      };
+      if (this.hmacSigner) {
+        const hmacHeaders = this.hmacSigner.buildHeaders(payload);
+        Object.assign(headers, hmacHeaders);
+      }
+      const options = {
+        method: "POST",
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: url.pathname,
+        headers,
+        timeout: this.timeout
+      };
+      const req = transport.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          const statusCode = res.statusCode || 0;
+          if (statusCode >= 200 && statusCode < 300) {
+            resolve(true);
+          } else if (statusCode === 429) {
+            const retryAfter = res.headers["retry-after"];
+            reject(new Error(`Rate limited. Retry after: ${retryAfter}`));
+          } else if (statusCode >= 500) {
+            reject(new Error(`Server error: ${statusCode}`));
+          } else {
+            if (this.debug) {
+              console.error(`[ErrorExplorer] Client error ${statusCode}:`, data);
+            }
+            resolve(false);
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(error);
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Request timeout"));
+      });
+      req.write(payload);
+      req.end();
+    });
+  }
+  /**
+   * Send synchronously (blocking) - for use in exit handlers
+   */
+  sendSync(event) {
+    this.send(event).catch((err) => {
+      if (this.debug) {
+        console.error("[ErrorExplorer] Sync send failed:", err);
+      }
+    });
+  }
+  /**
+   * Sleep for a given duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/ErrorExplorer.ts
+var SDK_NAME = "@error-explorer/node";
+var SDK_VERSION = "1.0.0";
+var ErrorExplorerClient = class {
+  config = null;
+  transport = null;
+  initialized = false;
+  tags = {};
+  extra = {};
+  contexts = {};
+  /**
+   * Initialize the SDK
+   */
+  init(options) {
+    if (this.initialized) {
+      console.warn("[ErrorExplorer] Already initialized");
+      return;
+    }
+    try {
+      this.config = resolveConfig(options);
+      if (this.config.serverName) {
+        setServerName(this.config.serverName);
+      }
+      this.transport = new HttpTransport({
+        endpoint: this.config.endpoint,
+        token: this.config.token,
+        timeout: this.config.timeout,
+        maxRetries: this.config.maxRetries,
+        hmacSecret: this.config.hmacSecret,
+        debug: this.config.debug
+      });
+      if (this.config.breadcrumbs.enabled) {
+        initBreadcrumbManager(this.config);
+        this.startBreadcrumbTrackers();
+      }
+      if (this.config.autoCapture.uncaughtExceptions || this.config.autoCapture.unhandledRejections) {
+        const processCapture2 = getProcessCapture();
+        if (this.config.autoCapture.uncaughtExceptions) {
+          processCapture2.startUncaughtException(
+            this.handleCapturedError.bind(this),
+            this.config.exitOnUncaughtException
+          );
+        }
+        if (this.config.autoCapture.unhandledRejections) {
+          processCapture2.startUnhandledRejection(this.handleCapturedError.bind(this));
+        }
+      }
+      if (this.config.autoCapture.console) {
+        getConsoleCapture().start(this.handleCapturedError.bind(this));
+      }
+      this.initialized = true;
+      if (this.config.debug) {
+        console.log("[ErrorExplorer] Initialized", {
+          endpoint: this.config.endpoint,
+          environment: this.config.environment,
+          serverName: this.config.serverName
+        });
+      }
+    } catch (error) {
+      console.error("[ErrorExplorer] Initialization failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Check if SDK is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Set user context
+   */
+  setUser(user) {
+    getUserContextManager().setUser(user);
+  }
+  /**
+   * Clear user context
+   */
+  clearUser() {
+    getUserContextManager().clearUser();
+  }
+  /**
+   * Set a single tag
+   */
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  /**
+   * Set multiple tags
+   */
+  setTags(tags) {
+    this.tags = { ...this.tags, ...tags };
+  }
+  /**
+   * Set extra data
+   */
+  setExtra(key, value) {
+    this.extra[key] = value;
+  }
+  /**
+   * Set a named context
+   */
+  setContext(name, context) {
+    this.contexts[name] = context;
+  }
+  /**
+   * Add a manual breadcrumb
+   */
+  addBreadcrumb(breadcrumb) {
+    const manager = getBreadcrumbManager();
+    if (manager) {
+      manager.add(breadcrumb);
+    }
+  }
+  /**
+   * Capture an exception manually
+   */
+  captureException(error, context) {
+    if (!this.initialized || !this.config) {
+      console.warn("[ErrorExplorer] Not initialized");
+      return "";
+    }
+    const eventId = generateUuid();
+    const event = this.buildEvent(error, context, "error");
+    this.processAndSend(event);
+    return eventId;
+  }
+  /**
+   * Capture a message manually
+   */
+  captureMessage(message, level = "info") {
+    if (!this.initialized || !this.config) {
+      console.warn("[ErrorExplorer] Not initialized");
+      return "";
+    }
+    const eventId = generateUuid();
+    const event = this.buildEvent(new Error(message), void 0, level);
+    event.exception_class = "Message";
+    this.processAndSend(event);
+    return eventId;
+  }
+  /**
+   * Flush all pending events (best effort)
+   */
+  async flush(timeout = 5e3) {
+    if (!this.initialized) {
+      return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(timeout, 100)));
+    return true;
+  }
+  /**
+   * Close the SDK and cleanup
+   */
+  async close(timeout = 5e3) {
+    if (!this.initialized) {
+      return true;
+    }
+    await this.flush(timeout);
+    this.stopAllTrackers();
+    resetBreadcrumbManager();
+    resetProcessCapture();
+    resetConsoleCapture();
+    resetConsoleTracker();
+    resetHttpTracker();
+    resetUserContextManager();
+    resetServerContext();
+    resetOsContext();
+    resetRuntimeContext();
+    this.config = null;
+    this.transport = null;
+    this.initialized = false;
+    this.tags = {};
+    this.extra = {};
+    this.contexts = {};
+    return true;
+  }
+  /**
+   * Handle a captured error from auto-capture
+   */
+  handleCapturedError(captured) {
+    if (!this.config) {
+      return;
+    }
+    if (this.shouldIgnoreError(captured.message)) {
+      if (this.config.debug) {
+        console.log("[ErrorExplorer] Ignoring error:", captured.message);
+      }
+      return;
+    }
+    const event = this.buildEvent(captured.error, void 0, captured.severity);
+    event.tags = {
+      ...event.tags,
+      capture_type: captured.type
+    };
+    this.processAndSend(event);
+  }
+  /**
+   * Check if an error should be ignored
+   */
+  shouldIgnoreError(message) {
+    if (!this.config) {
+      return true;
+    }
+    return matchesPattern(message, this.config.ignoreErrors);
+  }
+  /**
+   * Build a complete error event
+   */
+  buildEvent(error, context, severity = "error") {
+    const config = this.config;
+    const message = getErrorMessage(error);
+    const name = getErrorName(error);
+    const stack = getErrorStack(error);
+    const frames = parseStackTrace(stack);
+    const topFrame = frames[0];
+    const event = {
+      message,
+      exception_class: name,
+      file: topFrame?.filename,
+      line: topFrame?.lineno,
+      column: topFrame?.colno,
+      stack_trace: stack,
+      frames,
+      severity: context?.level ?? severity,
+      environment: config.environment,
+      release: config.release || void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      // User context
+      user: context?.user ?? getUserContextManager().getUser() ?? void 0,
+      // Server context
+      server: getServerContext(),
+      // Runtime context
+      runtime: collectRuntimeContext(),
+      // OS context
+      os: collectOsContext(),
+      // Process context
+      process: collectProcessContext(),
+      // Request context (if provided)
+      request: context?.request ? extractRequestContext(context.request) : void 0,
+      // Breadcrumbs
+      breadcrumbs: getBreadcrumbManager()?.getAll(),
+      // Tags (merge global + context)
+      tags: { ...this.tags, ...context?.tags },
+      // Extra data
+      extra: { ...this.extra, ...context?.extra },
+      // Custom contexts
+      contexts: this.contexts,
+      // SDK info
+      sdk: {
+        name: SDK_NAME,
+        version: SDK_VERSION
+      },
+      // Fingerprint for grouping
+      fingerprint: context?.fingerprint
+    };
+    return event;
+  }
+  /**
+   * Process event through beforeSend and send
+   */
+  async processAndSend(event) {
+    if (!this.config || !this.transport) {
+      return;
+    }
+    let processedEvent = event;
+    if (this.config.beforeSend) {
+      try {
+        const result = this.config.beforeSend(event);
+        processedEvent = result instanceof Promise ? await result : result;
+      } catch (e) {
+        console.error("[ErrorExplorer] beforeSend threw an error:", e);
+        processedEvent = event;
+      }
+    }
+    if (!processedEvent) {
+      if (this.config.debug) {
+        console.log("[ErrorExplorer] Event dropped by beforeSend");
+      }
+      return;
+    }
+    await this.transport.send(processedEvent);
+  }
+  /**
+   * Start all breadcrumb trackers
+   */
+  startBreadcrumbTrackers() {
+    if (!this.config) {
+      return;
+    }
+    const bc = this.config.breadcrumbs;
+    if (bc.console) {
+      getConsoleTracker().start();
+    }
+    if (bc.http) {
+      getHttpTracker().start();
+    }
+  }
+  /**
+   * Stop all breadcrumb trackers
+   */
+  stopAllTrackers() {
+    resetConsoleTracker();
+    resetHttpTracker();
+  }
+};
+var ErrorExplorer = new ErrorExplorerClient();
+
+// src/middleware/express.ts
+function requestHandler(options = {}) {
+  const { extractUser, breadcrumbs = true } = options;
+  return (req, res, next) => {
+    const transaction = generateTransactionId();
+    req.errorExplorer = {
+      transaction,
+      startTime: Date.now()
+    };
+    if (extractUser) {
+      try {
+        const user = extractUser(req);
+        if (user) {
+          req.errorExplorer.user = user;
+        }
+      } catch {
+      }
+    }
+    if (breadcrumbs) {
+      const manager = getBreadcrumbManager();
+      if (manager) {
+        manager.add({
+          type: "http",
+          category: "http.request",
+          message: `${req.method} ${req.path || req.url}`,
+          level: "info",
+          data: {
+            method: req.method,
+            url: req.originalUrl || req.url,
+            transaction
+          }
+        });
+      }
+    }
+    if (breadcrumbs) {
+      const originalEnd = res.end;
+      let ended = false;
+      res.end = function(...args) {
+        if (!ended) {
+          ended = true;
+          const duration = req.errorExplorer?.startTime ? Date.now() - req.errorExplorer.startTime : void 0;
+          const manager = getBreadcrumbManager();
+          if (manager) {
+            manager.add({
+              type: "http",
+              category: "http.response",
+              message: `${req.method} ${req.path || req.url} - ${res.statusCode}`,
+              level: res.statusCode >= 400 ? "warning" : "info",
+              data: {
+                method: req.method,
+                url: req.originalUrl || req.url,
+                status_code: res.statusCode,
+                duration_ms: duration,
+                transaction
+              }
+            });
+          }
+        }
+        return originalEnd.apply(res, args);
+      };
+    }
+    next();
+  };
+}
+function errorHandler(options = {}) {
+  const { callNext = true, onError } = options;
+  return (error, req, res, next) => {
+    if (res.headersSent) {
+      if (callNext) {
+        next(error);
+      }
+      return;
+    }
+    const requestContext = extractRequestContext(req);
+    const user = req.errorExplorer?.user;
+    const transaction = req.errorExplorer?.transaction;
+    ErrorExplorer.captureException(error, {
+      request: req,
+      user,
+      tags: {
+        transaction: transaction || "unknown",
+        route: req.path || req.url || "unknown",
+        method: req.method || "unknown"
+      },
+      extra: {
+        requestContext,
+        query: req.query,
+        params: req.params
+      }
+    });
+    if (onError) {
+      try {
+        onError(error, req, res);
+      } catch {
+      }
+    }
+    if (callNext) {
+      next(error);
+    }
+  };
+}
+function setupExpress(requestOptions = {}, errorOptions = {}) {
+  return {
+    requestHandler: requestHandler(requestOptions),
+    errorHandler: errorHandler(errorOptions)
+  };
+}
+
+export { errorHandler, requestHandler, setupExpress };
+//# sourceMappingURL=express.js.map
+//# sourceMappingURL=express.js.map