@onairos/react-native 3.0.49 → 3.0.51

package/lib/commonjs/services/platformAuthService.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.testApiConnectivity = exports.isOAuthCallback = exports.initiateOAuth = exports.initiateNativeAuth = exports.hasNativeSDK = exports.handleOAuthCallback = exports.getPlatformColor = exports.getAuthEndpoint = void 0;
+exports.verifyEmailCode = exports.updateGoogleClientIds = exports.testApiConnectivity = exports.requestEmailVerification = exports.refreshYouTubeTokens = exports.refreshGoogleTokens = exports.isOAuthCallback = exports.initiateOAuth = exports.initiateNativeAuth = exports.hasNativeSDK = exports.handleOAuthCallbackUrl = exports.handleOAuthCallback = exports.getPlatformColor = exports.getAuthEndpoint = exports.disconnectPlatform = exports.checkEmailVerificationStatus = void 0;
+var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // Define types for platform auth configuration
 
 // Configuration for each platform's authentication
-const PLATFORM_AUTH_CONFIG = {
+let PLATFORM_AUTH_CONFIG = {
   instagram: {
     hasNativeSDK: false,
     // Instagram uses OAuth WebView flow
@@ -15,11 +17,15 @@ const PLATFORM_AUTH_CONFIG = {
     color: '#E1306C'
   },
   youtube: {
-    hasNativeSDK: false,
+    hasNativeSDK: true,
     // Native Google Sign-In SDK enabled
     nativeSDKPackage: '@react-native-google-signin/google-signin',
     authEndpoint: 'https://api2.onairos.uk/youtube/authorize',
-    color: '#FF0000'
+    color: '#FF0000',
+    clientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
+    redirectUri: 'onairosevents://auth/callback',
+    scope: 'https://www.googleapis.com/auth/youtube.readonly',
+    responseType: 'code'
   },
   reddit: {
     hasNativeSDK: false,
@@ -189,67 +195,192 @@ const initiateOAuth = async (platform, username, appName) => {
  * @returns A Promise that resolves to the authentication result
  */
 exports.initiateOAuth = initiateOAuth;
-const initiateNativeAuth = async platform => {
-  try {
-    // Currently only YouTube (Google Sign-In) is supported
-    if (platform === 'youtube') {
-      console.log('Initiating native Google Sign-In for YouTube');
+const initiateNativeAuth = async (platform, username) => {
+  if (platform === 'youtube') {
+    console.log('🔗 Initiating native Google Sign-In for YouTube');
+    try {
+      var _userInfo$user, _currentUser$user, _userInfo$user4, _userInfo$user6, _userInfo$user7, _userInfo$user8;
+      // Import Google Sign-In dynamically to avoid errors if not installed
+      const {
+        GoogleSignin,
+        statusCodes
+      } = require('@react-native-google-signin/google-signin');
+
+      // Configure Google Sign-In
+      await GoogleSignin.configure({
+        webClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
+        // Replace with your web client ID
+        iosClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
+        // Replace with your iOS client ID
+        scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
+        offlineAccess: true,
+        // CRITICAL: This ensures we get refresh tokens
+        hostedDomain: '',
+        forceCodeForRefreshToken: true,
+        // CRITICAL: Force refresh token on first sign-in
+        accountName: '' // Clear to avoid conflicts
+      });
+
+      // Check if Google Play Services are available
+      await GoogleSignin.hasPlayServices();
+
+      // Sign in with Google
+      const userInfo = await GoogleSignin.signIn();
+      console.log('✅ Google Sign-In successful:', (_userInfo$user = userInfo.user) === null || _userInfo$user === void 0 ? void 0 : _userInfo$user.email);
+
+      // Get access token for API calls
+      const tokens = await GoogleSignin.getTokens();
+      console.log('🔑 Got Google tokens');
+
+      // Get current user info with refresh token
+      const currentUser = await GoogleSignin.getCurrentUser();
+      console.log('👤 Current user info:', currentUser === null || currentUser === void 0 || (_currentUser$user = currentUser.user) === null || _currentUser$user === void 0 ? void 0 : _currentUser$user.email);
+
+      // Extract refresh token from server auth code
+      let refreshToken = null;
+      if (currentUser !== null && currentUser !== void 0 && currentUser.serverAuthCode) {
+        console.log('🔄 Server auth code available for refresh token');
+        refreshToken = currentUser.serverAuthCode;
+      }
+      if (!refreshToken) {
+        console.warn('⚠️ No refresh token available - token refresh may fail later');
+      } else {
+        console.log('✅ Refresh token available for YouTube connection');
+      }
+
+      // Fetch YouTube channel information
+      let channelName = 'Unknown Channel';
+      let channelId = null;
       try {
-        // Import Google Sign-In dynamically to avoid errors if not installed
-        const {
-          GoogleSignin,
-          statusCodes
-        } = require('@react-native-google-signin/google-signin');
-
-        // Configure Google Sign-In
-        await GoogleSignin.configure({
-          scopes: ['https://www.googleapis.com/auth/youtube.readonly', 'https://www.googleapis.com/auth/youtube.force-ssl'],
-          webClientId: 'YOUR_WEB_CLIENT_ID.apps.googleusercontent.com',
-          // Replace with your Web Client ID from Google Cloud Console
-          iosClientId: 'YOUR_IOS_CLIENT_ID.apps.googleusercontent.com',
-          // Replace with your iOS Client ID (iOS only)
-          offlineAccess: true,
-          hostedDomain: '',
-          forceCodeForRefreshToken: true
+        console.log('📺 Fetching YouTube channel information...');
+        const channelResponse = await fetch('https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true', {
+          headers: {
+            'Authorization': `Bearer ${tokens.accessToken}`,
+            'Accept': 'application/json'
+          }
         });
+        if (channelResponse.ok) {
+          const channelData = await channelResponse.json();
+          if (channelData.items && channelData.items.length > 0) {
+            channelName = channelData.items[0].snippet.title;
+            channelId = channelData.items[0].id;
+            console.log('✅ YouTube channel found:', channelName);
+          }
+        }
+      } catch (channelError) {
+        var _userInfo$user2, _userInfo$user3;
+        console.log('⚠️ Error fetching YouTube channel info:', channelError);
+        channelName = ((_userInfo$user2 = userInfo.user) === null || _userInfo$user2 === void 0 ? void 0 : _userInfo$user2.name) || ((_userInfo$user3 = userInfo.user) === null || _userInfo$user3 === void 0 ? void 0 : _userInfo$user3.email) || 'Unknown Channel';
+      }
 
-        // Check if device supports Google Play Services
-        await GoogleSignin.hasPlayServices();
+      // Get authentication info
+      let authToken = (await _asyncStorage.default.getItem('onairos_jwt_token')) || (await _asyncStorage.default.getItem('enoch_token')) || (await _asyncStorage.default.getItem('auth_token'));
+      const storedUsername = await _asyncStorage.default.getItem('onairos_username');
+      const finalUsername = storedUsername || username || ((_userInfo$user4 = userInfo.user) === null || _userInfo$user4 === void 0 ? void 0 : _userInfo$user4.email) || 'youtube_user';
 
-        // Sign in
-        const userInfo = await GoogleSignin.signIn();
-        console.log('Google Sign-In successful:', userInfo);
+      // Create auth token if needed
+      if (!authToken || authToken.trim().length < 20) {
+        console.log('🔐 Creating authentication token for YouTube...');
+        try {
+          var _userInfo$user5;
+          const fallbackEmail = ((_userInfo$user5 = userInfo.user) === null || _userInfo$user5 === void 0 ? void 0 : _userInfo$user5.email) || `${finalUsername}@youtube.temp`;
 
-        // Get access token
-        const tokens = await GoogleSignin.getTokens();
-        console.log('Google tokens:', tokens);
+          // Create user accounts and get JWT token
+          const onairosSignupResponse = await fetch('https://api2.onairos.uk/register/enoch', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              email: fallbackEmail,
+              username: finalUsername,
+              name: finalUsername
+            })
+          });
+          if (onairosSignupResponse.ok) {
+            var _onairosResponseData$;
+            const onairosResponseData = await onairosSignupResponse.json();
 
-        // Here you would typically send the tokens to your backend
-        // to associate the YouTube account with the user
+            // Extract token from response
+            authToken = onairosResponseData.token || ((_onairosResponseData$ = onairosResponseData.data) === null || _onairosResponseData$ === void 0 ? void 0 : _onairosResponseData$.token) || onairosResponseData.jwt;
+            if (authToken) {
+              // Store tokens
+              await _asyncStorage.default.setItem('onairos_jwt_token', authToken);
+              await _asyncStorage.default.setItem('enoch_token', authToken);
+              await _asyncStorage.default.setItem('auth_token', authToken);
+              await _asyncStorage.default.setItem('onairos_username', onairosResponseData.username || finalUsername);
+              console.log('✅ Successfully created and stored authentication token');
+            }
+          }
+        } catch (tokenError) {
+          console.warn('⚠️ Error creating auth token:', tokenError);
+        }
+      }
+      console.log('🔗 Linking YouTube data to user:', finalUsername);
+      console.log('📺 YouTube channel name:', channelName);
 
+      // Send tokens to backend for YouTube data processing
+      const backendResponse = await fetch('https://api2.onairos.uk/youtube/native-auth', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(authToken && {
+            'Authorization': `Bearer ${authToken}`
+          })
+        },
+        body: JSON.stringify({
+          session: {
+            username: finalUsername,
+            platform: 'youtube',
+            timestamp: new Date().toISOString(),
+            channelName: channelName,
+            channelId: channelId
+          },
+          googleUser: userInfo.user,
+          accessToken: tokens.accessToken,
+          idToken: tokens.idToken,
+          refreshToken: refreshToken,
+          // CRITICAL: Include refresh token
+          serverAuthCode: currentUser === null || currentUser === void 0 ? void 0 : currentUser.serverAuthCode,
+          userAccountInfo: {
+            username: finalUsername,
+            email: (_userInfo$user6 = userInfo.user) === null || _userInfo$user6 === void 0 ? void 0 : _userInfo$user6.email,
+            authToken: authToken,
+            channelName: channelName,
+            channelId: channelId,
+            userIdentifier: authToken ? `user-${authToken.substring(0, 10)}` : `youtube-${(_userInfo$user7 = userInfo.user) === null || _userInfo$user7 === void 0 ? void 0 : _userInfo$user7.email}`,
+            googleId: (_userInfo$user8 = userInfo.user) === null || _userInfo$user8 === void 0 ? void 0 : _userInfo$user8.id
+          },
+          tokenExpiry: new Date(Date.now() + 3600 * 1000).toISOString(),
+          // 1 hour from now
+          requestRefreshToken: true
+        })
+      });
+      if (backendResponse.ok) {
+        const responseData = await backendResponse.json();
+        console.log('✅ YouTube connection processed by backend:', responseData);
         return true;
-      } catch (error) {
-        console.error('Google Sign-In error:', error);
-        const {
-          statusCodes: StatusCodes
-        } = require('@react-native-google-signin/google-signin');
-        if (error.code === StatusCodes.SIGN_IN_CANCELLED) {
-          console.log('User cancelled the sign-in flow');
-        } else if (error.code === StatusCodes.IN_PROGRESS) {
-          console.log('Sign-in is in progress already');
-        } else if (error.code === StatusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
-          console.log('Play services not available or outdated');
-        } else {
-          console.log('Some other error happened');
-        }
+      } else {
+        const errorData = await backendResponse.text();
+        console.error('❌ Backend processing failed:', backendResponse.status, errorData);
         return false;
       }
+    } catch (error) {
+      console.error('❌ Google Sign-In error:', error);
+      const {
+        statusCodes: StatusCodes
+      } = require('@react-native-google-signin/google-signin');
+      if (error.code === StatusCodes.SIGN_IN_CANCELLED) {
+        console.log('User cancelled Google Sign-In');
+      } else if (error.code === StatusCodes.IN_PROGRESS) {
+        console.log('Google Sign-In already in progress');
+      } else if (error.code === StatusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
+        console.log('Google Play Services not available');
+      }
+      return false;
     }
-    throw new Error(`Native authentication not supported for ${platform}`);
-  } catch (error) {
-    console.error(`Error initiating native auth for ${platform}:`, error);
-    throw error;
   }
+  return false;
 };
 
 /**
@@ -316,5 +447,326 @@ const testApiConnectivity = async () => {
     };
   }
 };
+
+/**
+ * 🔄 REFRESH GOOGLE TOKENS
+ */
 exports.testApiConnectivity = testApiConnectivity;
+const refreshGoogleTokens = async () => {
+  try {
+    console.log('🔄 Attempting to refresh Google tokens...');
+    const {
+      GoogleSignin
+    } = require('@react-native-google-signin/google-signin');
+    const currentUser = await GoogleSignin.getCurrentUser();
+    if (!currentUser) {
+      console.log('❌ User not signed in to Google, cannot refresh tokens');
+      return null;
+    }
+    const tokens = await GoogleSignin.getTokens();
+    console.log('✅ Successfully refreshed Google tokens');
+    return {
+      accessToken: tokens.accessToken,
+      idToken: tokens.idToken
+    };
+  } catch (error) {
+    console.error('❌ Failed to refresh Google tokens:', error);
+
+    // If refresh fails, try to sign in again
+    try {
+      console.log('🔄 Refresh failed, attempting re-authentication...');
+      const {
+        GoogleSignin
+      } = require('@react-native-google-signin/google-signin');
+      const userInfo = await GoogleSignin.signIn();
+      const tokens = await GoogleSignin.getTokens();
+      console.log('✅ Re-authentication successful');
+      return {
+        accessToken: tokens.accessToken,
+        idToken: tokens.idToken
+      };
+    } catch (signInError) {
+      console.error('❌ Re-authentication also failed:', signInError);
+      return null;
+    }
+  }
+};
+
+/**
+ * 🔄 REFRESH YOUTUBE TOKENS
+ */
+exports.refreshGoogleTokens = refreshGoogleTokens;
+const refreshYouTubeTokens = async () => {
+  try {
+    var _currentUser$user2;
+    console.log('🔄 Refreshing YouTube tokens...');
+
+    // Get fresh tokens from Google SDK
+    const freshTokens = await refreshGoogleTokens();
+    if (!freshTokens) {
+      console.error('❌ Failed to get fresh tokens from Google SDK');
+      return false;
+    }
+
+    // Get current user info
+    const {
+      GoogleSignin
+    } = require('@react-native-google-signin/google-signin');
+    const currentUser = await GoogleSignin.getCurrentUser();
+    if (!currentUser) {
+      console.error('❌ No current Google user found');
+      return false;
+    }
+
+    // Get stored auth token
+    const authToken = (await _asyncStorage.default.getItem('onairos_jwt_token')) || (await _asyncStorage.default.getItem('enoch_token')) || (await _asyncStorage.default.getItem('auth_token'));
+    if (!authToken) {
+      console.error('❌ No auth token found for YouTube refresh');
+      return false;
+    }
+
+    // Send refreshed tokens to backend
+    const refreshResponse = await fetch('https://api2.onairos.uk/youtube/refresh-token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      body: JSON.stringify({
+        accessToken: freshTokens.accessToken,
+        idToken: freshTokens.idToken,
+        refreshToken: currentUser.serverAuthCode,
+        userEmail: (_currentUser$user2 = currentUser.user) === null || _currentUser$user2 === void 0 ? void 0 : _currentUser$user2.email,
+        tokenExpiry: new Date(Date.now() + 3600 * 1000).toISOString(),
+        timestamp: new Date().toISOString()
+      })
+    });
+    if (refreshResponse.ok) {
+      const responseData = await refreshResponse.json();
+      console.log('✅ YouTube tokens refreshed successfully:', responseData);
+      return true;
+    } else {
+      const errorData = await refreshResponse.text();
+      console.error('❌ YouTube token refresh failed:', refreshResponse.status, errorData);
+      return false;
+    }
+  } catch (error) {
+    console.error('❌ Error refreshing YouTube tokens:', error);
+    return false;
+  }
+};
+
+/**
+ * 🎯 ENHANCED OAUTH CALLBACK HANDLER
+ */
+exports.refreshYouTubeTokens = refreshYouTubeTokens;
+const handleOAuthCallbackUrl = url => {
+  try {
+    console.log('🔍 Processing OAuth callback URL:', url);
+
+    // Parse the URL
+    const parsedUrl = new URL(url);
+
+    // Extract platform and code
+    const platform = parsedUrl.searchParams.get('platform') || parsedUrl.pathname.split('/').find(segment => ['instagram', 'youtube', 'reddit', 'pinterest', 'email'].includes(segment));
+    const code = parsedUrl.searchParams.get('code');
+    const error = parsedUrl.searchParams.get('error');
+    if (error) {
+      console.error('❌ OAuth error in callback:', error);
+      return {
+        success: false
+      };
+    }
+    if (code && platform) {
+      console.log(`✅ OAuth callback processed: ${platform} with code: ${code.substring(0, 10)}...`);
+      return {
+        platform,
+        code,
+        success: true
+      };
+    }
+    console.warn('⚠️ OAuth callback missing platform or code');
+    return {
+      success: false
+    };
+  } catch (error) {
+    console.error('❌ Error processing OAuth callback:', error);
+    return {
+      success: false
+    };
+  }
+};
+
+/**
+ * 🔧 UPDATE GOOGLE CLIENT IDS
+ * Allows apps to configure their own Google client IDs
+ */
+exports.handleOAuthCallbackUrl = handleOAuthCallbackUrl;
+const updateGoogleClientIds = config => {
+  console.log('🔧 Updating Google client IDs configuration');
+  if (config.webClientId || config.iosClientId) {
+    // Update the YouTube configuration
+    PLATFORM_AUTH_CONFIG.youtube = {
+      ...PLATFORM_AUTH_CONFIG.youtube,
+      clientId: config.webClientId || PLATFORM_AUTH_CONFIG.youtube.clientId
+    };
+    console.log('✅ Google client IDs updated successfully');
+  }
+};
+
+/**
+ * 📧 EMAIL VERIFICATION FUNCTIONS
+ * Using the correct Onairos email verification endpoints
+ */
+exports.updateGoogleClientIds = updateGoogleClientIds;
+const requestEmailVerification = async email => {
+  try {
+    console.log('📧 Requesting email verification for:', email);
+    const response = await fetch('https://api2.onairos.uk/email/verify', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        email
+      })
+    });
+    const result = await response.json();
+    if (response.ok && result.success) {
+      console.log('✅ Email verification requested successfully');
+      console.log('🔍 Testing mode: Code logged to server console, but accepts any code');
+      return {
+        success: true,
+        message: result.message || 'Verification code sent to your email (testing mode: any code accepted)'
+      };
+    } else {
+      console.error('❌ Email verification request failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Failed to send verification code'
+      };
+    }
+  } catch (error) {
+    console.error('❌ Email verification request error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error'
+    };
+  }
+};
+exports.requestEmailVerification = requestEmailVerification;
+const verifyEmailCode = async (email, code) => {
+  try {
+    console.log('🔍 Verifying email code for:', email);
+    const response = await fetch('https://api2.onairos.uk/email/verify/confirm', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        email,
+        code
+      })
+    });
+    const result = await response.json();
+    if (response.ok && result.success) {
+      console.log('✅ Email verification successful');
+      console.log('🔍 Testing mode: Any code accepted for verification');
+      return {
+        success: true,
+        message: result.message || 'Email verified successfully'
+      };
+    } else {
+      console.error('❌ Email verification failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Invalid verification code'
+      };
+    }
+  } catch (error) {
+    console.error('❌ Email verification error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error'
+    };
+  }
+};
+exports.verifyEmailCode = verifyEmailCode;
+const checkEmailVerificationStatus = async email => {
+  try {
+    console.log('🔍 Checking email verification status for:', email);
+    const response = await fetch(`https://api2.onairos.uk/email/verify/status/${encodeURIComponent(email)}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    const result = await response.json();
+    if (response.ok) {
+      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 check failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Failed to check verification status'
+      };
+    }
+  } catch (error) {
+    console.error('❌ Email verification status error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error'
+    };
+  }
+};
+
+/**
+ * 🔌 UNIVERSAL PLATFORM DISCONNECTION
+ * Backend confirmed this endpoint is fully implemented
+ */
+exports.checkEmailVerificationStatus = checkEmailVerificationStatus;
+const disconnectPlatform = async (platform, username) => {
+  try {
+    console.log(`🔌 Disconnecting ${platform} for user:`, username);
+    const response = await fetch('https://api2.onairos.uk/revoke', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        Info: {
+          connection: platform.charAt(0).toUpperCase() + platform.slice(1),
+          // Capitalize platform name
+          username: username
+        }
+      })
+    });
+    const result = await response.json();
+    if (response.ok && result.success) {
+      console.log(`✅ ${platform} disconnected successfully`);
+      return {
+        success: true,
+        message: result.message || `${platform} disconnected successfully`
+      };
+    } else {
+      console.error(`❌ ${platform} disconnection failed:`, result.error);
+      return {
+        success: false,
+        error: result.error || `Failed to disconnect ${platform}`
+      };
+    }
+  } catch (error) {
+    console.error(`❌ ${platform} disconnection error:`, error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error'
+    };
+  }
+};
+exports.disconnectPlatform = disconnectPlatform;
 //# sourceMappingURL=platformAuthService.js.map