@oxyhq/services 5.5.6 → 5.5.8

package/src/ui/context/OxyContext.tsx

@@ -1,44 +1,52 @@
 import React, { createContext, useContext, useState, useEffect, useCallback, ReactNode, useMemo } from 'react';
 import { OxyServices } from '../../core';
-import { AuthManager, AuthState } from '../../core/AuthManager';
 import { User } from '../../models/interfaces';
-import { SecureClientSession } from '../../models/secureSession';
+import { SecureLoginResponse, SecureClientSession, MinimalUserData } from '../../models/secureSession';
+import { DeviceManager } from '../../utils/deviceManager';
 
-// Context interface with session management support
+// Define the context shape
 export interface OxyContextState {
-  // Auth state from AuthManager
-  isAuthenticated: boolean;
-  user: User | null;
+  // Authentication state
+  user: User | null; // Current active user (loaded from server)
+  minimalUser: MinimalUserData | null; // Minimal user data for UI
+  sessions: SecureClientSession[]; // All active sessions
+  activeSessionId: string | null;
+  isAuthenticated: boolean; // Single source of truth for authentication - use this instead of service methods
   isLoading: boolean;
   error: string | null;
 
-  // Session management
-  sessions: any[];
-  activeSessionId: string | null;
-
   // Auth methods
   login: (username: string, password: string, deviceName?: string) => Promise<User>;
   logout: (targetSessionId?: string) => Promise<void>;
+  logoutAll: () => Promise<void>;
   signUp: (username: string, email: string, password: string) => Promise<User>;
 
-  // Session management methods
-  refreshSessions: () => Promise<void>;
+  // Multi-session methods
   switchSession: (sessionId: string) => Promise<void>;
   removeSession: (sessionId: string) => Promise<void>;
-  logoutAll: () => Promise<void>;
+  refreshSessions: () => Promise<void>;
 
-  // Access to services and auth manager
-  oxyServices: OxyServices;
-  authManager: AuthManager;
+  // Device management methods
+  getDeviceSessions: () => Promise<any[]>;
+  logoutAllDeviceSessions: () => Promise<void>;
+  updateDeviceName: (deviceName: string) => Promise<void>;
 
-  // UI controls
+  // Access to services
+  oxyServices: OxyServices;
   bottomSheetRef?: React.RefObject<any>;
+
+  // API configuration
+  setApiUrl: (url: string) => void;
+
+  // Methods to directly control the bottom sheet
   showBottomSheet?: (screenOrConfig?: string | { screen: string; props?: Record<string, any> }) => void;
   hideBottomSheet?: () => void;
 }
 
+// Create the context with default values
 const OxyContext = createContext<OxyContextState | null>(null);
 
