@sailfish-ai/recorder 1.1.3 → 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,40 +151,36 @@ export function matchUrlWithWildcard(url, patterns) {
     });
 }
 // Updated XMLHttpRequest interceptor with single check function
-function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
-    // Store references to the original (or patched) send method
+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,
     ];
-    // Override XMLHttpRequest's send method
     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) {
-    // Store a reference to the original fetch function
+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 +188,48 @@ 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
+        // Check if URL matches the propagation and exclusion patterns
         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
-            return originalFetch.apply(this, arguments);
-        }
-        // Only modify the request if we need to add the header
-        if (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) {
-                // 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 = [], }) {
+// 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);