@loamly/tracker 1.7.0 → 1.8.0

package/dist/index.cjs

@@ -22,7 +22,9 @@ var index_exports = {};
 __export(index_exports, {
   AI_BOT_PATTERNS: () => AI_BOT_PATTERNS,
   AI_PLATFORMS: () => AI_PLATFORMS,
+  AgenticBrowserAnalyzer: () => AgenticBrowserAnalyzer,
   VERSION: () => VERSION,
+  createAgenticAnalyzer: () => createAgenticAnalyzer,
   default: () => loamly,
   detectAIFromReferrer: () => detectAIFromReferrer,
   detectAIFromUTM: () => detectAIFromUTM,
@@ -32,7 +34,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/config.ts
-var VERSION = "1.7.0";
+var VERSION = "1.8.0";
 var DEFAULT_CONFIG = {
   apiHost: "https://app.loamly.ai",
   endpoints: {
@@ -525,6 +527,151 @@ var BehavioralClassifier = class {
   }
 };
 
+// src/detection/focus-blur.ts
+var FocusBlurAnalyzer = class {
+  constructor() {
+    this.sequence = [];
+    this.firstInteractionTime = null;
+    this.analyzed = false;
+    this.result = null;
+    this.pageLoadTime = performance.now();
+  }
+  /**
+   * Initialize event tracking
+   * Must be called after DOM is ready
+   */
+  initTracking() {
+    document.addEventListener("focus", (e) => {
+      this.recordEvent("focus", e.target);
+    }, true);
+    document.addEventListener("blur", (e) => {
+      this.recordEvent("blur", e.target);
+    }, true);
+    window.addEventListener("focus", () => {
+      this.recordEvent("window_focus", null);
+    });
+    window.addEventListener("blur", () => {
+      this.recordEvent("window_blur", null);
+    });
+    const recordFirstInteraction = () => {
+      if (this.firstInteractionTime === null) {
+        this.firstInteractionTime = performance.now();
+      }
+    };
+    document.addEventListener("click", recordFirstInteraction, { once: true, passive: true });
+    document.addEventListener("keydown", recordFirstInteraction, { once: true, passive: true });
+  }
+  /**
+   * Record a focus/blur event
+   */
+  recordEvent(type, target) {
+    const event = {
+      type,
+      target: target?.tagName || "WINDOW",
+      timestamp: performance.now()
+    };
+    this.sequence.push(event);
+    if (this.sequence.length > 20) {
+      this.sequence = this.sequence.slice(-20);
+    }
+  }
+  /**
+   * Analyze the focus/blur sequence for paste patterns
+   */
+  analyze() {
+    if (this.analyzed && this.result) {
+      return this.result;
+    }
+    const signals = [];
+    let confidence = 0;
+    const earlyEvents = this.sequence.filter((e) => e.timestamp < this.pageLoadTime + 500);
+    const hasEarlyWindowFocus = earlyEvents.some((e) => e.type === "window_focus");
+    if (hasEarlyWindowFocus) {
+      signals.push("early_window_focus");
+      confidence += 0.15;
+    }
+    const hasEarlyBodyFocus = earlyEvents.some(
+      (e) => e.type === "focus" && e.target === "BODY"
+    );
+    if (hasEarlyBodyFocus) {
+      signals.push("early_body_focus");
+      confidence += 0.15;
+    }
+    const hasLinkFocus = this.sequence.some(
+      (e) => e.type === "focus" && e.target === "A"
+    );
+    if (!hasLinkFocus) {
+      signals.push("no_link_focus");
+      confidence += 0.1;
+    }
+    const firstFocus = this.sequence.find((e) => e.type === "focus");
+    if (firstFocus && (firstFocus.target === "BODY" || firstFocus.target === "HTML")) {
+      signals.push("first_focus_body");
+      confidence += 0.1;
+    }
+    const windowEvents = this.sequence.filter(
+      (e) => e.type === "window_focus" || e.type === "window_blur"
+    );
+    if (windowEvents.length <= 2) {
+      signals.push("minimal_window_switches");
+      confidence += 0.05;
+    }
+    if (this.firstInteractionTime !== null) {
+      const timeToInteraction = this.firstInteractionTime - this.pageLoadTime;
+      if (timeToInteraction > 3e3) {
+        signals.push("delayed_first_interaction");
+        confidence += 0.1;
+      }
+    }
+    confidence = Math.min(confidence, 0.65);
+    let navType;
+    if (confidence >= 0.35) {
+      navType = "likely_paste";
+    } else if (signals.length === 0) {
+      navType = "unknown";
+    } else {
+      navType = "likely_click";
+    }
+    this.result = {
+      nav_type: navType,
+      confidence,
+      signals,
+      sequence: this.sequence.slice(-10),
+      time_to_first_interaction_ms: this.firstInteractionTime ? Math.round(this.firstInteractionTime - this.pageLoadTime) : null
+    };
+    this.analyzed = true;
+    return this.result;
+  }
+  /**
+   * Get current result (analyze if not done)
+   */
+  getResult() {
+    return this.analyze();
+  }
+  /**
+   * Check if analysis has been performed
+   */
+  hasAnalyzed() {
+    return this.analyzed;
+  }
+  /**
+   * Get the raw sequence for debugging
+   */
+  getSequence() {
+    return [...this.sequence];
+  }
+  /**
+   * Reset the analyzer
+   */
+  reset() {
+    this.sequence = [];
+    this.pageLoadTime = performance.now();
+    this.firstInteractionTime = null;
+    this.analyzed = false;
+    this.result = null;
+  }
+};
+
 // src/utils.ts
 function generateUUID() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
@@ -612,6 +759,8 @@ var navigationTiming = null;
 var aiDetection = null;
 var behavioralClassifier = null;
 var behavioralMLResult = null;
+var focusBlurAnalyzer = null;
+var focusBlurResult = null;
 function log(...args) {
   if (debugMode) {
     console.log("[Loamly]", ...args);
@@ -654,6 +803,13 @@ function init(userConfig = {}) {
   behavioralClassifier = new BehavioralClassifier(1e4);
   behavioralClassifier.setOnClassify(handleBehavioralClassification);
   setupBehavioralMLTracking();
+  focusBlurAnalyzer = new FocusBlurAnalyzer();
+  focusBlurAnalyzer.initTracking();
+  setTimeout(() => {
+    if (focusBlurAnalyzer) {
+      handleFocusBlurAnalysis(focusBlurAnalyzer.analyze());
+    }
+  }, 5e3);
   log("Initialization complete");
 }
 function pageview(customUrl) {
@@ -907,7 +1063,8 @@ function handleBehavioralClassification(result) {
     signals: result.signals,
     session_duration_ms: result.sessionDurationMs,
     navigation_timing: navigationTiming,
-    ai_detection: aiDetection
+    ai_detection: aiDetection,
+    focus_blur: focusBlurResult
   });
   if (result.classification === "ai_influenced" && result.confidence >= 0.7) {
     aiDetection = {
@@ -918,6 +1075,32 @@ function handleBehavioralClassification(result) {
     log("AI detection updated from behavioral ML:", aiDetection);
   }
 }
+function handleFocusBlurAnalysis(result) {
+  log("Focus/blur analysis:", result);
+  focusBlurResult = {
+    navType: result.nav_type,
+    confidence: result.confidence,
+    signals: result.signals,
+    timeToFirstInteractionMs: result.time_to_first_interaction_ms
+  };
+  sendBehavioralEvent("focus_blur_analysis", {
+    nav_type: result.nav_type,
+    confidence: result.confidence,
+    signals: result.signals,
+    time_to_first_interaction_ms: result.time_to_first_interaction_ms,
+    sequence_length: result.sequence.length
+  });
+  if (result.nav_type === "likely_paste" && result.confidence >= 0.4) {
+    if (!aiDetection || aiDetection.confidence < result.confidence) {
+      aiDetection = {
+        isAI: true,
+        confidence: result.confidence,
+        method: "behavioral"
+      };
+      log("AI detection updated from focus/blur analysis:", aiDetection);
+    }
+  }
+}
 function getCurrentSessionId() {
   return sessionId;
 }
@@ -933,6 +1116,9 @@ function getNavigationTimingResult() {
 function getBehavioralMLResult() {
   return behavioralMLResult;
 }
+function getFocusBlurResult() {
+  return focusBlurResult;
+}
 function isTrackerInitialized() {
   return initialized;
 }
@@ -946,6 +1132,8 @@ function reset() {
   aiDetection = null;
   behavioralClassifier = null;
   behavioralMLResult = null;
+  focusBlurAnalyzer = null;
+  focusBlurResult = null;
   try {
     sessionStorage.removeItem("loamly_session");
     sessionStorage.removeItem("loamly_start");
@@ -967,20 +1155,246 @@ var loamly = {
   getAIDetection: getAIDetectionResult,
   getNavigationTiming: getNavigationTimingResult,
   getBehavioralML: getBehavioralMLResult,
+  getFocusBlur: getFocusBlurResult,
   isInitialized: isTrackerInitialized,
   reset,
   debug: setDebug
 };
+
+// src/detection/agentic-browser.ts
+var CometDetector = class {
+  constructor() {
+    this.detected = false;
+    this.checkComplete = false;
+    this.observer = null;
+  }
+  /**
+   * Initialize detection
+   * @param timeout - Max time to observe for Comet DOM (default: 5s)
+   */
+  init(timeout = 5e3) {
+    if (typeof document === "undefined") return;
+    this.check();
+    if (!this.detected && document.body) {
+      this.observer = new MutationObserver(() => this.check());
+      this.observer.observe(document.body, { childList: true, subtree: true });
+      setTimeout(() => {
+        if (this.observer && !this.detected) {
+          this.observer.disconnect();
+          this.observer = null;
+          this.checkComplete = true;
+        }
+      }, timeout);
+    }
+  }
+  check() {
+    if (document.querySelector(".pplx-agent-overlay-stop-button")) {
+      this.detected = true;
+      this.checkComplete = true;
+      if (this.observer) {
+        this.observer.disconnect();
+        this.observer = null;
+      }
+    }
+  }
+  isDetected() {
+    return this.detected;
+  }
+  isCheckComplete() {
+    return this.checkComplete;
+  }
+  destroy() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+  }
+};
+var MouseAnalyzer = class {
+  /**
+   * @param teleportThreshold - Distance in pixels to consider a teleport (default: 500)
+   */
+  constructor(teleportThreshold = 500) {
+    this.lastX = -1;
+    this.lastY = -1;
+    this.teleportingClicks = 0;
+    this.totalMovements = 0;
+    this.handleMove = (e) => {
+      this.totalMovements++;
+      this.lastX = e.clientX;
+      this.lastY = e.clientY;
+    };
+    this.handleClick = (e) => {
+      if (this.lastX !== -1 && this.lastY !== -1) {
+        const dx = Math.abs(e.clientX - this.lastX);
+        const dy = Math.abs(e.clientY - this.lastY);
+        if (dx > this.teleportThreshold || dy > this.teleportThreshold) {
+          this.teleportingClicks++;
+        }
+      }
+      this.lastX = e.clientX;
+      this.lastY = e.clientY;
+    };
+    this.teleportThreshold = teleportThreshold;
+  }
+  /**
+   * Initialize mouse tracking
+   */
+  init() {
+    if (typeof document === "undefined") return;
+    document.addEventListener("mousemove", this.handleMove, { passive: true });
+    document.addEventListener("mousedown", this.handleClick, { passive: true });
+  }
+  getPatterns() {
+    return {
+      teleportingClicks: this.teleportingClicks,
+      totalMovements: this.totalMovements
+    };
+  }
+  destroy() {
+    if (typeof document === "undefined") return;
+    document.removeEventListener("mousemove", this.handleMove);
+    document.removeEventListener("mousedown", this.handleClick);
+  }
+};
+var CDPDetector = class {
+  constructor() {
+    this.detected = false;
+  }
+  /**
+   * Run detection checks
+   */
+  detect() {
+    if (typeof navigator === "undefined") return false;
+    if (navigator.webdriver) {
+      this.detected = true;
+      return true;
+    }
+    if (typeof window !== "undefined") {
+      const win = window;
+      const automationProps = [
+        "__webdriver_evaluate",
+        "__selenium_evaluate",
+        "__webdriver_script_function",
+        "__webdriver_script_func",
+        "__webdriver_script_fn",
+        "__fxdriver_evaluate",
+        "__driver_unwrapped",
+        "__webdriver_unwrapped",
+        "__driver_evaluate",
+        "__selenium_unwrapped",
+        "__fxdriver_unwrapped"
+      ];
+      for (const prop of automationProps) {
+        if (prop in win) {
+          this.detected = true;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isDetected() {
+    return this.detected;
+  }
+};
+var AgenticBrowserAnalyzer = class {
+  constructor() {
+    this.initialized = false;
+    this.cometDetector = new CometDetector();
+    this.mouseAnalyzer = new MouseAnalyzer();
+    this.cdpDetector = new CDPDetector();
+  }
+  /**
+   * Initialize all detectors
+   */
+  init() {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.cometDetector.init();
+    this.mouseAnalyzer.init();
+    this.cdpDetector.detect();
+  }
+  /**
+   * Get current detection result
+   */
+  getResult() {
+    const signals = [];
+    let probability = 0;
+    if (this.cometDetector.isDetected()) {
+      signals.push("comet_dom_detected");
+      probability = Math.max(probability, 0.85);
+    }
+    if (this.cdpDetector.isDetected()) {
+      signals.push("cdp_detected");
+      probability = Math.max(probability, 0.92);
+    }
+    const mousePatterns = this.mouseAnalyzer.getPatterns();
+    if (mousePatterns.teleportingClicks > 0) {
+      signals.push(`teleporting_clicks:${mousePatterns.teleportingClicks}`);
+      probability = Math.max(probability, 0.78);
+    }
+    return {
+      cometDOMDetected: this.cometDetector.isDetected(),
+      cdpDetected: this.cdpDetector.isDetected(),
+      mousePatterns,
+      agenticProbability: probability,
+      signals
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.cometDetector.destroy();
+    this.mouseAnalyzer.destroy();
+  }
+};
+function createAgenticAnalyzer() {
+  const analyzer = new AgenticBrowserAnalyzer();
+  if (typeof document !== "undefined") {
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => analyzer.init());
+    } else {
+      analyzer.init();
+    }
+  }
+  return analyzer;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AI_BOT_PATTERNS,
   AI_PLATFORMS,
+  AgenticBrowserAnalyzer,
   VERSION,
+  createAgenticAnalyzer,
   detectAIFromReferrer,
   detectAIFromUTM,
   detectNavigationType,
   loamly
 });
+/**
+ * Loamly Tracker Configuration
+ * 
+ * @module @loamly/tracker
+ * @license MIT
+ * @see https://github.com/loamly/loamly
+ */
+/**
+ * Agentic Browser Detection
+ * 
+ * LOA-187: Detects AI agentic browsers like Perplexity Comet, ChatGPT Atlas,
+ * and other automated browsing agents.
+ * 
+ * Detection methods:
+ * - DOM fingerprinting (Perplexity Comet overlay)
+ * - Mouse movement patterns (teleporting clicks)
+ * - CDP (Chrome DevTools Protocol) automation fingerprint
+ * - navigator.webdriver detection
+ * 
+ * @module @loamly/tracker/detection/agentic-browser
+ * @license MIT
+ */
 /**
  * Loamly Tracker
  * 
@@ -988,7 +1402,9 @@ var loamly = {
  * See what AI tells your customers — and track when they click.
  * 
  * @module @loamly/tracker
+ * @version 1.8.0
  * @license MIT
+ * @see https://github.com/loamly/loamly
  * @see https://loamly.ai
  */
 //# sourceMappingURL=index.cjs.map