@watchforge/browser 0.1.1 → 0.1.4

package/src/stacktrace.js

@@ -0,0 +1,233 @@
+/**
+ * Stack trace parsing and source context enrichment (Python SDK parity).
+ */
+
+const CONTEXT_LINES = 5;
+const MAX_SOURCE_FILE_BYTES = 512 * 1024;
+
+const isBrowser = typeof window !== "undefined";
+const isNode =
+  typeof process !== "undefined" && process.versions && process.versions.node;
+
+const LIBRARY_PATH_PATTERNS = [
+  "/node_modules/",
+  "node_modules\\",
+  "/webpack/",
+  "webpack-internal://",
+];
+
+function isLibraryPath(filePath) {
+  if (!filePath) return false;
+  return LIBRARY_PATH_PATTERNS.some((p) => filePath.includes(p));
+}
+
+function parseStackLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("at ")) return null;
+
+  const withFn = trimmed.match(/^at\s+(?:async\s+)?(.*?)\s+\((.*?):(\d+):(\d+)\)$/);
+  if (withFn) {
+    return {
+      function: withFn[1] || "<anonymous>",
+      file: withFn[2],
+      lineno: parseInt(withFn[3], 10),
+      colno: parseInt(withFn[4], 10),
+    };
+  }
+
+  const withoutFn = trimmed.match(/^at\s+(?:async\s+)?(.*?):(\d+):(\d+)$/);
+  if (withoutFn) {
+    return {
+      function: "<anonymous>",
+      file: withoutFn[1],
+      lineno: parseInt(withoutFn[2], 10),
+      colno: parseInt(withoutFn[3], 10),
+    };
+  }
+
+  const evalMatch = trimmed.match(/^at\s+(.*?)\s+\((.*?)\)$/);
+  if (evalMatch) {
+    const inner = parseStackLine(`at ${evalMatch[2]}`);
+    if (inner) {
+      return { ...inner, function: evalMatch[1] || inner.function };
+    }
+  }
+
+  return null;
+}
+
+export function buildStacktraceFromError(error) {
+  if (!error || !error.stack || typeof error.stack !== "string") {
+    return null;
+  }
+
+  const stackLines = error.stack.split("\n");
+  const frames = [];
+
+  for (let i = 1; i < stackLines.length; i++) {
+    const parsed = parseStackLine(stackLines[i]);
+    if (!parsed) continue;
+
+    const { function: functionName, file, lineno, colno } = parsed;
+    const filename = file.split("/").pop()?.split("?")[0] || file;
+    const inApp = !isLibraryPath(file);
+
+    frames.push({
+      filename,
+      abs_path: file,
+      lineno,
+      colno,
+      function: functionName,
+      module: null,
+      context_line: null,
+      pre_context: [],
+      post_context: [],
+      vars: {},
+      in_app: inApp,
+    });
+  }
+
+  if (!frames.length) return null;
+
+  frames.reverse();
+  return { frames };
+}
+
+function applySourceContext(frame, sourceLines, lineno) {
+  if (!sourceLines?.length || !lineno || lineno < 1) return;
+
+  const idx = lineno - 1;
+  if (idx >= sourceLines.length) return;
+
+  frame.context_line = sourceLines[idx].replace(/\r$/, "");
+  const preStart = Math.max(0, idx - CONTEXT_LINES);
+  frame.pre_context = sourceLines
+    .slice(preStart, idx)
+    .map((l) => l.replace(/\r$/, ""));
+  const postEnd = Math.min(sourceLines.length, idx + CONTEXT_LINES + 1);
+  frame.post_context = sourceLines
+    .slice(idx + 1, postEnd)
+    .map((l) => l.replace(/\r$/, ""));
+}
+
+let nodeModulesPromise = null;
+const importNodeBuiltin = (specifier) =>
+  new Function("specifier", "return import(specifier)")(specifier);
+
+function getNodeModules() {
+  if (!isNode) return Promise.resolve(null);
+  if (!nodeModulesPromise) {
+    nodeModulesPromise = (async () => {
+      try {
+        const { createRequire } = await importNodeBuiltin("module");
+        const { fileURLToPath } = await importNodeBuiltin("url");
+        const req = createRequire(fileURLToPath(import.meta.url));
+        return {
+          fs: req("fs"),
+          path: req("path"),
+          fileURLToPath,
+        };
+      } catch {
+        return null;
+      }
+    })();
+  }
+  return nodeModulesPromise;
+}
+
+async function readNodeSourceLines(absPath) {
+  if (!isNode || !absPath) return null;
+
+  try {
+    if (absPath.startsWith("http://") || absPath.startsWith("https://")) {
+      return null;
+    }
+
+    const mods = await getNodeModules();
+    if (!mods) return null;
+
+    const { fs, path, fileURLToPath } = mods;
+    let filePath = absPath;
+
+    if (filePath.startsWith("file://")) {
+      filePath = fileURLToPath(filePath);
+    }
+
+    if (!path.isAbsolute(filePath)) {
+      filePath = path.resolve(process.cwd(), filePath);
+    }
+
+    if (!fs.existsSync(filePath)) return null;
+
+    const stat = fs.statSync(filePath);
+    if (stat.size > MAX_SOURCE_FILE_BYTES) return null;
+
+    const content = fs.readFileSync(filePath, "utf8");
+    return content.split("\n");
+  } catch {
+    return null;
+  }
+}
+
+async function enrichFrameWithNodeSource(frame) {
+  if (!frame.in_app || !frame.lineno) return;
+  const lines = await readNodeSourceLines(frame.abs_path);
+  if (lines) applySourceContext(frame, lines, frame.lineno);
+}
+
+async function fetchBrowserSourceLines(absPath) {
+  if (!isBrowser || !absPath) return null;
+
+  try {
+    let url = absPath;
+    if (url.startsWith("webpack-internal://")) {
+      url = url.replace("webpack-internal:///", "/").replace("webpack-internal://", "/");
+    }
+
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      if (url.startsWith("/")) {
+        url = `${window.location.origin}${url}`;
+      } else {
+        return null;
+      }
+    }
+
+    const target = new URL(url, window.location.href);
+    if (target.origin !== window.location.origin) return null;
+
+    const response = await fetch(target.href, { credentials: "same-origin" });
+    if (!response.ok) return null;
+
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("javascript") && !contentType.includes("text")) {
+      return null;
+    }
+
+    const text = await response.text();
+    if (text.length > MAX_SOURCE_FILE_BYTES) return null;
+    return text.split("\n");
+  } catch {
+    return null;
+  }
+}
+
+async function enrichFrameWithBrowserSource(frame) {
+  if (!frame.in_app || !frame.lineno) return;
+  const lines = await fetchBrowserSourceLines(frame.abs_path);
+  if (lines) applySourceContext(frame, lines, frame.lineno);
+}
+
+export async function enrichStacktraceAsync(stacktrace) {
+  if (!stacktrace?.frames?.length) return stacktrace;
+
+  const inAppFrames = stacktrace.frames.filter((f) => f.in_app);
+  const targets = inAppFrames.slice(-5);
+
+  if (isNode) {
+    await Promise.all(targets.map((frame) => enrichFrameWithNodeSource(frame)));
+  } else if (isBrowser) {
+    await Promise.all(targets.map((frame) => enrichFrameWithBrowserSource(frame)));
+  }
+
+  return stacktrace;
+}

