@oxyhq/services 5.16.44 → 5.17.1

package/src/ui/screens/AccountSettingsScreen.tsx

@@ -22,7 +22,6 @@ 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';
@@ -77,13 +76,9 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
     const normalizedTheme = normalizeTheme(theme);
 
     // Use TanStack Query for user data
-    const { data: user, isLoading: userLoading } = useCurrentUser({ enabled: isAuthenticated });
+    const { data: finalUser, 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;
@@ -229,17 +224,17 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                 setUsername(finalUser.username || '');
                 setEmail(finalUser.email || '');
                 setBio(finalUser.bio || '');
-                setLocation(typeof finalUser.location === 'string' ? finalUser.location : '');
+                setLocation(finalUser.location || '');
 
                 // Handle locations - convert single location to array format
                 if (finalUser.locations && Array.isArray(finalUser.locations)) {
-                    setLocations(finalUser.locations.map((loc, index) => ({
+                    setLocations(finalUser.locations.map((loc: any, index: number) => ({
                         id: loc.id || `existing-${index}`,
                         name: loc.name,
                         label: loc.label,
                         coordinates: loc.coordinates
                     })));
-                } else if (finalUser.location && typeof finalUser.location === 'string') {
+                } else if (finalUser.location) {
                     // Convert single location string to array format
                     setLocations([{
                         id: 'existing-0',
@@ -252,17 +247,17 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
 
                 // Handle links - simple and direct like other fields
                 if (finalUser.linksMetadata && Array.isArray(finalUser.linksMetadata)) {
-                    const urls = finalUser.linksMetadata.map(l => l.url);
+                    const urls = finalUser.linksMetadata.map((l: any) => l.url);
                     setLinks(urls);
-                    const metadataWithIds = finalUser.linksMetadata.map((link, index) => ({
+                    const metadataWithIds = finalUser.linksMetadata.map((link: any, index: number) => ({
                         ...link,
-                        id: (link as any).id || `existing-${index}`
+                        id: link.id || `existing-${index}`
                     }));
                     setLinksMetadata(metadataWithIds);
                 } else if (Array.isArray(finalUser.links)) {
-                    const simpleLinks = finalUser.links.map(l => typeof l === 'string' ? l : (l as any).link).filter(Boolean) as string[];
+                    const simpleLinks = finalUser.links.map((l: any) => typeof l === 'string' ? l : l.link).filter(Boolean);
                     setLinks(simpleLinks);
-                    const linksWithMetadata = simpleLinks.map((url, index) => ({
+                    const linksWithMetadata = simpleLinks.map((url: string, index: number) => ({
                         url,
                         title: url.replace(/^https?:\/\//, '').replace(/\/$/, ''),
                         description: `Link to ${url}`,
@@ -270,7 +265,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                         id: `existing-${index}`
                     }));
                     setLinksMetadata(linksWithMetadata);
-                } else if (finalUser.website && typeof finalUser.website === 'string') {
+                } else if (finalUser.website) {
                     setLinks([finalUser.website]);
                     setLinksMetadata([{
                         url: finalUser.website,
@@ -388,14 +383,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                     setLocations(tempLocations);
                     break;
                 case 'links':
-                    // Ensure all links have required fields
-                    const linksWithRequiredFields = tempLinksWithMetadata.map(link => ({
-                        url: link.url,
-                        title: link.title || link.url.replace(/^https?:\/\//, '').replace(/\/$/, ''),
-                        description: link.description || `Link to ${link.url}`,
-                        image: link.image,
-                    }));
-                    await updateProfileMutation.mutateAsync({ linksMetadata: linksWithRequiredFields });
+                    await updateProfileMutation.mutateAsync({ linksMetadata: tempLinksWithMetadata });
                     setLinksMetadata(tempLinksWithMetadata);
                     setLinks(tempLinksWithMetadata.map(l => l.url));
                     break;
@@ -521,54 +509,48 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
     const handleOpenLinksModal = useCallback(() => setShowEditLinksModal(true), []);
 
     // Handler to refresh data after modal saves
-    // 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
+    // Note: Query will automatically refetch after mutations invalidate it
     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 (currentUser) {
-            const userDisplayName = typeof currentUser.name === 'string'
-                ? currentUser.name
-                : currentUser.name?.first || currentUser.name?.full || '';
-            const userLastName = typeof currentUser.name === 'object' ? currentUser.name?.last || '' : '';
+        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 || '' : '';
             setDisplayName(userDisplayName);
             setLastName(userLastName);
-            setUsername(currentUser.username || '');
-            setEmail(currentUser.email || '');
-            setBio(currentUser.bio || '');
+            setUsername(finalUser.username || '');
+            setEmail(finalUser.email || '');
+            setBio(finalUser.bio || '');
 
             // Reload locations and links
-            if (currentUser.locations && Array.isArray(currentUser.locations)) {
-                setLocations(currentUser.locations.map((loc, index) => ({
+            if (finalUser.locations && Array.isArray(finalUser.locations)) {
+                setLocations(finalUser.locations.map((loc: any, index: number) => ({
                     id: loc.id || `existing-${index}`,
                     name: loc.name,
                     label: loc.label,
                     coordinates: loc.coordinates
                 })));
-            } else if (currentUser.location && typeof currentUser.location === 'string') {
+            } else if (finalUser.location) {
                 setLocations([{
                     id: 'existing-0',
-                    name: currentUser.location,
+                    name: finalUser.location,
                     label: 'Location'
                 }]);
             } else {
                 setLocations([]);
             }
 
-            if (currentUser.linksMetadata && Array.isArray(currentUser.linksMetadata)) {
-                setLinksMetadata(currentUser.linksMetadata.map((link, index) => ({
+            if (finalUser.linksMetadata && Array.isArray(finalUser.linksMetadata)) {
+                setLinksMetadata(finalUser.linksMetadata.map((link: any, index: number) => ({
                     ...link,
-                    id: (link as any).id || `existing-${index}`
+                    id: link.id || `existing-${index}`
                 })));
             } else {
                 setLinksMetadata([]);
             }
         }
-    }, []); // Empty dependency array - callback reads fresh data from store at call time
+    }, [finalUser]); // Query will automatically refetch after mutations
 
     // Handle initialField prop - open appropriate modal
     useEffect(() => {
@@ -836,7 +818,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                                     {/* Search results */}
                                     {locationSearchResults.length > 0 && (
                                         <View style={styles.searchResults}>
-                                            {locationSearchResults.map((result) => (
+                                            {locationSearchResults.map((result: any) => (
                                                 <TouchableOpacity
                                                     key={result.place_id}
                                                     style={styles.searchResultItem}
@@ -867,7 +849,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, index) => (
+                                    {tempLocations.map((location: any, index: number) => (
                                         <View key={location.id} style={styles.locationItem}>
                                             <View style={styles.locationItemContent}>
                                                 <View style={styles.locationItemDragHandle}>
@@ -995,7 +977,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                                         onPress: () => setIsAddingLink(true),
                                     }]),
                                     // Existing links
-                                    ...tempLinksWithMetadata.map((link, index) => ({
+                                    ...tempLinksWithMetadata.map((link: any, index: number) => ({
                                         id: link.id,
                                         customIcon: link.image ? (
                                             <Image source={{ uri: link.image }} style={{ width: 36, height: 36, borderRadius: 18 }} />

package/src/ui/screens/AccountSwitcherScreen.tsx

@@ -405,7 +405,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
                                                 ) : (
                                                     <View style={styles.accountAvatarFallback}>
                                                         <Text style={styles.accountAvatarText}>
-                                                            {displayName?.charAt(0).toUpperCase() || '?'}
+                                                            {displayName.charAt(0).toUpperCase()}
                                                         </Text>
                                                     </View>
                                                 )}
@@ -432,7 +432,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
                                                 </TouchableOpacity>
                                                 <TouchableOpacity
                                                     style={styles.removeButton}
-                                                    onPress={() => handleRemoveSession(sessionWithUser.sessionId, displayName || 'this account')}
+                                                    onPress={() => handleRemoveSession(sessionWithUser.sessionId, displayName)}
                                                     disabled={isSwitching || isRemoving}
                                                 >
                                                     {isRemoving ? (
@@ -460,7 +460,7 @@ const ModernAccountSwitcherScreen: React.FC<BaseScreenProps> = ({
                                         iconColor: '#007AFF',
                                         title: 'Add Another Account',
                                         subtitle: 'Sign in with a different account',
-                                        onPress: () => navigate?.('SignIn'),
+                                        onPress: () => navigate?.('OxyAuth'),
                                     },
                                     {
                                         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?.('SignIn'),
+                                            onPress: () => navigate?.('OxyAuth'),
                                             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?.('SignIn')}
+                                                        onPress={() => navigate?.('OxyAuth')}
                                                     >
                                                         <Text style={styles.addAccountButtonText}>{t('accountCenter.sections.addAccount') || 'Add Account'}</Text>
                                                     </TouchableOpacity>

package/src/ui/screens/OxyAuthScreen.tsx

@@ -72,6 +72,22 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
   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],
+  );
+
   // Handle successful authorization
   const handleAuthSuccess = useCallback(async (sessionId: string) => {
     if (isProcessingRef.current) return;
@@ -86,7 +102,8 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
         }
       } else {
         // Fallback if switchSession not available (shouldn't happen, but for safety)
-        await oxyServices.getTokenBySession(sessionId);
+        const deviceId = await resolveDeviceIdForSession(sessionId);
+        await oxyServices.getTokenBySession(sessionId, deviceId);
         const user = await oxyServices.getUserBySession(sessionId);
         if (onAuthenticated) {
           onAuthenticated(user);
@@ -99,7 +116,7 @@ const OxyAuthScreen: React.FC<BaseScreenProps> = ({
       setError('Authorization successful but failed to complete sign in. Please try again.');
       isProcessingRef.current = false;
     }
-  }, [oxyServices, switchSession, onAuthenticated]);
+  }, [oxyServices, resolveDeviceIdForSession, switchSession, onAuthenticated]);
 
   // Connect to socket for real-time updates
   const connectSocket = useCallback((sessionToken: string) => {
@@ -523,5 +540,3 @@ const styles = StyleSheet.create({
 });
 
 export default OxyAuthScreen;
-
-

package/src/ui/screens/PrivacySettingsScreen.tsx

@@ -1,9 +1,10 @@
-import React, { useState, useCallback, useMemo } from 'react';
+import React, { useState, useCallback, useEffect, useMemo } from 'react';
 import {
     View,
     Text,
     StyleSheet,
     ScrollView,
+    ActivityIndicator,
     TouchableOpacity,
 } from 'react-native';
 import type { BaseScreenProps } from '../types/navigation';
@@ -14,8 +15,6 @@ import { useThemeStyles } from '../hooks/useThemeStyles';
 import { normalizeTheme } from '../utils/themeUtils';
 import type { BlockedUser, RestrictedUser } from '../../models/interfaces';
 import { useOxy } from '../context/OxyContext';
-import { usePrivacySettings, useBlockedUsers, useRestrictedUsers } from '../hooks/queries';
-import { useUpdatePrivacySettings, useUnblockUser, useUnrestrictUser } from '../hooks/mutations';
 
 interface PrivacySettings {
     isPrivateAccount: boolean;
@@ -45,20 +44,8 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
     goBack,
 }) => {
     // Use useOxy() hook for OxyContext values
-    const { oxyServices } = useOxy();
+    const { oxyServices, user } = useOxy();
     const { t } = useI18n();
-    
-    // TanStack Query hooks for server state
-    const { data: privacySettingsData, isLoading: isLoadingSettings, error: settingsError } = usePrivacySettings();
-    const { data: blockedUsers = [], isLoading: isLoadingBlocked } = useBlockedUsers();
-    const { data: restrictedUsers = [], isLoading: isLoadingRestricted } = useRestrictedUsers();
-    
-    // Mutations
-    const updatePrivacySettingsMutation = useUpdatePrivacySettings();
-    const unblockUserMutation = useUnblockUser();
-    const unrestrictUserMutation = useUnrestrictUser();
-    
-    // Client state for optimistic UI updates
     const [settings, setSettings] = useState<PrivacySettings>({
         isPrivateAccount: false,
         hideOnlineStatus: false,
@@ -80,64 +67,111 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         autoFilter: true,
         muteKeywords: false,
     });
-    
-    // Update local state when server data changes
-    React.useEffect(() => {
-        if (privacySettingsData) {
-            setSettings(privacySettingsData as PrivacySettings);
-        }
-    }, [privacySettingsData]);
-    
-    // Show error toast if settings failed to load
-    React.useEffect(() => {
-        if (settingsError) {
-            toast.error(t('privacySettings.loadError') || 'Failed to load privacy settings');
-        }
-    }, [settingsError, t]);
-    
-    const isLoading = isLoadingSettings;
-    const isSaving = updatePrivacySettingsMutation.isPending;
-    const isLoadingUsers = isLoadingBlocked || isLoadingRestricted;
+    const [isLoading, setIsLoading] = useState(true);
+    const [isSaving, setIsSaving] = useState(false);
+    const [blockedUsers, setBlockedUsers] = useState<BlockedUser[]>([]);
+    const [restrictedUsers, setRestrictedUsers] = useState<RestrictedUser[]>([]);
+    const [isLoadingUsers, setIsLoadingUsers] = useState(false);
+
+    // Load settings and users
+    useEffect(() => {
+        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 (privacySettings) {
+                        setSettings(privacySettings);
+                    }
+                }
+            } catch (error) {
+                console.error('Failed to load privacy settings:', error);
+                toast.error(t('privacySettings.loadError') || 'Failed to load privacy settings');
+            } finally {
+                setIsLoading(false);
+            }
+        };
+
+        loadSettings();
+    }, [oxyServices, t]);
+
+    // Load blocked and restricted users
+    useEffect(() => {
+        const loadUsers = async () => {
+            if (!oxyServices) return;
+            try {
+                setIsLoadingUsers(true);
+                const [blocked, restricted] = await Promise.all([
+                    oxyServices.getBlockedUsers(),
+                    oxyServices.getRestrictedUsers(),
+                ]);
+                setBlockedUsers(blocked);
+                setRestrictedUsers(restricted);
+            } catch (error) {
+                console.error('Failed to load blocked/restricted users:', error);
+            } finally {
+                setIsLoadingUsers(false);
+            }
+        };
+
+        loadUsers();
+    }, [oxyServices]);
 
     const updateSetting = useCallback(async (key: keyof PrivacySettings, value: boolean) => {
-        // Optimistic update
-        const newSettings = { ...settings, [key]: value };
-        setSettings(newSettings);
-        
-        // Use mutation hook
-        updatePrivacySettingsMutation.mutate(
-            { settings: { [key]: value } },
-            {
-                onError: () => {
-                    // Revert on error
-                    setSettings(settings);
-                    toast.error(t('privacySettings.updateError') || 'Failed to update privacy setting');
-                },
+        try {
+            setIsSaving(true);
+            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);
+                toast.success(t('privacySettings.updated') || 'Privacy settings updated');
             }
-        );
-    }, [settings, updatePrivacySettingsMutation, t]);
+        } catch (error) {
+            console.error(`Failed to update ${key}:`, error);
+            toast.error(t('privacySettings.updateError') || 'Failed to update privacy setting');
+            // Revert on error
+            setSettings(settings);
+        } finally {
+            setIsSaving(false);
+        }
+    }, [settings, oxyServices, t]);
 
     const handleUnblock = useCallback(async (userId: string) => {
-        unblockUserMutation.mutate(userId, {
-            onSuccess: () => {
-                toast.success(t('privacySettings.userUnblocked') || 'User unblocked');
-            },
-            onError: () => {
-                toast.error(t('privacySettings.unblockError') || 'Failed to unblock user');
-            },
-        });
-    }, [unblockUserMutation, t]);
+        if (!oxyServices) return;
+        try {
+            await oxyServices.unblockUser(userId);
+            setBlockedUsers(prev => prev.filter(u => {
+                const id = typeof u.blockedId === 'string' ? u.blockedId : u.blockedId._id;
+                return id !== userId;
+            }));
+            toast.success(t('privacySettings.userUnblocked') || 'User unblocked');
+        } catch (error) {
+            console.error('Failed to unblock user:', error);
+            toast.error(t('privacySettings.unblockError') || 'Failed to unblock user');
+        }
+    }, [oxyServices, t]);
 
     const handleUnrestrict = useCallback(async (userId: string) => {
-        unrestrictUserMutation.mutate(userId, {
-            onSuccess: () => {
-                toast.success(t('privacySettings.userUnrestricted') || 'User unrestricted');
-            },
-            onError: () => {
-                toast.error(t('privacySettings.unrestrictError') || 'Failed to unrestrict user');
-            },
-        });
-    }, [unrestrictUserMutation, t]);
+        if (!oxyServices) return;
+        try {
+            await oxyServices.unrestrictUser(userId);
+            setRestrictedUsers(prev => prev.filter(u => {
+                const id = typeof u.restrictedId === 'string' ? u.restrictedId : u.restrictedId._id;
+                return id !== userId;
+            }));
+            toast.success(t('privacySettings.userUnrestricted') || 'User unrestricted');
+        } catch (error) {
+            console.error('Failed to unrestrict user:', error);
+            toast.error(t('privacySettings.unrestrictError') || 'Failed to unrestrict user');
+        }
+    }, [oxyServices, t]);
 
     // Helper to extract user info from blocked/restricted objects
     const extractUserInfo = useCallback((

package/src/ui/screens/ProfileScreen.tsx

@@ -121,7 +121,7 @@ const ProfileScreen: React.FC<ProfileScreenProps> = ({ userId, username, theme,
                         id: `existing-${index}`
                     }));
                     setLinks(linksWithMetadata);
-                } else if (profileRes.website && typeof profileRes.website === 'string') {
+                } else if (profileRes.website) {
                     setLinks([{
                         url: profileRes.website,
                         title: profileRes.website.replace(/^https?:\/\//, '').replace(/\/$/, ''),
@@ -252,32 +252,32 @@ const ProfileScreen: React.FC<ProfileScreenProps> = ({ userId, username, theme,
 
                     {/* Info Grid Row */}
                     <View style={styles.infoGrid}>
-                        {profile?.createdAt ? (
+                        {profile?.createdAt && (
                             <View style={styles.infoGridItem}>
                                 <Ionicons name="calendar-outline" size={16} color={colors.secondaryText} style={{ marginRight: 6 }} />
                                 <Text style={[styles.infoGridText, { color: colors.secondaryText }]}>
                                     {t('profile.joinedOn', { date: new Date(profile.createdAt).toLocaleDateString() }) || `Joined ${new Date(profile.createdAt).toLocaleDateString()}`}
                                 </Text>
                             </View>
-                        ) : null}
-                        {profile?.location && typeof profile.location === 'string' ? (
+                        )}
+                        {profile?.location && (
                             <View style={styles.infoGridItem}>
                                 <Ionicons name="location-outline" size={16} color={colors.secondaryText} style={{ marginRight: 6 }} />
                                 <Text style={[styles.infoGridText, { color: colors.secondaryText }]} numberOfLines={1}>{profile.location}</Text>
                             </View>
-                        ) : null}
-                        {profile?.website && typeof profile.website === 'string' ? (
+                        )}
+                        {profile?.website && (
                             <View style={styles.infoGridItem}>
                                 <Ionicons name="globe-outline" size={16} color={colors.secondaryText} style={{ marginRight: 6 }} />
                                 <Text style={[styles.infoGridText, { color: colors.secondaryText }]} numberOfLines={1}>{profile.website}</Text>
                             </View>
-                        ) : null}
-                        {profile && 'company' in profile && typeof profile.company === 'string' && profile.company ? (
+                        )}
+                        {profile && 'company' in profile && typeof profile.company === 'string' && profile.company && (
                             <View style={styles.infoGridItem}>
                                 <Ionicons name="business-outline" size={16} color={colors.secondaryText} style={{ marginRight: 6 }} />
-                                <Text style={[styles.infoGridText, { color: colors.secondaryText }]} numberOfLines={1}>{profile.company as string}</Text>
+                                <Text style={[styles.infoGridText, { color: colors.secondaryText }]} numberOfLines={1}>{profile.company}</Text>
                             </View>
-                        ) : null}
+                        )}
                         {profile && 'jobTitle' in profile && typeof profile.jobTitle === 'string' && profile.jobTitle && (
                             <View style={styles.infoGridItem}>
                                 <Ionicons name="briefcase-outline" size={16} color={colors.secondaryText} style={{ marginRight: 6 }} />

package/src/ui/stores/authStore.ts

@@ -1,84 +1,44 @@
 import { create } from 'zustand';
-import type { User } from '../../models/interfaces';
 
 export interface AuthState {
-  user: User | null;
   isAuthenticated: boolean;
   isLoading: boolean;
   error: string | null;
-  lastUserFetch: number | null; // Timestamp of last user fetch for caching
   
   // Identity sync state (offline-first)
   isIdentitySynced: boolean;
   isSyncing: boolean;
   
-  loginSuccess: (user: User) => void;
+  loginSuccess: () => void;
   loginFailure: (error: string) => void;
   logout: () => void;
-  fetchUser: (oxyServices: { getCurrentUser: () => Promise<User> }, forceRefresh?: boolean) => Promise<void>;
-  setUser: (user: User) => void; // Direct user setter for caching
   
   // Identity sync actions
   setIdentitySynced: (synced: boolean) => void;
   setSyncing: (syncing: boolean) => void;
 }
 
-export const useAuthStore = create<AuthState>((set: (state: Partial<AuthState>) => void, get: () => AuthState) => ({
-  user: null,
+export const useAuthStore = create<AuthState>((set: (state: Partial<AuthState>) => void) => ({
   isAuthenticated: false,
   isLoading: false,
   error: null,
-  lastUserFetch: null,
   
   // Identity sync state (offline-first)
-  isIdentitySynced: true, // Assume synced until proven otherwise
+  isIdentitySynced: false, // Registration/identity sync not confirmed until done
   isSyncing: false,
   
-  loginSuccess: (user: User) => set({ 
+  loginSuccess: () => set({ 
     isLoading: false, 
-    isAuthenticated: true, 
-    user, 
-    lastUserFetch: Date.now(),
-    isIdentitySynced: true, // If login succeeded, identity is synced
+    isAuthenticated: true,
+    isIdentitySynced: true, // If login succeeded, registration is complete
   }),
   loginFailure: (error: string) => set({ isLoading: false, error }),
   logout: () => set({ 
-    user: null, 
-    isAuthenticated: false, 
-    lastUserFetch: null,
-    // Reset identity sync state when logging out (for accounts app, identity = account)
-    isIdentitySynced: false,
+    isAuthenticated: false,
     isSyncing: false,
   }),
-  setUser: (user: User) => set({ user, lastUserFetch: Date.now() }),
   
   // Identity sync actions
   setIdentitySynced: (synced: boolean) => set({ isIdentitySynced: synced }),
   setSyncing: (syncing: boolean) => set({ isSyncing: syncing }),
-  fetchUser: async (oxyServices, forceRefresh = false) => {
-    const state = get();
-    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 });
-    }
-  },
-})); 
+}));