@sailfish-ai/recorder 1.2.11 → 1.3.2

package/dist/index.js

@@ -4,6 +4,7 @@ import { gatherAndCacheDeviceInfo } from "./deviceInfo";
 import { sendRecordingEvents } from "./eventCache";
 import { fetchCaptureSettings, sendDomainsToNotPropagateHeaderTo, startRecordingSession, } from "./graphql";
 import { initializeRecording } from "./recording";
+import { sendMessage } from "./websocket";
 // Default list of domains to ignore
 const DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT = [
     "t.co",
@@ -55,34 +56,78 @@ export const DEFAULT_CONSOLE_RECORDING_SETTINGS = {
 //   recordBody: true,
 //   recordInitialRequests: false,
 // };
+const PERSIST_SESSION_FOR_REOPENING_TABS = false;
 // Functions
-// Function to get the current sessionId from sessionStorage
+// Function to get or set the device & program UUID in localStorage
+function getOrSetUserDeviceUuid() {
+    let userDeviceUuid = localStorage.getItem("sailfishUserDeviceUuid");
+    if (!userDeviceUuid) {
+        userDeviceUuid = uuidv4();
+        localStorage.setItem("sailfishUserDeviceUuid", userDeviceUuid);
+    }
+    return userDeviceUuid;
+}
+// Function to generate a unique key for storing sessionId in localStorage
+function getTabKey() {
+    let tabKey = sessionStorage.getItem("sailfishTabKey");
+    if (!tabKey) {
+        tabKey = uuidv4();
+        sessionStorage.setItem("sailfishTabKey", tabKey);
+    }
+    return tabKey;
+}
+// Function to get or set the current sessionId in sessionStorage
 function getOrSetSessionId(forceNew = false) {
     let sessionId = sessionStorage.getItem("sailfishSessionId");
     if (!sessionId || forceNew) {
-        sessionId = uuidv4();
+        const tabKey = getTabKey();
+        const storedSessionId = PERSIST_SESSION_FOR_REOPENING_TABS
+            ? localStorage.getItem(`sailfishSessionId_${tabKey}`)
+            : null;
+        if (storedSessionId && !forceNew) {
+            sessionId = storedSessionId;
+        }
+        else {
+            sessionId = uuidv4();
+        }
         sessionStorage.setItem("sailfishSessionId", sessionId);
     }
     return sessionId;
 }
-// Function to reset the sessionId when the page becomes visible again
+// Function to store the current sessionId in localStorage on page unload
+function storeSessionId() {
+    if (PERSIST_SESSION_FOR_REOPENING_TABS) {
+        const tabKey = getTabKey();
+        const sessionId = sessionStorage.getItem("sailfishSessionId");
+        if (sessionId) {
+            localStorage.setItem(`sailfishSessionId_${tabKey}`, sessionId);
+        }
+    }
+}
+// Function to handle resetting the sessionId when the page becomes visible again
 function handleVisibilityChange() {
     if (document.visibilityState === "visible") {
-        getOrSetSessionId(true); // Force a new sessionId when the user returns to the page
+        getOrSetSessionId(); // Restore sessionId when the user returns to the page
     }
 }
 // Initialize event listeners for visibility change and page unload
 document.addEventListener("visibilitychange", handleVisibilityChange);
-window.addEventListener("beforeunload", () => {
-    sessionStorage.removeItem("sailfishSessionId");
-});
+window.addEventListener("beforeunload", storeSessionId);
+export function sendUserUuid() {
+    const userDeviceUuid = getOrSetUserDeviceUuid();
+    const message = {
+        type: "userDeviceUuid",
+        userDeviceUuid,
+    };
+    sendMessage(message);
+}
+sendUserUuid();
 function storeCredentialsAndConnection({ apiKey, backendApi, }) {
     sessionStorage.setItem("sailfishApiKey", apiKey);
     sessionStorage.setItem("sailfishBackendApi", 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");
     }
@@ -148,7 +193,6 @@ export function matchUrlWithWildcard(url, patterns) {
 }
 // Updated XMLHttpRequest interceptor with domain exclusion
 function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
-    console.log("[Sailfish] RUNNING setupXMLHttpRequestInterceptor");
     const originalOpen = XMLHttpRequest.prototype.open;
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
@@ -159,26 +203,22 @@ function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsTo
     ];
     // Intercept open()
     XMLHttpRequest.prototype.open = function (method, url, ...args) {
-        console.log("Sailfish XMLHttpRequest.prototype.open", method, url);
         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", this._requestUrl);
         const url = this._requestUrl;
         if (!url)
             return originalSend.apply(this, args);
         // Skip domain check for excluded domains
         if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
-            console.log(`[XML] [ExcludedDomain] IGNORE --> ${url}`);
             return originalSend.apply(this, args);
         }
         // Check if domain should propagate headers
         const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
             matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
         if (sessionId && shouldPropagateHeader) {
-            console.log(`[XML] [InPropagateDomains] PROPAGATE FOR --> ${url}`);
             try {
                 this.setRequestHeader("X-Sf3-Rid", sessionId);
             }
@@ -186,15 +226,11 @@ function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsTo
                 console.warn(`Could not set X-Sf3-Rid header for ${url}`, e);
             }
         }
-        else {
-            console.log(`[XML] [NOT InPropagateDomains] IGNORE --> ${url}`);
-        }
         return originalSend.apply(this, args);
     };
 }
 // Updated fetch interceptor with exclusion handling
 function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagateHeadersTo = []) {
-    console.log("[Sailfish] RUNNING setupFetchInterceptor");
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
     const combinedIgnoreDomains = [
@@ -217,24 +253,20 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                 url = input.href;
             }
             else {
-                console.log("Unsupported args -->", args);
                 return target.apply(thisArg, args); // Skip unsupported inputs
             }
             // 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);
                 }
             }
             // Check domain exclusion
             if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
-                console.log(`[InIgnoreDomains] IGNORE --> ${url}`);
                 cache.set(url, "ignore");
                 return target.apply(thisArg, args);
             }
@@ -242,18 +274,15 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
             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
     function injectHeader(target, thisArg, args, input, init, sessionId) {
-        console.log("[Sailfish] RUNNING injectHeader");
         if (sessionId) {
             if (input instanceof Request) {
                 // Clone the Request and modify headers
@@ -263,7 +292,6 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                 const modifiedRequest = new Request(clonedRequest, {
                     headers: newHeaders,
                 });
-                console.log(`[modified call] newHeaders --> `, newHeaders);
                 return target.call(thisArg, modifiedRequest, init);
             }
             else {
@@ -272,12 +300,10 @@ function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagat
                 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);
         }
     }