@onairos/react-native 3.1.2 → 3.1.4

package/src/components/TrainingModal.tsx

@@ -11,6 +11,7 @@ import {
   TouchableWithoutFeedback,
   SafeAreaView,
   Image,
+  Alert,
 } from 'react-native';
 import Icon from 'react-native-vector-icons/MaterialIcons';
 import { io, Socket } from 'socket.io-client';
@@ -34,10 +35,13 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
   const [socketConnected, setSocketConnected] = useState(false);
   const [trainingStatus, setTrainingStatus] = useState('Initializing...');
   const [hasError, setHasError] = useState(false);
+  const [errorCode, setErrorCode] = useState<string | null>(null);
   const [isTrainingComplete, setIsTrainingComplete] = useState(false);
   const [userTraits, setUserTraits] = useState<any>(null);
   const [inferenceResults, setInferenceResults] = useState<any>(null);
   const [internalProgress, setInternalProgress] = useState(0);
+  const [isEnochSDK, setIsEnochSDK] = useState(false); // Determine if using Enoch SDK
+  const [trainingResults, setTrainingResults] = useState<any>(null);
   
   // Use internal progress if available, otherwise fall back to prop progress
   const currentProgress = internalProgress > 0 ? internalProgress / 100 : progress;
@@ -52,36 +56,48 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
     name: username || 'mobile_user'
   };
 
