@onairos/react-native 3.0.66 → 3.0.68

package/src/components/UniversalOnboarding.tsx

@@ -503,9 +503,9 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
       
       console.log('📧 Email validation passed, proceeding...');
       
-      // For development mode, just proceed to verification step without API call
-      if (debug || test) {
-        console.log('🧪 Debug/test mode: Skipping API call, proceeding to verification');
+      // For test mode, just proceed to verification step without API call
+      if (isTestMode) {
+        console.log('🧪 Test mode: Skipping API call, proceeding to verification');
         setStep('verify');
         return;
       }
@@ -538,7 +538,7 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
         
         // Race between API call and timeout
         const result = await Promise.race([
-          requestEmailVerification(email.trim()),
+          requestEmailVerification(email.trim(), isTestMode),
           timeoutPromise
         ]) as any;
         
@@ -610,14 +610,14 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
         }
       }
 
-      // Real API call (production)
-      const result = await verifyEmailCode(email.trim(), verificationCode.trim());
+      // Real API call (production) or test mode
+      const result = await verifyEmailCode(email.trim(), verificationCode.trim(), isTestMode);
       
       if (result.success) {
         console.log('✅ Email verification successful');
         
-                 // Check if user exists in backend
-         const existingUser = (result as any).existingUser || false;
+        // Check if user exists in backend (properly typed now)
+        const existingUser = result.existingUser || false;
         setIsExistingUser(existingUser);
         
         if (existingUser) {
@@ -685,45 +685,240 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
     }
   }, [connections, selectedTier, platformToggles, username, AppName, auto, inferenceData, partner]);
 
-  const handleTrainingComplete = useCallback(() => {
+  const handleTrainingComplete = useCallback(async () => {
     console.log('🎉 Training completed successfully');
+    console.log('🔍 Auto mode enabled:', auto);
+    console.log('🔍 Inference data available:', !!inferenceData);
     
-    // Prepare completion data
-    const completionData = {
-      pin,
-      connections,
-      platformToggles,
-      selectedTier,
-      tierData: requestData?.[selectedTier],
-      sessionSaved: true,
-      // Add inference data if auto mode is enabled
-      ...(auto && inferenceData && { inferenceData }),
-      // Add partner info for special partners
-      ...(partner && { partner: partner === 'couplebible' ? 'CoupleBible' : partner }),
-    };
-    
-    console.log('Completion data prepared:', completionData);
-    
-    // Close the modal first
-    handleClose();
-    
-    // Then call the completion callback
-    setTimeout(() => {
-      onComplete('https://api2.onairos.uk', 'dummy-token', completionData);
-    }, 100);
-  }, [pin, connections, platformToggles, selectedTier, requestData, auto, inferenceData, partner, handleClose, onComplete]);
+    try {
+      if (auto && inferenceData) {
+        console.log('🤖 Auto mode: Making API request to get URL and perform inference');
+        
+        // First, get the API URL from backend
+        const apiUrlResponse = await fetch('https://api2.onairos.uk/', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            Info: {
+              storage: 'secure',
+              appId: AppName,
+              confirmations: Object.keys(requestData || {}),
+              EncryptedUserPin: pin, // Use the actual PIN from user
+              account: email.trim(),
+              proofMode: false,
+            }
+          })
+        });
+        
+        if (!apiUrlResponse.ok) {
+          throw new Error(`Failed to get API URL: ${apiUrlResponse.status}`);
+        }
+        
+        const { apiUrl, token } = await apiUrlResponse.json();
+        console.log('✅ Received API URL:', apiUrl);
+        console.log('✅ Received token:', token?.substring(0, 20) + '...');
+        
+        // Now make the inference call with the provided data
+        const inferenceResponse = await fetch(apiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+          },
+          body: JSON.stringify({
+            ...inferenceData,
+            userEmail: email.trim(),
+            appName: AppName,
+            timestamp: new Date().toISOString(),
+          })
+        });
+        
+        if (!inferenceResponse.ok) {
+          throw new Error(`Inference API failed: ${inferenceResponse.status}`);
+        }
+        
+        const inferenceResults = await inferenceResponse.json();
+        console.log('✅ Auto mode inference results:', inferenceResults);
+        
+        // Close the modal first
+        handleClose();
+        
+        // Complete onboarding with inference results
+        setTimeout(() => {
+          onComplete(apiUrl, token, {
+            pin,
+            connections,
+            platformToggles,
+            selectedTier,
+            tierData: requestData?.[selectedTier],
+            sessionSaved: true,
+            // Add inference data if auto mode is enabled
+            ...(auto && inferenceData && { inferenceData }),
+            // Add partner info for special partners
+            ...(partner && { partner: partner === 'couplebible' ? 'CoupleBible' : partner }),
+            autoMode: true,
+            inferenceResults,
+            apiUrl,
+            token,
+          });
+        }, 100);
+        
+      } else {
+        console.log('📋 Standard mode: Returning API URL for manual use');
+        
+        // Prepare completion data
+        const completionData = {
+          pin,
+          connections,
+          platformToggles,
+          selectedTier,
+          tierData: requestData?.[selectedTier],
+          sessionSaved: true,
+          // Add inference data if auto mode is enabled
+          ...(auto && inferenceData && { inferenceData }),
+          // Add partner info for special partners
+          ...(partner && { partner: partner === 'couplebible' ? 'CoupleBible' : partner }),
+          autoMode: false,
+        };
+        
+        console.log('Completion data prepared:', completionData);
+        
+        // Close the modal first
+        handleClose();
+        
+        // Then call the completion callback
+        setTimeout(() => {
+          onComplete('https://api2.onairos.uk', 'dummy-token', completionData);
+        }, 100);
+      }
+    } catch (error) {
+      console.error('❌ Error in training complete:', error);
+      
+      // Fallback to standard mode
+      const completionData = {
+        pin,
+        connections,
+        platformToggles,
+        selectedTier,
+        tierData: requestData?.[selectedTier],
+        sessionSaved: true,
+        // Add inference data if auto mode is enabled
+        ...(auto && inferenceData && { inferenceData }),
+        // Add partner info for special partners
+        ...(partner && { partner: partner === 'couplebible' ? 'CoupleBible' : partner }),
+        autoMode: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+      
+      console.log('Fallback completion data:', completionData);
+      
+      // Close the modal first
+      handleClose();
+      
+      // Then call the completion callback
+      setTimeout(() => {
+        onComplete('https://api2.onairos.uk', 'dummy-token', completionData);
+      }, 100);
+    }
+  }, [pin, connections, platformToggles, selectedTier, requestData, auto, inferenceData, partner, handleClose, onComplete, AppName, email]);
 
