@oxyhq/services 5.16.4 → 5.16.8

package/src/ui/context/OxyContext.tsx

@@ -30,6 +30,9 @@ import { useQueryClient } from '@tanstack/react-query';
 import { clearQueryCache } from '../hooks/queryClient';
 import { useAccountStore } from '../stores/accountStore';
 import { KeyManager } from '../../crypto/keyManager';
+import { translate } from '../../i18n';
+import { queryKeys } from '../hooks/queries/queryKeys';
+import { useUpdateProfile } from '../hooks/mutations/useAccountMutations';
 
 export interface OxyContextState {
   user: User | null;
@@ -84,6 +87,7 @@ export interface OxyContextState {
   oxyServices: OxyServices;
   useFollow?: UseFollowHook;
   showBottomSheet?: (screenOrConfig: RouteName | { screen: RouteName; props?: Record<string, unknown> }) => void;
+  openAvatarPicker: () => void;
 }
 
 const OxyContext = createContext<OxyContextState | null>(null);
@@ -380,16 +384,40 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     if (!storage) return;
 
     let wasOffline = false;
-    let checkInterval: NodeJS.Timeout | null = null;
+    let checkTimeout: NodeJS.Timeout | null = null;
+    
+    // Circuit breaker and exponential backoff state
+    const stateRef = {
+      consecutiveFailures: 0,
+      currentInterval: 10000, // Start with 10 seconds
+      baseInterval: 10000, // Base interval in milliseconds
+      maxInterval: 60000, // Maximum interval (60 seconds)
+      maxFailures: 5, // Circuit breaker threshold
+    };
+
+    const scheduleNextCheck = () => {
+      if (checkTimeout) {
+        clearTimeout(checkTimeout);
+      }
+      checkTimeout = setTimeout(() => {
+        checkNetworkAndSync();
+      }, stateRef.currentInterval);
+    };
 
     const checkNetworkAndSync = async () => {
       try {
         // Try a lightweight health check to see if we're online
         await oxyServices.healthCheck().catch(() => {
           wasOffline = true;
-          return;
+          throw new Error('Health check failed');
         });
 
+        // Health check succeeded - reset circuit breaker and backoff
+        if (stateRef.consecutiveFailures > 0) {
+          stateRef.consecutiveFailures = 0;
+          stateRef.currentInterval = stateRef.baseInterval;
+        }
+
         // If we were offline and now we're online, sync identity if needed
         if (wasOffline) {
           if (__DEV__ && logger) {
@@ -414,18 +442,36 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       } catch (error) {
         // Network check failed - we're offline
         wasOffline = true;
+        
+        // Increment failure count and apply exponential backoff
+        stateRef.consecutiveFailures++;
+        
+        // Calculate new interval with exponential backoff, capped at maxInterval
+        const backoffMultiplier = Math.min(
+          Math.pow(2, stateRef.consecutiveFailures - 1),
+          stateRef.maxInterval / stateRef.baseInterval
+        );
+        stateRef.currentInterval = Math.min(
+          stateRef.baseInterval * backoffMultiplier,
+          stateRef.maxInterval
+        );
+        
+        // If we hit the circuit breaker threshold, use max interval
+        if (stateRef.consecutiveFailures >= stateRef.maxFailures) {
+          stateRef.currentInterval = stateRef.maxInterval;
+        }
+      } finally {
+        // Always schedule next check (will use updated interval)
+        scheduleNextCheck();
       }
     };
 
     // Check immediately
     checkNetworkAndSync();
 
-    // Check periodically (every 10 seconds when app is active)
-    checkInterval = setInterval(checkNetworkAndSync, 10000);
-
     return () => {
-      if (checkInterval) {
-        clearInterval(checkInterval);
+      if (checkTimeout) {
+        clearTimeout(checkTimeout);
       }
     };
   }, [oxyServices, storage, syncIdentity, logger]);
@@ -440,6 +486,9 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
   const useFollowHook = loadUseFollowHook();
 
+  // Create update profile mutation for avatar picker
+  const updateProfileMutation = useUpdateProfile();
+
   const restoreSessionsFromStorage = useCallback(async (): Promise<void> => {
     if (!storage) {
       return;
@@ -573,6 +622,46 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     [],
   );
 
+  // Create openAvatarPicker function
+  const openAvatarPicker = useCallback(() => {
+    showBottomSheetForContext({
+      screen: 'FileManagement' as RouteName,
+      props: {
+        selectMode: true,
+        multiSelect: false,
+        disabledMimeTypes: ['video/', 'audio/', 'application/pdf'],
+        afterSelect: 'none', // Don't navigate away - stay on current screen
+        onSelect: async (file: any) => {
+          if (!file.contentType.startsWith('image/')) {
+            toast.error(translate(currentLanguage, 'editProfile.toasts.selectImage') || 'Please select an image file');
+            return;
+          }
+          try {
+            // Update file visibility to public for avatar (skip if temporary asset ID)
+            if (file.id && !file.id.startsWith('temp-')) {
+              try {
+                await oxyServices.assetUpdateVisibility(file.id, 'public');
+                console.log('[OxyContext] Avatar visibility updated to public');
+              } catch (visError: any) {
+                // Only log non-404 errors (404 means asset doesn't exist yet, which is OK)
+                if (visError?.response?.status !== 404) {
+                  console.warn('[OxyContext] Failed to update avatar visibility, continuing anyway:', visError);
+                }
+              }
+            }
+
+            // Update user profile using mutation hook (provides optimistic updates, error handling, retry)
+            await updateProfileMutation.mutateAsync({ avatar: file.id });
+            
+            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, showBottomSheetForContext, updateProfileMutation]);
+
   const contextValue: OxyContextState = useMemo(() => ({
     user,
     sessions,
@@ -612,6 +701,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     oxyServices,
     useFollow: useFollowHook,
     showBottomSheet: showBottomSheetForContext,
+    openAvatarPicker,
   }), [
     activeSessionId,
     createIdentity,
@@ -647,6 +737,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     useFollowHook,
     user,
     showBottomSheetForContext,
+    openAvatarPicker,
   ]);
 
   return (

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

@@ -1,4 +1,25 @@
-// Export all mutation hooks
-export * from './useAccountMutations';
-export * from './useServicesMutations';
+/**
+ * Mutation Hooks
+ * 
+ * TanStack Query mutation hooks for updating Oxy services data.
+ * All mutations handle authentication, error handling, and query invalidation.
+ */
+
+// Account mutation hooks
+export {
+  useUpdateProfile,
+  useUploadAvatar,
+  useUpdateAccountSettings,
+  useUpdatePrivacySettings,
+  useUploadFile,
+} from './useAccountMutations';
+
+// Service mutation hooks (sessions, devices)
+export {
+  useSwitchSession,
+  useLogoutSession,
+  useLogoutAll,
+  useUpdateDeviceName,
+  useRemoveDevice,
+} from './useServicesMutations';
 

package/src/ui/hooks/mutations/useAccountMutations.ts

@@ -275,3 +275,208 @@ export const useUpdateAccountSettings = () => {
   });
 };
 
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+export const useUpdatePrivacySettings = () => {
+  const { oxyServices, activeSessionId, user, syncIdentity } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ settings, userId }: { settings: Record<string, any>; userId?: string }) => {
+      const targetUserId = userId || user?.id;
+      if (!targetUserId) {
+        throw new Error('User ID is required');
+      }
+
+      // Ensure we have a valid token before making the request
+      if (!oxyServices.hasValidToken() && activeSessionId) {
+        try {
+          // Try to get token for the session
+          await oxyServices.getTokenBySession(activeSessionId);
+        } catch (tokenError) {
+          // If getting token fails, might be an offline session - try syncing
+          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+            try {
+              await syncIdentity();
+              // Retry getting token after sync
+              await oxyServices.getTokenBySession(activeSessionId);
+            } catch (syncError) {
+              throw new Error('Session needs to be synced. Please try again.');
+            }
+          } else {
+            throw tokenError;
+          }
+        }
+      }
+
+      try {
+        return await oxyServices.updatePrivacySettings(settings, targetUserId);
+      } catch (error: any) {
+        const errorMessage = error?.message || '';
+        const status = error?.status || error?.response?.status;
+        
+        // Handle authentication errors
+        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
+          // Try to sync session and get token
+          if (activeSessionId) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+              // Retry the update after getting token
+              return await oxyServices.updatePrivacySettings(settings, targetUserId);
+            } catch (retryError) {
+              throw new Error('Authentication failed. Please sign in again.');
+            }
+          } else {
+            throw new Error('No active session. Please sign in.');
+          }
+        }
+        
+        // TanStack Query will automatically retry on network errors
+        throw error;
+      }
+    },
+    // Optimistic update
+    onMutate: async ({ settings, userId }) => {
+      const targetUserId = userId || user?.id;
+      if (!targetUserId) return;
+
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
+      await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+
+      // Snapshot previous values
+      const previousPrivacySettings = queryClient.getQueryData(queryKeys.privacy.settings(targetUserId));
+      const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+
+      // Optimistically update privacy settings
+      if (previousPrivacySettings) {
+        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), {
+          ...previousPrivacySettings,
+          ...settings,
+        });
+      }
+
+      // Also update user query if available
+      if (previousUser) {
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+          ...previousUser,
+          privacySettings: {
+            ...previousUser.privacySettings,
+            ...settings,
+          },
+        });
+      }
+
+      return { previousPrivacySettings, previousUser };
+    },
+    // On error, rollback
+    onError: (error, { userId }, context) => {
+      const targetUserId = userId || user?.id;
+      if (context?.previousPrivacySettings && targetUserId) {
+        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), context.previousPrivacySettings);
+      }
+      if (context?.previousUser) {
+        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+      }
+      toast.error(error instanceof Error ? error.message : 'Failed to update privacy settings');
+    },
+    // On success, invalidate and refetch
+    onSuccess: (data, { userId }) => {
+      const targetUserId = userId || user?.id;
+      if (targetUserId) {
+        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), data);
+      }
+      // Also update account query if it contains privacy settings
+      const currentUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+      if (currentUser) {
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+          ...currentUser,
+          privacySettings: data,
+        });
+      }
+      invalidateAccountQueries(queryClient);
+    },
+    // Always refetch after error or success
+    onSettled: (data, error, { userId }) => {
+      const targetUserId = userId || user?.id;
+      if (targetUserId) {
+        queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
+      }
+      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
+    },
+  });
+};
+
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+export const useUploadFile = () => {
+  const { oxyServices, activeSessionId, syncIdentity } = useOxy();
+
+  return useMutation({
+    mutationFn: async ({ 
+      file, 
+      visibility, 
+      metadata, 
+      onProgress 
+    }: { 
+      file: File; 
+      visibility?: 'private' | 'public' | 'unlisted'; 
+      metadata?: Record<string, any>;
+      onProgress?: (progress: number) => void;
+    }) => {
+      // Ensure we have a valid token before making the request
+      if (!oxyServices.hasValidToken() && activeSessionId) {
+        try {
+          // Try to get token for the session
+          await oxyServices.getTokenBySession(activeSessionId);
+        } catch (tokenError) {
+          // If getting token fails, might be an offline session - try syncing
+          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+            try {
+              await syncIdentity();
+              // Retry getting token after sync
+              await oxyServices.getTokenBySession(activeSessionId);
+            } catch (syncError) {
+              throw new Error('Session needs to be synced. Please try again.');
+            }
+          } else {
+            throw tokenError;
+          }
+        }
+      }
+
+      try {
+        return await oxyServices.assetUpload(file as any, visibility, metadata, onProgress);
+      } catch (error: any) {
+        const errorMessage = error?.message || '';
+        const status = error?.status || error?.response?.status;
+        
+        // Handle authentication errors
+        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
+          // Try to sync session and get token
+          if (activeSessionId) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+              // Retry the upload after getting token
+              return await oxyServices.assetUpload(file as any, visibility, metadata, onProgress);
+            } catch (retryError) {
+              throw new Error('Authentication failed. Please sign in again.');
+            }
+          } else {
+            throw new Error('No active session. Please sign in.');
+          }
+        }
+        
+        // TanStack Query will automatically retry on network errors
+        throw error;
+      }
+    },
+  });
+};
+

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