-  // Start Enoch training via API
-  const startEnochTraining = async (socketId: string) => {
+  // Check if we should use Enoch SDK (based on modelKey or other criteria)
+  useEffect(() => {
+    // For now, default to clean training unless specified
+    // In real implementation, this would be determined by SDK type
+    setIsEnochSDK(modelKey?.includes('enoch') || false);
+  }, [modelKey]);
+
+  // Start training with new API schema
+  const startTraining = async (socketId: string) => {
     try {
       setTrainingStatus('Starting training...');
       setInternalProgress(10);
+      setHasError(false);
+      setErrorCode(null);
       
       if (!userToken) {
         throw new Error('No authentication token available');
       }
       
-      console.log('🚀 Starting Enoch training with socketId:', socketId);
-      console.log('🔍 Production mode: Using live training API');
+      // Determine endpoint based on SDK type
+      const endpoint = isEnochSDK ? '/mobile-training/enoch' : '/mobile-training/clean';
+      
+      console.log(`🚀 Starting training with endpoint: ${endpoint}`);
+      console.log('🔍 Production mode: Using new training API schema');
       
-      // Prepare user data for training
+      // Prepare training data in new format
       const trainingData = {
-        socketId,
-        username: userInfo?.username || userInfo?.name || username || 'mobile_user',
-        email: userInfo?.email || null,
-        modelKey: modelKey || null,
-        userId: userInfo?.id || null
+        Info: {
+          username: userInfo?.username || userInfo?.name || username || 'mobile_user',
+          // Mock connected platforms - in real implementation this would come from props
+          connectedPlatforms: ['youtube', 'instagram', 'reddit'] // TODO: Get from actual connections
+        }
       };
       
       console.log('📤 Sending training data:', trainingData);
       
-      // Call the actual training API - backend confirmed this is working
-      const response = await fetch('https://api2.onairos.uk/enoch/trainModel/mobile', {
+      // Call the new training API
+      const response = await fetch(`https://api2.onairos.uk${endpoint}`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'Authorization': `Bearer ${userToken || 'temp-token'}` // Backend has JWT auth working
+          'Authorization': `Bearer ${userToken}` // JWT token authentication
         },
         body: JSON.stringify(trainingData)
       });
@@ -90,66 +106,142 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
       
       if (result.success) {
         console.log('🚀 Training Started:', result.message);
-        setTrainingStatus('Training model...');
+        setTrainingStatus('Training initiated...');
         setInternalProgress(20);
       } else {
         console.error('Training start failed:', result.error);
-        setTrainingStatus(`Error: ${result.error}`);
-        setHasError(true);
         
-        // In production mode, don't fallback to simulation on API failure
-        console.error('🚨 Production mode: Training failed, not falling back to simulation');
+        // Handle specific error codes from new schema
+        if (result.code) {
+          setErrorCode(result.code);
+          handleTrainingError(result.code, result.error);
+        } else {
+          setTrainingStatus(`Error: ${result.error}`);
+          setHasError(true);
+        }
       }
       
     } catch (error) {
       console.error('Training start error:', error);
       setTrainingStatus(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
       setHasError(true);
-      
-      // In production mode, show the actual error
-      console.error('🚨 Production mode: Training failed with error:', error);
+    }
+  };
+
+  // Handle training errors with specific error codes
+  const handleTrainingError = (code: string, message: string) => {
+    console.error(`Training Error [${code}]:`, message);
+    setHasError(true);
+    
+    switch (code) {
+      case 'PIN_REQUIRED':
+        setTrainingStatus('PIN setup required');
+        Alert.alert(
+          'PIN Required',
+          'Please set up your PIN first before training.',
+          [
+            { text: 'Cancel', style: 'cancel' },
+            { text: 'Set PIN', onPress: () => {
+              // TODO: Navigate to PIN setup
+              console.log('Navigate to PIN setup');
+            }}
+          ]
+        );
+        break;
+        
+      case 'CONNECTIONS_REQUIRED':
+        setTrainingStatus('No connected accounts');
+        Alert.alert(
+          'Connections Required',
+          'Please connect at least one social media account before training.',
+          [
+            { text: 'Cancel', style: 'cancel' },
+            { text: 'Connect', onPress: () => {
+              // TODO: Navigate to connections
+              console.log('Navigate to connections');
+            }}
+          ]
+        );
+        break;
+        
+      case 'INSUFFICIENT_DATA':
+        setTrainingStatus('Insufficient data for training');
+        Alert.alert(
+          'Insufficient Data',
+          'We need more interaction data to train your model effectively. Please use your connected platforms more and try again.',
+          [{ text: 'OK', style: 'default' }]
+        );
+        break;
+        
+      case 'ENCRYPTION_REQUIRED':
+        setTrainingStatus('Model encryption failed');
+        Alert.alert(
+          'Encryption Error',
+          'Failed to encrypt your model. Please try again.',
+          [{ text: 'OK', style: 'default' }]
+        );
+        break;
+        
+      default:
+        setTrainingStatus(`Error: ${message}`);
+        Alert.alert(
+          'Training Error',
+          message || 'An unexpected error occurred during training.',
+          [{ text: 'OK', style: 'default' }]
+        );
     }
   };
 
   // Simulate training progress for test mode
   const simulateTraining = () => {
-    console.log('🧪 Starting simulated training...');
-    setTrainingStatus('Initializing training...');
-    setInternalProgress(10);
+    console.log('🧪 Starting simulated training with new schema phases...');
+    setTrainingStatus('Validating Requirements');
+    setInternalProgress(5);
     
-    // Fast training for test mode (shorter delays)
-    const baseDelay = 800;
-    const stages = [
-      { progress: 20, status: 'Analyzing data patterns...', delay: baseDelay },
-      { progress: 35, status: 'Building neural network...', delay: baseDelay },
-      { progress: 50, status: 'Training model...', delay: baseDelay },
-      { progress: 65, status: 'Optimizing parameters...', delay: baseDelay },
-      { progress: 80, status: 'Running test inference...', delay: baseDelay },
-      { progress: 95, status: 'Finalizing model...', delay: baseDelay },
-      { progress: 100, status: 'Complete!', delay: 300 },
+    // Simulate all phases from the new schema
+    const phases = [
+      { progress: 10, status: 'Validating Requirements', delay: 1000 },
+      { progress: 25, status: 'Training Model', delay: 2000 },
+      { progress: 50, status: 'Training Model', delay: 2000 },
+      { progress: 65, status: 'Model Trained - Running Test Inference', delay: 1500 },
+      { progress: 80, status: 'Encrypting and Compressing Model', delay: 1000 },
+      { progress: 95, status: 'Uploading Encrypted Model to ARDrive', delay: 1500 },
+      { progress: 100, status: 'Complete!', delay: 500 },
     ];
     
-    let currentStage = 0;
+    let currentPhase = 0;
     
     const progressInterval = setInterval(() => {
-      if (currentStage < stages.length) {
-        const stage = stages[currentStage];
-        setInternalProgress(stage.progress);
-        setTrainingStatus(stage.status);
+      if (currentPhase < phases.length) {
+        const phase = phases[currentPhase];
+        setInternalProgress(phase.progress);
+        setTrainingStatus(phase.status);
         
-        if (stage.progress === 100) {
+        if (phase.progress === 100) {
           setIsTrainingComplete(true);
           clearInterval(progressInterval);
           
+          // Mock completion results
+          const mockResults = {
+            completed: true,
+            message: "Model trained, encrypted, and stored successfully",
+            storage: "ARDrive",
+            encryption: true,
+            inference: isEnochSDK, // Only Enoch SDK runs inference
+            modelUrl: `https://arweave.net/mock_tx_${Date.now()}`
+          };
+          
+          setTrainingResults(mockResults);
+          
           // Auto-complete after a short delay
           setTimeout(() => {
             onComplete && onComplete();
-          }, 800);
+          }, 1000);
         }
         
-        currentStage++;
+        currentPhase++;
       }
-    }, stages[currentStage]?.delay || baseDelay);
+    }, phases[currentPhase]?.delay || 1000);
     
     // Cleanup interval on unmount
     return () => clearInterval(progressInterval);
@@ -162,16 +254,17 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
     console.log('Setting up socket connection for training...');
     console.log('🧑‍💻 User info available:', userInfo);
     console.log('🧪 Test mode:', test);
+    console.log('🔧 Using Enoch SDK:', isEnochSDK);
     
     // If test mode is enabled, use simulation instead of real API
     if (test) {
-      console.log('🧪 Test mode enabled - Using simulated training');
+      console.log('🧪 Test mode enabled - Using simulated training with new schema');
       setSocketConnected(true);
       simulateTraining();
       return;
     }
     
-    // Initialize real socket connection - backend confirmed this is working
+    // Initialize real socket connection
     try {
       console.log('🔌 Production mode: Initializing real socket connection');
       
@@ -181,13 +274,13 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
         autoConnect: false
       });
       
-      // Socket event listeners
+      // Socket event listeners for new schema
       socketRef.current.on('connect', () => {
         console.log('✅ Socket connected for training');
         setSocketConnected(true);
         const socketId = socketRef.current?.id;
         if (socketId) {
-          startEnochTraining(socketId);
+          startTraining(socketId);
         }
       });
       
@@ -201,42 +294,92 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
         setTrainingStatus('Connection failed');
         setHasError(true);
       });
