@onairos/react-native 3.1.16 → 3.1.18

package/src/context/AuthContext.tsx

@@ -1,393 +1,393 @@
-import React, { createContext, useState, useEffect, useContext } from 'react';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { User } from '../types/index';
-import { 
-  saveAuthToken, 
-  getAuthToken, 
-  removeAuthToken, 
-  verifyToken, 
-  getUserProfile, 
-  authenticateWithApple,
-  authenticateWithOnairos,
-  authenticateWithOnairosSignIn,
-  updateUserOnboardedStatus
-} from '../services/authService';
-import {
-  saveUserProgress,
-  saveAuthState,
-  getAuthState,
-  clearUserData,
-  getResumeTarget,
-  markStepCompleted,
-  updateLastScreen,
-  isReturningUser,
-  markEventPageReached,
-  hasEventAccessToken,
-  STORAGE_KEYS
-} from '../services/storageService';
-
-interface AuthContextType {
-  user: User | null;
-  isLoading: boolean;
-  hasCompletedOnboarding: boolean;
-  login: (userData: User) => void;
-  logout: () => void;
-  deleteAccount: () => Promise<void>;
-  completeOnboarding: (userData: Partial<User>) => void;
-  updateUser: (userData: Partial<User>) => void;
-  appleSignIn: (appleAuthData: any) => Promise<User>;
-  onairosSignIn: (onairosAuthData: { token: string; email: string }) => Promise<User>;
-  isAuthenticated: boolean;
-  updateOnboardedStatus: () => Promise<void>;
-  // New methods for progress tracking
-  getResumeTarget: () => Promise<{ screen: string; params?: any }>;
-  markStepCompleted: (step: string) => Promise<void>;
-  updateLastScreen: (screen: string, params?: any) => Promise<void>;
-  isReturningUser: () => Promise<boolean>;
-  // New methods for event access token
-  markEventPageReached: (eventData?: any) => Promise<void>;
-  hasEventAccessToken: () => Promise<boolean>;
-}
-
-const AuthContext = createContext<AuthContextType | undefined>(undefined);
-
-export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-  const [user, setUser] = useState<User | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [hasCompletedOnboarding, setHasCompletedOnboarding] = useState(false);
-  const [isAuthenticated, setIsAuthenticated] = useState(false);
-
-  useEffect(() => {
-    // Check if user is already logged in
-    const loadStoredUser = async () => {
-      try {
-        // PRIORITY 1: Check if user has completed onboarding (for release mode reliability)
-        const hasEventToken = await hasEventAccessToken();
-        const storedUser = await AsyncStorage.getItem('user');
-        
-        if (hasEventToken && storedUser) {
-          console.log('🎯 Found event access token - user has completed onboarding, authentication confirmed');
-          setUser(JSON.parse(storedUser));
-          setIsAuthenticated(true);
-          setHasCompletedOnboarding(true);
-          setIsLoading(false);
-          return; // Skip network verification for completed users
-        }
-        
-        // PRIORITY 2: Check if we have a JWT token for users still in onboarding
-        const token = await getAuthToken();
-        
-        if (token) {
-          // For users with tokens but no completion token, try network verification
-          // but don't fail if network is unreachable (important for release mode)
-          let isValid = false;
-          try {
-            isValid = await verifyToken();
-          } catch (networkError) {
-            console.warn('🌐 Network verification failed, using local token validation:', networkError);
-            // In release mode, network might be slow/unreliable
-            // If we have a token and stored user, trust the local state
-            if (storedUser) {
-              console.log('💾 Network unreachable, trusting local authentication state');
-              isValid = true; // Trust local state when network fails
-            }
-          }
-          
-          if (isValid) {
-            // Token is valid (or we're trusting local state), get user data
-            if (storedUser) {
-              setUser(JSON.parse(storedUser));
-              setIsAuthenticated(true);
-            } else {
-              // If user data is not in AsyncStorage, try to fetch it
-              try {
-                const userData = await getUserProfile();
-                await AsyncStorage.setItem('user', JSON.stringify(userData));
-                setUser(userData);
-                setIsAuthenticated(true);
-                              } catch (profileError) {
-                  console.error('Failed to fetch user profile:', profileError);
-                  // Only remove token if we're sure it's invalid (not just network issues)
-                  const errorMessage = profileError instanceof Error ? profileError.message : String(profileError);
-                  if (errorMessage.includes('401') || errorMessage.includes('403')) {
-                    await removeAuthToken();
-                  } else {
-                    console.log('🌐 Profile fetch failed (likely network), keeping authentication state');
-                    // Create fallback user for offline scenarios
-                    if (token) {
-                      const fallbackUser = {
-                        id: 'offline_user',
-                        name: 'Onairos User',
-                        email: 'user@onairos.com',
-                        onboarded: false
-                      };
-                      await AsyncStorage.setItem('user', JSON.stringify(fallbackUser));
-                      setUser(fallbackUser);
-                      setIsAuthenticated(true);
-                    }
-                  }
-                }
-            }
-          } else {
-            // Token verification definitely failed - remove it
-            await removeAuthToken();
-          }
-        }
-        
-        const onboardingCompleted = await AsyncStorage.getItem('onboardingCompleted');
-        if (onboardingCompleted === 'true') {
-          setHasCompletedOnboarding(true);
-        }
-      } catch (error) {
-        console.error('Failed to load authentication state:', error);
-      } finally {
-        setIsLoading(false);
-      }
-    };
-
-    loadStoredUser();
-  }, []);
-
-  const login = async (userData: User) => {
-    try {
-      // Ensure onboarded is set to false for new users
-      const userWithOnboarded = {
-        ...userData,
-        onboarded: false // Always force camera flow for new logins
-      };
-      
-      await AsyncStorage.setItem('user', JSON.stringify(userWithOnboarded));
-      setUser(userWithOnboarded);
-      setIsAuthenticated(true);
-      
-      // Save auth state and mark authentication step as completed
-      await saveAuthState({
-        isAuthenticated: true,
-        authMethod: userData.email?.includes('apple') ? 'apple' : 'onairos',
-        hasValidToken: true,
-        userEmail: userData.email,
-        userName: userData.name
-      });
-      
-      await markStepCompleted('authentication');
-      
-      console.log('User logged in with onboarded=false:', userWithOnboarded);
-    } catch (error) {
-      console.error('Failed to save user data:', error);
-    }
-  };
-  
-  // Handle Apple Sign-In
-  const appleSignIn = async (appleAuthData: any): Promise<User> => {
-    try {
-      setIsLoading(true);
-      
-      // Call the API to authenticate with Apple
-      const authResponse = await authenticateWithApple(appleAuthData);
-      
-      // Save the JWT token
-      await saveAuthToken(authResponse.token);
-      
-      // CRITICAL: Save auth method as 'apple' for proper button logic
-      await AsyncStorage.setItem('auth_method', 'apple');
-      
-      // Save Onairos connection status from backend response
-      if (authResponse.onairos) {
-        await AsyncStorage.setItem('hasConnectedOnairos', authResponse.onairos.hasConnectedOnairos.toString());
-        if (authResponse.onairos.onairosUserId) {
-          await AsyncStorage.setItem('onairosUserId', authResponse.onairos.onairosUserId);
-        }
-        if (authResponse.onairos.lastConnectedAt) {
-          await AsyncStorage.setItem('lastConnectedAt', authResponse.onairos.lastConnectedAt);
-        }
-        console.log('🔗 Stored Onairos connection status:', authResponse.onairos.hasConnectedOnairos);
-      } else {
-        // Default to false if no Onairos info provided
-        await AsyncStorage.setItem('hasConnectedOnairos', 'false');
-        console.log('🔗 No Onairos connection info from backend, defaulting to false');
-      }
-      
-      // Create user object from response
-      const userData: User = {
-        id: authResponse.user.id,
-        name: authResponse.user.name || 'Onairos User',
-        email: authResponse.user.email,
-        profilePicture: authResponse.user.profilePicture,
-        onboarded: false // Default to false for new Apple sign-ins
-      };
-      
-      // Save user data to AsyncStorage and update state
-      await AsyncStorage.setItem('user', JSON.stringify(userData));
-      setUser(userData);
-      setIsAuthenticated(true);
-      
-      console.log('🍎 Apple sign-in completed - auth_method set to "apple"');
-      
-      return userData;
-    } catch (error) {
-      console.error('Apple sign-in failed:', error);
-      throw error;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  // Handle Onairos Sign-In (similar to Apple)
-  const onairosSignIn = async (onairosAuthData: { token: string; email: string }): Promise<User> => {
-    try {
-      setIsLoading(true);
-      
-      // Call the API to authenticate with Onairos
-      const authResponse = await authenticateWithOnairos(onairosAuthData);
-      
-      // Save the JWT token
-      await saveAuthToken(authResponse.token);
-      
-      // CRITICAL: Save auth method as 'onairos' for proper button logic
-      await AsyncStorage.setItem('auth_method', 'onairos');
-      
-      // Create user object from response
-      const userData: User = {
-        id: authResponse.user.id,
-        name: authResponse.user.name || 'Onairos User',
-        email: authResponse.user.email,
-        profilePicture: authResponse.user.profilePicture,
-        onboarded: false // Default to false for new Onairos sign-ins
-      };
-      
-      // Save user data to AsyncStorage and update state
-      await AsyncStorage.setItem('user', JSON.stringify(userData));
-      setUser(userData);
-      setIsAuthenticated(true);
-      
-      console.log('🔑 Onairos sign-in completed - auth_method set to "onairos"');
-      
-      return userData;
-    } catch (error) {
-      console.error('Onairos sign-in failed:', error);
-      throw error;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const logout = async () => {
-    try {
-      // Clear all user data using the new storage service
-      await clearUserData();
-      setUser(null);
-      setIsAuthenticated(false);
-    } catch (error) {
-      console.error('Failed to remove user data:', error);
-    }
-  };
-
-  const completeOnboarding = async (userData: Partial<User>) => {
-    try {
-      // Update user data
-      const updatedUser = { ...user, ...userData };
-      await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
-      setUser(updatedUser as User);
-      
-      // Update onboarded status on backend
-      await updateOnboardedStatus();
-    } catch (error) {
-      console.error('Failed to complete onboarding:', error);
-      throw error;
-    }
-  };
-
-  const updateUser = async (userData: Partial<User>) => {
-    try {
-      if (!user) return;
-      const updatedUser = { ...user, ...userData };
-      await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
-      setUser(updatedUser);
-    } catch (error) {
-      console.error('Failed to update user data:', error);
-    }
-  };
-
-  // Update user onboarded status
-  const updateOnboardedStatus = async (): Promise<void> => {
-    try {
-      setIsLoading(true);
-      
-      // Call the API to update onboarded status
-      await updateUserOnboardedStatus();
-      
-      // Update local user data
-      if (user) {
-        const updatedUser = { ...user, onboarded: true };
-        await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
-        setUser(updatedUser);
-      }
-    } catch (error) {
-      console.error('Failed to update onboarded status:', error);
-      throw error;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  const deleteAccount = async () => {
-    try {
-      // In a real app, you would make an API call to delete the user account on the server
-      // For example: await api.deleteUser(user.id);
-      
-      // Remove user data from AsyncStorage
-      await AsyncStorage.removeItem('user');
-      
-      // Remove JWT token
-      await removeAuthToken();
-      
-      // Clear any other user-related data from AsyncStorage
-      await AsyncStorage.removeItem('onboardingCompleted');
-      
-      // Update state
-      setUser(null);
-      setIsAuthenticated(false);
-      setHasCompletedOnboarding(false);
-      
-      console.log('Account deleted successfully');
-    } catch (error) {
-      console.error('Failed to delete account:', error);
-      throw error;
-    }
-  };
-
-  return (
-    <AuthContext.Provider value={{ 
-      user, 
-      isLoading, 
-      hasCompletedOnboarding, 
-      login, 
-      logout,
-      deleteAccount,
-      completeOnboarding,
-      updateUser,
-      appleSignIn,
-      onairosSignIn,
-      isAuthenticated,
-      updateOnboardedStatus,
-      // Progress tracking methods
-      getResumeTarget,
-      markStepCompleted,
-      updateLastScreen,
-      isReturningUser,
-      // Event access token methods
-      markEventPageReached,
-      hasEventAccessToken
-    }}>
-      {children}
-    </AuthContext.Provider>
-  );
-};
-
-export const useAuth = (): AuthContextType => {
-  const context = useContext(AuthContext);
-  if (context === undefined) {
-    throw new Error('useAuth must be used within an AuthProvider');
-  }
-  return context;
-};
+import React, { createContext, useState, useEffect, useContext } from 'react';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { User } from '../types/index';
+import { 
+  saveAuthToken, 
+  getAuthToken, 
+  removeAuthToken, 
+  verifyToken, 
+  getUserProfile, 
+  authenticateWithApple,
+  authenticateWithOnairos,
+  authenticateWithOnairosSignIn,
+  updateUserOnboardedStatus
+} from '../services/authService';
+import {
+  saveUserProgress,
+  saveAuthState,
+  getAuthState,
+  clearUserData,
+  getResumeTarget,
+  markStepCompleted,
+  updateLastScreen,
+  isReturningUser,
+  markEventPageReached,
+  hasEventAccessToken,
+  STORAGE_KEYS
+} from '../services/storageService';
+
+interface AuthContextType {
+  user: User | null;
+  isLoading: boolean;
+  hasCompletedOnboarding: boolean;
+  login: (userData: User) => void;
+  logout: () => void;
+  deleteAccount: () => Promise<void>;
+  completeOnboarding: (userData: Partial<User>) => void;
+  updateUser: (userData: Partial<User>) => void;
+  appleSignIn: (appleAuthData: any) => Promise<User>;
+  onairosSignIn: (onairosAuthData: { token: string; email: string }) => Promise<User>;
+  isAuthenticated: boolean;
+  updateOnboardedStatus: () => Promise<void>;
+  // New methods for progress tracking
+  getResumeTarget: () => Promise<{ screen: string; params?: any }>;
+  markStepCompleted: (step: string) => Promise<void>;
+  updateLastScreen: (screen: string, params?: any) => Promise<void>;
+  isReturningUser: () => Promise<boolean>;
+  // New methods for event access token
+  markEventPageReached: (eventData?: any) => Promise<void>;
+  hasEventAccessToken: () => Promise<boolean>;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const [user, setUser] = useState<User | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [hasCompletedOnboarding, setHasCompletedOnboarding] = useState(false);
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+
+  useEffect(() => {
+    // Check if user is already logged in
+    const loadStoredUser = async () => {
+      try {
+        // PRIORITY 1: Check if user has completed onboarding (for release mode reliability)
+        const hasEventToken = await hasEventAccessToken();
+        const storedUser = await AsyncStorage.getItem('user');
+        
+        if (hasEventToken && storedUser) {
+          console.log('🎯 Found event access token - user has completed onboarding, authentication confirmed');
+          setUser(JSON.parse(storedUser));
+          setIsAuthenticated(true);
+          setHasCompletedOnboarding(true);
+          setIsLoading(false);
+          return; // Skip network verification for completed users
+        }
+        
+        // PRIORITY 2: Check if we have a JWT token for users still in onboarding
+        const token = await getAuthToken();
+        
+        if (token) {
+          // For users with tokens but no completion token, try network verification
+          // but don't fail if network is unreachable (important for release mode)
+          let isValid = false;
+          try {
+            isValid = await verifyToken();
+          } catch (networkError) {
+            console.warn('🌐 Network verification failed, using local token validation:', networkError);
+            // In release mode, network might be slow/unreliable
+            // If we have a token and stored user, trust the local state
+            if (storedUser) {
+              console.log('💾 Network unreachable, trusting local authentication state');
+              isValid = true; // Trust local state when network fails
+            }
+          }
+          
+          if (isValid) {
+            // Token is valid (or we're trusting local state), get user data
+            if (storedUser) {
+              setUser(JSON.parse(storedUser));
+              setIsAuthenticated(true);
+            } else {
+              // If user data is not in AsyncStorage, try to fetch it
+              try {
+                const userData = await getUserProfile();
+                await AsyncStorage.setItem('user', JSON.stringify(userData));
+                setUser(userData);
+                setIsAuthenticated(true);
+                              } catch (profileError) {
+                  console.error('Failed to fetch user profile:', profileError);
+                  // Only remove token if we're sure it's invalid (not just network issues)
+                  const errorMessage = profileError instanceof Error ? profileError.message : String(profileError);
+                  if (errorMessage.includes('401') || errorMessage.includes('403')) {
+                    await removeAuthToken();
+                  } else {
+                    console.log('🌐 Profile fetch failed (likely network), keeping authentication state');
+                    // Create fallback user for offline scenarios
+                    if (token) {
+                      const fallbackUser = {
+                        id: 'offline_user',
+                        name: 'Onairos User',
+                        email: 'user@onairos.com',
+                        onboarded: false
+                      };
+                      await AsyncStorage.setItem('user', JSON.stringify(fallbackUser));
+                      setUser(fallbackUser);
+                      setIsAuthenticated(true);
+                    }
+                  }
+                }
+            }
+          } else {
+            // Token verification definitely failed - remove it
+            await removeAuthToken();
+          }
+        }
+        
+        const onboardingCompleted = await AsyncStorage.getItem('onboardingCompleted');
+        if (onboardingCompleted === 'true') {
+          setHasCompletedOnboarding(true);
+        }
+      } catch (error) {
+        console.error('Failed to load authentication state:', error);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    loadStoredUser();
+  }, []);
+
+  const login = async (userData: User) => {
+    try {
+      // Ensure onboarded is set to false for new users
+      const userWithOnboarded = {
+        ...userData,
+        onboarded: false // Always force camera flow for new logins
+      };
+      
+      await AsyncStorage.setItem('user', JSON.stringify(userWithOnboarded));
+      setUser(userWithOnboarded);
+      setIsAuthenticated(true);
+      
+      // Save auth state and mark authentication step as completed
+      await saveAuthState({
+        isAuthenticated: true,
+        authMethod: userData.email?.includes('apple') ? 'apple' : 'onairos',
+        hasValidToken: true,
+        userEmail: userData.email,
+        userName: userData.name
+      });
+      
+      await markStepCompleted('authentication');
+      
+      console.log('User logged in with onboarded=false:', userWithOnboarded);
+    } catch (error) {
+      console.error('Failed to save user data:', error);
+    }
+  };
+  
+  // Handle Apple Sign-In
+  const appleSignIn = async (appleAuthData: any): Promise<User> => {
+    try {
+      setIsLoading(true);
+      
+      // Call the API to authenticate with Apple
+      const authResponse = await authenticateWithApple(appleAuthData);
+      
+      // Save the JWT token
+      await saveAuthToken(authResponse.token);
+      
+      // CRITICAL: Save auth method as 'apple' for proper button logic
+      await AsyncStorage.setItem('auth_method', 'apple');
+      
+      // Save Onairos connection status from backend response
+      if (authResponse.onairos) {
+        await AsyncStorage.setItem('hasConnectedOnairos', authResponse.onairos.hasConnectedOnairos.toString());
+        if (authResponse.onairos.onairosUserId) {
+          await AsyncStorage.setItem('onairosUserId', authResponse.onairos.onairosUserId);
+        }
+        if (authResponse.onairos.lastConnectedAt) {
+          await AsyncStorage.setItem('lastConnectedAt', authResponse.onairos.lastConnectedAt);
+        }
+        console.log('🔗 Stored Onairos connection status:', authResponse.onairos.hasConnectedOnairos);
+      } else {
+        // Default to false if no Onairos info provided
+        await AsyncStorage.setItem('hasConnectedOnairos', 'false');
+        console.log('🔗 No Onairos connection info from backend, defaulting to false');
+      }
+      
+      // Create user object from response
+      const userData: User = {
+        id: authResponse.user.id,
+        name: authResponse.user.name || 'Onairos User',
+        email: authResponse.user.email,
+        profilePicture: authResponse.user.profilePicture,
+        onboarded: false // Default to false for new Apple sign-ins
+      };
+      
+      // Save user data to AsyncStorage and update state
+      await AsyncStorage.setItem('user', JSON.stringify(userData));
+      setUser(userData);
+      setIsAuthenticated(true);
+      
+      console.log('🍎 Apple sign-in completed - auth_method set to "apple"');
+      
+      return userData;
+    } catch (error) {
+      console.error('Apple sign-in failed:', error);
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Handle Onairos Sign-In (similar to Apple)
+  const onairosSignIn = async (onairosAuthData: { token: string; email: string }): Promise<User> => {
+    try {
+      setIsLoading(true);
+      
+      // Call the API to authenticate with Onairos
+      const authResponse = await authenticateWithOnairos(onairosAuthData);
+      
+      // Save the JWT token
+      await saveAuthToken(authResponse.token);
+      
+      // CRITICAL: Save auth method as 'onairos' for proper button logic
+      await AsyncStorage.setItem('auth_method', 'onairos');
+      
+      // Create user object from response
+      const userData: User = {
+        id: authResponse.user.id,
+        name: authResponse.user.name || 'Onairos User',
+        email: authResponse.user.email,
+        profilePicture: authResponse.user.profilePicture,
+        onboarded: false // Default to false for new Onairos sign-ins
+      };
+      
+      // Save user data to AsyncStorage and update state
+      await AsyncStorage.setItem('user', JSON.stringify(userData));
+      setUser(userData);
+      setIsAuthenticated(true);
+      
+      console.log('🔑 Onairos sign-in completed - auth_method set to "onairos"');
+      
+      return userData;
+    } catch (error) {
+      console.error('Onairos sign-in failed:', error);
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const logout = async () => {
+    try {
+      // Clear all user data using the new storage service
+      await clearUserData();
+      setUser(null);
+      setIsAuthenticated(false);
+    } catch (error) {
+      console.error('Failed to remove user data:', error);
+    }
+  };
+
+  const completeOnboarding = async (userData: Partial<User>) => {
+    try {
+      // Update user data
+      const updatedUser = { ...user, ...userData };
+      await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
+      setUser(updatedUser as User);
+      
+      // Update onboarded status on backend
+      await updateOnboardedStatus();
+    } catch (error) {
+      console.error('Failed to complete onboarding:', error);
+      throw error;
+    }
+  };
+
+  const updateUser = async (userData: Partial<User>) => {
+    try {
+      if (!user) return;
+      const updatedUser = { ...user, ...userData };
+      await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
+      setUser(updatedUser);
+    } catch (error) {
+      console.error('Failed to update user data:', error);
+    }
+  };
+
+  // Update user onboarded status
+  const updateOnboardedStatus = async (): Promise<void> => {
+    try {
+      setIsLoading(true);
+      
+      // Call the API to update onboarded status
+      await updateUserOnboardedStatus();
+      
+      // Update local user data
+      if (user) {
+        const updatedUser = { ...user, onboarded: true };
+        await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
+        setUser(updatedUser);
+      }
+    } catch (error) {
+      console.error('Failed to update onboarded status:', error);
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const deleteAccount = async () => {
+    try {
+      // In a real app, you would make an API call to delete the user account on the server
+      // For example: await api.deleteUser(user.id);
+      
+      // Remove user data from AsyncStorage
+      await AsyncStorage.removeItem('user');
+      
+      // Remove JWT token
+      await removeAuthToken();
+      
+      // Clear any other user-related data from AsyncStorage
+      await AsyncStorage.removeItem('onboardingCompleted');
+      
+      // Update state
+      setUser(null);
+      setIsAuthenticated(false);
+      setHasCompletedOnboarding(false);
+      
+      console.log('Account deleted successfully');
+    } catch (error) {
+      console.error('Failed to delete account:', error);
+      throw error;
+    }
+  };
+
+  return (
+    <AuthContext.Provider value={{ 
+      user, 
+      isLoading, 
+      hasCompletedOnboarding, 
+      login, 
+      logout,
+      deleteAccount,
+      completeOnboarding,
+      updateUser,
+      appleSignIn,
+      onairosSignIn,
+      isAuthenticated,
+      updateOnboardedStatus,
+      // Progress tracking methods
+      getResumeTarget,
+      markStepCompleted,
+      updateLastScreen,
+      isReturningUser,
+      // Event access token methods
+      markEventPageReached,
+      hasEventAccessToken
+    }}>
+      {children}
+    </AuthContext.Provider>
+  );
+};
+
+export const useAuth = (): AuthContextType => {
+  const context = useContext(AuthContext);
+  if (context === undefined) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+};