@sailfish-ai/recorder 1.7.35 → 1.7.41

package/dist/segmentHelpers.js

@@ -0,0 +1,150 @@
+import { identify, trackingEvent } from "./sendSailfishMessages";
+function safeParseJson(text) {
+    if (typeof text !== "string" || !text.trim())
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSegmentHost(url) {
+    try {
+        const u = new URL(url, window.location.href);
+        // Recognize any Segment ingestion domain (US default or regional)
+        return (u.hostname === "api.segment.io" || u.hostname.endsWith(".segmentapis.com"));
+    }
+    catch {
+        return false;
+    }
+}
+function pathType(url) {
+    try {
+        const u = new URL(url, window.location.href);
+        const path = u.pathname;
+        // Segment ingestion endpoints for identify and track (short and full paths)
+        if (path.endsWith("/v1/i") ||
+            path === "/i" ||
+            path.endsWith("/v1/identify")) {
+            return "identify";
+        }
+        if (path.endsWith("/v1/t") || path === "/t" || path.endsWith("/v1/track")) {
+            return "track";
+        }
+    }
+    catch {
+        // URL parsing failed
+    }
+    return null;
+}
+/**
+ * Try to capture Segment payloads and mirror them to our identify/trackingEvent calls.
+ * - For /v1/i: call identify(userId, traits)
+ * - For /v1/t: call trackingEvent({ event, properties })
+ */
+export async function maybeCaptureSegment(url, bodyCandidate) {
+    if (!isSegmentHost(url))
+        return;
+    const type = pathType(url);
+    if (!type)
+        return;
+    // Body is usually text/plain JSON from browsers
+    let json;
+    if (typeof bodyCandidate === "string") {
+        json = safeParseJson(bodyCandidate);
+    }
+    else if (bodyCandidate &&
+        typeof bodyCandidate.text === "function") {
+        // BodyInit like Request/Blob/Response with .text(): read safely
+        try {
+            const txt = await bodyCandidate.text();
+            json = safeParseJson(txt);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    else if (bodyCandidate instanceof URLSearchParams) {
+        // Segment won't send this way normally, but no harm
+        json = safeParseJson(bodyCandidate.toString());
+    }
+    if (!json || typeof json !== "object")
+        return;
+    if (type === "identify") {
+        const userId = json.userId ?? json.user_id;
+        const traits = (json.traits ?? {});
+        if (typeof userId === "string" && userId) {
+            identify(userId, traits, false);
+        }
+    }
+    else if (type === "track") {
+        const event = json.event ?? json.name;
+        const properties = (json.properties ?? {});
+        if (typeof event === "string" && event) {
+            trackingEvent({ event, properties });
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Convenience wrappers used by interceptors (centralized here to avoid dupes)
+// ─────────────────────────────────────────────────────────────────────────────
+export function maybeMirrorSegmentFromXhr(url, sendArg) {
+    try {
+        if (!url)
+            return;
+        if (typeof sendArg === "string") {
+            void maybeCaptureSegment(url, sendArg);
+        }
+    }
+    catch {
+        /* noop */
+    }
+}
+export async function maybeMirrorSegmentFromFetchRequest(req) {
+    try {
+        const url = req?.url;
+        if (!url)
+            return;
+        // Clone so we don't consume the original body
+        const preview = req.clone();
+        const text = await preview.text().catch(() => undefined);
+        if (typeof text === "string") {
+            await maybeCaptureSegment(url, text);
+        }
+    }
+    catch {
+        /* noop */
+    }
+}
+export async function maybeMirrorSegmentFromFetchUrlAndInit(input, init) {
+    try {
+        const url = String(input);
+        const body = init?.body;
+        if (typeof body === "string") {
+            await maybeCaptureSegment(url, body);
+        }
+        else if (body && typeof body.text === "function") {
+            const txt = await body.text().catch(() => undefined);
+            if (typeof txt === "string") {
+                await maybeCaptureSegment(url, txt);
+            }
+        }
+    }
+    catch {
+        /* noop */
+    }
+}
+export async function maybeMirrorSegmentFromFetchArgs(input, init) {
+    try {
+        if (input instanceof Request) {
+            await maybeMirrorSegmentFromFetchRequest(input);
+        }
+        else if (typeof input === "string" || input instanceof URL) {
+            await maybeMirrorSegmentFromFetchUrlAndInit(input, init);
+        }
+    }
+    catch {
+        /* noop */
+    }
+}

package/dist/sendSailfishMessages.js

@@ -1,3 +1,4 @@
+import { nowTimestamp } from "./utils";
 import { sendMessage } from "./websocket";
 // Internal state to track the last sent messages
 let lastIdentifyMessage = null;
@@ -35,3 +36,12 @@ export function addOrUpdateMetadata(metadata) {
     lastMetadataMessage = metadata;
     sendMessage(message);
 }
+// Function to send trackingEvent message
+export function trackingEvent(trackingData) {
+    const message = {
+        type: "trackingEvent",
+        trackingData,
+        timestamp: nowTimestamp(),
+    };
+    sendMessage(message);
+}

package/dist/types/inAppReportIssueModal.d.ts

@@ -1,3 +1,9 @@
+export declare const ReportIssueContext: {
+    resolveSessionId: (() => string) | null;
+    apiKey: string | null;
+    backendApi: string | null;
+    triageBaseUrl: string;
+};
 export declare function setupIssueReporting(options: {
     apiKey: string;
     backendApi: string;

package/dist/types/segmentHelpers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Try to capture Segment payloads and mirror them to our identify/trackingEvent calls.
+ * - For /v1/i: call identify(userId, traits)
+ * - For /v1/t: call trackingEvent({ event, properties })
+ */
+export declare function maybeCaptureSegment(url: string, bodyCandidate?: unknown): Promise<void>;
+export declare function maybeMirrorSegmentFromXhr(url: string | null, sendArg: unknown): void;
+export declare function maybeMirrorSegmentFromFetchRequest(req: Request): Promise<void>;
+export declare function maybeMirrorSegmentFromFetchUrlAndInit(input: string | URL, init?: RequestInit): Promise<void>;
+export declare function maybeMirrorSegmentFromFetchArgs(input: Request | string | URL, init?: RequestInit): Promise<void>;

package/dist/types/sendSailfishMessages.d.ts

@@ -1,2 +1,3 @@
 export declare function identify(userId: string, traits?: Record<string, any>, overwrite?: boolean): void;
 export declare function addOrUpdateMetadata(metadata: Record<string, any>): void;
+export declare function trackingEvent(trackingData: Record<string, any>): void;

package/dist/types/utils.d.ts

@@ -4,3 +4,5 @@ export declare function buildBatches<T extends {
     };
 }>(queue: T[], getSize: (item: T) => number, maxBytes: number): T[][];
 export declare function eventSize(event: any): number;
+declare let nowTimestamp: () => number;
+export { nowTimestamp };

package/dist/utils.js

@@ -39,3 +39,10 @@ export function buildBatches(queue, getSize, maxBytes) {
 export function eventSize(event) {
     return new Blob([JSON.stringify(event)]).size;
 }
+// guard against old third party libraries which redefine Date.now
+let nowTimestamp = Date.now;
+if (!( /*@__PURE__*//[1-9][0-9]{12}/.test(Date.now().toString()))) {
+    // they have already redefined it! use a fallback
+    nowTimestamp = () => new Date().getTime();
+}
+export { nowTimestamp };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.7.35",
+  "version": "1.7.41",
   "publishPublicly": true,
   "main": "dist/sailfish-recorder.umd.js",
   "types": "dist/types/index.d.ts",