@oxyhq/services 5.2.2 → 5.2.4

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

@@ -1,8 +1,6 @@
 "use strict";
 
-import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
-
-// Define authenticated user with tokens
+import React, { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';
 
 // Define the context shape
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -30,7 +28,6 @@ class WebStorage {
 }
 
 // React Native AsyncStorage implementation
-// This will be dynamically imported only in React Native environment
 let AsyncStorage;
 
 // Determine the platform and set up storage
@@ -41,7 +38,6 @@ const isReactNative = () => {
 // Get appropriate storage for the platform
 const getStorage = async () => {
   if (isReactNative()) {
-    // Dynamically import AsyncStorage only in React Native environment
     if (!AsyncStorage) {
       try {
         const asyncStorageModule = await import('@react-native-async-storage/async-storage');
@@ -53,38 +49,33 @@ const getStorage = async () => {
     }
     return AsyncStorage;
   }
-
-  // Default to web storage
   return new WebStorage();
 };
 
-// Storage keys
-const getStorageKeys = (prefix = 'oxy') => ({
-  users: `${prefix}_users`,
-  // Array of authenticated users with tokens
-  activeUserId: `${prefix}_active_user_id`,
-  // ID of currently active user
-  // Legacy keys for migration
-  accessToken: `${prefix}_access_token`,
-  refreshToken: `${prefix}_refresh_token`,
-  user: `${prefix}_user`
+// 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 = ({
   children,
   oxyServices,
-  storageKeyPrefix = 'oxy',
+  storageKeyPrefix = 'oxy_secure',
   onAuthStateChange,
   bottomSheetRef
 }) => {
   // Authentication state
   const [user, setUser] = useState(null);
-  const [users, setUsers] = useState([]);
+  const [minimalUser, setMinimalUser] = useState(null);
+  const [sessions, setSessions] = useState([]);
+  const [activeSessionId, setActiveSessionId] = useState(null);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState(null);
   const [storage, setStorage] = useState(null);
 
-  // Storage keys
-  const keys = getStorageKeys(storageKeyPrefix);
+  // Storage keys (memoized to prevent infinite loops)
+  const keys = useMemo(() => getSecureStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
 
   // Initialize storage
   useEffect(() => {
@@ -106,69 +97,54 @@ export const OxyContextProvider = ({
       if (!storage) return;
       setIsLoading(true);
       try {
-        // Check for multi-user data first
-        const usersData = await storage.getItem(keys.users);
-        const activeUserId = await storage.getItem(keys.activeUserId);
-        console.log('InitAuth - usersData:', usersData);
-        console.log('InitAuth - activeUserId:', activeUserId);
-        if (usersData) {
-          // Multi-user setup exists
-          const parsedUsers = JSON.parse(usersData);
-          console.log('InitAuth - parsedUsers:', parsedUsers);
-          setUsers(parsedUsers);
-          if (activeUserId && parsedUsers.length > 0) {
-            const activeUser = parsedUsers.find(u => u.id === activeUserId);
-            console.log('InitAuth - activeUser found:', activeUser);
-            if (activeUser) {
-              setUser(activeUser);
-              oxyServices.setTokens(activeUser.accessToken, activeUser.refreshToken || activeUser.accessToken);
-
-              // Validate the tokens
-              const isValid = await oxyServices.validate();
-              console.log('InitAuth - token validation result:', isValid);
-              if (!isValid) {
-                // Remove invalid user during initialization
-                console.log('InitAuth - removing invalid user due to failed validation');
-                const filteredUsers = parsedUsers.filter(u => u.id !== activeUser.id);
-                setUsers(filteredUsers);
-                await saveUsersToStorage(filteredUsers);
-
-                // If there are other users, switch to the first one
-                if (filteredUsers.length > 0) {
-                  const newActiveUser = filteredUsers[0];
-                  setUser(newActiveUser);
-                  await saveActiveUserId(newActiveUser.id);
-                  oxyServices.setTokens(newActiveUser.accessToken, newActiveUser.refreshToken || newActiveUser.accessToken);
+        // 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 = JSON.parse(sessionsData);
+          setSessions(parsedSessions);
+          if (storedActiveSessionId && parsedSessions.length > 0) {
+            const activeSession = parsedSessions.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(newActiveUser);
+                    onAuthStateChange(fullUser);
                   }
                 } else {
-                  // No valid users left
-                  setUser(null);
-                  await storage.removeItem(keys.activeUserId);
-                  oxyServices.clearTokens();
-                  if (onAuthStateChange) {
-                    onAuthStateChange(null);
-                  }
-                }
-              } else {
-                console.log('InitAuth - user validated successfully, setting auth state');
-                // Notify about auth state change
-                if (onAuthStateChange) {
-                  onAuthStateChange(activeUser);
+                  console.log('SecureAuth - session invalid, removing');
+                  await removeInvalidSession(activeSession.sessionId);
                 }
+              } catch (error) {
+                console.error('SecureAuth - session validation error:', error);
+                await removeInvalidSession(activeSession.sessionId);
               }
             }
           }
-        } else {
-          console.log('InitAuth - no users data, checking legacy auth');
-          // Check for legacy single-user data and migrate
-          await migrateLegacyAuth();
         }
       } catch (err) {
-        console.error('Auth initialization error:', err);
+        console.error('Secure auth initialization error:', err);
         await clearAllStorage();
-        oxyServices.clearTokens();
       } finally {
         setIsLoading(false);
       }
@@ -176,451 +152,238 @@ export const OxyContextProvider = ({
     if (storage) {
       initAuth();
     }
-  }, [storage, oxyServices, keys.users, keys.activeUserId, onAuthStateChange]);
-
-  // Migrate legacy single-user authentication to multi-user
-  const migrateLegacyAuth = async () => {
-    if (!storage) return;
-    try {
-      const accessToken = await storage.getItem(keys.accessToken);
-      const refreshToken = await storage.getItem(keys.refreshToken);
-      const storedUser = await storage.getItem(keys.user);
-      if (accessToken && storedUser) {
-        // Set tokens in OxyServices
-        oxyServices.setTokens(accessToken, refreshToken || accessToken);
-
-        // Validate the tokens
-        const isValid = await oxyServices.validate();
-        if (isValid) {
-          const parsedUser = JSON.parse(storedUser);
-          const authenticatedUser = {
-            ...parsedUser,
-            accessToken,
-            refreshToken: refreshToken || undefined
-          };
-
-          // Store in new multi-user format
-          await storage.setItem(keys.users, JSON.stringify([authenticatedUser]));
-          await storage.setItem(keys.activeUserId, authenticatedUser.id);
-
-          // Set state
-          setUsers([authenticatedUser]);
-          setUser(authenticatedUser);
-
-          // Notify about auth state change
-          if (onAuthStateChange) {
-            onAuthStateChange(authenticatedUser);
-          }
-        }
-
-        // Clear legacy storage
-        await storage.removeItem(keys.accessToken);
-        await storage.removeItem(keys.refreshToken);
-        await storage.removeItem(keys.user);
+  }, [storage, oxyServices, keys, onAuthStateChange]);
+
+  // Remove invalid session
+  const removeInvalidSession = useCallback(async sessionId => {
+    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);
       }
-    } catch (err) {
-      console.error('Migration error:', err);
     }
-  };
+  }, [sessions, storage, keys, onAuthStateChange]);
 
-  // Helper to clear legacy storage
-  const clearStorage = async () => {
+  // Save sessions to storage
+  const saveSessionsToStorage = useCallback(async sessionsList => {
     if (!storage) return;
-    try {
-      await storage.removeItem(keys.accessToken);
-      await storage.removeItem(keys.refreshToken);
-      await storage.removeItem(keys.user);
-    } catch (err) {
-      console.error('Clear storage error:', err);
-    }
-  };
+    await storage.setItem(keys.sessions, JSON.stringify(sessionsList));
+  }, [storage, keys.sessions]);
+
+  // Save active session ID to storage
+  const saveActiveSessionId = useCallback(async sessionId => {
+    if (!storage) return;
+    await storage.setItem(keys.activeSessionId, sessionId);
+  }, [storage, keys.activeSessionId]);
 
-  // Helper to clear all storage (multi-user)
-  const clearAllStorage = async () => {
+  // Clear all storage
+  const clearAllStorage = useCallback(async () => {
     if (!storage) return;
     try {
-      await storage.removeItem(keys.users);
-      await storage.removeItem(keys.activeUserId);
-      // Also clear legacy keys
-      await clearStorage();
+      await storage.removeItem(keys.sessions);
+      await storage.removeItem(keys.activeSessionId);
     } catch (err) {
-      console.error('Clear all storage error:', err);
+      console.error('Clear secure storage error:', err);
     }
-  };
-
-  // Save users to storage
-  const saveUsersToStorage = async usersList => {
-    if (!storage) return;
-    await storage.setItem(keys.users, JSON.stringify(usersList));
-  };
+  }, [storage, keys]);
 
-  // Save active user ID to storage
-  const saveActiveUserId = async userId => {
-    if (!storage) return;
-    await storage.setItem(keys.activeUserId, userId);
-  };
+  // Switch to a different session
+  const switchToSession = useCallback(async sessionId => {
+    try {
+      setIsLoading(true);
 
-  // Utility function to handle different token response formats
-  const storeTokens = async response => {
-    // Store token and user data
-    if (response.accessToken) {
-      await storage?.setItem(keys.accessToken, response.accessToken);
-      if (response.refreshToken) {
-        await storage?.setItem(keys.refreshToken, response.refreshToken);
+      // 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);
       }
-    } else if (response.token) {
-      // Handle legacy API response
-      await storage?.setItem(keys.accessToken, response.token);
+    } catch (error) {
+      console.error('Switch session error:', error);
+      setError('Failed to switch session');
+    } finally {
+      setIsLoading(false);
     }
-    await storage?.setItem(keys.user, JSON.stringify(response.user));
-  };
+  }, [oxyServices, onAuthStateChange, saveActiveSessionId]);
 
-  // Login method (updated for multi-user)
-  const login = async (username, password) => {
+  // Secure login method
+  const login = async (username, password, deviceName) => {
     if (!storage) throw new Error('Storage not initialized');
     setIsLoading(true);
     setError(null);
     try {
-      const response = await oxyServices.login(username, password);
-      const accessToken = response.accessToken || response.token;
-      if (!accessToken) {
-        throw new Error('No access token received from login');
-      }
-      const newUser = {
-        ...response.user,
-        accessToken,
-        refreshToken: response.refreshToken
-        // sessionId will be set by backend, but we don't get it in response yet
+      const response = await oxyServices.secureLogin(username, password, deviceName);
+
+      // Create client session object
+      const clientSession = {
+        sessionId: response.sessionId,
+        deviceId: response.deviceId,
+        expiresAt: response.expiresAt,
+        lastActive: new Date().toISOString()
       };
 
-      // Check if user already exists
-      const existingUserIndex = users.findIndex(u => u.id === newUser.id);
-      let updatedUsers;
-      if (existingUserIndex >= 0) {
-        // Update existing user
-        updatedUsers = [...users];
-        updatedUsers[existingUserIndex] = newUser;
-      } else {
-        // Add new user
-        updatedUsers = [...users, newUser];
-      }
+      // Add to sessions list
+      const updatedSessions = [...sessions, clientSession];
+      setSessions(updatedSessions);
+      await saveSessionsToStorage(updatedSessions);
 
-      // Update state
-      setUsers(updatedUsers);
-      setUser(newUser);
+      // Set as active session
+      setActiveSessionId(response.sessionId);
+      await saveActiveSessionId(response.sessionId);
 
-      // Save to storage
-      await saveUsersToStorage(updatedUsers);
-      await saveActiveUserId(newUser.id);
+      // Get access token for API calls
+      await oxyServices.getTokenBySession(response.sessionId);
 
-      // Notify about auth state change
+      // Load full user data
+      const fullUser = await oxyServices.getUserBySession(response.sessionId);
+      setUser(fullUser);
+      setMinimalUser(response.user);
       if (onAuthStateChange) {
-        onAuthStateChange(newUser);
+        onAuthStateChange(fullUser);
       }
-      return newUser;
-    } catch (err) {
-      setError(err.message || 'Login failed');
-      throw err;
+      return fullUser;
+    } catch (error) {
+      setError(error.message || 'Login failed');
+      throw error;
     } finally {
       setIsLoading(false);
     }
   };
 
-  // Logout method (supports multi-user)
-  const logout = async userId => {
-    if (!storage) throw new Error('Storage not initialized');
-    setIsLoading(true);
-    setError(null);
+  // Logout method
+  const logout = async targetSessionId => {
+    if (!activeSessionId) return;
     try {
-      const targetUserId = userId || user?.id;
-      if (!targetUserId) return;
-      const targetUser = users.find(u => u.id === targetUserId);
-      if (targetUser) {
-        // Set the target user's tokens to logout
-        oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
-        try {
-          await oxyServices.logout();
-        } catch (logoutError) {
-          console.warn('Logout API call failed:', logoutError);
-        }
-
-        // Remove user from list
-        const updatedUsers = users.filter(u => u.id !== targetUserId);
-        setUsers(updatedUsers);
-
-        // If logging out current user, switch to another user or clear
-        if (targetUserId === user?.id) {
-          if (updatedUsers.length > 0) {
-            // Switch to first available user
-            const nextUser = updatedUsers[0];
-            setUser(nextUser);
-            oxyServices.setTokens(nextUser.accessToken, nextUser.refreshToken || nextUser.accessToken);
-            await saveActiveUserId(nextUser.id);
-            if (onAuthStateChange) {
-              onAuthStateChange(nextUser);
-            }
-          } else {
-            // No users left
-            setUser(null);
-            oxyServices.clearTokens();
-            await storage.removeItem(keys.activeUserId);
-            if (onAuthStateChange) {
-              onAuthStateChange(null);
-            }
+      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);
           }
         }
-
-        // Save updated users list
-        await saveUsersToStorage(updatedUsers);
       }
-    } catch (err) {
-      setError(err.message || 'Logout failed');
-      throw err;
-    } finally {
-      setIsLoading(false);
+    } catch (error) {
+      console.error('Logout error:', error);
+      setError('Logout failed');
     }
   };
 
-  // Logout all users
+  // Logout all sessions
   const logoutAll = async () => {
-    if (!storage) throw new Error('Storage not initialized');
-    setIsLoading(true);
-    setError(null);
+    if (!activeSessionId) return;
     try {
-      // Logout each user
-      for (const userItem of users) {
-        try {
-          oxyServices.setTokens(userItem.accessToken, userItem.refreshToken || userItem.accessToken);
-          await oxyServices.logout();
-        } catch (logoutError) {
-          console.warn(`Logout failed for user ${userItem.id}:`, logoutError);
-        }
-      }
+      await oxyServices.logoutAllSecureSessions(activeSessionId);
 
-      // Clear all state and storage
-      setUsers([]);
+      // Clear all local data
+      setSessions([]);
+      setActiveSessionId(null);
       setUser(null);
-      oxyServices.clearTokens();
+      setMinimalUser(null);
       await clearAllStorage();
-
-      // Notify about auth state change
       if (onAuthStateChange) {
         onAuthStateChange(null);
       }
-    } catch (err) {
-      setError(err.message || 'Logout all failed');
-      throw err;
-    } finally {
-      setIsLoading(false);
-    }
-  };
-
-  // Switch user
-  const switchUser = async userId => {
-    if (!storage) throw new Error('Storage not initialized');
-    setError(null);
-    try {
-      const targetUser = users.find(u => u.id === userId);
-      if (!targetUser) {
-        throw new Error('User not found');
-      }
-
-      // Validate tokens before switching
-      oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
-      const isValid = await oxyServices.validate();
-      if (!isValid) {
-        // Remove invalid user
-        await removeUser(userId);
-        throw new Error('User session is invalid');
-      }
-
-      // Switch to the user
-      setUser(targetUser);
-      await saveActiveUserId(userId);
-
-      // Notify about auth state change
-      if (onAuthStateChange) {
-        onAuthStateChange(targetUser);
-      }
-    } catch (err) {
-      setError(err.message || 'Switch user failed');
-      throw err;
+    } catch (error) {
+      console.error('Logout all error:', error);
+      setError('Logout all failed');
     }
   };
 
-  // Remove user
-  const removeUser = async userId => {
-    if (!storage) throw new Error('Storage not initialized');
-    try {
-      const updatedUsers = users.filter(u => u.id !== userId);
-      setUsers(updatedUsers);
-
-      // If removing current user, switch to another or clear
-      if (userId === user?.id) {
-        if (updatedUsers.length > 0) {
-          await switchUser(updatedUsers[0].id);
-        } else {
-          setUser(null);
-          oxyServices.clearTokens();
-          await storage.removeItem(keys.activeUserId);
-          if (onAuthStateChange) {
-            onAuthStateChange(null);
-          }
-        }
-      }
-
-      // Save updated users list
-      await saveUsersToStorage(updatedUsers);
-    } catch (err) {
-      setError(err.message || 'Remove user failed');
-      throw err;
-    }
+  // Sign up method (placeholder - you can implement based on your needs)
+  const signUp = async (username, email, password) => {
+    // Implement sign up logic similar to secureLogin
+    throw new Error('Sign up not implemented yet');
   };
 
-  // Get user sessions
-  const getUserSessions = async userId => {
-    try {
-      const targetUserId = userId || user?.id;
-      if (!targetUserId) return [];
-      const targetUser = users.find(u => u.id === targetUserId);
-      if (!targetUser) return [];
-
-      // Store current tokens to restore later
-      const currentUser = user;
-      const wasCurrentUser = targetUserId === user?.id;
-      if (!wasCurrentUser) {
-        // Temporarily switch to target user's tokens
-        oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
-      }
-      try {
-        // Use the new OxyServices method
-        const sessions = await oxyServices.getUserSessions();
-        return sessions;
-      } finally {
-        if (!wasCurrentUser && currentUser) {
-          // Restore original tokens
-          oxyServices.setTokens(currentUser.accessToken, currentUser.refreshToken || currentUser.accessToken);
-        }
-      }
-    } catch (err) {
-      console.error('Get user sessions failed:', err);
-      return [];
-    }
+  // Switch session method
+  const switchSession = async sessionId => {
+    await switchToSession(sessionId);
   };
 
-  // Logout specific session
-  const logoutSession = async (sessionId, userId) => {
-    try {
-      const targetUserId = userId || user?.id;
-      if (!targetUserId) return;
-      const targetUser = users.find(u => u.id === targetUserId);
-      if (!targetUser) return;
-
-      // Store current tokens to restore later
-      const currentUser = user;
-      const wasCurrentUser = targetUserId === user?.id;
-      if (!wasCurrentUser) {
-        // Temporarily switch to target user's tokens
-        oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
-      }
-      try {
-        // Use the new OxyServices method
-        await oxyServices.logoutSession(sessionId);
-
-        // If this is the current user's session, remove them from local state
-        if (wasCurrentUser && sessionId === targetUser.sessionId) {
-          await removeUser(targetUserId);
-        }
-      } finally {
-        if (!wasCurrentUser && currentUser) {
-          // Restore original tokens
-          oxyServices.setTokens(currentUser.accessToken, currentUser.refreshToken || currentUser.accessToken);
-        }
-      }
-    } catch (err) {
-      console.error('Logout session failed:', err);
-      throw err;
-    }
+  // Remove session method
+  const removeSession = async sessionId => {
+    await logout(sessionId);
   };
 
-  // Sign up method
-  const signUp = async (username, email, password) => {
-    if (!storage) throw new Error('Storage not initialized');
-    setIsLoading(true);
-    setError(null);
+  // Refresh sessions method
+  const refreshSessions = async () => {
+    if (!activeSessionId) return;
     try {
-      const response = await oxyServices.signUp(username, email, password);
-      setUser(response.user);
-
-      // Store tokens
-      await storeTokens(response);
-
-      // Notify about auth state change
-      if (onAuthStateChange) {
-        onAuthStateChange(response.user);
-      }
-      return response.user;
-    } catch (err) {
-      setError(err.message || 'Sign up failed');
-      throw err;
-    } finally {
-      setIsLoading(false);
+      const serverSessions = await oxyServices.getSessionsBySessionId(activeSessionId);
+
+      // Update local sessions with server data
+      const updatedSessions = 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);
     }
   };
 
-  // Methods to control the bottom sheet
-  const showBottomSheet = useCallback(screenOrConfig => {
-    if (bottomSheetRef?.current) {
-      // Expand the bottom sheet
-      bottomSheetRef.current.expand();
-      if (typeof screenOrConfig === 'string') {
-        // If a screen is specified, navigate to it
-        if (screenOrConfig && bottomSheetRef.current._navigateToScreen) {
-          setTimeout(() => {
-            bottomSheetRef.current._navigateToScreen(screenOrConfig);
-          }, 100);
-        }
-      } else if (screenOrConfig && typeof screenOrConfig === 'object' && screenOrConfig.screen) {
-        // If an object is passed, navigate and pass props
-        if (bottomSheetRef.current._navigateToScreen) {
-          setTimeout(() => {
-            bottomSheetRef.current._navigateToScreen(screenOrConfig.screen, screenOrConfig.props || {});
-          }, 100);
-        }
-      }
-    }
-  }, [bottomSheetRef]);
-  const hideBottomSheet = useCallback(() => {
-    if (bottomSheetRef?.current) {
-      bottomSheetRef.current.close();
-    }
-  }, [bottomSheetRef]);
-
-  // Build context value
+  // Context value
   const contextValue = {
-    // Single user state (current active user)
     user,
+    minimalUser,
+    sessions,
+    activeSessionId,
     isAuthenticated: !!user,
     isLoading,
     error,
-    // Multi-user state
-    users,
-    // Auth methods
     login,
     logout,
     logoutAll,
     signUp,
-    // Multi-user methods
-    switchUser,
-    removeUser,
-    getUserSessions,
-    logoutSession,
-    // OxyServices instance
+    switchSession,
+    removeSession,
+    refreshSessions,
     oxyServices,
-    // Bottom sheet methods
     bottomSheetRef,
-    showBottomSheet,
-    hideBottomSheet
+    showBottomSheet: undefined,
+    // Implement as needed
+    hideBottomSheet: undefined // Implement as needed
   };
   return /*#__PURE__*/_jsx(OxyContext.Provider, {
     value: contextValue,
@@ -636,4 +399,5 @@ export const useOxy = () => {
   }
   return context;
 };
+export default OxyContext;
 //# sourceMappingURL=OxyContext.js.map