package/src/transport.js

@@ -2,9 +2,12 @@
 const isBrowser = typeof window !== 'undefined';
 const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
 
-// Lazy-load Node.js require function for ES modules
+// Lazy-load Node.js require function for ES modules. Use Function-based import
+// so browser bundlers do not try to resolve Node built-ins like "module".
 let nodeRequire = null;
 let nodeRequirePromise = null;
+const importNodeBuiltin = (specifier) =>
+  new Function("specifier", "return import(specifier)")(specifier);
 
 function getNodeRequire() {
   if (!isNode) return Promise.resolve(null);
@@ -14,8 +17,8 @@ function getNodeRequire() {
   if (!nodeRequirePromise) {
     nodeRequirePromise = (async () => {
       try {
-        const { createRequire } = await import('module');
-        const { fileURLToPath } = await import('url');
+        const { createRequire } = await importNodeBuiltin('module');
+        const { fileURLToPath } = await importNodeBuiltin('url');
         nodeRequire = createRequire(fileURLToPath(import.meta.url));
         return nodeRequire;
       } catch (e) {
@@ -47,6 +50,7 @@ function parseDsn(dsn) {
         host,
         projectId,
         apiUrl: `${finalScheme}://${host}/api/ingestion/events/`,
+        replayUrl: `${finalScheme}://${host}/api/ingestion/replays/`,
       };
     }
   } catch (e) {
@@ -79,6 +83,20 @@ function getApiUrl(dsn) {
   return isBrowser ? "/api/ingestion/events/" : "http://127.0.0.1:8001/api/ingestion/events/";
 }
 
+function getReplayUrl(dsn) {
+  const apiUrl = getApiUrl(dsn);
+  if (apiUrl.endsWith("/events/")) {
+    return apiUrl.replace(/\/events\/$/, "/replays/");
+  }
+
+  const parsed = parseDsn(dsn);
+  if (parsed) {
+    return parsed.replayUrl;
+  }
+
+  return isBrowser ? "/api/ingestion/replays/" : "http://127.0.0.1:8001/api/ingestion/replays/";
+}
+
 export function sendEvent(dsn, payload) {
   const apiUrl = getApiUrl(dsn);
   
@@ -189,3 +207,27 @@ export function sendEvent(dsn, payload) {
     });
   }
 }
+
+export function sendReplay(dsn, payload) {
+  const apiUrl = getReplayUrl(dsn);
+
+  if (isBrowser) {
+    fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `DSN ${dsn}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+      keepalive: false,
+    }).catch((error) => {
+      console.error("WatchForge SDK - Failed to send replay:", error);
+    });
+    return;
+  }
+
+  if (isNode) {
+    // Replays are browser-only, but keep this no-op explicit for framework code paths.
+    return;
+  }
+}