@oxyhq/services 5.16.21 → 5.16.23

package/src/core/services/TokenService.ts

@@ -0,0 +1,226 @@
+/**
+ * TokenService - Single Source of Truth for Token Management
+ * 
+ * Handles all token storage, retrieval, refresh, and validation.
+ * Used by HttpService, SocketService, and other services that need tokens.
+ * 
+ * Architecture:
+ * - Single storage location (no duplication)
+ * - Automatic token refresh when expiring soon
+ * - Type-safe token payload handling
+ * - userId is always MongoDB ObjectId, never publicKey
+ */
+
+import { jwtDecode } from 'jwt-decode';
+
+/**
+ * AccessTokenPayload - Matches the token payload structure from API
+ * userId is always MongoDB ObjectId (24 hex characters), never publicKey
+ */
+interface AccessTokenPayload {
+  userId: string;      // MongoDB ObjectId - PRIMARY IDENTIFIER
+  sessionId: string;   // Session UUID
+  deviceId: string;   // Device identifier
+  type: 'access';
+  iat?: number;        // Issued at (added by JWT)
+  exp?: number;        // Expiration (added by JWT)
+}
+
+interface TokenStore {
+  accessToken: string | null;
+  refreshToken: string | null;
+}
+
+/**
+ * TokenService - Singleton pattern for global token management
+ */
+class TokenService {
+  private static instance: TokenService;
+  private tokenStore: TokenStore = {
+    accessToken: null,
+    refreshToken: null,
+  };
+  private refreshPromise: Promise<void> | null = null;
+  private baseURL: string | null = null;
+
+  private constructor() {}
+
+  static getInstance(): TokenService {
+    if (!TokenService.instance) {
+      TokenService.instance = new TokenService();
+    }
+    return TokenService.instance;
+  }
+
+  /**
+   * Initialize TokenService with base URL for refresh requests
+   */
+  initialize(baseURL: string): void {
+    this.baseURL = baseURL;
+  }
+
+  /**
+   * Get current access token
+   */
+  getAccessToken(): string | null {
+    return this.tokenStore.accessToken;
+  }
+
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken(): string | null {
+    return this.tokenStore.refreshToken;
+  }
+
+  /**
+   * Set tokens (called after login or token refresh)
+   */
+  setTokens(accessToken: string, refreshToken: string = ''): void {
+    this.tokenStore.accessToken = accessToken;
+    this.tokenStore.refreshToken = refreshToken || this.tokenStore.refreshToken;
+  }
+
+  /**
+   * Clear all tokens (called on logout)
+   */
+  clearTokens(): void {
+    this.tokenStore.accessToken = null;
+    this.tokenStore.refreshToken = null;
+    this.refreshPromise = null;
+  }
+
+  /**
+   * Check if access token exists
+   */
+  hasAccessToken(): boolean {
+    return !!this.tokenStore.accessToken;
+  }
+
+  /**
+   * Check if token is expiring soon (within 60 seconds)
+   */
+  isTokenExpiringSoon(): boolean {
+    const token = this.tokenStore.accessToken;
+    if (!token) return false;
+
+    try {
+      const decoded = jwtDecode<AccessTokenPayload>(token);
+      if (!decoded.exp) return false;
+
+      const currentTime = Math.floor(Date.now() / 1000);
+      return decoded.exp - currentTime < 60; // Expiring within 60 seconds
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get userId from current access token
+   * Returns MongoDB ObjectId (never publicKey)
+   */
+  getUserIdFromToken(): string | null {
+    const token = this.tokenStore.accessToken;
+    if (!token) return null;
+
+    try {
+      const decoded = jwtDecode<AccessTokenPayload>(token);
+      return decoded.userId || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Refresh access token if expiring soon
+   * Returns promise that resolves when token is refreshed (or already valid)
+   */
+  async refreshTokenIfNeeded(): Promise<void> {
+    // If already refreshing, wait for that promise
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+
+    // If token not expiring soon, no refresh needed
+    if (!this.isTokenExpiringSoon()) {
+      return;
+    }
+
+    // Start refresh
+    this.refreshPromise = this._performRefresh();
+    
+    try {
+      await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+
+  /**
+   * Perform token refresh
+   */
+  private async _performRefresh(): Promise<void> {
+    const token = this.tokenStore.accessToken;
+    if (!token) {
+      throw new Error('No access token to refresh');
+    }
+
+    try {
+      const decoded = jwtDecode<AccessTokenPayload>(token);
+      if (!decoded.sessionId) {
+        throw new Error('Token missing sessionId');
+      }
+
+      if (!this.baseURL) {
+        throw new Error('TokenService not initialized with baseURL');
+      }
+
+      const refreshUrl = `${this.baseURL}/api/session/token/${decoded.sessionId}`;
+      
+      const response = await fetch(refreshUrl, {
+        method: 'GET',
+        headers: { 'Accept': 'application/json' },
+        signal: AbortSignal.timeout(5000),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Token refresh failed: ${response.status}`);
+      }
+
+      const { accessToken: newToken } = await response.json();
+      
+      if (!newToken) {
+        throw new Error('No access token in refresh response');
+      }
+
+      // Validate new token has correct userId format (ObjectId)
+      const newDecoded = jwtDecode<AccessTokenPayload>(newToken);
+      if (newDecoded.userId && !/^[0-9a-fA-F]{24}$/.test(newDecoded.userId)) {
+        throw new Error(`Invalid userId format in refreshed token: ${newDecoded.userId.substring(0, 20)}...`);
+      }
+
+      this.setTokens(newToken);
+    } catch (error) {
+      // Clear tokens on refresh failure (likely expired or invalid)
+      this.clearTokens();
+      throw error;
+    }
+  }
+
+  /**
+   * Get authorization header with automatic refresh
+   */
+  async getAuthHeader(): Promise<string | null> {
+    // Refresh if needed
+    await this.refreshTokenIfNeeded().catch(() => {
+      // Ignore refresh errors, will use current token or return null
+    });
+
+    const token = this.tokenStore.accessToken;
+    return token ? `Bearer ${token}` : null;
+  }
+}
+
+// Export singleton instance
+export const tokenService = TokenService.getInstance();
+

package/src/models/interfaces.ts

@@ -21,9 +21,23 @@ export interface OxyConfig {
   onRequestError?: (url: string, method: string, error: Error) => void;
 }
 
+/**
+ * User Model
+ * 
+ * IMPORTANT: 
+ * - id: MongoDB ObjectId (24 hex characters) - PRIMARY IDENTIFIER for all internal operations
+ * - publicKey: Cryptographic public key (130 hex characters) - LOOKUP KEY for authentication and identity operations
+ * 
+ * Never use publicKey as an ID. Always use id (ObjectId) for:
+ * - Database queries
+ * - Session userId
+ * - Token userId
+ * - Socket room names
+ * - API route parameters (unless explicitly doing publicKey lookup)
+ */
 export interface User {
-  id: string;
-  publicKey: string;
+  id: string;           // MongoDB ObjectId - PRIMARY IDENTIFIER (always 24 hex chars)
+  publicKey: string;    // Cryptographic public key - LOOKUP KEY (130 hex chars for secp256k1)
   username: string;
   email?: string;
   // Avatar file id (asset id)

package/src/models/session.ts

@@ -1,9 +1,16 @@
+/**
+ * Client Session Model
+ * 
+ * IMPORTANT:
+ * - userId: MongoDB ObjectId (24 hex characters), never publicKey
+ * - Used for session management and user identification
+ */
 export interface ClientSession {
   sessionId: string;
   deviceId: string;
   expiresAt: string;
   lastActive: string;
-  userId?: string;
+  userId?: string;  // MongoDB ObjectId - PRIMARY IDENTIFIER (never publicKey)
   isCurrent?: boolean;
 }
 

package/src/ui/context/OxyContext.tsx

@@ -9,7 +9,7 @@ import {
   useState,
   type ReactNode,
 } from 'react';
-import { Platform, Alert } from 'react-native';
+import { Platform } from 'react-native';
 import { OxyServices } from '../../core';
 import type { User, ApiError } from '../../models/interfaces';
 import type { ClientSession } from '../../models/session';
@@ -59,6 +59,9 @@ export interface OxyContextState {
   isIdentitySynced: () => Promise<boolean>;
   syncIdentity: () => Promise<User>;
   deleteIdentityAndClearAccount: (skipBackup?: boolean, force?: boolean, userConfirmed?: boolean) => Promise<void>;
+  storeTransferCode: (transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => void;
+  getTransferCode: (transferId: string) => { code: string; sourceDeviceId: string | null; publicKey: string; timestamp: number } | null;
+  clearTransferCode: (transferId: string) => void;
 
   // Identity sync state (reactive, from Zustand store)
   identitySyncState: {
@@ -613,7 +616,56 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     : undefined;
   const currentDeviceId = activeSession?.deviceId ?? null;
 
-  const userId = user?.id;
+  // 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
+  const userId = oxyServices.getCurrentUserId() || user?.id;
+
+  // Store transfer codes in memory for verification
+  // Map: transferId -> { code, sourceDeviceId, publicKey, timestamp }
+  const transferCodesRef = useRef<Map<string, { code: string; sourceDeviceId: string | null; publicKey: string; timestamp: number }>>(new Map());
+
+  // Cleanup old transfer codes (older than 15 minutes)
+  useEffect(() => {
+    const cleanup = setInterval(() => {
+      const now = Date.now();
+      const fifteenMinutes = 15 * 60 * 1000;
+      transferCodesRef.current.forEach((value, key) => {
+        if (now - value.timestamp > fifteenMinutes) {
+          transferCodesRef.current.delete(key);
+          if (__DEV__) {
+            logger('Cleaned up expired transfer code', { transferId: key });
+          }
+        }
+      });
+    }, 60000); // Check every minute
+
+    return () => clearInterval(cleanup);
+  }, [logger]);
+
+  // Transfer code management functions
+  const storeTransferCode = useCallback((transferId: string, code: string, sourceDeviceId: string | null, publicKey: string) => {
+    transferCodesRef.current.set(transferId, {
+      code,
+      sourceDeviceId,
+      publicKey,
+      timestamp: Date.now(),
+    });
+    if (__DEV__) {
+      logger('Stored transfer code', { transferId, sourceDeviceId, publicKey: publicKey.substring(0, 16) + '...' });
+    }
+  }, [logger]);
+
+  const getTransferCode = useCallback((transferId: string) => {
+    return transferCodesRef.current.get(transferId) || null;
+  }, []);
+
+  const clearTransferCode = useCallback((transferId: string) => {
+    transferCodesRef.current.delete(transferId);
+    if (__DEV__) {
+      logger('Cleared transfer code', { transferId });
+    }
+  }, [logger]);
 
   const refreshSessionsWithUser = useCallback(
     () => refreshSessions(userId),
@@ -633,40 +685,171 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   }, [logger, logout]);
 
   const handleIdentityTransferComplete = useCallback(
-    async (data: { transferId: string; sourceDeviceId: string; publicKey: string; completedAt: string }) => {
-      // Show confirmation dialog asking if user wants to delete identity from this device
-      return new Promise<void>((resolve) => {
-        Alert.alert(
-          'Identity Transfer Complete',
-          'Your identity has been successfully transferred to another device. Would you like to remove it from this device?',
-          [
-            {
-              text: 'Keep on This Device',
-              style: 'cancel',
-              onPress: () => resolve(),
-            },
-            {
-              text: 'Remove from This Device',
-              style: 'destructive',
-              onPress: async () => {
-                try {
-                  // Delete identity with user confirmation
-                  await deleteIdentityAndClearAccount(false, false, true);
-                  toast.success('Identity removed from this device');
-                } catch (error: any) {
-                  logger('Failed to delete identity after transfer', error);
-                  toast.error(error?.message || 'Failed to remove identity from this device');
-                } finally {
-                  resolve();
-                }
-              },
-            },
-          ],
-          { cancelable: true, onDismiss: () => resolve() }
-        );
-      });
+    async (data: { transferId: string; sourceDeviceId: string; publicKey: string; transferCode?: string; completedAt: string }) => {
+      if (__DEV__) {
+        console.log('[OxyContext] handleIdentityTransferComplete called', {
+          transferId: data.transferId,
+          sourceDeviceId: data.sourceDeviceId,
+          currentDeviceId,
+          hasActiveSession: activeSessionId !== null,
+        });
+      }
+      
+      try {
+        logger('Received identity transfer complete notification', {
+          transferId: data.transferId,
+          sourceDeviceId: data.sourceDeviceId,
+          currentDeviceId,
+          hasActiveSession: activeSessionId !== null,
+          publicKey: data.publicKey.substring(0, 16) + '...',
+        });
+
+        // Get stored transfer code for verification
+        const storedTransfer = getTransferCode(data.transferId);
+
+        if (!storedTransfer) {
+          if (__DEV__) {
+            console.warn('[OxyContext] Transfer code not found for transferId', {
+              transferId: data.transferId,
+            });
+          }
+          logger('Transfer code not found for transferId', { 
+            transferId: data.transferId,
+          });
+          toast.error('Transfer verification failed: Code not found. Identity will not be deleted.');
+          return;
+        }
+
+        if (__DEV__) {
+          console.log('[OxyContext] Found stored transfer code', {
+            transferId: data.transferId,
+            storedSourceDeviceId: storedTransfer.sourceDeviceId,
+            receivedSourceDeviceId: data.sourceDeviceId,
+            currentDeviceId,
+          });
+        }
+
+        // Verify publicKey matches first (most important check)
+        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;
+        }
+
+        // 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 = 
+          // Exact match
+          (data.sourceDeviceId && data.sourceDeviceId === currentDeviceId) ||
+          // Stored sourceDeviceId matches current deviceId
+          (storedTransfer.sourceDeviceId && storedTransfer.sourceDeviceId === currentDeviceId);
+
+        // If publicKey matches, we're very lenient with deviceId - only warn but don't block
+        if (!deviceIdMatches && publicKeyMatches) {
+          logger('Device ID mismatch for transfer, but publicKey matches - proceeding with deletion', {
+            transferId: data.transferId,
+            receivedDeviceId: data.sourceDeviceId,
+            storedDeviceId: storedTransfer.sourceDeviceId,
+            currentDeviceId,
+            hasActiveSession: activeSessionId !== null,
+          });
+          // Proceed with deletion - publicKey match is the critical verification
+        } else if (!deviceIdMatches && !publicKeyMatches) {
+          // Both don't match - this is suspicious, block deletion
+          logger('Device ID and publicKey mismatch for transfer', {
+            transferId: data.transferId,
+            receivedDeviceId: data.sourceDeviceId,
+            currentDeviceId,
+          });
+          toast.error('Transfer verification failed: Device and key mismatch. Identity will not be deleted.');
+          return;
+        }
+
+        // Verify transfer code matches (if provided)
+        // Transfer code is optional - if not provided, we still proceed if publicKey matches
+        if (data.transferCode) {
+          const codeMatches = data.transferCode.toUpperCase() === storedTransfer.code.toUpperCase();
+          if (!codeMatches) {
+            logger('Transfer code mismatch, but publicKey matches - proceeding with deletion', {
+              transferId: data.transferId,
+              receivedCode: data.transferCode,
+              storedCode: storedTransfer.code.substring(0, 2) + '****',
+            });
+            // Don't block - publicKey match is sufficient, code mismatch might be due to user error
+            // Log warning but proceed
+          }
+        } else {
+          // If transfer code is not provided, log info but proceed
+          if (__DEV__) {
+            logger('Transfer code not provided in completion notification, but publicKey matches - proceeding', { 
+              transferId: data.transferId 
+            });
+          }
+        }
+
+        // Check if transfer is too old (safety timeout - 10 minutes)
+        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;
+        }
+
+        // All verifications passed - automatically delete identity
+        if (__DEV__) {
+          console.log('[OxyContext] All verifications passed, deleting identity', {
+            transferId: data.transferId,
+            sourceDeviceId: data.sourceDeviceId,
+            currentDeviceId,
+          });
+        }
+        
+        logger('All transfer verifications passed, deleting identity from source device', {
+          transferId: data.transferId,
+          sourceDeviceId: data.sourceDeviceId,
+          publicKey: data.publicKey.substring(0, 16) + '...',
+        });
+
+        try {
+          await deleteIdentityAndClearAccount(false, false, true);
+          
+          if (__DEV__) {
+            console.log('[OxyContext] Identity deleted successfully');
+          }
+
+          // Clear the transfer code after successful deletion
+          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) {
+          if (__DEV__) {
+            console.error('[OxyContext] Error deleting identity', deleteError);
+          }
+          logger('Error during identity deletion', deleteError);
+          throw deleteError; // Re-throw to be caught by outer catch
+        }
+      } 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]
+    [deleteIdentityAndClearAccount, logger, getTransferCode, clearTransferCode, currentDeviceId, activeSessionId],
   );
 
   useSessionSocket({
@@ -677,6 +860,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     logout,
     clearSessionState,
     baseURL: oxyServices.getBaseURL(),
+    getAccessToken: () => oxyServices.getAccessToken(),
     onRemoteSignOut: handleRemoteSignOut,
     onSessionRemoved: handleSessionRemoved,
     onIdentityTransferComplete: handleIdentityTransferComplete,
@@ -755,6 +939,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     isIdentitySynced,
     syncIdentity,
     deleteIdentityAndClearAccount,
+    storeTransferCode,
+    getTransferCode,
+    clearTransferCode,
     identitySyncState: {
       isSynced: isIdentitySyncedStore ?? true,
       isSyncing: isSyncing ?? false,
@@ -785,6 +972,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     isIdentitySynced,
     syncIdentity,
     deleteIdentityAndClearAccount,
+    storeTransferCode,
+    getTransferCode,
+    clearTransferCode,
     isIdentitySyncedStore,
     isSyncing,
     currentLanguage,

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

@@ -204,9 +204,17 @@ export const useAuthOperations = ({
         // Get full user data
         fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
         
-        // Ensure id is set to publicKey (per migration document)
-        if (fullUser.id !== fullUser.publicKey) {
-          fullUser.id = fullUser.publicKey;
+        // 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
         }
 
         // Fetch device sessions