cuoral-ionic 0.0.5 → 0.0.7

package/ios/Plugin/CuoralPlugin.swift

@@ -110,10 +110,19 @@ public class CuoralPlugin: CAPPlugin {
         do {
             assetWriter = try AVAssetWriter(url: outputURL, fileType: .mp4)
             
+            // Reduced quality settings to prevent huge file sizes
+            // 2.5 Mbps bitrate = ~18MB per minute (down from ~600MB per minute)
+            let compressionProperties: [String: Any] = [
+                AVVideoAverageBitRateKey: 2_500_000, // 2.5 Mbps
+                AVVideoMaxKeyFrameIntervalKey: 30,
+                AVVideoProfileLevelKey: AVVideoProfileLevelH264BaselineAutoLevel
+            ]
+            
             let videoSettings: [String: Any] = [
                 AVVideoCodecKey: AVVideoCodecType.h264,
                 AVVideoWidthKey: UIScreen.main.bounds.width * UIScreen.main.scale,
-                AVVideoHeightKey: UIScreen.main.bounds.height * UIScreen.main.scale
+                AVVideoHeightKey: UIScreen.main.bounds.height * UIScreen.main.scale,
+                AVVideoCompressionPropertiesKey: compressionProperties
             ]
             
             videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoSettings)
@@ -184,6 +193,12 @@ public class CuoralPlugin: CAPPlugin {
         
         isRecording = false
         
+        // Get upload parameters
+        let shouldUpload = call.getBool("autoUpload") ?? true
+        let sessionId = call.getString("sessionId") ?? ""
+        let publicKey = call.getString("publicKey") ?? ""
+        let customerId = call.getString("customerId") ?? ""
+        
         recorder.stopCapture { [weak self] error in
             guard let self = self else { return }
             
@@ -208,20 +223,241 @@ public class CuoralPlugin: CAPPlugin {
                 let duration = self.recordingStartTime.map { Date().timeIntervalSince($0) } ?? 0
                 let filePath = self.videoOutputURL?.path ?? ""
                 
-                call.resolve([
-                    "success": true,
-                    "filePath": filePath,
-                    "duration": Int(duration)
-                ])
-                
-                // Clean up
-                self.assetWriter = nil
-                self.videoInput = nil
-                self.videoOutputURL = nil
-                self.recordingStartTime = nil
-                self.firstFrameTime = nil
+                // If autoUpload is enabled, upload the video
+                if shouldUpload && !sessionId.isEmpty && !publicKey.isEmpty {
+                    self.uploadRecording(
+                        filePath: filePath,
+                        sessionId: sessionId,
+                        publicKey: publicKey,
+                        customerId: customerId,
+                        duration: Int(duration)
+                    ) { success, error in
+                        if success {
+                            call.resolve([
+                                "success": true,
+                                "filePath": filePath,
+                                "duration": Int(duration),
+                                "uploaded": true
+                            ])
+                        } else {
+                            call.resolve([
+                                "success": true,
+                                "filePath": filePath,
+                                "duration": Int(duration),
+                                "uploaded": false,
+                                "uploadError": error ?? "Unknown error"
+                            ])
+                        }
+                        
+                        // Clean up
+                        self.assetWriter = nil
+                        self.videoInput = nil
+                        self.videoOutputURL = nil
+                        self.recordingStartTime = nil
+                        self.firstFrameTime = nil
+                    }
+                } else {
+                    // No upload, just return file path
+                    call.resolve([
+                        "success": true,
+                        "filePath": filePath,
+                        "duration": Int(duration),
+                        "uploaded": false
+                    ])
+                    
+                    // Clean up
+                    self.assetWriter = nil
+                    self.videoInput = nil
+                    self.videoOutputURL = nil
+                    self.recordingStartTime = nil
+                    self.firstFrameTime = nil
+                }
+            }
+        }
+    }
+    
+    /**
+     * Upload recording to Cuoral backend
+     */
+    private func uploadRecording(
+        filePath: String,
+        sessionId: String,
+        publicKey: String,
+        customerId: String,
+        duration: Int,
+        completion: @escaping (Bool, String?) -> Void
+    ) {
+        guard let fileURL = URL(string: "file://\(filePath)"),
+              FileManager.default.fileExists(atPath: filePath) else {
+            completion(false, "File not found")
+            return
+        }
+        
+        // Read video data
+        guard let videoData = try? Data(contentsOf: fileURL) else {
+            completion(false, "Failed to read video file")
+            return
+        }
+        
+        // Step 1: Initiate recording to get record_id
+        initiateRecording(sessionId: sessionId, customerId: customerId, publicKey: publicKey) { recordId, error in
+            if let error = error {
+                completion(false, "Failed to initiate recording: \(error)")
+                return
             }
+            
+            guard let recordId = recordId else {
+                completion(false, "No record ID returned")
+                return
+            }
+            
+            // Step 2: Upload video with the record_id
+            self.uploadVideo(
+                videoData: videoData,
+                recordId: recordId,
+                publicKey: publicKey,
+                customerId: customerId,
+                duration: duration,
+                completion: completion
+            )
+        }
+    }
+    
+    /**
+     * Step 1: Initiate recording session
+     */
+    private func initiateRecording(
+        sessionId: String,
+        customerId: String,
+        publicKey: String,
+        completion: @escaping (String?, String?) -> Void
+    ) {
+        let url = URL(string: "https://api.cuoral.com/customer-intelligence/initiate/record")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        request.setValue(publicKey, forHTTPHeaderField: "x-org-id")
+        
+        // API needs both session_id and customer_id (matching widget.js)
+        let body: [String: String] = [
+            "session_id": sessionId,
+            "customer_id": customerId
+        ]
+        
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: body) else {
+            completion(nil, "Failed to serialize JSON")
+            return
         }
+        
+        request.httpBody = jsonData
+        request.timeoutInterval = 30.0
+        
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(nil, error.localizedDescription)
+                return
+            }
+            
+            guard let httpResponse = response as? HTTPURLResponse else {
+                completion(nil, "Invalid response")
+                return
+            }
+            
+            // API returns JSON: { status: 'success', record_id: '...' }
+            guard httpResponse.statusCode == 200, let data = data else {
+                completion(nil, "Failed to initiate recording (status \(httpResponse.statusCode))")
+                return
+            }
+            
+            // Parse JSON response
+            guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let status = json["status"] as? String,
+                  status == "success",
+                  let recordId = json["record_id"] as? String else {
+                completion(nil, "Invalid response format")
+                return
+            }
+            
+            completion(recordId, nil)
+        }.resume()
+    }
+    
+    /**
+     * Step 2: Upload video to the initiated recording
+     */
+    private func uploadVideo(
+        videoData: Data,
+        recordId: String,
+        publicKey: String,
+        customerId: String,
+        duration: Int,
+        completion: @escaping (Bool, String?) -> Void
+    ) {
+        // Create multipart form data
+        let boundary = "Boundary-\(UUID().uuidString)"
+        var body = Data()
+        
+        // Add form fields (API spec: only record_id is required)
+        let parameters: [String: String] = [
+            "record_id": recordId,
+            "console_error": "[]",
+            "api_response_log": "[]",
+            "page_view": "[]"
+        ]
+        
+        for (key, value) in parameters {
+            body.append("--\(boundary)\r\n".data(using: .utf8)!)
+            body.append("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n".data(using: .utf8)!)
+            body.append("\(value)\r\n".data(using: .utf8)!)
+        }
+        
+        // Add video file
+        body.append("--\(boundary)\r\n".data(using: .utf8)!)
+        body.append("Content-Disposition: form-data; name=\"record_media\"; filename=\"recording.mp4\"\r\n".data(using: .utf8)!)
+        body.append("Content-Type: video/mp4\r\n\r\n".data(using: .utf8)!)
+        body.append(videoData)
+        body.append("\r\n".data(using: .utf8)!)
+        body.append("--\(boundary)--\r\n".data(using: .utf8)!)
+        
+        // Create request
+        let url = URL(string: "https://api.cuoral.com/customer-intelligence/update/record")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+        request.setValue("*/*", forHTTPHeaderField: "Accept")
+        // Note: widget.js doesn't send x-org-id for update endpoint
+        request.httpBody = body
+        request.timeoutInterval = 60.0 // 60 seconds for upload
+        
+        // Send request
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(false, error.localizedDescription)
+                return
+            }
+            
+            guard let httpResponse = response as? HTTPURLResponse else {
+                completion(false, "Invalid response")
+                return
+            }
+            
+            // API returns JSON: { status: 'success' }
+            guard httpResponse.statusCode == 200, let data = data else {
+                completion(false, "Upload failed with status \(httpResponse.statusCode)")
+                return
+            }
+            
+            // Parse JSON response
+            guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let status = json["status"] as? String,
+                  status == "success" else {
+                completion(false, "Upload failed")
+                return
+            }
+            
+            completion(true, nil)
+        }.resume()
     }
     
     @objc func getRecordingState(_ call: CAPPluginCall) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cuoral-ionic",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Cuoral Ionic Framework Library - Proactive customer success platform with support ticketing, customer intelligence, screen recording, and engagement tools",
   "type": "module",
   "main": "dist/index.js",