+
+      // Handle training updates with new schema phases
+      socketRef.current.on('trainingUpdate', (data) => {
+        console.log('📡 Training update received:', data);
+        
+        if (data.error) {
+          if (data.code) {
+            setErrorCode(data.code);
+            handleTrainingError(data.code, data.error);
+          } else {
+            console.error('Training update error:', data.error);
+            setTrainingStatus(`Error: ${data.error}`);
+            setHasError(true);
+          }
+        } else {
+          // Handle different status phases
+          if (data.status) {
+            setTrainingStatus(data.status);
+            
+            // Update progress based on phase
+            switch (data.status) {
+              case 'Validating Requirements':
+                setInternalProgress(10);
+                break;
+              case 'Training Model':
+                setInternalProgress(data.percent || 40);
+                break;
+              case 'Model Trained - Running Test Inference':
+                setInternalProgress(65);
+                break;
+              case 'Encrypting and Compressing Model':
+                setInternalProgress(80);
+                break;
+              case 'Uploading Encrypted Model to ARDrive':
+                setInternalProgress(90);
+                break;
+              default:
+                if (data.percent) {
+                  setInternalProgress(data.percent);
+                }
+            }
+          }
+          
+          if (data.progress) {
+            setInternalProgress(data.progress);
+          }
+        }
+      });
       
+      // Handle training completion with new schema
       socketRef.current.on('trainingCompleted', (data) => {
         console.log('✅ Training Complete:', data);
-        setTrainingStatus('Running test inference...');
-        setInternalProgress(60);
+        
+        if (data.completed && data.storage === 'ARDrive' && data.encryption === true) {
+          setTrainingStatus('Training completed successfully!');
+          setIsTrainingComplete(true);
+          setInternalProgress(100);
+          setTrainingResults(data);
+          
+          // Display results
+          console.log('✅ Model URL:', data.modelUrl);
+          console.log('✅ Storage:', data.storage);
+          console.log('✅ Encrypted:', data.encryption);
+          console.log('✅ Inference:', data.inference);
+          
+          // Auto-complete after a short delay
+          setTimeout(() => {
+            onComplete && onComplete();
+          }, 1500);
+        } else {
+          console.error('Training completion missing required fields:', data);
+          setTrainingStatus('Training completed with warnings');
+          setHasError(true);
+        }
       });
