@oxyhq/services 5.17.17 → 5.17.18

package/src/ui/screens/AccountSettingsScreen.tsx

@@ -22,6 +22,7 @@ import { MaterialCommunityIcons } from '@expo/vector-icons';
 import { toast } from '../../lib/sonner';
 import { fontFamilies } from '../styles/fonts';
 import { confirmAction } from '../utils/confirmAction';
+import { useAuthStore } from '../stores/authStore';
 import { Header, GroupedSection, Section } from '../components';
 import { useI18n } from '../hooks/useI18n';
 import { useThemeStyles } from '../hooks/useThemeStyles';
@@ -76,9 +77,13 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
     const normalizedTheme = normalizeTheme(theme);
 
     // Use TanStack Query for user data
-    const { data: finalUser, isLoading: userLoading } = useCurrentUser({ enabled: isAuthenticated });
+    const { data: user, isLoading: userLoading } = useCurrentUser({ enabled: isAuthenticated });
     const updateProfileMutation = useUpdateProfile();
     const uploadAvatarMutation = useUploadAvatar();
+
+    // Fallback to store for backward compatibility
+    const userFromStore = useAuthStore((state) => state.user);
+    const finalUser = user || userFromStore;
     const [isLoading, setIsLoading] = useState(false);
     const isSaving = updateProfileMutation.isPending;
     const isUpdatingAvatar = uploadAvatarMutation.isPending;
