@oxyhq/services 5.13.0 → 5.13.2

package/lib/module/ui/context/OxyContext.js

@@ -1,17 +1,38 @@
 "use strict";
 
 import { createContext, useContext, useEffect, useCallback, useMemo, useRef, useState } from 'react';
-import { View, Text } from 'react-native';
 import { OxyServices } from '../../core';
+import { normalizeAndSortSessions, mergeSessions, sessionsArraysEqual } from '../../utils/sessionUtils';
 import { DeviceManager } from '../../utils/deviceManager';
 import { useSessionSocket } from '../hooks/useSessionSocket';
 import { toast } from '../../lib/sonner';
 import { useAuthStore } from '../stores/authStore';
+import { getLanguageMetadata, getLanguageName, getNativeLanguageName, normalizeLanguageCode } from '../../utils/languageUtils';
 
 // Define the context shape
 // NOTE: We intentionally avoid importing useFollow here to prevent a require cycle.
 // If consumers relied on `const { useFollow } = useOxy()`, we provide a lazy proxy below.
 import { jsx as _jsx } from "react/jsx-runtime";
+// Empty follow hook fallback
+const createEmptyFollowHook = () => {
+  const emptyResult = {
+    isFollowing: false,
+    isLoading: false,
+    error: null,
+    toggleFollow: async () => {},
+    setFollowStatus: () => {},
+    fetchStatus: async () => {},
+    clearError: () => {},
+    followerCount: null,
+    followingCount: null,
+    isLoadingCounts: false,
+    fetchUserCounts: async () => {},
+    setFollowerCount: () => {},
+    setFollowingCount: () => {}
+  };
+  return () => emptyResult;
+};
+
 // Create the context with default values
 const OxyContext = /*#__PURE__*/createContext(null);
 