@@ -1,5 +1,30 @@
-// Export all query hooks
-export * from './useAccountQueries';
-export * from './useServicesQueries';
-export * from './queryKeys';
+/**
+ * Query Hooks
+ * 
+ * TanStack Query hooks for fetching Oxy services data.
+ * All hooks follow the same pattern with optional `enabled` parameter.
+ */
+
+// Account and user query hooks
+export {
+  useUserProfile,
+  useUserProfiles,
+  useCurrentUser,
+  useUserById,
+  useUserByUsername,
+  useUsersBySessions,
+  usePrivacySettings,
+} from './useAccountQueries';
+
+// Service query hooks (sessions, devices, security)
+export {
+  useSessions,
+  useSession,
+  useDeviceSessions,
+  useUserDevices,
+  useSecurityInfo,
+} from './useServicesQueries';
+
+// Query keys and invalidation helpers (for advanced usage)
+export { queryKeys, invalidateAccountQueries, invalidateUserQueries, invalidateSessionQueries } from './queryKeys';
 

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

@@ -48,6 +48,12 @@ export const queryKeys = {
     details: () => [...queryKeys.devices.all, 'detail'] as const,
     detail: (deviceId: string) => [...queryKeys.devices.details(), deviceId] as const,
   },
+
+  // Privacy settings queries
+  privacy: {
+    all: ['privacy'] as const,
+    settings: (userId?: string) => [...queryKeys.privacy.all, 'settings', userId || 'current'] as const,
+  },
 } as const;
 
 /**

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

@@ -124,3 +124,72 @@ export const useUsersBySessions = (sessionIds: string[], options?: { enabled?: b
   });
 };
 
+/**
+ * Get privacy settings for a user
+ */
+export const usePrivacySettings = (userId?: string, options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId, syncIdentity, user } = useOxy();
+  const targetUserId = userId || user?.id;
+
+  return useQuery({
+    queryKey: queryKeys.privacy.settings(userId),
+    queryFn: async () => {
+      if (!targetUserId) {
+        throw new Error('User ID is required');
+      }
+
+      // Ensure we have a valid token before making the request
+      if (!oxyServices.hasValidToken() && activeSessionId) {
+        try {
+          // Try to get token for the session
+          await oxyServices.getTokenBySession(activeSessionId);
+        } catch (tokenError) {
+          // If getting token fails, might be an offline session - try syncing
+          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+            try {
+              await syncIdentity();
+              // Retry getting token after sync
+              await oxyServices.getTokenBySession(activeSessionId);
+            } catch (syncError) {
+              throw new Error('Session needs to be synced. Please try again.');
+            }
+          } else {
+            throw tokenError;
+          }
+        }
+      }
+
+      try {
+        return await oxyServices.getPrivacySettings(targetUserId);
+      } catch (error: any) {
+        const errorMessage = error?.message || '';
+        const status = error?.status || error?.response?.status;
+        
+        // Handle authentication errors
+        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
+          // Try to sync session and get token
+          if (activeSessionId) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+              // Retry the request after getting token
+              return await oxyServices.getPrivacySettings(targetUserId);
+            } catch (retryError) {
+              throw new Error('Authentication failed. Please sign in again.');
+            }
+          } else {
+            throw new Error('No active session. Please sign in.');
+          }
+        }
+        
+        // TanStack Query will automatically retry on network errors
+        throw error;
+      }
+    },
+    enabled: (options?.enabled !== false) && !!targetUserId,
+    staleTime: 2 * 60 * 1000, // 2 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+

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

