@bbearai/core 0.4.6 → 0.5.1

package/dist/index.mjs

@@ -249,32 +249,312 @@ function captureError(error, errorInfo) {
   };
 }
 
+// src/offline-queue.ts
+var LocalStorageAdapter = class {
+  constructor() {
+    this.fallback = /* @__PURE__ */ new Map();
+  }
+  get isAvailable() {
+    try {
+      const key = "__bugbear_test__";
+      localStorage.setItem(key, "1");
+      localStorage.removeItem(key);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getItem(key) {
+    if (this.isAvailable) return localStorage.getItem(key);
+    return this.fallback.get(key) ?? null;
+  }
+  async setItem(key, value) {
+    if (this.isAvailable) {
+      localStorage.setItem(key, value);
+    } else {
+      this.fallback.set(key, value);
+    }
+  }
+  async removeItem(key) {
+    if (this.isAvailable) {
+      localStorage.removeItem(key);
+    } else {
+      this.fallback.delete(key);
+    }
+  }
+};
+var OfflineQueue = class {
+  constructor(config) {
+    this.items = [];
+    this.storageKey = "bugbear_offline_queue";
+    this.flushing = false;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.maxItems = config.maxItems ?? 50;
+    this.maxRetries = config.maxRetries ?? 5;
+    this.storage = config.storage ?? new LocalStorageAdapter();
+  }
+  // ── Flush handler registration ──────────────────────────────
+  /** Register a handler that replays a queued operation. */
+  registerHandler(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  // ── Change listener ─────────────────────────────────────────
+  /** Subscribe to queue count changes (for UI badges). */
+  onChange(callback) {
+    this.listener = callback;
+  }
+  notify() {
+    this.listener?.(this.items.length);
+  }
+  // ── Persistence ─────────────────────────────────────────────
+  /** Load queue from persistent storage. Call once after construction. */
+  async load() {
+    try {
+      const raw = await this.storage.getItem(this.storageKey);
+      if (raw) {
+        this.items = JSON.parse(raw);
+      }
+    } catch {
+      this.items = [];
+    }
+    this.notify();
+  }
+  async save() {
+    try {
+      await this.storage.setItem(this.storageKey, JSON.stringify(this.items));
+    } catch (err) {
+      console.error("BugBear: Failed to persist offline queue", err);
+    }
+    this.notify();
+  }
+  // ── Enqueue ─────────────────────────────────────────────────
+  /** Add a failed operation to the queue. Returns the item ID. */
+  async enqueue(type, payload) {
+    if (this.items.length >= this.maxItems) {
+      this.items.shift();
+    }
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    this.items.push({ id, type, payload, createdAt: Date.now(), retries: 0 });
+    await this.save();
+    return id;
+  }
+  // ── Accessors ───────────────────────────────────────────────
+  /** Number of items waiting to be flushed. */
+  get count() {
+    return this.items.length;
+  }
+  /** Read-only snapshot of pending items. */
+  get pending() {
+    return [...this.items];
+  }
+  /** Whether a flush is currently in progress. */
+  get isFlushing() {
+    return this.flushing;
+  }
+  // ── Flush ───────────────────────────────────────────────────
+  /**
+   * Process all queued items in FIFO order.
+   * Stops early if a network error is encountered (still offline).
+   */
+  async flush() {
+    if (this.flushing || this.items.length === 0) {
+      return { flushed: 0, failed: 0 };
+    }
+    this.flushing = true;
+    let flushed = 0;
+    let failed = 0;
+    const snapshot = [...this.items];
+    for (const item of snapshot) {
+      const handler = this.handlers.get(item.type);
+      if (!handler) {
+        failed++;
+        continue;
+      }
+      try {
+        const result = await handler(item.payload);
+        if (result.success) {
+          this.items = this.items.filter((i) => i.id !== item.id);
+          flushed++;
+        } else if (isNetworkError(result.error)) {
+          break;
+        } else {
+          const idx = this.items.findIndex((i) => i.id === item.id);
+          if (idx !== -1) {
+            this.items[idx].retries++;
+            if (this.items[idx].retries >= this.maxRetries) {
+              this.items.splice(idx, 1);
+            }
+          }
+          failed++;
+        }
+      } catch {
+        break;
+      }
+    }
+    await this.save();
+    this.flushing = false;
+    return { flushed, failed };
+  }
+  // ── Clear ───────────────────────────────────────────────────
+  /** Drop all queued items. */
+  async clear() {
+    this.items = [];
+    await this.save();
+  }
+};
+function isNetworkError(error) {
+  if (!error) return false;
+  const msg = error.toLowerCase();
+  return msg.includes("failed to fetch") || msg.includes("networkerror") || msg.includes("network request failed") || msg.includes("timeout") || msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("load failed") || // Safari
+  msg.includes("the internet connection appears to be offline") || msg.includes("a]server with the specified hostname could not be found");
+}
+
 // src/client.ts
 var formatPgError = (e) => {
   if (!e || typeof e !== "object") return { raw: e };
   const { message, code, details, hint } = e;
   return { message, code, details, hint };
 };
-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.reportSubmitInFlight = false;
+    /** Offline queue — only created when config.offlineQueue.enabled is true. */
+    this._queue = null;
+    /** Active Realtime channel references for cleanup. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.realtimeChannels = [];
+    if (!config.supabaseUrl) {
+      throw new Error("BugBear: supabaseUrl is required. Get it from your BugBear project settings.");
+    }
+    if (!config.supabaseAnonKey) {
+      throw new Error("BugBear: supabaseAnonKey is required. Get it from your BugBear project settings.");
+    }
     this.config = config;
-    this.supabase = createClient(
-      config.supabaseUrl || DEFAULT_SUPABASE_URL,
-      config.supabaseAnonKey || HOSTED_BUGBEAR_ANON_KEY
-    );
+    this.supabase = createClient(config.supabaseUrl, config.supabaseAnonKey);
+    if (config.offlineQueue?.enabled) {
+      this._queue = new OfflineQueue({
+        enabled: true,
+        maxItems: config.offlineQueue.maxItems,
+        maxRetries: config.offlineQueue.maxRetries
+      });
+      this.registerQueueHandlers();
+    }
+  }
+  // ── Offline Queue ─────────────────────────────────────────
+  /**
+   * Access the offline queue (if enabled).
+   * Use this to check queue.count, subscribe to changes, or trigger flush.
+   */
+  get queue() {
+    return this._queue;
+  }
+  /**
+   * Initialize the offline queue with a platform-specific storage adapter.
+   * Must be called after construction for React Native (which supplies AsyncStorage).
+   * Web callers can skip this — LocalStorageAdapter is the default.
+   */
+  async initQueue(storage) {
+    if (!this._queue) return;
+    if (storage) {
+      this._queue = new OfflineQueue({
+        enabled: true,
+        maxItems: this.config.offlineQueue?.maxItems,
+        maxRetries: this.config.offlineQueue?.maxRetries,
+        storage
+      });
+      this.registerQueueHandlers();
+    }
+    await this._queue.load();
+  }
+  registerQueueHandlers() {
+    if (!this._queue) return;
+    this._queue.registerHandler("report", async (payload) => {
+      const { error } = await this.supabase.from("reports").insert(payload).select("id").single();
+      if (error) return { success: false, error: error.message };
+      return { success: true };
+    });
+    this._queue.registerHandler("message", async (payload) => {
+      const { error } = await this.supabase.from("discussion_messages").insert(payload);
+      if (error) return { success: false, error: error.message };
+      return { success: true };
+    });
+    this._queue.registerHandler("feedback", async (payload) => {
+      const { error } = await this.supabase.from("test_feedback").insert(payload);
+      if (error) return { success: false, error: error.message };
+      return { success: true };
+    });
+  }
+  // ── Realtime Subscriptions ─────────────────────────────────
+  /** Whether realtime is enabled in config. */
+  get realtimeEnabled() {
+    return !!this.config.realtime?.enabled;
+  }
+  /**
+   * Subscribe to postgres_changes on relevant tables.
+   * Each callback fires when the corresponding table has changes —
+   * the provider should call its refresh function in response.
+   * Returns a cleanup function that unsubscribes all channels.
+   */
+  subscribeToChanges(callbacks) {
+    this.unsubscribeAll();
+    const projectId = this.config.projectId;
+    const debounce = (fn, ms = 500) => {
+      let timer;
+      return () => {
+        clearTimeout(timer);
+        timer = setTimeout(fn, ms);
+      };
+    };
+    if (callbacks.onAssignmentChange) {
+      const debouncedCb = debounce(callbacks.onAssignmentChange);
+      const channel = this.supabase.channel("bugbear-assignments").on("postgres_changes", {
+        event: "*",
+        schema: "public",
+        table: "test_assignments",
+        filter: `project_id=eq.${projectId}`
+      }, debouncedCb).subscribe((status) => {
+        if (status === "CHANNEL_ERROR") {
+          console.warn("BugBear: Realtime subscription failed for test_assignments");
+        }
+      });
+      this.realtimeChannels.push(channel);
+    }
+    if (callbacks.onMessageChange) {
+      const debouncedCb = debounce(callbacks.onMessageChange);
+      const channel = this.supabase.channel("bugbear-messages").on("postgres_changes", {
+        event: "INSERT",
+        schema: "public",
+        table: "discussion_messages"
+      }, debouncedCb).subscribe((status) => {
+        if (status === "CHANNEL_ERROR") {
+          console.warn("BugBear: Realtime subscription failed for discussion_messages");
+        }
+      });
+      this.realtimeChannels.push(channel);
+    }
+    if (callbacks.onReportChange) {
+      const debouncedCb = debounce(callbacks.onReportChange);
+      const channel = this.supabase.channel("bugbear-reports").on("postgres_changes", {
+        event: "UPDATE",
+        schema: "public",
+        table: "reports",
+        filter: `project_id=eq.${projectId}`
+      }, debouncedCb).subscribe((status) => {
+        if (status === "CHANNEL_ERROR") {
+          console.warn("BugBear: Realtime subscription failed for reports");
+        }
+      });
+      this.realtimeChannels.push(channel);
+    }
+    return () => this.unsubscribeAll();
+  }
+  /** Remove all active Realtime channels. */
+  unsubscribeAll() {
+    for (const channel of this.realtimeChannels) {
+      this.supabase.removeChannel(channel);
+    }
+    this.realtimeChannels = [];
   }
   /**
    * Track navigation for context.
@@ -334,6 +614,7 @@ var BugBearClient = class {
       return { success: false, error: "A report is already being submitted" };
     }
     this.reportSubmitInFlight = true;
+    let fullReport;
     try {
       const validationError = this.validateReport(report);
       if (validationError) {
@@ -350,7 +631,7 @@ var BugBearClient = class {
         return { success: false, error: "User not authenticated" };
       }
       const testerInfo = await this.getTesterInfo();
-      const fullReport = {
+      fullReport = {
         project_id: this.config.projectId,
         reporter_id: userInfo.id,
         // User ID from host app (required)
@@ -377,6 +658,10 @@ var BugBearClient = class {
       };
       const { data, error } = await this.supabase.from("reports").insert(fullReport).select("id").single();
       if (error) {
+        if (this._queue && isNetworkError(error.message)) {
+          await this._queue.enqueue("report", fullReport);
+          return { success: false, queued: true, error: "Queued \u2014 will send when online" };
+        }
         console.error("BugBear: Failed to submit report", error.message);
         return { success: false, error: error.message };
       }
@@ -386,6 +671,10 @@ var BugBearClient = class {
       return { success: true, reportId: data.id };
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
+      if (this._queue && fullReport && isNetworkError(message)) {
+        await this._queue.enqueue("report", fullReport);
+        return { success: false, queued: true, error: "Queued \u2014 will send when online" };
+      }
       return { success: false, error: message };
     } finally {
       this.reportSubmitInFlight = false;
@@ -395,14 +684,18 @@ var BugBearClient = class {
    * Get assigned tests for current user
    * First looks up the tester by email, then fetches their assignments
    */
-  async getAssignedTests() {
+  async getAssignedTests(options) {
     try {
       const testerInfo = await this.getTesterInfo();
       if (!testerInfo) return [];
-      const { data, error } = await this.supabase.from("test_assignments").select(`
+      const pageSize = Math.min(options?.pageSize ?? 100, 100);
+      const from = (options?.page ?? 0) * pageSize;
+      const to = from + pageSize - 1;
+      const selectFields = `
           id,
           status,
           started_at,
+          completed_at,
           skip_reason,
           is_verification,
           original_report_id,
@@ -437,20 +730,24 @@ var BugBearClient = class {
               color,
               description,
               login_hint
-            )
+            ),
+            platforms
           )
-        `).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).in("status", ["pending", "in_progress"]).order("created_at", { ascending: true }).limit(100);
-      if (error) {
-        console.error("BugBear: Failed to fetch assignments", formatPgError(error));
+        `;
+      const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+      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"]).gte("completed_at", twentyFourHoursAgo).order("completed_at", { ascending: false }).limit(50)
+      ]);
+      if (pendingResult.error) {
+        console.error("BugBear: Failed to fetch assignments", formatPgError(pendingResult.error));
         return [];
       }
-      const mapped = (data || []).filter((item) => {
-        if (!item.test_case) {
-          console.warn("BugBear: Assignment returned without test_case", { id: item.id });
-          return false;
-        }
-        return true;
-      }).map((item) => ({
+      const allData = [
+        ...pendingResult.data || [],
+        ...completedResult.data || []
+      ];
+      const mapItem = (item) => ({
         id: item.id,
         status: item.status,
         startedAt: item.started_at,
@@ -488,12 +785,24 @@ var BugBearClient = class {
             color: item.test_case.role.color,
             description: item.test_case.role.description,
             loginHint: item.test_case.role.login_hint
-          } : void 0
+          } : void 0,
+          platforms: item.test_case.platforms || void 0
         }
-      }));
+      });
+      const mapped = allData.filter((item) => {
+        if (!item.test_case) {
+          console.warn("BugBear: Assignment returned without test_case", { id: item.id });
+          return false;
+        }
+        return true;
+      }).map(mapItem);
       mapped.sort((a, b) => {
         if (a.isVerification && !b.isVerification) return -1;
         if (!a.isVerification && b.isVerification) return 1;
+        const aActive = a.status === "pending" || a.status === "in_progress";
+        const bActive = b.status === "pending" || b.status === "in_progress";
+        if (aActive && !bActive) return -1;
+        if (!aActive && bActive) return 1;
         return 0;
       });
       return mapped;
@@ -658,6 +967,36 @@ var BugBearClient = class {
   async failAssignment(assignmentId) {
     return this.updateAssignmentStatus(assignmentId, "failed");
   }
+  /**
+   * Reopen a completed assignment — sets it back to in_progress with a fresh timer.
+   * Clears completed_at and duration_seconds so it can be re-evaluated.
+   */
+  async reopenAssignment(assignmentId) {
+    try {
+      const { data: current, error: fetchError } = await this.supabase.from("test_assignments").select("status").eq("id", assignmentId).single();
+      if (fetchError || !current) {
+        return { success: false, error: "Assignment not found" };
+      }
+      if (current.status === "pending" || current.status === "in_progress") {
+        return { success: true };
+      }
+      const { error } = await this.supabase.from("test_assignments").update({
+        status: "in_progress",
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        completed_at: null,
+        duration_seconds: null,
+        skip_reason: null
+      }).eq("id", assignmentId).eq("status", current.status);
+      if (error) {
+        console.error("BugBear: Failed to reopen assignment", error);
+        return { success: false, error: error.message };
+      }
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
   /**
    * Skip a test assignment with a required reason
    * Marks the assignment as 'skipped' and records why it was skipped
@@ -698,6 +1037,7 @@ var BugBearClient = class {
    * This empowers testers to shape better tests over time
    */
   async submitTestFeedback(options) {
+    let feedbackPayload;
     try {
       const testerInfo = await this.getTesterInfo();
       if (!testerInfo) {
@@ -717,7 +1057,7 @@ var BugBearClient = class {
           return { success: false, error: `${name} must be between 1 and 5` };
         }
       }
-      const { error: feedbackError } = await this.supabase.from("test_feedback").insert({
+      feedbackPayload = {
         project_id: this.config.projectId,
         test_case_id: testCaseId,
         assignment_id: assignmentId || null,
@@ -735,8 +1075,13 @@ var BugBearClient = class {
         platform: this.getDeviceInfo().platform,
         time_to_complete_seconds: timeToCompleteSeconds || null,
         screenshot_urls: screenshotUrls || []
-      });
+      };
+      const { error: feedbackError } = await this.supabase.from("test_feedback").insert(feedbackPayload);
       if (feedbackError) {
+        if (this._queue && isNetworkError(feedbackError.message)) {
+          await this._queue.enqueue("feedback", feedbackPayload);
+          return { success: false, queued: true, error: "Queued \u2014 will send when online" };
+        }
         console.error("BugBear: Failed to submit feedback", feedbackError);
         return { success: false, error: feedbackError.message };
       }
@@ -753,6 +1098,10 @@ var BugBearClient = class {
       return { success: true };
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
+      if (this._queue && feedbackPayload && isNetworkError(message)) {
+        await this._queue.enqueue("feedback", feedbackPayload);
+        return { success: false, queued: true, error: "Queued \u2014 will send when online" };
+      }
       console.error("BugBear: Error submitting feedback", err);
       return { success: false, error: message };
     }
@@ -1387,6 +1736,7 @@ var BugBearClient = class {
    * Send a message to a thread
    */
   async sendMessage(threadId, content, attachments) {
+    let insertData;
     try {
       const testerInfo = await this.getTesterInfo();
       if (!testerInfo) {
@@ -1398,7 +1748,7 @@ var BugBearClient = class {
         console.error("BugBear: Rate limit exceeded for messages");
         return false;
       }
-      const insertData = {
+      insertData = {
         thread_id: threadId,
         sender_type: "tester",
         sender_tester_id: testerInfo.id,
@@ -1413,12 +1763,21 @@ var BugBearClient = class {
       }
       const { error } = await this.supabase.from("discussion_messages").insert(insertData);
       if (error) {
+        if (this._queue && isNetworkError(error.message)) {
+          await this._queue.enqueue("message", insertData);
+          return false;
+        }
         console.error("BugBear: Failed to send message", formatPgError(error));
         return false;
       }
       await this.markThreadAsRead(threadId);
       return true;
     } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      if (this._queue && insertData && isNetworkError(message)) {
+        await this._queue.enqueue("message", insertData);
+        return false;
+      }
       console.error("BugBear: Error sending message", err);
       return false;
     }
@@ -1754,8 +2113,11 @@ function createBugBear(config) {
 export {
   BUG_CATEGORIES,
   BugBearClient,
+  LocalStorageAdapter,
+  OfflineQueue,
   captureError,
   contextCapture,
   createBugBear,
-  isBugCategory
+  isBugCategory,
+  isNetworkError
 };

package/package.json

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