cuoral-ionic 0.0.1 → 0.0.2

package/dist/index.js

@@ -28,11 +28,9 @@ exports.CuoralMessageType = void 0;
 })(exports.CuoralMessageType || (exports.CuoralMessageType = {}));
 
 /**
- * Register the Capacitor plugin
+ * Register the Capacitor plugin (mobile only - iOS and Android)
  */
-const CuoralPlugin = core.registerPlugin('CuoralPlugin', {
-    web: () => Promise.resolve().then(function () { return web; }).then(m => new m.CuoralPluginWeb()),
-});
+const CuoralPlugin$1 = core.registerPlugin('CuoralPlugin');
 /**
  * High-level API for easier integration
  */
@@ -51,17 +49,17 @@ class CuoralRecorder {
                 return false;
             }
             // Check support
-            const { supported } = await CuoralPlugin.isRecordingSupported();
+            const { supported } = await CuoralPlugin$1.isRecordingSupported();
             if (!supported) {
                 throw new Error('Screen recording is not supported on this device');
             }
             // Request permissions
-            const { granted } = await CuoralPlugin.requestPermissions();
+            const { granted } = await CuoralPlugin$1.requestPermissions();
             if (!granted) {
                 throw new Error('Recording permissions not granted');
             }
             // Start recording
-            const result = await CuoralPlugin.startRecording(options);
+            const result = await CuoralPlugin$1.startRecording(options);
             if (result.success) {
                 this.isRecording = true;
                 this.recordingStartTime = Date.now();
@@ -71,10 +69,21 @@ class CuoralRecorder {
                     payload: { timestamp: this.recordingStartTime },
                 });
             }
