cuoral-ionic 0.0.6 → 0.0.8

package/src/cuoral.ts

@@ -42,6 +42,8 @@ export class Cuoral {
   private static readonly DEV_WIDGET_URL = 'assets/mobile.html';
 
   constructor(options: CuoralOptions) {
+    console.log('[Cuoral] Constructor called with options:', options);
+    
     // Check if running on a mobile platform
     if (!Capacitor.isNativePlatform()) {
       throw new Error('Cuoral Ionic library only works on native mobile platforms (iOS/Android). Web is not supported.');
@@ -53,6 +55,8 @@ export class Cuoral {
       ...options
     };
     
+    console.log('[Cuoral] Merged options:', this.options);
+    
     // Determine widget base URL
     const baseUrl = options.widgetBaseUrl || Cuoral.PRODUCTION_WIDGET_URL;
     const params = new URLSearchParams({
@@ -61,6 +65,12 @@ export class Cuoral {
       _t: Date.now().toString(),
     });
     
+    // Add session_id if available (for widget to use existing session)
+    const existingSessionId = localStorage.getItem('__x_loadID');
+    if (existingSessionId) {
+      params.set('cuoral_mobile_session_id', existingSessionId);
+    }
+    
     if (options.email) params.set('email', options.email);
     if (options.firstName) params.set('first_name', options.firstName);
     if (options.lastName) params.set('last_name', options.lastName);
@@ -80,14 +90,29 @@ export class Cuoral {
     
     this.recorder = new CuoralRecorder();
     
+    // Expose bridge on window for widget detection and debugging
+    (window as any).CuoralCapacitorBridge = true;
+    (window as any).__cuoralBridge = this.bridge;  // For debugging
+    (window as any).__cuoralRecorder = this.recorder;  // For debugging
+    console.log('[Cuoral] Bridge and recorder created, exposed on window');
+    
     // Setup automatic message handlers
     this.setupMessageHandlers();
+    console.log('[Cuoral] Constructor complete');
   }
 
   /**
    * Initialize Cuoral
    */
   public async initialize(): Promise<void> {
+    // Fetch session configuration and initialize intelligence if enabled by backend
+    await this.initializeIntelligence();
+    
+    console.log('[Cuoral] Initialize - Session ID:', localStorage.getItem('__x_loadID'));
+    
+    // Setup localStorage listener to detect when widget changes session
+    this.setupStorageListener();
+    
     this.bridge.initialize();
     
     // Recreate modal if it was destroyed (e.g., after clearSession)
@@ -96,13 +121,12 @@ export class Cuoral {
       this.modal = new CuoralModal(widgetUrl, this.options.showFloatingButton);
     }
     
-    // Initialize modal if enabled
+    // Update modal URL with session ID
     if (this.modal) {
+      const widgetUrl = this.getWidgetUrl();
+      this.modal.updateWidgetUrl(widgetUrl);
       this.modal.initialize();
     }
-    
-    // Fetch session configuration and initialize intelligence if enabled by backend
-    await this.initializeIntelligence();
   }
 
   /**
@@ -139,8 +163,11 @@ export class Cuoral {
       
       // Only initialize intelligence if customer_intelligence is enabled in backend
       if (config && config.customer_intelligence === true) {
+        console.log('[Cuoral] Initializing intelligence with session:', sessionId);
         this.intelligence = new CuoralIntelligence(sessionId);
         this.intelligence.init();
+      } else {
+        console.log('[Cuoral] Intelligence not enabled or no config for session:', sessionId);
       }
     } catch (error) {
       console.warn('[Cuoral] Failed to initialize intelligence:', error);
@@ -205,6 +232,54 @@ export class Cuoral {
     }
   }
 
+  /**
+   * Update user profile for the current session
+   * Call this after user logs in to update the intelligence session with their profile
+   * @param email - User's email address
+   * @param name - User's full name
+   */
+  public async updateUserProfile(email: string, name: string): Promise<boolean> {
+    try {
+      const sessionId = localStorage.getItem('__x_loadID');
+      if (!sessionId) {
+        console.warn('[Cuoral] No session ID found, cannot update profile');
+        return false;
+      }
+
+      console.log('[Cuoral] Updating user profile for session:', sessionId);
+      
+      const response = await fetch('https://api.cuoral.com/conversation/set-profile', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          session_id: sessionId,
+          email: email,
+          name: name,
+        }),
+      });
+
+      if (!response.ok) {
+        console.error('[Cuoral] Failed to update profile:', response.statusText);
+        return false;
+      }
+
+      console.log('[Cuoral] ✓ User profile updated successfully for session:', sessionId);
+      
+      // Store user info locally
+      this.options.email = email;
+      const nameParts = name.split(' ');
+      if (nameParts.length > 0) {
+        this.options.firstName = nameParts[0];
+        this.options.lastName = nameParts.slice(1).join(' ');
+      }
+      
+      return true;
+    } catch (error) {
+      console.error('[Cuoral] Error updating user profile:', error);
+      return false;
+    }
+  }
+
   /**
    * Start native screen recording programmatically
    * @returns Promise<boolean> - true if recording started successfully
@@ -220,11 +295,20 @@ export class Cuoral {
 
   /**
    * Stop native screen recording programmatically
-   * @returns Promise<{filePath?: string; duration?: number} | null> - Recording result or null if failed
+   * Recording will be automatically uploaded to the portal
+   * @returns Promise<{filePath?: string; duration?: number; uploaded?: boolean} | null> - Recording result or null if failed
    */
-  public async stopRecording(): Promise<{filePath?: string; duration?: number} | null> {
+  public async stopRecording(): Promise<{filePath?: string; duration?: number; uploaded?: boolean} | null> {
     try {
-      return await this.recorder.stopRecording();
+      const sessionId = localStorage.getItem('__x_loadID');
+      const customerId = localStorage.getItem('cuoralCustomerId');
+      
+      return await this.recorder.stopRecording({
+        autoUpload: true,
+        sessionId: sessionId || undefined,
+        publicKey: this.options.publicKey,
+        customerId: customerId || undefined,
+      });
     } catch (error) {
       console.error('[Cuoral] Failed to stop recording:', error);
       return null;
@@ -274,7 +358,7 @@ export class Cuoral {
     // Add session_id if available
     const sessionId = localStorage.getItem('__x_loadID');
     if (sessionId) {
-      params.set('session_id', sessionId);
+      params.set('cuoral_mobile_session_id', sessionId);
     }
     
     if (this.options.email) params.set('email', this.options.email);
@@ -333,6 +417,32 @@ export class Cuoral {
     }
   }
 
+  /**
+   * Setup localStorage listener for session changes
+   * Widget updates localStorage when creating new session, SDK detects and syncs
+   */
+  private setupStorageListener(): void {
+    // Poll localStorage every 2 seconds to detect session changes
+    // (storage event doesn't fire for same-window changes)
+    let lastKnownSession = localStorage.getItem('__x_loadID');
+    
+    setInterval(() => {
+      const currentSession = localStorage.getItem('__x_loadID');
+      if (currentSession && currentSession !== lastKnownSession) {
+        console.log('[Cuoral] 🔄 Session changed in localStorage');
+        console.log('[Cuoral] Old session:', lastKnownSession);
+        console.log('[Cuoral] New session:', currentSession);
+        
+        lastKnownSession = currentSession;
+        
+        // Update intelligence to use new session
+        if (this.intelligence) {
+          this.intelligence.updateSessionId(currentSession);
+        }
+      }
+    }, 2000);
+  }
+
   /**
    * Clean up resources
    */
@@ -431,18 +541,52 @@ export class Cuoral {
   private setupMessageHandlers(): void {
     // Handle start recording requests from widget
     this.bridge.on(CuoralMessageType.START_RECORDING, async () => {
-      const success = await this.recorder.startRecording();
-      if (!success) {
-        // Error already handled by recorder
+      // Pass sendMessages: false to prevent duplicate messages
+      const success = await this.recorder.startRecording(undefined, false);
+      if (success) {
+        // Send RECORDING_STARTED back to widget
+        this.bridge.sendToWidget({
+          type: CuoralMessageType.RECORDING_STARTED,
+          payload: {
+            timestamp: Date.now()
+          }
+        });
+      } else {
+        this.bridge.sendToWidget({
+          type: CuoralMessageType.RECORDING_ERROR,
+          payload: {
+            error: 'Failed to start recording'
+          }
+        });
       }
     });
 
     // Handle stop recording requests from widget
     this.bridge.on(CuoralMessageType.STOP_RECORDING, async () => {
-      const result = await this.recorder.stopRecording();
+      const sessionId = localStorage.getItem('__x_loadID');
+      const customerId = localStorage.getItem('cuoralCustomerId');
       
-      if (result) {
-        // Convert file path to web-accessible URL
+      // Pass sendMessages: false to prevent duplicate messages
+      const result = await this.recorder.stopRecording({
+        autoUpload: true,
+        sessionId: sessionId || undefined,
+        publicKey: this.options.publicKey,
+        customerId: customerId || undefined,
+      }, false);
+      
+      if (result && result.uploaded) {
+        // Video was automatically uploaded, notify widget with RECORDING_STOPPED
+        this.bridge.sendToWidget({
+          type: CuoralMessageType.RECORDING_STOPPED,
+          payload: {
+            duration: result.duration,
+            uploaded: true,
+            uploadedToBackend: true,
+            timestamp: Date.now()
+          }
+        });
+      } else if (result) {
+        // Upload failed or was disabled, send video data to widget (old behavior)
         const capacitorUrl = result.filePath ? Capacitor.convertFileSrc(result.filePath) : '';
         
         try {

package/src/intelligence.ts

@@ -117,6 +117,27 @@ export class CuoralIntelligence {
     this.sessionId = sessionId;
   }
 
+  /**
+   * Update the session ID (e.g., when user logs in)
+   */
+  public updateSessionId(newSessionId: string): void {
+    console.log('[Cuoral Intelligence] Updating session ID from', this.sessionId, 'to', newSessionId);
+    this.sessionId = newSessionId;
+    
+    // Flush any pending events with the old session before switching
+    this.flush();
+    
+    // Update native error capture with new session ID
+    if (Capacitor.isNativePlatform()) {
+      CuoralPlugin.setupNativeErrorCapture({
+        backendUrl: this.config.consoleErrorBackendUrl,
+        sessionId: newSessionId
+      }).catch(error => {
+        console.warn('[Cuoral Intelligence] Failed to update native error capture:', error);
+      });
+    }
+  }
+
   /**
    * Initialize intelligence tracking
    */
@@ -482,6 +503,7 @@ export class CuoralIntelligence {
       data,
     };
 
+    console.log(`[Intelligence] Enqueuing ${type} event with session:`, this.sessionId);
     queue.push(event);
 
     // Flush immediately for critical errors
@@ -506,6 +528,7 @@ export class CuoralIntelligence {
       return;
     }
 
+
     // Clear timer
     if (this.batchTimers[eventType]) {
       clearTimeout(this.batchTimers[eventType]);

package/src/plugin.ts

@@ -19,7 +19,18 @@ export interface CuoralPluginInterface {
   /**
    * Stop screen recording
    */
-  stopRecording(): Promise<{ success: boolean; filePath?: string; duration?: number }>;
+  stopRecording(options?: {
+    autoUpload?: boolean;
+    sessionId?: string;
+    publicKey?: string;
+    customerId?: string;
+  }): Promise<{ 
+    success: boolean; 
+    filePath?: string; 
+    duration?: number;
+    uploaded?: boolean;
+    uploadError?: string;
+  }>;
 
   /**
    * Get recording state
@@ -59,7 +70,7 @@ export class CuoralRecorder {
   /**
    * Start recording with automatic permission handling
    */
-  async startRecording(options?: RecordingOptions): Promise<boolean> {
+  async startRecording(options?: RecordingOptions, sendMessages: boolean = true): Promise<boolean> {
     try {
       // Check if already recording
       if (this.isRecording) {
@@ -86,20 +97,24 @@ export class CuoralRecorder {
         this.isRecording = true;
         this.recordingStartTime = Date.now();
         
-        // Post message to widget
-        this.postMessage({
-          type: CuoralMessageType.RECORDING_STARTED,
-          payload: { timestamp: this.recordingStartTime },
-        });
+        // Post message to widget only if enabled (disabled when called from widget handler)
+        if (sendMessages) {
+          this.postMessage({
+            type: CuoralMessageType.RECORDING_STARTED,
+            payload: { timestamp: this.recordingStartTime },
+          });
+        }
       } else {
         // Recording failed - reset state and notify widget
         this.isRecording = false;
         this.recordingStartTime = undefined;
         
-        this.postMessage({
-          type: CuoralMessageType.RECORDING_ERROR,
-          payload: { error: 'Failed to start recording' },
-        });
+        if (sendMessages) {
+          this.postMessage({
+            type: CuoralMessageType.RECORDING_ERROR,
+            payload: { error: 'Failed to start recording' },
+          });
+        }
       }
 
       return result.success;
@@ -108,10 +123,12 @@ export class CuoralRecorder {
       this.isRecording = false;
       this.recordingStartTime = undefined;
       
-      this.postMessage({
-        type: CuoralMessageType.RECORDING_ERROR,
-        payload: { error: (error as Error).message },
-      });
+      if (sendMessages) {
+        this.postMessage({
+          type: CuoralMessageType.RECORDING_ERROR,
+          payload: { error: (error as Error).message },
+        });
+      }
       return false;
     }
   }
@@ -119,51 +136,67 @@ export class CuoralRecorder {
   /**
    * Stop recording
    */
-  async stopRecording(): Promise<{ filePath?: string; duration?: number } | null> {
+  async stopRecording(options?: {
+    autoUpload?: boolean;
+    sessionId?: string;
+    publicKey?: string;
+    customerId?: string;
+  }, sendMessages: boolean = true): Promise<{ filePath?: string; duration?: number; uploaded?: boolean } | null> {
     try {
       if (!this.isRecording) {
         // Send error message to widget so it can exit "stopping" state
-        this.postMessage({
-          type: CuoralMessageType.RECORDING_ERROR,
-          payload: { error: 'Not recording' },
-        });
+        if (sendMessages) {
+          this.postMessage({
+            type: CuoralMessageType.RECORDING_ERROR,
+            payload: { error: 'Not recording' },
+          });
+        }
         return null;
       }
 
-      const result = await CuoralPlugin.stopRecording();
+      const result = await CuoralPlugin.stopRecording(options);
       if (result.success) {
         this.isRecording = false;
         const duration = this.recordingStartTime 
           ? Math.floor((Date.now() - this.recordingStartTime) / 1000)
           : 0;
 
-        // Post message to widget
-        this.postMessage({
-          type: CuoralMessageType.RECORDING_STOPPED,
-          payload: {
-            filePath: result.filePath,
-            duration: result.duration || duration,
-          },
-        });
+        // Send RECORDING_STOPPED message only if enabled
+        if (sendMessages) {
+          this.postMessage({
+            type: CuoralMessageType.RECORDING_STOPPED,
+            payload: {
+              filePath: result.filePath,
+              duration: result.duration || duration,
+              uploaded: result.uploaded,
+              uploadedToBackend: result.uploaded,
+            },
+          });
+        }
 
         return {
           filePath: result.filePath,
           duration: result.duration || duration,
+          uploaded: result.uploaded,
         };
       }
 
       // If result.success is false, send error to widget
-      this.postMessage({
-        type: CuoralMessageType.RECORDING_ERROR,
-        payload: { error: 'Failed to stop recording' },
-      });
+      if (sendMessages) {
+        this.postMessage({
+          type: CuoralMessageType.RECORDING_ERROR,
+          payload: { error: 'Failed to stop recording' },
+        });
+      }
       return null;
     } catch (error) {
       console.error('[Cuoral] Failed to stop recording:', error);
-      this.postMessage({
-        type: CuoralMessageType.RECORDING_ERROR,
-        payload: { error: (error as Error).message },
-      });
+      if (sendMessages) {
+        this.postMessage({
+          type: CuoralMessageType.RECORDING_ERROR,
+          payload: { error: (error as Error).message },
+        });
+      }
       return null;
     }
   }

package/src/types.ts

@@ -7,6 +7,7 @@ export enum CuoralMessageType {
   STOP_RECORDING = 'CUORAL_STOP_RECORDING',
   RECORDING_STARTED = 'CUORAL_RECORDING_STARTED',
   RECORDING_STOPPED = 'CUORAL_RECORDING_STOPPED',
+  RECORDING_UPLOADED = 'CUORAL_RECORDING_UPLOADED',
   RECORDING_ERROR = 'CUORAL_RECORDING_ERROR',
   
   // Screenshot
@@ -17,6 +18,9 @@ export enum CuoralMessageType {
   // Widget Communication
   WIDGET_READY = 'CUORAL_WIDGET_READY',
   WIDGET_CLOSED = 'CUORAL_WIDGET_CLOSED',
+  SESSION_UPDATED = 'CUORAL_SESSION_UPDATED',
+  REQUEST_SESSION_ID = 'CUORAL_REQUEST_SESSION_ID',
+  SESSION_ID_RESPONSE = 'CUORAL_SESSION_ID_RESPONSE',
   
   // File Upload
   UPLOAD_FILE = 'CUORAL_UPLOAD_FILE',