@@ -64,6 +85,8 @@ const getStorage = async () => {
 const getStorageKeys = (prefix = 'oxy_session') => ({
   activeSessionId: `${prefix}_active_session_id`,
   // Only store the active session ID
+  sessionIds: `${prefix}_session_ids`,
+  // Store all session IDs for quick account loading
   language: `${prefix}_language` // Store the selected language
 });
 export const OxyProvider = ({
@@ -103,43 +126,87 @@ export const OxyProvider = ({
   const [minimalUser, setMinimalUser] = useState(null);
   const [sessions, setSessions] = useState([]);
   const [activeSessionId, setActiveSessionId] = useState(null);
+
+  // Track in-flight refresh to prevent duplicate calls
+  const refreshInFlightRef = useRef(null);
   const [storage, setStorage] = useState(null);
   const [currentLanguage, setCurrentLanguage] = useState('en-US');
 
-  // Normalize language codes to BCP-47 (e.g., en-US)
-  const normalizeLanguageCode = useCallback(lang => {
-    if (!lang) return null;
-    if (lang.includes('-')) return lang;
-    const map = {
-      en: 'en-US',
-      es: 'es-ES',
-      ca: 'ca-ES',
-      fr: 'fr-FR',
-      de: 'de-DE',
-      it: 'it-IT',
-      pt: 'pt-PT',
-      ja: 'ja-JP',
-      ko: 'ko-KR',
-      zh: 'zh-CN',
-      ar: 'ar-SA'
-    };
-    return map[lang] || lang;
+  // Storage keys (memoized to prevent infinite loops) - declared early for use in helpers
+  const keys = useMemo(() => getStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
+
+  // Helper to apply language preference from user/server
+  const applyLanguagePreference = useCallback(async user => {
+    const userLanguage = user?.language;
+    if (!userLanguage || !storage) return;
+    try {
+      const serverLang = normalizeLanguageCode(userLanguage);
+      await storage.setItem(keys.language, serverLang);
+      setCurrentLanguage(serverLang);
+    } catch (e) {
+      if (__DEV__) {
+        console.warn('Failed to apply server language preference', e);
+      }
+    }
+  }, [storage, keys.language]);
+  const mapSessionsToClient = useCallback((sessions, fallbackDeviceId, fallbackUserId) => {
+    return sessions.map(s => ({
+      sessionId: s.sessionId,
+      deviceId: s.deviceId || fallbackDeviceId || '',
+      expiresAt: s.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+      lastActive: s.lastActive || new Date().toISOString(),
+      userId: s.user?.id || s.userId || s.user?._id?.toString() || fallbackUserId || '',
+      isCurrent: Boolean(s.isCurrent)
+    }));
   }, []);
-  // Add a new state to track token restoration
-  const [tokenReady, setTokenReady] = useState(false);
 
-  // Storage keys (memoized to prevent infinite loops)
-  const keys = useMemo(() => getStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
+  // Save all session IDs to storage for quick loading on initialization
+  const saveSessionIds = useCallback(async sessionIds => {
+    if (!storage) return;
+    try {
+      const uniqueIds = Array.from(new Set(sessionIds));
+      await storage.setItem(keys.sessionIds, JSON.stringify(uniqueIds));
+    } catch (err) {
+      if (__DEV__) {
+        console.warn('Failed to save session IDs:', err);
+      }
+    }
+  }, [storage, keys.sessionIds]);
+  const updateSessions = useCallback((newSessions, mergeWithExisting = false) => {
+    setSessions(prevSessions => {
+      const sessionsToProcess = mergeWithExisting ? mergeSessions(prevSessions, newSessions, activeSessionId, false) : normalizeAndSortSessions(newSessions, activeSessionId, false);
+
+      // Save all session IDs to storage
+      if (storage) {
+        const allSessionIds = sessionsToProcess.map(s => s.sessionId);
+        saveSessionIds(allSessionIds).catch(() => {
+          // Ignore errors - non-critical
+        });
+      }
+      return sessionsArraysEqual(prevSessions, sessionsToProcess) ? prevSessions : sessionsToProcess;
+    });
+  }, [activeSessionId, storage, saveSessionIds]);
 
-  // Clear all storage - defined before initAuth to avoid dependency issues
+  // Token ready state - start optimistically so children render immediately
+  const [tokenReady, setTokenReady] = useState(true);
+
+  // Clear all storage
   const clearAllStorage = useCallback(async () => {
     if (!storage) return;
     try {
       await storage.removeItem(keys.activeSessionId);
+      await storage.removeItem(keys.sessionIds);
     } catch (err) {
-      console.error('Clear storage error:', err);
+      if (__DEV__) {
+        console.error('Clear storage error:', err);
+      }
+      onError?.({
+        message: 'Failed to clear storage',
+        code: 'STORAGE_ERROR',
+        status: 500
+      });
     }
-  }, [storage, keys]);
+  }, [storage, keys, onError]);
 
   // Initialize storage
   useEffect(() => {
@@ -148,25 +215,28 @@ export const OxyProvider = ({
         const platformStorage = await getStorage();
         setStorage(platformStorage);
       } catch (error) {
-        console.error('Init storage failed', error);
+        const errorMessage = error instanceof Error ? error.message : 'Failed to initialize storage';
         useAuthStore.setState({
-          error: 'Failed to initialize storage'
+          error: errorMessage
+        });
+        onError?.({
+          message: errorMessage,
+          code: 'STORAGE_INIT_ERROR',
+          status: 500
         });
       }
     };
     initStorage();
-  }, []);
+  }, [onError]);
 
   // Initialize authentication state
+  // Note: We don't set isLoading during initialization to avoid showing spinners
+  // Children render immediately and can check isTokenReady/isAuthenticated themselves
   useEffect(() => {
     const initAuth = async () => {
       if (!storage) return;
-      useAuthStore.setState({
-        isLoading: true
-      });
+      // Don't set isLoading during initialization - let it happen in background
       try {
-        setTokenReady(false);
-
         // Load saved language preference
         const savedLanguageRaw = await storage.getItem(keys.language);
         const savedLanguage = normalizeLanguageCode(savedLanguageRaw) || savedLanguageRaw;
@@ -174,8 +244,51 @@ export const OxyProvider = ({
           setCurrentLanguage(savedLanguage);
         }
 
+        // Load all stored session IDs and validate them
+        const storedSessionIdsJson = await storage.getItem(keys.sessionIds);
+        const storedSessionIds = storedSessionIdsJson ? JSON.parse(storedSessionIdsJson) : [];
+
         // Try to restore active session from storage
         const storedActiveSessionId = await storage.getItem(keys.activeSessionId);
+        const validSessions = [];
+
+        // If we have stored session IDs, validate them (even without active session)
+        if (storedSessionIds.length > 0) {
+          if (__DEV__) {
+            console.log('Loading stored sessions on init:', storedSessionIds.length);
+          }
+
+          // Validate each stored session ID and build session list
+          for (const sessionId of storedSessionIds) {
+            try {
+              const validation = await oxyServices.validateSession(sessionId, {
+                useHeaderValidation: true
+              });
+              if (validation.valid && validation.user) {
+                validSessions.push({
+                  sessionId,
+                  userId: validation.user.id?.toString() || '',
+                  deviceId: '',
+                  expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                  lastActive: new Date().toISOString(),
+                  isCurrent: sessionId === storedActiveSessionId
+                });
+              }
+            } catch (e) {
+              // Session invalid, skip it
+              if (__DEV__) {
+                console.warn('Session validation failed for:', sessionId, e);
+              }
+            }
+          }
+
+          // Update sessions list with validated sessions (even if no active session)
+          if (validSessions.length > 0) {
+            updateSessions(validSessions, false);
+          }
+        }
+
+        // If we have an active session, authenticate with it
         if (storedActiveSessionId) {
           try {
             const validation = await oxyServices.validateSession(storedActiveSessionId, {
@@ -191,86 +304,66 @@ export const OxyProvider = ({
                 username: fullUser.username,
                 avatar: fullUser.avatar
               });
-              // Apply server language if present
-              if (fullUser?.language) {
-                try {
-                  const serverLang = normalizeLanguageCode(fullUser.language) || fullUser.language;
-                  await storage.setItem(keys.language, serverLang);
-                  setCurrentLanguage(serverLang);
-                } catch (e) {
-                  console.warn('Failed to apply server language preference', e);
+              await applyLanguagePreference(fullUser);
+              try {
+                const deviceSessions = await oxyServices.getDeviceSessions(storedActiveSessionId);
+                const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, fullUser.id);
+                updateSessions(allDeviceSessions, true);
+              } catch (e) {
+                if (__DEV__) {
+                  console.warn('Failed to get device sessions on init, falling back to user sessions:', e);
                 }
+                const serverSessions = await oxyServices.getSessionsBySessionId(storedActiveSessionId);
+                updateSessions(mapSessionsToClient(serverSessions, undefined, fullUser.id), false);
               }
-              const serverSessions = await oxyServices.getSessionsBySessionId(storedActiveSessionId);
-              const clientSessions = serverSessions.map(s => ({
-                sessionId: s.sessionId,
-                deviceId: s.deviceId,
-                expiresAt: s.expiresAt || new Date().toISOString(),
-                lastActive: s.lastActive || new Date().toISOString(),
-                userId: s.userId || fullUser.id
-              }));
-              setSessions(clientSessions);
               onAuthStateChange?.(fullUser);
             } else {
-              await clearAllStorage();
+              // Active session invalid, remove it but keep other sessions
+              await storage.removeItem(keys.activeSessionId);
+              // Update session list to remove invalid active session
+              updateSessions(validSessions.filter(s => s.sessionId !== storedActiveSessionId), false);
             }
           } catch (e) {
-            console.error('Session validation error', e);
-            await clearAllStorage();
+            if (__DEV__) {
+              console.error('Active session validation error', e);
+            }
+            // Remove invalid active session but keep other sessions
+            await storage.removeItem(keys.activeSessionId);
+            updateSessions(validSessions.filter(s => s.sessionId !== storedActiveSessionId), false);
           }
         }
         setTokenReady(true);
       } catch (e) {
-        console.error('Auth init error', e);
+        if (__DEV__) {
+          console.error('Auth init error', e);
+        }
         await clearAllStorage();
-      } finally {
-        useAuthStore.setState({
-          isLoading: false
-        });
+        setTokenReady(true);
       }
     };
     initAuth();
-  }, [storage, oxyServices, keys, onAuthStateChange, loginSuccess, clearAllStorage]);
-
-  // Remove invalid session - refresh sessions from backend
-  const removeInvalidSession = useCallback(async sessionId => {
-    // Remove from local state
-    const filteredSessions = sessions.filter(s => s.sessionId !== sessionId);
-    setSessions(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);
-      logoutStore();
-      setMinimalUser(null);
-      await storage?.removeItem(keys.activeSessionId);
-      if (onAuthStateChange) {
-        onAuthStateChange(null);
-      }
-    }
-  }, [sessions, storage, keys, onAuthStateChange, logoutStore]);
+  }, [storage, oxyServices, keys, onAuthStateChange, loginSuccess, clearAllStorage, applyLanguagePreference, mapSessionsToClient, updateSessions]);
 
   // Save active session ID to storage (only session ID, no user data)
   const saveActiveSessionId = useCallback(async sessionId => {
     if (!storage) return;
     await storage.setItem(keys.activeSessionId, sessionId);
   }, [storage, keys.activeSessionId]);
-
-  // Switch to a different session
   const switchToSession = useCallback(async sessionId => {
     try {
-      useAuthStore.setState({
-        isLoading: true
+      const validation = await oxyServices.validateSession(sessionId, {
+        useHeaderValidation: true
       });
-
-      // Get access token for this session
+      if (!validation.valid) {
+        updateSessions(sessions.filter(s => s.sessionId !== sessionId), false);
+        throw new Error('Session is invalid or expired');
+      }
+      if (!validation.user) {
+        throw new Error('User data not available from session validation');
+      }
+      const fullUser = validation.user;
       await oxyServices.getTokenBySession(sessionId);
-
-      // Load full user data
-      const fullUser = await oxyServices.getUserBySession(sessionId);
+      setTokenReady(true);
       setActiveSessionId(sessionId);
       loginSuccess(fullUser);
       setMinimalUser({
@@ -279,32 +372,52 @@ export const OxyProvider = ({
         avatar: fullUser.avatar
       });
       await saveActiveSessionId(sessionId);
-      // Apply server language if present
-      if (fullUser?.language) {
-        try {
-          const serverLang = normalizeLanguageCode(fullUser.language) || fullUser.language;
-          await storage?.setItem(keys.language, serverLang);
-          setCurrentLanguage(serverLang);
-        } catch (e) {
-          console.warn('Failed to apply server language after switch', e);
+      await applyLanguagePreference(fullUser);
+      oxyServices.getDeviceSessions(sessionId).then(deviceSessions => {
+        const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, fullUser.id);
+        updateSessions(allDeviceSessions, true);
+      }).catch(error => {
+        if (__DEV__) console.warn('Failed to get device sessions after switch:', error);
+      });
+      onAuthStateChange?.(fullUser);
+    } catch (error) {
+      const isInvalidSession = error?.response?.status === 401 || error?.message?.includes('Invalid or expired session') || error?.message?.includes('Session is invalid');
+      if (isInvalidSession) {
+        updateSessions(sessions.filter(s => s.sessionId !== sessionId), false);
+        if (sessionId === activeSessionId && sessions.length > 1) {
+          const otherSessions = sessions.filter(s => s.sessionId !== sessionId);
+          for (const otherSession of otherSessions) {
+            try {
+              const otherValidation = await oxyServices.validateSession(otherSession.sessionId, {
+                useHeaderValidation: true
+              });
+              if (otherValidation.valid) {
+                await switchToSession(otherSession.sessionId);
+                return;
+              }
+            } catch {
+              // Continue to next session
+              continue;
+            }
+          }
         }
       }
-      if (onAuthStateChange) {
-        onAuthStateChange(fullUser);
+      const errorMessage = error instanceof Error ? error.message : 'Failed to switch session';
+      if (__DEV__) {
+        console.error('Switch session error:', error);
       }
-    } catch (error) {
-      console.error('Switch session error:', error);
       useAuthStore.setState({
-        error: 'Failed to switch session'
+        error: errorMessage
       });
-    } finally {
-      useAuthStore.setState({
-        isLoading: false
+      onError?.({
+        message: errorMessage,
+        code: isInvalidSession ? 'INVALID_SESSION' : 'SESSION_SWITCH_ERROR',
+        status: isInvalidSession ? 401 : 500
       });
+      setTokenReady(false);
+      throw error; // Re-throw so calling code can handle it
     }
-  }, [oxyServices, onAuthStateChange, loginSuccess, saveActiveSessionId]);
-
-  // Login method - only store session ID, retrieve data from backend
+  }, [oxyServices, onAuthStateChange, loginSuccess, saveActiveSessionId, applyLanguagePreference, mapSessionsToClient, onError, activeSessionId, sessions]);
   const login = useCallback(async (username, password, deviceName) => {
     if (!storage) throw new Error('Storage not initialized');
     useAuthStore.setState({
@@ -312,59 +425,71 @@ export const OxyProvider = ({
       error: 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('Auth - Using device fingerprint:', deviceFingerprint);
-      console.log('Auth - Using device ID:', deviceInfo.deviceId);
       const response = await oxyServices.signIn(username, password, deviceName || deviceInfo.deviceName || DeviceManager.getDefaultDeviceName(), deviceFingerprint);
 
       // Handle MFA requirement
-      if (response && response.mfaRequired) {
-        const err = new Error('Multi-factor authentication required');
-        err.code = 'MFA_REQUIRED';
-        err.mfaToken = response.mfaToken;
-        err.expiresAt = response.expiresAt;
-        throw err;
+      if (response && 'mfaRequired' in response && response.mfaRequired) {
+        const mfaError = new Error('Multi-factor authentication required');
+        mfaError.code = 'MFA_REQUIRED';
+        mfaError.mfaToken = response.mfaToken;
+        mfaError.expiresAt = response.expiresAt;
+        throw mfaError;
       }
-
-      // Set as active session (only store session ID)
-      setActiveSessionId(response.sessionId);
-      await saveActiveSessionId(response.sessionId);
-
-      // Get access token for API calls
-      await oxyServices.getTokenBySession(response.sessionId);
-
-      // Load full user data from backend
-      const fullUser = await oxyServices.getUserBySession(response.sessionId);
-      loginSuccess(fullUser);
-      setMinimalUser(response.user);
-
-      // Load sessions from backend
-      const serverSessions = await oxyServices.getSessionsBySessionId(response.sessionId);
-      const clientSessions = serverSessions.map(serverSession => ({
-        sessionId: serverSession.sessionId,
-        deviceId: serverSession.deviceId,
-        expiresAt: serverSession.expiresAt || new Date().toISOString(),
-        lastActive: serverSession.lastActive || new Date().toISOString(),
-        userId: serverSession.userId || fullUser.id
-      }));
-      setSessions(clientSessions);
-      if (onAuthStateChange) {
-        onAuthStateChange(fullUser);
+      const sessionResponse = response;
+      await oxyServices.getTokenBySession(sessionResponse.sessionId);
+      const fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
+      let allDeviceSessions = [];
+      try {
+        const deviceSessions = await oxyServices.getDeviceSessions(sessionResponse.sessionId);
+        allDeviceSessions = mapSessionsToClient(deviceSessions, sessionResponse.deviceId, fullUser.id);
+      } catch (error) {
+        if (__DEV__) {
+          console.warn('Failed to get device sessions, falling back to user sessions:', error);
+        }
+        const serverSessions = await oxyServices.getSessionsBySessionId(sessionResponse.sessionId);
+        allDeviceSessions = mapSessionsToClient(serverSessions, undefined, fullUser.id);
       }
+      const userUserId = fullUser.id?.toString();
+      const existingSession = allDeviceSessions.find(s => s.userId?.toString() === userUserId && s.sessionId !== sessionResponse.sessionId);
+      if (existingSession) {
+        try {
+          await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
+        } catch (logoutError) {
+          if (__DEV__) {
+            console.warn('Failed to logout duplicate session:', logoutError);
+          }
+        }
+        await switchToSession(existingSession.sessionId);
+        loginSuccess(fullUser);
+        setMinimalUser(sessionResponse.user);
+        updateSessions(allDeviceSessions.filter(s => s.sessionId !== sessionResponse.sessionId), false);
+        onAuthStateChange?.(fullUser);
+        return fullUser;
+      }
+      setActiveSessionId(sessionResponse.sessionId);
+      await saveActiveSessionId(sessionResponse.sessionId);
+      loginSuccess(fullUser);
+      setMinimalUser(sessionResponse.user);
+      updateSessions(allDeviceSessions, true);
+      onAuthStateChange?.(fullUser);
       return fullUser;
     } catch (error) {
-      loginFailure(error.message || 'Login failed');
+      const errorMessage = error instanceof Error ? error.message : 'Login failed';
+      loginFailure(errorMessage);
+      onError?.({
+        message: errorMessage,
+        code: 'LOGIN_ERROR',
+        status: 401
+      });
       throw error;
     } finally {
       useAuthStore.setState({
         isLoading: false
       });
     }
-  }, [storage, oxyServices, saveActiveSessionId, loginSuccess, setMinimalUser, onAuthStateChange, loginFailure]);
+  }, [storage, oxyServices, saveActiveSessionId, loginSuccess, onAuthStateChange, loginFailure, mapSessionsToClient, onError, sessions, switchToSession]);
 
   // Logout method
   const logout = useCallback(async targetSessionId => {
@@ -372,18 +497,12 @@ export const OxyProvider = ({
     try {
       const sessionToLogout = targetSessionId || activeSessionId;
       await oxyServices.logoutSession(activeSessionId, sessionToLogout);
-
-      // Remove session from local state
       const filteredSessions = sessions.filter(s => s.sessionId !== sessionToLogout);
-      setSessions(filteredSessions);
-
-      // If logging out active session
+      updateSessions(filteredSessions, false);
       if (sessionToLogout === activeSessionId) {
         if (filteredSessions.length > 0) {
-          // Switch to another session
           await switchToSession(filteredSessions[0].sessionId);
         } else {
-          // No sessions left
           setActiveSessionId(null);
           logoutStore();
           setMinimalUser(null);
@@ -394,74 +513,57 @@ export const OxyProvider = ({
         }
       }
     } catch (error) {
-      console.error('Logout error:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Logout failed';
+      if (__DEV__) {
+        console.error('Logout error:', error);
+      }
       useAuthStore.setState({
-        error: 'Logout failed'
+        error: errorMessage
+      });
+      onError?.({
+        message: errorMessage,
+        code: 'LOGOUT_ERROR',
+        status: 500
       });
     }
-  }, [activeSessionId, oxyServices, sessions, switchToSession, logoutStore, setMinimalUser, storage, keys.activeSessionId, onAuthStateChange]);
-
-  // Logout all sessions
+  }, [activeSessionId, oxyServices, sessions, switchToSession, logoutStore, storage, keys.activeSessionId, onAuthStateChange, onError]);
   const logoutAll = useCallback(async () => {
-    console.log('logoutAll called with activeSessionId:', activeSessionId);
     if (!activeSessionId) {
-      console.error('No active session ID found, cannot logout all');
+      const error = new Error('No active session found');
       useAuthStore.setState({
-        error: 'No active session found'
+        error: error.message
       });
-      throw new Error('No active session found');
-    }
-    if (!oxyServices) {
-      console.error('OxyServices not initialized');
-      useAuthStore.setState({
-        error: 'Service not available'
+      onError?.({
+        message: error.message,
+        code: 'NO_SESSION_ERROR',
+        status: 404
       });
-      throw new Error('Service not available');
+      throw error;
     }
     try {
-      console.log('Calling oxyServices.logoutAllSessions with sessionId:', activeSessionId);
       await oxyServices.logoutAllSessions(activeSessionId);
-      console.log('logoutAllSessions completed successfully');
-
-      // Clear all local data
-      setSessions([]);
+      updateSessions([], false);
       setActiveSessionId(null);
       logoutStore();
       setMinimalUser(null);
       await clearAllStorage();
-      console.log('Local storage cleared');
-      if (onAuthStateChange) {
-        onAuthStateChange(null);
-        console.log('Auth state change callback called');
-      }
+      onAuthStateChange?.(null);
     } catch (error) {
-      console.error('Logout all error:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Logout all failed';
       useAuthStore.setState({
-        error: `Logout all failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+        error: errorMessage
+      });
+      onError?.({
+        message: errorMessage,
+        code: 'LOGOUT_ALL_ERROR',
+        status: 500
       });
       throw error;
     }
-  }, [activeSessionId, oxyServices, logoutStore, setMinimalUser, clearAllStorage, onAuthStateChange]);
+  }, [activeSessionId, oxyServices, logoutStore, clearAllStorage, onAuthStateChange, onError]);
 
-  // Effect to restore token on app load or session switch
-  useEffect(() => {
-    const restoreToken = async () => {
-      if (activeSessionId && oxyServices) {
-        try {
-          await oxyServices.getTokenBySession(activeSessionId);
-          setTokenReady(true);
-        } catch (err) {
-          // If token restoration fails, force logout
-          await logout();
-          setTokenReady(false);
-        }
-      } else {
-        setTokenReady(true); // No session, so token is not needed
-      }
-    };
-    restoreToken();
-    // Only run when activeSessionId or oxyServices changes
-  }, [activeSessionId, oxyServices, logout]);
+  // Token restoration is handled in initAuth and switchToSession
+  // No separate effect needed - children render immediately with isTokenReady available
 
   // Sign up method
   const signUp = useCallback(async (username, email, password) => {
@@ -471,23 +573,24 @@ export const OxyProvider = ({
       error: 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 to create a session
-      // This will handle the session creation and device registration
+      await oxyServices.signUp(username, email, password);
       const user = await login(username, password);
       return user;
     } catch (error) {
-      loginFailure(error.message || 'Sign up failed');
+      const errorMessage = error instanceof Error ? error.message : 'Sign up failed';
+      loginFailure(errorMessage);
+      onError?.({
+        message: errorMessage,
+        code: 'SIGNUP_ERROR',
+        status: 400
+      });
       throw error;
     } finally {
       useAuthStore.setState({
         isLoading: false
       });
     }
-  }, [storage, oxyServices, login, loginFailure]);
+  }, [storage, oxyServices, login, loginFailure, onError]);
 
   // Complete MFA login by verifying TOTP
   const completeMfaLogin = useCallback(async (mfaToken, code) => {
@@ -512,116 +615,106 @@ export const OxyProvider = ({
         username: fullUser.username,
         avatar: fullUser.avatar
       });
-      // Apply server language if present
-      if (fullUser?.language) {
-        try {
-          const serverLang = normalizeLanguageCode(fullUser.language) || fullUser.language;
-          await storage.setItem(keys.language, serverLang);
-          setCurrentLanguage(serverLang);
-        } catch (e) {
-          console.warn('Failed to apply server language on MFA login', e);
-        }
-      }
+      await applyLanguagePreference(fullUser);
 
-      // Load sessions list
-      const serverSessions = await oxyServices.getSessionsBySessionId(response.sessionId);
-      const clientSessions = serverSessions.map(s => ({
-        sessionId: s.sessionId,
-        deviceId: s.deviceId,
-        expiresAt: s.expiresAt || new Date().toISOString(),
-        lastActive: s.lastActive || new Date().toISOString(),
-        userId: s.userId || fullUser.id
-      }));
-      setSessions(clientSessions);
-      // Apply server language if present
-      if (fullUser?.language) {
-        try {
-          await storage.setItem(keys.language, fullUser.language);
-          setCurrentLanguage(fullUser.language);
-        } catch (e) {
-          console.warn('Failed to apply server language on MFA login', e);
+      // Get all device sessions to support multiple accounts
+      try {
+        const deviceSessions = await oxyServices.getDeviceSessions(response.sessionId);
+        const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, fullUser.id);
+        updateSessions(allDeviceSessions, true);
+      } catch (error) {
+        // Fallback to user sessions if device sessions fail
+        if (__DEV__) {
+          console.warn('Failed to get device sessions for MFA, falling back to user sessions:', error);
         }
+        const serverSessions = await oxyServices.getSessionsBySessionId(response.sessionId);
+        const userSessions = mapSessionsToClient(serverSessions, undefined, fullUser.id);
+        updateSessions(userSessions, true);
       }
-      if (onAuthStateChange) onAuthStateChange(fullUser);
+      onAuthStateChange?.(fullUser);
       return fullUser;
     } catch (error) {
-      loginFailure(error.message || 'MFA verification failed');
+      const errorMessage = error instanceof Error ? error.message : 'MFA verification failed';
+      loginFailure(errorMessage);
+      onError?.({
+        message: errorMessage,
+        code: 'MFA_ERROR',
+        status: 401
+      });
       throw error;
     } finally {
       useAuthStore.setState({
         isLoading: false
       });
     }
-  }, [storage, oxyServices, loginSuccess, loginFailure, saveActiveSessionId, onAuthStateChange]);
-
-  // Switch session method
+  }, [storage, oxyServices, loginSuccess, loginFailure, saveActiveSessionId, onAuthStateChange, applyLanguagePreference, onError]);
   const switchSession = useCallback(async sessionId => {
     await switchToSession(sessionId);
   }, [switchToSession]);
-
-  // Remove session method
   const removeSession = useCallback(async sessionId => {
     await logout(sessionId);
   }, [logout]);
-
-  // Refresh sessions method
   const refreshSessions = useCallback(async () => {
-    console.log('refreshSessions called with activeSessionId:', activeSessionId);
-    if (!activeSessionId) {
-      console.log('refreshSessions: No activeSessionId, returning');
-      return;
+    if (!activeSessionId) return;
+
+    // If a refresh is already in progress, return the existing promise
+    if (refreshInFlightRef.current) {
+      return refreshInFlightRef.current;
     }
-    try {
-      console.log('refreshSessions: Calling getSessionsBySessionId...');
-      const serverSessions = await oxyServices.getSessionsBySessionId(activeSessionId);
-      console.log('refreshSessions: Server sessions received:', serverSessions);
-
-      // Update local sessions with server data
-      const updatedSessions = serverSessions.map(serverSession => ({
-        sessionId: serverSession.sessionId,
-        deviceId: serverSession.deviceId,
-        expiresAt: serverSession.expiresAt || new Date().toISOString(),
-        lastActive: serverSession.lastActive || new Date().toISOString(),
-        userId: serverSession.userId || user?.id
-      }));
-      console.log('refreshSessions: Updated sessions:', updatedSessions);
-      setSessions(updatedSessions);
-      console.log('refreshSessions: Sessions updated in state');
-    } catch (error) {
-      console.error('Refresh sessions error:', error);
 
-      // If the current session is invalid, try to find another valid session
-      if (sessions.length > 1) {
-        console.log('Current session invalid, trying to switch to another session...');
-        const otherSessions = sessions.filter(s => s.sessionId !== activeSessionId);
-        for (const session of otherSessions) {
-          try {
-            // Try to validate this session
-            await oxyServices.validateSession(session.sessionId, {
-              useHeaderValidation: true
-            });
-            console.log('Found valid session, switching to:', session.sessionId);
-            await switchToSession(session.sessionId);
-            return; // Successfully switched to another session
-          } catch (sessionError) {
-            console.log('Session validation failed for:', session.sessionId, sessionError);
-            continue; // Try next session
-          }
+    // Create the refresh promise
+    const refreshPromise = (async () => {
+      try {
+        const deviceSessions = await oxyServices.getDeviceSessions(activeSessionId);
+        const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, user?.id);
+        updateSessions(allDeviceSessions, true);
+      } catch (error) {
+        if (__DEV__) {
+          console.warn('Failed to refresh device sessions, falling back to user sessions:', error);
         }
-      }
+        try {
+          const serverSessions = await oxyServices.getSessionsBySessionId(activeSessionId);
+          const userSessions = mapSessionsToClient(serverSessions, undefined, user?.id);
+          updateSessions(userSessions, true);
+        } catch (fallbackError) {
+          if (__DEV__) {
+            console.error('Refresh sessions error:', fallbackError);
+          }
 
-      // If no valid sessions found, clear all sessions
-      console.log('No valid sessions found, clearing all sessions');
-      setSessions([]);
-      setActiveSessionId(null);
-      logoutStore();
-      setMinimalUser(null);
-      await clearAllStorage();
-      if (onAuthStateChange) {
-        onAuthStateChange(null);
+          // If the current session is invalid, try to find another valid session
+          if (sessions.length > 1) {
+            const otherSessions = sessions.filter(s => s.sessionId !== activeSessionId);
+            for (const session of otherSessions) {
+              try {
+                const validation = await oxyServices.validateSession(session.sessionId, {
+                  useHeaderValidation: true
+                });
+                if (validation.valid) {
+                  await switchToSession(session.sessionId);
+                  return;
+                }
+              } catch {
+                continue;
+              }
+            }
+          }
+
+          // No valid sessions found, clear all
+          updateSessions([], false);
+          setActiveSessionId(null);
+          logoutStore();
+          setMinimalUser(null);
+          await clearAllStorage();
+          onAuthStateChange?.(null);
+        }
+      } finally {
+        // Clear the in-flight ref when done
+        refreshInFlightRef.current = null;
       }
-    }
-  }, [activeSessionId, oxyServices, user?.id, sessions, switchToSession, logoutStore, setMinimalUser, clearAllStorage, onAuthStateChange]);
+    })();
+    refreshInFlightRef.current = refreshPromise;
+    return refreshPromise;
+  }, [activeSessionId, oxyServices, user?.id, updateSessions, sessions, switchToSession, logoutStore, clearAllStorage, onAuthStateChange, mapSessionsToClient]);
 
   // Device management methods
   const getDeviceSessions = useCallback(async () => {
@@ -629,58 +722,67 @@ export const OxyProvider = ({
     try {
       return await oxyServices.getDeviceSessions(activeSessionId);
     } catch (error) {
-      console.error('Get device sessions error:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Failed to get device sessions';
+      onError?.({
+        message: errorMessage,
+        code: 'GET_DEVICE_SESSIONS_ERROR',
+        status: 500
+      });
       throw error;
     }
-  }, [activeSessionId, oxyServices]);
+  }, [activeSessionId, oxyServices, onError]);
   const logoutAllDeviceSessions = useCallback(async () => {
     if (!activeSessionId) throw new Error('No active session');
     try {
       await oxyServices.logoutAllDeviceSessions(activeSessionId);
-
-      // Clear all local sessions since we logged out from all devices
-      setSessions([]);
+      updateSessions([], false);
       setActiveSessionId(null);
       logoutStore();
       setMinimalUser(null);
       await clearAllStorage();
-      if (onAuthStateChange) {
-        onAuthStateChange(null);
-      }
+      onAuthStateChange?.(null);
     } catch (error) {
-      console.error('Logout all device sessions error:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Failed to logout all device sessions';
+      onError?.({
+        message: errorMessage,
+        code: 'LOGOUT_ALL_DEVICES_ERROR',
+        status: 500
+      });
       throw error;
     }
-  }, [activeSessionId, oxyServices, logoutStore, setMinimalUser, clearAllStorage, onAuthStateChange]);
+  }, [activeSessionId, oxyServices, logoutStore, clearAllStorage, onAuthStateChange, onError]);
   const updateDeviceName = useCallback(async deviceName => {
     if (!activeSessionId) throw new Error('No active session');
     try {
       await oxyServices.updateDeviceName(activeSessionId, deviceName);
-
-      // Update local device info
       await DeviceManager.updateDeviceName(deviceName);
     } catch (error) {
-      console.error('Update device name error:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Failed to update device name';
+      onError?.({
+        message: errorMessage,
+        code: 'UPDATE_DEVICE_NAME_ERROR',
+        status: 500
+      });
       throw error;
     }
-  }, [activeSessionId, oxyServices]);
+  }, [activeSessionId, oxyServices, onError]);
 
   // Language management method
   const setLanguage = useCallback(async languageId => {
     if (!storage) throw new Error('Storage not initialized');
     try {
-      // Save language preference
       await storage.setItem(keys.language, languageId);
       setCurrentLanguage(languageId);
-      console.log(`Language changed to ${languageId}`);
-
-      // TODO: Here you can add any additional logic needed for app-wide language updates
-      // such as updating i18n configuration, refreshing translations, etc.
     } catch (error) {
-      console.error('Error saving language preference:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Failed to save language preference';
+      onError?.({
+        message: errorMessage,
+        code: 'LANGUAGE_SAVE_ERROR',
+        status: 500
+      });
       throw error;
     }
-  }, [storage, keys.language]);
+  }, [storage, keys.language, onError]);
 
   // Bottom sheet control methods
   const showBottomSheet = useCallback(screenOrConfig => {
@@ -695,9 +797,8 @@ export const OxyProvider = ({
       } else if (bottomSheetRef.current.present) {
         if (__DEV__) console.log('Presenting bottom sheet');
         bottomSheetRef.current.present();
-      } else {
+      } else if (__DEV__) {
         console.warn('No expand or present method available on bottomSheetRef');
-        if (__DEV__) console.log('Available methods on bottomSheetRef.current:', Object.keys(bottomSheetRef.current));
       }
 
       // Then navigate to the specified screen if provided
@@ -715,10 +816,8 @@ export const OxyProvider = ({
           }
         }, 100);
       }
-    } else {
-      console.warn('bottomSheetRef is not available');
-      console.warn('To fix this, ensure you pass a bottomSheetRef to OxyProvider:');
-      console.warn('<OxyProvider baseURL="..." bottomSheetRef={yourBottomSheetRef}>');
+    } else if (__DEV__) {
+      console.warn('bottomSheetRef is not available. Pass a bottomSheetRef to OxyProvider.');
     }
   }, [bottomSheetRef]);
   const hideBottomSheet = useCallback(() => {
@@ -751,41 +850,22 @@ export const OxyProvider = ({
       if (mod && typeof mod.useFollow === 'function') {
         return mod.useFollow(userId);
       }
-      console.warn('useFollow module did not export a function as expected');
-      return {
-        isFollowing: false,
-        isLoading: false,
-        error: null,
-        toggleFollow: async () => {},
-        setFollowStatus: () => {},
-        fetchStatus: async () => {},
-        clearError: () => {},
-        followerCount: null,
-        followingCount: null,
-        isLoadingCounts: false,
-        fetchUserCounts: async () => {},
-        setFollowerCount: () => {},
-        setFollowingCount: () => {}
-      };
+      if (__DEV__) {
+        console.warn('useFollow module did not export a function as expected');
+      }
+      return createEmptyFollowHook()(userId);
     } catch (e) {
-      console.warn('Failed to dynamically load useFollow hook:', e);
-      return {
-        isFollowing: false,
-        isLoading: false,
-        error: null,
-        toggleFollow: async () => {},
-        setFollowStatus: () => {},
-        fetchStatus: async () => {},
-        clearError: () => {},
-        followerCount: null,
-        followingCount: null,
-        isLoadingCounts: false,
-        fetchUserCounts: async () => {},
-        setFollowerCount: () => {},
-        setFollowingCount: () => {}
-      };
+      if (__DEV__) {
+        console.warn('Failed to dynamically load useFollow hook:', e);
+      }
+      return createEmptyFollowHook()(userId);
     }
   };
+
+  // Compute language metadata from currentLanguage
+  const languageMetadata = useMemo(() => getLanguageMetadata(currentLanguage), [currentLanguage]);
+  const languageName = useMemo(() => getLanguageName(currentLanguage), [currentLanguage]);
+  const nativeLanguageName = useMemo(() => getNativeLanguageName(currentLanguage), [currentLanguage]);
   const contextValue = useMemo(() => ({
     user,
     minimalUser,
@@ -793,8 +873,12 @@ export const OxyProvider = ({
     activeSessionId,
     isAuthenticated,
     isLoading,
+    isTokenReady: tokenReady,
     error,
     currentLanguage,
+    currentLanguageMetadata: languageMetadata,
+    currentLanguageName: languageName,
+    currentNativeLanguageName: nativeLanguageName,
     login,
     logout,
     logoutAll,
@@ -816,21 +900,9 @@ export const OxyProvider = ({
   // Only depend on user ID, not the entire user object
   minimalUser?.id, sessions.length,
   // Only depend on sessions count, not the entire array
-  activeSessionId, isAuthenticated, isLoading, error, currentLanguage, login, logout, logoutAll, signUp, completeMfaLogin, switchSession, removeSession, refreshSessions, setLanguage, getDeviceSessions, logoutAllDeviceSessions, updateDeviceName, oxyServices, bottomSheetRef, showBottomSheet, hideBottomSheet]);
-
-  // Wrap children rendering to block until token is ready
-  if (!tokenReady) {
-    return /*#__PURE__*/_jsx(View, {
-      style: {
-        flex: 1,
-        justifyContent: 'center',
-        alignItems: 'center'
-      },
-      children: /*#__PURE__*/_jsx(Text, {
-        children: "Loading authentication..."
-      })
-    });
-  }
+  activeSessionId, isAuthenticated, isLoading, tokenReady, error, currentLanguage, languageMetadata, languageName, nativeLanguageName, login, logout, logoutAll, signUp, completeMfaLogin, switchSession, removeSession, refreshSessions, setLanguage, getDeviceSessions, logoutAllDeviceSessions, updateDeviceName, oxyServices, bottomSheetRef, showBottomSheet, hideBottomSheet]);
+
+  // Always render children - let the consuming app decide how to handle token loading state
   return /*#__PURE__*/_jsx(OxyContext.Provider, {
     value: contextValue,
     children: children