@oxyhq/services 5.16.40 → 5.16.42

package/src/ui/hooks/auth/index.ts

@@ -6,3 +6,4 @@ export type { UsernameValidationResult } from './useUsernameValidation';
 
 
 
+

package/src/ui/hooks/useAvatarPicker.ts

@@ -0,0 +1,62 @@
+import { useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { toast } from '../../lib/sonner';
+import { translate } from '../../i18n';
+import type { RouteName } from '../navigation/routes';
+import { showBottomSheet as globalShowBottomSheet } from '../navigation/bottomSheetManager';
+import { updateAvatarVisibility, updateProfileWithAvatar } from '../utils/avatarUtils';
+import type { OxyServices } from '../../core';
+import type { User } from '../../models/interfaces';
+
+interface UseAvatarPickerOptions {
+  oxyServices: OxyServices;
+  currentLanguage: string;
+  activeSessionId: string | null;
+  queryClient: ReturnType<typeof useQueryClient>;
+  syncIdentity: (username?: string) => Promise<User>;
+}
+
+/**
+ * Hook to handle avatar picker functionality
+ */
+export function useAvatarPicker({
+  oxyServices,
+  currentLanguage,
+  activeSessionId,
+  queryClient,
+  syncIdentity,
+}: UseAvatarPickerOptions) {
+  const openAvatarPicker = useCallback(() => {
+    globalShowBottomSheet({
+      screen: 'FileManagement' as RouteName,
+      props: {
+        selectMode: true,
+        multiSelect: false,
+        disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
+        afterSelect: 'none',
+        onSelect: async (file: any) => {
+          if (!file.contentType.startsWith('image/')) {
+            toast.error(translate(currentLanguage, 'editProfile.toasts.selectImage') || 'Please select an image file');
+            return;
+          }
+          try {
+            await updateAvatarVisibility(file.id, oxyServices, 'useAvatarPicker');
+            await updateProfileWithAvatar(
+              { avatar: file.id },
+              oxyServices,
+              activeSessionId,
+              queryClient,
+              () => syncIdentity()
+            );
+            toast.success(translate(currentLanguage, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
+          } catch (e: any) {
+            toast.error(e.message || translate(currentLanguage, 'editProfile.toasts.updateAvatarFailed') || 'Failed to update avatar');
+          }
+        },
+      },
+    });
+  }, [oxyServices, currentLanguage, activeSessionId, queryClient, syncIdentity]);
+
+  return { openAvatarPicker };
+}
+

package/src/ui/hooks/useIdentityTransfer.ts

@@ -0,0 +1,135 @@
+import { useCallback } from 'react';
+import { toast } from '../../lib/sonner';
+import { useTransferStore } from '../stores/transferStore';
+import type { IdentitySessionCore } from '../../core/identity-session';
+
+interface UseIdentityTransferOptions {
+  identityCore: IdentitySessionCore | null;
+  currentDeviceId: string | null;
+  activeSessionId: string | null;
+  getPublicKey: () => Promise<string | null>;
+  deleteIdentityAndClearAccount: (skipBackup?: boolean, force?: boolean, userConfirmed?: boolean) => Promise<void>;
+  logger: (message: string, err?: unknown) => void;
+}
+
+/**
+ * Hook to handle identity transfer completion
+ * This hook processes the identity_transfer_complete event and deletes the identity from the source device
+ */
+export function useIdentityTransfer({
+  identityCore,
+  currentDeviceId,
+  activeSessionId,
+  getPublicKey,
+  deleteIdentityAndClearAccount,
+  logger,
+}: UseIdentityTransferOptions) {
+  const getTransferCode = useTransferStore((state) => state.getTransferCode);
+  const clearTransferCode = useTransferStore((state) => state.clearTransferCode);
+  const updateTransferState = useTransferStore((state) => state.updateTransferState);
+
+  const handleIdentityTransferComplete = useCallback(
+    async (data: { transferId: string; sourceDeviceId: string; publicKey: string; transferCode?: string; completedAt: string }) => {
+      try {
+        logger('Received identity transfer complete notification', {
+          transferId: data.transferId,
+          sourceDeviceId: data.sourceDeviceId,
+          currentDeviceId,
+          hasActiveSession: activeSessionId !== null,
+          publicKey: data.publicKey.substring(0, 16) + '...',
+        });
+
+        const storedTransfer = getTransferCode(data.transferId);
+
+        if (!storedTransfer) {
+          logger('Transfer code not found for transferId', { transferId: data.transferId });
+          toast.error('Transfer verification failed: Code not found. Identity will not be deleted.');
+          return;
+        }
+
+        const currentPublicKey = await getPublicKey();
+        if (!currentPublicKey) {
+          logger('No public key found on device - cannot verify transfer', { transferId: data.transferId });
+          toast.error('Transfer verification failed: No identity found on device. Identity will not be deleted.');
+          return;
+        }
+
+        const isSourceDevice = currentPublicKey === storedTransfer.publicKey;
+        if (!isSourceDevice) {
+          logger('Current device public key does not match stored transfer public key - this is not the source device', {
+            transferId: data.transferId,
+            currentPublicKey: currentPublicKey.substring(0, 16) + '...',
+            storedPublicKey: storedTransfer.publicKey.substring(0, 16) + '...',
+          });
+          return;
+        }
+
+        const publicKeyMatches = data.publicKey === storedTransfer.publicKey;
+        if (!publicKeyMatches) {
+          logger('Public key mismatch for transfer', {
+            transferId: data.transferId,
+            receivedPublicKey: data.publicKey.substring(0, 16) + '...',
+            storedPublicKey: storedTransfer.publicKey.substring(0, 16) + '...',
+          });
+          toast.error('Transfer verification failed: Public key mismatch. Identity will not be deleted.');
+          return;
+        }
+
+        const transferAge = Date.now() - storedTransfer.timestamp;
+        const tenMinutes = 10 * 60 * 1000;
+        if (transferAge > tenMinutes) {
+          logger('Transfer confirmation received too late', {
+            transferId: data.transferId,
+            age: transferAge,
+            ageMinutes: Math.round(transferAge / 60000),
+          });
+          toast.error('Transfer verification failed: Confirmation received too late. Identity will not be deleted.');
+          clearTransferCode(data.transferId);
+          return;
+        }
+
+        logger('All transfer verifications passed, deleting identity from source device', {
+          transferId: data.transferId,
+          sourceDeviceId: data.sourceDeviceId,
+          publicKey: data.publicKey.substring(0, 16) + '...',
+        });
+
+        try {
+          const identityStillExists = identityCore ? await identityCore.hasIdentity() : false;
+          if (!identityStillExists) {
+            logger('Identity already deleted - skipping deletion', { transferId: data.transferId });
+            await updateTransferState(data.transferId, 'completed');
+            await clearTransferCode(data.transferId);
+            return;
+          }
+
+          await deleteIdentityAndClearAccount(false, false, true);
+          
+          const identityDeleted = identityCore ? !(await identityCore.hasIdentity()) : true;
+          if (!identityDeleted) {
+            logger('Identity deletion failed - identity still exists', { transferId: data.transferId });
+            await updateTransferState(data.transferId, 'failed');
+            throw new Error('Identity deletion failed - identity still exists');
+          }
+
+          await updateTransferState(data.transferId, 'completed');
+          await clearTransferCode(data.transferId);
+
+          logger('Identity successfully deleted and transfer code cleared', { transferId: data.transferId });
+          toast.success('Identity successfully transferred and removed from this device');
+        } catch (deleteError: any) {
+          logger('Error during identity deletion', deleteError);
+          await updateTransferState(data.transferId, 'failed');
+          throw deleteError;
+        }
+      } catch (error: any) {
+        logger('Failed to delete identity after transfer', error);
+        toast.error(error?.message || 'Failed to remove identity from this device. Please try again manually from Security Settings.');
+      }
+    },
+    [deleteIdentityAndClearAccount, logger, getTransferCode, clearTransferCode, updateTransferState, currentDeviceId, activeSessionId, getPublicKey, identityCore]
+  );
+
+  return { handleIdentityTransferComplete };
+}
+

package/src/ui/hooks/useTransferCodesPersistence.ts

@@ -0,0 +1,80 @@
+import { useEffect } from 'react';
+import { useStorage } from './useStorage';
+import { useTransferStore } from '../stores/transferStore';
+
+const TRANSFER_CODES_STORAGE_KEY = 'oxy_transfer_codes';
+const ACTIVE_TRANSFER_STORAGE_KEY = 'oxy_active_transfer_id';
+
+/**
+ * Hook to handle persistence of transfer codes to storage
+ * This hook automatically loads transfer codes on mount and persists them when they change
+ */
+export function useTransferCodesPersistence(storageKeyPrefix: string = 'oxy_session') {
+  const TRANSFER_CODES_KEY = `${storageKeyPrefix}_transfer_codes`;
+  const ACTIVE_TRANSFER_KEY = `${storageKeyPrefix}_active_transfer_id`;
+
+  const { storage, isReady: isStorageReady } = useStorage();
+  
+  const isRestored = useTransferStore((state) => state.isRestored);
+  const restoreFromStorage = useTransferStore((state) => state.restoreFromStorage);
+  const markRestored = useTransferStore((state) => state.markRestored);
+  const cleanupExpired = useTransferStore((state) => state.cleanupExpired);
+  const { transferCodes, activeTransferId } = useTransferStore((state) => ({
+    transferCodes: state.transferCodes,
+    activeTransferId: state.activeTransferId,
+  }));
+
+  // Load transfer codes from storage on startup (only once)
+  useEffect(() => {
+    if (!storage || !isStorageReady || isRestored) return;
+
+    const loadTransferCodes = async () => {
+      try {
+        const storedCodes = await storage.getItem(TRANSFER_CODES_KEY);
+        const storedActiveTransferId = await storage.getItem(ACTIVE_TRANSFER_KEY);
+        
+        const parsedCodes = storedCodes ? JSON.parse(storedCodes) : {};
+        const activeTransferId = storedActiveTransferId || null;
+        
+        restoreFromStorage(parsedCodes, activeTransferId);
+        markRestored();
+      } catch (error) {
+        // Mark as restored even on error to prevent retries
+        markRestored();
+      }
+    };
+
+    loadTransferCodes();
+  }, [storage, isStorageReady, isRestored, restoreFromStorage, markRestored, TRANSFER_CODES_KEY, ACTIVE_TRANSFER_KEY]);
+
+  // Persist transfer codes to storage whenever store changes
+  useEffect(() => {
+    if (!storage || !isStorageReady || !isRestored) return;
+
+    const persistTransferCodes = async () => {
+      try {
+        await storage.setItem(TRANSFER_CODES_KEY, JSON.stringify(transferCodes));
+        
+        if (activeTransferId) {
+          await storage.setItem(ACTIVE_TRANSFER_KEY, activeTransferId);
+        } else {
+          await storage.removeItem(ACTIVE_TRANSFER_KEY);
+        }
+      } catch (error) {
+        // Silently fail - persistence errors are not critical
+      }
+    };
+
+    persistTransferCodes();
+  }, [transferCodes, activeTransferId, storage, isStorageReady, isRestored, TRANSFER_CODES_KEY, ACTIVE_TRANSFER_KEY]);
+
+  // Cleanup expired transfer codes (every minute)
+  useEffect(() => {
+    const cleanup = setInterval(() => {
+      cleanupExpired();
+    }, 60000);
+
+    return () => clearInterval(cleanup);
+  }, [cleanupExpired]);
+}
+

package/src/ui/screens/AccountCenterScreen.tsx

@@ -86,9 +86,14 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
     return (
         <View style={[styles.container, { backgroundColor }]}>
             {/* Header with user profile */}
-            {user && (
+            {user && user.username && (
                 <ProfileCard
-                    user={user}
+                    user={{
+                        username: user.username,
+                        email: user.email,
+                        name: user.name,
+                        avatar: user.avatar,
+                    }}
                     theme={normalizedTheme}
                     onEditPress={() => navigate?.('EditProfile', { activeTab: 'profile' })}
                     onClosePress={onClose}

package/src/ui/screens/AccountSettingsScreen.tsx

@@ -229,7 +229,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                 setUsername(finalUser.username || '');
                 setEmail(finalUser.email || '');
                 setBio(finalUser.bio || '');
-                setLocation(finalUser.location || '');
+                setLocation(typeof finalUser.location === 'string' ? finalUser.location : '');
 
                 // Handle locations - convert single location to array format
                 if (finalUser.locations && Array.isArray(finalUser.locations)) {
@@ -239,7 +239,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                         label: loc.label,
                         coordinates: loc.coordinates
                     })));
-                } else if (finalUser.location) {
+                } else if (finalUser.location && typeof finalUser.location === 'string') {
                     // Convert single location string to array format
                     setLocations([{
                         id: 'existing-0',
@@ -256,11 +256,11 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                     setLinks(urls);
                     const metadataWithIds = finalUser.linksMetadata.map((link, index) => ({
                         ...link,
-                        id: link.id || `existing-${index}`
+                        id: (link as any).id || `existing-${index}`
                     }));
                     setLinksMetadata(metadataWithIds);
                 } else if (Array.isArray(finalUser.links)) {
-                    const simpleLinks = finalUser.links.map(l => typeof l === 'string' ? l : l.link).filter(Boolean);
+                    const simpleLinks = finalUser.links.map(l => typeof l === 'string' ? l : (l as any).link).filter(Boolean) as string[];
                     setLinks(simpleLinks);
                     const linksWithMetadata = simpleLinks.map((url, index) => ({
                         url,
@@ -270,7 +270,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                         id: `existing-${index}`
                     }));
                     setLinksMetadata(linksWithMetadata);
-                } else if (finalUser.website) {
+                } else if (finalUser.website && typeof finalUser.website === 'string') {
                     setLinks([finalUser.website]);
                     setLinksMetadata([{
                         url: finalUser.website,
@@ -388,7 +388,14 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                     setLocations(tempLocations);
                     break;
                 case 'links':
-                    await updateProfileMutation.mutateAsync({ linksMetadata: tempLinksWithMetadata });
+                    // 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 });
                     setLinksMetadata(tempLinksWithMetadata);
                     setLinks(tempLinksWithMetadata.map(l => l.url));
                     break;
@@ -542,7 +549,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
                     label: loc.label,
                     coordinates: loc.coordinates
                 })));
-            } else if (currentUser.location) {
+            } else if (currentUser.location && typeof currentUser.location === 'string') {
                 setLocations([{
                     id: 'existing-0',
                     name: currentUser.location,
@@ -555,7 +562,7 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
             if (currentUser.linksMetadata && Array.isArray(currentUser.linksMetadata)) {
                 setLinksMetadata(currentUser.linksMetadata.map((link, index) => ({
                     ...link,
-                    id: link.id || `existing-${index}`
+                    id: (link as any).id || `existing-${index}`
                 })));
             } else {
                 setLinksMetadata([]);

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)}
+                                                    onPress={() => handleRemoveSession(sessionWithUser.sessionId, displayName || 'this account')}
                                                     disabled={isSwitching || isRemoving}
                                                 >
                                                     {isRemoving ? (

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) {
+                } else if (profileRes.website && typeof profileRes.website === 'string') {
                     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>
-                        )}
-                        {profile?.location && (
+                        ) : null}
+                        {profile?.location && typeof profile.location === 'string' ? (
                             <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>
-                        )}
-                        {profile?.website && (
+                        ) : null}
+                        {profile?.website && typeof profile.website === 'string' ? (
                             <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>
-                        )}
-                        {profile && 'company' in profile && typeof profile.company === 'string' && profile.company && (
+                        ) : null}
+                        {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}</Text>
+                                <Text style={[styles.infoGridText, { color: colors.secondaryText }]} numberOfLines={1}>{profile.company as string}</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/utils/sessionHelpers.ts

@@ -10,6 +10,7 @@ interface DeviceSession {
   user?: { id?: string; _id?: { toString(): string } };
   userId?: string;
   isCurrent?: boolean;
+  deviceInfo?: import('../../core/identity-session/types').DeviceInfo;
 }
 
 export interface FetchSessionsWithFallbackOptions {
@@ -57,6 +58,12 @@ export const mapSessionsToClient = (
       fallbackUserId ||
       '',
     isCurrent: Boolean(session.isCurrent),
+    deviceInfo: session.deviceInfo || {
+      deviceName: '',
+      deviceType: 'unknown',
+      platform: 'unknown',
+      lastActive: session.lastActive || now.toISOString(),
+    },
   }));
 };
 

package/src/utils/index.ts

@@ -1,5 +1,4 @@
-export { DeviceManager } from './deviceManager';
-export type { DeviceFingerprint, StoredDeviceInfo } from './deviceManager';
+// DeviceManager removed - use IdentitySessionCore.getDeviceManager() instead
 
 // Request utilities
 export { RequestDeduplicator, RequestQueue, SimpleLogger } from './requestUtils';

package/src/utils/sessionUtils.ts

@@ -6,18 +6,26 @@
  */
 
 import type { ClientSession } from '../models/session';
+import type { DeviceInfo } from '../core/identity-session/types';
 
 /**
  * Normalize a session to ensure all required fields are present
  */
 export function normalizeSession(session: Partial<ClientSession> & { sessionId: string }): ClientSession {
   const now = new Date().toISOString();
+  const defaultDeviceInfo: DeviceInfo = {
+    deviceName: '',
+    deviceType: 'unknown',
+    platform: 'unknown',
+    lastActive: now,
+  };
   return {
     sessionId: session.sessionId,
     deviceId: session.deviceId || '',
     expiresAt: session.expiresAt || now,
     lastActive: session.lastActive || now,
     userId: session.userId || '',
+    deviceInfo: session.deviceInfo || defaultDeviceInfo,
   };
 }