@@ -51,7 +51,9 @@
     "rollup-plugin-typescript2": "^0.36.0",
     "typescript": "^5.0.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "rrweb": "^1.1.3"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/cuoral/cuoral-ionic.git"

package/src/cuoral.ts

@@ -61,6 +61,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);
@@ -88,6 +94,14 @@ export class Cuoral {
    * 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 +110,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 +152,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 +221,89 @@ 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
+   */
+  public async startRecording(): Promise<boolean> {
+    try {
+      return await this.recorder.startRecording();
+    } catch (error) {
+      console.error('[Cuoral] Failed to start recording:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Stop native screen recording programmatically
+   * 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; uploaded?: boolean} | null> {
+    try {
+      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;
+    }
+  }
+
   /**
    * Open the widget modal
    */
@@ -248,7 +347,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);
@@ -307,6 +406,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
    */
@@ -413,10 +538,28 @@ export class Cuoral {
 
     // 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
+      const result = await this.recorder.stopRecording({
+        autoUpload: true,
+        sessionId: sessionId || undefined,
+        publicKey: this.options.publicKey,
+        customerId: customerId || undefined,
+      });
+      
+      if (result && result.uploaded) {
+        // Video was automatically uploaded, just notify widget
+        this.bridge.sendToWidget({
+          type: CuoralMessageType.RECORDING_UPLOADED,
+          payload: {
+            duration: result.duration,
+            uploaded: 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 {