+// Props for the OxyContextProvider
 export interface OxyContextProviderProps {
   children: ReactNode;
   oxyServices: OxyServices;
@@ -47,7 +55,7 @@ export interface OxyContextProviderProps {
   bottomSheetRef?: React.RefObject<any>;
 }
 
-// Storage implementation
+// Platform storage implementation
 interface StorageInterface {
   getItem: (key: string) => Promise<string | null>;
   setItem: (key: string, value: string) => Promise<void>;
@@ -55,6 +63,7 @@ interface StorageInterface {
   clear: () => Promise<void>;
 }
 
+// Web localStorage implementation
 class WebStorage implements StorageInterface {
   async getItem(key: string): Promise<string | null> {
     return localStorage.getItem(key);
@@ -73,12 +82,15 @@ class WebStorage implements StorageInterface {
   }
 }
 
+// React Native AsyncStorage implementation
 let AsyncStorage: StorageInterface;
 
+// Determine the platform and set up storage
 const isReactNative = (): boolean => {
   return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
 };
 
+// Get appropriate storage for the platform
 const getStorage = async (): Promise<StorageInterface> => {
   if (isReactNative()) {
     if (!AsyncStorage) {
@@ -92,9 +104,16 @@ const getStorage = async (): Promise<StorageInterface> => {
     }
     return AsyncStorage;
   }
+
   return new WebStorage();
 };
 
+// Storage keys for secure sessions
+const getSecureStorageKeys = (prefix = 'oxy_secure') => ({
+  sessions: `${prefix}_sessions`, // Array of SecureClientSession objects
+  activeSessionId: `${prefix}_active_session_id`, // ID of currently active session
+});
+
 export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
   children,
   oxyServices,
@@ -102,29 +121,17 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
   onAuthStateChange,
   bottomSheetRef,
 }) => {
+  // Authentication state
+  const [user, setUser] = useState<User | null>(null);
+  const [minimalUser, setMinimalUser] = useState<MinimalUserData | null>(null);
+  const [sessions, setSessions] = useState<SecureClientSession[]>([]);
+  const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
   const [storage, setStorage] = useState<StorageInterface | null>(null);
-  const [authState, setAuthState] = useState<AuthState>({
-    isAuthenticated: false,
-    accessToken: null,
-    user: null,
-    activeSessionId: null,
-    sessions: [],
-    isLoading: true,
-    error: null,
-  });
-
-  // Create AuthManager instance
-  const authManager = useMemo(() => {
-    return new AuthManager({
-      oxyServices,
-      onStateChange: (newState) => {
-        setAuthState(newState);
-        if (onAuthStateChange) {
-          onAuthStateChange(newState.user);
-        }
-      },
-    });
-  }, [oxyServices, onAuthStateChange]);
+
+  // Storage keys (memoized to prevent infinite loops)
+  const keys = useMemo(() => getSecureStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
 
   // Initialize storage
   useEffect(() => {
@@ -134,109 +141,499 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
         setStorage(platformStorage);
       } catch (error) {
         console.error('Failed to initialize storage:', error);
-        setAuthState(prev => ({ ...prev, error: 'Failed to initialize storage', isLoading: false }));
+        setError('Failed to initialize storage');
       }
     };
+
     initStorage();
   }, []);
 
-  // Initialize authentication
+  // Effect to initialize authentication state
   useEffect(() => {
     const initAuth = async () => {
       if (!storage) return;
 
+      setIsLoading(true);
       try {
-        const activeSessionId = await storage.getItem(`${storageKeyPrefix}_active_session_id`);
-        await authManager.initialize(activeSessionId);
-      } catch (error) {
-        console.error('Auth initialization failed:', error);
-        await storage.removeItem(`${storageKeyPrefix}_active_session_id`);
+        // Load stored sessions
+        const sessionsData = await storage.getItem(keys.sessions);
+        const storedActiveSessionId = await storage.getItem(keys.activeSessionId);
+
+        console.log('SecureAuth - sessionsData:', sessionsData);
+        console.log('SecureAuth - activeSessionId:', storedActiveSessionId);
+
+        if (sessionsData) {
+          const parsedSessions: SecureClientSession[] = JSON.parse(sessionsData);
+
+          // Migrate old session format to include user info
+          const migratedSessions: SecureClientSession[] = [];
+          let shouldUpdateStorage = false;
+
+          for (const session of parsedSessions) {
+            if (!session.userId || !session.username) {
+              // Session is missing user info, try to fetch it
+              try {
+                const sessionUser = await oxyServices.getUserBySession(session.sessionId);
+                migratedSessions.push({
+                  ...session,
+                  userId: sessionUser.id,
+                  username: sessionUser.username
+                });
+                shouldUpdateStorage = true;
+                console.log(`Migrated session ${session.sessionId} for user ${sessionUser.username}`);
+              } catch (error) {
+                // Session might be invalid, skip it
+                console.log(`Removing invalid session ${session.sessionId}:`, error);
+                shouldUpdateStorage = true;
+              }
+            } else {
+              // Session already has user info
+              migratedSessions.push(session);
+            }
+          }
+
+          // Update storage if we made changes
+          if (shouldUpdateStorage) {
+            await saveSessionsToStorage(migratedSessions);
+          }
+
+          setSessions(migratedSessions);
+
+          if (storedActiveSessionId && migratedSessions.length > 0) {
+            const activeSession = migratedSessions.find(s => s.sessionId === storedActiveSessionId);
+
+            if (activeSession) {
+              console.log('SecureAuth - activeSession found:', activeSession);
+
+              // Validate session
+              try {
+                const validation = await oxyServices.validateSession(activeSession.sessionId);
+
+                if (validation.valid) {
+                  console.log('SecureAuth - session validated successfully');
+                  setActiveSessionId(activeSession.sessionId);
+
+                  // Get access token for API calls
+                  await oxyServices.getTokenBySession(activeSession.sessionId);
+
+                  // Load full user data
+                  const fullUser = await oxyServices.getUserBySession(activeSession.sessionId);
+                  setUser(fullUser);
+                  setMinimalUser({
+                    id: fullUser.id,
+                    username: fullUser.username,
+                    avatar: fullUser.avatar
+                  });
+
+                  if (onAuthStateChange) {
+                    onAuthStateChange(fullUser);
+                  }
+                } else {
+                  console.log('SecureAuth - session invalid, removing');
+                  await removeInvalidSession(activeSession.sessionId);
+                }
+              } catch (error) {
+                console.error('SecureAuth - session validation error:', error);
+                await removeInvalidSession(activeSession.sessionId);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        console.error('Secure auth initialization error:', err);
+        await clearAllStorage();
+      } finally {
+        setIsLoading(false);
       }
     };
 
     if (storage) {
       initAuth();
     }
-  }, [storage, authManager, storageKeyPrefix]);
+  }, [storage, oxyServices, keys, onAuthStateChange]);
+
+  // Remove invalid session
+  const removeInvalidSession = useCallback(async (sessionId: string): Promise<void> => {
+    const filteredSessions = sessions.filter(s => s.sessionId !== sessionId);
+    setSessions(filteredSessions);
+    await saveSessionsToStorage(filteredSessions);
+
+    // If there are other sessions, switch to the first one
+    if (filteredSessions.length > 0) {
+      await switchToSession(filteredSessions[0].sessionId);
+    } else {
+      // No valid sessions left
+      setActiveSessionId(null);
+      setUser(null);
+      setMinimalUser(null);
+      await storage?.removeItem(keys.activeSessionId);
+
+      if (onAuthStateChange) {
+        onAuthStateChange(null);
+      }
+    }
+  }, [sessions, storage, keys, onAuthStateChange]);
+
+  // Save sessions to storage
+  const saveSessionsToStorage = useCallback(async (sessionsList: SecureClientSession[]): Promise<void> => {
+    if (!storage) return;
+    await storage.setItem(keys.sessions, JSON.stringify(sessionsList));
+  }, [storage, keys.sessions]);
+
+  // Save active session ID to storage
+  const saveActiveSessionId = useCallback(async (sessionId: string): Promise<void> => {
+    if (!storage) return;
+    await storage.setItem(keys.activeSessionId, sessionId);
+  }, [storage, keys.activeSessionId]);
+
+  // Clear all storage
+  const clearAllStorage = useCallback(async (): Promise<void> => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(keys.sessions);
+      await storage.removeItem(keys.activeSessionId);
+    } catch (err) {
+      console.error('Clear secure storage error:', err);
+    }
+  }, [storage, keys]);
 
-  // Auth methods that integrate with storage
-  const login = useCallback(async (username: string, password: string, deviceName?: string): Promise<User> => {
-    await authManager.login(username, password, deviceName);
+  // Switch to a different session
+  const switchToSession = useCallback(async (sessionId: string): Promise<void> => {
+    try {
+      setIsLoading(true);
 
-    // Save session ID to storage
-    const sessionId = authManager.getActiveSessionId();
-    if (sessionId && storage) {
-      await storage.setItem(`${storageKeyPrefix}_active_session_id`, sessionId);
+      // Get access token for this session
+      await oxyServices.getTokenBySession(sessionId);
+
+      // Load full user data
+      const fullUser = await oxyServices.getUserBySession(sessionId);
+
+      setActiveSessionId(sessionId);
+      setUser(fullUser);
+      setMinimalUser({
+        id: fullUser.id,
+        username: fullUser.username,
+        avatar: fullUser.avatar
+      });
+
+      await saveActiveSessionId(sessionId);
+
+      if (onAuthStateChange) {
+        onAuthStateChange(fullUser);
+      }
+    } catch (error) {
+      console.error('Switch session error:', error);
+      setError('Failed to switch session');
+    } finally {
+      setIsLoading(false);
     }
+  }, [oxyServices, onAuthStateChange, saveActiveSessionId]);
+
+  // Secure login method
+  const login = async (username: string, password: string, deviceName?: string): Promise<User> => {
+    if (!storage) throw new Error('Storage not initialized');
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      // Get device fingerprint for enhanced device identification
+      const deviceFingerprint = DeviceManager.getDeviceFingerprint();
+
+      // Get or generate persistent device info
+      const deviceInfo = await DeviceManager.getDeviceInfo();
+
+      console.log('SecureAuth - Using device fingerprint:', deviceFingerprint);
+      console.log('SecureAuth - Using device ID:', deviceInfo.deviceId);
+
+      const response: SecureLoginResponse = await oxyServices.secureLogin(
+        username,
+        password,
+        deviceName || deviceInfo.deviceName || DeviceManager.getDefaultDeviceName(),
+        deviceFingerprint
+      );
+
+      // Create client session object with user info for duplicate detection
+      const clientSession: SecureClientSession = {
+        sessionId: response.sessionId,
+        deviceId: response.deviceId,
+        expiresAt: response.expiresAt,
+        lastActive: new Date().toISOString(),
+        userId: response.user.id,
+        username: response.user.username
+      };
+
+      // Check if this user already has a session (prevent duplicate accounts)
+      const existingUserSessionIndex = sessions.findIndex(s =>
+        s.userId === response.user.id || s.username === response.user.username
+      );
+
+      let updatedSessions: SecureClientSession[];
+
+      if (existingUserSessionIndex !== -1) {
+        // User already has a session - replace it with the new one (reused session scenario)
+        const existingSession = sessions[existingUserSessionIndex];
+        updatedSessions = [...sessions];
+        updatedSessions[existingUserSessionIndex] = clientSession;
+
+        console.log(`Reusing/updating existing session for user ${response.user.username}. Previous session: ${existingSession.sessionId}, New session: ${response.sessionId}`);
+
+        // If the replaced session was the active one, update active session
+        if (activeSessionId === existingSession.sessionId) {
+          setActiveSessionId(response.sessionId);
+          await saveActiveSessionId(response.sessionId);
+        }
+      } else {
+        // Add new session for new user
+        updatedSessions = [...sessions, clientSession];
+        console.log(`Added new session for user ${response.user.username} on device ${response.deviceId}`);
+      }
+
+      setSessions(updatedSessions);
+      await saveSessionsToStorage(updatedSessions);
+
+      // Set as active session
+      setActiveSessionId(response.sessionId);
+      await saveActiveSessionId(response.sessionId);
+
+      // Get access token for API calls
+      await oxyServices.getTokenBySession(response.sessionId);
 
-    return authManager.getCurrentUser();
-  }, [authManager, storage, storageKeyPrefix]);
+      // Load full user data
+      const fullUser = await oxyServices.getUserBySession(response.sessionId);
+      setUser(fullUser);
+      setMinimalUser(response.user);
 
-  const logout = useCallback(async (targetSessionId?: string): Promise<void> => {
-    await authManager.logout(targetSessionId);
+      if (onAuthStateChange) {
+        onAuthStateChange(fullUser);
+      }
 
-    // Clear from storage if logging out current session
-    if (!targetSessionId && storage) {
-      await storage.removeItem(`${storageKeyPrefix}_active_session_id`);
+      return fullUser;
+    } catch (error: any) {
+      setError(error.message || 'Login failed');
+      throw error;
+    } finally {
+      setIsLoading(false);
     }
-  }, [authManager, storage, storageKeyPrefix]);
+  };
 
-  const refreshSessions = useCallback(async (): Promise<void> => {
-    await authManager.refreshSessions();
-  }, [authManager]);
+  // Logout method
+  const logout = async (targetSessionId?: string): Promise<void> => {
+    if (!activeSessionId) return;
+
+    try {
+      const sessionToLogout = targetSessionId || activeSessionId;
+      await oxyServices.logoutSecureSession(activeSessionId, sessionToLogout);
+
+      // Remove session from local storage
+      const filteredSessions = sessions.filter(s => s.sessionId !== sessionToLogout);
+      setSessions(filteredSessions);
+      await saveSessionsToStorage(filteredSessions);
+
+      // If logging out active session
+      if (sessionToLogout === activeSessionId) {
+        if (filteredSessions.length > 0) {
+          // Switch to another session
+          await switchToSession(filteredSessions[0].sessionId);
+        } else {
+          // No sessions left
+          setActiveSessionId(null);
+          setUser(null);
+          setMinimalUser(null);
+          await storage?.removeItem(keys.activeSessionId);
+
+          if (onAuthStateChange) {
+            onAuthStateChange(null);
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Logout error:', error);
+      setError('Logout failed');
+    }
+  };
 
-  const switchSession = useCallback(async (sessionId: string): Promise<void> => {
-    await authManager.switchSession(sessionId);
+  // Logout all sessions
+  const logoutAll = async (): Promise<void> => {
+    console.log('logoutAll called with activeSessionId:', activeSessionId);
 
-    // Update storage with new active session
-    if (storage) {
-      await storage.setItem(`${storageKeyPrefix}_active_session_id`, sessionId);
+    if (!activeSessionId) {
+      console.error('No active session ID found, cannot logout all');
+      setError('No active session found');
+      throw new Error('No active session found');
+    }
+
+    if (!oxyServices) {
+      console.error('OxyServices not initialized');
+      setError('Service not available');
+      throw new Error('Service not available');
     }
-  }, [authManager, storage, storageKeyPrefix]);
 
-  const removeSession = useCallback(async (sessionId: string): Promise<void> => {
-    await authManager.removeSession(sessionId);
-  }, [authManager]);
+    try {
+      console.log('Calling oxyServices.logoutAllSecureSessions with sessionId:', activeSessionId);
+      await oxyServices.logoutAllSecureSessions(activeSessionId);
+      console.log('logoutAllSecureSessions completed successfully');
+
+      // Clear all local data
+      setSessions([]);
+      setActiveSessionId(null);
+      setUser(null);
+      setMinimalUser(null);
+      await clearAllStorage();
+      console.log('Local storage cleared');
+
+      if (onAuthStateChange) {
+        onAuthStateChange(null);
+        console.log('Auth state change callback called');
+      }
+    } catch (error) {
+      console.error('Logout all error:', error);
+      setError(`Logout all failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      throw error;
+    }
+  };
 
-  const logoutAll = useCallback(async (): Promise<void> => {
-    await authManager.logoutAll();
+  // Sign up method
+  const signUp = async (username: string, email: string, password: string): Promise<User> => {
+    if (!storage) throw new Error('Storage not initialized');
 
-    // Clear from storage
-    if (storage) {
-      await storage.removeItem(`${storageKeyPrefix}_active_session_id`);
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      // Create new account using the OxyServices signUp method
+      const response = await oxyServices.signUp(username, email, password);
+
+      console.log('SignUp successful:', response);
+
+      // Now log the user in securely to create a session
+      // This will handle the session creation and device registration
+      const user = await login(username, password);
+
+      return user;
+    } catch (error: any) {
+      setError(error.message || 'Sign up failed');
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Switch session method
+  const switchSession = async (sessionId: string): Promise<void> => {
+    await switchToSession(sessionId);
+  };
+
+  // Remove session method
+  const removeSession = async (sessionId: string): Promise<void> => {
+    await logout(sessionId);
+  };
+
+  // Refresh sessions method
+  const refreshSessions = async (): Promise<void> => {
+    if (!activeSessionId) return;
+
+    try {
+      const serverSessions = await oxyServices.getSessionsBySessionId(activeSessionId);
+
+      // Update local sessions with server data
+      const updatedSessions: SecureClientSession[] = serverSessions.map(serverSession => ({
+        sessionId: serverSession.sessionId,
+        deviceId: serverSession.deviceId,
+        expiresAt: new Date().toISOString(), // You might want to get this from server
+        lastActive: new Date().toISOString()
+      }));
+
+      setSessions(updatedSessions);
+      await saveSessionsToStorage(updatedSessions);
+    } catch (error) {
+      console.error('Refresh sessions error:', error);
     }
-  }, [authManager, storage, storageKeyPrefix]);
+  };
+
+  // Device management methods
+  const getDeviceSessions = async (): Promise<any[]> => {
+    if (!activeSessionId) throw new Error('No active session');
+
+    try {
+      return await oxyServices.getDeviceSessions(activeSessionId);
+    } catch (error) {
+      console.error('Get device sessions error:', error);
+      throw error;
+    }
+  };
 
-  const signUp = useCallback(async (username: string, email: string, password: string): Promise<User> => {
-    await authManager.signUp(username, email, password);
+  const logoutAllDeviceSessions = async (): Promise<void> => {
+    if (!activeSessionId) throw new Error('No active session');
 
-    // Save session ID to storage after auto-login
-    const sessionId = authManager.getActiveSessionId();
-    if (sessionId && storage) {
-      await storage.setItem(`${storageKeyPrefix}_active_session_id`, sessionId);
+    try {
+      await oxyServices.logoutAllDeviceSessions(activeSessionId);
+
+      // Clear all local sessions since we logged out from all devices
+      setSessions([]);
+      setActiveSessionId(null);
+      setUser(null);
+      setMinimalUser(null);
+      await clearAllStorage();
+
+      if (onAuthStateChange) {
+        onAuthStateChange(null);
+      }
+    } catch (error) {
+      console.error('Logout all device sessions error:', error);
+      throw error;
     }
+  };
+
+  const updateDeviceName = async (deviceName: string): Promise<void> => {
+    if (!activeSessionId) throw new Error('No active session');
 
-    return authManager.getCurrentUser();
-  }, [authManager, storage, storageKeyPrefix]);
+    try {
+      await oxyServices.updateDeviceName(activeSessionId, deviceName);
 
-  // Bottom sheet controls
+      // Update local device info
+      await DeviceManager.updateDeviceName(deviceName);
+    } catch (error) {
+      console.error('Update device name error:', error);
+      throw error;
+    }
+  };
+
+  // Bottom sheet control methods
   const showBottomSheet = useCallback((screenOrConfig?: string | { screen: string; props?: Record<string, any> }) => {
+    console.log('showBottomSheet called with:', screenOrConfig);
+
     if (bottomSheetRef?.current) {
+      console.log('bottomSheetRef is available');
+
+      // First, show the bottom sheet
       if (bottomSheetRef.current.expand) {
+        console.log('Expanding bottom sheet');
         bottomSheetRef.current.expand();
       } else if (bottomSheetRef.current.present) {
+        console.log('Presenting bottom sheet');
         bottomSheetRef.current.present();
+      } else {
+        console.warn('No expand or present method available on bottomSheetRef');
       }
 
+      // Then navigate to the specified screen if provided
       if (screenOrConfig) {
+        // Add a small delay to ensure the bottom sheet is opened first
         setTimeout(() => {
           if (typeof screenOrConfig === 'string') {
+            // Simple screen name
+            console.log('Navigating to screen:', screenOrConfig);
             bottomSheetRef.current?._navigateToScreen?.(screenOrConfig);
           } else {
+            // Screen with props
+            console.log('Navigating to screen with props:', screenOrConfig.screen, screenOrConfig.props);
             bottomSheetRef.current?._navigateToScreen?.(screenOrConfig.screen, screenOrConfig.props);
           }
         }, 100);
       }
+    } else {
+      console.warn('bottomSheetRef is not available');
     }
   }, [bottomSheetRef]);
 
@@ -246,22 +643,47 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
     }
   }, [bottomSheetRef]);
 
+  // API URL configuration
+  const setApiUrl = useCallback((url: string) => {
+    try {
+      oxyServices.setBaseURL(url);
+    } catch (error) {
+      console.error('Failed to update API URL:', error);
+      setError(`Failed to update API URL: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }, [oxyServices]);
+
+  // Compute comprehensive authentication status
+  // This is the single source of truth for authentication across the entire app
+  const isAuthenticated = useMemo(() => {
+    // User is authenticated if:
+    // 1. We have a full user object loaded, OR
+    // 2. We have an active session (token will be fetched on-demand)
+    // This covers both the loaded state and the loading-but-authenticated state
+    return !!user || !!activeSessionId;
+  }, [user, activeSessionId]);
+
+  // Context value
   const contextValue: OxyContextState = {
-    isAuthenticated: authState.isAuthenticated,
-    user: authState.user,
-    isLoading: authState.isLoading,
-    error: authState.error,
-    sessions: authState.sessions,
-    activeSessionId: authState.activeSessionId,
+    user,
+    minimalUser,
+    sessions,
+    activeSessionId,
+    isAuthenticated,
+    isLoading,
+    error,
     login,
     logout,
+    logoutAll,
     signUp,
-    refreshSessions,
     switchSession,
     removeSession,
-    logoutAll,
+    refreshSessions,
+    getDeviceSessions,
+    logoutAllDeviceSessions,
+    updateDeviceName,
     oxyServices,
-    authManager,
+    setApiUrl,
     bottomSheetRef,
     showBottomSheet,
     hideBottomSheet,
@@ -274,6 +696,7 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
   );
 };
 
+// Hook to use the context
 export const useOxy = (): OxyContextState => {
   const context = useContext(OxyContext);
   if (!context) {