@sailfish-ai/recorder 1.1.2 → 1.2.0

package/README.md

@@ -1,3 +1,3 @@
 # JS/TS Record-Only Package
 
-## TODO - Rename all Sailfish to GrepLion
+## TODO - Rename all Sailfish to GrepLion!

package/dist/index.js

@@ -92,15 +92,22 @@ 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]+:\/\//, "");
     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 +116,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,41 +151,36 @@ export function matchUrlWithWildcard(url, patterns) {
     });
 }
 // Updated XMLHttpRequest interceptor with single check function
-function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
-    const originalOpen = XMLHttpRequest.prototype.open;
+function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
     ];
-    XMLHttpRequest.prototype.open = function (...args) {
-        this._url = args[1]; // Store the request URL
-        originalOpen.apply(this, args);
-    };
     XMLHttpRequest.prototype.send = function (...args) {
         const url = this._url;
-        // Check if URL matches any domain or path pattern
+        // Check if URL matches the propagation and exclusion patterns
         const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
-        if (sessionId && !shouldSkipHeader) {
+        const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
+            matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
+        if (sessionId && shouldPropagateHeader && !shouldSkipHeader) {
             this.setRequestHeader("X-Sf3-Rid", sessionId);
         }
         originalSend.apply(this, args);
     };
 }
 // Updated fetch interceptor with single check function
-function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
+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,
     ];
-    window.fetch = async function (input, init = {}) {
+    window.fetch = function (input, init) {
         let url;
-        // Check if input is a string (URL) or a Request object
         if (typeof input === "string") {
             url = input;
         }
@@ -182,30 +188,48 @@ function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
             url = input.url;
         }
         else {
-            throw new Error("Invalid input type for fetch");
+            return originalFetch.apply(this, arguments);
         }
-        // Check if URL matches any domain or path pattern
+        // Check if URL matches the propagation and exclusion patterns
         const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
-        if (sessionId && !shouldSkipHeader) {
-            init.headers = {
-                ...init.headers,
-                "X-Sf3-Rid": sessionId,
-            };
+        const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
+            matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
+        // Proceed with fetch if header should propagate and not be excluded
+        if (sessionId && shouldPropagateHeader && !shouldSkipHeader) {
+            if (input instanceof Request) {
+                const clonedRequest = input.clone();
+                const newHeaders = new Headers(clonedRequest.headers);
+                newHeaders.set("X-Sf3-Rid", sessionId);
+                const modifiedRequest = new Request(clonedRequest, {
+                    headers: newHeaders,
+                });
+                return originalFetch.call(this, modifiedRequest);
+            }
+            else {
+                const modifiedInit = { ...init };
+                const newHeaders = new Headers(init?.headers || {});
+                newHeaders.set("X-Sf3-Rid", sessionId);
+                modifiedInit.headers = newHeaders;
+                return originalFetch.call(this, input, modifiedInit);
+            }
+        }
+        else {
+            return originalFetch.apply(this, arguments);
         }
-        return originalFetch(input, init);
     };
 }
 // Main Recording Function
-export async function startRecording({ apiKey, backendApi, domainsToNotPropagateHeaderTo = [], }) {
+// Main Recording Function
+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);