@sailfish-ai/recorder 1.2.5 → 1.2.7

package/dist/index.js

@@ -93,6 +93,7 @@ function storeCredentialsAndConnection({ apiKey, backendApi, }) {
 }
 // Utility function to match domains or paths with wildcard support
 export function matchUrlWithWildcard(url, patterns) {
+    console.log(`Calling matchUrlWithWildcard against ${url}`);
     if (!url || typeof url !== "string") {
         throw new Error("Invalid URL input");
     }
@@ -157,80 +158,57 @@ export function matchUrlWithWildcard(url, patterns) {
     });
 }
 // Updated XMLHttpRequest interceptor with single check function
-// Updated XMLHttpRequest interceptor to bypass for CORS-sensitive domains
 function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
     const originalOpen = XMLHttpRequest.prototype.open;
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed ignore domains
+    // Combined ignore and propagate logic
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
     ];
     // Store URL during open()
     XMLHttpRequest.prototype.open = function (method, url, ...args) {
-        // Ensure the URL is a string, otherwise handle gracefully
-        if (typeof url === "string" && url.length > 0) {
-            this._requestUrl = url; // Capture the valid URL
-        }
-        else {
-            console.warn("Invalid or non-string URL passed to XMLHttpRequest:", url);
-            this._requestUrl = null; // Handle invalid or non-string URL
-        }
+        console.log("Sailfish XMLHttpRequest.prototype.open");
+        this._requestUrl = typeof url === "string" && url.length > 0 ? url : null;
         return originalOpen.apply(this, [method, url, ...args]);
     };
     // Intercept send()
     XMLHttpRequest.prototype.send = function (...args) {
+        console.log("Sailfish XMLHttpRequest.prototype.send");
         const url = this._requestUrl;
-        // If no valid URL was captured, proceed without modification
-        if (!url) {
+        if (!url)
             return originalSend.apply(this, args);
-        }
-        // Bypass logic for domains listed in the combinedIgnoreDomains
+        // Check if domain should be ignored based on combined ignore list
         if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+            console.log([`[XML] [InIgnoreDomains] IGNORE --> ${url}`]);
             return originalSend.apply(this, args);
         }
-        // Check if the domain should propagate headers
+        // Check if domain should propagate headers
         const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
             matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
         if (sessionId && shouldPropagateHeader) {
+            console.log([`[XML] [InPropagateDomans] PROPAGATE FOR --> ${url}`]);
             this.setRequestHeader("X-Sf3-Rid", sessionId);
         }
+        console.log([`[XML] [NOT InPropagateDomans] IGNORE --> ${url}`]);
         return originalSend.apply(this, args);
     };
 }
-// Updated fetch interceptor to bypass for CORS-sensitive domains
-function setupFetchInterceptor(domainsToNotPatchFetchFor, domainsToPropagateHeadersTo = []) {
+// Updated fetch interceptor with exclusion handling
+function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagateHeadersTo = []) {
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed ignore domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
-        ...domainsToNotPatchFetchFor,
+        ...domainsToNotPropagateHeadersTo,
     ];
-    // Cache results of domain checks to reduce performance overhead
     const cache = new Map();
