@sailfish-ai/recorder 1.1.3 → 1.2.1

package/dist/index.js

@@ -6,6 +6,7 @@ import { fetchCaptureSettings, sendDomainsToNotPropagateHeaderTo, startRecording
 import { initializeRecording } from "./recording";
 // Default list of domains to ignore
 const DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT = [
+    "t.co",
     "identitytoolkit.googleapis.com",
 ];
 const DOMAINS_TO_NOT_RECORD_NETWORK_REQUESTS_TO = [];
@@ -92,15 +93,27 @@ function storeCredentialsAndConnection({ apiKey, backendApi, }) {
 }
 // Utility function to match domains or paths with wildcard support
 export function matchUrlWithWildcard(url, patterns) {
-    // Strip any protocol (e.g., http, https, ws, wss, ftp, etc.) from the URL
-    const strippedUrl = url.replace(/^[a-zA-Z]+:\/\//, "");
+    if (!url || typeof url !== "string") {
+        throw new Error("Invalid URL input");
+    }
+    // Ensure the URL has a protocol. If not, prepend "http://"
+    const formattedUrl = url.match(/^[a-zA-Z]+:\/\//) ? url : `http://${url}`;
+    const strippedUrl = formattedUrl.replace(/^[a-zA-Z]+:\/\//, "");
     const parsedUrl = new URL("http://" + strippedUrl); // Add a dummy protocol for URL parsing
-    const { hostname, pathname } = parsedUrl;
-    const domain = hostname.toLowerCase();
+    const { hostname, pathname, port } = parsedUrl;
+    // Handle stripping 'www.' and port
+    const domain = hostname.startsWith("www.")
+        ? hostname.slice(4).toLowerCase()
+        : hostname.toLowerCase();
     return patterns.some((pattern) => {
-        // Strip any protocol from the pattern
+        // Strip any protocol and handle port in the pattern if present
         const strippedPattern = pattern.replace(/^[a-zA-Z]+:\/\//, "");
         let [patternDomain, patternPath] = strippedPattern.split("/", 2);
+        // Handle port in pattern
+        let patternPort = "";
+        if (patternDomain.includes(":")) {
+            [patternDomain, patternPort] = patternDomain.split(":");
+        }
         // Handle domain wildcards
         const normalizedPatternDomain = patternDomain
             .replace(/\./g, "\\.") // Escape dots for regex
@@ -109,6 +122,10 @@ export function matchUrlWithWildcard(url, patterns) {
         const domainRegex = new RegExp(`^${normalizedPatternDomain}$`, "i");
         // Strip 'www.' from both the input domain and the pattern domain for comparison
         const strippedDomain = domain.startsWith("www.") ? domain.slice(4) : domain;
+        // If pattern specifies a port, match the exact port
+        if (patternPort && port !== patternPort) {
+            return false;
+        }
         // Handle subdomain wildcard (*.) to match both base and subdomains
         if (patternDomain.startsWith("*.") &&
             (domain === patternDomain.slice(2) ||
@@ -140,40 +157,41 @@ export function matchUrlWithWildcard(url, patterns) {
     });
 }
 // Updated XMLHttpRequest interceptor with single check function
-function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
-    // Store references to the original (or patched) send method
+// Updated XMLHttpRequest interceptor to bypass for CORS-sensitive domains
+function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed domains
+    // Combine default and passed ignore domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
     ];
-    // Override XMLHttpRequest's send method
     XMLHttpRequest.prototype.send = function (...args) {
         const url = this._url;
-        // Check if URL matches any domain or path pattern
-        const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
-        if (sessionId && !shouldSkipHeader) {
+        // Bypass logic for domains listed in the combinedIgnoreDomains
+        if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+            return originalSend.apply(this, args);
+        }
+        // Check if the domain should propagate headers
+        const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
+            matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
+        if (sessionId && shouldPropagateHeader) {
             this.setRequestHeader("X-Sf3-Rid", sessionId);
         }
-        originalSend.apply(this, args);
+        return originalSend.apply(this, args);
     };
 }
-// Updated fetch interceptor with single check function
-function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
-    // Store a reference to the original fetch function
+// Updated fetch interceptor to bypass for CORS-sensitive domains
+function setupFetchInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed domains
+    // Combine default and passed ignore domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
     ];
-    // Define our fetch wrapper
     window.fetch = function (input, init) {
         let url;
-        // Determine the URL based on input type
         if (typeof input === "string") {
             url = input;
         }
@@ -181,60 +199,49 @@ function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
             url = input.url;
         }
         else {
-            // Unknown input type; defer to the original fetch
             return originalFetch.apply(this, arguments);
         }
-        // Check if URL matches any domain or path pattern
-        const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
-        // Use the original fetch if the domain matches the ignore patterns
-        if (shouldSkipHeader) {
-            // Call the original fetch with the original arguments
+        // Bypass logic for domains listed in the combinedIgnoreDomains
+        if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
             return originalFetch.apply(this, arguments);
         }
-        // Only modify the request if we need to add the header
-        if (sessionId) {
+        // Check if the domain should propagate headers
+        const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
+            matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
+        if (sessionId && shouldPropagateHeader) {
             if (input instanceof Request) {
-                // Clone the original request
                 const clonedRequest = input.clone();
-                // Clone the headers and add the custom header
                 const newHeaders = new Headers(clonedRequest.headers);
                 newHeaders.set("X-Sf3-Rid", sessionId);
-                // Create a new Request with the modified headers
                 const modifiedRequest = new Request(clonedRequest, {
                     headers: newHeaders,
                 });
-                // Call the original fetch with the modified Request
                 return originalFetch.call(this, modifiedRequest);
             }
             else {
-                // Input is a URL string
-                // Clone and modify the init object
                 const modifiedInit = { ...init };
-                // Clone the headers
                 const newHeaders = new Headers(init?.headers || {});
                 newHeaders.set("X-Sf3-Rid", sessionId);
                 modifiedInit.headers = newHeaders;
-                // Call the original fetch with the modified init
                 return originalFetch.call(this, input, modifiedInit);
             }
         }
         else {
-            // No sessionId; call the original fetch
             return originalFetch.apply(this, arguments);
         }
     };
 }
 // Main Recording Function
-export async function startRecording({ apiKey, backendApi, domainsToNotPropagateHeaderTo = [], }) {
+export async function startRecording({ apiKey, backendApi, domainsToPropagateHeaderTo = [], domainsToNotPropagateHeaderTo = [], }) {
     let sessionId = getOrSetSessionId();
     storeCredentialsAndConnection({ apiKey, backendApi });
     // Non-blocking GraphQL request to send the domains if provided
     if (domainsToNotPropagateHeaderTo.length > 0) {
         sendDomainsToNotPropagateHeaderTo(apiKey, domainsToNotPropagateHeaderTo, backendApi).catch((error) => console.error("Failed to send domains to not propagate header to:", error));
     }
-    // Setup interceptors with custom ignore domains
-    setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo);
-    setupFetchInterceptor(domainsToNotPropagateHeaderTo);
+    // Setup interceptors with custom ignore and propagate domains
+    setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeaderTo);
+    setupFetchInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeaderTo);
     gatherAndCacheDeviceInfo();
     try {
         const captureSettingsResponse = await fetchCaptureSettings(apiKey, backendApi);