-      
+
+      // Legacy handlers for backward compatibility
       socketRef.current.on('inferenceCompleted', (data) => {
         console.log('🧠 Inference Complete:', data);
-        setTrainingStatus('Uploading to S3...');
-        setInternalProgress(80);
         setUserTraits(data.traits);
         setInferenceResults(data.inferenceResults);
       });
       
       socketRef.current.on('modelStandby', (data) => {
-        console.log('🎉 All Complete:', data);
-        setIsTrainingComplete(true);
-        setTrainingStatus('Complete!');
-        setInternalProgress(100);
-        
-        // Auto-complete after a short delay
-        setTimeout(() => {
-          onComplete && onComplete();
-        }, 1500);
-      });
-      
-      socketRef.current.on('trainingUpdate', (data) => {
-        if (data.error) {
-          console.error('Training update error:', data.error);
-          setTrainingStatus(`Error: ${data.error}`);
-          setHasError(true);
-        } else if (data.progress) {
-          setInternalProgress(data.progress);
-          setTrainingStatus(data.status || 'Training in progress...');
-        }
+        console.log('🎉 Model Ready:', data);
+        // This is handled by trainingCompleted now
       });
       
       // Connect to socket
@@ -256,7 +399,46 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
         socketRef.current = null;
       }
     };
-  }, [visible, userInfo, test]);
+  }, [visible, userInfo, test, isEnochSDK]);
+
+  // Render error details for specific error codes
+  const renderErrorDetails = () => {
+    if (!hasError || !errorCode) return null;
+    
+    const errorDetails = {
+      'PIN_REQUIRED': {
+        icon: 'lock',
+        title: 'PIN Setup Required',
+        description: 'Set up your PIN to secure your AI model'
+      },
+      'CONNECTIONS_REQUIRED': {
+        icon: 'link',
+        title: 'Connect Accounts',
+        description: 'Connect at least one social media account'
+      },
+      'INSUFFICIENT_DATA': {
+        icon: 'data-usage',
+        title: 'More Data Needed',
+        description: 'We need more interaction data to train effectively'
+      },
+      'ENCRYPTION_REQUIRED': {
+        icon: 'security',
+        title: 'Encryption Failed',
+        description: 'Failed to encrypt your model securely'
+      }
+    };
+    
+    const details = errorDetails[errorCode];
+    if (!details) return null;
+    
+    return (
+      <View style={styles.errorDetailsContainer}>
+        <Icon name={details.icon} size={32} color="#FF6B6B" />
+        <Text style={styles.errorTitle}>{details.title}</Text>
+        <Text style={styles.errorDescription}>{details.description}</Text>
+      </View>
+    );
+  };
 
   return (
     <Modal
@@ -282,7 +464,9 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
                     resizeMode="contain"
                   />
                   
-                  <Text style={styles.title}>Training Your AI</Text>
+                  <Text style={styles.title}>
+                    {isEnochSDK ? 'Training AI with Inference' : 'Training Your AI'}
+                  </Text>
                   
                   <View style={styles.progressContainer}>
                     <View style={styles.progressBar}>
@@ -307,6 +491,31 @@ export const TrainingModal: React.FC<TrainingModalProps> = ({
                     </View>
                   )}
 
+                  {renderErrorDetails()}
+                  
+                  {isTrainingComplete && trainingResults && (
+                    <View style={styles.resultsContainer}>
+                      <Icon name="check-circle" size={32} color="#4CAF50" />
+                      <Text style={styles.resultsTitle}>Training Complete!</Text>
+                      <View style={styles.resultsDetails}>
+                        <View style={styles.resultItem}>
+                          <Icon name="cloud-done" size={16} color="#666" />
+                          <Text style={styles.resultText}>Storage: {trainingResults.storage}</Text>
+                        </View>
+                        <View style={styles.resultItem}>
+                          <Icon name="security" size={16} color="#666" />
+                          <Text style={styles.resultText}>Encrypted: {trainingResults.encryption ? 'Yes' : 'No'}</Text>
+                        </View>
+                        {trainingResults.inference && (
+                          <View style={styles.resultItem}>
+                            <Icon name="psychology" size={16} color="#666" />
+                            <Text style={styles.resultText}>Inference: Completed</Text>
+                          </View>
+                        )}
+                      </View>
+                    </View>
+                  )}
+
                   <View style={styles.footer}>
                     <TouchableOpacity
                       style={styles.cancelButton}
@@ -390,6 +599,7 @@ const styles = StyleSheet.create({
     fontSize: 14,
     color: COLORS.text.secondary,
     marginBottom: 24,
+    textAlign: 'center',
   },
   progressContainer: {
     width: '100%',
@@ -466,11 +676,62 @@ const styles = StyleSheet.create({
   errorContainer: {
     flexDirection: 'row',
     alignItems: 'center',
-    marginBottom: 24,
+    marginBottom: 16,
   },
   errorText: {
     fontSize: 14,
     color: '#FF6B6B',
     marginLeft: 8,
   },
+  errorDetailsContainer: {
+    alignItems: 'center',
+    marginBottom: 24,
+    padding: 16,
+    backgroundColor: '#FFF5F5',
+    borderRadius: 12,
+    borderWidth: 1,
+    borderColor: '#FFEBEE',
+  },
+  errorTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#FF6B6B',
+    marginTop: 8,
+    marginBottom: 4,
+  },
+  errorDescription: {
+    fontSize: 14,
+    color: '#666',
+    textAlign: 'center',
+  },
+  resultsContainer: {
+    alignItems: 'center',
+    marginBottom: 24,
+    padding: 16,
+    backgroundColor: '#F5F5F5',
+    borderRadius: 12,
+    borderWidth: 1,
+    borderColor: '#E0E0E0',
+  },
+  resultsTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#4CAF50',
+    marginTop: 8,
+    marginBottom: 12,
+  },
+  resultsDetails: {
+    alignItems: 'flex-start',
+    width: '100%',
+  },
+  resultItem: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    marginBottom: 4,
+  },
+  resultText: {
+    fontSize: 14,
+    color: '#666',
+    marginLeft: 8,
+  },
 });

