@bbearai/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,675 @@
+// src/client.ts
+import { createClient } from "@supabase/supabase-js";
+var DEFAULT_SUPABASE_URL = "https://kyxgzjnqgvapvlnvqawz.supabase.co";
+var getEnvVar = (key) => {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[key];
+    }
+  } catch {
+  }
+  return void 0;
+};
+var HOSTED_BUGBEAR_ANON_KEY = getEnvVar("BUGBEAR_ANON_KEY") || getEnvVar("NEXT_PUBLIC_BUGBEAR_ANON_KEY") || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt5eGd6am5xZ3ZhcHZsbnZxYXd6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjkyNjgwNDIsImV4cCI6MjA4NDg0NDA0Mn0.NUkAlCHLFjeRoisbmNUVoGb4R6uQ8xs5LAEIX1BWTwU";
+var BugBearClient = class {
+  constructor(config) {
+    this.navigationHistory = [];
+    this.config = config;
+    this.supabase = createClient(
+      config.supabaseUrl || DEFAULT_SUPABASE_URL,
+      config.supabaseAnonKey || HOSTED_BUGBEAR_ANON_KEY
+    );
+  }
+  /**
+   * Track navigation for context
+   */
+  trackNavigation(route) {
+    this.navigationHistory.push(route);
+    if (this.navigationHistory.length > 10) {
+      this.navigationHistory.shift();
+    }
+  }
+  /**
+   * Get current navigation history
+   */
+  getNavigationHistory() {
+    if (this.config.getNavigationHistory) {
+      return this.config.getNavigationHistory();
+    }
+    return [...this.navigationHistory];
+  }
+  /**
+   * Get current user info from host app or BugBear's own auth
+   */
+  async getCurrentUserInfo() {
+    if (this.config.getCurrentUser) {
+      return await this.config.getCurrentUser();
+    }
+    const { data: { user } } = await this.supabase.auth.getUser();
+    if (!user || !user.email) return null;
+    return {
+      id: user.id,
+      email: user.email
+    };
+  }
+  /**
+   * Submit a report
+   */
+  async submitReport(report) {
+    try {
+      const userInfo = await this.getCurrentUserInfo();
+      if (!userInfo) {
+        console.error("BugBear: No user info available, cannot submit report");
+        return { success: false, error: "User not authenticated" };
+      }
+      const testerInfo = await this.getTesterInfo();
+      const fullReport = {
+        project_id: this.config.projectId,
+        reporter_id: userInfo.id,
+        // User ID from host app (required)
+        tester_id: testerInfo?.id || null,
+        // Tester record ID (optional)
+        report_type: report.type,
+        title: report.title || this.generateTitle(report),
+        description: report.description,
+        severity: report.severity,
+        failed_at_step: report.failedAtStep,
+        voice_audio_url: report.voiceAudioUrl,
+        voice_transcript: report.voiceTranscript,
+        screenshot_urls: report.screenshots || [],
+        app_context: report.appContext,
+        device_info: report.deviceInfo || this.getDeviceInfo(),
+        navigation_history: this.getNavigationHistory(),
+        assignment_id: report.assignmentId,
+        test_case_id: report.testCaseId
+      };
+      const { data, error } = await this.supabase.from("reports").insert(fullReport).select("id").single();
+      if (error) {
+        console.error("BugBear: Failed to submit report", error.message);
+        return { success: false, error: error.message };
+      }
+      if (this.config.onReportSubmitted) {
+        this.config.onReportSubmitted(report);
+      }
+      return { success: true, reportId: data.id };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get assigned tests for current user
+   * First looks up the tester by email, then fetches their assignments
+   */
+  async getAssignedTests() {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return [];
+      const { data, error } = await this.supabase.from("test_assignments").select(`
+          id,
+          status,
+          test_case:test_cases(
+            id,
+            title,
+            test_key,
+            description,
+            steps,
+            expected_result,
+            priority,
+            target_route,
+            track:qa_tracks(
+              id,
+              name,
+              icon,
+              color,
+              test_template,
+              rubric_mode,
+              description
+            )
+          )
+        `).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["pending", "in_progress"]).order("created_at", { ascending: true });
+      if (error) {
+        console.error("BugBear: Failed to fetch assignments", error);
+        return [];
+      }
+      return (data || []).map((item) => ({
+        id: item.id,
+        status: item.status,
+        testCase: {
+          id: item.test_case.id,
+          title: item.test_case.title,
+          testKey: item.test_case.test_key,
+          description: item.test_case.description,
+          steps: item.test_case.steps,
+          expectedResult: item.test_case.expected_result,
+          priority: item.test_case.priority,
+          targetRoute: item.test_case.target_route,
+          track: item.test_case.track ? {
+            id: item.test_case.track.id,
+            name: item.test_case.track.name,
+            icon: item.test_case.track.icon,
+            color: item.test_case.track.color,
+            testTemplate: item.test_case.track.test_template,
+            rubricMode: item.test_case.track.rubric_mode || "pass_fail",
+            description: item.test_case.track.description
+          } : void 0
+        }
+      }));
+    } catch (err) {
+      console.error("BugBear: Error fetching assignments", err);
+      return [];
+    }
+  }
+  /**
+   * Get current tester info
+   * Looks up tester by email from the host app's authenticated user
+   */
+  async getTesterInfo() {
+    try {
+      const userInfo = await this.getCurrentUserInfo();
+      if (!userInfo) return null;
+      const { data, error } = await this.supabase.from("testers").select("*").eq("project_id", this.config.projectId).eq("email", userInfo.email).eq("status", "active").single();
+      if (error || !data) return null;
+      return {
+        id: data.id,
+        name: data.name,
+        email: data.email,
+        assignedTests: data.assigned_count || 0,
+        completedTests: data.completed_count || 0
+      };
+    } catch (err) {
+      console.error("BugBear: getTesterInfo error", err);
+      return null;
+    }
+  }
+  /**
+   * Check if current user is a tester for this project
+   */
+  async isTester() {
+    const info = await this.getTesterInfo();
+    return info !== null;
+  }
+  /**
+   * Check if QA mode is enabled for this project
+   * This is a master switch that admins can toggle in the dashboard
+   */
+  async isQAEnabled() {
+    try {
+      const { data, error } = await this.supabase.from("projects").select("is_qa_enabled").eq("id", this.config.projectId).single();
+      if (error) {
+        if (error.code !== "PGRST116") {
+          console.warn("BugBear: Could not check QA status", error.message || error.code || "Unknown error");
+        }
+        return true;
+      }
+      return data?.is_qa_enabled ?? true;
+    } catch (err) {
+      return true;
+    }
+  }
+  /**
+   * Check if the widget should be visible
+   * (QA mode enabled AND current user is a tester)
+   */
+  async shouldShowWidget() {
+    const [qaEnabled, isTester] = await Promise.all([
+      this.isQAEnabled(),
+      this.isTester()
+    ]);
+    return qaEnabled && isTester;
+  }
+  /**
+   * Upload a screenshot
+   */
+  async uploadScreenshot(file, filename) {
+    try {
+      const name = filename || `screenshot-${Date.now()}.png`;
+      const path = `${this.config.projectId}/${name}`;
+      const { error } = await this.supabase.storage.from("screenshots").upload(path, file, {
+        contentType: "image/png",
+        upsert: false
+      });
+      if (error) {
+        console.error("BugBear: Failed to upload screenshot", error);
+        return null;
+      }
+      const { data: { publicUrl } } = this.supabase.storage.from("screenshots").getPublicUrl(path);
+      return publicUrl;
+    } catch (err) {
+      console.error("BugBear: Error uploading screenshot", err);
+      return null;
+    }
+  }
+  /**
+   * Generate a title from the report content
+   */
+  generateTitle(report) {
+    const prefix = report.type === "bug" ? "\u{1F41B} Bug:" : report.type === "feedback" ? "\u{1F4A1} Feedback:" : report.type === "suggestion" ? "\u2728 Suggestion:" : report.type === "test_fail" ? "\u274C Test Failed:" : "\u2705 Test Passed:";
+    const desc = report.description || "";
+    const shortDesc = desc.length > 50 ? desc.slice(0, 50) + "..." : desc;
+    return `${prefix} ${shortDesc}`;
+  }
+  /**
+   * Get device info (override in platform-specific implementations)
+   */
+  getDeviceInfo() {
+    if (typeof window !== "undefined") {
+      return {
+        platform: "web",
+        userAgent: navigator.userAgent,
+        screenSize: {
+          width: window.screen.width,
+          height: window.screen.height
+        }
+      };
+    }
+    return { platform: "web" };
+  }
+  /**
+   * Create a fix request for Claude Code to pick up
+   * Called from the dashboard when user clicks "Send to Claude Code"
+   */
+  async createFixRequest(request) {
+    try {
+      const userInfo = await this.getCurrentUserInfo();
+      const fixRequest = {
+        project_id: this.config.projectId,
+        title: request.title,
+        description: request.description || null,
+        prompt: request.prompt,
+        file_path: request.filePath || null,
+        report_id: request.reportId || null,
+        status: "pending",
+        created_by: userInfo?.id || null
+      };
+      const { data, error } = await this.supabase.from("fix_requests").insert(fixRequest).select("id").single();
+      if (error) {
+        console.error("BugBear: Failed to create fix request", error.message);
+        return { success: false, error: error.message };
+      }
+      return { success: true, fixRequestId: data.id };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get pending fix requests for this project
+   * Useful for dashboard to show queue status
+   */
+  async getFixRequests(options) {
+    try {
+      let query = this.supabase.from("fix_requests").select("*").eq("project_id", this.config.projectId).order("created_at", { ascending: false }).limit(options?.limit || 20);
+      if (options?.status) {
+        query = query.eq("status", options.status);
+      }
+      const { data, error } = await query;
+      if (error) {
+        console.error("BugBear: Failed to fetch fix requests", error);
+        return [];
+      }
+      return (data || []).map((fr) => ({
+        id: fr.id,
+        title: fr.title,
+        description: fr.description,
+        status: fr.status,
+        claimedBy: fr.claimed_by,
+        claimedAt: fr.claimed_at,
+        completedAt: fr.completed_at,
+        createdAt: fr.created_at
+      }));
+    } catch (err) {
+      console.error("BugBear: Error fetching fix requests", err);
+      return [];
+    }
+  }
+  /**
+   * Get threads visible to the current tester
+   * Includes threads where audience is 'all' or tester is in audience_tester_ids
+   */
+  async getThreadsForTester() {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return [];
+      const { data: threads, error } = await this.supabase.from("discussion_threads").select(`
+          id,
+          subject,
+          thread_type,
+          priority,
+          is_pinned,
+          is_resolved,
+          last_message_at,
+          created_at
+        `).eq("project_id", this.config.projectId).or(`audience.eq.all,audience_tester_ids.cs.{${testerInfo.id}}`).order("is_pinned", { ascending: false }).order("last_message_at", { ascending: false });
+      if (error) {
+        console.error("BugBear: Failed to fetch threads", error);
+        return [];
+      }
+      if (!threads || threads.length === 0) return [];
+      const threadIds = threads.map((t) => t.id);
+      const { data: readStatuses } = await this.supabase.from("discussion_read_status").select("thread_id, last_read_at, last_read_message_id").eq("tester_id", testerInfo.id).in("thread_id", threadIds);
+      const readStatusMap = new Map(
+        (readStatuses || []).map((rs) => [rs.thread_id, rs])
+      );
+      const { data: lastMessages } = await this.supabase.from("discussion_messages").select(`
+          id,
+          thread_id,
+          sender_type,
+          sender_name,
+          content,
+          created_at,
+          attachments
+        `).in("thread_id", threadIds).order("created_at", { ascending: false });
+      const lastMessageMap = /* @__PURE__ */ new Map();
+      for (const msg of lastMessages || []) {
+        if (!lastMessageMap.has(msg.thread_id)) {
+          lastMessageMap.set(msg.thread_id, msg);
+        }
+      }
+      const unreadCounts = await Promise.all(
+        threads.map(async (thread) => {
+          const readStatus = readStatusMap.get(thread.id);
+          const lastReadAt = readStatus?.last_read_at || "1970-01-01T00:00:00Z";
+          const { count, error: countError } = await this.supabase.from("discussion_messages").select("*", { count: "exact", head: true }).eq("thread_id", thread.id).gt("created_at", lastReadAt);
+          return { threadId: thread.id, count: countError ? 0 : count || 0 };
+        })
+      );
+      const unreadCountMap = new Map(
+        unreadCounts.map((uc) => [uc.threadId, uc.count])
+      );
+      return threads.map((thread) => {
+        const lastMsg = lastMessageMap.get(thread.id);
+        return {
+          id: thread.id,
+          subject: thread.subject,
+          threadType: thread.thread_type,
+          priority: thread.priority,
+          isPinned: thread.is_pinned,
+          isResolved: thread.is_resolved,
+          lastMessageAt: thread.last_message_at,
+          createdAt: thread.created_at,
+          unreadCount: unreadCountMap.get(thread.id) || 0,
+          lastMessage: lastMsg ? {
+            id: lastMsg.id,
+            threadId: lastMsg.thread_id,
+            senderType: lastMsg.sender_type,
+            senderName: lastMsg.sender_name,
+            content: lastMsg.content,
+            createdAt: lastMsg.created_at,
+            attachments: lastMsg.attachments || []
+          } : void 0
+        };
+      });
+    } catch (err) {
+      console.error("BugBear: Error fetching threads", err);
+      return [];
+    }
+  }
+  /**
+   * Get all messages in a thread
+   */
+  async getThreadMessages(threadId) {
+    try {
+      const { data, error } = await this.supabase.from("discussion_messages").select(`
+          id,
+          thread_id,
+          sender_type,
+          sender_name,
+          content,
+          created_at,
+          attachments
+        `).eq("thread_id", threadId).order("created_at", { ascending: true });
+      if (error) {
+        console.error("BugBear: Failed to fetch messages", error);
+        return [];
+      }
+      return (data || []).map((msg) => ({
+        id: msg.id,
+        threadId: msg.thread_id,
+        senderType: msg.sender_type,
+        senderName: msg.sender_name,
+        content: msg.content,
+        createdAt: msg.created_at,
+        attachments: msg.attachments || []
+      }));
+    } catch (err) {
+      console.error("BugBear: Error fetching messages", err);
+      return [];
+    }
+  }
+  /**
+   * Send a message to a thread
+   */
+  async sendMessage(threadId, content) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) {
+        console.error("BugBear: No tester info, cannot send message");
+        return false;
+      }
+      const { error } = await this.supabase.from("discussion_messages").insert({
+        thread_id: threadId,
+        sender_type: "tester",
+        sender_id: testerInfo.id,
+        sender_name: testerInfo.name,
+        content
+      });
+      if (error) {
+        console.error("BugBear: Failed to send message", error);
+        return false;
+      }
+      await this.supabase.from("discussion_threads").update({ last_message_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", threadId);
+      return true;
+    } catch (err) {
+      console.error("BugBear: Error sending message", err);
+      return false;
+    }
+  }
+  /**
+   * Mark a thread as read
+   */
+  async markThreadAsRead(threadId) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return;
+      const { data: latestMsg } = await this.supabase.from("discussion_messages").select("id").eq("thread_id", threadId).order("created_at", { ascending: false }).limit(1).single();
+      await this.supabase.from("discussion_read_status").upsert({
+        thread_id: threadId,
+        tester_id: testerInfo.id,
+        last_read_at: (/* @__PURE__ */ new Date()).toISOString(),
+        last_read_message_id: latestMsg?.id || null
+      }, {
+        onConflict: "thread_id,tester_id"
+      });
+    } catch (err) {
+      console.error("BugBear: Error marking thread as read", err);
+    }
+  }
+  /**
+   * Get total unread message count across all threads
+   */
+  async getUnreadCount() {
+    try {
+      const threads = await this.getThreadsForTester();
+      return threads.reduce((sum, thread) => sum + thread.unreadCount, 0);
+    } catch (err) {
+      console.error("BugBear: Error getting unread count", err);
+      return 0;
+    }
+  }
+};
+function createBugBear(config) {
+  return new BugBearClient(config);
+}
+
+// src/capture.ts
+var MAX_CONSOLE_LOGS = 50;
+var MAX_NETWORK_REQUESTS = 20;
+var ContextCaptureManager = class {
+  constructor() {
+    this.consoleLogs = [];
+    this.networkRequests = [];
+    this.originalConsole = {};
+    this.isCapturing = false;
+  }
+  /**
+   * Start capturing console logs and network requests
+   */
+  startCapture() {
+    if (this.isCapturing) return;
+    this.isCapturing = true;
+    this.captureConsole();
+    this.captureFetch();
+  }
+  /**
+   * Stop capturing and restore original functions
+   */
+  stopCapture() {
+    if (!this.isCapturing) return;
+    this.isCapturing = false;
+    if (this.originalConsole.log) console.log = this.originalConsole.log;
+    if (this.originalConsole.warn) console.warn = this.originalConsole.warn;
+    if (this.originalConsole.error) console.error = this.originalConsole.error;
+    if (this.originalConsole.info) console.info = this.originalConsole.info;
+    if (this.originalFetch && typeof window !== "undefined") {
+      window.fetch = this.originalFetch;
+    }
+  }
+  /**
+   * Get captured context for a bug report
+   */
+  getEnhancedContext() {
+    return {
+      consoleLogs: [...this.consoleLogs],
+      networkRequests: [...this.networkRequests],
+      performanceMetrics: this.getPerformanceMetrics(),
+      environment: this.getEnvironmentInfo()
+    };
+  }
+  /**
+   * Clear captured data
+   */
+  clear() {
+    this.consoleLogs = [];
+    this.networkRequests = [];
+  }
+  /**
+   * Add a log entry manually (for custom logging)
+   */
+  addLog(level, message, args) {
+    this.consoleLogs.push({
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      args
+    });
+    if (this.consoleLogs.length > MAX_CONSOLE_LOGS) {
+      this.consoleLogs = this.consoleLogs.slice(-MAX_CONSOLE_LOGS);
+    }
+  }
+  /**
+   * Add a network request manually
+   */
+  addNetworkRequest(request) {
+    this.networkRequests.push(request);
+    if (this.networkRequests.length > MAX_NETWORK_REQUESTS) {
+      this.networkRequests = this.networkRequests.slice(-MAX_NETWORK_REQUESTS);
+    }
+  }
+  captureConsole() {
+    if (typeof console === "undefined") return;
+    const levels = ["log", "warn", "error", "info"];
+    levels.forEach((level) => {
+      this.originalConsole[level] = console[level];
+      console[level] = (...args) => {
+        this.originalConsole[level]?.apply(console, args);
+        try {
+          const message = args.map((arg) => {
+            if (typeof arg === "string") return arg;
+            try {
+              return JSON.stringify(arg);
+            } catch {
+              return String(arg);
+            }
+          }).join(" ");
+          this.addLog(level, message.slice(0, 500));
+        } catch {
+        }
+      };
+    });
+  }
+  captureFetch() {
+    if (typeof window === "undefined" || typeof fetch === "undefined") return;
+    this.originalFetch = window.fetch;
+    const self = this;
+    window.fetch = async function(input, init) {
+      const startTime = Date.now();
+      const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      const method = init?.method || "GET";
+      try {
+        const response = await self.originalFetch.call(window, input, init);
+        self.addNetworkRequest({
+          method,
+          url: url.slice(0, 200),
+          // Limit URL length
+          status: response.status,
+          duration: Date.now() - startTime,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return response;
+      } catch (error) {
+        self.addNetworkRequest({
+          method,
+          url: url.slice(0, 200),
+          duration: Date.now() - startTime,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        throw error;
+      }
+    };
+  }
+  getPerformanceMetrics() {
+    if (typeof window === "undefined" || typeof performance === "undefined") return void 0;
+    const metrics = {};
+    try {
+      const navigation = performance.getEntriesByType("navigation")[0];
+      if (navigation) {
+        metrics.pageLoadTime = Math.round(navigation.loadEventEnd - navigation.startTime);
+      }
+    } catch {
+    }
+    try {
+      const memory = performance.memory;
+      if (memory) {
+        metrics.memoryUsage = Math.round(memory.usedJSHeapSize / 1024 / 1024);
+      }
+    } catch {
+    }
+    return Object.keys(metrics).length > 0 ? metrics : void 0;
+  }
+  getEnvironmentInfo() {
+    if (typeof window === "undefined" || typeof navigator === "undefined") return void 0;
+    return {
+      language: navigator.language,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      cookiesEnabled: navigator.cookieEnabled,
+      localStorage: typeof localStorage !== "undefined",
+      online: navigator.onLine
+    };
+  }
+};
+var contextCapture = new ContextCaptureManager();
+function captureError(error, errorInfo) {
+  return {
+    errorMessage: error.message,
+    errorStack: error.stack,
+    componentStack: errorInfo?.componentStack
+  };
+}
+export {
+  BugBearClient,
+  captureError,
+  contextCapture,
+  createBugBear
+};