@onairos/react-native 3.1.12 → 3.1.14

package/lib/commonjs/components/PlatformConnectorsStep.js

@@ -0,0 +1,828 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+var _theme = require("../theme");
+var _haptics = require("../utils/haptics");
+var _PlatformToggle = _interopRequireDefault(require("./PlatformToggle"));
+var _PersonaImage = _interopRequireDefault(require("./PersonaImage"));
+var _PrimaryButton = _interopRequireDefault(require("./PrimaryButton"));
+var _PersonalizationConsentScreen = _interopRequireDefault(require("./PersonalizationConsentScreen"));
+var _PinCreationScreen = _interopRequireDefault(require("./PinCreationScreen"));
+var _PersonaLoadingScreen = _interopRequireDefault(require("./PersonaLoadingScreen"));
+var _useConnections = require("../hooks/useConnections");
+var _connectedAccountsService = require("../services/connectedAccountsService");
+var _platformAuthService = require("../services/platformAuthService");
+var _OAuthWebView = require("./onboarding/OAuthWebView");
+var _AuthContext = require("../context/AuthContext");
+var _mobileTrainingService = require("../services/mobileTrainingService");
+var _authService = require("../services/authService");
+var _pinEncryptionService = require("../services/pinEncryptionService");
+var _pinStorageUtils = require("../services/pinStorageUtils");
+var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+var _socket = require("socket.io-client");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const PlatformConnectorsStep = ({
+  onUpdate,
+  onSkip,
+  loading = false,
+  onPinComplete,
+  onReviewerBypass
+}) => {
+  const [connectedPlatforms, setConnectedPlatforms] = (0, _react.useState)(new Set());
+  const [showConsentScreen, setShowConsentScreen] = (0, _react.useState)(false);
+  const [showPinScreen, setShowPinScreen] = (0, _react.useState)(false);
+  const [showLoadingScreen, setShowLoadingScreen] = (0, _react.useState)(false);
+  const [createdPin, setCreatedPin] = (0, _react.useState)('');
+  const [connectionStatuses, setConnectionStatuses] = (0, _react.useState)({});
+  const [showOAuthWebView, setShowOAuthWebView] = (0, _react.useState)(false);
+  const [oauthUrl, setOauthUrl] = (0, _react.useState)('');
+  const [currentPlatform, setCurrentPlatform] = (0, _react.useState)('');
+  const [longPressTimer, setLongPressTimer] = (0, _react.useState)(null);
+
+  // EXACT same training state variables as UniversalOnboarding
+  const [username, setUsername] = (0, _react.useState)('');
+  const [personaProgress, setPersonaProgress] = (0, _react.useState)(0);
+  const [personaStatus, setPersonaStatus] = (0, _react.useState)('Initializing...');
+  const [isPersonaComplete, setIsPersonaComplete] = (0, _react.useState)(false);
+  const [socketConnected, setSocketConnected] = (0, _react.useState)(false);
+  const [hasError, setHasError] = (0, _react.useState)(false);
+  const [userTraits, setUserTraits] = (0, _react.useState)(null);
+  const [inferenceResults, setInferenceResults] = (0, _react.useState)(null);
+  const [userToken, setUserToken] = (0, _react.useState)(null);
+  const [userInfo, setUserInfo] = (0, _react.useState)(null);
+  const socketRef = (0, _react.useRef)(null);
+
+  // EXACT same background training state as UniversalOnboarding
+  const [isBackgroundTrainingStarted, setIsBackgroundTrainingStarted] = (0, _react.useState)(false);
+  const [backgroundTrainingProgress, setBackgroundTrainingProgress] = (0, _react.useState)('');
+  const [backgroundSocketId, setBackgroundSocketId] = (0, _react.useState)(null);
+
+  // Use the real platform connection hook
+  const {
+    connectPlatform,
+    disconnectPlatform,
+    isConnecting
+  } = (0, _useConnections.useConnections)();
+
+  // Get the authenticated user from auth context
+  const {
+    user
+  } = (0, _AuthContext.useAuth)();
+
+  // Initialize username on mount
+  (0, _react.useEffect)(() => {
+    const initializeUsername = async () => {
+      try {
+        // First try to get stored username
+        const storedUsername = await _asyncStorage.default.getItem('onairos_username');
+        if (storedUsername && !username) {
+          console.log('📝 [USERNAME] Using stored username:', storedUsername);
+          setUsername(storedUsername);
+          return;
+        }
+
+        // If no stored username, generate from user data
+        if (user && !username) {
+          var _user$email;
+          const initialUsername = (user === null || user === void 0 || (_user$email = user.email) === null || _user$email === void 0 ? void 0 : _user$email.split('@')[0]) || (user === null || user === void 0 ? void 0 : user.name) || `user_${Math.floor(Math.random() * 10000)}`;
+          console.log('📝 [USERNAME] Generated username from user data:', initialUsername);
+          setUsername(initialUsername);
+          // Store it for future use
+          await _asyncStorage.default.setItem('onairos_username', initialUsername);
+          return;
+        }
+
+        // If no user data and no stored username, create a fallback
+        if (!username) {
+          const fallbackUsername = `mobile_user_${Math.floor(Math.random() * 10000)}`;
+          console.log('📝 [USERNAME] Using fallback username:', fallbackUsername);
+          setUsername(fallbackUsername);
+          await _asyncStorage.default.setItem('onairos_username', fallbackUsername);
+        }
+      } catch (error) {
+        console.error('❌ [USERNAME] Error initializing username:', error);
+        // Fallback to simple username
+        const fallbackUsername = `user_${Math.floor(Math.random() * 10000)}`;
+        setUsername(fallbackUsername);
+      }
+    };
+    initializeUsername();
+  }, [user, username]);
+
+  // EXACT same ensureAuthToken function from UniversalOnboarding
+  const ensureAuthToken = async () => {
+    try {
+      var _user$name, _onairosResponseData$;
+      let existingToken = (await _asyncStorage.default.getItem('onairos_jwt_token')) || (await _asyncStorage.default.getItem('enoch_token')) || (await _asyncStorage.default.getItem('auth_token'));
+      if (existingToken && existingToken.trim().length > 20) {
+        console.log('✅ Authentication token already exists:', `${existingToken.substring(0, 20)}...`);
+        return existingToken;
+      }
+      console.log('🔐 Creating Enoch authentication token...');
+      console.log('🔍 [ENSURE AUTH] Current username state:', username);
+      console.log('🔍 [ENSURE AUTH] Current user state:', user);
+      const fallbackEmail = (user === null || user === void 0 ? void 0 : user.email) || `${username || 'user'}@onairos.temp`;
+      const fallbackUsername = username || (user === null || user === void 0 || (_user$name = user.name) === null || _user$name === void 0 ? void 0 : _user$name.split('@')[0]) || 'mobile_user';
+      console.log('🔍 [ENSURE AUTH] Using fallback email:', fallbackEmail);
+      console.log('🔍 [ENSURE AUTH] Using fallback username:', fallbackUsername);
+
+      // Create Enoch user
+      try {
+        await fetch('https://api2.onairos.uk/enoch/users/register', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            email: fallbackEmail,
+            name: fallbackUsername,
+            photoUrl: ''
+          })
+        });
+      } catch (enochError) {
+        console.warn('⚠️ Enoch user creation failed (continuing):', enochError);
+      }
+
+      // Create Onairos account to 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: fallbackUsername,
+          name: fallbackUsername
+        })
+      });
+      if (!onairosSignupResponse.ok) {
+        const errorText = await onairosSignupResponse.text();
+        throw new Error(`Onairos signup failed: ${onairosSignupResponse.status} ${errorText}`);
+      }
+      const onairosResponseData = await onairosSignupResponse.json();
+      let authToken = onairosResponseData.token || ((_onairosResponseData$ = onairosResponseData.data) === null || _onairosResponseData$ === void 0 ? void 0 : _onairosResponseData$.token) || onairosResponseData.jwt;
+      if (!authToken) {
+        throw new Error('No authentication token returned from server');
+      }
+
+      // Store the token
+      await _asyncStorage.default.setItem('onairos_jwt_token', authToken);
+      await _asyncStorage.default.setItem('auth_token', authToken);
+      await _asyncStorage.default.setItem('enoch_token', authToken);
+      await _asyncStorage.default.setItem('onairos_username', onairosResponseData.username || fallbackUsername);
+      console.log('✅ Successfully stored authentication tokens');
+      return authToken;
+    } catch (error) {
+      console.error('❌ Error ensuring authentication token:', error);
+      throw error;
+    }
+  };
+
+  // EXACT same background training function from UniversalOnboarding
+  const startBackgroundTraining = (0, _react.useCallback)(async () => {
+    try {
+      console.log('🚀 [BACKGROUND] Starting background training optimization...');
+      setBackgroundTrainingProgress('Connecting...');
+      const authToken = await ensureAuthToken();
+      if (!authToken) {
+        throw new Error('Failed to create authentication token for background training');
+      }
+      console.log('✅ [BACKGROUND] Auth token ready:', `${authToken.substring(0, 20)}...`);
+      setUserToken(authToken);
+
+      // Set up user info if not available
+      if (!userInfo) {
+        var _user$email2;
+        const storedUsername = await (0, _authService.getOnairosUsername)();
+        const fallbackUsername = storedUsername || (user === null || user === void 0 || (_user$email2 = user.email) === null || _user$email2 === void 0 ? void 0 : _user$email2.split('@')[0]) || (user === null || user === void 0 ? void 0 : user.name) || 'mobile_user';
+        const newUserInfo = {
+          username: fallbackUsername,
+          email: (user === null || user === void 0 ? void 0 : user.email) || null,
+          id: null
+        };
+        setUserInfo(newUserInfo);
+        setUsername(fallbackUsername);
+        console.log('🧑‍💻 [BACKGROUND] User info set:', newUserInfo);
+      }
+      console.log('🔌 [BACKGROUND] Setting up socket for background training...');
+      setBackgroundTrainingProgress('Initializing data collection...');
+      const backgroundSocket = (0, _socket.io)('https://api2.onairos.uk', {
+        transports: ['websocket', 'polling'],
+        autoConnect: false,
+        timeout: 15000,
+        reconnection: true,
+        reconnectionAttempts: 3,
+        reconnectionDelay: 1000,
+        forceNew: true
+      });
+      backgroundSocket.on('connect', async () => {
+        console.log('✅ [BACKGROUND] Socket connected, starting background data collection...');
+        const socketId = backgroundSocket.id;
+        setBackgroundSocketId(socketId || null);
+        setBackgroundTrainingProgress('Collecting your data...');
+        if (socketId) {
+          // Step 4: Start background training WITHOUT PIN (per backend instructions)
+          await startBackgroundEnochTraining(socketId, authToken);
+        }
+      });
+      backgroundSocket.on('trainingUpdate', data => {
+        console.log('🔥 [SOCKET] Received trainingUpdate event:', data);
+        if (data.progress) {
+          setBackgroundTrainingProgress(data.status || 'Processing...');
+          setPersonaProgress(data.progress);
+          setPersonaStatus(data.status || 'Training in progress');
+          console.log('📊 [BACKGROUND] Training progress:', data.progress, '%');
+        } else {
+          console.log('⚠️ [SOCKET] trainingUpdate event has no progress data:', data);
+        }
+      });
+      backgroundSocket.on('disconnect', () => {
+        console.log('❌ [BACKGROUND] Socket disconnected');
+      });
+      backgroundSocket.on('trainingCompleted', data => {
+        console.log('🔥 [SOCKET] Received trainingCompleted event:', data);
+        console.log('✅ [BACKGROUND] Training Complete:', data);
+        setPersonaStatus('Running test inference');
+        setPersonaProgress(60);
+      });
+      backgroundSocket.on('inferenceCompleted', data => {
+        console.log('🔥 [SOCKET] Received inferenceCompleted event:', data);
+        console.log('🧠 [BACKGROUND] Inference Complete:', data);
+        setPersonaStatus('Uploading to S3');
+        setPersonaProgress(80);
+      });
+      backgroundSocket.on('modelStandby', data => {
+        console.log('🔥 [SOCKET] Received modelStandby event:', data);
+        console.log('🎉 [BACKGROUND] All Complete:', data);
+        setIsPersonaComplete(true);
+        setPersonaStatus('Complete!');
+        setPersonaProgress(100);
+      });
+      backgroundSocket.on('connect_error', error => {
+        console.error('❌ [BACKGROUND] Socket connection error:', error);
+        setBackgroundTrainingProgress('Connection failed');
+        setPersonaStatus('Connection error');
+        setPersonaProgress(0);
+      });
+
+      // Store socket reference for later use
+      socketRef.current = backgroundSocket;
+
+      // Connect the socket to start background training
+      backgroundSocket.connect();
+      console.log('✅ [BACKGROUND] Background training initiated successfully');
+    } catch (error) {
+      console.error('❌ [BACKGROUND] Error starting background training:', error);
+      setBackgroundTrainingProgress('Failed to start training');
+      setPersonaStatus('Training failed');
+      setPersonaProgress(0);
+    }
+  }, [userInfo, username, user, connectedPlatforms]);
+
+  // EXACT same background training API call from UniversalOnboarding
+  const startBackgroundEnochTraining = async (socketId, authToken) => {
+    try {
+      console.log('🚀 [BACKGROUND] Starting background training with socketId:', socketId);
+      console.log('🔑 Using auth token:', `${authToken.substring(0, 20)}...`);
+
+      // Prepare background training data - EXACT same as UniversalOnboarding
+      const backgroundData = {
+        socketId,
+        username: (userInfo === null || userInfo === void 0 ? void 0 : userInfo.username) || (userInfo === null || userInfo === void 0 ? void 0 : userInfo.name) || username || 'mobile_user',
+        email: (userInfo === null || userInfo === void 0 ? void 0 : userInfo.email) || null,
+        modelKey: null,
+        connectedPlatforms: [],
+        // No connected platforms for background training
+        platformConnections: {} // No platform connections for background training
+        // No encrypted PIN for background training
+      };
+      console.log('📤 Sending background training data to /mobile-training/enoch:', backgroundData);
+
+      // Use the new training function that includes YouTube migration check
+      const backgroundResult = await (0, _mobileTrainingService.startEnochTrainingWithYouTubeCheck)(backgroundData);
+      console.log('📡 Background training API response:', backgroundResult);
+
+      // Handle CONNECTIONS_REQUIRED scenario (pre-training validation)
+      if (backgroundResult.requiresConnections || backgroundResult.code === 'CONNECTIONS_REQUIRED') {
+        console.log('🔗 Connections required detected from background training');
+        setPersonaStatus('Connections required');
+        setHasError(true);
+        setBackgroundTrainingProgress('');
+        return;
+      }
+      if (backgroundResult.success) {
+        console.log('✅ [BACKGROUND] Training started successfully');
+        console.log('🔍 [BACKGROUND] Setting isBackgroundTrainingStarted to true');
+        setIsBackgroundTrainingStarted(true);
+        setBackgroundTrainingProgress('Training model...');
+        setPersonaStatus('Training model...');
+        setPersonaProgress(25);
+        console.log('🔍 [BACKGROUND] Background training state updated:', {
+          isBackgroundTrainingStarted: true,
+          backgroundSocketId: socketId
+        });
+      } else {
+        console.error('❌ Background training start failed:', backgroundResult.error);
+        setPersonaStatus(`Error: ${backgroundResult.error || 'Background training failed to start'}`);
+        setHasError(true);
+        setBackgroundTrainingProgress('');
+        throw new Error(backgroundResult.error || 'Background training failed to start');
+      }
+    } catch (error) {
+      console.error('❌ [BACKGROUND] Background training error:', error);
+      setPersonaStatus('Training failed to start');
+      setHasError(true);
+      setBackgroundTrainingProgress('');
+      throw error;
+    }
+  };
+
+  // EXACT same continue training function from UniversalOnboarding
+  const continueBackgroundTrainingWithPin = async userPin => {
+    try {
+      var _socketRef$current, _socketRef$current2;
+      console.log('🔐 [BACKGROUND] Continuing existing background training with PIN validation');
+      console.log('🔑 Using auth token:', `${userToken === null || userToken === void 0 ? void 0 : userToken.substring(0, 20)}...`);
+      if (!backgroundSocketId) {
+        throw new Error('No background training socket available');
+      }
+      const encryptedPin = await (0, _pinEncryptionService.getEncryptedPinForAPI)().catch(() => null);
+      if (!encryptedPin) {
+        console.warn('⚠️ No encrypted PIN available, continuing without PIN validation');
+      }
+      console.log('📤 [BACKGROUND] Sending PIN validation to continue training...');
+      setPersonaStatus('Validating PIN and continuing training');
+      setPersonaProgress(30);
+
+      // Check socket connection status after PIN submission
+      console.log('🔍 [SOCKET] Socket connection status after PIN:', {
+        socketId: backgroundSocketId,
+        isConnected: (_socketRef$current = socketRef.current) === null || _socketRef$current === void 0 ? void 0 : _socketRef$current.connected,
+        socketExists: !!socketRef.current,
+        socketId_current: (_socketRef$current2 = socketRef.current) === null || _socketRef$current2 === void 0 ? void 0 : _socketRef$current2.id
+      });
+    } catch (error) {
+      console.error('❌ [BACKGROUND] Failed to continue training with PIN:', error);
+      throw error;
+    }
+  };
+
+  // Cleanup socket on unmount
+  (0, _react.useEffect)(() => {
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.disconnect();
+      }
+    };
+  }, []);
+
+  // Real platforms that can be connected (from UniversalOnboarding)
+  const platforms = [{
+    id: 'pinterest',
+    name: 'Pinterest',
+    icon: (0, _connectedAccountsService.getPlatformIcon)('pinterest'),
+    description: 'We analyze your pins, boards, and interests to understand your style and preferences.'
+  }, {
+    id: 'youtube',
+    name: 'YouTube',
+    icon: (0, _connectedAccountsService.getPlatformIcon)('youtube'),
+    description: 'We analyze your watch history, likes, and subscriptions to understand your interests.'
+  }, {
+    id: 'linkedin',
+    name: 'LinkedIn',
+    icon: (0, _connectedAccountsService.getPlatformIcon)('linkedin'),
+    description: 'We analyze your professional network and career interests.'
+  }, {
+    id: 'reddit',
+    name: 'Reddit',
+    icon: (0, _connectedAccountsService.getPlatformIcon)('reddit'),
+    description: 'We analyze your posts and comments to understand your interests.'
+  }, {
+    id: 'gmail',
+    name: 'Gmail',
+    icon: (0, _connectedAccountsService.getPlatformIcon)('gmail'),
+    description: 'We analyze your email patterns to understand your communication style.'
+  }];
+  const handlePlatformToggle = async (platformId, enabled) => {
+    console.log(`🔄 [PLATFORM TOGGLE] ${platformId} - enabled: ${enabled}, username: "${username}", user:`, user);
+    (0, _haptics.triggerHaptic)(_haptics.HapticType.BUTTON_PRESS);
+    try {
+      if (enabled) {
+        // Ensure we have a valid username before proceeding
+        let validUsername = username;
+        if (!validUsername || validUsername.trim() === '') {
+          console.log('⚠️ [PLATFORM TOGGLE] No username available, generating one...');
+
+          // Try to get stored username first
+          const storedUsername = await _asyncStorage.default.getItem('onairos_username');
+          if (storedUsername) {
+            validUsername = storedUsername;
+            setUsername(validUsername);
+          } else {
+            var _user$email3;
+            // Generate username from user data or fallback
+            validUsername = (user === null || user === void 0 || (_user$email3 = user.email) === null || _user$email3 === void 0 ? void 0 : _user$email3.split('@')[0]) || (user === null || user === void 0 ? void 0 : user.name) || `mobile_user_${Math.floor(Math.random() * 10000)}`;
+            setUsername(validUsername);
+            await _asyncStorage.default.setItem('onairos_username', validUsername);
+          }
+          console.log(`📝 [PLATFORM TOGGLE] Using username: "${validUsername}"`);
+        }
+
+        // Check if the platform has a native SDK
+        if ((0, _platformAuthService.hasNativeSDK)(platformId)) {
+          console.log(`🔧 [PLATFORM TOGGLE] ${platformId} has native SDK`);
+          // Use native SDK authentication (YouTube)
+          setCurrentPlatform(platformId);
+          setConnectionStatuses(prev => ({
+            ...prev,
+            [platformId]: 'connecting'
+          }));
+          const success = await (0, _platformAuthService.initiateNativeAuth)(platformId, validUsername);
+          if (success) {
+            const newConnected = new Set(connectedPlatforms);
+            newConnected.add(platformId);
+            setConnectedPlatforms(newConnected);
+            setConnectionStatuses(prev => ({
+              ...prev,
+              [platformId]: 'connected'
+            }));
+            (0, _haptics.triggerHaptic)(_haptics.HapticType.SUCCESS);
+          } else {
+            setConnectionStatuses(prev => ({
+              ...prev,
+              [platformId]: 'error'
+            }));
+            (0, _haptics.triggerHaptic)(_haptics.HapticType.ERROR);
+          }
+        } else {
+          console.log(`🌐 [PLATFORM TOGGLE] ${platformId} using OAuth WebView with username: "${validUsername}"`);
+          // For platforms like Pinterest, use OAuth WebView
+          setCurrentPlatform(platformId);
+          setConnectionStatuses(prev => ({
+            ...prev,
+            [platformId]: 'connecting'
+          }));
+          console.log(`🚀 [PLATFORM TOGGLE] Calling initiateOAuth for ${platformId}...`);
+          const oauthUrl = await (0, _platformAuthService.initiateOAuth)(platformId, validUsername);
+          console.log(`📡 [PLATFORM TOGGLE] OAuth URL received for ${platformId}:`, oauthUrl);
+          if (oauthUrl) {
+            console.log(`✅ [PLATFORM TOGGLE] Setting OAuth URL and showing WebView for ${platformId}`);
+            setOauthUrl(oauthUrl);
+            setShowOAuthWebView(true);
+          } else {
+            console.log(`❌ [PLATFORM TOGGLE] No OAuth URL received for ${platformId}`);
+            setConnectionStatuses(prev => ({
+              ...prev,
+              [platformId]: 'error'
+            }));
+            (0, _haptics.triggerHaptic)(_haptics.HapticType.ERROR);
+          }
+        }
+      } else {
+        // Disconnect the platform
+        await disconnectPlatform(platformId);
+        const newConnected = new Set(connectedPlatforms);
+        newConnected.delete(platformId);
+        setConnectedPlatforms(newConnected);
+        setConnectionStatuses(prev => ({
+          ...prev,
+          [platformId]: 'disconnected'
+        }));
+        (0, _haptics.triggerHaptic)(_haptics.HapticType.BUTTON_PRESS);
+      }
+    } catch (error) {
+      console.error(`Error toggling platform ${platformId}:`, error);
+      setConnectionStatuses(prev => ({
+        ...prev,
+        [platformId]: 'error'
+      }));
+      (0, _haptics.triggerHaptic)(_haptics.HapticType.ERROR);
+    }
+  };
+  const handleUpdate = () => {
+    (0, _haptics.triggerHaptic)(_haptics.HapticType.BUTTON_PRESS);
+
+    // EXACT same logic as UniversalOnboarding handleProceed
+    console.log('🚀 [TRANSITION] Starting background training during connect → pin transition');
+    startBackgroundTraining().catch(error => {
+      console.error('❌ [TRANSITION] Background training failed during transition:', error);
+      // Continue to PIN screen even if training fails
+    });
+    setShowPinScreen(true);
+  };
+  const handleConsentAccept = () => {
+    (0, _haptics.triggerHaptic)(_haptics.HapticType.BUTTON_PRESS);
+    if (onPinComplete) {
+      onPinComplete(createdPin);
+    } else {
+      onUpdate(Array.from(connectedPlatforms));
+    }
+  };
+  const handleConsentDecline = () => {
+    (0, _haptics.triggerHaptic)(_haptics.HapticType.BUTTON_PRESS);
+    setShowConsentScreen(false);
+  };
+  const handleSkip = () => {
+    (0, _haptics.triggerHaptic)(_haptics.HapticType.BUTTON_PRESS);
+    onSkip();
+  };
+  const handlePinComplete = async pin => {
+    setCreatedPin(pin);
+
+    // Store PIN temporarily for training component access (EXACT same as UniversalOnboarding)
+    (0, _pinStorageUtils.setTemporaryPin)(pin);
+    console.log('🔐 [PIN SUBMIT] PIN submitted, checking for background training...');
+    console.log('🔍 [PIN SUBMIT] Background training state:', {
+      isBackgroundTrainingStarted,
+      backgroundSocketId,
+      hasBackgroundSocket: !!backgroundSocketId,
+      userToken: !!userToken,
+      userInfo: !!userInfo
+    });
+
+    // EXACT same logic as UniversalOnboarding handlePinSubmit
+    if (isBackgroundTrainingStarted && backgroundSocketId) {
+      console.log('✅ [PIN SUBMIT] Background training detected, continuing with PIN validation...');
+
+      // Continue with existing training by sending PIN validation
+      try {
+        await continueBackgroundTrainingWithPin(pin);
+        setShowPinScreen(false);
+        setShowLoadingScreen(true); // Move to loading screen to show training progress
+      } catch (error) {
+        console.error('❌ [PIN SUBMIT] Failed to continue background training:', error);
+        setPersonaStatus('Error: Failed to continue training');
+        setHasError(true);
+        setShowPinScreen(false);
+        setShowLoadingScreen(true);
+      }
+    } else {
+      console.log('ℹ️ [PIN SUBMIT] No background training detected');
+      setPersonaStatus('No training in progress. Please restart the flow.');
+      setHasError(true);
+      setShowPinScreen(false);
+      setShowLoadingScreen(true);
+    }
+    console.log('🔐 [PIN SUBMIT] PIN stored securely, moved to loading screen');
+  };
+  const handleLoadingComplete = () => {
+    setShowLoadingScreen(false);
+    setShowConsentScreen(true);
+  };
+  const handleOAuthSuccess = code => {
+    console.log(`OAuth success for ${currentPlatform} with code:`, code);
+    if (currentPlatform) {
+      // Update connected platforms
+      const newConnected = new Set(connectedPlatforms);
+      newConnected.add(currentPlatform);
+      setConnectedPlatforms(newConnected);
+      setConnectionStatuses(prev => ({
+        ...prev,
+        [currentPlatform]: 'connected'
+      }));
+      (0, _haptics.triggerHaptic)(_haptics.HapticType.SUCCESS);
+    }
+
+    // Close the OAuth window
+    setShowOAuthWebView(false);
+    setOauthUrl('');
+    setCurrentPlatform('');
+  };
+  const handleOAuthClose = () => {
+    setShowOAuthWebView(false);
+    setOauthUrl('');
+    if (currentPlatform) {
+      setConnectionStatuses(prev => ({
+        ...prev,
+        [currentPlatform]: 'disconnected'
+      }));
+    }
+    setCurrentPlatform('');
+  };
+  const handlePinBack = () => {
+    setShowPinScreen(false);
+  };
+  const handleReviewerBypass = () => {
+    console.log('🔍 Reviewer bypass activated in new UI');
+    if (onReviewerBypass) {
+      onReviewerBypass();
+    }
+  };
+  const handleSkipLongPress = () => {
+    console.log('🔍 Skip button long press detected, starting reviewer bypass timer');
+
+    // Start a timer for haptic feedback at 2 seconds
+    const hapticTimer = setTimeout(() => {
+      // Provide haptic feedback
+      _reactNative.Vibration.vibrate(100);
+    }, 2000);
+
+    // Start a timer for 4 seconds for the bypass
+    const bypassTimer = setTimeout(() => {
+      handleReviewerBypass();
+    }, 4000);
+
+    // Store the timer
+    setLongPressTimer(bypassTimer);
+  };
+  const handleSkipPressOut = () => {
+    console.log('🔍 Skip button press released, clearing reviewer bypass timer');
+
+    // Clear the timer if the press is released before 4 seconds
+    if (longPressTimer) {
+      clearTimeout(longPressTimer);
+      setLongPressTimer(null);
+    }
+  };
+
+  // Calculate persona level based on connected platforms (1-5)
+  const personaLevel = Math.min(5, Math.max(1, connectedPlatforms.size + 1));
+
+  // Show PIN screen if triggered
+  if (showPinScreen) {
+    return /*#__PURE__*/_react.default.createElement(_PinCreationScreen.default, {
+      visible: showPinScreen,
+      onComplete: handlePinComplete,
+      onBack: handlePinBack
+    });
+  }
+
+  // Show loading screen if triggered
+  if (showLoadingScreen) {
+    return /*#__PURE__*/_react.default.createElement(_PersonaLoadingScreen.default, {
+      visible: showLoadingScreen,
+      onComplete: handleLoadingComplete,
+      progress: personaProgress,
+      status: personaStatus
+    });
+  }
+
+  // Show OAuth WebView if triggered
+  if (showOAuthWebView && oauthUrl) {
+    return /*#__PURE__*/_react.default.createElement(_OAuthWebView.OAuthWebView, {
+      url: oauthUrl,
+      platform: currentPlatform,
+      onClose: handleOAuthClose,
+      onSuccess: handleOAuthSuccess,
+      onComplete: handleOAuthClose
+    });
+  }
+
+  // Show consent screen if triggered
+  if (showConsentScreen) {
+    return /*#__PURE__*/_react.default.createElement(_PersonalizationConsentScreen.default, {
+      visible: showConsentScreen,
+      onAccept: handleConsentAccept,
+      onDecline: handleConsentDecline
+    });
+  }
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.container
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.fixedHeaderSection
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.headingContainer
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.Text, {
+    style: styles.title
+  }, "Connect platforms"), /*#__PURE__*/_react.default.createElement(_reactNative.Text, {
+    style: styles.subtitle
+  }, "More connections, smarter personalization.")), /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.personaContainer
+  }, /*#__PURE__*/_react.default.createElement(_PersonaImage.default, {
+    level: personaLevel,
+    style: styles.largePersona
+  }))), /*#__PURE__*/_react.default.createElement(_reactNative.KeyboardAvoidingView, {
+    behavior: _reactNative.Platform.OS === 'ios' ? 'padding' : 'height',
+    style: styles.scrollableSection
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.ScrollView, {
+    style: styles.scrollView,
+    showsVerticalScrollIndicator: false,
+    contentContainerStyle: styles.scrollContent
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.platformsContainer
+  }, platforms.map((platform, index) => /*#__PURE__*/_react.default.createElement(_PlatformToggle.default, {
+    key: platform.id,
+    platform: platform,
+    isEnabled: connectedPlatforms.has(platform.id),
+    onToggle: handlePlatformToggle,
+    fullWidth: true,
+    isLast: index === platforms.length - 1,
+    customIconSize: platform.id === 'youtube' ? 36 : undefined
+  }))))), /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.bottomContainer
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.buttonContainer
+  }, /*#__PURE__*/_react.default.createElement(_PrimaryButton.default, {
+    label: "Continue",
+    onPress: handleUpdate,
+    disabled: loading || connectedPlatforms.size === 0 || isConnecting,
+    loading: loading || isConnecting
+  })), /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+    style: styles.skipContainer
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.TouchableOpacity, {
+    onPress: handleSkip,
+    onLongPress: handleSkipLongPress,
+    onPressOut: handleSkipPressOut,
+    activeOpacity: 0.7
+  }, /*#__PURE__*/_react.default.createElement(_reactNative.Text, {
+    style: styles.skipButton
+  }, "Skip")))));
+};
+const styles = _reactNative.StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: _theme.COLORS.surface
+  },
+  fixedHeaderSection: {
+    paddingTop: 8,
+    paddingHorizontal: 0,
+    backgroundColor: _theme.COLORS.surface,
+    maxHeight: '50%',
+    // Limit fixed section to 50% of screen
+    overflow: 'hidden' // Hide any overflow
+  },
+  scrollableSection: {
+    flex: 1
+  },
+  scrollView: {
+    flex: 1
+  },
+  scrollContent: {
+    paddingTop: 0 // Ensure scroll starts at the top
+  },
+  headingContainer: {
+    width: '100%',
+    marginBottom: 0,
+    // Remove margin to make persona very close
+    paddingHorizontal: 0
+  },
+  title: {
+    fontFamily: 'IBM Plex Sans',
+    fontWeight: '700',
+    fontSize: 24,
+    lineHeight: 32,
+    color: _theme.COLORS.grey800,
+    textAlign: 'left',
+    marginBottom: 2
+  },
+  subtitle: {
+    fontFamily: 'Inter',
+    fontWeight: '400',
+    fontSize: 16,
+    lineHeight: 24,
+    color: _theme.COLORS.grey600,
+    textAlign: 'left',
+    marginBottom: 0 // Remove bottom margin to bring persona closer
+  },
+  personaContainer: {
+    alignItems: 'center',
+    marginTop: -110,
+    // Negative margin to pull persona up into header space
+    marginBottom: 0 // Remove bottom margin
+  },
+  largePersona: {
+    width: 650,
+    // Make it bigger than default 200x200
+    height: 650,
+    marginTop: -20,
+    // Additional negative margin to override internal spacing
+    marginBottom: -20 // Pull content below up as well
+  },
+  platformsContainer: {
+    paddingHorizontal: 0,
+    paddingTop: 8,
+    // Reduced from 20 to minimize space at top of scroll area
+    paddingBottom: 120 // More space to account for fixed buttons at bottom
+  },
+  bottomContainer: {
+    position: 'absolute',
+    bottom: -40,
+    // Position 40px from bottom of screen
+    left: 0,
+    right: 0,
+    paddingHorizontal: 0,
+    paddingBottom: _theme.SPACING.xl,
+    backgroundColor: _theme.COLORS.surface
+  },
+  buttonContainer: {
+    marginBottom: 16
+  },
+  skipContainer: {
+    alignItems: 'center'
+  },
+  skipButton: {
+    fontSize: 16,
+    fontFamily: 'Inter',
+    fontWeight: '500',
+    color: _theme.COLORS.grey600,
+    textAlign: 'center'
+  }
+});
+var _default = exports.default = PlatformConnectorsStep;
+//# sourceMappingURL=PlatformConnectorsStep.js.map