@watchforge/browser 0.1.10 → 0.1.12

package/bin/watchforge.js

@@ -214,6 +214,7 @@ function createConfig(cwd, args) {
   replaysOnErrorSampleRate: ${Number(args.replaysOnError)},
   replaysSessionSampleRate: ${Number(args.replaysSession)},
   maskAllInputs: true,
+  projectRoot: process.env.INIT_CWD || process.env.PWD || "",
 };
 `;
   writeIfChanged(configPath, content);
@@ -280,6 +281,7 @@ export default function WatchForgeInit() {
 
 function createNextGlobalError(cwd, layoutPath) {
   const appDir = path.dirname(layoutPath);
+  const configImport = toImportPath(appDir, getConfigPath(cwd));
   const usesTs = projectUsesTypeScript(cwd);
   const globalErrorPath = path.join(appDir, usesTs ? "global-error.tsx" : "global-error.jsx");
 
@@ -301,25 +303,31 @@ function createNextGlobalError(cwd, layoutPath) {
   const content = `"use client";
 
 import { useEffect } from "react";
-import { captureException } from "@watchforge/browser";
+import { register, captureException } from "@watchforge/browser";
+import { watchforgeConfig } from "${configImport}";
 
 export default function GlobalError(${propsSignature}) {
   useEffect(() => {
-    void captureException(error, {
-      tags: {
-        framework: "nextjs",
-        runtime: "error-boundary",
-      },
-      extra: {
-        digest: error.digest,
-      },
-      contexts: {
-        nextjs: {
-          error_boundary: "global-error",
-          digest: error.digest || null,
+    register(watchforgeConfig);
+    const timer = window.setTimeout(() => {
+      void captureException(error, {
+        tags: {
+          framework: "nextjs",
+          runtime: "error-boundary",
         },
-      },
-    });
+        extra: {
+          digest: error.digest,
+        },
+        contexts: {
+          nextjs: {
+            error_boundary: "global-error",
+            digest: error.digest || null,
+          },
+        },
+      });
+    }, 100);
+
+    return () => window.clearTimeout(timer);
   }, [error]);
 
   return (
@@ -347,17 +355,35 @@ function createNextInstrumentation(cwd, layoutPath) {
   const configImport = toImportPath(path.dirname(instrumentationPath), getConfigPath(cwd));
 
   if (fileExists(instrumentationPath)) {
-    const content = fs.readFileSync(instrumentationPath, "utf8");
+    let content = fs.readFileSync(instrumentationPath, "utf8");
+    if (content.includes("onRequestError")) {
+      log(`${path.relative(cwd, instrumentationPath)} already contains WatchForge request error capture`);
+      return;
+    }
+
     if (content.includes("@watchforge/browser/next/server")) {
-      log(`${path.relative(cwd, instrumentationPath)} already contains WatchForge setup`);
+      content = content.replace(
+        /import\s*\{\s*register\s+as\s+registerWatchForge\s*\}\s*from\s*"@watchforge\/browser\/next\/server";/,
+        'import { register as registerWatchForge, onRequestError as watchForgeOnRequestError } from "@watchforge/browser/next/server";'
+      );
+      if (!content.includes("watchForgeOnRequestError")) {
+        content = `import { onRequestError as watchForgeOnRequestError } from "@watchforge/browser/next/server";\n${content}`;
+      }
+      content = `${content.trim()}\n\nexport const onRequestError = watchForgeOnRequestError;\n`;
+      fs.writeFileSync(instrumentationPath, content);
+      log(`patched ${path.relative(cwd, instrumentationPath)} for SSR/request error capture`);
       return;
     }
+
     log(`skipped ${path.relative(cwd, instrumentationPath)} because it already exists`);
-    log("add registerWatchForge(watchforgeConfig) there manually to report Next.js server runtime errors");
+    log("add registerWatchForge(watchforgeConfig) and onRequestError there manually");
     return;
   }
 
-  const content = `import { register as registerWatchForge } from "@watchforge/browser/next/server";
+  const content = `import {
+  register as registerWatchForge,
+  onRequestError as watchForgeOnRequestError,
+} from "@watchforge/browser/next/server";
 import { watchforgeConfig } from "${configImport}";
 
 export async function register() {
@@ -365,6 +391,8 @@ export async function register() {
     registerWatchForge(watchforgeConfig);
   }
 }
+
+export const onRequestError = watchForgeOnRequestError;
 `;
 
   writeIfChanged(instrumentationPath, content);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watchforge/browser",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "description": "WatchForge JavaScript SDK for browser JavaScript, Next.js, React, Node.js, and Express.js",

package/src/client.js

@@ -2,6 +2,7 @@ import { sendEvent, parseDsn } from "./transport.js";
 import {
   buildStacktraceFromError,
   enrichStacktraceAsync,
+  setProjectRoot,
 } from "./stacktrace.js";
 import {
   getSdkMetadata,
@@ -13,12 +14,14 @@ import {
   flushReplayForEvent,
   getReplayContext,
   initReplay,
+  waitForReplayReady,
 } from "./replay.js";
 
 let DSN = null;
 let APP_ENV = "production";
 let RELEASE = null;
 let DEBUG = false;
+let CAPTURE_CONSOLE_ERRORS = true;
 
 // Detect environment
 const isBrowser = typeof window !== "undefined";
@@ -28,6 +31,9 @@ const isNode =
 // In-memory breadcrumb buffer (shared for all events in this process / page)
 const MAX_BREADCRUMBS = 100;
 let breadcrumbs = [];
+let browserInstrumentationInstalled = false;
+let nodeInstrumentationInstalled = false;
+let replayInitPromise = null;
 
 export function addBreadcrumb(breadcrumb) {
   const entry = {
@@ -48,6 +54,10 @@ function getBreadcrumbsSnapshot() {
   return breadcrumbs.slice();
 }
 
+function isWatchForgeInternalMessage(message) {
+  return String(message || "").includes("WatchForge SDK");
+}
+
 // Simple browser environment detectors (best-effort, not 100% accurate)
 function getBrowserContext() {
   if (!isBrowser) return null;
@@ -150,6 +160,8 @@ function getRuntimeContext() {
 
 function setupBrowserInstrumentation() {
   if (!isBrowser) return;
+  if (browserInstrumentationInstalled) return;
+  browserInstrumentationInstalled = true;
 
   // Global error handlers (already existed but keep here with breadcrumbs)
   window.onerror = function (msg, url, line, col, error) {
@@ -180,13 +192,42 @@ function setupBrowserInstrumentation() {
     const original = console[level].bind(console);
     console[level] = (...args) => {
       try {
+        const message = args.map(String).join(" ");
         addBreadcrumb({
           type: "log",
           level,
           category: "console",
-          message: args.map(String).join(" "),
+          message,
           data: {},
         });
+
+        if (
+          level === "error" &&
+          CAPTURE_CONSOLE_ERRORS &&
+          !isWatchForgeInternalMessage(message)
+        ) {
+          const errorArg = args.find((arg) => arg instanceof Error);
+          const error =
+            errorArg ||
+            new Error(message || "console.error");
+          setTimeout(() => {
+            void captureException(error, {
+              tags: {
+                handled: true,
+                mechanism: "console.error",
+              },
+              contexts: {
+                console: {
+                  arguments: args.map((arg) =>
+                    arg instanceof Error
+                      ? { name: arg.name, message: arg.message, stack: arg.stack }
+                      : String(arg)
+                  ),
+                },
+              },
+            });
+          }, 0);
+        }
       } catch (_) {
         // best-effort, never break console
       }
@@ -389,11 +430,18 @@ export function register({
   blockClass = "rr-block",
   ignoreClass = "rr-ignore",
   maskTextClass = "rr-mask",
+  captureConsoleErrors = true,
+  projectRoot = null,
 }) {
   DSN = dsn;
   APP_ENV = app_env;
   RELEASE = release;
   DEBUG = debug;
+  CAPTURE_CONSOLE_ERRORS = Boolean(captureConsoleErrors);
+  setProjectRoot(
+    projectRoot ||
+      (isNode ? process.env.WATCHFORGE_PROJECT_ROOT || process.env.INIT_CWD : null)
+  );
   
   // Initialize tracing
   initTracing(dsn, app_env, debug);
@@ -420,7 +468,7 @@ export function register({
   // Browser: Set up full instrumentation (errors, breadcrumbs, HTTP, navigation)
   if (isBrowser) {
     setupBrowserInstrumentation();
-    initReplay({
+    replayInitPromise = initReplay({
       replaysSessionSampleRate,
       replaysOnErrorSampleRate,
       maskAllInputs,
@@ -433,6 +481,9 @@ export function register({
   
   // Node.js: Set up process error handlers
   if (isNode) {
+    if (nodeInstrumentationInstalled) return;
+    nodeInstrumentationInstalled = true;
+
     process.on("uncaughtException", (error) => {
       void captureException(error);
     });
@@ -454,7 +505,10 @@ export async function captureException(error, context = {}) {
 
   let stacktrace = buildStacktraceFromError(error);
   if (stacktrace) {
-    stacktrace = await enrichStacktraceAsync(stacktrace);
+    stacktrace = await enrichStacktraceAsync(
+      stacktrace,
+      error?.message || String(error || "")
+    );
   }
 
   const event = {
@@ -468,6 +522,15 @@ export async function captureException(error, context = {}) {
     sdk: getSdkMetadata(),
   };
 
+  if (isBrowser && replayInitPromise) {
+    try {
+      await replayInitPromise;
+      await waitForReplayReady();
+    } catch {
+      // Replay is best-effort; never block error delivery.
+    }
+  }
+
   const replay = flushReplayForEvent(DSN, event.event_id);
   if (replay) {
     event.replay_id = replay.replay_id;

package/src/contexts.js

@@ -7,7 +7,7 @@ const isNode =
   typeof process !== "undefined" && process.versions && process.versions.node;
 
 export const SDK_NAME = "@watchforge/browser";
-export const SDK_VERSION = "0.1.10";
+export const SDK_VERSION = "0.1.12";
 
 export function getSdkMetadata() {
   return {

package/src/index.d.ts

@@ -9,6 +9,8 @@ export interface WatchForgeRegisterOptions {
   blockClass?: string;
   ignoreClass?: string;
   maskTextClass?: string;
+  captureConsoleErrors?: boolean;
+  projectRoot?: string | null;
 }
 
 export interface WatchForgeCaptureContext {

package/src/next-server.d.ts

@@ -5,6 +5,27 @@ import type {
 
 export function register(options: WatchForgeRegisterOptions): void;
 
+export type NextRequestErrorContext = {
+  routerKind: "Pages Router" | "App Router";
+  routePath: string;
+  routeType: "render" | "route" | "action" | "middleware";
+  renderSource?:
+    | "react-server-components"
+    | "react-server-components-payload"
+    | "server-rendering";
+  revalidateReason?: "on-demand" | "stale";
+};
+
+export function onRequestError(
+  error: unknown,
+  request: Readonly<{
+    path: string;
+    method: string;
+    headers: Record<string, string | string[] | undefined>;
+  }>,
+  context: Readonly<NextRequestErrorContext>
+): void | Promise<void>;
+
 export function captureException(
   error: unknown,
   context?: WatchForgeCaptureContext

package/src/next-server.js

@@ -1,10 +1,70 @@
 import {
   captureException,
   captureMessage,
-  register,
+  register as registerClient,
 } from "./client.js";
 
-export { captureException, captureMessage, register };
+let registeredOptions = null;
+
+export function register(options) {
+  registeredOptions = options;
+  registerClient(options);
+}
+
+export { captureException, captureMessage };
+
+function buildRequestUrl(request) {
+  if (!request?.path) return "";
+  const path = request.path.startsWith("/") ? request.path : `/${request.path}`;
+  return path;
+}
+
+export async function onRequestError(error, request, context) {
+  if (!registeredOptions) return;
+
+  await captureException(error, {
+    request: {
+      url: buildRequestUrl(request),
+      method: request?.method || "GET",
+      headers: sanitizeRequestHeaders(request?.headers),
+    },
+    tags: {
+      framework: "nextjs",
+      runtime: "server",
+      router: context?.routerKind || "unknown",
+      route_type: context?.routeType || "unknown",
+    },
+    contexts: {
+      nextjs: {
+        on_request_error: true,
+        router_kind: context?.routerKind || null,
+        route_path: context?.routePath || null,
+        route_type: context?.routeType || null,
+        render_source: context?.renderSource || null,
+      },
+    },
+  });
+}
+
+function sanitizeRequestHeaders(headers) {
+  if (!headers) return {};
+
+  const sensitive = new Set([
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "x-csrftoken",
+  ]);
+  const entries =
+    typeof headers.entries === "function"
+      ? Array.from(headers.entries())
+      : Object.entries(headers);
+
+  return Object.fromEntries(
+    entries.filter(([key]) => !sensitive.has(String(key).toLowerCase()))
+  );
+}
 
 function sanitizeHeaders(headers) {
   if (!headers || typeof headers.entries !== "function") return {};

package/src/replay.js

@@ -120,6 +120,27 @@ export async function initReplay(config = {}) {
   }
 }
 
+export function waitForReplayReady(timeoutMs = 300) {
+  if (!isBrowser || !replayId || !sessionId) return Promise.resolve(false);
+  if (events.length > 0) return Promise.resolve(true);
+
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const check = () => {
+      if (events.length > 0) {
+        resolve(true);
+        return;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        resolve(false);
+        return;
+      }
+      setTimeout(check, 25);
+    };
+    check();
+  });
+}
+
 export function getReplayContext() {
   if (!isBrowser || !replayId || !sessionId) return null;
   return {
@@ -151,7 +172,7 @@ export function flushReplayForEvent(dsn, eventId) {
     events,
     sdk: {
       name: "@watchforge/browser",
-      version: "0.1.10",
+      version: "0.1.12",
     },
   };
 

package/src/stacktrace.js

@@ -60,6 +60,7 @@ export function buildStacktraceFromError(error) {
     return null;
   }
 
+  const errorMessage = error?.message || "";
   const stackLines = error.stack.split("\n");
   const frames = [];
 
@@ -88,6 +89,7 @@ export function buildStacktraceFromError(error) {
       post_context: [],
       vars: {},
       in_app: inApp,
+      error_message: errorMessage,
     });
   }
 
@@ -114,6 +116,45 @@ function applySourceContext(frame, sourceLines, lineno) {
     .map((l) => l.replace(/\r$/, ""));
 }
 
+function getUndefinedIdentifier(message) {
+  if (!message || typeof message !== "string") return null;
+  const match = message.match(/^([A-Za-z_$][\w$]*) is not defined$/);
+  return match?.[1] || null;
+}
+
+function inferLineFromErrorMessage(frame, sourceLines) {
+  const identifier = getUndefinedIdentifier(frame.error_message);
+  if (!identifier || !sourceLines?.length) return null;
+
+  const tokenPattern = new RegExp(`\\b${identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+  const functionName = frame.function && frame.function !== "<anonymous>"
+    ? String(frame.function)
+    : null;
+
+  const candidates = [];
+  for (let i = 0; i < sourceLines.length; i++) {
+    if (!tokenPattern.test(sourceLines[i])) continue;
+    candidates.push(i);
+  }
+
+  if (!candidates.length) return null;
+
+  if (functionName) {
+    const functionPattern = new RegExp(`\\b${functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+    let nearestFunctionLine = -1;
+    for (let i = 0; i < sourceLines.length; i++) {
+      if (functionPattern.test(sourceLines[i])) {
+        nearestFunctionLine = i;
+      }
+      if (candidates.includes(i) && nearestFunctionLine !== -1) {
+        return i + 1;
+      }
+    }
+  }
+
+  return candidates[0] + 1;
+}
+
 function normalizeSourcePath(source) {
   if (!source) return "";
 
@@ -167,6 +208,114 @@ function getNodeModules() {
   return nodeModulesPromise;
 }
 
+let cachedProjectRoots = null;
+let configuredProjectRoot = null;
+
+export function setProjectRoot(projectRoot) {
+  configuredProjectRoot = projectRoot || null;
+  cachedProjectRoots = null;
+}
+
+function packageJsonHasNext(packageJson) {
+  return Boolean(packageJson.dependencies?.next || packageJson.devDependencies?.next);
+}
+
+async function findProjectRoots() {
+  if (cachedProjectRoots) return cachedProjectRoots;
+
+  const mods = await getNodeModules();
+  if (!mods) {
+    cachedProjectRoots = [process.cwd()];
+    return cachedProjectRoots;
+  }
+
+  const { fs, path } = mods;
+  const roots = new Set();
+  const seeds = [
+    configuredProjectRoot,
+    process.env.WATCHFORGE_PROJECT_ROOT,
+    process.env.INIT_CWD,
+    process.env.PWD,
+    process.cwd(),
+  ].filter(Boolean);
+
+  for (const seed of seeds) {
+    roots.add(seed);
+
+    let dir = seed;
+    for (let depth = 0; depth < 10; depth++) {
+      const packageJsonPath = path.join(dir, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        try {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+          if (packageJsonHasNext(packageJson)) {
+            roots.add(dir);
+          }
+        } catch {
+          // ignore invalid package.json
+        }
+      }
+
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+
+  cachedProjectRoots = [...roots];
+  return cachedProjectRoots;
+}
+
+function readFileLines(fs, filePath) {
+  const stat = fs.statSync(filePath);
+  if (stat.size > MAX_SOURCE_FILE_BYTES) return null;
+  return fs.readFileSync(filePath, "utf8").split("\n");
+}
+
+function findFileUnderRoot(fs, path, root, normalizedPath, basename, maxDepth = 5) {
+  const suffix = normalizedPath.replace(/^\/+/, "");
+  const directCandidate = path.join(root, suffix);
+  if (fs.existsSync(directCandidate)) {
+    return directCandidate;
+  }
+
+  const stack = [{ dir: root, depth: 0 }];
+  let scannedFiles = 0;
+
+  while (stack.length > 0 && scannedFiles < 500) {
+    const { dir, depth } = stack.pop();
+    if (depth > maxDepth) continue;
+
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".next" || entry.name === ".git") {
+        continue;
+      }
+
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isFile()) {
+        scannedFiles += 1;
+        if (entry.name === basename) {
+          const normalizedEntry = entryPath.replace(/\\/g, "/");
+          if (normalizedEntry.endsWith(suffix)) {
+            return entryPath;
+          }
+        }
+      } else if (entry.isDirectory()) {
+        stack.push({ dir: entryPath, depth: depth + 1 });
+      }
+    }
+  }
+
+  return null;
+}
+
 async function readNodeSourceLines(absPath) {
   if (!isNode || !absPath) return null;
 
@@ -185,26 +334,87 @@ async function readNodeSourceLines(absPath) {
       filePath = fileURLToPath(filePath);
     }
 
-    if (!path.isAbsolute(filePath)) {
-      filePath = path.resolve(process.cwd(), filePath);
+    const normalizedPath = normalizeSourcePath(filePath);
+    const roots = await findProjectRoots();
+    const candidates = new Set();
+
+    if (path.isAbsolute(filePath)) {
+      candidates.add(filePath);
+    }
+
+    for (const root of roots) {
+      candidates.add(path.resolve(root, filePath));
+      candidates.add(path.resolve(root, normalizedPath));
+
+      const srcMatch = normalizedPath.match(/(?:^|\/)?(src\/.+)$/);
+      if (srcMatch) {
+        candidates.add(path.resolve(root, srcMatch[1]));
+      }
+    }
+
+    for (const candidate of candidates) {
+      if (!candidate || !fs.existsSync(candidate)) continue;
+      const lines = readFileLines(fs, candidate);
+      if (lines) return lines;
     }
 
-    if (!fs.existsSync(filePath)) return null;
+    const basename = path.basename(normalizedPath);
+    for (const root of roots) {
+      const packageJsonPath = path.join(root, "package.json");
+      if (!fs.existsSync(packageJsonPath)) continue;
+
+      let isNextProject = root === process.env.INIT_CWD || root === process.env.PWD;
+      if (!isNextProject) {
+        try {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+          isNextProject = packageJsonHasNext(packageJson);
+        } catch {
+          isNextProject = false;
+        }
+      }
 
-    const stat = fs.statSync(filePath);
-    if (stat.size > MAX_SOURCE_FILE_BYTES) return null;
+      if (!isNextProject) continue;
+
+      const discovered = findFileUnderRoot(fs, path, root, normalizedPath, basename);
+      if (discovered && fs.existsSync(discovered)) {
+        const lines = readFileLines(fs, discovered);
+        if (lines) return lines;
+      }
+    }
 
-    const content = fs.readFileSync(filePath, "utf8");
-    return content.split("\n");
+    return null;
   } catch {
     return null;
   }
 }
 
+function resolveFrameLine(frame, lines) {
+  let lineno = frame.lineno;
+  if (!lines?.length || !lineno) return lineno;
+
+  if (lineno > lines.length) {
+    const inferredLine = inferLineFromErrorMessage(frame, lines);
+    if (inferredLine) {
+      lineno = inferredLine;
+      frame.lineno = inferredLine;
+      const identifier = getUndefinedIdentifier(frame.error_message);
+      if (identifier) {
+        const col = lines[inferredLine - 1].indexOf(identifier);
+        if (col >= 0) frame.colno = col + 1;
+      }
+    }
+  }
+
+  return lineno;
+}
+
 async function enrichFrameWithNodeSource(frame) {
   if (!frame.in_app || !frame.lineno) return;
   const lines = await readNodeSourceLines(frame.raw_abs_path || frame.abs_path);
-  if (lines) applySourceContext(frame, lines, frame.lineno);
+  if (!lines) return;
+
+  const lineno = resolveFrameLine(frame, lines);
+  applySourceContext(frame, lines, lineno);
 }
 
 function getBrowserSourceFetchCandidates(absPath, rawAbsPath) {
@@ -475,13 +685,21 @@ async function enrichFrameWithBrowserSource(frame) {
   await enrichFrameWithSourceMap(frame);
 }
 
-export async function enrichStacktraceAsync(stacktrace) {
+export async function enrichStacktraceAsync(stacktrace, errorMessage = null) {
   if (!stacktrace?.frames?.length) return stacktrace;
 
   const inAppFrames = stacktrace.frames.filter((f) => f.in_app);
   // Enrich the error frame first (last in-app frame), then nearby frames.
   const targets = [...inAppFrames.slice(-5)].reverse();
 
+  if (errorMessage) {
+    for (const frame of targets) {
+      if (!frame.error_message) {
+        frame.error_message = errorMessage;
+      }
+    }
+  }
+
   if (isNode) {
     await Promise.all(targets.map((frame) => enrichFrameWithNodeSource(frame)));
   } else if (isBrowser) {

package/src/tracing.js

@@ -118,7 +118,7 @@ class Transaction {
       request: this.request,
       platform: typeof window !== "undefined" ? "javascript" : "node",
       sdk_name: "watchforge-javascript",
-      sdk_version: "0.1.0",
+      sdk_version: "0.1.12",
     };
 
     if (DEBUG) {