@sailfish-ai/recorder 1.7.6 → 1.7.7

package/dist/errorInterceptor.js

@@ -0,0 +1,113 @@
+import { SourceMapConsumer } from "source-map-js";
+import { sendMessage } from "./websocket";
+/**
+ * Resolves stack traces using source maps.
+ * @param stackTrace - The minified stack trace.
+ * @returns The mapped stack trace with original file/line/column.
+ */
+export async function resolveStackTrace(stackTrace) {
+    if (!stackTrace)
+        return ["No stack trace available"];
+    const traceLines = Array.isArray(stackTrace) ? stackTrace : stackTrace.split("\n");
+    const mappedStack = [];
+    for (const line of traceLines) {
+        const match = line.match(/\/assets\/([^\/]+\.js):(\d+):(\d+)/);
+        if (!match) {
+            mappedStack.push(line); // Keep non-matching lines
+            continue;
+        }
+        const [, fileUrl, lineNum, colNum] = match;
+        const fileName = fileUrl.split("/").pop();
+        const sourceMapUrl = `/assets/${fileName}.map`;
+        try {
+            const response = await fetch(sourceMapUrl);
+            if (!response.ok) {
+                break;
+            }
+            const rawSourceMap = await response.json();
+            if (!rawSourceMap.sources || !Array.isArray(rawSourceMap.sources)) {
+                mappedStack.push(line);
+                continue;
+            }
+            const consumer = await new SourceMapConsumer(rawSourceMap);
+            const original = consumer.originalPositionFor({
+                line: parseInt(lineNum, 10) - 1,
+                column: parseInt(colNum, 10),
+            });
+            if (original.source && original.line) {
+                // Get index of original source in rawSourceMap.sources
+                const sourceIndex = rawSourceMap.sources.indexOf(original.source);
+                let contextSnippet = [];
+                if (sourceIndex !== -1 &&
+                    rawSourceMap.sourcesContent &&
+                    rawSourceMap.sourcesContent[sourceIndex]) {
+                    const lines = rawSourceMap.sourcesContent[sourceIndex].split("\n");
+                    const errorLine = original.line || 1;
+                    // Define range (clamp within file bounds)
+                    const start = Math.max(errorLine - 6, 0); // -6 because index is 0-based
+                    const end = Math.min(errorLine + 4, lines.length); // +4 to get 5 lines after
+                    // Extract and trim context lines
+                    contextSnippet = lines.slice(start, end).map((line, i) => {
+                        const lineNumber = start + i + 1;
+                        const prefix = lineNumber === errorLine ? "👉" : "  ";
+                        return `${prefix} ${lineNumber.toString().padStart(4)} | ${line.trim()}`;
+                    });
+                }
+                mappedStack.push(`${original.source}:${original.line}:${original.column} (${original.name || "anonymous"})`);
+            }
+            else {
+                mappedStack.push(line);
+            }
+        }
+        catch (err) {
+            mappedStack.push(line);
+        }
+    }
+    return mappedStack;
+}
+/**
+ * Captures full error details and resolves the stack trace.
+ */
+async function captureError(error, isPromiseRejection = false) {
+    let errorMessage;
+    let stack;
+    if (error instanceof Error) {
+        errorMessage = error.message;
+        stack = error.stack || "No stack trace";
+    }
+    else if (typeof error === "string") {
+        errorMessage = error;
+        stack = "No stack trace available";
+    }
+    else {
+        errorMessage = "Unknown error occurred";
+        stack = "No stack trace available";
+    }
+    const mappedStack = await resolveStackTrace(stack);
+    const filteredStack = mappedStack.filter((line) => !line.includes("chunk-") && !line.includes("react-dom"));
+    const errorDetails = {
+        message: errorMessage,
+        stack,
+        filteredStack,
+        userAgent: navigator.userAgent,
+        url: window.location.href,
+        timestamp: Date.now(),
+        level: "error",
+    };
+    // Sends the mapped error details to the backend.
+    sendMessage({
+        type: "frontendError",
+        data: errorDetails,
+    });
+}
+/**
+ * Initializes the error interceptor globally.
+ */
+export function initializeErrorInterceptor() {
+    window.addEventListener("error", (event) => {
+        captureError(event.error || event.message);
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+        captureError(event.reason, true);
+    });
+}

package/dist/eventCache.js

@@ -16,7 +16,7 @@ export function sendRecordingEvents(webSocket) {
                 let batchSize = 0;
                 const sendBatch = () => {
                     if (batch.length > 0) {
-                        const message = JSON.stringify({ type: "events", events: batch });
+                        const message = JSON.stringify({ type: "events", events: batch, mapUuid: window.sfMapUuid });
                         webSocket.send(message);
                         batch = [];
                         batchSize = 0;