-    // Function to check if the input is a non-standard fetch input (Blob, FormData, etc.)
-    function isNonStandardRequestInfo(input) {
-        return (input instanceof Blob ||
-            input instanceof FormData ||
-            input instanceof ArrayBuffer);
-    }
-    // Function to check if fetch is polyfilled (e.g., in older browsers or Node.js)
-    function isPolyfilledFetch() {
-        return !window.fetch.toString().includes("[native code]");
-    }
-    // Log a warning if fetch is polyfilled
-    if (isPolyfilledFetch()) {
-        console.log("Fetch is polyfilled, behavior may differ from native fetch.");
-    }
-    // Proxy to conditionally intercept fetch based on domains
     window.fetch = new Proxy(originalFetch, {
         apply: (target, thisArg, args) => {
             let input = args[0];
             let init = args[1] || {};
             let url;
-            // Handle different types of `input` for fetch
             if (typeof input === "string") {
                 url = input;
             }
@@ -240,52 +218,39 @@ function setupFetchInterceptor(domainsToNotPatchFetchFor, domainsToPropagateHead
             else if (input instanceof URL) {
                 url = input.href;
             }
-            else if (isNonStandardRequestInfo(input)) {
-                // Pass through non-standard inputs like Blob, FormData, etc.
-                return target.apply(thisArg, args);
-            }
             else {
-                // Unsupported input type, skip interception
-                console.warn("Unsupported input type for fetch:", input);
-                return target.apply(thisArg, args);
+                console.log("Unsupported args -->", args);
+                return target.apply(thisArg, args); // Skip unsupported inputs
             }
-            // Check the cache for domain results to avoid redundant checks
+            // Cache check
             if (cache.has(url)) {
                 const cachedResult = cache.get(url);
                 if (cachedResult === "ignore") {
+                    console.log(`[CACHE] IGNORE --> ${url}`);
                     return target.apply(thisArg, args);
                 }
                 if (cachedResult === "propagate") {
+                    console.log(`[CACHE] PROPAGATE FOR --> ${url}`);
                     return injectHeader(target, thisArg, args, input, init, sessionId);
                 }
             }
-            // ** Security Restriction Handling **
-            try {
-                // ** Check if we should skip patching fetch entirely for this domain **
-                if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
-                    // Cache the result for this domain to avoid future checks
-                    cache.set(url, "ignore");
-                    return target.apply(thisArg, args);
-                }
-                // Check if the domain should propagate the header
-                const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
-                    matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
-                // ** Skip CORS-sensitive requests **
-                if (!shouldPropagateHeader) {
-                    // Cache the result for this domain to avoid future checks
-                    cache.set(url, "ignore");
-                    return target.apply(thisArg, args);
-                }
-                // Cache the result for this domain
-                cache.set(url, "propagate");
-                // ** Proceed to inject X-Sf3-Rid header **
-                return injectHeader(target, thisArg, args, input, init, sessionId);
+            // Check domain exclusion
+            if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+                console.log(`[InIgnoreDomains] IGNORE --> ${url}`);
+                cache.set(url, "ignore");
+                return target.apply(thisArg, args);
             }
-            catch (error) {
-                // ** Handle security restrictions and fallback to the original fetch **
-                console.error("Failed to intercept fetch due to security restrictions:", error);
+            // Check domain propagation
+            const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
+                matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
+            if (!shouldPropagateHeader) {
+                console.log(`[NOT InPropagateDomans] IGNORE --> ${url}`);
+                cache.set(url, "ignore");
                 return target.apply(thisArg, args);
             }
+            cache.set(url, "propagate");
+            console.log(`[InPropagateDomans] PROPAGATE FOR --> ${url}`);
+            return injectHeader(target, thisArg, args, input, init, sessionId);
         },
     });
     // Helper function to inject the X-Sf3-Rid header
@@ -299,6 +264,7 @@ function setupFetchInterceptor(domainsToNotPatchFetchFor, domainsToPropagateHead
                 const modifiedRequest = new Request(clonedRequest, {
                     headers: newHeaders,
                 });
+                console.log(`[modified call] newHeaders --> `, newHeaders);
                 return target.call(thisArg, modifiedRequest, init);
             }
             else {
@@ -307,10 +273,12 @@ function setupFetchInterceptor(domainsToNotPatchFetchFor, domainsToPropagateHead
                 const newHeaders = new Headers(init.headers || {});
                 newHeaders.set("X-Sf3-Rid", sessionId);
                 modifiedInit.headers = newHeaders;
+                console.log(`[modified call] newHeaders --> `, newHeaders);
                 return target.call(thisArg, input, modifiedInit);
             }
         }
         else {
+            console.log("[UNMODIFIED CALL]");
             return target.apply(thisArg, args);
         }
     }