@@ -89,12 +89,59 @@ export const useDeviceSessions = (options?: { enabled?: boolean }) => {
  * Get user devices
  */
 export const useUserDevices = (options?: { enabled?: boolean }) => {
-  const { oxyServices, isAuthenticated } = useOxy();
+  const { oxyServices, isAuthenticated, activeSessionId, syncIdentity } = useOxy();
 
   return useQuery({
     queryKey: queryKeys.devices.list(),
     queryFn: async () => {
-      return await oxyServices.getUserDevices();
+      // Ensure we have a valid token before making the request
+      if (!oxyServices.hasValidToken() && activeSessionId) {
+        try {
+          // Try to get token for the session
+          await oxyServices.getTokenBySession(activeSessionId);
+        } catch (tokenError) {
+          // If getting token fails, might be an offline session - try syncing
+          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+            try {
+              await syncIdentity();
+              // Retry getting token after sync
+              await oxyServices.getTokenBySession(activeSessionId);
+            } catch (syncError) {
+              throw new Error('Session needs to be synced. Please try again.');
+            }
+          } else {
+            throw tokenError;
+          }
+        }
+      }
+
+      try {
+        return await oxyServices.getUserDevices();
+      } catch (error: any) {
+        const errorMessage = error?.message || '';
+        const status = error?.status || error?.response?.status;
+        
+        // Handle authentication errors
+        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
+          // Try to sync session and get token
+          if (activeSessionId) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+              // Retry the request after getting token
+              return await oxyServices.getUserDevices();
+            } catch (retryError) {
+              throw new Error('Authentication failed. Please sign in again.');
+            }
+          } else {
+            throw new Error('No active session. Please sign in.');
+          }
+        }
+        
+        // TanStack Query will automatically retry on network errors
+        throw error;
+      }
     },
     enabled: (options?.enabled !== false) && isAuthenticated,
     staleTime: 5 * 60 * 1000,

