@onairos/react-native 3.4.0 → 3.5.4

package/src/services/platformAuthService.ts

@@ -1,1113 +0,0 @@
-import { Platform, Linking } from 'react-native';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import type { PlatformAuthConfig } from '../types';
-import { makeDeveloperRequest, getApiConfig, storeJWT, extractUsernameFromJWT } from './apiKeyService';
-
-// 🔑 CRITICAL: Use two-tier authentication system
-// - Developer API key for email verification requests
-// - JWT tokens for user-authenticated requests after email verification
-
-/**
- * Initialize the platform auth service
- * This service now uses the two-tier authentication system
- */
-export const initializePlatformAuthService = async (): Promise<void> => {
-  try {
-    // Check if app is already initialized with API key
-    const existingConfig = getApiConfig();
-    
-    if (existingConfig && existingConfig.apiKey) {
-      console.log('🔑 Platform auth service using existing app configuration');
-      console.log(`✅ Environment: ${existingConfig.environment}`);
-      return;
-    }
-    
-    // If no app initialization, we can't proceed
-    console.error('❌ Platform auth service requires app-level API key initialization');
-    throw new Error('Platform auth service requires app-level API key initialization. Please call initializeApiKey() first.');
-  } catch (error) {
-    console.error('❌ Failed to initialize platform auth service:', error);
-    throw error;
-  }
-};
-
-// Configuration for each platform's authentication
-let PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
-  instagram: {
-    hasNativeSDK: false, // Instagram uses OAuth WebView flow
-    authEndpoint: '/instagram/authorize',
-    color: '#E1306C',
-  },
-  youtube: {
-    hasNativeSDK: true, // Native Google Sign-In SDK enabled
-    nativeSDKPackage: '@react-native-google-signin/google-signin',
-    authEndpoint: '/youtube/authorize',
-    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,
-    authEndpoint: '/reddit/authorize',
-    color: '#FF4500',
-  },
-  pinterest: {
-    hasNativeSDK: false,
-    authEndpoint: '/pinterest/authorize',
-    color: '#E60023',
-  },
-  email: {
-    hasNativeSDK: false,
-    authEndpoint: '/gmail/authorize',
-    color: '#4285F4',
-  },
-};
-
-/**
- * Checks if a native SDK is available for the given platform
- */
-export const hasNativeSDK = (platform: string): boolean => {
-  const config = PLATFORM_AUTH_CONFIG[platform];
-  return config?.hasNativeSDK || false;
-};
-
-/**
- * Gets the auth endpoint URL for a platform
- */
-export const getAuthEndpoint = (platform: string): string => {
-  const config = PLATFORM_AUTH_CONFIG[platform];
-  return config?.authEndpoint || '';
-};
-
-/**
- * Gets the color associated with a platform
- */
-export const getPlatformColor = (platform: string): string => {
-  const config = PLATFORM_AUTH_CONFIG[platform];
-  return config?.color || '#000000';
-};
-
-/**
- * Initiates the OAuth flow for a platform
- * @param platform The platform to authenticate with
- * @param username The username to associate with the authentication
- * @param appName The app name to use for the OAuth session (optional)
- * @returns A Promise that resolves to the OAuth URL to open in a WebView or null if using native SDK
- */
-export const initiateOAuth = async (platform: string, username: string, appName?: string): Promise<string | null> => {
-  try {
-    console.log('🚀 Initiating OAuth for platform:', platform);
-    console.log('👤 Username:', username);
-    console.log('📱 App name:', appName);
-    
-    // Check if the platform is supported
-    if (!PLATFORM_AUTH_CONFIG[platform]) {
-      console.error('❌ Unsupported platform:', platform);
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
-
-    // Check if platform has a native SDK
-    if (PLATFORM_AUTH_CONFIG[platform].hasNativeSDK) {
-      console.log('📱 Platform uses native SDK, returning null');
-      // Return null to indicate that we should use the native SDK
-      return null;
-    }
-
-    console.log('🌐 Platform uses OAuth WebView flow');
-    console.log('🔗 Auth endpoint:', PLATFORM_AUTH_CONFIG[platform].authEndpoint);
-
-    // Pre-flight connectivity check
-    console.log('🔍 Performing pre-flight connectivity check...');
-    const connectivityResult = await testApiConnectivity();
-    
-    if (!connectivityResult.success) {
-      console.error('❌ Pre-flight connectivity check failed:', connectivityResult.error);
-      throw new Error(`Cannot reach authentication server: ${connectivityResult.error}`);
-    }
-    
-    console.log('✅ Pre-flight connectivity check passed');
-
-    // Handle Instagram with specific API format
-    if (platform === 'instagram') {
-      const state = 'djksbfds';
-      const jsonData = {
-        session: {
-          oauthState: state,
-          username: username || 'Avatar',
-        },
-      };
-
-      console.log('📤 Sending Instagram OAuth request:', jsonData);
-
-      const response = await makeDeveloperRequest(PLATFORM_AUTH_CONFIG[platform].authEndpoint, {
-        method: 'POST',
-        body: JSON.stringify(jsonData),
-      });
-
-      console.log('📡 Instagram OAuth response status:', response.status);
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error('❌ Instagram OAuth API error:', errorText);
-        throw new Error(`Instagram OAuth API error: ${response.status} - ${errorText}`);
-      }
-
-      const responseData = await response.json();
-      console.log('📥 Instagram OAuth response data:', responseData);
-      
-      if (responseData.instagramURL) {
-        console.log('✅ Instagram OAuth URL received:', responseData.instagramURL);
-        
-        // Validate the URL before returning
-        if (await validateOAuthUrl(responseData.instagramURL)) {
-          return responseData.instagramURL;
-        } else {
-          throw new Error('Received invalid Instagram OAuth URL');
-        }
-      }
-      
-      console.error('❌ No Instagram URL found in response');
-      throw new Error('No Instagram URL found in response');
-    }
-
-    // Prepare the request body for other platforms
-    const jsonData = {
-      session: {
-        oauthState: 'djksbfds', // Use same state for all platforms
-        username: username || 'Avatar',
-        appName: appName || 'DefaultApp',
-      },
-    };
-
-    console.log(`📤 Sending ${platform} OAuth request:`, jsonData);
-
-    // Make the authenticated request to get the OAuth URL
-    const response = await makeDeveloperRequest(PLATFORM_AUTH_CONFIG[platform].authEndpoint, {
-      method: 'POST',
-      body: JSON.stringify(jsonData),
-    });
-
-    console.log(`📡 ${platform} OAuth response status:`, response.status);
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.error(`❌ ${platform} OAuth API error:`, errorText);
-      throw new Error(`${platform} OAuth API error: ${response.status} - ${errorText}`);
-    }
-
-    // Parse the response
-    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
-    let oauthUrl: string | null = null;
-    
-    switch (platform) {
-      case 'reddit':
-        oauthUrl = data.redditURL;
-        break;
-      case 'pinterest':
-        oauthUrl = data.pinterestURL;
-        break;
-      case 'youtube':
-        oauthUrl = data.youtubeURL;
-        break;
-      case 'email':
-        // Gmail might return under different field names
-        oauthUrl = data.emailURL || data.gmailURL || data.authUrl || data.url;
-        break;
-      default:
-        oauthUrl = data.url;
-        break;
-    }
-
-    if (!oauthUrl) {
-      console.error(`❌ No OAuth URL found in response for ${platform}. Response:`, data);
-      throw new Error(`No OAuth URL found in response for ${platform}`);
-    }
-
-    console.log(`✅ ${platform} OAuth URL received:`, oauthUrl);
-    
-    // Validate the URL before returning
-    if (await validateOAuthUrl(oauthUrl)) {
-      return oauthUrl;
-    } else {
-      throw new Error(`Received invalid ${platform} OAuth URL`);
-    }
-  } catch (error) {
-    console.error(`Error initiating OAuth for ${platform}:`, error);
-    throw error;
-  }
-};
-
-/**
- * Validates an OAuth URL to ensure it's reachable
- * @param url The OAuth URL to validate
- * @returns Promise<boolean> indicating if the URL is valid and reachable
- */
-const validateOAuthUrl = async (url: string): Promise<boolean> => {
-  try {
-    console.log('🔍 Validating OAuth URL:', url);
-    
-    // Basic URL format validation
-    if (!url || typeof url !== 'string') {
-      console.error('❌ Invalid URL format:', url);
-      return false;
-    }
-    
-    // Check if URL starts with https
-    if (!url.startsWith('https://')) {
-      console.error('❌ URL must use HTTPS:', url);
-      return false;
-    }
-    
-    // Try to parse the URL
-    try {
-      new URL(url);
-    } catch (parseError) {
-      console.error('❌ URL parsing failed:', parseError);
-      return false;
-    }
-    
-    // Make a HEAD request to check if the URL is reachable
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
-    
-    try {
-      const response = await fetch(url, {
-        method: 'HEAD',
-        signal: controller.signal,
-      });
-      
-      clearTimeout(timeoutId);
-      
-      // Accept any response that's not a network error
-      // OAuth pages might return various status codes
-      console.log('✅ OAuth URL validation successful, status:', response.status);
-      return true;
-    } catch (fetchError) {
-      clearTimeout(timeoutId);
-      
-      if (fetchError.name === 'AbortError') {
-        console.warn('⚠️ OAuth URL validation timeout, but proceeding anyway');
-        return true; // Allow timeout as URLs might be slow to respond
-      }
-      
-      console.warn('⚠️ OAuth URL validation failed, but proceeding anyway:', fetchError.message);
-      return true; // Allow network errors as they might be temporary
-    }
-  } catch (error) {
-    console.warn('⚠️ OAuth URL validation error, but proceeding anyway:', error);
-    return true; // Allow validation errors to not block the flow
-  }
-};
-
-/**
- * Initiates the native SDK authentication flow for a platform
- * @param platform The platform to authenticate with
- * @returns A Promise that resolves to the authentication result
- */
-export const initiateNativeAuth = async (platform: string, username?: string): Promise<boolean> => {
-  if (platform === 'youtube') {
-    console.log('🔗 Initiating native Google Sign-In for YouTube');
-    try {
-      // Check if Google Sign-In package is available
-      let GoogleSignin, statusCodes;
-      try {
-        const googleSignInModule = require('@react-native-google-signin/google-signin');
-        GoogleSignin = googleSignInModule.GoogleSignin;
-        statusCodes = googleSignInModule.statusCodes;
-      } catch (importError) {
-        console.error('❌ Google Sign-In package not available:', importError);
-        throw new Error('Google Sign-In SDK not installed. Please install @react-native-google-signin/google-signin');
-      }
-      
-      // Configure Google Sign-In with better error handling
-      try {
-        const youtubeConfig = PLATFORM_AUTH_CONFIG.youtube;
-        const webClientId = youtubeConfig.clientId || '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com';
-        const iosClientId = youtubeConfig.iosClientId || webClientId;
-        
-        await GoogleSignin.configure({
-          webClientId: webClientId,
-          iosClientId: iosClientId,
-          scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
-          offlineAccess: true,
-          hostedDomain: '',
-          forceCodeForRefreshToken: true,
-          accountName: '',
-        });
-        console.log('✅ Google Sign-In configured successfully with client ID:', webClientId.substring(0, 20) + '...');
-      } catch (configError) {
-        console.error('❌ Google Sign-In configuration failed:', configError);
-        throw new Error(`Google Sign-In configuration failed: ${configError.message || configError}`);
-      }
-      
-      // Check if Google Play Services are available (Android only)
-      try {
-        await GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true });
-        console.log('✅ Google Play Services available');
-      } catch (playServicesError) {
-        console.error('❌ Google Play Services error:', playServicesError);
-        throw new Error(`Google Play Services not available: ${playServicesError.message || playServicesError}`);
-      }
-      
-      // Sign in with Google
-      let userInfo;
-      try {
-        userInfo = await GoogleSignin.signIn();
-        console.log('✅ Google Sign-In successful:', userInfo.user?.email);
-      } catch (signInError) {
-        console.error('❌ Google Sign-In failed:', signInError);
-        
-        // Handle specific error codes
-        if (signInError.code === statusCodes.SIGN_IN_CANCELLED) {
-          throw new Error('Google Sign-In was cancelled by user');
-        } else if (signInError.code === statusCodes.IN_PROGRESS) {
-          throw new Error('Google Sign-In already in progress');
-        } else if (signInError.code === statusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
-          throw new Error('Google Play Services not available or outdated');
-        } else {
-          throw new Error(`Google Sign-In failed: ${signInError.message || signInError}`);
-        }
-      }
-      
-      // 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?.user?.email);
-      
-      // Extract refresh token from server auth code
-      let refreshToken = null;
-      if (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 {
-        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) {
-        console.log('⚠️ Error fetching YouTube channel info:', channelError);
-        channelName = userInfo.user?.name || userInfo.user?.email || 'Unknown Channel';
-      }
-      
-      // Get authentication info
-      let authToken = await AsyncStorage.getItem('onairos_jwt_token') || 
-                     await AsyncStorage.getItem('enoch_token') || 
-                     await AsyncStorage.getItem('auth_token');
-      const storedUsername = await AsyncStorage.getItem('onairos_username');
-      const finalUsername = storedUsername || username || userInfo.user?.email || 'youtube_user';
-      
-      // Create auth token if needed
-      if (!authToken || authToken.trim().length < 20) {
-        console.log('🔐 Creating authentication token for YouTube...');
-        
-        try {
-          const fallbackEmail = userInfo.user?.email || `${finalUsername}@youtube.temp`;
-          
-          // 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) {
-            const onairosResponseData = await onairosSignupResponse.json();
-            
-            // Extract token from response
-            authToken = onairosResponseData.token || onairosResponseData.data?.token || onairosResponseData.jwt;
-            
-            if (authToken) {
-              // Store tokens
-              await AsyncStorage.setItem('onairos_jwt_token', authToken);
-              await AsyncStorage.setItem('enoch_token', authToken);
-              await AsyncStorage.setItem('auth_token', authToken);
-              await AsyncStorage.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?.serverAuthCode,
-          userAccountInfo: {
-            username: finalUsername,
-            email: userInfo.user?.email,
-            authToken: authToken,
-            channelName: channelName,
-            channelId: channelId,
-            userIdentifier: authToken ? `user-${authToken.substring(0, 10)}` : `youtube-${userInfo.user?.email}`,
-            googleId: userInfo.user?.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;
-      } else {
-        const errorData = await backendResponse.text();
-        console.error('❌ Backend processing failed:', backendResponse.status, errorData);
-        return false;
-      }
-      
-    } catch (error: any) {
-      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;
-    }
-  }
-    
-  return false;
-};
-
-/**
- * Handles the OAuth callback
- * @param url The callback URL
- * @returns The authorization code extracted from the URL
- */
-export const handleOAuthCallback = (url: string): string | null => {
-  try {
-    // Parse the URL
-    const parsedUrl = new URL(url);
-    
-    // Extract the authorization code
-    return parsedUrl.searchParams.get('code');
-  } catch (error) {
-    console.error('Error handling OAuth callback:', error);
-    return null;
-  }
-};
-
-/**
- * Checks if a URL is an OAuth callback
- * @param url The URL to check
- * @returns True if the URL is an OAuth callback
- */
-export const isOAuthCallback = (url: string): boolean => {
-  // Check if the URL starts with our redirect URI
-  return url.startsWith('onairosanime://auth/');
-};
-
-/**
- * Test connectivity to the Onairos API server
- */
-export const testApiConnectivity = async (): Promise<{ success: boolean; error?: string }> => {
-  try {
-    console.log('🔍 Testing connectivity to Onairos API...');
-    
-    // Test multiple endpoints for better reliability
-    const testEndpoints = [
-      'https://api2.onairos.uk/health',
-      'https://api2.onairos.uk', // Base URL
-    ];
-    
-    let lastError: string | null = null;
-    
-    for (const endpoint of testEndpoints) {
-      try {
-        console.log(`🔍 Testing endpoint: ${endpoint}`);
-        
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
-        
-        const response = await fetch(endpoint, {
-          method: 'GET',
-          headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': 'OnairosReactNative/1.0',
-          },
-          signal: controller.signal,
-        });
-        
-        clearTimeout(timeoutId);
-        
-        console.log(`🌐 API connectivity test response for ${endpoint}:`, response.status);
-        
-        if (response.ok || response.status === 404) {
-          // Accept 404 as it means the server is reachable
-          console.log('✅ API server is reachable');
-          return { success: true };
-        } else {
-          console.log(`⚠️ API server responded with status ${response.status} for ${endpoint}`);
-          lastError = `API server error: ${response.status}`;
-          // Continue to next endpoint
-        }
-      } catch (fetchError) {
-        console.log(`❌ Failed to reach ${endpoint}:`, fetchError);
-        
-        if (fetchError.name === 'AbortError') {
-          lastError = 'Connection timeout - API server took too long to respond';
-        } else if (fetchError.message.includes('Network request failed')) {
-          lastError = 'Network error - check your internet connection';
-        } else if (fetchError.message.includes('not connected to the internet')) {
-          lastError = 'No internet connection';
-        } else {
-          lastError = `Network error: ${fetchError.message}`;
-        }
-        
-        // Continue to next endpoint
-      }
-    }
-    
-    console.error('❌ All API connectivity tests failed');
-    return { success: false, error: lastError || 'Cannot reach API server' };
-  } catch (error) {
-    console.error('❌ API connectivity test failed:', error);
-    return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
-  }
-};
-
-/**
- * 🔄 REFRESH GOOGLE TOKENS
- */
-export const refreshGoogleTokens = async (): Promise<{ accessToken: string; idToken?: string } | null> => {
-  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
- */
-export const refreshYouTubeTokens = async (): Promise<boolean> => {
-  try {
-    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.getItem('onairos_jwt_token') || 
-                     await AsyncStorage.getItem('enoch_token') || 
-                     await AsyncStorage.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.user?.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
- */
-export const handleOAuthCallbackUrl = (url: string): { platform?: string; code?: string; success: boolean } => {
-  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
- */
-export const updateGoogleClientIds = (config: {
-  webClientId?: string;
-  iosClientId?: string;
-}) => {
-  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,
-      iosClientId: config.iosClientId || PLATFORM_AUTH_CONFIG.youtube.iosClientId,
-    };
-    
-    console.log('✅ Google client IDs updated successfully');
-    console.log('  - Web Client ID:', config.webClientId ? config.webClientId.substring(0, 20) + '...' : 'not provided');
-    console.log('  - iOS Client ID:', config.iosClientId ? config.iosClientId.substring(0, 20) + '...' : 'not provided');
-  }
-};
-
-/**
- * Request email verification using developer API key
- * @param email Email address to verify
- * @param testMode Whether to use test mode
- * @returns Promise with verification result
- */
-export const requestEmailVerification = async (
-  email: string,
-  testMode: boolean = false
-): Promise<{ success: boolean; message?: string; error?: string }> => {
-  try {
-    console.log('📧 Requesting email verification for:', email);
-    
-    const response = await makeDeveloperRequest('/email/verification', {
-      method: 'POST',
-      body: JSON.stringify({
-        email,
-        action: 'request',
-        testMode
-      })
-    });
-
-    const data = await response.json();
-
-    if (response.ok && data.success) {
-      console.log('✅ Email verification requested successfully');
-      return {
-        success: true,
-        message: data.message || 'Verification code sent to your email'
-      };
-    } else {
-      console.error('❌ Email verification request failed:', data.error);
-      return {
-        success: false,
-        error: data.error || 'Failed to send verification code'
-      };
-    }
-  } catch (error) {
-    console.error('❌ Error requesting email verification:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Network error'
-    };
-  }
-};
-
-/**
- * Verify email code and store JWT token
- * @param email Email address
- * @param code Verification code
- * @param testMode Whether to use test mode
- * @returns Promise with verification result and JWT token
- */
-export const verifyEmailCode = async (
-  email: string,
-  code: string,
-  testMode: boolean = false
-): Promise<{ success: boolean; message?: string; error?: string; existingUser?: boolean; token?: string }> => {
-  try {
-    console.log('🔍 Verifying email code for:', email);
-    
-    const response = await makeDeveloperRequest('/email/verification', {
-      method: 'POST',
-      body: JSON.stringify({
-        email,
-        action: 'verify',
-        code,
-        testMode
-      })
-    });
-
-    const data = await response.json();
-
-    if (response.ok && data.success) {
-      console.log('✅ Email verification successful');
-      
-      // Store JWT token if received
-      if (data.token || data.jwtToken) {
-        const jwtToken = data.token || data.jwtToken;
-        await storeJWT(jwtToken);
-        console.log('🎫 JWT token stored successfully');
-      }
-      
-      return {
-        success: true,
-        message: data.message || 'Email verified successfully',
-        existingUser: data.existingUser || false,
-        token: data.token || data.jwtToken
-      };
-    } else {
-      console.error('❌ Email verification failed:', data.error);
-      return {
-        success: false,
-        error: data.error || 'Invalid verification code'
-      };
-    }
-  } catch (error) {
-    console.error('❌ Error verifying email code:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Network error'
-    };
-  }
-};
-
-/**
- * Check email verification status
- * @param email Email address
- * @param testMode Whether to use test mode
- * @returns Promise with status result
- */
-export const checkEmailVerificationStatus = async (
-  email: string,
-  testMode: boolean = false
-): Promise<{ success: boolean; isPending?: boolean; error?: string }> => {
-  try {
-    console.log('🔍 Checking email verification status for:', email);
-    
-    const response = await makeDeveloperRequest('/email/verification/status', {
-      method: 'POST',
-      body: JSON.stringify({
-        email,
-        testMode
-      })
-    });
-
-    const data = await response.json();
-
-    if (response.ok && data.success) {
-      return {
-        success: true,
-        isPending: data.isPending || false
-      };
-    } else {
-      return {
-        success: false,
-        error: data.error || 'Failed to check verification status'
-      };
-    }
-  } catch (error) {
-    console.error('❌ Error checking email verification status:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Network error'
-    };
-  }
-};
-
-/**
- * Disconnect a platform (uses developer API key)
- * @param platform Platform to disconnect
- * @param username Username associated with the platform
- * @returns Promise with disconnect result
- */
-export const disconnectPlatform = async (platform: string, username: string): Promise<{ success: boolean; error?: string }> => {
-  try {
-    console.log('🔌 Disconnecting platform:', platform, 'for user:', username);
-    
-    // Make authenticated API call to disconnect platform
-    const response = await makeDeveloperRequest('/revoke', {
-      method: 'POST',
-      body: JSON.stringify({
-        platform,
-        username
-      })
-    });
-
-    const data = await response.json();
-
-    if (response.ok && data.success) {
-      console.log(`✅ ${platform} disconnected successfully`);
-      return { success: true };
-    } else {
-      console.error(`❌ Failed to disconnect ${platform}:`, data.error);
-      return {
-        success: false,
-        error: data.error || 'Failed to disconnect platform'
-      };
-    }
-  } catch (error) {
-    console.error(`❌ Error disconnecting ${platform}:`, error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Network error'
-    };
-  }
-};
-
-/**
- * Store PIN for user (uses JWT authentication and extracts username from JWT)
- * @param pin User PIN
- * @param username Optional username (if not provided, extracts from JWT)
- * @returns Promise with result
- */
-export const storePIN = async (pin: string, username?: string): Promise<{ success: boolean; error?: string }> => {
-  try {
-    // Extract username from JWT if not provided
-    const userToStore = username || extractUsernameFromJWT();
-    
-    if (!userToStore) {
-      console.error('❌ No username available - either provide username or ensure JWT token is valid');
-      return {
-        success: false,
-        error: 'No username available for PIN storage'
-      };
-    }
-
-    console.log('🔐 Storing PIN for user:', userToStore);
-    
-    // Make authenticated request to store PIN (using developer API key for now)
-    const response = await makeDeveloperRequest('/store-pin/web', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        username: userToStore,
-        pin
-      })
-    });
-
-    const data = await response.json();
-
-    if (response.ok && data.success) {
-      console.log('✅ PIN stored successfully for user:', userToStore);
-      return { success: true };
-    } else {
-      console.error('❌ Failed to store PIN:', data.error);
-      return {
-        success: false,
-        error: data.error || 'Failed to store PIN'
-      };
-    }
-  } catch (error) {
-    console.error('❌ Error storing PIN:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Network error'
-    };
-  }
-};
-
-/**
- * 🎫 GET STORED JWT TOKEN
- * Helper function to retrieve stored JWT token from email verification or other sources
- */
-export const getStoredJwtToken = async (): Promise<string | null> => {
-  try {
-    console.log('🎫 Retrieving stored JWT token...');
-    
-    // Try different storage keys in order of preference
-    const tokenSources = [
-      'email_verification_token',
-      'onairos_jwt_token',
-      'enoch_token',
-      'auth_token',
-    ];
-    
-    for (const source of tokenSources) {
-      const token = await AsyncStorage.getItem(source);
-      if (token && token.length > 20) {
-        console.log(`✅ JWT token found in ${source}:`, token.substring(0, 20) + '...');
-        return token;
-      }
-    }
-    
-    console.warn('⚠️ No JWT token found in storage');
-    return null;
-  } catch (error) {
-    console.error('❌ Error retrieving JWT token:', error);
-    return null;
-  }
-};
-
-/**
- * 🎫 CLEAR STORED TOKENS
- * Helper function to clear all stored tokens (useful for logout)
- */
-export const clearStoredTokens = async (): Promise<void> => {
-  try {
-    console.log('🧹 Clearing all stored tokens...');
-    
-    const tokenKeys = [
-      'email_verification_token',
-      'onairos_jwt_token',
-      'enoch_token',
-      'auth_token',
-      'email_verification_email',
-      'email_verification_request_id',
-      'email_verification_request_email',
-      'token_timestamp',
-      'user_pin_stored',
-      'pin_storage_timestamp',
-    ];
-    
-    await Promise.all(
-      tokenKeys.map(key => AsyncStorage.removeItem(key))
-    );
-    
-    console.log('✅ All tokens cleared successfully');
-  } catch (error) {
-    console.error('❌ Error clearing tokens:', error);
-  }
-};