@oxyhq/services 5.16.30 → 5.16.32

package/src/ui/context/OxyContext.tsx

@@ -222,7 +222,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         // CRITICAL: Invalidate cache on app startup to ensure fresh state check
         // This prevents stale cache from previous session from showing incorrect state
         KeyManager.invalidateCache();
-        
+
         // Check if identity exists and verify integrity
         const hasIdentity = await KeyManager.hasIdentity();
         if (hasIdentity) {
@@ -421,7 +421,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       if (pendingTransfers.length > 0) {
         const activeTransferId = getActiveTransferId();
         const hasActiveTransfer = activeTransferId && pendingTransfers.some((t: { transferId: string; data: any }) => t.transferId === activeTransferId);
-        
+
         if (hasActiveTransfer) {
           throw new Error(
             'Cannot delete identity: An active identity transfer is in progress. ' +
@@ -485,11 +485,11 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         if (wasOffline) {
           const now = Date.now();
           const timeSinceLastLog = now - lastReconnectionLog;
-          
+
           if (timeSinceLastLog >= RECONNECTION_LOG_DEBOUNCE_MS) {
             logger('Network reconnected, checking identity sync...');
             lastReconnectionLog = now;
-            
+
             // Sync identity first (if not synced)
             try {
               const hasIdentityValue = await hasIdentity();
@@ -520,7 +520,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
             // This is handled by useCheckPendingTransfers hook which runs automatically
             // when authenticated and online
           }
-          
+
           // TanStack Query will automatically retry pending mutations
           // Reset flag immediately after processing (whether logged or not)
           wasOffline = false;
@@ -580,6 +580,22 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     setTokenReady(false);
 
     try {
+      // CRITICAL: Get current local identity (publicKey) before restoring sessions
+      // Sessions must belong to the current local identity stored in Accounts app
+      let currentPublicKey: string | null = null;
+      try {
+        if (Platform.OS !== 'web') {
+          // Only check identity on native platforms (web doesn't have local identity)
+          // KeyManager is already imported at the top of the file
+          currentPublicKey = await KeyManager.getPublicKey();
+        }
+      } catch (identityError) {
+        if (__DEV__) {
+          logger('Failed to get current local identity during session restoration', identityError);
+        }
+        // Continue without identity check if it fails (e.g., on web platform)
+      }
+
       const storedSessionIdsJson = await storage.getItem(storageKeys.sessionIds);
       const storedSessionIds: string[] = storedSessionIdsJson ? JSON.parse(storedSessionIdsJson) : [];
       const storedActiveSessionId = await storage.getItem(storageKeys.activeSessionId);
@@ -592,12 +608,25 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
             const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
             if (validation?.valid && validation.user) {
               const now = new Date();
+              // user.id is now publicKey (canonical identity)
+              const sessionPublicKey = validation.user.publicKey || validation.user.id || '';
+
+              // IDENTITY BINDING: Only restore sessions that match current local identity
+              // If we have a current local identity, filter out sessions that don't match
+              if (currentPublicKey && sessionPublicKey !== currentPublicKey) {
+                if (__DEV__) {
+                  logger(`Skipping session ${sessionId.substring(0, 8)}... - belongs to different identity (${sessionPublicKey.substring(0, 16)}... vs ${currentPublicKey.substring(0, 16)}...)`);
+                }
+                continue; // Skip this session - it belongs to a different identity
+              }
+
               validSessions.push({
                 sessionId,
                 deviceId: '',
                 expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
                 lastActive: now.toISOString(),
-                userId: validation.user.id?.toString() ?? '',
+                publicKey: sessionPublicKey, // Canonical user identity
+                userId: validation.user.id?.toString(), // Optional MongoDB ObjectId for backward compatibility
                 isCurrent: sessionId === storedActiveSessionId,
               });
             }
@@ -615,6 +644,13 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
         if (validSessions.length > 0) {
           updateSessions(validSessions, { merge: false });
+        } else if (currentPublicKey && storedSessionIds.length > 0) {
+          // All sessions were filtered out due to identity mismatch - clear stored sessions
+          if (__DEV__) {
+            logger('All stored sessions belong to different identity - clearing session storage');
+          }
+          await storage.removeItem(storageKeys.sessionIds);
+          await storage.removeItem(storageKeys.activeSessionId);
         }
       }
 
@@ -726,9 +762,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     return isAuthenticatedFromStore || isAuthenticatedFromSessions;
   }, [isAuthenticatedFromStore, isAuthenticatedFromSessions]);
 
-  // Get userId from JWT token (MongoDB ObjectId) for socket room matching
-  // user.id is set to publicKey for compatibility, but socket rooms use MongoDB ObjectId
-  // The JWT token's userId field contains the MongoDB ObjectId
+  // Get userId from JWT token for socket room matching
+  // Note: JWT token may contain MongoDB ObjectId internally, but user.id is publicKey (canonical identity)
+  // Socket rooms may need internal mapping from publicKey to MongoDB ObjectId if backend requires it
   const userId = oxyServices.getCurrentUserId() || user?.id;
 
   // Use Zustand store for transfer state management
@@ -748,16 +784,16 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         // Load transfer codes
         const storedCodes = await storage.getItem(TRANSFER_CODES_STORAGE_KEY);
         const storedActiveTransferId = await storage.getItem(ACTIVE_TRANSFER_STORAGE_KEY);
-        
+
         const parsedCodes = storedCodes ? JSON.parse(storedCodes) : {};
         const activeTransferId = storedActiveTransferId || null;
-        
+
         // Restore to Zustand store (store handles validation and expiration)
         restoreFromStorage(parsedCodes, activeTransferId);
         markRestored();
-        
+
         if (__DEV__ && Object.keys(parsedCodes).length > 0) {
-          logger('Restored transfer codes from storage', { 
+          logger('Restored transfer codes from storage', {
             count: Object.keys(parsedCodes).length,
             hasActiveTransfer: !!activeTransferId,
           });
@@ -782,7 +818,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     const persistTransferCodes = async () => {
       try {
         await storage.setItem(TRANSFER_CODES_STORAGE_KEY, JSON.stringify(transferCodes));
-        
+
         if (activeTransferId) {
           await storage.setItem(ACTIVE_TRANSFER_STORAGE_KEY, activeTransferId);
         } else {
@@ -810,7 +846,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   // Transfer code management functions using Zustand store
   const storeTransferCode = useCallback(async (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => {
     storeTransferCodeStore(transferId, code, sourceDeviceId, publicKey);
-    
+
     if (__DEV__) {
       logger('Stored transfer code', { transferId, sourceDeviceId, publicKey: publicKey.substring(0, 16) + '...' });
     }
@@ -822,7 +858,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const updateTransferState = useCallback(async (transferId: string, state: 'pending' | 'completed' | 'failed') => {
     updateTransferStateStore(transferId, state);
-    
+
     if (__DEV__) {
       logger('Updated transfer state', { transferId, state });
     }
@@ -830,7 +866,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const clearTransferCode = useCallback(async (transferId: string) => {
     clearTransferCodeStore(transferId);
-    
+
     if (__DEV__) {
       logger('Cleared transfer code', { transferId });
     }
@@ -872,7 +908,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         const storedTransfer = getTransferCode(data.transferId);
 
         if (!storedTransfer) {
-          logger('Transfer code not found for transferId', { 
+          logger('Transfer code not found for transferId', {
             transferId: data.transferId,
           });
           toast.error('Transfer verification failed: Code not found. Identity will not be deleted.');
@@ -894,7 +930,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         // Verify deviceId matches - very lenient since publicKey is the critical check
         // If publicKey matches, we allow deletion even if deviceId doesn't match exactly
         // This handles cases where deviceId might not be available or slightly different
-        const deviceIdMatches = 
+        const deviceIdMatches =
           // Exact match
           (data.sourceDeviceId && data.sourceDeviceId === currentDeviceId) ||
           // Stored sourceDeviceId matches current deviceId
@@ -974,7 +1010,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
           }
 
           await deleteIdentityAndClearAccount(false, false, true);
-          
+
           // Verify identity was actually deleted
           const identityDeleted = !(await KeyManager.hasIdentity());
           if (!identityDeleted) {

package/src/ui/context/hooks/useAuthOperations.ts

@@ -146,9 +146,9 @@ export const useAuthOperations = ({
         const localDeviceId = `device_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(); // 7 days
 
-        // Create minimal user object with publicKey as id
+        // Create minimal user object with publicKey as id (canonical identity)
         fullUser = {
-          id: publicKey, // Use publicKey as id (per migration document)
+          id: publicKey, // publicKey is the canonical user identity
           publicKey,
           username: '',
           privacySettings: {},
@@ -170,7 +170,7 @@ export const useAuthOperations = ({
           deviceId: localDeviceId,
           expiresAt,
           lastActive: new Date().toISOString(),
-          userId: publicKey,
+          publicKey, // Canonical user identity
           isCurrent: true,
         };
 
@@ -204,17 +204,10 @@ export const useAuthOperations = ({
         // Get full user data
         fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
         
-        // IMPORTANT: user.id should be MongoDB ObjectId, not publicKey
-        // The API should return the correct id (ObjectId) from the database
-        // If it doesn't, we need to fix the API, not work around it here
-        // Validate that id is ObjectId format (24 hex characters)
-        if (fullUser.id && !/^[0-9a-fA-F]{24}$/.test(fullUser.id)) {
-          console.warn('[useAuthOperations] User.id is not MongoDB ObjectId format:', {
-            id: fullUser.id.substring(0, 20),
-            publicKey: fullUser.publicKey.substring(0, 20),
-            message: 'API should return MongoDB ObjectId as user.id, not publicKey'
-          });
-          // Don't override - let the API fix this issue
+        // user.id is now publicKey (canonical identity) - this is correct
+        // Ensure publicKey field is set for consistency
+        if (!fullUser.publicKey && fullUser.id) {
+          fullUser.publicKey = fullUser.id;
         }
 
         // Fetch device sessions
@@ -222,7 +215,8 @@ export const useAuthOperations = ({
         try {
           allDeviceSessions = await fetchSessionsWithFallback(oxyServices, sessionResponse.sessionId, {
             fallbackDeviceId: sessionResponse.deviceId,
-            fallbackUserId: fullUser.id,
+            fallbackUserId: fullUser.id, // Still pass for backward compatibility
+            fallbackPublicKey: fullUser.publicKey || fullUser.id, // publicKey is canonical identity
             logger,
           });
         } catch (error) {
@@ -292,6 +286,13 @@ export const useAuthOperations = ({
       setAuthState({ isLoading: true, error: null });
 
       try {
+        // SESSION CLEANUP: Clear all sessions before creating new identity
+        // New identity means old sessions are no longer valid
+        await clearSessionState();
+        if (__DEV__ && logger) {
+          logger('Cleared all sessions before creating new identity');
+        }
+
         // Generate new key pair directly (works offline)
         const { publicKey, privateKey } = await KeyManager.generateKeyPair();
         await KeyManager.importKeyPair(privateKey);
@@ -463,6 +464,13 @@ export const useAuthOperations = ({
       setAuthState({ isLoading: true, error: null });
 
       try {
+        // SESSION CLEANUP: Clear all sessions before importing new identity
+        // Importing a different identity means old sessions are no longer valid
+        await clearSessionState();
+        if (__DEV__ && logger) {
+          logger('Cleared all sessions before importing identity');
+        }
+
         // Decrypt private key from backup data
         const Crypto = await import('expo-crypto');
         

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

@@ -4,3 +4,4 @@
 export { useUsernameValidation, USERNAME_MIN_LENGTH, USERNAME_REGEX, USERNAME_FORMAT_ERROR, USERNAME_DEBOUNCE_MS } from './useUsernameValidation';
 export type { UsernameValidationResult } from './useUsernameValidation';
 
+

package/src/ui/hooks/queries/useServicesQueries.ts

@@ -8,7 +8,7 @@ import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sess
  * Get all active sessions for the current user
  */
 export const useSessions = (userId?: string, options?: { enabled?: boolean }) => {
-  const { oxyServices, activeSessionId } = useOxy();
+  const { oxyServices, activeSessionId, user } = useOxy();
 
   return useQuery({
     queryKey: queryKeys.sessions.list(userId),
@@ -17,12 +17,14 @@ export const useSessions = (userId?: string, options?: { enabled?: boolean }) =>
         throw new Error('No active session');
       }
       
+      const publicKey = user?.publicKey || user?.id || ''; // user.id is now publicKey
       const sessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
         fallbackDeviceId: undefined,
         fallbackUserId: userId,
+        fallbackPublicKey: publicKey,
       });
       
-      return mapSessionsToClient(sessions, activeSessionId);
+      return sessions; // Already mapped by fetchSessionsWithFallback
     },
     enabled: (options?.enabled !== false) && !!activeSessionId,
     staleTime: 2 * 60 * 1000, // 2 minutes (sessions change frequently)
@@ -49,12 +51,15 @@ export const useSession = (sessionId: string | null, options?: { enabled?: boole
       }
 
       const now = new Date();
+      // user.id is now publicKey (canonical identity)
+      const publicKey = validation.user.publicKey || validation.user.id || '';
       return {
         sessionId,
         deviceId: '', // Device ID not available from validation response
         expiresAt: validation.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
         lastActive: validation.lastActivity || now.toISOString(),
-        userId: validation.user.id?.toString() ?? '',
+        publicKey, // Canonical user identity
+        userId: validation.user.id?.toString(), // Optional MongoDB ObjectId
         isCurrent: false,
       } as ClientSession;
     },

package/src/ui/hooks/useSessionManagement.ts

@@ -255,8 +255,10 @@ export const useSessionManagement = ({
         await activateSession(sessionId, user);
 
         try {
+          const publicKey = user.publicKey || user.id || ''; // user.id is now publicKey
           const deviceSessions = await fetchSessionsWithFallback(oxyServices, sessionId, {
-            fallbackUserId: user.id,
+            fallbackUserId: user.id, // Still pass for backward compatibility
+            fallbackPublicKey: publicKey,
             logger,
           });
           updateSessions(deviceSessions, { merge: true });
@@ -330,8 +332,13 @@ export const useSessionManagement = ({
 
       const refreshPromise = (async () => {
         try {
+          // Get publicKey from active session or current user
+          const activeSession = sessions.find(s => s.sessionId === activeSessionId);
+          const publicKey = activeSession?.publicKey || activeUserId || ''; // Fallback to userId if publicKey not available
+          
           const deviceSessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
             fallbackUserId: activeUserId,
+            fallbackPublicKey: publicKey,
             logger,
           });
           updateSessions(deviceSessions, { merge: true });

package/src/ui/utils/sessionHelpers.ts

@@ -7,14 +7,16 @@ interface DeviceSession {
   deviceName?: string;
   expiresAt?: string;
   lastActive?: string;
-  user?: { id?: string; _id?: { toString(): string } };
+  user?: { id?: string; publicKey?: string; _id?: { toString(): string } };
   userId?: string;
+  publicKey?: string;
   isCurrent?: boolean;
 }
 
 export interface FetchSessionsWithFallbackOptions {
   fallbackDeviceId?: string;
   fallbackUserId?: string;
+  fallbackPublicKey?: string; // Canonical user identity
   logger?: (message: string, error?: unknown) => void;
 }
 
@@ -37,27 +39,41 @@ export interface SessionValidationResult {
  * @param sessions - Raw session array returned from the API
  * @param fallbackDeviceId - Device identifier to use when missing from payload
  * @param fallbackUserId - User identifier to use when missing from payload
+ * @param fallbackPublicKey - Public key to use when missing from payload (canonical identity)
  */
 export const mapSessionsToClient = (
   sessions: DeviceSession[],
   fallbackDeviceId?: string,
   fallbackUserId?: string,
+  fallbackPublicKey?: string,
 ): ClientSession[] => {
   const now = new Date();
 
-  return sessions.map((session) => ({
-    sessionId: session.sessionId,
-    deviceId: session.deviceId || fallbackDeviceId || '',
-    expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-    lastActive: session.lastActive || now.toISOString(),
-    userId:
-      session.user?.id ||
+  return sessions.map((session) => {
+    // publicKey is the canonical user identity (user.id now equals publicKey)
+    // Extract from user.id (which is now publicKey), user.publicKey, or session.publicKey
+    const publicKey =
+      session.user?.id || // user.id is now publicKey (canonical identifier)
+      session.user?.publicKey ||
+      session.publicKey ||
+      fallbackPublicKey ||
+      '';
+
+    // userId is MongoDB ObjectId (internal backend reference, optional)
+    const userId =
       session.userId ||
-      (session.user?._id ? session.user._id.toString() : undefined) ||
-      fallbackUserId ||
-      '',
-    isCurrent: Boolean(session.isCurrent),
-  }));
+      (session.user?._id ? session.user._id.toString() : undefined);
+
+    return {
+      sessionId: session.sessionId,
+      deviceId: session.deviceId || fallbackDeviceId || '',
+      expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+      lastActive: session.lastActive || now.toISOString(),
+      publicKey, // Canonical user identity - REQUIRED
+      userId, // MongoDB ObjectId (optional, for backward compatibility)
+      isCurrent: Boolean(session.isCurrent),
+    };
+  });
 };
 
 /**
@@ -73,19 +89,20 @@ export const fetchSessionsWithFallback = async (
   {
     fallbackDeviceId,
     fallbackUserId,
+    fallbackPublicKey,
     logger,
   }: FetchSessionsWithFallbackOptions = {},
 ): Promise<ClientSession[]> => {
   try {
     const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
-    return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId);
+    return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId, fallbackPublicKey);
   } catch (error) {
     if (__DEV__ && logger) {
       logger('Failed to get device sessions, falling back to user sessions', error);
     }
 
     const userSessions = await oxyServices.getSessionsBySessionId(sessionId);
-    return mapSessionsToClient(userSessions, fallbackDeviceId, fallbackUserId);
+    return mapSessionsToClient(userSessions, fallbackDeviceId, fallbackUserId, fallbackPublicKey);
   }
 };
 

package/src/utils/sessionUtils.ts

@@ -12,12 +12,19 @@ import type { ClientSession } from '../models/session';
  */
 export function normalizeSession(session: Partial<ClientSession> & { sessionId: string }): ClientSession {
   const now = new Date().toISOString();
+  
+  // publicKey is required (canonical user identity)
+  if (!session.publicKey) {
+    throw new Error(`Session ${session.sessionId} is missing required publicKey field`);
+  }
+  
   return {
     sessionId: session.sessionId,
     deviceId: session.deviceId || '',
     expiresAt: session.expiresAt || now,
     lastActive: session.lastActive || now,
-    userId: session.userId || '',
+    publicKey: session.publicKey, // Canonical user identity - required
+    userId: session.userId, // Optional MongoDB ObjectId for backward compatibility
   };
 }