@bentolabs/sdk 1.0.0 → 1.0.3

package/dist/index.d.ts

@@ -2,16 +2,29 @@ interface SDKConfig {
     apiKey: string;
     endpoint: string;
     debug: boolean;
+    batchSize: number;
+    batchInterval: number;
+    enableRecording: boolean;
+    maxRetries: number;
+    baseRetryDelay: number;
 }
 interface SDKOptions {
     endpoint?: string;
     debug?: boolean;
+    batchSize?: number;
+    batchInterval?: number;
+    enableRecording?: boolean;
+    maxRetries?: number;
+    baseRetryDelay?: number;
 }
 export declare class BentoLabsSDK {
     private config;
     private sessionId;
     private events;
     private isRecording;
+    private batchTimer;
+    private retryTimer;
+    private stopRecording;
     constructor();
     /**
      * Initialize the BentoLabs SDK
@@ -35,6 +48,22 @@ export declare class BentoLabsSDK {
      * Start batching events for transmission
      */
     private startBatching;
+    /**
+     * Add an event to the events array
+     */
+    private addEvent;
+    /**
+     * Send batched events to the API with exponential backoff retry
+     */
+    private sendBatch;
+    /**
+     * Schedule retry attempts for failed events
+     */
+    private scheduleRetry;
+    /**
+     * Stop recording and clean up resources
+     */
+    stop(): void;
     /**
      * Get current session ID
      */
@@ -49,6 +78,14 @@ export declare class BentoLabsSDK {
     getConfig(): Omit<SDKConfig, 'apiKey'> & {
         apiKey: string;
     };
+    /**
+     * Get current event queue length
+     */
+    getEventQueueLength(): number;
+    /**
+     * Manually trigger a batch send
+     */
+    flushEvents(): Promise<void>;
 }
 declare const _default: BentoLabsSDK;
 export default _default;

package/dist/index.js

@@ -1,16 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BentoLabsSDK = void 0;
+const rrweb_1 = require("rrweb");
 class BentoLabsSDK {
     constructor() {
         this.config = {
             apiKey: '',
             endpoint: '',
             debug: false,
+            batchSize: 50,
+            batchInterval: 10000, // 10 seconds
+            enableRecording: true,
+            maxRetries: 3,
+            baseRetryDelay: 1000,
         };
         this.sessionId = '';
         this.events = [];
         this.isRecording = false;
+        this.batchTimer = null;
+        this.retryTimer = null;
+        this.stopRecording = null;
     }
     /**
      * Initialize the BentoLabs SDK
@@ -23,6 +32,11 @@ class BentoLabsSDK {
         const defaultOptions = {
             endpoint: 'https://api.bentolabs.ai', // Replace with your actual API URL
             debug: false,
+            batchSize: 50,
+            batchInterval: 10000, // 10 seconds
+            enableRecording: true,
+            maxRetries: 3,
+            baseRetryDelay: 1000, // 1 second
         };
         const mergedOptions = Object.assign(Object.assign(Object.assign({}, defaultOptions), options), { 
             // Ensure debug is always a boolean
@@ -32,6 +46,11 @@ class BentoLabsSDK {
             apiKey,
             endpoint: mergedOptions.endpoint,
             debug: mergedOptions.debug,
+            batchSize: mergedOptions.batchSize,
+            batchInterval: mergedOptions.batchInterval,
+            enableRecording: mergedOptions.enableRecording,
+            maxRetries: mergedOptions.maxRetries,
+            baseRetryDelay: mergedOptions.baseRetryDelay,
         };
         // Generate session ID with 'sess_' prefix
         this.sessionId = this.generateSessionId();
@@ -69,11 +88,39 @@ class BentoLabsSDK {
      * Start recording user interactions
      */
     startRecording() {
+        if (!this.config.enableRecording) {
+            if (this.config.debug) {
+                console.log('[BentoLabsSDK] Recording disabled in configuration');
+            }
+            return;
+        }
         if (this.config.debug) {
             console.log('[BentoLabsSDK] Starting recording for session:', this.sessionId);
         }
-        this.isRecording = true;
-        // TODO: Implement rrweb recording logic
+        try {
+            const stopFn = (0, rrweb_1.record)({
+                emit: (event) => {
+                    this.addEvent({
+                        timestamp: event.timestamp,
+                        type: event.type.toString(),
+                        data: event,
+                        sessionId: this.sessionId,
+                    });
+                },
+                recordCanvas: true,
+                collectFonts: true,
+                plugins: [],
+            });
+            this.stopRecording = stopFn || null;
+            this.isRecording = true;
+            if (this.config.debug) {
+                console.log('[BentoLabsSDK] Recording started successfully');
+            }
+        }
+        catch (error) {
+            console.error('[BentoLabsSDK] Failed to start recording:', error);
+            this.isRecording = false;
+        }
     }
     /**
      * Start batching events for transmission
@@ -82,7 +129,156 @@ class BentoLabsSDK {
         if (this.config.debug) {
             console.log('[BentoLabsSDK] Starting event batching');
         }
-        // TODO: Implement event batching logic
+        // Clear any existing timer
+        if (this.batchTimer) {
+            clearInterval(this.batchTimer);
+        }
+        // Set up periodic batch sending
+        this.batchTimer = setInterval(() => {
+            this.sendBatch();
+        }, this.config.batchInterval);
+        if (this.config.debug) {
+            console.log(`[BentoLabsSDK] Batch timer set for ${this.config.batchInterval}ms intervals`);
+        }
+    }
+    /**
+     * Add an event to the events array
+     */
+    addEvent(event) {
+        this.events.push(event);
+        if (this.config.debug) {
+            console.log('[BentoLabsSDK] Event added:', event.type);
+        }
+        // Check if we should send a batch based on size
+        if (this.events.length >= this.config.batchSize) {
+            if (this.config.debug) {
+                console.log(`[BentoLabsSDK] Batch size limit reached (${this.config.batchSize}), sending batch`);
+            }
+            this.sendBatch();
+        }
+    }
+    /**
+     * Send batched events to the API with exponential backoff retry
+     */
+    async sendBatch() {
+        // Filter out events that are not ready for retry yet
+        const now = Date.now();
+        const readyEvents = this.events.filter(event => {
+            if ('nextRetryTime' in event) {
+                return now >= event.nextRetryTime;
+            }
+            return true;
+        });
+        if (readyEvents.length === 0) {
+            return;
+        }
+        // Remove ready events from the main array
+        this.events = this.events.filter(event => !readyEvents.includes(event));
+        const payload = {
+            sessionId: this.sessionId,
+            events: readyEvents,
+            timestamp: now,
+            userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'Unknown',
+            url: typeof window !== 'undefined' ? window.location.href : 'Unknown',
+        };
+        if (this.config.debug) {
+            console.log(`[BentoLabsSDK] Sending batch with ${readyEvents.length} events`);
+        }
+        try {
+            const response = await fetch(`${this.config.endpoint}/events`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                    'X-Session-ID': this.sessionId,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            if (this.config.debug) {
+                console.log('[BentoLabsSDK] Batch sent successfully');
+            }
+        }
+        catch (error) {
+            console.error('[BentoLabsSDK] Failed to send batch:', error);
+            // Convert events to retryable events with exponential backoff
+            const retryableEvents = readyEvents.map(event => {
+                const retryCount = 'retryCount' in event ? event.retryCount + 1 : 1;
+                const delay = this.config.baseRetryDelay * Math.pow(2, retryCount - 1);
+                return Object.assign(Object.assign({}, event), { retryCount, nextRetryTime: now + delay });
+            });
+            // Filter out events that have exceeded max retries
+            const eventsToRetry = retryableEvents.filter(event => event.retryCount <= this.config.maxRetries);
+            const droppedEvents = retryableEvents.length - eventsToRetry.length;
+            if (droppedEvents > 0 && this.config.debug) {
+                console.log(`[BentoLabsSDK] Dropped ${droppedEvents} events after max retries`);
+            }
+            // Re-add events that can still be retried
+            this.events.unshift(...eventsToRetry);
+            if (this.config.debug && eventsToRetry.length > 0) {
+                const nextRetryIn = Math.min(...eventsToRetry.map(e => e.nextRetryTime)) - now;
+                console.log(`[BentoLabsSDK] ${eventsToRetry.length} events re-queued for retry in ${nextRetryIn}ms`);
+            }
+            // Set up retry timer if we have events to retry
+            this.scheduleRetry();
+        }
+    }
+    /**
+     * Schedule retry attempts for failed events
+     */
+    scheduleRetry() {
+        // Clear existing retry timer
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+        // Find the next retry time
+        const now = Date.now();
+        const retryableEvents = this.events.filter(event => 'nextRetryTime' in event);
+        if (retryableEvents.length === 0) {
+            return;
+        }
+        const nextRetryTime = Math.min(...retryableEvents.map(e => e.nextRetryTime));
+        const delay = Math.max(0, nextRetryTime - now);
+        if (this.config.debug) {
+            console.log(`[BentoLabsSDK] Scheduling retry in ${delay}ms`);
+        }
+        this.retryTimer = setTimeout(() => {
+            this.sendBatch();
+        }, delay);
+    }
+    /**
+     * Stop recording and clean up resources
+     */
+    stop() {
+        if (this.config.debug) {
+            console.log('[BentoLabsSDK] Stopping recording and batching');
+        }
+        // Stop rrweb recording
+        if (this.stopRecording) {
+            this.stopRecording();
+            this.stopRecording = null;
+        }
+        // Clear batch timer
+        if (this.batchTimer) {
+            clearInterval(this.batchTimer);
+            this.batchTimer = null;
+        }
+        // Clear retry timer
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+        // Send any remaining events
+        if (this.events.length > 0) {
+            this.sendBatch();
+        }
+        this.isRecording = false;
+        if (this.config.debug) {
+            console.log('[BentoLabsSDK] Stopped successfully');
+        }
     }
     /**
      * Get current session ID
@@ -106,8 +302,25 @@ class BentoLabsSDK {
                 : '',
             endpoint: this.config.endpoint,
             debug: this.config.debug,
+            batchSize: this.config.batchSize,
+            batchInterval: this.config.batchInterval,
+            enableRecording: this.config.enableRecording,
+            maxRetries: this.config.maxRetries,
+            baseRetryDelay: this.config.baseRetryDelay,
         };
     }
+    /**
+     * Get current event queue length
+     */
+    getEventQueueLength() {
+        return this.events.length;
+    }
+    /**
+     * Manually trigger a batch send
+     */
+    async flushEvents() {
+        await this.sendBatch();
+    }
 }
 exports.BentoLabsSDK = BentoLabsSDK;
 // Export a default instance for convenience

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bentolabs/sdk",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {