@bbearai/core 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -415,6 +415,433 @@ function isNetworkError(error) {
   msg.includes("the internet connection appears to be offline") || msg.includes("a]server with the specified hostname could not be found");
 }
 
+// src/monitoring/fingerprint.ts
+function generateFingerprint(source, message, route) {
+  const input = `${source}|${message}|${route}`;
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + input.charCodeAt(i) & 4294967295;
+  }
+  return `bb_${(hash >>> 0).toString(36)}`;
+}
+var DedupWindow = class {
+  constructor(windowMs) {
+    this.windowMs = windowMs;
+    this.seen = /* @__PURE__ */ new Map();
+  }
+  /** Returns true if this fingerprint should be reported (not a recent duplicate). */
+  shouldReport(fingerprint) {
+    const now = Date.now();
+    const lastSeen = this.seen.get(fingerprint);
+    if (lastSeen !== void 0 && now - lastSeen < this.windowMs) {
+      return false;
+    }
+    this.seen.set(fingerprint, now);
+    this.cleanup(now);
+    return true;
+  }
+  /** Remove expired entries to prevent memory leaks in long sessions. */
+  cleanup(now) {
+    if (this.seen.size > 100) {
+      for (const [fp, ts] of this.seen) {
+        if (now - ts >= this.windowMs) {
+          this.seen.delete(fp);
+        }
+      }
+    }
+  }
+};
+
+// src/monitoring/scrub.ts
+var SENSITIVE_PARAMS = /^(token|key|password|secret|auth|credential|api_key|access_token|secret_key|apikey|session)$/i;
+function scrubUrl(url) {
+  try {
+    const parsed = new URL(url);
+    let changed = false;
+    for (const [key] of parsed.searchParams) {
+      if (SENSITIVE_PARAMS.test(key)) {
+        parsed.searchParams.set(key, "[REDACTED]");
+        changed = true;
+      }
+    }
+    return changed ? parsed.toString() : url;
+  } catch {
+    return url;
+  }
+}
+
+// src/monitoring/error-monitor.ts
+var SOURCE_TO_REPORT_SOURCE = {
+  crash: "auto_crash",
+  api_failure: "auto_api",
+  rage_click: "auto_rage_click"
+};
+var SEVERITY_ORDER = ["low", "medium", "high", "critical"];
+var ErrorMonitor = class {
+  constructor(config, deps) {
+    this.deps = deps;
+    this.sessionReportCount = 0;
+    this.pendingSentryData = null;
+    this.config = {
+      sampleRate: 1,
+      maxReportsPerSession: 10,
+      dedupWindowMs: 3e5,
+      severityThreshold: "low",
+      scrubUrls: true,
+      ...config
+    };
+    this.dedup = new DedupWindow(this.config.dedupWindowMs);
+  }
+  async handleEvent(event) {
+    if (!this.dedup.shouldReport(event.fingerprint)) return;
+    if (Math.random() >= this.config.sampleRate) return;
+    if (this.sessionReportCount >= this.config.maxReportsPerSession) return;
+    const severity = this.getSeverity(event);
+    if (SEVERITY_ORDER.indexOf(severity) < SEVERITY_ORDER.indexOf(this.config.severityThreshold)) return;
+    if (this.config.beforeCapture && !this.config.beforeCapture(event)) return;
+    const scrubbedUrl = this.config.scrubUrls && event.requestUrl ? scrubUrl(event.requestUrl) : event.requestUrl;
+    if (this.pendingSentryData) {
+      event.sentryEventId = this.pendingSentryData.sentryEventId;
+      event.sentryBreadcrumbs = this.pendingSentryData.sentryBreadcrumbs;
+      this.pendingSentryData = null;
+    }
+    this.sessionReportCount++;
+    await this.deps.submitReport({
+      type: "bug",
+      reportSource: SOURCE_TO_REPORT_SOURCE[event.source],
+      title: this.generateTitle(event),
+      description: event.message,
+      severity,
+      category: event.source === "crash" ? "crash" : "functional",
+      appContext: {
+        currentRoute: event.route,
+        errorMessage: event.error?.message,
+        errorStack: event.error?.stack,
+        custom: {
+          monitoringSource: event.source,
+          fingerprint: event.fingerprint,
+          ...event.statusCode ? { statusCode: event.statusCode } : {},
+          ...scrubbedUrl ? { requestUrl: scrubbedUrl } : {},
+          ...event.requestMethod ? { requestMethod: event.requestMethod } : {},
+          ...event.clickCount ? { clickCount: event.clickCount } : {},
+          ...event.targetSelector ? { targetSelector: event.targetSelector } : {},
+          ...event.sentryEventId ? { sentryEventId: event.sentryEventId } : {}
+        }
+      },
+      enhancedContext: this.deps.getEnhancedContext(),
+      deviceInfo: this.deps.getDeviceInfo()
+    });
+  }
+  enrichWithSentry(data) {
+    this.pendingSentryData = data;
+  }
+  getSeverity(event) {
+    if (event.source === "crash") return "critical";
+    if (event.source === "api_failure") return event.statusCode && event.statusCode >= 500 ? "high" : "medium";
+    return "medium";
+  }
+  generateTitle(event) {
+    switch (event.source) {
+      case "crash":
+        return `[Auto] Crash on ${event.route}: ${event.message.slice(0, 80)}`;
+      case "api_failure":
+        return `[Auto] ${event.requestMethod || "API"} ${event.statusCode || "error"} on ${event.route}`;
+      case "rage_click":
+        return `[Auto] Rage click on ${event.route} (${event.targetSelector || "unknown"})`;
+    }
+  }
+  destroy() {
+    this.sessionReportCount = 0;
+    this.pendingSentryData = null;
+  }
+};
+
+// src/monitoring/rage-click-detector.ts
+var RageClickDetector = class {
+  constructor(onRageClick) {
+    this.onRageClick = onRageClick;
+    this.clicks = [];
+    this.threshold = 3;
+    this.windowMs = 2e3;
+    this.destroyed = false;
+  }
+  recordClick(x, y, targetSelector) {
+    if (this.destroyed) return;
+    const now = Date.now();
+    this.clicks = this.clicks.filter((c) => now - c.time < this.windowMs);
+    this.clicks.push({ time: now, target: targetSelector, x, y });
+    const sameTarget = this.clicks.filter((c) => c.target === targetSelector);
+    if (sameTarget.length >= this.threshold) {
+      this.onRageClick({
+        clickCount: sameTarget.length,
+        targetSelector,
+        x,
+        y
+      });
+      this.clicks = [];
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    this.clicks = [];
+  }
+};
+
+// src/monitoring/web-handlers.ts
+function getSelector(el) {
+  if (el.id) return `#${el.id}`;
+  const tag = el.tagName.toLowerCase();
+  const classes = Array.from(el.classList).slice(0, 2);
+  return classes.length > 0 ? `${tag}.${classes.join(".")}` : tag;
+}
+function currentRoute() {
+  try {
+    return typeof window !== "undefined" && window.location ? window.location.pathname : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var WebCrashHandler = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+    this.prevOnError = null;
+    this.rejectionHandler = null;
+  }
+  start() {
+    this.prevOnError = window.onerror;
+    window.onerror = (message, source, lineno, colno, error) => {
+      const msg = typeof message === "string" ? message : "Unknown error";
+      const route = currentRoute();
+      this.onEvent({
+        source: "crash",
+        fingerprint: generateFingerprint("crash", msg, route),
+        message: msg,
+        route,
+        timestamp: Date.now(),
+        error: error ?? new Error(msg)
+      });
+      if (typeof this.prevOnError === "function") {
+        return this.prevOnError(message, source, lineno, colno, error);
+      }
+      return false;
+    };
+    this.rejectionHandler = (e) => {
+      const reason = e.reason;
+      const error = reason instanceof Error ? reason : new Error(String(reason));
+      const msg = error.message || "Unhandled promise rejection";
+      const route = currentRoute();
+      this.onEvent({
+        source: "crash",
+        fingerprint: generateFingerprint("crash", msg, route),
+        message: msg,
+        route,
+        timestamp: Date.now(),
+        error
+      });
+    };
+    window.addEventListener("unhandledrejection", this.rejectionHandler);
+  }
+  destroy() {
+    window.onerror = this.prevOnError;
+    if (this.rejectionHandler) {
+      window.removeEventListener("unhandledrejection", this.rejectionHandler);
+      this.rejectionHandler = null;
+    }
+  }
+};
+var WebApiFailureHandler = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+    this.originalFetch = null;
+  }
+  start() {
+    this.originalFetch = window.fetch;
+    const original = this.originalFetch;
+    const onEvent = this.onEvent;
+    window.fetch = async function patchedFetch(input, init) {
+      const response = await original.call(window, input, init);
+      if (response.status >= 400) {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        const method = (init?.method ?? "GET").toUpperCase();
+        const route = currentRoute();
+        const msg = `${method} ${url} failed with ${response.status}`;
+        onEvent({
+          source: "api_failure",
+          fingerprint: generateFingerprint("api_failure", msg, route),
+          message: msg,
+          route,
+          timestamp: Date.now(),
+          requestUrl: url,
+          requestMethod: method,
+          statusCode: response.status
+        });
+      }
+      return response;
+    };
+  }
+  destroy() {
+    if (this.originalFetch) {
+      window.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+  }
+};
+var WebRageClickHandler = class {
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+    this.clickHandler = null;
+    this.detector = new RageClickDetector((rageEvent) => {
+      const route = currentRoute();
+      this.onEvent({
+        source: "rage_click",
+        fingerprint: generateFingerprint("rage_click", rageEvent.targetSelector, route),
+        message: `Rage click detected on ${rageEvent.targetSelector}`,
+        route,
+        timestamp: Date.now(),
+        clickCount: rageEvent.clickCount,
+        targetSelector: rageEvent.targetSelector
+      });
+    });
+  }
+  start() {
+    this.clickHandler = (e) => {
+      const target = e.target;
+      if (!(target instanceof Element)) return;
+      const selector = getSelector(target);
+      this.detector.recordClick(e.clientX, e.clientY, selector);
+    };
+    document.addEventListener("click", this.clickHandler, true);
+  }
+  destroy() {
+    if (this.clickHandler) {
+      document.removeEventListener("click", this.clickHandler, true);
+      this.clickHandler = null;
+    }
+    this.detector.destroy();
+  }
+};
+
+// src/monitoring/rn-handlers.ts
+var RNCrashHandler = class {
+  constructor(onEvent, getCurrentRoute) {
+    this.onEvent = onEvent;
+    this.getCurrentRoute = getCurrentRoute;
+    this.originalHandler = null;
+    this.started = false;
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    const errorUtils = globalThis.ErrorUtils;
+    if (!errorUtils) return;
+    this.originalHandler = errorUtils.getGlobalHandler();
+    const self = this;
+    errorUtils.setGlobalHandler((error, isFatal) => {
+      const normalizedError = error instanceof Error ? error : new Error(String(error));
+      const route = self.getCurrentRoute();
+      self.onEvent({
+        source: "crash",
+        fingerprint: generateFingerprint("crash", normalizedError.message, route),
+        message: normalizedError.message,
+        route,
+        timestamp: Date.now(),
+        error: normalizedError
+      });
+      if (self.originalHandler) {
+        self.originalHandler(error, isFatal);
+      }
+    });
+  }
+  destroy() {
+    if (!this.started) return;
+    this.started = false;
+    const errorUtils = globalThis.ErrorUtils;
+    if (errorUtils && this.originalHandler) {
+      errorUtils.setGlobalHandler(this.originalHandler);
+    }
+    this.originalHandler = null;
+  }
+};
+var RNApiFailureHandler = class {
+  constructor(onEvent, getCurrentRoute) {
+    this.onEvent = onEvent;
+    this.getCurrentRoute = getCurrentRoute;
+    this.originalFetch = null;
+    this.started = false;
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.originalFetch = globalThis.fetch;
+    const self = this;
+    globalThis.fetch = async function patchedFetch(input, init) {
+      const response = await self.originalFetch.call(globalThis, input, init);
+      if (response.status >= 400) {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        const method = init?.method ?? "GET";
+        const route = self.getCurrentRoute();
+        self.onEvent({
+          source: "api_failure",
+          fingerprint: generateFingerprint("api_failure", `${method} ${response.status}`, route),
+          message: `${method} ${url} failed with ${response.status}`,
+          route,
+          timestamp: Date.now(),
+          requestUrl: url,
+          requestMethod: method,
+          statusCode: response.status
+        });
+      }
+      return response;
+    };
+  }
+  destroy() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.originalFetch) {
+      globalThis.fetch = this.originalFetch;
+      this.originalFetch = null;
+    }
+  }
+};
+var RNRageClickHandler = class {
+  constructor(onEvent, getCurrentRoute) {
+    this.onEvent = onEvent;
+    this.getCurrentRoute = getCurrentRoute;
+    this.detector = null;
+  }
+  start() {
+    if (this.detector) return;
+    const self = this;
+    this.detector = new RageClickDetector((rageEvent) => {
+      const route = self.getCurrentRoute();
+      self.onEvent({
+        source: "rage_click",
+        fingerprint: generateFingerprint("rage_click", rageEvent.targetSelector, route),
+        message: `Rage click detected on ${rageEvent.targetSelector}`,
+        route,
+        timestamp: Date.now(),
+        clickCount: rageEvent.clickCount,
+        targetSelector: rageEvent.targetSelector
+      });
+    });
+  }
+  /**
+   * Record a touch event. Call this from the BugBearProvider's onTouchEnd handler.
+   * @param x - Touch x coordinate
+   * @param y - Touch y coordinate
+   * @param viewId - Identifier for the touched view (e.g., testID, accessibilityLabel, or nativeID)
+   */
+  recordTouch(x, y, viewId) {
+    this.detector?.recordClick(x, y, viewId);
+  }
+  destroy() {
+    if (this.detector) {
+      this.detector.destroy();
+      this.detector = null;
+    }
+  }
+};
+
 // src/client.ts
 var formatPgError = (e) => {
   if (!e || typeof e !== "object") return { raw: e };
@@ -433,6 +860,8 @@ var BugBearClient = class {
     /** Active Realtime channel references for cleanup. */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.realtimeChannels = [];
+    /** Error monitor instance — created when config.monitoring is present. */
+    this.monitor = null;
     /** Whether the client has been successfully initialized. */
     this.initialized = false;
     /** Initialization error, if any. */
@@ -450,6 +879,7 @@ var BugBearClient = class {
       this.initialized = true;
       this.pendingInit = Promise.resolve();
       this.initOfflineQueue();
+      this.initMonitoring();
     } else {
       throw new Error(
         "BugBear: Missing configuration. Provide either:\n  \u2022 apiKey (recommended) \u2014 resolves everything automatically\n  \u2022 projectId + supabaseUrl + supabaseAnonKey \u2014 explicit credentials\n\nGet your API key at https://app.bugbear.ai/settings/projects"
@@ -507,6 +937,7 @@ var BugBearClient = class {
     this.supabase = createClient(resolved.supabaseUrl, resolved.supabaseAnonKey);
     this.initialized = true;
     this.initOfflineQueue();
+    this.initMonitoring();
   }
   /** Initialize offline queue if configured. Shared by both init paths. */
   initOfflineQueue() {
@@ -519,6 +950,17 @@ var BugBearClient = class {
       this.registerQueueHandlers();
     }
   }
+  /** Initialize error monitoring if configured. Shared by both init paths. */
+  initMonitoring() {
+    const mc = this.config.monitoring;
+    if (!mc || !mc.crashes && !mc.apiFailures && !mc.rageClicks) return;
+    this.monitor = new ErrorMonitor(mc, {
+      submitReport: (report) => this.submitReport(report),
+      getCurrentRoute: () => contextCapture.getCurrentRoute(),
+      getEnhancedContext: () => contextCapture.getEnhancedContext(),
+      getDeviceInfo: () => this.getDeviceInfo()
+    });
+  }
   /** Read cached config from localStorage if available and not expired. */
   readConfigCache(apiKey) {
     if (typeof localStorage === "undefined") return null;
@@ -774,7 +1216,9 @@ var BugBearClient = class {
         navigation_history: this.getNavigationHistory(),
         enhanced_context: report.enhancedContext || contextCapture.getEnhancedContext(),
         assignment_id: report.assignmentId,
-        test_case_id: report.testCaseId
+        test_case_id: report.testCaseId,
+        report_source: report.reportSource || "manual",
+        error_fingerprint: report.appContext?.custom?.fingerprint || null
       };
       const { data, error } = await this.supabase.from("reports").insert(fullReport).select("id").single();
       if (error) {
@@ -856,7 +1300,7 @@ var BugBearClient = class {
         `;
       const [pendingResult, completedResult] = await Promise.all([
         this.supabase.from("test_assignments").select(selectFields).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["pending", "in_progress"]).order("created_at", { ascending: true }).range(from, to),
-        this.supabase.from("test_assignments").select(selectFields).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["passed", "failed", "skipped", "blocked"]).order("completed_at", { ascending: false }).limit(100)
+        this.supabase.from("test_assignments").select(selectFields).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["passed", "failed", "skipped", "blocked"]).or("is_verification.eq.false,is_verification.is.null").order("completed_at", { ascending: false }).limit(100)
       ]);
       if (pendingResult.error) {
         console.error("BugBear: Failed to fetch assignments", formatPgError(pendingResult.error));
@@ -1325,7 +1769,8 @@ var BugBearClient = class {
         avatarUrl: tester.avatar_url || void 0,
         platforms: tester.platforms || [],
         assignedTests: tester.assigned_count || 0,
-        completedTests: tester.completed_count || 0
+        completedTests: tester.completed_count || 0,
+        role: tester.role || "tester"
       };
     } catch (err) {
       console.error("BugBear: getTesterInfo error", err);
@@ -1613,15 +2058,78 @@ var BugBearClient = class {
     }
   }
   /**
-   * Check if the widget should be visible
-   * (QA mode enabled AND current user is a tester)
+   * Check if the widget should be visible.
+   * Behavior depends on the configured mode:
+   * - 'qa': QA enabled AND user is a registered tester
+   * - 'feedback': Any authenticated user
+   * - 'auto': Either QA tester OR authenticated non-tester
    */
   async shouldShowWidget() {
-    const [qaEnabled, isTester] = await Promise.all([
+    const mode = this.config.mode || "qa";
+    if (mode === "qa") {
+      const [qaEnabled2, tester] = await Promise.all([
+        this.isQAEnabled(),
+        this.isTester()
+      ]);
+      return qaEnabled2 && tester;
+    }
+    if (mode === "feedback") {
+      const userInfo2 = await this.getCurrentUserInfo();
+      return userInfo2 !== null;
+    }
+    const [qaEnabled, testerInfo, userInfo] = await Promise.all([
       this.isQAEnabled(),
-      this.isTester()
+      this.getTesterInfo(),
+      this.getCurrentUserInfo()
     ]);
-    return qaEnabled && isTester;
+    if (qaEnabled && testerInfo && testerInfo.role !== "feedback") return true;
+    if (userInfo) return true;
+    return false;
+  }
+  /**
+   * Resolve the effective widget mode for the current user.
+   * - 'qa' or 'feedback' config → returned as-is
+   * - 'auto' → checks if user is a QA tester (role='tester') → 'qa', otherwise 'feedback'
+   */
+  async getEffectiveMode() {
+    const mode = this.config.mode || "qa";
+    if (mode === "qa") return "qa";
+    if (mode === "feedback") return "feedback";
+    const [qaEnabled, testerInfo] = await Promise.all([
+      this.isQAEnabled(),
+      this.getTesterInfo()
+    ]);
+    if (qaEnabled && testerInfo && testerInfo.role !== "feedback") return "qa";
+    return "feedback";
+  }
+  /**
+   * Auto-provision a feedback user record in the testers table.
+   * Called during initialization when mode is 'feedback' or 'auto' for non-testers.
+   * Idempotent — safe to call multiple times. Returns the tester info for the user.
+   */
+  async ensureFeedbackUser() {
+    try {
+      await this.ensureReady();
+      const userInfo = await this.getCurrentUserInfo();
+      if (!userInfo?.email) return null;
+      const { error } = await this.supabase.rpc("ensure_feedback_user", {
+        p_project_id: this.config.projectId,
+        p_user_id: userInfo.id,
+        p_email: userInfo.email,
+        p_name: userInfo.name || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to ensure feedback user", error.message);
+        this.config.onError?.(new Error(`ensure_feedback_user failed: ${error.message}`), {
+          context: "feedback_user_provisioning"
+        });
+        return null;
+      }
+      return this.getTesterInfo();
+    } catch (err) {
+      console.error("BugBear: Error ensuring feedback user", err);
+      return null;
+    }
   }
   /**
    * Upload a screenshot (web - uses File/Blob)
@@ -2251,11 +2759,22 @@ function createBugBear(config) {
 export {
   BUG_CATEGORIES,
   BugBearClient,
+  DedupWindow,
+  ErrorMonitor,
   LocalStorageAdapter,
   OfflineQueue,
+  RNApiFailureHandler,
+  RNCrashHandler,
+  RNRageClickHandler,
+  RageClickDetector,
+  WebApiFailureHandler,
+  WebCrashHandler,
+  WebRageClickHandler,
   captureError,
   contextCapture,
   createBugBear,
+  generateFingerprint,
   isBugCategory,
-  isNetworkError
+  isNetworkError,
+  scrubUrl
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbearai/core",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Core utilities and types for BugBear QA platform",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",