@oxyhq/services 5.16.3 → 5.16.7

package/src/core/mixins/OxyServices.assets.ts

@@ -1,25 +1,17 @@
-/**
- * Asset & File Methods Mixin
- */
-import type { AccountStorageUsageResponse, AssetInitResponse, AssetUrlResponse, AssetVariant } from '../../models/interfaces';
+import type { AccountStorageUsageResponse, AssetUrlResponse, AssetVariant } from '../../models/interfaces';
 import type { OxyServicesBase } from '../OxyServices.base';
-import { File } from 'expo-file-system';
 
 export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T) {
   return class extends Base {
     constructor(...args: any[]) {
       super(...(args as [any]));
     }
-    // ============================================================================
-    // FILE METHODS (Convenience wrappers using Asset Service)
-    // ============================================================================
 
     /**
      * Delete file
      */
     async deleteFile(fileId: string): Promise<any> {
       try {
-        // Central Asset Service delete with force=true behavior controlled by caller via assetDelete
         return await this.makeRequest('DELETE', `/api/assets/${encodeURIComponent(fileId)}`, undefined, { cache: false });
       } catch (error) {
         throw this.handleError(error);
@@ -28,8 +20,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
 
     /**
      * Get file download URL (synchronous - uses stream endpoint for images to avoid ORB blocking)
-     * The stream endpoint serves images directly with proper CORS headers, avoiding browser ORB blocking
-     * For better performance with signed URLs, use getFileDownloadUrlAsync when possible
      */
     getFileDownloadUrl(fileId: string, variant?: string, expiresIn?: number): string {
       const base = this.getBaseURL();
@@ -40,16 +30,12 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       const token = this.getClient().getAccessToken();
       if (token) params.set('token', token);
 
-      // Use stream endpoint which serves images directly with proper CORS headers
-      // This avoids ERR_BLOCKED_BY_ORB errors that occur with redirect-based endpoints
       const qs = params.toString();
       return `${base}/api/assets/${encodeURIComponent(fileId)}/stream${qs ? `?${qs}` : ''}`;
     }
 
     /**
      * Get file download URL asynchronously (returns signed URL directly from CDN)
-     * This is more efficient than the synchronous version as it avoids redirects
-     * Use this when you can handle async operations (e.g., in useEffect, useMemo with async)
      */
     async getFileDownloadUrlAsync(fileId: string, variant?: string, expiresIn?: number): Promise<string> {
       try {
@@ -62,7 +48,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
 
         return url || this.getFileDownloadUrl(fileId, variant, expiresIn);
       } catch (error) {
-        // Fallback to synchronous method on error
         return this.getFileDownloadUrl(fileId, variant, expiresIn);
       }
     }
@@ -76,7 +61,7 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
         if (limit) paramsObj.limit = limit;
         if (offset) paramsObj.offset = offset;
         return await this.makeRequest('GET', '/api/assets', paramsObj, {
-          cache: false, // Don't cache file lists - always get fresh data
+          cache: false,
         });
       } catch (error) {
         throw this.handleError(error);
@@ -85,8 +70,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
 
     /**
      * Get account storage usage (server-side usage aggregated from assets)
-     *
-     * NOTE: This is NOT the same as `getStorage()` from the language mixin (which returns local storage).
      */
     async getAccountStorageUsage(): Promise<AccountStorageUsageResponse> {
       try {
@@ -142,7 +125,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
 
     /**
      * Get batch access to multiple files
-     * Returns URLs and access status for each file
      */
     async getBatchFileAccess(fileIds: string[], context?: string): Promise<Record<string, any>> {
       try {
@@ -161,7 +143,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
     async getFileDownloadUrls(fileIds: string[], context?: string): Promise<Record<string, string>> {
       const response: any = await this.getBatchFileAccess(fileIds, context);
       const urls: Record<string, string> = {};
-      // response.results is the map
       const results = response.results || {};
       for (const [id, result] of Object.entries(results as Record<string, any>)) {
         if (result.allowed && result.url) {
@@ -175,281 +156,46 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
      * Upload raw file data
      */
     async uploadRawFile(file: File | Blob, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>): Promise<any> {
-      // Switch to Central Asset Service upload flow
       return this.assetUpload(file as File, visibility, metadata);
     }
 
-    // ============================================================================
-    // CENTRAL ASSET SERVICE METHODS
-    // ============================================================================
-
-    /**
-     * Get base64 string from file - uses expo-file-system when URI is available
-     * Returns base64 string directly for use with expo-crypto
-     */
-    async getFileBase64(file: File | Blob): Promise<string> {
-      // Check for URI from DocumentPicker (Expo 54)
-      const uri = (file as any).uri;
-      if (uri && typeof uri === 'string') {
-        // Use Expo 54 FileSystem API
-        try {
-          const fileInstance = new File(uri);
-          return await fileInstance.base64();
-        } catch (error: any) {
-          throw new Error(`Failed to read file from URI: ${error.message || 'Unknown error'}`);
-        }
-      }
-      
-      // For files without URI (web Blobs), convert to base64 using fetch
-      const blobUrl = URL.createObjectURL(file);
-      try {
-        const response = await fetch(blobUrl);
-        if (!response.ok) {
-          throw new Error(`Failed to fetch file: ${response.statusText || 'HTTP ' + response.status}`);
-        }
-        const buffer = await response.arrayBuffer();
-        // Convert ArrayBuffer to base64 using chunked approach to avoid stack overflow
-        return this.arrayBufferToBase64Safe(buffer);
-      } finally {
-        URL.revokeObjectURL(blobUrl);
-      }
-    }
-
-    /**
-     * Convert File or Blob to ArrayBuffer - uses expo-file-system when URI available
-     */
-    async fileToArrayBuffer(file: File | Blob): Promise<ArrayBuffer> {
-      // Check for URI from DocumentPicker (Expo 54)
-      const uri = (file as any).uri;
-      if (uri && typeof uri === 'string') {
-        // Use Expo 54 FileSystem API
-        try {
-          const fileInstance = new File(uri);
-          const bytes = await fileInstance.bytes();
-          return bytes.buffer;
-        } catch (error: any) {
-          throw new Error(`Failed to read file from URI: ${error.message || 'Unknown error'}`);
-        }
-      }
-      
-      // For files without URI, use native arrayBuffer if available, else fetch
-      if (typeof (file as File).arrayBuffer === 'function') {
-        return await (file as File).arrayBuffer();
-      }
-      
-      // Fallback: fetch via blob URL
-      const blobUrl = URL.createObjectURL(file);
-      try {
-        const response = await fetch(blobUrl);
-        if (!response.ok) {
-          throw new Error(`Failed to fetch file: ${response.statusText || 'HTTP ' + response.status}`);
-        }
-        return await response.arrayBuffer();
-      } finally {
-        URL.revokeObjectURL(blobUrl);
-      }
-    }
-
-    /**
-     * Convert ArrayBuffer to hex string
-     */
-    arrayBufferToHex(buffer: ArrayBuffer): string {
-      const bytes = new Uint8Array(buffer);
-      return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
-    }
-
-    /**
-     * Convert base64 string to ArrayBuffer (safe for large files)
-     */
-    base64ToArrayBuffer(base64: string): ArrayBuffer {
-      const binaryString = atob(base64);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      return bytes.buffer;
-    }
-
-    /**
-     * Convert binary string to base64 (manual implementation for Node.js when btoa is not available)
-     */
-    binaryToBase64(binary: string): string {
-      const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-      let result = '';
-      let i = 0;
-      
-      while (i < binary.length) {
-        const a = binary.charCodeAt(i++);
-        const b = i < binary.length ? binary.charCodeAt(i++) : 0;
-        const c = i < binary.length ? binary.charCodeAt(i++) : 0;
-        
-        const bitmap = (a << 16) | (b << 8) | c;
-        
-        result += base64Chars.charAt((bitmap >> 18) & 63);
-        result += base64Chars.charAt((bitmap >> 12) & 63);
-        result += i - 2 < binary.length ? base64Chars.charAt((bitmap >> 6) & 63) : '=';
-        result += i - 1 < binary.length ? base64Chars.charAt(bitmap & 63) : '=';
-      }
-      
-      return result;
-    }
-
-    /**
-     * Convert ArrayBuffer to base64 string (safe chunked approach to avoid stack overflow)
-     */
-    arrayBufferToBase64Safe(buffer: ArrayBuffer): string {
-      const bytes = new Uint8Array(buffer);
-      const chunkSize = 8192; // Process in chunks to avoid stack overflow
-      
-      // Use chunked approach for large buffers
-      if (bytes.length > chunkSize) {
-        let binary = '';
-        for (let i = 0; i < bytes.length; i += chunkSize) {
-          const chunk = bytes.slice(i, i + chunkSize);
-          binary += String.fromCharCode.apply(null, Array.from(chunk));
-        }
-        // Use btoa if available (browser/React Native), otherwise use manual encoding
-        return typeof btoa !== 'undefined' ? btoa(binary) : this.binaryToBase64(binary);
-      }
-      
-      // Small buffers can use direct conversion
-      const binary = String.fromCharCode.apply(null, Array.from(bytes));
-      return typeof btoa !== 'undefined' ? btoa(binary) : this.binaryToBase64(binary);
-    }
-
-    /**
-     * Calculate SHA256 hash of file content - uses expo-crypto (Expo 54 unified API)
-     */
-    async calculateSHA256(file: File | Blob): Promise<string> {
-      // Use expo-crypto (works on all platforms with Expo 54)
-      const CryptoModule = await import('expo-crypto' as any).catch(() => null);
-      if (!CryptoModule) {
-        throw new Error('expo-crypto is not available. Install it with: npx expo install expo-crypto');
-      }
-
-      const Crypto = CryptoModule.default || CryptoModule;
-      if (!Crypto?.digestStringAsync) {
-        throw new Error('expo-crypto.digestStringAsync is not available');
-      }
-
-      try {
-        // Read file as base64 (uses expo-file-system if URI available, else converts)
-        const base64 = await this.getFileBase64(file);
-        const algorithm = (Crypto as any).CryptoDigestAlgorithm?.SHA256 || 'SHA256';
-        const encoding = (Crypto as any).CryptoEncoding?.BASE64 || 'base64';
-        return await Crypto.digestStringAsync(algorithm, base64, { encoding });
-      } catch (error: any) {
-        const errorMessage = error?.message || String(error) || 'Unknown error';
-        throw new Error(`Failed to calculate SHA256 hash: ${errorMessage}`);
-      }
-    }
-
-    /**
-     * Initialize asset upload - returns pre-signed URL and file ID
-     */
-    async assetInit(sha256: string, size: number, mime: string): Promise<AssetInitResponse> {
-      try {
-        return await this.makeRequest<AssetInitResponse>('POST', '/api/assets/init', {
-          sha256,
-          size,
-          mime
-        }, { cache: false });
-      } catch (error) {
-        throw this.handleError(error);
-      }
-    }
-
-    /**
-     * Complete asset upload - commit metadata and trigger variant generation
-     */
-    async assetComplete(fileId: string, originalName: string, size: number, mime: string, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>): Promise<any> {
-      try {
-        return await this.makeRequest('POST', '/api/assets/complete', {
-          fileId,
-          originalName,
-          size,
-          mime,
-          visibility,
-          metadata
-        }, { cache: false });
-      } catch (error) {
-        throw this.handleError(error);
-      }
-    }
-
     /**
      * Upload file using Central Asset Service
      */
     async assetUpload(file: File, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>, onProgress?: (progress: number) => void): Promise<any> {
       const fileName = file.name || 'unknown';
       const fileSize = file.size;
-      const fileType = file.type || 'application/octet-stream';
       
       try {
-        // Calculate SHA256
-        let sha256: string;
-        try {
-          sha256 = await this.calculateSHA256(file);
-        } catch (error: any) {
-          throw new Error(`Failed to calculate file hash for "${fileName}": ${error.message || 'Unknown error'}`);
+        const formData = new FormData();
+        formData.append('file', file);
+        if (visibility) {
+          formData.append('visibility', visibility);
         }
-        
-        // Initialize upload
-        let initResponse: AssetInitResponse;
-        try {
-          initResponse = await this.assetInit(sha256, fileSize, fileType);
-        } catch (error: any) {
-          throw new Error(`Failed to initialize upload for "${fileName}": ${error.message || 'Unknown error'}`);
+        if (metadata) {
+          formData.append('metadata', JSON.stringify(metadata));
         }
 
-        // Try presigned URL first, fallback to direct upload
-        try {
-          await this.uploadToPresignedUrl(initResponse.uploadUrl, file, onProgress);
-        } catch (uploadError: any) {
-          // Fallback: direct upload via API to avoid CORS issues
-          try {
-            const fd = new FormData();
-            fd.append('file', file);
-            await this.getClient().request({
-              method: 'POST',
-              url: `/api/assets/${encodeURIComponent(initResponse.fileId)}/upload-direct`,
-              data: fd,
-              cache: false,
-            });
-          } catch (directUploadError: any) {
-            throw new Error(
-              `Failed to upload file "${fileName}" (${(fileSize / 1024 / 1024).toFixed(2)}MB): ` +
-              `Presigned URL failed: ${uploadError.message || 'Unknown error'}. ` +
-              `Direct upload failed: ${directUploadError.message || 'Unknown error'}`
-            );
-          }
-        }
+        const response = await this.getClient().request<{ file: any }>({
+          method: 'POST',
+          url: '/api/assets/upload',
+          data: formData,
+          cache: false,
+        });
 
-        // Complete upload
-        try {
-          return await this.assetComplete(
-            initResponse.fileId,
-            fileName,
-            fileSize,
-            fileType,
-            visibility,
-            metadata
-          );
-        } catch (error: any) {
-          throw new Error(`Failed to complete upload for "${fileName}": ${error.message || 'Unknown error'}`);
+        if (onProgress && response) {
+          onProgress(100);
         }
+
+        return response;
       } catch (error) {
-        // Log the original error for debugging
         console.error('File upload error:', error);
         
-        // Preserve original error message before passing to handleError
-        // This ensures we don't lose the error details
         let errorMessage = 'File upload failed';
         
         if (error instanceof Error) {
           errorMessage = error.message || errorMessage;
         } else if (error && typeof error === 'object') {
-          // Try to extract message from various error formats
           if ('message' in error) {
             errorMessage = String((error as any).message) || errorMessage;
           } else if ('error' in error && typeof (error as any).error === 'string') {
@@ -461,66 +207,28 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
           errorMessage = String(error) || errorMessage;
         }
         
-        // Add file context to error for better debugging
         const contextError = error as Error & { fileContext?: Record<string, unknown> };
         if (!contextError.fileContext) {
           contextError.fileContext = {
             fileName,
             fileSize,
-            fileType,
           };
         }
         
-        // If the error already has a message, preserve it
         if (error instanceof Error && error.message) {
-          // Pass through handleError but ensure message is preserved
           const handledError = this.handleError(contextError);
-          // If handleError stripped the message, restore it
           if (!handledError.message || handledError.message.trim() === 'An unexpected error occurred') {
             handledError.message = errorMessage;
           }
           throw handledError;
         }
         
-        // For non-Error objects, create a new Error with the message
         const newError = new Error(errorMessage);
         (newError as any).fileContext = contextError.fileContext;
         throw this.handleError(newError);
       }
     }
 
-    /**
-     * Upload file to pre-signed URL
-     */
-    public async uploadToPresignedUrl(url: string, file: File, onProgress?: (progress: number) => void): Promise<void> {
-      return new Promise((resolve, reject) => {
-        const xhr = new XMLHttpRequest();
-        
-        xhr.upload.addEventListener('progress', (event) => {
-          if (event.lengthComputable && onProgress) {
-            const progress = (event.loaded / event.total) * 100;
-            onProgress(progress);
-          }
-        });
-        
-        xhr.addEventListener('load', () => {
-          if (xhr.status >= 200 && xhr.status < 300) {
-            resolve();
-          } else {
-            reject(new Error(`Upload failed with status ${xhr.status}`));
-          }
-        });
-        
-        xhr.addEventListener('error', () => {
-          reject(new Error('Upload failed'));
-        });
-        
-        xhr.open('PUT', url);
-        xhr.setRequestHeader('Content-Type', file.type);
-        xhr.send(file);
-      });
-    }
-
     /**
      * Link asset to an entity
      */
@@ -557,7 +265,7 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       try {
         return await this.makeRequest('GET', `/api/assets/${fileId}`, undefined, {
           cache: true,
-          cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+          cacheTTL: 5 * 60 * 1000,
         });
       } catch (error) {
         throw this.handleError(error);
@@ -575,7 +283,7 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
         
         return await this.makeRequest<AssetUrlResponse>('GET', `/api/assets/${fileId}/url`, params, {
           cache: true,
-          cacheTTL: 10 * 60 * 1000, // 10 minutes cache for URLs
+          cacheTTL: 10 * 60 * 1000,
         });
       } catch (error) {
         throw this.handleError(error);
@@ -619,9 +327,6 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
 
     /**
      * Update asset visibility
-     * @param fileId - The file ID
-     * @param visibility - New visibility level ('private', 'public', or 'unlisted')
-     * @returns Updated asset information
      */
     async assetUpdateVisibility(fileId: string, visibility: 'private' | 'public' | 'unlisted'): Promise<any> {
       try {
@@ -633,42 +338,20 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       }
     }
 
-    /**
-     * Helper: Upload and link avatar with automatic public visibility
-     * @param file - The avatar file
-     * @param userId - User ID to link to
-     * @param app - App name (defaults to 'profiles')
-     * @returns The uploaded and linked asset
-     */
     async uploadAvatar(file: File, userId: string, app: string = 'profiles'): Promise<any> {
       try {
-        // Upload as public
         const asset = await this.assetUpload(file, 'public');
-        
-        // Link to user profile as avatar
         await this.assetLink(asset.file.id, app, 'avatar', userId, 'public');
-        
         return asset;
       } catch (error) {
         throw this.handleError(error);
       }
     }
 
-    /**
-     * Helper: Upload and link profile banner with automatic public visibility
-     * @param file - The banner file
-     * @param userId - User ID to link to
-     * @param app - App name (defaults to 'profiles')
-     * @returns The uploaded and linked asset
-     */
     async uploadProfileBanner(file: File, userId: string, app: string = 'profiles'): Promise<any> {
       try {
-        // Upload as public
         const asset = await this.assetUpload(file, 'public');
-        
-        // Link to user profile as banner
         await this.assetLink(asset.file.id, app, 'profile-banner', userId, 'public');
-        
         return asset;
       } catch (error) {
         throw this.handleError(error);
@@ -696,7 +379,7 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
         Object.keys(params).length ? params : undefined,
         {
           cache: true,
-          cacheTTL: cacheTTL ?? 10 * 60 * 1000, // default 10 minutes cache for URLs
+          cacheTTL: cacheTTL ?? 10 * 60 * 1000,
         }
       );
 

package/src/index.ts

@@ -112,13 +112,60 @@ export type {
   MinimalUserData
 } from './models/session';
 
-// UI components and hooks
+// UI hooks - Stores
 export { useAuthStore } from './ui/stores/authStore';
-export { useAssetStore, useAssets as useAssetsStore, useAsset, useUploadProgress, useAssetLoading, useAssetErrors, useAssetsByApp, useAssetsByEntity, useAssetUsageCount, useIsAssetLinked } from './ui/stores/assetStore';
+export { 
+  useAssetStore, 
+  useAssets as useAssetsStore, 
+  useAsset, 
+  useUploadProgress, 
+  useAssetLoading, 
+  useAssetErrors, 
+  useAssetsByApp, 
+  useAssetsByEntity, 
+  useAssetUsageCount, 
+  useIsAssetLinked 
+} from './ui/stores/assetStore';
+
+// UI hooks - Custom hooks
 export { useSessionSocket } from './ui/hooks/useSessionSocket';
 export { useAssets, setOxyAssetInstance } from './ui/hooks/useAssets';
 export { useFileDownloadUrl, setOxyFileUrlInstance } from './ui/hooks/useFileDownloadUrl';
 
+// UI hooks - Query hooks (TanStack Query)
+export {
+  // Account queries
+  useUserProfile,
+  useUserProfiles,
+  useCurrentUser,
+  useUserById,
+  useUserByUsername,
+  useUsersBySessions,
+  usePrivacySettings,
+  // Service queries
+  useSessions,
+  useSession,
+  useDeviceSessions,
+  useUserDevices,
+  useSecurityInfo,
+} from './ui/hooks/queries';
+
+// UI hooks - Mutation hooks (TanStack Query)
+export {
+  // Account mutations
+  useUpdateProfile,
+  useUploadAvatar,
+  useUpdateAccountSettings,
+  useUpdatePrivacySettings,
+  useUploadFile,
+  // Service mutations
+  useSwitchSession,
+  useLogoutSession,
+  useLogoutAll,
+  useUpdateDeviceName,
+  useRemoveDevice,
+} from './ui/hooks/mutations';
+
 // UI components
 export { OxySignInButton } from './ui/components/OxySignInButton';
 export { OxyLogo, FollowButton } from './ui';

package/src/ui/context/OxyContext.tsx

@@ -380,16 +380,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 +438,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]);