package/src/ui/hooks/useAssets.ts

@@ -58,43 +58,23 @@ export const useAssets = () => {
       clearErrors();
       setUploading(true);
       
-      // Calculate SHA256 for progress tracking
-      const sha256 = await oxyInstance.calculateSHA256(file);
-      
-      // Initialize progress tracking
-      const initialProgress: AssetUploadProgress = {
-        fileId: '', // Will be set after init
-        uploaded: 0,
-        total: file.size,
-        percentage: 0,
-        status: 'uploading'
-      };
-      
-      // Upload with progress callback (visibility undefined, metadata, then onProgress)
-      const result = await oxyInstance.assetUpload(file as any, undefined, metadata, (percentage: number) => {
-        if (initialProgress.fileId) {
-          setUploadProgress(initialProgress.fileId, {
-            ...initialProgress,
-            uploaded: Math.round((percentage / 100) * file.size),
-            percentage,
-            status: percentage < 100 ? 'uploading' : 'processing'
-          });
-        }
-      });
+      // Upload file (progress tracking simplified for now)
+      const result = await oxyInstance.assetUpload(file as any, undefined, metadata);
 
       // Update progress with final status
-      if (result.file && initialProgress.fileId) {
-        setUploadProgress(initialProgress.fileId, {
-          ...initialProgress,
-          fileId: result.file.id,
+      if (result?.file) {
+        const fileId = result.file.id;
+        setUploadProgress(fileId, {
+          fileId,
           uploaded: file.size,
+          total: file.size,
           percentage: 100,
           status: 'complete'
         });
         
         // Remove progress after a short delay
         setTimeout(() => {
-          removeUploadProgress(result.file.id);
+          removeUploadProgress(fileId);
         }, 2000);
       }
 

package/src/ui/screens/AccountOverviewScreen.tsx

@@ -108,10 +108,11 @@ const AccountOverviewScreen: React.FC<BaseScreenProps> = ({
         return undefined;
     }, [user?.avatar, oxyServices]);
 
-    // Handle avatar press to navigate to EditProfile
+    // Handle avatar press - use openAvatarPicker from context
+    const { openAvatarPicker } = useOxy();
     const handleAvatarPress = useCallback(() => {
-        navigate?.('EditProfile', { initialSection: 'profilePicture', initialField: 'avatar' });
-    }, [navigate]);
+        openAvatarPicker();
+    }, [openAvatarPicker]);
 
     // Play Lottie animation once when component mounts
     useEffect(() => {