@onairos/react-native 3.1.12 → 3.1.13

package/src/services/jwtStorageService.ts

@@ -0,0 +1,257 @@
+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

@@ -0,0 +1,204 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,97 @@
+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');
+};