@@ -215,10 +220,9 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
             // Only reset all fields if it's a new user or first load
             // Skip reset if it's just an avatar update
             if (shouldInitialize && !isAvatarOnlyUpdate) {
-                // Prioritize name.full over name.first for display name
                 const userDisplayName = typeof finalUser.name === 'string'
                     ? finalUser.name
-                    : finalUser.name?.full || finalUser.name?.first || '';
+                    : finalUser.name?.first || finalUser.name?.full || '';
                 const userLastName = typeof finalUser.name === 'object' ? finalUser.name?.last || '' : '';
                 setDisplayName(userDisplayName);
                 setLastName(userLastName);
@@ -363,15 +367,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
         try {
             switch (field) {
                 case 'displayName':
-                    // Send both first/last AND full name for proper synchronization
-                    const fullName = [tempDisplayName, tempLastName].filter(Boolean).join(' ').trim() || tempDisplayName;
-                    await updateProfileMutation.mutateAsync({
-                        name: {
-                            first: tempDisplayName,
-                            last: tempLastName,
-                            full: fullName
-                        }
-                    });
+                    await updateProfileMutation.mutateAsync({ name: { first: tempDisplayName, last: tempLastName } });
                     setDisplayName(tempDisplayName);
                     setLastName(tempLastName);
                     break;
@@ -476,12 +472,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
 
             // Handle name field
             if (displayName || lastName) {
-                const fullName = [displayName, lastName].filter(Boolean).join(' ').trim() || displayName;
-                updates.name = {
-                    first: displayName,
-                    last: lastName,
-                    full: fullName
-                };
+                updates.name = { first: displayName, last: lastName };
             }
 
             // Handle avatar
@@ -523,40 +514,46 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
     const handleOpenLinksModal = useCallback(() => setShowEditLinksModal(true), []);
 
     // Handler to refresh data after modal saves
-    // Note: Query will automatically refetch after mutations invalidate it
+    // Note: Access user directly from store when invoked to get latest value,
+    // not from closure which may be stale after modal saves update the backend
     const handleModalSave = useCallback(() => {
+        // Get fresh user data from store to ensure we have the latest values
+        // after the modal's save operation updates the backend
+        // Read from store directly (not from closure) to avoid stale data
+        const currentUser = useAuthStore.getState().user;
+
         // Reload user data to reflect changes
-        if (finalUser) {
-            const userDisplayName = typeof finalUser.name === 'string'
-                ? finalUser.name
-                : finalUser.name?.first || finalUser.name?.full || '';
-            const userLastName = typeof finalUser.name === 'object' ? finalUser.name?.last || '' : '';
+        if (currentUser) {
+            const userDisplayName = typeof currentUser.name === 'string'
+                ? currentUser.name
+                : currentUser.name?.first || currentUser.name?.full || '';
+            const userLastName = typeof currentUser.name === 'object' ? currentUser.name?.last || '' : '';
             setDisplayName(userDisplayName);
             setLastName(userLastName);
-            setUsername(finalUser.username || '');
-            setEmail(finalUser.email || '');
-            setBio(finalUser.bio || '');
+            setUsername(currentUser.username || '');
+            setEmail(currentUser.email || '');
+            setBio(currentUser.bio || '');
 
             // Reload locations and links
-            if (finalUser.locations && Array.isArray(finalUser.locations)) {
-                setLocations(finalUser.locations.map((loc: any, index: number) => ({
+            if (currentUser.locations && Array.isArray(currentUser.locations)) {
+                setLocations(currentUser.locations.map((loc, index) => ({
                     id: loc.id || `existing-${index}`,
                     name: loc.name,
                     label: loc.label,
                     coordinates: loc.coordinates
                 })));
-            } else if (finalUser.location) {
+            } else if (currentUser.location) {
                 setLocations([{
                     id: 'existing-0',
-                    name: finalUser.location,
+                    name: currentUser.location,
                     label: 'Location'
                 }]);
             } else {
                 setLocations([]);
             }
 
-            if (finalUser.linksMetadata && Array.isArray(finalUser.linksMetadata)) {
-                setLinksMetadata(finalUser.linksMetadata.map((link: any, index: number) => ({
+            if (currentUser.linksMetadata && Array.isArray(currentUser.linksMetadata)) {
+                setLinksMetadata(currentUser.linksMetadata.map((link, index) => ({
                     ...link,
                     id: link.id || `existing-${index}`
                 })));
@@ -564,7 +561,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                 setLinksMetadata([]);
             }
         }
-    }, [finalUser]); // Query will automatically refetch after mutations
+    }, []); // Empty dependency array - callback reads fresh data from store at call time
 
     // Handle initialField prop - open appropriate modal
     useEffect(() => {
@@ -832,7 +829,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                                     {/* Search results */}
                                     {locationSearchResults.length > 0 && (
                                         <View style={styles.searchResults}>
-                                            {locationSearchResults.map((result: any) => (
+                                            {locationSearchResults.map((result) => (
                                                 <TouchableOpacity
                                                     key={result.place_id}
                                                     style={styles.searchResultItem}
@@ -863,7 +860,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                             {tempLocations.length > 0 && (
                                 <View style={styles.locationsList}>
                                     <Text style={styles.locationsListTitle}>Your Locations ({tempLocations.length})</Text>
-                                    {tempLocations.map((location: any, index: number) => (
+                                    {tempLocations.map((location, index) => (
                                         <View key={location.id} style={styles.locationItem}>
                                             <View style={styles.locationItemContent}>
                                                 <View style={styles.locationItemDragHandle}>
@@ -991,7 +988,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                                         onPress: () => setIsAddingLink(true),
                                     }]),
                                     // Existing links
-                                    ...tempLinksWithMetadata.map((link: any, index: number) => ({
+                                    ...tempLinksWithMetadata.map((link, index) => ({
                                         id: link.id,
                                         customIcon: link.image ? (
                                             <Image source={{ uri: link.image }} style={{ width: 36, height: 36, borderRadius: 18 }} />

package/src/ui/screens/AccountSwitcherScreen.tsx

@@ -130,7 +130,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
 
                 // Create a map for O(1) lookup
                 const userProfileMap = new Map<string, User | null>();
-                batchResults.forEach(({ sessionId, user }) => {
+                batchResults.forEach(({ sessionId, user }: { sessionId: string; user: any }) => {
                     userProfileMap.set(sessionId, user);
                 });
 
@@ -460,7 +460,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
                                         iconColor: '#007AFF',
                                         title: 'Add Another Account',
                                         subtitle: 'Sign in with a different account',
-                                        onPress: () => navigate?.('OxyAuth'),
+                                        onPress: () => navigate?.('SignIn'),
                                     },
                                     {
                                         id: 'device-management',
@@ -561,7 +561,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
                                             iconColor: '#ccc',
                                             title: t('accountSwitcher.empty.title') || 'No saved accounts',
                                             subtitle: t('accountSwitcher.empty.subtitle') || 'Add another account to switch between them quickly',
-                                            onPress: () => navigate?.('OxyAuth'),
+                                            onPress: () => navigate?.('SignIn'),
                                             customContent: (
                                                 <View style={styles.emptyStateContainer}>
                                                     <OxyIcon name="person-outline" size={48} color="#ccc" />
@@ -571,7 +571,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
                                                     </Text>
                                                     <TouchableOpacity
                                                         style={styles.addAccountButton}
-                                                        onPress={() => navigate?.('OxyAuth')}
+                                                        onPress={() => navigate?.('SignIn')}
                                                     >
                                                         <Text style={styles.addAccountButtonText}>{t('accountCenter.sections.addAccount') || 'Add Account'}</Text>
                                                     </TouchableOpacity>

package/src/ui/screens/OxyAuthScreen.tsx

@@ -4,7 +4,7 @@
  * This screen is used by OTHER apps in the Oxy ecosystem to authenticate users.
  * It presents two options:
  * 1. Scan QR code with Oxy Accounts app
- * 2. Open Oxy Accounts app directly (via deep link)
+ * 2. Open the Oxy Auth web flow
  * 
  * Uses WebSocket for real-time authorization updates (with polling fallback).
  * The Oxy Accounts app is where users manage their cryptographic identity.
@@ -29,9 +29,8 @@ import { useOxy } from '../context/OxyContext';
 import QRCode from 'react-native-qrcode-svg';
 import OxyLogo from '../components/OxyLogo';
 
-// Deep link scheme for Oxy Accounts app
-const OXY_ACCOUNTS_SCHEME = 'oxyaccounts://';
 const OXY_ACCOUNTS_WEB_URL = 'https://accounts.oxy.so';
+const OXY_AUTH_WEB_URL = 'https://auth.oxy.so';
 
 // Auth session expiration (5 minutes)
 const AUTH_SESSION_EXPIRY_MS = 5 * 60 * 1000;
@@ -52,6 +51,63 @@ interface AuthUpdatePayload {
   username?: string;
 }
 
+const resolveAuthWebBaseUrl = (baseURL: string, authWebUrl?: string): string => {
+  if (authWebUrl) {
+    return authWebUrl;
+  }
+
+  try {
+    const url = new URL(baseURL);
+    if (url.port === '3001') {
+      url.port = '3000';
+      return url.origin;
+    }
+    if (url.hostname.startsWith('api.')) {
+      url.hostname = `auth.${url.hostname.slice(4)}`;
+      return url.origin;
+    }
+  } catch {
+    // Ignore parsing errors, fall back to default.
+  }
+  return OXY_AUTH_WEB_URL;
+};
+
+const resolveAuthRedirectUri = async (authRedirectUri?: string): Promise<string | null> => {
+  if (authRedirectUri) {
+    return authRedirectUri;
+  }
+
+  try {
+    const initialUrl = await Linking.getInitialURL();
+    if (!initialUrl) {
+      return null;
+    }
+
+    const parsed = new URL(initialUrl);
+    parsed.search = '';
+    parsed.hash = '';
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+};
+
+const getRedirectParams = (url: string): { sessionId?: string; error?: string } | null => {
+  try {
+    const parsed = new URL(url);
+    const sessionId = parsed.searchParams.get('session_id') ?? undefined;
+    const error = parsed.searchParams.get('error') ?? undefined;
+
+    if (!sessionId && !error) {
+      return null;
+    }
+
+    return { sessionId, error };
+  } catch {
+    return null;
+  }
+};
+
 const OxyAuthScreen: React.FC<BaseScreenProps> = ({
   navigate,
   goBack,
@@ -60,7 +116,7 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
 }) => {
   const themeValue = (theme === 'light' || theme === 'dark') ? theme : 'light';
   const colors = useThemeColors(themeValue);
-  const { oxyServices, switchSession } = useOxy();
+  const { oxyServices, signIn, switchSession } = useOxy();
 
   const [authSession, setAuthSession] = useState<AuthSession | null>(null);
   const [isLoading, setIsLoading] = useState(true);
@@ -71,22 +127,7 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
   const socketRef = useRef<Socket | null>(null);
   const pollingIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const isProcessingRef = useRef(false);
-
-  const resolveDeviceIdForSession = useCallback(
-    async (sessionId: string): Promise<string | undefined> => {
-      try {
-        const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
-        const matchingSession = deviceSessions?.find((session) => session.sessionId === sessionId);
-        return matchingSession?.deviceId || undefined;
-      } catch (err) {
-        if (__DEV__) {
-          console.log('Failed to resolve deviceId for session', err);
-        }
-        return undefined;
-      }
-    },
-    [oxyServices],
-  );
+  const linkingHandledRef = useRef(false);
 
   // Handle successful authorization
   const handleAuthSuccess = useCallback(async (sessionId: string) => {
@@ -102,8 +143,7 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
         }
       } else {
         // Fallback if switchSession not available (shouldn't happen, but for safety)
-        const deviceId = await resolveDeviceIdForSession(sessionId);
-        await oxyServices.getTokenBySession(sessionId, deviceId);
+        await oxyServices.getTokenBySession(sessionId);
         const user = await oxyServices.getUserBySession(sessionId);
         if (onAuthenticated) {
           onAuthenticated(user);
@@ -116,7 +156,7 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
       setError('Authorization successful but failed to complete sign in. Please try again.');
       isProcessingRef.current = false;
     }
-  }, [oxyServices, resolveDeviceIdForSession, switchSession, onAuthenticated]);
+  }, [oxyServices, switchSession, onAuthenticated]);
 
   // Connect to socket for real-time updates
   const connectSocket = useCallback((sessionToken: string) => {
@@ -188,12 +228,12 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
       if (isProcessingRef.current) return;
 
       try {
-        const response = await oxyServices.makeRequest<{
+        const response: {
           authorized: boolean;
           sessionId?: string;
           publicKey?: string;
           status?: string;
-        }>('GET', `/api/auth/session/status/${sessionToken}`, undefined, { cache: false });
+        } = await oxyServices.makeRequest('GET', `/api/auth/session/status/${sessionToken}`, undefined, { cache: false });
 
         if (response.authorized && response.sessionId) {
           cleanup();
@@ -298,31 +338,27 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
     return `oxyauth://${authSession.sessionToken}`;
   };
 
-  // Open Oxy Accounts app
-  const handleOpenAccounts = useCallback(async () => {
+  // Open Oxy Auth web flow
+  const handleOpenAuth = useCallback(async () => {
     if (!authSession) return;
 
-    const deepLinkUrl = `${OXY_ACCOUNTS_SCHEME}authorize?token=${authSession.sessionToken}`;
-    const webUrl = `${OXY_ACCOUNTS_WEB_URL}/authorize?token=${authSession.sessionToken}`;
+    const authBaseUrl = resolveAuthWebBaseUrl(
+      oxyServices.getBaseURL(),
+      oxyServices.config?.authWebUrl
+    );
+    const webUrl = new URL('/authorize', authBaseUrl);
+    webUrl.searchParams.set('token', authSession.sessionToken);
+    const redirectUri = await resolveAuthRedirectUri(oxyServices.config?.authRedirectUri);
+    if (redirectUri) {
+      webUrl.searchParams.set('redirect_uri', redirectUri);
+    }
 
     try {
-      const canOpen = await Linking.canOpenURL(deepLinkUrl);
-
-      if (canOpen) {
-        await Linking.openURL(deepLinkUrl);
-      } else {
-        // Fallback to web URL
-        await Linking.openURL(webUrl);
-      }
+      await Linking.openURL(webUrl.toString());
     } catch (err) {
-      // Fallback to web URL
-      try {
-        await Linking.openURL(webUrl);
-      } catch {
-        setError('Unable to open Oxy Accounts. Please install the app or use QR code.');
-      }
+      setError('Unable to open Oxy Auth. Please try again or use the QR code.');
     }
-  }, [authSession]);
+  }, [authSession, oxyServices]);
 
   // Refresh session
   const handleRefresh = useCallback(() => {
@@ -330,6 +366,49 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
     generateAuthSession();
   }, [generateAuthSession, cleanup]);
 
+  const handleAuthRedirect = useCallback((url: string) => {
+    const params = getRedirectParams(url);
+    if (!params) {
+      return;
+    }
+
+    if (params.error) {
+      cleanup();
+      setError('Authorization was denied.');
+      return;
+    }
+
+    if (params.sessionId) {
+      cleanup();
+      handleAuthSuccess(params.sessionId);
+    }
+  }, [cleanup, handleAuthSuccess]);
+
+  useEffect(() => {
+    if (Platform.OS === 'web') {
+      return;
+    }
+
+    const subscription = Linking.addEventListener('url', ({ url }) => {
+      linkingHandledRef.current = true;
+      handleAuthRedirect(url);
+    });
+
+    Linking.getInitialURL()
+      .then((url) => {
+        if (url && !linkingHandledRef.current) {
+          handleAuthRedirect(url);
+        }
+      })
+      .catch(() => {
+        // Ignore linking errors; auth will still resolve via socket/polling.
+      });
+
+    return () => {
+      subscription.remove();
+    };
+  }, [handleAuthRedirect]);
+
   if (isLoading) {
     return (
       <View style={[styles.container, { backgroundColor: colors.background }]}>
@@ -381,26 +460,21 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
         </Text>
       </View>
 
-      {/* Divider and Open Accounts Button - Only show on native platforms */}
-      {Platform.OS !== 'web' && (
-        <>
-          {/* Divider */}
-          <View style={styles.dividerContainer}>
-            <View style={[styles.divider, { backgroundColor: colors.border }]} />
-            <Text style={[styles.dividerText, { color: colors.secondaryText }]}>or</Text>
-            <View style={[styles.divider, { backgroundColor: colors.border }]} />
-          </View>
-
-          {/* Open Accounts Button */}
-          <TouchableOpacity
-            style={[styles.button, { backgroundColor: colors.primary }]}
-            onPress={handleOpenAccounts}
-          >
-            <OxyLogo width={20} height={20} fillColor="white" style={styles.buttonIcon} />
-            <Text style={styles.buttonText}>Open Oxy Accounts</Text>
-          </TouchableOpacity>
-        </>
-      )}
+      {/* Divider */}
+      <View style={styles.dividerContainer}>
+        <View style={[styles.divider, { backgroundColor: colors.border }]} />
+        <Text style={[styles.dividerText, { color: colors.secondaryText }]}>or</Text>
+        <View style={[styles.divider, { backgroundColor: colors.border }]} />
+      </View>
+
+      {/* Open Oxy Auth Button */}
+      <TouchableOpacity
+        style={[styles.button, { backgroundColor: colors.primary }]}
+        onPress={handleOpenAuth}
+      >
+        <OxyLogo width={20} height={20} fillColor="white" style={styles.buttonIcon} />
+        <Text style={styles.buttonText}>Open Oxy Auth</Text>
+      </TouchableOpacity>
 
       {/* Status */}
       {isWaiting && (

package/src/ui/screens/PrivacySettingsScreen.tsx

@@ -78,11 +78,8 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         const loadSettings = async () => {
             try {
                 setIsLoading(true);
-                // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
-                // Never use user?.id as it may be set to publicKey
-                const userId = oxyServices?.getCurrentUserId();
-                if (userId && oxyServices) {
-                    const privacySettings = await oxyServices.getPrivacySettings(userId);
+                if (user?.id && oxyServices) {
+                    const privacySettings = await oxyServices.getPrivacySettings(user.id);
                     if (privacySettings) {
                         setSettings(privacySettings);
                     }
@@ -96,7 +93,7 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         };
 
         loadSettings();
-    }, [oxyServices, t]);
+    }, [user?.id, oxyServices, t]);
 
     // Load blocked and restricted users
     useEffect(() => {
@@ -126,11 +123,8 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
             const newSettings = { ...settings, [key]: value };
             setSettings(newSettings);
             
-            // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
-            // Never use user?.id as it may be set to publicKey
-            const userId = oxyServices?.getCurrentUserId();
-            if (userId && oxyServices) {
-                await oxyServices.updatePrivacySettings({ [key]: value }, userId);
+            if (user?.id && oxyServices) {
+                await oxyServices.updatePrivacySettings({ [key]: value }, user.id);
                 toast.success(t('privacySettings.updated') || 'Privacy settings updated');
             }
         } catch (error) {
@@ -141,7 +135,7 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         } finally {
             setIsSaving(false);
         }
-    }, [settings, oxyServices, t]);
+    }, [settings, user?.id, oxyServices, t]);
 
     const handleUnblock = useCallback(async (userId: string) => {
         if (!oxyServices) return;

package/src/ui/stores/accountStore.ts

@@ -112,8 +112,6 @@ export const useAccountStore = create<AccountState>((set, get) => ({
                 return existing && 
                     existing.sessionId === newAccount.sessionId &&
                     existing.userId === newAccount.userId &&
-                    existing.username === newAccount.username &&
-                    existing.displayName === newAccount.displayName &&
                     existing.avatar === newAccount.avatar &&
                     existing.avatarUrl === newAccount.avatarUrl;
             });
@@ -152,15 +150,7 @@ export const useAccountStore = create<AccountState>((set, get) => ({
         if (!existing) return {} as any;
         
         const updated = { ...existing, ...updates };
-        // Check if any meaningful field has changed
-        const hasChanges = 
-            existing.username !== updated.username ||
-            existing.displayName !== updated.displayName ||
-            existing.avatar !== updated.avatar ||
-            existing.avatarUrl !== updated.avatarUrl ||
-            existing.userId !== updated.userId;
-        
-        if (!hasChanges) {
+        if (existing.avatar === updated.avatar && existing.avatarUrl === updated.avatarUrl) {
             return {} as any; // No change
         }
         

package/src/ui/stores/authStore.ts

@@ -1,65 +1,64 @@
-/** Auth store for Services SDK (sessions/tokens only). */
-
 import { create } from 'zustand';
+import type { User } from '../../models/interfaces';
 
 export interface AuthState {
+  user: User | null;
   isAuthenticated: boolean;
-  isOnline: boolean;
   isLoading: boolean;
   error: string | null;
-  identitySynced: boolean;
+  lastUserFetch: number | null; // Timestamp of last user fetch for caching
   
-  setOnline: (online: boolean) => void;
-  loginSuccess: () => void;
+  loginSuccess: (user: User) => void;
   loginFailure: (error: string) => void;
   logout: () => void;
-  setIdentitySynced: (synced: boolean) => void;
-  
-  canAuthenticate: () => boolean;
+  fetchUser: (oxyServices: { getCurrentUser: () => Promise<User> }, forceRefresh?: boolean) => Promise<void>;
+  setUser: (user: User) => void; // Direct user setter for caching
 }
 
-export const useAuthStore = create<AuthState>((set, get) => ({
+export const useAuthStore = create<AuthState>((set: (state: Partial<AuthState>) => void, get: () => AuthState) => ({
+  user: null,
   isAuthenticated: false,
-  isOnline: true, // Assume online initially
   isLoading: false,
   error: null,
-  identitySynced: false,
-  
-  setOnline: (online: boolean) => {
-    set({ isOnline: online });
-    // If we go offline, we can't be authenticated
-    if (!online) {
-      set({ isAuthenticated: false });
-    }
-  },
-  
-  loginSuccess: () => set({ 
-    isLoading: false, 
-    isAuthenticated: get().isOnline, // Only authenticated if online
-    error: null,
-  }),
+  lastUserFetch: null,
   
-  loginFailure: (error: string) => set({ 
+  loginSuccess: (user: User) => set({ 
     isLoading: false, 
-    isAuthenticated: false,
-    error 
+    isAuthenticated: true, 
+    user, 
+    lastUserFetch: Date.now(),
   }),
-  
+  loginFailure: (error: string) => set({ isLoading: false, error }),
   logout: () => set({ 
-    isAuthenticated: false,
-    error: null,
-    identitySynced: false,
+    user: null, 
+    isAuthenticated: false, 
+    lastUserFetch: null,
   }),
-
-  // Track whether identity registration is confirmed with backend
-  setIdentitySynced: (synced: boolean) => set({ identitySynced: synced }),
-  
-  /**
-   * Check if user can authenticate
-   * Requires both valid tokens (checked by caller) and network
-   */
-  canAuthenticate: () => {
+  setUser: (user: User) => set({ user, lastUserFetch: Date.now() }),
+  fetchUser: async (oxyServices, forceRefresh = false) => {
     const state = get();
-    return state.isOnline;
+    const now = Date.now();
+    const cacheAge = state.lastUserFetch ? now - state.lastUserFetch : Number.POSITIVE_INFINITY;
+    const cacheValid = cacheAge < 5 * 60 * 1000; // 5 minutes cache
+
+    // Use cached data if available and not forcing refresh
+    if (!forceRefresh && state.user && cacheValid) {
+      if (__DEV__) {
+      console.log('AuthStore: Using cached user data (age:', cacheAge, 'ms)');
+      }
+      return;
+    }
+
+    set({ isLoading: true, error: null });
+    try {
+      const user = await oxyServices.getCurrentUser();
+      set({ user, isLoading: false, isAuthenticated: true, lastUserFetch: now });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to fetch user';
+      if (__DEV__) {
+      console.error('AuthStore: Error fetching user:', error);
+      }
+      set({ error: errorMessage, isLoading: false });
+    }
   },
-})); 
+}));