package/src/components/UniversalOnboarding.tsx

@@ -488,20 +488,6 @@ export const UniversalOnboarding: React.FC<UniversalOnboardingProps> = ({
     console.log('🧪 testMode value:', testMode);
     console.log('🧪 isTestMode computed:', isTestMode);
     
-    // TEMPORARY TESTFLIGHT DEBUG - REMOVE AFTER FIXING
-    const debugInfo = {
-      testMode: testMode,
-      isTestMode: isTestMode,
-      requestEmailVerificationAvailable: typeof requestEmailVerification === 'function',
-      email: email?.substring(0, 5) + '...',
-      emailLength: email?.length || 0
-    };
-    
-    if (__DEV__ || debug) {
-      Alert.alert('🔍 DEBUG INFO', JSON.stringify(debugInfo, null, 2));
-    }
-    // END TEMPORARY DEBUG
-    
     try {
       if (!email || !email.trim()) {
         console.log('❌ No email provided');

package/src/services/apiKeyService.ts

@@ -61,8 +61,9 @@ export const initializeApiKey = async (config: OnairosConfig): Promise<void> =>
       throw new Error('Developer API key is required for SDK initialization');
     }
 
-    if (config.apiKey.length < 32) {
-      throw new Error('Invalid API key format. API key must be at least 32 characters long.');
+    // Check if it's admin key first (admin key is shorter than 32 chars)
+    if (!isAdminKey(config.apiKey) && config.apiKey.length < 32) {
+      throw new Error('Invalid API key format. Developer keys must be at least 32 characters long.');
     }
 
     // Set global configuration
@@ -84,11 +85,11 @@ export const initializeApiKey = async (config: OnairosConfig): Promise<void> =>
       });
     }
 
-    // Validate the developer API key
+    // Validate the API key (handles both admin and developer keys)
     const validation = await validateApiKey(config.apiKey);
     
     if (!validation.isValid) {
-      throw new Error(`Developer API key validation failed: ${validation.error}`);
+      throw new Error(`API key validation failed: ${validation.error}`);
     }
 
     // Try to load existing JWT token
@@ -98,7 +99,13 @@ export const initializeApiKey = async (config: OnairosConfig): Promise<void> =>
     
     if (globalConfig.enableLogging) {
       console.log('✅ Onairos SDK initialized successfully');
-      console.log('🔑 Developer API key ready for app-level operations');
+      
+      if (isAdminKey(config.apiKey)) {
+        console.log('🔑 Admin API key ready with full permissions');
+      } else {
+        console.log('🔑 Developer API key ready for app-level operations');
+      }
+      
       if (userToken) {
         console.log('🎫 User JWT token loaded from storage');
       }