@sailfish-ai/recorder 1.7.35 → 1.7.42

package/dist/index.js

@@ -1,4 +1,11 @@
 const DEBUG = import.meta.env.VITE_DEBUG ? import.meta.env.VITE_DEBUG : false;
+// ── SSR guards ─────────────────────────────────────────
+const HAS_WINDOW = typeof globalThis !== "undefined" &&
+    typeof globalThis.window !== "undefined";
+const HAS_DOCUMENT = typeof globalThis !== "undefined" &&
+    typeof globalThis.document !== "undefined";
+const HAS_LOCAL_STORAGE = typeof globalThis !== "undefined" && "localStorage" in globalThis;
+const HAS_SESSION_STORAGE = typeof globalThis !== "undefined" && "sessionStorage" in globalThis;
 // import { NetworkRecordOptions } from "@sailfish-rrweb/rrweb-plugin-network-record";
 import { v4 as uuidv4 } from "uuid";
 import { NetworkRequestEventId, STATIC_EXTENSIONS, xSf3RidHeader, } from "./constants";
@@ -57,16 +64,18 @@ dynamicExcludedHosts.add = (host) => {
     }
     // 4. Persist wrapper to localStorage
     try {
-        // TODO decouple into two logical pieces
-        const wrapper = {
-            version: STORAGE_VERSION,
-            entries: {},
-        };
-        const now = Date.now();
-        for (const p of dynamicExcludedHosts) {
-            wrapper.entries[p] = now;
+        if (HAS_LOCAL_STORAGE) {
+            // TODO decouple into two logical pieces
+            const wrapper = {
+                version: STORAGE_VERSION,
+                entries: {},
+            };
+            const now = Date.now();
+            for (const p of dynamicExcludedHosts) {
+                wrapper.entries[p] = now;
+            }
+            localStorage.setItem(DYNAMIC_EXCLUDED_HOSTS_KEY, JSON.stringify(wrapper));
         }
-        localStorage.setItem(DYNAMIC_EXCLUDED_HOSTS_KEY, JSON.stringify(wrapper));
     }
     catch (e) {
         if (DEBUG)
@@ -85,35 +94,37 @@ dynamicPassedHosts.add = (host) => {
     }
     // 1. Persist wrapper to localStorage (update timestamp unconditionally)
     try {
-        // TODO decouple into two logical pieces
-        const raw = localStorage.getItem(DYNAMIC_PASSED_HOSTS_KEY);
-        let wrapper;
-        if (!raw) {
-            wrapper = { version: STORAGE_VERSION, entries: {} };
-        }
-        else {
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                // migrate old array → wrapper
-                wrapper = {
-                    version: STORAGE_VERSION,
-                    entries: Object.fromEntries(parsed.map((h) => [h, Date.now()])),
-                };
-            }
-            else if (parsed &&
-                typeof parsed === "object" &&
-                "entries" in parsed &&
-                typeof parsed.entries === "object") {
-                wrapper = parsed;
+        if (HAS_LOCAL_STORAGE) {
+            // TODO decouple into two logical pieces
+            const raw = localStorage.getItem(DYNAMIC_PASSED_HOSTS_KEY);
+            let wrapper;
+            if (!raw) {
+                wrapper = { version: STORAGE_VERSION, entries: {} };
             }
             else {
-                wrapper = { version: STORAGE_VERSION, entries: {} };
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed)) {
+                    // migrate old array → wrapper
+                    wrapper = {
+                        version: STORAGE_VERSION,
+                        entries: Object.fromEntries(parsed.map((h) => [h, Date.now()])),
+                    };
+                }
+                else if (parsed &&
+                    typeof parsed === "object" &&
+                    "entries" in parsed &&
+                    typeof parsed.entries === "object") {
+                    wrapper = parsed;
+                }
+                else {
+                    wrapper = { version: STORAGE_VERSION, entries: {} };
+                }
             }
+            // always set/update the timestamp
+            wrapper.entries[cleaned] = Date.now();
+            wrapper.version = STORAGE_VERSION;
+            localStorage.setItem(DYNAMIC_PASSED_HOSTS_KEY, JSON.stringify(wrapper));
         }
-        // always set/update the timestamp
-        wrapper.entries[cleaned] = Date.now();
-        wrapper.version = STORAGE_VERSION;
-        localStorage.setItem(DYNAMIC_PASSED_HOSTS_KEY, JSON.stringify(wrapper));
     }
     catch (e) {
         if (DEBUG)
@@ -129,6 +140,8 @@ dynamicPassedHosts.add = (host) => {
  * Notify the backend of the updated dynamicExcludedHosts
  */
 function updateExcludedHostsStorageAndBackend(dynamicExcludedHosts) {
+    if (!HAS_SESSION_STORAGE)
+        return;
     const apiKeyForUpdate = sessionStorage.getItem(SF_API_KEY_FOR_UPDATE) || "";
     const apiForUpdate = sessionStorage.getItem(SF_BACKEND_API) || "";
     if (!apiForUpdate) {
@@ -190,60 +203,64 @@ export function consolidateDynamicExclusions(hostPathSet, threshold = 3) {
     return newSet;
 }
 // 2️⃣ Load & evict old entries (>7 days) + version check for Excluded
-(() => {
-    const stored = localStorage.getItem(DYNAMIC_EXCLUDED_HOSTS_KEY);
-    if (!stored)
-        return;
-    try {
-        const wrapper = JSON.parse(stored);
-        // if it's from an old version, drop it
-        if (wrapper.version !== STORAGE_VERSION) {
-            localStorage.removeItem(DYNAMIC_EXCLUDED_HOSTS_KEY);
+if (HAS_LOCAL_STORAGE) {
+    (() => {
+        const stored = localStorage.getItem(DYNAMIC_EXCLUDED_HOSTS_KEY);
+        if (!stored)
             return;
-        }
-        const now = Date.now();
-        const valid = {};
-        for (const [host, ts] of Object.entries(wrapper.entries)) {
-            if (now - ts < 7 * 24 * 60 * 60 * 1000) {
-                dynamicExcludedHosts.add(host);
-                valid[host] = ts;
+        try {
+            const wrapper = JSON.parse(stored);
+            // if it's from an old version, drop it
+            if (wrapper.version !== STORAGE_VERSION) {
+                localStorage.removeItem(DYNAMIC_EXCLUDED_HOSTS_KEY);
+                return;
+            }
+            const now = Date.now();
+            const valid = {};
+            for (const [host, ts] of Object.entries(wrapper.entries)) {
+                if (now - ts < 7 * 24 * 60 * 60 * 1000) {
+                    dynamicExcludedHosts.add(host);
+                    valid[host] = ts;
+                }
             }
+            localStorage.setItem(DYNAMIC_EXCLUDED_HOSTS_KEY, JSON.stringify({ version: STORAGE_VERSION, entries: valid }));
         }
-        localStorage.setItem(DYNAMIC_EXCLUDED_HOSTS_KEY, JSON.stringify({ version: STORAGE_VERSION, entries: valid }));
-    }
-    catch (e) {
-        if (DEBUG)
-            console.warn("Failed to parse dynamicExcludedHosts:", e);
-        localStorage.removeItem(DYNAMIC_EXCLUDED_HOSTS_KEY);
-    }
-})();
+        catch (e) {
+            if (DEBUG)
+                console.warn("Failed to parse dynamicExcludedHosts:", e);
+            localStorage.removeItem(DYNAMIC_EXCLUDED_HOSTS_KEY);
+        }
+    })();
+}
 // 3️⃣ Load & evict old entries (>7 days) + version check for Passed
-(() => {
-    const stored = localStorage.getItem(DYNAMIC_PASSED_HOSTS_KEY);
-    if (!stored)
-        return;
-    try {
-        const wrapper = JSON.parse(stored);
-        if (wrapper.version !== STORAGE_VERSION) {
-            localStorage.removeItem(DYNAMIC_PASSED_HOSTS_KEY);
+if (HAS_LOCAL_STORAGE) {
+    (() => {
+        const stored = localStorage.getItem(DYNAMIC_PASSED_HOSTS_KEY);
+        if (!stored)
             return;
-        }
-        const now = Date.now();
-        const valid = {};
-        for (const [host, ts] of Object.entries(wrapper.entries)) {
-            if (now - ts < 7 * 24 * 60 * 60 * 1000) {
-                dynamicPassedHosts.add(host);
-                valid[host] = ts;
+        try {
+            const wrapper = JSON.parse(stored);
+            if (wrapper.version !== STORAGE_VERSION) {
+                localStorage.removeItem(DYNAMIC_PASSED_HOSTS_KEY);
+                return;
+            }
+            const now = Date.now();
+            const valid = {};
+            for (const [host, ts] of Object.entries(wrapper.entries)) {
+                if (now - ts < 7 * 24 * 60 * 60 * 1000) {
+                    dynamicPassedHosts.add(host);
+                    valid[host] = ts;
+                }
             }
+            localStorage.setItem(DYNAMIC_PASSED_HOSTS_KEY, JSON.stringify({ version: STORAGE_VERSION, entries: valid }));
         }
-        localStorage.setItem(DYNAMIC_PASSED_HOSTS_KEY, JSON.stringify({ version: STORAGE_VERSION, entries: valid }));
-    }
-    catch (e) {
-        if (DEBUG)
-            console.warn("Failed to parse dynamicPassedHosts:", e);
-        localStorage.removeItem(DYNAMIC_PASSED_HOSTS_KEY);
-    }
-})();
+        catch (e) {
+            if (DEBUG)
+                console.warn("Failed to parse dynamicPassedHosts:", e);
+            localStorage.removeItem(DYNAMIC_PASSED_HOSTS_KEY);
+        }
+    })();
+}
 const ActionType = {
     PROPAGATE: "propagate",
     IGNORE: "ignore",
@@ -266,7 +283,7 @@ export const DEFAULT_CONSOLE_RECORDING_SETTINGS = {
     stringifyOptions: {
         stringLengthLimit: 1000,
         numOfKeysLimit: 20,
-        depthOfLimit: 1,
+        depthOfLimit: 4,
     },
     logger: "console",
 };
@@ -342,15 +359,25 @@ function sendTimeZone() {
     sendMessage(message);
 }
 // Send standard information like userDeviceUuid and timeZone
-sendUserDeviceUuid();
-sendTimeZone();
+if (HAS_WINDOW) {
+    sendUserDeviceUuid();
+    sendTimeZone();
+}
 // Function to get or set the device & program UUID in localStorage
 function getOrSetUserDeviceUuid() {
-    let userDeviceUuid = localStorage.getItem("sailfishUserDeviceUuid");
+    let userDeviceUuid = null;
+    if (HAS_LOCAL_STORAGE) {
+        try {
+            userDeviceUuid = localStorage.getItem("sailfishUserDeviceUuid");
+        }
+        catch { }
+    }
     if (!userDeviceUuid) {
         userDeviceUuid = uuidv4();
         try {
-            localStorage.setItem("sailfishUserDeviceUuid", userDeviceUuid);
+            if (HAS_LOCAL_STORAGE) {
+                localStorage.setItem("sailfishUserDeviceUuid", userDeviceUuid);
+            }
         }
         catch { }
     }
@@ -359,6 +386,8 @@ function getOrSetUserDeviceUuid() {
 // Storing the sailfishSessionId in window.name, as window.name retains its value after a page refresh
 // but resets when a new tab (including a duplicated tab) is opened.
 function getOrSetSessionId() {
+    if (!HAS_WINDOW)
+        return uuidv4();
     if (!window.name) {
         window.name = uuidv4();
     }
@@ -371,37 +400,68 @@ function handleVisibilityChange() {
     }
 }
 function clearPageVisitUuid() {
+    if (!HAS_SESSION_STORAGE)
+        return;
     sessionStorage.removeItem("pageVisitUUID");
     sessionStorage.removeItem("prevPageVisitUUID");
 }
 // Initialize event listeners for visibility change and page unload
-document.addEventListener("visibilitychange", handleVisibilityChange);
-// Clearing window.name on refresh to generate and retain a new sessionId
-window.addEventListener("beforeunload", () => {
-    window.name = "";
-    clearPageVisitUuid();
-});
+if (HAS_DOCUMENT) {
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+}
+if (HAS_WINDOW) {
+    window.addEventListener("beforeunload", () => {
+        window.name = "";
+        clearPageVisitUuid();
+    });
+}
 function storeCredentialsAndConnection({ apiKey, backendApi, }) {
+    if (!HAS_SESSION_STORAGE)
+        return;
     sessionStorage.setItem("sailfishApiKey", apiKey);
     sessionStorage.setItem("sailfishBackendApi", backendApi);
 }
 // Utility function to match domains or paths with wildcard support
-export function matchUrlWithWildcard(url, patterns) {
-    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, port } = parsedUrl;
+export function matchUrlWithWildcard(input, patterns) {
+    // Tolerate non-string inputs (Request, URL, etc.); coerce to string when possible.
+    let urlStr;
+    if (typeof input === "string") {
+        urlStr = input;
+    }
+    else if (typeof URL !== "undefined" && input instanceof URL) {
+        urlStr = input.href;
+    }
+    else if (typeof Request !== "undefined" && input instanceof Request) {
+        urlStr = input.url;
+    }
+    else if (input != null && typeof input.toString === "function") {
+        // As per web APIs, fetch/open may accept any object with a stringifier.
+        urlStr = input.toString();
+    }
+    if (!urlStr)
+        return false;
+    // Use WHATWG URL parsing with a base for relative URLs.
+    let parsed;
+    try {
+        const base = typeof window !== "undefined"
+            ? window.location.href
+            : "http://localhost/";
+        parsed = new URL(urlStr, base);
+    }
+    catch {
+        return false; // If we can't parse, just say "no match" instead of throwing.
+    }
+    const { hostname, pathname, port, protocol } = parsed;
+    // Only match http(s) hosts/paths; ignore others like data:, blob:, about:.
+    if (!/^https?:$/.test(protocol))
+        return false;
     // Handle stripping 'www.' and port
     const domain = hostname.startsWith("www.")
         ? hostname.slice(4).toLowerCase()
         : hostname.toLowerCase();
     return patterns.some((pattern) => {
         // Strip any protocol and handle port in the pattern if present
-        const strippedPattern = pattern.replace(/^[a-zA-Z]+:\/\//, "");
+        const strippedPattern = String(pattern || "").replace(/^[a-zA-Z]+:\/\//, "");
         let [patternDomain, patternPath] = strippedPattern.split("/", 2);
         // Handle port in pattern
         let patternPort = "";
@@ -417,14 +477,16 @@ export function matchUrlWithWildcard(url, patterns) {
         // 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) {
+        if (patternPort && port !== patternPort)
             return false;
-        }
-        // Handle subdomain wildcard (*.) to match both base and subdomains
-        if (patternDomain.startsWith("*.") &&
-            (domain === patternDomain.slice(2) ||
-                strippedDomain === patternDomain.slice(2))) {
-            // Check for path match if the pattern includes a path
+        // handle patterns like "*.example.com"
+        if (patternDomain.startsWith("*.")) {
+            const base = patternDomain.slice(2).toLowerCase();
+            const isDomainMatch = domain === base ||
+                strippedDomain === base ||
+                domain.endsWith("." + base);
+            if (!isDomainMatch)
+                return false;
             if (patternPath) {
                 const normalizedPatternPath = patternPath
                     .replace(/\*/g, ".*") // Replace '*' with regex to match any characters
@@ -435,9 +497,8 @@ export function matchUrlWithWildcard(url, patterns) {
             return true; // Domain matched, no path required
         }
         // Check if the domain matches (include check for base domain without www)
-        if (!domainRegex.test(strippedDomain) && !domainRegex.test(domain)) {
+        if (!domainRegex.test(strippedDomain) && !domainRegex.test(domain))
             return false;
-        }
         // If there's a path in the pattern, match the path
         if (patternPath) {
             const normalizedPatternPath = patternPath
@@ -451,7 +512,14 @@ export function matchUrlWithWildcard(url, patterns) {
     });
 }
 function shouldSkipHeadersPropagation(url, domainsToNotPropagateHeaderTo = []) {
-    const urlObj = new URL(url, window.location.href);
+    let urlObj;
+    try {
+        urlObj = new URL(typeof url === "string" ? url : String(url?.url ?? url), window.location.href);
+    }
+    catch {
+        // If we cannot parse, play it safe and do NOT inject headers.
+        return true;
+    }
     // 1️⃣ STATIC ASSET EXCLUSIONS (by comprehensive file extension list)
     for (const ext of STATIC_EXTENSIONS) {
         if (urlObj.pathname.toLowerCase().endsWith(ext)) {

package/dist/notifyEventStore.js

@@ -1,26 +1,80 @@
-import { openDB } from 'idb';
-const DB_NAME = 'leapsNotifyDB';
-const STORE_NAME = 'notifyMessages';
-const dbPromise = openDB(DB_NAME, 1, {
-    upgrade(db) {
-        if (!db.objectStoreNames.contains(STORE_NAME)) {
-            db.createObjectStore(STORE_NAME, { keyPath: 'id', autoIncrement: true });
+// SSR/Edge-safe IndexedDB helpers for notify messages.
+// No top-level access to `indexedDB`. No dependency on `idb` package.
+// On server/edge (no IDB), calls are no-ops / return safe defaults.
+const DB_NAME = "leapsNotifyDB";
+const STORE_NAME = "notifyMessages";
+const DB_VERSION = 1;
+let _dbPromise = null;
+// Narrow feature check that won’t throw in SSR/Edge
+function hasIndexedDB() {
+    return typeof globalThis !== "undefined" && !!globalThis.indexedDB;
+}
+// Lazily open DB only in real browsers. Never at module init.
+function openDb() {
+    if (!hasIndexedDB())
+        return Promise.resolve(null);
+    if (_dbPromise)
+        return _dbPromise;
+    _dbPromise = new Promise((resolve) => {
+        try {
+            const req = globalThis.indexedDB.open(DB_NAME, DB_VERSION);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    db.createObjectStore(STORE_NAME, {
+                        keyPath: "id",
+                        autoIncrement: true,
+                    });
+                }
+            };
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => resolve(null); // fail closed, don’t throw
+            req.onblocked = () => resolve(null); // avoid hanging if blocked
+        }
+        catch {
+            resolve(null);
+        }
+    });
+    return _dbPromise;
+}
+async function withStore(mode, fn) {
+    const db = await openDb();
+    if (!db)
+        return null;
+    return new Promise((resolve) => {
+        try {
+            const tx = db.transaction(STORE_NAME, mode);
+            const store = tx.objectStore(STORE_NAME);
+            Promise.resolve(fn(store))
+                .then((result) => {
+                tx.oncomplete = () => resolve(result);
+                tx.onerror = () => resolve(null);
+            })
+                .catch(() => resolve(null));
+        }
+        catch {
+            resolve(null);
         }
-    },
-});
+    });
+}
+// ── Public API (safe for SSR/Edge) ─────────────────────────────────────────────
 export async function saveNotifyMessageToIDB(message) {
-    const db = await dbPromise;
-    const tx = db.transaction(STORE_NAME, 'readwrite');
-    await tx.store.add({ value: message });
-    await tx.done;
+    await withStore("readwrite", (store) => {
+        store.add({ value: message });
+    });
 }
 export async function getAllNotifyMessages() {
-    const db = await dbPromise;
-    return await db.getAll(STORE_NAME);
+    const result = await withStore("readonly", (store) => {
+        return new Promise((resolve) => {
+            const req = store.getAll();
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => resolve([]);
+        });
+    });
+    return result ?? []; // SSR/Edge → []
 }
 export async function deleteNotifyMessageById(id) {
-    const db = await dbPromise;
-    const tx = db.transaction(STORE_NAME, 'readwrite');
-    await tx.store.delete(id);
-    await tx.done;
+    await withStore("readwrite", (store) => {
+        store.delete(id);
+    });
 }