+            else {
+                // Recording failed - reset state and notify widget
+                this.isRecording = false;
+                this.recordingStartTime = undefined;
+                this.postMessage({
+                    type: exports.CuoralMessageType.RECORDING_ERROR,
+                    payload: { error: 'Failed to start recording' },
+                });
+            }
             return result.success;
         }
         catch (error) {
-            console.error('[Cuoral] Failed to start recording:', error);
+            // Exception occurred - reset state and notify widget
+            this.isRecording = false;
+            this.recordingStartTime = undefined;
             this.postMessage({
                 type: exports.CuoralMessageType.RECORDING_ERROR,
                 payload: { error: error.message },
@@ -88,10 +97,14 @@ class CuoralRecorder {
     async stopRecording() {
         try {
             if (!this.isRecording) {
-                console.warn('[Cuoral] Not recording');
+                // Send error message to widget so it can exit "stopping" state
+                this.postMessage({
+                    type: exports.CuoralMessageType.RECORDING_ERROR,
+                    payload: { error: 'Not recording' },
+                });
                 return null;
             }
-            const result = await CuoralPlugin.stopRecording();
+            const result = await CuoralPlugin$1.stopRecording();
             if (result.success) {
                 this.isRecording = false;
                 const duration = this.recordingStartTime
@@ -110,6 +123,11 @@ class CuoralRecorder {
                     duration: result.duration || duration,
                 };
             }
+            // If result.success is false, send error to widget
+            this.postMessage({
+                type: exports.CuoralMessageType.RECORDING_ERROR,
+                payload: { error: 'Failed to stop recording' },
+            });
             return null;
         }
         catch (error) {
@@ -126,7 +144,7 @@ class CuoralRecorder {
      */
     async takeScreenshot(options) {
         try {
-            const screenshot = await CuoralPlugin.takeScreenshot(options);
+            const screenshot = await CuoralPlugin$1.takeScreenshot(options);
             // Post message to widget
             this.postMessage({
                 type: exports.CuoralMessageType.SCREENSHOT_TAKEN,
@@ -147,7 +165,7 @@ class CuoralRecorder {
      * Get current recording state
      */
     async getState() {
-        return await CuoralPlugin.getRecordingState();
+        return await CuoralPlugin$1.getRecordingState();
     }
     /**
      * Post message to WebView
@@ -539,11 +557,522 @@ class CuoralModal {
     }
 }
 
+// Register the Cuoral plugin for native error capture
+const CuoralPlugin = core.registerPlugin('CuoralPlugin');
+class CuoralIntelligence {
+    constructor(sessionId) {
+        this.config = {
+            consoleErrorBackendUrl: 'https://api.cuoral.com/customer-intelligence/console-error',
+            pageViewBackendUrl: 'https://api.cuoral.com/customer-intelligence/page-view',
+            apiResponseBackendUrl: 'https://api.cuoral.com/customer-intelligence/api-response',
+            batchSize: 10,
+            batchInterval: 2000,
+            maxQueueSize: 30,
+            retryAttempts: 1,
+            retryDelay: 2000,
+        };
+        this.queues = {
+            console_error: [],
+            unhandled_error: [],
+            page_view: [],
+            api_call: [],
+        };
+        this.batchTimers = {};
+        this.sessionId = null;
+        this.isInitialized = false;
+        this.lastPageViewTimestamp = Date.now();
+        this.lastPageViewScreen = '';
+        this.pendingEvents = [];
+        // Network monitoring state
+        this.originalFetch = null;
+        this.originalXMLHttpRequest = null;
+        this.sessionId = sessionId;
+    }
+    /**
+     * Initialize intelligence tracking
+     */
+    init() {
+        if (this.isInitialized) {
+            console.warn('[Cuoral Intelligence] Already initialized');
+            return;
+        }
+        this.setupConsoleErrorListener();
+        this.setupNetworkMonitoring();
+        this.setupAppStateListener();
+        this.setupNativeErrorCapture();
+        this.isInitialized = true;
+        this.flushPendingEvents();
+    }
+    /**
+     * Track a page/screen view
+     */
+    trackPageView(screen, metadata) {
+        const duration = Date.now() - this.lastPageViewTimestamp;
+        this.enqueueEvent('page_view', {
+            screen,
+            referrer: this.lastPageViewScreen,
+            duration,
+            metadata: metadata || {},
+        });
+        this.lastPageViewTimestamp = Date.now();
+        this.lastPageViewScreen = screen;
+    }
+    /**
+     * Track a console error manually
+     */
+    trackError(message, stackTrace, metadata) {
+        this.enqueueEvent('console_error', {
+            message,
+            stack_trace: stackTrace || 'No stack trace available',
+            log_level: 'error',
+            metadata: metadata || {},
+        });
+    }
+    /**
+     * Flush all queued events immediately
+     */
+    flush() {
+        Object.keys(this.queues).forEach((type) => {
+            this.flushQueue(type);
+        });
+    }
+    /**
+     * Destroy and cleanup
+     */
+    destroy() {
+        // Clear all timers
+        Object.keys(this.batchTimers).forEach((type) => {
+            if (this.batchTimers[type]) {
+                clearTimeout(this.batchTimers[type]);
+                delete this.batchTimers[type];
+            }
+        });
+        // Restore original functions
+        if (this.originalFetch) {
+            window.fetch = this.originalFetch;
+            this.originalFetch = null;
+        }
+        if (this.originalXMLHttpRequest) {
+            window.XMLHttpRequest = this.originalXMLHttpRequest;
+            this.originalXMLHttpRequest = null;
+        }
+        // Clear queues
+        Object.keys(this.queues).forEach((type) => {
+            this.queues[type] = [];
+        });
+        this.isInitialized = false;
+    }
+    /**
+     * Setup console error listener
+     */
+    setupConsoleErrorListener() {
+        // Override console.error
+        const originalConsoleError = console.error;
+        console.error = (...args) => {
+            originalConsoleError.apply(console, args);
+            try {
+                // Try to find an Error object in arguments to get real stack trace
+                let stack = '';
+                let message = '';
+                // Check each argument for error information
+                for (const arg of args) {
+                    if (arg instanceof Error) {
+                        stack = arg.stack || '';
+                        message = arg.message;
+                        break;
+                    }
+                    else if (arg && typeof arg === 'object') {
+                        if (arg.stack && typeof arg.stack === 'string') {
+                            stack = arg.stack;
+                            message = arg.message || arg.toString();
+                            break;
+                        }
+                        if (arg.rejection && arg.rejection instanceof Error) {
+                            stack = arg.rejection.stack || '';
+                            message = arg.rejection.message;
+                            break;
+                        }
+                        if (arg.error instanceof Error) {
+                            stack = arg.error.stack || '';
+                            message = arg.error.message;
+                            break;
+                        }
+                    }
+                }
+                // If no stack found, generate one from current context
+                // Note: Angular's ErrorHandler doesn't pass Error objects, so this will
+                // capture the console.error call stack, not the original error stack.
+                // For better error tracking, use source maps or test with unminified builds.
+                if (!stack) {
+                    const error = new Error();
+                    stack = error.stack || 'No stack trace available';
+                    message = args.map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ');
+                }
+                this.enqueueEvent('console_error', {
+                    message: message || 'Console error',
+                    stack_trace: stack,
+                    log_level: 'error',
+                    metadata: {},
+                });
+            }
+            catch (err) {
+                // Silently fail
+            }
+        };
+        // Global error handler
+        window.onerror = (message, source, lineno, colno, error) => {
+            try {
+                this.enqueueEvent('unhandled_error', {
+                    message: String(message),
+                    source: source || 'unknown',
+                    lineno: lineno || 0,
+                    colno: colno || 0,
+                    stack_trace: error?.stack || 'No stack trace available',
+                    log_level: 'error',
+                });
+            }
+            catch (err) {
+                // Silently fail
+            }
+            return false;
+        };
+        // Unhandled promise rejection
+        window.addEventListener('unhandledrejection', (event) => {
+            this.enqueueEvent('unhandled_error', {
+                message: event.reason instanceof Error ? event.reason.message : String(event.reason),
+                stack_trace: event.reason?.stack || 'No stack trace available',
+                log_level: 'error',
+            });
+        });
+    }
+    /**
+     * Setup network monitoring
+     */
+    setupNetworkMonitoring() {
+        // Store original fetch
+        if (!this.originalFetch) {
+            this.originalFetch = window.fetch;
+        }
+        // Override fetch
+        window.fetch = async (...args) => {
+            const url = args[0] instanceof Request ? args[0].url : args[0];
+            const method = args[0] instanceof Request && args[0].method
+                ? args[0].method
+                : args[1]?.method || 'GET';
+            const startTime = Date.now();
+            try {
+                const response = await this.originalFetch.apply(window, args);
+                const duration = Date.now() - startTime;
+                const status = response.status;
+                // Only track errors (4xx, 5xx)
+                if (status >= 400) {
+                    const responseClone = response.clone();
+                    try {
+                        const text = await responseClone.text();
+                        let responseData = null;
+                        try {
+                            const truncated = text.length > 5000 ? text.substring(0, 5000) + '...' : text;
+                            responseData = JSON.parse(truncated);
+                        }
+                        catch (e) {
+                            responseData = text.length > 5000 ? text.substring(0, 5000) + '...' : text;
+                        }
+                        this.enqueueEvent('api_call', {
+                            method,
+                            url,
+                            status_code: status,
+                            response_data: responseData,
+                            duration,
+                        });
+                    }
+                    catch (err) {
+                        this.enqueueEvent('api_call', {
+                            method,
+                            url,
+                            status_code: status,
+                            duration,
+                            error: 'Failed to read response body',
+                        });
+                    }
+                }
+                return response;
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                this.enqueueEvent('api_call', {
+                    method,
+                    url,
+                    status_code: 0,
+                    response_data: error.message || 'Network Error',
+                    duration,
+                    error: error.message || 'Network Error',
+                });
+                throw error;
+            }
+        };
+        // Store original XMLHttpRequest
+        if (!this.originalXMLHttpRequest && window.XMLHttpRequest) {
+            this.originalXMLHttpRequest = window.XMLHttpRequest;
+        }
+        // Override XMLHttpRequest
+        const originalOpen = XMLHttpRequest.prototype.open;
+        const originalSend = XMLHttpRequest.prototype.send;
+        XMLHttpRequest.prototype.open = function (method, url) {
+            this._cuoralMethod = method;
+            this._cuoralUrl = url;
+            return originalOpen.apply(this, arguments);
+        };
+        XMLHttpRequest.prototype.send = function () {
+            const startTime = Date.now();
+            const xhr = this;
+            const loadendHandler = () => {
+                try {
+                    const status = xhr.status;
+                    const duration = Date.now() - startTime;
+                    // Only track errors (4xx, 5xx)
+                    if (status >= 400) {
+                        let responseData = null;
+                        try {
+                            const responseText = xhr.responseText || '';
+                            const truncated = responseText.length > 5000
+                                ? responseText.substring(0, 5000) + '...'
+                                : responseText;
+                            responseData = truncated ? JSON.parse(truncated) : truncated;
+                        }
+                        catch (e) {
+                            const responseText = xhr.responseText || '';
+                            responseData = responseText.length > 5000
+                                ? responseText.substring(0, 5000) + '...'
+                                : responseText;
+                        }
+                        window._cuoralIntelligence?.enqueueEvent('api_call', {
+                            method: xhr._cuoralMethod,
+                            url: xhr._cuoralUrl,
+                            status_code: status,
+                            response_data: responseData,
+                            duration,
+                        });
+                    }
+                }
+                catch (err) {
+                    // Silently fail
+                }
+            };
+            this.addEventListener('loadend', loadendHandler, { once: true });
+            return originalSend.apply(this, arguments);
+        };
+        // Store reference for XMLHttpRequest monitoring
+        window._cuoralIntelligence = this;
+    }
+    /**
+     * Setup app state listener
+     */
+    setupAppStateListener() {
+        // Listen for app going to background
+        window.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                this.flush();
+            }
+        });
+        // Listen for app pause (Capacitor)
+        if (core.Capacitor.isNativePlatform()) {
+            window.addEventListener('pause', () => {
+                this.flush();
+            });
+        }
+    }
+    /**
+     * Enqueue an event
+     */
+    enqueueEvent(type, data) {
+        const queue = this.queues[type];
+        if (!queue) {
+            return;
+        }
+        // Don't track successful API calls (2xx, 3xx)
+        if (type === 'api_call' && data.status_code >= 200 && data.status_code < 400) {
+            return;
+        }
+        // Limit queue size
+        if (queue.length >= this.config.maxQueueSize) {
+            queue.shift();
+        }
+        const event = {
+            event_type: type,
+            timestamp: Date.now(),
+            session_id: this.sessionId || '',
+            user_agent: navigator.userAgent,
+            url: window.location.href,
+            data,
+        };
+        queue.push(event);
+        // Flush immediately for critical errors
+        const shouldFlushImmediately = type === 'api_call' && (data.status_code === 0 || data.status_code >= 400);
+        if (shouldFlushImmediately || queue.length >= this.config.batchSize) {
+            this.flushQueue(type);
+        }
+        else if (!this.batchTimers[type]) {
+            this.batchTimers[type] = setTimeout(() => this.flushQueue(type), this.config.batchInterval);
+        }
+    }
+    /**
+     * Flush a specific queue
+     */
+    flushQueue(eventType, useBeacon = false) {
+        const queue = this.queues[eventType];
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        // Clear timer
+        if (this.batchTimers[eventType]) {
+            clearTimeout(this.batchTimers[eventType]);
+            delete this.batchTimers[eventType];
+        }
+        const eventsToProcess = [...queue];
+        this.queues[eventType] = [];
+        let backendUrl;
+        let transformedPayload;
+        if (eventType === 'console_error' || eventType === 'unhandled_error') {
+            backendUrl = this.config.consoleErrorBackendUrl;
+            transformedPayload = eventsToProcess.map((event) => ({
+                message: event.data.message,
+                stack_trace: event.data.stack_trace,
+                log_level: 'error',
+                url: event.url,
+                session_id: event.session_id,
+                source: 'mobile',
+                console_metadata: event.data.metadata || {},
+            }));
+        }
+        else if (eventType === 'page_view') {
+            backendUrl = this.config.pageViewBackendUrl;
+            transformedPayload = eventsToProcess.map((event) => ({
+                session_id: event.session_id,
+                url: event.data.screen,
+                referrer: event.data.referrer,
+                user_agent: event.user_agent,
+                source: 'mobile',
+                page_metadata: {
+                    duration: event.data.duration,
+                    screen: event.data.screen,
+                    ...event.data.metadata,
+                },
+                timestamp: new Date(event.timestamp).toISOString(),
+            }));
+        }
+        else if (eventType === 'api_call') {
+            backendUrl = this.config.apiResponseBackendUrl;
+            transformedPayload = eventsToProcess
+                .map((event) => {
+                let responseBody = event.data.response_data;
+                if (typeof responseBody === 'string') {
+                    try {
+                        responseBody = JSON.parse(responseBody);
+                    }
+                    catch (e) {
+                        responseBody = { raw_text: responseBody };
+                    }
+                }
+                else if (responseBody === null || typeof responseBody === 'undefined') {
+                    responseBody = {};
+                }
+                return {
+                    url: event.data.url,
+                    method: event.data.method,
+                    status_code: event.data.status_code,
+                    response_body: responseBody,
+                    session_id: event.session_id,
+                    source: 'mobile',
+                    api_metadata: {
+                        duration: event.data.duration,
+                        error: event.data.error || null,
+                    },
+                };
+            })
+                .filter((item) => item !== null && item !== undefined);
+        }
+        else {
+            return;
+        }
+        const filteredPayload = transformedPayload.filter((item) => item !== null && item !== undefined);
+        if (backendUrl && filteredPayload.length > 0) {
+            this.sendToBackend(backendUrl, filteredPayload, useBeacon);
+        }
+    }
+    /**
+     * Send data to backend
+     */
+    async sendToBackend(url, payload, useBeacon = false, retryCount = 0) {
+        if (!this.sessionId) {
+            this.pendingEvents.push({ url, payload, useBeacon });
+            return;
+        }
+        if (!navigator.onLine) {
+            return;
+        }
+        const data = JSON.stringify(payload);
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: data,
+                keepalive: useBeacon,
+            });
+            if (!response.ok && retryCount < this.config.retryAttempts) {
+                setTimeout(() => {
+                    this.sendToBackend(url, payload, false, retryCount + 1);
+                }, this.config.retryDelay);
+            }
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+    /**
+     * Flush pending events
+     */
+    flushPendingEvents() {
+        if (this.pendingEvents.length > 0) {
+            const pending = [...this.pendingEvents];
+            this.pendingEvents = [];
+            pending.forEach(({ url, payload, useBeacon }) => {
+                this.sendToBackend(url, payload, useBeacon);
+            });
+        }
+    }
+    /**
+     * Setup native error capture for Android/iOS crashes
+     */
+    setupNativeErrorCapture() {
+        try {
+            // Only run on native platforms and if we have a session ID
+            if (core.Capacitor.isNativePlatform() && this.sessionId) {
+                CuoralPlugin.setupNativeErrorCapture({
+                    backendUrl: this.config.consoleErrorBackendUrl,
+                    sessionId: this.sessionId,
+                }).catch(() => {
+                    // Silently fail - native error capture optional
+                });
+            }
+        }
+        catch (error) {
+            // Silently fail if plugin is not available
+        }
+    }
+}
+
 /**
  * Main Cuoral class - simple API for users
  */
 class Cuoral {
     constructor(options) {
+        // Check if running on a mobile platform
+        if (!core.Capacitor.isNativePlatform()) {
+            throw new Error('Cuoral Ionic library only works on native mobile platforms (iOS/Android). Web is not supported.');
+        }
         this.options = {
             showFloatingButton: true,
             useModal: true,
@@ -579,12 +1108,103 @@ class Cuoral {
     /**
      * Initialize Cuoral
      */
-    initialize() {
+    async initialize() {
         this.bridge.initialize();
         // Initialize modal if enabled
         if (this.modal) {
             this.modal.initialize();
         }
+        // Fetch session configuration and initialize intelligence if enabled by backend
+        await this.initializeIntelligence();
+    }
+    /**
+     * Initialize intelligence based on backend configuration
+     */
+    async initializeIntelligence() {
+        try {
+            let sessionId = localStorage.getItem('__x_loadID');
+            // If no session exists, initiate a new one
+            if (!sessionId) {
+                sessionId = await this.initiateSession();
+                if (!sessionId) {
+                    console.warn('[Cuoral] Failed to create session, intelligence not initialized');
+                    return;
+                }
+            }
+            // Fetch session configuration
+            const config = await this.fetchSessionConfiguration(sessionId);
+            // If session was invalid/expired, try to initiate a new one
+            if (!config && !localStorage.getItem('__x_loadID')) {
+                sessionId = await this.initiateSession();
+                if (sessionId) {
+                    const newConfig = await this.fetchSessionConfiguration(sessionId);
+                    if (newConfig && newConfig.customer_intelligence === true) {
+                        this.intelligence = new CuoralIntelligence(sessionId);
+                        this.intelligence.init();
+                    }
+                }
+                return;
+            }
+            // Only initialize intelligence if customer_intelligence is enabled in backend
+            if (config && config.customer_intelligence === true) {
+                this.intelligence = new CuoralIntelligence(sessionId);
+                this.intelligence.init();
+            }
+        }
+        catch (error) {
+            console.warn('[Cuoral] Failed to initialize intelligence:', error);
+            // Silently fail - don't break the app if intelligence fails to initialize
+        }
+    }
+    /**
+     * Fetch session configuration from backend
+     */
+    async fetchSessionConfiguration(sessionId) {
+        try {
+            const response = await fetch('https://api.cuoral.com/conversation/session/get', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-org-id': this.options.publicKey,
+                },
+                body: JSON.stringify({ session_id: sessionId }),
+            });
+            if (response.status === 404 || response.status === 400) {
+                // Session not found, clear and return null
+                localStorage.removeItem('__x_loadID');
+                return null;
+            }
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            // If session is expired, clear it
+            if (data.is_expired) {
+                localStorage.removeItem('__x_loadID');
+                return null;
+            }
+            return data.configuration || null;
+        }
+        catch (error) {
+            console.warn('[Cuoral] Failed to fetch session configuration:', error);
+            return null;
+        }
+    }
+    /**
+     * Track a page/screen view
+     */
+    trackPageView(screen, metadata) {
+        if (this.intelligence) {
+            this.intelligence.trackPageView(screen, metadata);
+        }
+    }
+    /**
+     * Track an error manually
+     */
+    trackError(message, stackTrace, metadata) {
+        if (this.intelligence) {
+            this.intelligence.trackError(message, stackTrace, metadata);
+        }
     }
     /**
      * Open the widget modal
@@ -635,6 +1255,77 @@ class Cuoral {
         if (this.modal) {
             this.modal.destroy();
         }
+        // Destroy intelligence if exists
+        if (this.intelligence) {
+            this.intelligence.destroy();
+        }
+    }
+    /**
+     * Get or create session ID
+     */
+    getOrCreateSessionId() {
+        const storageKey = '__x_loadID';
+        let sessionId = localStorage.getItem(storageKey);
+        if (!sessionId) {
+            // Session will be created by initiate-session API call
+            // For now, return a temporary ID that will be replaced
+            sessionId = `temp-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        }
+        return sessionId;
+    }
+    /**
+     * Initiate a new session with backend (like inline.js does)
+     */
+    async initiateSession() {
+        try {
+            const response = await fetch('https://api.cuoral.com/conversation/initiate-session', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-org-id': this.options.publicKey,
+                },
+                body: JSON.stringify({ public_key: this.options.publicKey }),
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            if (data.status && data.session_id) {
+                localStorage.setItem('__x_loadID', data.session_id);
+                // Set profile if email, firstName, lastName are provided
+                if (this.options.email && this.options.firstName && this.options.lastName) {
+                    await this.setProfile(data.session_id);
+                }
+                return data.session_id;
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn('[Cuoral] Failed to initiate session:', error);
+            return null;
+        }
+    }
+    /**
+     * Set user profile for the session
+     */
+    async setProfile(sessionId) {
+        try {
+            await fetch('https://api.cuoral.com/conversation/set-profile', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-org-id': this.options.publicKey,
+                },
+                body: JSON.stringify({
+                    session_id: sessionId,
+                    email: this.options.email,
+                    name: `${this.options.firstName} ${this.options.lastName}`,
+                }),
+            });
+        }
+        catch (error) {
+            console.warn('[Cuoral] Failed to set profile:', error);
+        }
     }
     /**
      * Setup automatic message handlers
@@ -705,121 +1396,10 @@ class Cuoral {
 Cuoral.PRODUCTION_WIDGET_URL = 'https://js.cuoral.com/mobile.html';
 Cuoral.DEV_WIDGET_URL = 'assets/mobile.html';
 
-/**
- * Web implementation (for testing in browser)
- */
-class CuoralPluginWeb extends core.WebPlugin {
-    constructor() {
-        super(...arguments);
-        this.isRecording = false;
-    }
-    async startRecording(options) {
-        console.log('[Cuoral Web] Start recording', options);
-        // Check if Screen Capture API is available
-        if (!navigator.mediaDevices || !navigator.mediaDevices.getDisplayMedia) {
-            throw new Error('Screen recording is not supported in this browser');
-        }
-        try {
-            // Request screen capture
-            const stream = await navigator.mediaDevices.getDisplayMedia({
-                video: true,
-                audio: options?.includeAudio || false,
-            });
-            this.isRecording = true;
-            this.recordingStartTime = Date.now();
-            // Store stream for later stopping
-            window.__cuoralRecordingStream = stream;
-            return { success: true };
-        }
-        catch (error) {
-            console.error('[Cuoral Web] Failed to start recording:', error);
-            return { success: false };
-        }
-    }
-    async stopRecording() {
-        console.log('[Cuoral Web] Stop recording');
-        if (!this.isRecording) {
-            return { success: false };
-        }
-        const stream = window.__cuoralRecordingStream;
-        if (stream) {
-            stream.getTracks().forEach(track => track.stop());
-            delete window.__cuoralRecordingStream;
-        }
-        const duration = this.recordingStartTime
-            ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
-            : 0;
-        this.isRecording = false;
-        this.recordingStartTime = undefined;
-        return {
-            success: true,
-            duration,
-            filePath: 'web-recording-not-saved',
-        };
-    }
-    async getRecordingState() {
-        return {
-            isRecording: this.isRecording,
-            duration: this.recordingStartTime
-                ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
-                : undefined,
-        };
-    }
-    async takeScreenshot(options) {
-        console.log('[Cuoral Web] Take screenshot', options);
-        try {
-            // Use Screen Capture API
-            const stream = await navigator.mediaDevices.getDisplayMedia({
-                video: { width: 1920, height: 1080 },
-            });
-            // Capture frame from video stream
-            const video = document.createElement('video');
-            video.srcObject = stream;
-            video.play();
-            await new Promise(resolve => {
-                video.onloadedmetadata = resolve;
-            });
-            const canvas = document.createElement('canvas');
-            canvas.width = video.videoWidth;
-            canvas.height = video.videoHeight;
-            const ctx = canvas.getContext('2d');
-            ctx?.drawImage(video, 0, 0);
-            // Stop stream
-            stream.getTracks().forEach(track => track.stop());
-            // Convert to base64
-            const format = options?.format || 'png';
-            const quality = options?.quality || 0.92;
-            const base64 = canvas.toDataURL(`image/${format}`, quality);
-            return {
-                base64: base64.split(',')[1],
-                mimeType: `image/${format}`,
-                width: canvas.width,
-                height: canvas.height,
-            };
-        }
-        catch (error) {
-            console.error('[Cuoral Web] Failed to take screenshot:', error);
-            throw error;
-        }
-    }
-    async isRecordingSupported() {
-        const supported = !!(navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia);
-        return { supported };
-    }
-    async requestPermissions() {
-        // Web doesn't require explicit permissions - they're requested on demand
-        return { granted: true };
-    }
-}
-
-var web = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  CuoralPluginWeb: CuoralPluginWeb
-});
-
 exports.Cuoral = Cuoral;
 exports.CuoralBridge = CuoralBridge;
+exports.CuoralIntelligence = CuoralIntelligence;
 exports.CuoralModal = CuoralModal;
-exports.CuoralPlugin = CuoralPlugin;
+exports.CuoralPlugin = CuoralPlugin$1;
 exports.CuoralRecorder = CuoralRecorder;
 //# sourceMappingURL=index.js.map