@sailfish-ai/recorder 1.0.0-alpha-1

package/dist/eventCache.js

@@ -0,0 +1,26 @@
+let eventCache = [];
+export function cacheEvents(event) {
+    eventCache.push(event);
+}
+export function sendCachedEvents(webSocket) {
+    if (eventCache.length > 0 && webSocket.readyState === WebSocket.OPEN) {
+        const message = {
+            type: "events",
+            events: eventCache,
+        };
+        webSocket.send(JSON.stringify(message));
+        eventCache = [];
+    }
+}
+export function sendRecordingEvents(webSocket, sessionId) {
+    if (webSocket && webSocket.readyState === WebSocket.OPEN && sessionId) {
+        if (eventCache.length > 0) {
+            const message = {
+                type: "events",
+                events: eventCache,
+            };
+            webSocket.send(JSON.stringify(message));
+            eventCache = [];
+        }
+    }
+}

package/dist/graphql.js

@@ -0,0 +1,38 @@
+export function sendGraphQLRequest(operationName, query, variables) {
+    return fetch(`${variables["backendApi"]}/graphql/?apiKey=${variables["apiKey"]}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ operationName, query, variables }),
+    }).then((response) => response.json());
+}
+export function fetchCaptureSettings(apiKey, backendApi) {
+    return sendGraphQLRequest("GetCaptureSettingsFromApiKey", `
+    query GetCaptureSettingsFromApiKey($apiKey: String!) {
+      captureSettingsFromApiKey(apiKey: $apiKey) {
+        recordCanvas
+        recordCrossOriginIframes
+        collectFonts
+        inlineImages
+        recordPassword
+        recordRealName
+        recordCreditCardInfo
+        recordSsn
+        recordDob
+        sampling
+      }
+    }
+  `, { apiKey, backendApi });
+}
+export function startRecordingSession(apiKey, recordingId, backendApi) {
+    return sendGraphQLRequest("StartSession", `mutation StartSession($apiKey: UUID!, $recordingSessionId: UUID!) {
+      startRecordingSession(companyApiKey: $apiKey, sessionId: $recordingSessionId) {
+        id
+      }
+    }`, {
+        apiKey,
+        recordingSessionId: recordingId,
+        backendApi,
+    });
+}

package/dist/index.js

@@ -0,0 +1,85 @@
+import { v4 as uuidv4 } from "uuid";
+import { sendRecordingEvents } from "./eventCache";
+import { fetchCaptureSettings, startRecordingSession } from "./graphql";
+import { initializeRecording } from "./recording";
+import { initializeWebSocket } from "./websocket";
+// Default Settings
+export const DEFAULT_DOMAINS_TO_IGNORE = [];
+export const DEFAULT_CAPTURE_SETTINGS = {
+    recordCanvas: false,
+    recordCrossOriginIframes: false,
+    collectFonts: false,
+    inlineImages: false,
+    recordPassword: false,
+    recordRealName: true,
+    recordCreditCardInfo: false,
+    recordSsn: false,
+    recordDob: false,
+    sampling: {},
+};
+export const DEFAULT_CONSOLE_RECORDING_SETTINGS = {
+    level: ["info", "log", "warn", "error"],
+    lengthThreshold: 10000,
+    stringifyOptions: {
+        stringLengthLimit: 1000,
+        numOfKeysLimit: 20,
+        depthOfLimit: 1,
+    },
+    logger: "console",
+};
+export const DEFAULT_NETWORK_CAPTURE_SETTINGS = {
+    initiatorTypes: ["fetch", "xmlhttprequest"],
+    ignoreRequestFn: (request) => {
+        const domain = extractHostname(request.url);
+        return DEFAULT_DOMAINS_TO_IGNORE.includes(domain);
+    },
+    recordHeaders: true,
+    ignoreHeaders: {
+        request: ["authorization"],
+        response: [],
+    },
+    ignoreBodyParts: {
+        request: ["variables.token"],
+        response: ["data.token"],
+    },
+    recordBody: true,
+    recordInitialRequests: false,
+};
+// Functions
+export async function startRecording({ apiKey, backendApi, }) {
+    const sessionId = uuidv4(); // Use the same value for recordingId and sessionId
+    try {
+        const captureSettingsResponse = await fetchCaptureSettings(apiKey, backendApi);
+        const captureSettings = captureSettingsResponse.data?.captureSettingsFromApiKey ||
+            DEFAULT_CAPTURE_SETTINGS;
+        const sessionResponse = await startRecordingSession(apiKey, sessionId, backendApi);
+        if (sessionResponse.data?.startRecordingSession) {
+            const webSocket = initializeWebSocket(backendApi, apiKey, sessionId);
+            initializeRecording(captureSettings, DEFAULT_CONSOLE_RECORDING_SETTINGS, DEFAULT_NETWORK_CAPTURE_SETTINGS, backendApi, apiKey, sessionId);
+            setInterval(() => sendRecordingEvents(webSocket, sessionId), 10000);
+        }
+        else {
+            console.error("Failed to start recording session:", sessionResponse.errors || sessionResponse);
+        }
+    }
+    catch (error) {
+        console.error("Error starting recording:", error);
+    }
+}
+function extractHostname(url) {
+    let hostname = url.indexOf("//") > -1 ? url.split("/")[2] : url.split("/")[0];
+    hostname = hostname.split(":")[0];
+    hostname = hostname.split("?")[0];
+    return hostname;
+}
+function getWebSocketHost(url) {
+    const parser = document.createElement("a");
+    parser.href = url;
+    return `${parser.hostname}${parser.port ? `:${parser.port}` : ""}`;
+}
+// Re-export from other modules
+export * from "./eventCache";
+export * from "./graphql";
+export * from "./recording";
+export * from "./types";
+export * from "./websocket";

package/dist/recording.js

@@ -0,0 +1,34 @@
+import { record } from "@sailfish-rrweb/record";
+import { getRecordConsolePlugin, } from "@sailfish-rrweb/rrweb-plugin-console-record";
+import { getRecordNetworkPlugin, } from "@sailfish-rrweb/rrweb-plugin-network-record";
+import { cacheEvents, sendRecordingEvents } from "./eventCache";
+import { initializeWebSocket } from "./websocket";
+const MASK_CLASS = "sailfishSanitize";
+const DEFAULT_DOMAINS_TO_IGNORE = [];
+function maskInputFn(text, node) {
+    // The maskInputFn logic here
+    return text; // Placeholder return
+}
+export async function initializeRecording(captureSettings, // TODO - Sibyl launch - replace type
+consoleRecordSettings, networkRecordSettings, backendApi, apiKey, sessionId) {
+    try {
+        record({
+            emit(event) {
+                cacheEvents(event);
+            },
+            plugins: [
+                getRecordConsolePlugin(consoleRecordSettings),
+                getRecordNetworkPlugin(networkRecordSettings),
+            ],
+            maskInputOptions: { text: true }, // Fix the incorrect property name
+            maskInputFn,
+            maskTextClass: MASK_CLASS,
+            ...captureSettings,
+        });
+        const webSocket = initializeWebSocket(backendApi, apiKey, sessionId);
+        setInterval(() => sendRecordingEvents(webSocket, sessionId), 10000);
+    }
+    catch (error) {
+        console.error("Error importing plugins!", error);
+    }
+}