@onairos/react-native 3.1.18 → 3.2.0

package/src/services/jwtStorageService.ts

@@ -1,257 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { Buffer } from 'buffer';
-
-/**
- * JWT Token Storage Service - CORRECTED APPROACH
- * Manages 3 DISTINCT JWT token types for different route families
- * 
- * TOKEN TYPES:
- * 1. Enoch JWT (enoch_token) - For /enoch/*, /api/auth/*, /mobile-training/enoch
- * 2. Onairos JWT (onairos_jwt_token) - For /youtube/*, /gmail/*, social connections  
- * 3. Auth Token (auth_token) - For context-specific auth flows
- */
-
-export enum TokenType {
-  ENOCH = 'enoch_token',
-  ONAIROS = 'onairos_jwt_token', 
-  AUTH = 'auth_token'
-}
-
-/**
- * Route-based token mapping
- * Determines which token type to use for which routes
- */
-export const getTokenTypeForRoute = (route: string): TokenType => {
-  const cleanRoute = route.toLowerCase();
-  
-  // Enoch routes - use Enoch JWT
-  if (cleanRoute.includes('/enoch/') || 
-      cleanRoute.includes('/api/auth/') || 
-      cleanRoute.includes('/mobile-training/enoch')) {
-    return TokenType.ENOCH;
-  }
-  
-  // Onairos routes - use Onairos JWT  
-  if (cleanRoute.includes('/youtube/') || 
-      cleanRoute.includes('/gmail/') ||
-      cleanRoute.includes('/connectedaccounts') ||
-      cleanRoute.includes('/social/')) {
-    return TokenType.ONAIROS;
-  }
-  
-  // Default to auth token for other routes
-  return TokenType.AUTH;
-};
-
-/**
- * Store JWT token of specific type
- * @param tokenType - Type of token to store
- * @param token - JWT token to store
- * @returns Promise<boolean> - Success status
- */
-export const storeJWT = async (tokenType: TokenType, token: string): Promise<boolean> => {
-  try {
-    if (!token || token.trim() === '') {
-      console.warn(`⚠️ [JWT Storage] Attempted to store empty/null ${tokenType} token`);
-      return false;
-    }
-    
-    // Validate JWT format (should have 3 parts separated by dots)
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-      console.warn(`⚠️ [JWT Storage] Invalid JWT format for ${tokenType} - token should have 3 parts`);
-      return false;
-    }
-    
-    await AsyncStorage.setItem(tokenType, token);
-    console.log(`✅ [JWT Storage] ${tokenType} token stored successfully`);
-    return true;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to store ${tokenType} token:`, error);
-    return false;
-  }
-};
-
-/**
- * Retrieve JWT token of specific type
- * @param tokenType - Type of token to retrieve
- * @returns Promise<string | null> - JWT token or null if not found
- */
-export const getJWT = async (tokenType: TokenType): Promise<string | null> => {
-  try {
-    const token = await AsyncStorage.getItem(tokenType);
-    
-    if (!token) {
-      console.log(`📭 [JWT Storage] No ${tokenType} token found in storage`);
-      return null;
-    }
-    
-    // Validate JWT format
-    if (!isValidJWTFormat(token)) {
-      console.warn(`⚠️ [JWT Storage] Invalid JWT format found for ${tokenType}, removing`);
-      await clearJWT(tokenType);
-      return null;
-    }
-    
-    console.log(`🔐 [JWT Storage] ${tokenType} token retrieved successfully`);
-    return token;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to retrieve ${tokenType} token:`, error);
-    return null;
-  }
-};
-
-/**
- * Get JWT token for specific route
- * @param route - API route to get token for
- * @returns Promise<string | null> - Appropriate JWT token or null
- */
-export const getJWTForRoute = async (route: string): Promise<string | null> => {
-  const tokenType = getTokenTypeForRoute(route);
-  const token = await getJWT(tokenType);
-  
-  if (token) {
-    console.log(`🎯 [JWT Storage] Using ${tokenType} token for route: ${route}`);
-  } else {
-    console.warn(`⚠️ [JWT Storage] No ${tokenType} token available for route: ${route}`);
-  }
-  
-  return token;
-};
-
-/**
- * Clear JWT token of specific type
- * @param tokenType - Type of token to clear
- * @returns Promise<boolean> - Success status
- */
-export const clearJWT = async (tokenType: TokenType): Promise<boolean> => {
-  try {
-    await AsyncStorage.removeItem(tokenType);
-    console.log(`✅ [JWT Storage] ${tokenType} token cleared successfully`);
-    return true;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to clear ${tokenType} token:`, error);
-    return false;
-  }
-};
-
-/**
- * Clear all JWT tokens
- * @returns Promise<boolean> - Success status
- */
-export const clearAllJWT = async (): Promise<boolean> => {
-  try {
-    await Promise.all([
-      clearJWT(TokenType.ENOCH),
-      clearJWT(TokenType.ONAIROS), 
-      clearJWT(TokenType.AUTH)
-    ]);
-    console.log('✅ [JWT Storage] All JWT tokens cleared successfully');
-    return true;
-  } catch (error) {
-    console.error('❌ [JWT Storage] Failed to clear all JWT tokens:', error);
-    return false;
-  }
-};
-
-/**
- * Replace JWT token after verification - route-aware
- * @param tokenType - Type of token being replaced
- * @param newToken - New JWT token from verification response
- * @returns Promise<boolean> - Success status
- */
-export const replaceJWTAfterVerification = async (tokenType: TokenType, newToken: string): Promise<boolean> => {
-  try {
-    console.log(`🔄 [JWT Storage] Replacing ${tokenType} token after verification`);
-    
-    if (!newToken || !isValidJWTFormat(newToken)) {
-      console.error(`❌ [JWT Storage] Invalid ${tokenType} token provided for replacement`);
-      return false;
-    }
-    
-    // Clear old token first, then store new one
-    await clearJWT(tokenType);
-    const stored = await storeJWT(tokenType, newToken);
-    
-    if (stored) {
-      console.log(`✅ [JWT Storage] ${tokenType} token successfully replaced after verification`);
-    }
-    
-    return stored;
-  } catch (error) {
-    console.error(`❌ [JWT Storage] Failed to replace ${tokenType} token after verification:`, error);
-    return false;
-  }
-};
-
-/**
- * Store Enoch JWT token (from email verification)
- * @param token - Enoch JWT token
- * @returns Promise<boolean> - Success status
- */
-export const storeEnochJWT = async (token: string): Promise<boolean> => {
-  return await storeJWT(TokenType.ENOCH, token);
-};
-
-/**
- * Store Onairos JWT token (from sign-in/registration)
- * @param token - Onairos JWT token  
- * @returns Promise<boolean> - Success status
- */
-export const storeOnairosJWT = async (token: string): Promise<boolean> => {
-  return await storeJWT(TokenType.ONAIROS, token);
-};
-
-/**
- * Store Auth token (for context-specific flows)
- * @param token - Auth token
- * @returns Promise<boolean> - Success status
- */
-export const storeAuthToken = async (token: string): Promise<boolean> => {
-  return await storeJWT(TokenType.AUTH, token);
-};
-
-/**
- * Validate JWT format
- * @param token - Token to validate
- * @returns boolean - True if valid JWT format
- */
-const isValidJWTFormat = (token: string): boolean => {
-  if (!token || token.length < 20) return false;
-  
-  // Check if it's an email address (invalid JWT)
-  if (token.includes('@') && token.includes('.') && !token.includes('Bearer') && token.length < 100) {
-    return false;
-  }
-  
-  // Check if it has JWT structure (3 parts separated by dots)
-  const tokenParts = token.split('.');
-  if (tokenParts.length !== 3) return false;
-  
-  // Additional validation - JWT should be longer than 50 characters typically
-  if (token.length < 50) return false;
-  
-  return true;
-};
-
-/**
- * Check if JWT token of specific type exists and is valid
- * @param tokenType - Type of token to check
- * @returns Promise<boolean> - True if valid token exists
- */
-export const hasValidJWT = async (tokenType: TokenType): Promise<boolean> => {
-  const token = await getJWT(tokenType);
-  return token !== null;
-};
-
-/**
- * Get all available tokens (for debugging)
- * @returns Promise<Record<TokenType, string | null>> - All tokens
- */
-export const getAllTokens = async (): Promise<Record<TokenType, string | null>> => {
-  return {
-    [TokenType.ENOCH]: await getJWT(TokenType.ENOCH),
-    [TokenType.ONAIROS]: await getJWT(TokenType.ONAIROS),
-    [TokenType.AUTH]: await getJWT(TokenType.AUTH)
-  };
-}; 

package/src/services/mobileTrainingService.ts

@@ -1,204 +0,0 @@
-import { getAuthToken } from './authService';
-// Migration functions no longer needed - backend handles all YouTube cases automatically
-// import { checkAndFixYouTubeConnection, getYouTubeConnectionStatus, shouldShowYouTubeMigrationWarning } from './youtubeMigrationService';
-
-const API_BASE_URL = 'https://api2.onairos.uk';
-
-/**
- * Mobile Training API Service
- * Implements the updated training spec routes
- */
-
-// Training Status Route
-export const getTrainingStatus = async (username: string) => {
-  try {
-    const authToken = await getAuthToken();
-    if (!authToken) {
-      throw new Error('No authentication token available');
-    }
-
-    const response = await fetch(`${API_BASE_URL}/mobile-training/status/${username}`, {
-      method: 'GET',
-      headers: {
-        'Authorization': authToken,
-        'Content-Type': 'application/json'
-      }
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json();
-      throw new Error(errorData.error || `HTTP ${response.status}`);
-    }
-
-    return await response.json();
-  } catch (error) {
-    console.error('❌ Failed to get training status:', error);
-    throw error;
-  }
-};
-
-// Model Info Route
-export const getModelInfo = async () => {
-  try {
-    const authToken = await getAuthToken();
-    if (!authToken) {
-      throw new Error('No authentication token available');
-    }
-
-    const response = await fetch(`${API_BASE_URL}/mobile-training/model-info`, {
-      method: 'GET',
-      headers: {
-        'Authorization': authToken,
-        'Content-Type': 'application/json'
-      }
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json();
-      throw new Error(errorData.error || `HTTP ${response.status}`);
-    }
-
-    return await response.json();
-  } catch (error) {
-    console.error('❌ Failed to get model info:', error);
-    throw error;
-  }
-};
-
-// Health Check Route
-export const getHealthCheck = async () => {
-  try {
-    const response = await fetch(`${API_BASE_URL}/mobile-training/health`, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json();
-      throw new Error(errorData.error || `HTTP ${response.status}`);
-    }
-
-    return await response.json();
-  } catch (error) {
-    console.error('❌ Failed to get health check:', error);
-    throw error;
-  }
-};
-
-/**
- * Start Enoch Training - Simplified Version
- * Backend now handles all YouTube connection cases automatically (temporary mode, refresh tokens, etc.)
- * No frontend migration checks needed anymore
- */
-export const startEnochTrainingWithYouTubeCheck = async (trainingData: {
-  socketId: string;
-  username: string;
-  email?: string | null;
-  modelKey?: string | null;
-  connectedPlatforms?: string[];
-  platformConnections?: any;
-  encryptedPin?: string;
-  hasPinData?: boolean;
-}) => {
-  try {
-    console.log('🚀 Starting Enoch training for user:', trainingData.username, '(backend auto-handles YouTube)');
-    
-    // ✅ SIMPLIFIED: Backend handles all YouTube connection cases automatically
-    console.log('🚀 [TRAINING] Starting training - backend handles all YouTube cases automatically');
-    console.log('ℹ️ [TRAINING] No migration checks needed:');
-    console.log('   - Temporary mode connections: Work automatically ✅');
-    console.log('   - Full refresh tokens: Auto-refresh when expired ✅');
-    console.log('   - Backend validation: Handles all edge cases ✅');
-    
-    // ✅ Proceed with training - backend handles YouTube automatically
-    return await startEnochTraining(trainingData);
-    
-  } catch (error) {
-    console.error('❌ Training error:', error);
-    throw error;
-  }
-};
-
-/**
- * Start Enoch Training
- * Updated to use the new /mobile-training/enoch endpoint with proper error handling
- */
-export const startEnochTraining = async (trainingData: {
-  socketId: string;
-  username: string;
-  email?: string | null;
-  modelKey?: string | null;
-  connectedPlatforms?: string[];
-  platformConnections?: any;
-  encryptedPin?: string;
-  hasPinData?: boolean;
-}) => {
-  try {
-    const authToken = await getAuthToken();
-    if (!authToken) {
-      throw new Error('No authentication token available');
-    }
-
-    console.log('📤 Sending training data to /mobile-training/enoch:', trainingData);
-
-    const response = await fetch(`${API_BASE_URL}/mobile-training/enoch`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': authToken
-      },
-      body: JSON.stringify(trainingData)
-    });
-
-    console.log('📡 Training API response status:', response.status);
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      console.error('❌ Training API failed with status:', response.status, 'Error:', errorText);
-      
-      // Try to parse error response
-      try {
-        const errorData = JSON.parse(errorText);
-        throw new Error(errorData.error || `HTTP ${response.status}`);
-      } catch (parseError) {
-        throw new Error(`Training API failed: ${response.status} - ${errorText}`);
-      }
-    }
-
-    const result = await response.json();
-    console.log('📡 Training API response:', result);
-
-    return result;
-  } catch (error) {
-    console.error('❌ Training start error:', error);
-    throw error;
-  }
-};
-
-/**
- * Helper function to check if training is in progress
- */
-export const isTrainingInProgress = async (username: string): Promise<boolean> => {
-  try {
-    const status = await getTrainingStatus(username);
-    return status.success && status.isTraining;
-  } catch (error) {
-    console.warn('⚠️ Could not check training status:', error);
-    return false;
-  }
-};
-
-/**
- * Helper function to get training features info
- */
-export const getTrainingFeatures = async () => {
-  try {
-    const health = await getHealthCheck();
-    return health.features;
-  } catch (error) {
-    console.warn('⚠️ Could not get training features:', error);
-    return null;
-  }
-}; 

package/src/services/pinEncryptionService.ts

@@ -1,76 +0,0 @@
-const CryptoJS = require('react-native-crypto-js');
-import { getTemporaryPin } from './pinStorageUtils';
-
-/**
- * Service for encrypting PIN data before sending to APIs
- */
-
-// Encryption key - in production, this should come from a secure source
-const ENCRYPTION_KEY = 'onairos-pin-encryption-key-2024';
-
-/**
- * Encrypt PIN using AES encryption
- */
-export const encryptPin = (pin: string): string => {
-  try {
-    const encrypted = CryptoJS.AES.encrypt(pin, ENCRYPTION_KEY).toString();
-    console.log('🔐 PIN encrypted successfully');
-    return encrypted;
-  } catch (error) {
-    console.error('❌ Error encrypting PIN:', error);
-    throw error;
-  }
-};
-
-/**
- * Decrypt PIN (for verification purposes)
- */
-export const decryptPin = (encryptedPin: string): string => {
-  try {
-    const decrypted = CryptoJS.AES.decrypt(encryptedPin, ENCRYPTION_KEY);
-    const pin = decrypted.toString(CryptoJS.enc.Utf8);
-    console.log('🔓 PIN decrypted successfully');
-    return pin;
-  } catch (error) {
-    console.error('❌ Error decrypting PIN:', error);
-    throw error;
-  }
-};
-
-/**
- * Get encrypted PIN for API transmission
- */
-export const getEncryptedPinForAPI = async (): Promise<string | null> => {
-  try {
-    // Get the temporary PIN from memory
-    const pin = getTemporaryPin();
-    
-    if (!pin) {
-      console.log('⚠️ No temporary PIN available for encryption');
-      return null;
-    }
-    
-    // Encrypt the PIN
-    const encryptedPin = encryptPin(pin);
-    console.log('✅ PIN encrypted for API transmission');
-    
-    return encryptedPin;
-  } catch (error) {
-    console.error('❌ Error getting encrypted PIN for API:', error);
-    return null;
-  }
-};
-
-/**
- * Hash PIN for verification (one-way hash)
- */
-export const hashPin = (pin: string): string => {
-  try {
-    const hash = CryptoJS.SHA256(pin + ENCRYPTION_KEY).toString();
-    console.log('🔒 PIN hashed successfully');
-    return hash;
-  } catch (error) {
-    console.error('❌ Error hashing PIN:', error);
-    throw error;
-  }
-}; 

package/src/services/pinStorageUtils.ts

@@ -1,97 +0,0 @@
-import { biometricPinService } from './biometricPinService';
-
-/**
- * Utility functions for PIN storage management
- */
-
-/**
- * Get the stored PIN for training/authentication purposes
- * This will prompt for biometric authentication
- */
-export const getStoredPinForTraining = async (): Promise<string | null> => {
-  try {
-    console.log('🔓 Retrieving stored PIN for training...');
-    
-    // Check if PIN is stored
-    const pinStored = await biometricPinService.isPinStored();
-    if (!pinStored) {
-      console.log('⚠️ No PIN stored in secure storage');
-      return null;
-    }
-    
-    // Retrieve PIN with biometric authentication
-    const pin = await biometricPinService.retrievePinWithBiometric();
-    
-    if (pin) {
-      console.log('✅ PIN retrieved successfully for training');
-      return pin;
-    } else {
-      console.log('❌ Failed to retrieve PIN or user cancelled authentication');
-      return null;
-    }
-    
-  } catch (error) {
-    console.error('❌ Error retrieving stored PIN:', error);
-    return null;
-  }
-};
-
-/**
- * Check if user has a PIN stored securely
- */
-export const hasStoredPin = async (): Promise<boolean> => {
-  try {
-    return await biometricPinService.isPinStored();
-  } catch (error) {
-    console.error('❌ Error checking PIN storage:', error);
-    return false;
-  }
-};
-
-/**
- * Remove stored PIN (for logout/reset purposes)
- */
-export const clearStoredPin = async (): Promise<boolean> => {
-  try {
-    console.log('🗑️ Clearing stored PIN...');
-    return await biometricPinService.removePinFromStorage();
-  } catch (error) {
-    console.error('❌ Error clearing stored PIN:', error);
-    return false;
-  }
-};
-
-/**
- * Get PIN for passing to training component
- * This function can be called from the onboarding flow
- */
-export const getPinForTraining = async (tempPin?: string): Promise<string | null> => {
-  // If a temporary PIN is provided (from the PIN input), use it
-  if (tempPin) {
-    console.log('📝 Using temporary PIN for training');
-    return tempPin;
-  }
-  
-  // Otherwise, try to retrieve stored PIN
-  return await getStoredPinForTraining();
-};
-
-/**
- * Store PIN temporarily in memory for training component
- * This is used when PIN is entered but not yet stored biometrically
- */
-let temporaryPin: string | null = null;
-
-export const setTemporaryPin = (pin: string): void => {
-  temporaryPin = pin;
-  console.log('📝 Temporary PIN set for training');
-};
-
-export const getTemporaryPin = (): string | null => {
-  return temporaryPin;
-};
-
-export const clearTemporaryPin = (): void => {
-  temporaryPin = null;
-  console.log('🗑️ Temporary PIN cleared');
-};