-  const handleDataRequestAccept = useCallback(() => {
+  const handleDataRequestAccept = useCallback(async () => {
     console.log('Data request accepted for existing user');
+    console.log('🔍 Auto mode enabled:', auto);
+    console.log('🔍 Inference data available:', !!inferenceData);
     
-    // Complete onboarding for existing user
-    onComplete('https://api2.onairos.uk', 'existing-session-token', {
-      existingAccount: true,
-      email: email.trim(),
-      dataRequestAccepted: true,
-      requestData,
-    });
-  }, [email, onComplete, requestData]);
+    try {
+      if (auto && inferenceData) {
+        console.log('🤖 Auto mode: Making API request to get URL and perform inference');
+        
+        // First, get the API URL from backend
+        const apiUrlResponse = await fetch('https://api2.onairos.uk/', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            Info: {
+              storage: 'secure', // or whatever storage type
+              appId: AppName,
+              confirmations: Object.keys(requestData || {}),
+              EncryptedUserPin: 'temp-pin', // This would come from user PIN in real flow
+              account: email.trim(),
+              proofMode: false,
+            }
+          })
+        });
+        
+        if (!apiUrlResponse.ok) {
+          throw new Error(`Failed to get API URL: ${apiUrlResponse.status}`);
+        }
+        
+        const { apiUrl, token } = await apiUrlResponse.json();
+        console.log('✅ Received API URL:', apiUrl);
+        console.log('✅ Received token:', token?.substring(0, 20) + '...');
+        
+        // Now make the inference call with the provided data
+        const inferenceResponse = await fetch(apiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+          },
+          body: JSON.stringify({
+            ...inferenceData,
+            userEmail: email.trim(),
+            appName: AppName,
+            timestamp: new Date().toISOString(),
+          })
+        });
+        
+        if (!inferenceResponse.ok) {
+          throw new Error(`Inference API failed: ${inferenceResponse.status}`);
+        }
+        
+        const inferenceResults = await inferenceResponse.json();
+        console.log('✅ Auto mode inference results:', inferenceResults);
+        
+        // Complete onboarding with inference results
+        onComplete(apiUrl, token, {
+          existingAccount: true,
+          email: email.trim(),
+          dataRequestAccepted: true,
+          requestData,
+          autoMode: true,
+          inferenceResults,
+          apiUrl,
+          token,
+        });
+        
+      } else {
+        console.log('📋 Standard mode: Returning API URL for manual use');
+        
+        // Standard mode: just return the API URL
+        onComplete('https://api2.onairos.uk', 'existing-session-token', {
+          existingAccount: true,
+          email: email.trim(),
+          dataRequestAccepted: true,
+          requestData,
+          autoMode: false,
+        });
+      }
+    } catch (error) {
+      console.error('❌ Error in data request accept:', error);
+      
+      // Fallback to standard mode
+      onComplete('https://api2.onairos.uk', 'existing-session-token', {
+        existingAccount: true,
+        email: email.trim(),
+        dataRequestAccepted: true,
+        requestData,
+        autoMode: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      });
+    }
+  }, [email, onComplete, requestData, auto, inferenceData, AppName]);
 
   const handleDataRequestDecline = useCallback(() => {
     console.log('Data request declined');
@@ -844,9 +1039,11 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
                       <Text style={styles.emailSubtitle}>
                         We've sent a 6-digit code to {email}
                       </Text>
-                      <Text style={styles.developmentNote}>
-                        🔍 Development Mode: Any 6-digit code will work
-                      </Text>
+                      {isTestMode && (
+                        <Text style={styles.developmentNote}>
+                          🔍 Test Mode: Any 6-digit code will work
+                        </Text>
+                      )}
                     </View>
                     
                     <View style={styles.emailInputSection}>

package/src/services/platformAuthService.ts

@@ -174,6 +174,12 @@ export const initiateOAuth = async (platform: string, username: string, appName?
     const data = await response.json();
     console.log(`📥 ${platform} OAuth response data:`, data);
     
+    // Extra logging for Gmail to help debug
+    if (platform === 'email') {
+      console.log('🔍 Gmail OAuth response keys:', Object.keys(data));
+      console.log('🔍 Gmail OAuth full response:', JSON.stringify(data, null, 2));
+    }
+    
     // Check if the response contains the OAuth URL based on platform
     switch (platform) {
       case 'reddit':
@@ -186,13 +192,18 @@ export const initiateOAuth = async (platform: string, username: string, appName?
         if (data.youtubeURL) return data.youtubeURL;
         break;
       case 'email':
+        // Gmail might return under different field names
         if (data.emailURL) return data.emailURL;
+        if (data.gmailURL) return data.gmailURL;
+        if (data.authUrl) return data.authUrl;
+        if (data.url) return data.url;
         break;
       default:
         if (data.url) return data.url;
         break;
     }
 
+    console.error(`❌ No OAuth URL found in response for ${platform}. Response:`, data);
     throw new Error(`No OAuth URL found in response for ${platform}`);
   } catch (error) {
     console.error(`Error initiating OAuth for ${platform}:`, error);
@@ -654,15 +665,17 @@ export const updateGoogleClientIds = (config: {
  * 📧 EMAIL VERIFICATION FUNCTIONS
  * Using the correct Onairos email verification endpoints
  */
-export const requestEmailVerification = async (email: string): Promise<{
+export const requestEmailVerification = async (email: string, testMode = false): Promise<{
   success: boolean;
   message?: string;
   error?: string;
 }> => {
   try {
     console.log('📧 Requesting email verification for:', email);
+    console.log('🔍 Test mode:', testMode);
     
-    const response = await fetch('https://api2.onairos.uk/email/verification', {
+    // Use the correct endpoint: /email/verify
+    const response = await fetch('https://api2.onairos.uk/email/verify', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -674,10 +687,14 @@ export const requestEmailVerification = async (email: string): Promise<{
     
     if (response.ok && result.success) {
       console.log('✅ Email verification requested successfully');
-      console.log('🔍 Testing mode: Code logged to server console, but accepts any code');
+      
+      const message = testMode 
+        ? 'Verification code sent to your email (testing mode: any code accepted)'
+        : result.message || 'Verification code sent to your email';
+      
       return {
         success: true,
-        message: result.message || 'Verification code sent to your email (testing mode: any code accepted)',
+        message,
       };
     } else {
       console.error('❌ Email verification request failed:', result.error);
@@ -695,49 +712,72 @@ export const requestEmailVerification = async (email: string): Promise<{
   }
 };
 
-export const verifyEmailCode = async (email: string, code: string): Promise<{
+export const verifyEmailCode = async (email: string, code: string, testMode = false): Promise<{
   success: boolean;
   message?: string;
   error?: string;
+  existingUser?: boolean;
 }> => {
   try {
     console.log('🔍 Verifying email code for:', email);
-    console.log('🔍 Development mode: All codes will pass through for now');
+    console.log('🔍 Test mode:', testMode);
+    
+    // In test mode, accept any code
+    if (testMode) {
+      console.log('🧪 Test mode: All codes will pass through');
+      // Simulate 30% chance of existing user in test mode
+      const simulateExistingUser = Math.random() < 0.3;
+      return {
+        success: true,
+        message: 'Email verified successfully (test mode: all codes accepted)',
+        existingUser: simulateExistingUser,
+      };
+    }
     
-    // For now, allow all codes to pass through
-    // Still make the API call to set up the routing, but don't rely on response
+    // Production mode: Make real API call with proper validation
     try {
-      const response = await fetch('https://api2.onairos.uk/email/verification', {
+      const response = await fetch('https://api2.onairos.uk/email/verify/confirm', {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
         },
-        body: JSON.stringify({ email, code, action: 'verify' }),
+        body: JSON.stringify({ email, code }),
       });
       
       const result = await response.json();
       console.log('📡 Email verification API response:', result);
+      
+      if (response.ok && result.success) {
+        console.log('✅ Email verification successful');
+        return {
+          success: true,
+          message: result.message || 'Email verified successfully',
+          existingUser: result.existingUser || false, // Backend should return this flag
+        };
+      } else {
+        console.error('❌ Email verification failed:', result.error);
+        return {
+          success: false,
+          error: result.error || 'Invalid verification code',
+        };
+      }
     } catch (apiError) {
-      console.warn('⚠️ Email verification API call failed, but continuing with bypass:', apiError);
+      console.error('❌ Email verification API call failed:', apiError);
+      return {
+        success: false,
+        error: 'Network error during verification',
+      };
     }
-    
-    // Always return success for now
-    console.log('✅ Email verification successful (bypass mode)');
-    return {
-      success: true,
-      message: 'Email verified successfully (development mode: all codes accepted)',
-    };
   } catch (error) {
     console.error('❌ Email verification error:', error);
-    // Even on error, return success for now
     return {
-      success: true,
-      message: 'Email verified successfully (development mode: all codes accepted)',
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
     };
   }
 };
 
-export const checkEmailVerificationStatus = async (email: string): Promise<{
+export const checkEmailVerificationStatus = async (email: string, testMode = false): Promise<{
   success: boolean;
   isPending?: boolean;
   message?: string;
@@ -745,11 +785,21 @@ export const checkEmailVerificationStatus = async (email: string): Promise<{
 }> => {
   try {
     console.log('🔍 Checking email verification status for:', email);
-    console.log('🔍 Development mode: Always returning no pending verification');
+    console.log('🔍 Test mode:', testMode);
     
-    // Make API call to set up routing, but don't rely on response for now
+    // In test mode, always return no pending verification
+    if (testMode) {
+      console.log('🧪 Test mode: Always returning no pending verification');
+      return {
+        success: true,
+        isPending: false,
+        message: 'Status retrieved successfully (test mode)',
+      };
+    }
+    
+    // Production mode: Make real API call
     try {
-      const response = await fetch(`https://api2.onairos.uk/email/verification/status/${encodeURIComponent(email)}`, {
+      const response = await fetch(`https://api2.onairos.uk/email/verify/status/${encodeURIComponent(email)}`, {
         method: 'GET',
         headers: {
           'Content-Type': 'application/json',
@@ -758,24 +808,33 @@ export const checkEmailVerificationStatus = async (email: string): Promise<{
       
       const result = await response.json();
       console.log('📡 Email verification status API response:', result);
+      
+      if (response.ok && result.success) {
+        console.log('✅ Email verification status retrieved');
+        return {
+          success: true,
+          isPending: result.isPending || false,
+          message: result.message || 'Status retrieved successfully',
+        };
+      } else {
+        console.error('❌ Email verification status failed:', result.error);
+        return {
+          success: false,
+          error: result.error || 'Failed to check verification status',
+        };
+      }
     } catch (apiError) {
-      console.warn('⚠️ Email verification status API call failed, but continuing with bypass:', apiError);
+      console.error('❌ Email verification status API call failed:', apiError);
+      return {
+        success: false,
+        error: 'Network error while checking status',
+      };
     }
-    
-    // For development, always return no pending verification
-    console.log('✅ Email verification status retrieved (bypass mode)');
-    return {
-      success: true,
-      isPending: false, // Always false so verification flow starts fresh
-      message: 'Status retrieved successfully (development mode)',
-    };
   } catch (error) {
     console.error('❌ Email verification status error:', error);
-    // Even on error, return success for development
     return {
-      success: true,
-      isPending: false,
-      message: 'Status retrieved successfully (development mode)',
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
     };
   }
 };