@keverdjs/fraud-sdk-angular 1.1.0 → 2.0.0

package/dist/index.mjs

@@ -2801,11 +2801,19 @@ var PageInteractionCollector = class {
 };
 
 // ../fraud-sdk/src/core/sdk.ts
+var DEFAULT_ENDPOINT = "https://api.keverd.com";
 var KeverdSDK = class {
+  // Maximum 10 minutes of collection
   constructor() {
     this.config = null;
     this.isInitialized = false;
     this.sessionId = null;
+    this.ghostInterval = null;
+    this.ghostStartTime = null;
+    this.ghostSignalCount = 0;
+    this.MIN_GHOST_SIGNALS = 10;
+    // Collect at least 10 signals (5 minutes of data)
+    this.MAX_GHOST_COLLECTION_TIME = 10 * 60 * 1e3;
     this.deviceCollector = new DeviceCollector();
     this.behavioralCollector = new BehavioralCollector();
     this.fingerprintManager = new FingerprintManager();
@@ -2828,12 +2836,10 @@ var KeverdSDK = class {
     if (typeof config === "string") {
       this.config = {
         apiKey: config,
-        endpoint: "https://api.keverd.com",
         debug: false
       };
     } else {
       this.config = {
-        endpoint: "https://api.keverd.com",
         debug: false,
         ...config
       };
@@ -2844,10 +2850,115 @@ var KeverdSDK = class {
     this.sessionId = this.generateSessionId();
     this.isInitialized = true;
     if (this.config.debug) {
-      console.log("[Keverd SDK] Initialized successfully", {
-        endpoint: this.config.endpoint
+      console.log("[Keverd SDK] Initialized successfully");
+    }
+    this.startSession().catch(() => {
+    });
+    this.startGhostSignalCollection();
+  }
+  startGhostSignalCollection() {
+    if (this.ghostInterval) return;
+    if (!this.config) return;
+    this.ghostStartTime = Date.now();
+    this.ghostSignalCount = 0;
+    const intervalMs = 3e4;
+    const sendGhostSignal = () => {
+      const now = Date.now();
+      const totalCollectionTime = this.ghostStartTime ? now - this.ghostStartTime : 0;
+      const hasEnoughSignals = this.ghostSignalCount >= this.MIN_GHOST_SIGNALS;
+      const exceededMaxTime = totalCollectionTime >= this.MAX_GHOST_COLLECTION_TIME;
+      if (hasEnoughSignals || exceededMaxTime) {
+        if (this.config?.debug) {
+          console.log(`[Keverd SDK] Ghost collection complete: ${this.ghostSignalCount} signals, ${Math.round(totalCollectionTime / 1e3)}s elapsed`);
+        }
+        this.stopGhostSignalCollection();
+        return;
+      }
+      const durationMs = this.ghostStartTime ? now - this.ghostStartTime : intervalMs;
+      this.sendGhostSignals(durationMs).catch((err) => {
+        if (this.config?.debug) {
+          console.debug("[Keverd SDK] Ghost signals upload failed:", err);
+        }
       });
+      this.ghostSignalCount++;
+      this.ghostStartTime = now;
+    };
+    setTimeout(() => {
+      sendGhostSignal();
+      this.ghostInterval = setInterval(() => {
+        sendGhostSignal();
+      }, intervalMs);
+    }, intervalMs);
+  }
+  stopGhostSignalCollection() {
+    if (this.ghostInterval) {
+      clearInterval(this.ghostInterval);
+      this.ghostInterval = null;
+      this.ghostStartTime = null;
+    }
+  }
+  async sendGhostSignals(durationMs) {
+    if (!this.isInitialized || !this.config) return;
+    const deviceInfo = this.deviceCollector.collect();
+    const behavioralData = this.behavioralCollector.getData();
+    const fingerprintData = await this.fingerprintManager.collect();
+    const fingerprintjsData = {
+      visitorId: fingerprintData.visitorId,
+      confidence: fingerprintData.confidence,
+      components: fingerprintData.components
+    };
+    const privacySignals = this.privacySignalCollector.collect();
+    const browserCapabilities = this.browserCapabilityCollector.collect();
+    const hardwareSignals = this.hardwareSignalCollector.collect();
+    const formInteractions = this.formInteractionCollector.getData();
+    const mouseSignals = this.behavioralCollector.getMouseSignals();
+    const keyboardSignals = this.behavioralCollector.getKeyboardSignals();
+    const pageInteractions = this.pageInteractionCollector.getData();
+    const networkSignals = {
+      connectionType: hardwareSignals.connectionType || void 0,
+      effectiveType: hardwareSignals.effectiveType || void 0,
+      downlink: hardwareSignals.downlink || void 0,
+      rtt: hardwareSignals.rtt || void 0,
+      saveData: hardwareSignals.saveData || void 0
+    };
+    const sessionInfo = {
+      sessionId: this.sessionId || void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const request = {
+      userId: this.config.userId,
+      device: deviceInfo,
+      session: sessionInfo,
+      behavioral: behavioralData,
+      duration_ms: durationMs,
+      fingerprintjs: fingerprintjsData || void 0,
+      privacySignals,
+      browserCapabilities,
+      hardwareSignals,
+      formInteractions,
+      mouseSignals,
+      keyboardSignals,
+      pageInteractions,
+      networkSignals,
+      useCase: "ghost"
+    };
+    const url = `${DEFAULT_ENDPOINT}/fingerprint/ghost`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-SDK-Source": "javascript"
+    };
+    const apiKey = this.config.apiKey;
+    if (apiKey) {
+      headers["x-keverd-key"] = apiKey;
+      headers["X-API-KEY"] = apiKey;
+      headers["Authorization"] = `Bearer ${apiKey}`;
     }
+    await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    }).catch(() => {
+    });
   }
   /**
    * Get visitor data (fingerprint and risk assessment)
@@ -3033,8 +3144,7 @@ var KeverdSDK = class {
     if (options.changeType) {
       request.changeType = options.changeType;
     }
-    const endpoint = this.config.endpoint || "https://api.keverd.com";
-    const url = `${endpoint}/fingerprint/verify/${useCase}`;
+    const url = `${DEFAULT_ENDPOINT}/fingerprint/verify/${useCase}`;
     const headers = {
       "Content-Type": "application/json",
       "X-SDK-Source": "javascript"
@@ -3064,8 +3174,7 @@ var KeverdSDK = class {
     if (!this.config) {
       throw new Error("SDK not initialized");
     }
-    const endpoint = this.config.endpoint || "https://api.keverd.com";
-    const url = `${endpoint}/fingerprint/score`;
+    const url = `${DEFAULT_ENDPOINT}/fingerprint/score`;
     const headers = {
       "Content-Type": "application/json",
       "X-SDK-Source": "javascript"
@@ -3095,15 +3204,215 @@ var KeverdSDK = class {
   generateSessionId() {
     return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   }
+  /**
+   * Detect browser name from user agent
+   */
+  _detectBrowser() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Chrome")) return "Chrome";
+    if (ua.includes("Firefox")) return "Firefox";
+    if (ua.includes("Safari") && !ua.includes("Chrome")) return "Safari";
+    if (ua.includes("Edge")) return "Edge";
+    if (ua.includes("Opera")) return "Opera";
+    return void 0;
+  }
+  /**
+   * Detect OS from user agent
+   */
+  _detectOS() {
+    const ua = navigator.userAgent;
+    if (ua.includes("Windows")) return "Windows";
+    if (ua.includes("Mac OS")) return "macOS";
+    if (ua.includes("Linux")) return "Linux";
+    if (ua.includes("Android")) return "Android";
+    if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+    return void 0;
+  }
+  /**
+   * Start a new session (called automatically on init, but can be called manually)
+   */
+  async startSession(userId, deviceHash, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    if (!this.sessionId) {
+      this.sessionId = this.generateSessionId();
+    }
+    try {
+      const url = `${DEFAULT_ENDPOINT}/dashboard/sessions/start`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const deviceInfo = this.deviceCollector.collect();
+      await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          session_id: this.sessionId,
+          user_id: userId || this.config.userId,
+          device_hash: deviceHash || deviceInfo.fingerprint,
+          metadata: metadata || {},
+          user_agent: navigator.userAgent,
+          browser: this._detectBrowser(),
+          os: this._detectOS(),
+          platform: "web",
+          sdk_type: "web",
+          sdk_source: "javascript"
+        })
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session started: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to start session on server:", error);
+      }
+    }
+  }
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${DEFAULT_ENDPOINT}/dashboard/sessions/${this.sessionId}/end`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session ended: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to end session on server:", error);
+      }
+    }
+  }
+  /**
+   * Pause the current session (e.g., when app goes to background)
+   */
+  async pauseSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${DEFAULT_ENDPOINT}/dashboard/sessions/${this.sessionId}/pause`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session paused: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to pause session on server:", error);
+      }
+    }
+  }
+  /**
+   * Resume a paused session (e.g., when app comes to foreground)
+   */
+  async resumeSession() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return;
+    }
+    try {
+      const url = `${DEFAULT_ENDPOINT}/dashboard/sessions/${this.sessionId}/resume`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      await fetch(url, {
+        method: "POST",
+        headers
+      });
+      if (this.config.debug) {
+        console.log(`[Keverd SDK] Session resumed: ${this.sessionId}`);
+      }
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to resume session on server:", error);
+      }
+    }
+  }
+  /**
+   * Get current session status
+   */
+  async getSessionStatus() {
+    if (!this.isInitialized || !this.config || !this.sessionId) {
+      return null;
+    }
+    try {
+      const url = `${DEFAULT_ENDPOINT}/dashboard/sessions/${this.sessionId}/status`;
+      const headers = {};
+      const apiKey = this.config.apiKey;
+      if (apiKey) {
+        headers["x-keverd-key"] = apiKey;
+        headers["X-API-KEY"] = apiKey;
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const response = await fetch(url, {
+        method: "GET",
+        headers
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      if (this.config.debug) {
+        console.warn("[Keverd SDK] Failed to get session status:", error);
+      }
+      return null;
+    }
+  }
   /**
    * Destroy the SDK instance
    */
-  destroy() {
+  async destroy() {
+    if (this.sessionId) {
+      await this.endSession();
+    }
     this.behavioralCollector.stop();
     this.formInteractionCollector.stop();
     this.pageInteractionCollector.stop();
     this.fingerprintManager.clearCache();
     this.isInitialized = false;
+    this.stopGhostSignalCollection();
+    this.ghostSignalCount = 0;
     if (this.config?.debug) {
       console.log("[Keverd SDK] Destroyed");
     }
@@ -3143,22 +3452,20 @@ var KeverdService = class {
       throw new Error("Keverd SDK: apiKey is required");
     }
     this.config = {
-      endpoint: config.endpoint || this.getDefaultEndpoint(),
       debug: false,
       ...config
     };
     Keverd.init({
       apiKey: this.config.apiKey,
-      endpoint: this.config.endpoint,
       userId: this.config.userId,
       debug: this.config.debug || false
     });
     this.isInitialized = true;
     if (this.config.debug) {
-      console.log("[Keverd SDK] Initialized successfully", {
-        endpoint: this.config.endpoint
-      });
+      console.log("[Keverd SDK] Initialized successfully");
     }
+    Keverd.startSession().catch(() => {
+    });
   }
   /**
    * Get visitor data (fingerprint and risk assessment)
@@ -3223,22 +3530,115 @@ var KeverdService = class {
       recommendedAction: response.recommended_action
     };
   }
-  /**
-   * Get default endpoint
-   */
-  getDefaultEndpoint() {
-    return "https://api.keverd.com";
-  }
   /**
    * Generate a session ID
    */
   generateSessionId() {
     return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   }
+  /**
+   * Start a new session (called automatically on init, but can be called manually)
+   */
+  startSession(userId, deviceHash, metadata) {
+    if (!this.isInitialized || !this.config) {
+      return throwError(() => ({
+        message: "Keverd SDK not initialized. Call init() first.",
+        code: "SDK_NOT_INITIALIZED"
+      }));
+    }
+    return from(Keverd.startSession(userId, deviceHash, metadata)).pipe(
+      catchError((error) => {
+        if (this.config?.debug) {
+          console.warn("[Keverd SDK] Failed to start session:", error);
+        }
+        return throwError(() => error);
+      })
+    );
+  }
+  /**
+   * End the current session
+   */
+  endSession() {
+    if (!this.isInitialized || !this.config) {
+      return throwError(() => ({
+        message: "Keverd SDK not initialized. Call init() first.",
+        code: "SDK_NOT_INITIALIZED"
+      }));
+    }
+    return from(Keverd.endSession()).pipe(
+      catchError((error) => {
+        if (this.config?.debug) {
+          console.warn("[Keverd SDK] Failed to end session:", error);
+        }
+        return throwError(() => error);
+      })
+    );
+  }
+  /**
+   * Pause the current session (e.g., when app goes to background)
+   */
+  pauseSession() {
+    if (!this.isInitialized || !this.config) {
+      return throwError(() => ({
+        message: "Keverd SDK not initialized. Call init() first.",
+        code: "SDK_NOT_INITIALIZED"
+      }));
+    }
+    return from(Keverd.pauseSession()).pipe(
+      catchError((error) => {
+        if (this.config?.debug) {
+          console.warn("[Keverd SDK] Failed to pause session:", error);
+        }
+        return throwError(() => error);
+      })
+    );
+  }
+  /**
+   * Resume a paused session (e.g., when app comes to foreground)
+   */
+  resumeSession() {
+    if (!this.isInitialized || !this.config) {
+      return throwError(() => ({
+        message: "Keverd SDK not initialized. Call init() first.",
+        code: "SDK_NOT_INITIALIZED"
+      }));
+    }
+    return from(Keverd.resumeSession()).pipe(
+      catchError((error) => {
+        if (this.config?.debug) {
+          console.warn("[Keverd SDK] Failed to resume session:", error);
+        }
+        return throwError(() => error);
+      })
+    );
+  }
+  /**
+   * Get current session status
+   */
+  getSessionStatus() {
+    if (!this.isInitialized || !this.config) {
+      return throwError(() => ({
+        message: "Keverd SDK not initialized. Call init() first.",
+        code: "SDK_NOT_INITIALIZED"
+      }));
+    }
+    return from(Keverd.getSessionStatus()).pipe(
+      catchError((error) => {
+        if (this.config?.debug) {
+          console.warn("[Keverd SDK] Failed to get session status:", error);
+        }
+        return throwError(() => error);
+      })
+    );
+  }
   /**
    * Destroy the SDK instance
    */
   destroy() {
+    if (this.isInitialized) {
+      Keverd.endSession().catch(() => {
+      });
+    }
     Keverd.destroy();
     this.isInitialized = false;
     this.config = null;
@@ -3274,7 +3674,6 @@ var KeverdModule = class {
    *   imports: [
    *     KeverdModule.forRoot({
    *       apiKey: 'your-api-key',
-   *       endpoint: 'https://api.keverd.com'
    *     })
    *   ]
    * })