@oxyhq/services 5.16.19 → 5.16.20

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

@@ -7,7 +7,7 @@ import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sess
 import { handleAuthError, isInvalidSessionError } from '../../utils/errorHandlers';
 import type { StorageInterface } from '../../utils/storageHelpers';
 import type { OxyServices } from '../../../core';
-import { KeyManager, SignatureService } from '../../../crypto';
+import { KeyManager, SignatureService, type BackupData } from '../../../crypto';
 
 export interface UseAuthOperationsOptions {
   oxyServices: OxyServices;
@@ -36,7 +36,7 @@ export interface UseAuthOperationsResult {
   /** Create a new identity locally (offline-first) and optionally sync with server */
   createIdentity: () => Promise<{ synced: boolean }>;
   /** Import an existing identity from backup file data */
-  importIdentity: (backupData: { encrypted: string; salt: string; iv: string; publicKey: string }, password: string) => Promise<{ synced: boolean }>;
+  importIdentity: (backupData: BackupData, password: string) => Promise<{ synced: boolean }>;
   /** Sign in with existing identity on device */
   signIn: (deviceName?: string) => Promise<User>;
   /** Logout from current session */
@@ -436,7 +436,7 @@ export const useAuthOperations = ({
    * Import identity from backup file data (offline-first)
    */
   const importIdentity = useCallback(
-    async (backupData: { encrypted: string; salt: string; iv: string; publicKey: string }, password: string): Promise<{ synced: boolean }> => {
+    async (backupData: BackupData, password: string): Promise<{ synced: boolean }> => {
       if (!storage) throw new Error('Storage not initialized');
 
       // Validate arguments - ensure backupData is an object, not a string (old signature)

package/src/ui/hooks/useSessionSocket.ts

@@ -13,9 +13,10 @@ interface UseSessionSocketProps {
   baseURL: string;
   onRemoteSignOut?: () => void;
   onSessionRemoved?: (sessionId: string) => void;
+  onIdentityTransferComplete?: (data: { transferId: string; sourceDeviceId: string; publicKey: string; completedAt: string }) => void;
 }
 
-export function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps) {
+export function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, onRemoteSignOut, onSessionRemoved, onIdentityTransferComplete }: UseSessionSocketProps) {
   const socketRef = useRef<any>(null);
   const joinedRoomRef = useRef<string | null>(null);
   
@@ -25,6 +26,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
   const clearSessionStateRef = useRef(clearSessionState);
   const onRemoteSignOutRef = useRef(onRemoteSignOut);
   const onSessionRemovedRef = useRef(onSessionRemoved);
+  const onIdentityTransferCompleteRef = useRef(onIdentityTransferComplete);
   const activeSessionIdRef = useRef(activeSessionId);
   const currentDeviceIdRef = useRef(currentDeviceId);
 
@@ -35,9 +37,10 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
     clearSessionStateRef.current = clearSessionState;
     onRemoteSignOutRef.current = onRemoteSignOut;
     onSessionRemovedRef.current = onSessionRemoved;
+    onIdentityTransferCompleteRef.current = onIdentityTransferComplete;
     activeSessionIdRef.current = activeSessionId;
     currentDeviceIdRef.current = currentDeviceId;
-  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId]);
+  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, onIdentityTransferComplete, activeSessionId, currentDeviceId]);
 
   useEffect(() => {
     if (!userId || !baseURL) {
@@ -192,6 +195,63 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
             }
           });
         }
+      } else if (data.type === 'identity_transfer_complete') {
+        // Handle identity transfer completion notification
+        const transferData = data as {
+          type: 'identity_transfer_complete';
+          transferId: string;
+          sourceDeviceId: string;
+          publicKey: string;
+          completedAt: string;
+        };
+        
+        if (__DEV__) {
+          logger.debug('Received identity_transfer_complete event', {
+            component: 'useSessionSocket',
+            transferId: transferData.transferId,
+            sourceDeviceId: transferData.sourceDeviceId,
+            currentDeviceId,
+            activeSessionId: activeSessionIdRef.current,
+          });
+        }
+        
+        // Check if this device is the source device
+        // Match by deviceId if available, otherwise show prompt if we have an active session
+        // (user can decide if they want to delete)
+        const isSourceDevice = transferData.sourceDeviceId && (
+          transferData.sourceDeviceId === currentDeviceId ||
+          // Fallback: if we don't have currentDeviceId but have an active session,
+          // show the prompt anyway (user can decide)
+          (currentDeviceId === null && activeSessionIdRef.current !== null)
+        );
+        
+        if (isSourceDevice) {
+          if (__DEV__) {
+            logger.debug('Matched source device, showing deletion prompt', {
+              component: 'useSessionSocket',
+              transferId: transferData.transferId,
+              sourceDeviceId: transferData.sourceDeviceId,
+              currentDeviceId,
+              matchedBy: transferData.sourceDeviceId === currentDeviceId ? 'deviceId' : 'session',
+            });
+          }
+          // This is the source device - notify callback to show deletion prompt
+          if (onIdentityTransferCompleteRef.current) {
+            onIdentityTransferCompleteRef.current({
+              transferId: transferData.transferId,
+              sourceDeviceId: transferData.sourceDeviceId,
+              publicKey: transferData.publicKey,
+              completedAt: transferData.completedAt,
+            });
+          }
+        } else if (__DEV__) {
+          logger.debug('Not the source device, ignoring transfer completion', {
+            component: 'useSessionSocket',
+            sourceDeviceId: transferData.sourceDeviceId,
+            currentDeviceId,
+            hasActiveSession: activeSessionIdRef.current !== null,
+          });
+        }
       } else {
         // For other event types (e.g., session_created), refresh sessions (with error handling)
         refreshSessionsRef.current().catch((error) => {

package/lib/commonjs/ui/hooks/useIdentityMutations.js

@@ -1,111 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useCreateIdentity = useCreateIdentity;
-exports.useImportIdentity = useImportIdentity;
-exports.useSyncIdentity = useSyncIdentity;
-var _reactQuery = require("@tanstack/react-query");
-/**
- * TanStack Query mutations for identity operations
- * Provides offline-first mutations for identity creation, import, and sync
- * Never deletes identity on errors - preserves user data
- */
-
-/**
- * Hook for creating a new identity with offline support
- * Never deletes identity on error - preserves user data
- */
-function useCreateIdentity(createIdentityFn) {
-  const queryClient = (0, _reactQuery.useQueryClient)();
-  return (0, _reactQuery.useMutation)({
-    mutationFn: createIdentityFn,
-    onSuccess: data => {
-      // Invalidate user queries to refetch after identity creation
-      queryClient.invalidateQueries({
-        queryKey: ['user']
-      });
-      queryClient.invalidateQueries({
-        queryKey: ['identity']
-      });
-    },
-    onError: error => {
-      // Never delete identity on error - just log it
-      // User can recover using backup file
-      if (__DEV__) {
-        console.warn('[useCreateIdentity] Identity creation error (identity may still exist):', error);
-      }
-    },
-    retry: false,
-    // Don't retry identity creation
-    networkMode: 'offlineFirst'
-  });
-}
-
-/**
- * Hook for importing an identity from backup file
- * Never deletes identity on error - preserves user data
- */
-function useImportIdentity(importIdentityFn) {
-  const queryClient = (0, _reactQuery.useQueryClient)();
-  return (0, _reactQuery.useMutation)({
-    mutationFn: variables => importIdentityFn(variables.backupData, variables.password),
-    onSuccess: data => {
-      queryClient.invalidateQueries({
-        queryKey: ['user']
-      });
-      queryClient.invalidateQueries({
-        queryKey: ['identity']
-      });
-    },
-    onError: error => {
-      // Never delete identity on error - just log it
-      if (__DEV__) {
-        console.warn('[useImportIdentity] Identity import error (identity may still exist):', error);
-      }
-    },
-    retry: false,
-    networkMode: 'offlineFirst'
-  });
-}
-
-/**
- * Hook for syncing identity with server
- * Never deletes identity on error - only logs and allows retry
- */
-function useSyncIdentity(syncIdentityFn) {
-  const queryClient = (0, _reactQuery.useQueryClient)();
-  return (0, _reactQuery.useMutation)({
-    mutationFn: syncIdentityFn,
-    onSuccess: user => {
-      // Update user cache
-      queryClient.setQueryData(['user', 'current'], user);
-      queryClient.invalidateQueries({
-        queryKey: ['user']
-      });
-      queryClient.invalidateQueries({
-        queryKey: ['identity']
-      });
-    },
-    onError: error => {
-      // Never delete identity on error - just log it
-      // User can retry sync later or use backup file
-      if (__DEV__) {
-        console.warn('[useSyncIdentity] Sync failed, but identity is preserved:', error);
-      }
-    },
-    retry: (failureCount, error) => {
-      // Retry up to 2 times for sync operations
-      // Don't retry if it's a network error - user can retry when online
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isNetworkError = errorMessage.includes('Network') || errorMessage.includes('Failed to fetch') || error?.code === 'NETWORK_ERROR';
-      if (isNetworkError) {
-        return false; // Don't retry network errors - user will retry when online
-      }
-      return failureCount < 2;
-    },
-    networkMode: 'offlineFirst'
-  });
-}
-//# sourceMappingURL=useIdentityMutations.js.map

package/lib/commonjs/ui/hooks/useIdentityMutations.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_reactQuery","require","useCreateIdentity","createIdentityFn","queryClient","useQueryClient","useMutation","mutationFn","onSuccess","data","invalidateQueries","queryKey","onError","error","__DEV__","console","warn","retry","networkMode","useImportIdentity","importIdentityFn","variables","backupData","password","useSyncIdentity","syncIdentityFn","user","setQueryData","failureCount","errorMessage","Error","message","String","isNetworkError","includes","code"],"sourceRoot":"../../../../src","sources":["ui/hooks/useIdentityMutations.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/ui/hooks/useIdentityMutations.js

@@ -1,105 +0,0 @@
-"use strict";
-
-/**
- * TanStack Query mutations for identity operations
- * Provides offline-first mutations for identity creation, import, and sync
- * Never deletes identity on errors - preserves user data
- */
-
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-/**
- * Hook for creating a new identity with offline support
- * Never deletes identity on error - preserves user data
- */
-export function useCreateIdentity(createIdentityFn) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: createIdentityFn,
-    onSuccess: data => {
-      // Invalidate user queries to refetch after identity creation
-      queryClient.invalidateQueries({
-        queryKey: ['user']
-      });
-      queryClient.invalidateQueries({
-        queryKey: ['identity']
-      });
-    },
-    onError: error => {
-      // Never delete identity on error - just log it
-      // User can recover using backup file
-      if (__DEV__) {
-        console.warn('[useCreateIdentity] Identity creation error (identity may still exist):', error);
-      }
-    },
-    retry: false,
-    // Don't retry identity creation
-    networkMode: 'offlineFirst'
-  });
-}
-
-/**
- * Hook for importing an identity from backup file
- * Never deletes identity on error - preserves user data
- */
-export function useImportIdentity(importIdentityFn) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: variables => importIdentityFn(variables.backupData, variables.password),
-    onSuccess: data => {
-      queryClient.invalidateQueries({
-        queryKey: ['user']
-      });
-      queryClient.invalidateQueries({
-        queryKey: ['identity']
-      });
-    },
-    onError: error => {
-      // Never delete identity on error - just log it
-      if (__DEV__) {
-        console.warn('[useImportIdentity] Identity import error (identity may still exist):', error);
-      }
-    },
-    retry: false,
-    networkMode: 'offlineFirst'
-  });
-}
-
-/**
- * Hook for syncing identity with server
- * Never deletes identity on error - only logs and allows retry
- */
-export function useSyncIdentity(syncIdentityFn) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: syncIdentityFn,
-    onSuccess: user => {
-      // Update user cache
-      queryClient.setQueryData(['user', 'current'], user);
-      queryClient.invalidateQueries({
-        queryKey: ['user']
-      });
-      queryClient.invalidateQueries({
-        queryKey: ['identity']
-      });
-    },
-    onError: error => {
-      // Never delete identity on error - just log it
-      // User can retry sync later or use backup file
-      if (__DEV__) {
-        console.warn('[useSyncIdentity] Sync failed, but identity is preserved:', error);
-      }
-    },
-    retry: (failureCount, error) => {
-      // Retry up to 2 times for sync operations
-      // Don't retry if it's a network error - user can retry when online
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isNetworkError = errorMessage.includes('Network') || errorMessage.includes('Failed to fetch') || error?.code === 'NETWORK_ERROR';
-      if (isNetworkError) {
-        return false; // Don't retry network errors - user will retry when online
-      }
-      return failureCount < 2;
-    },
-    networkMode: 'offlineFirst'
-  });
-}
-//# sourceMappingURL=useIdentityMutations.js.map

package/lib/module/ui/hooks/useIdentityMutations.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["useMutation","useQueryClient","useCreateIdentity","createIdentityFn","queryClient","mutationFn","onSuccess","data","invalidateQueries","queryKey","onError","error","__DEV__","console","warn","retry","networkMode","useImportIdentity","importIdentityFn","variables","backupData","password","useSyncIdentity","syncIdentityFn","user","setQueryData","failureCount","errorMessage","Error","message","String","isNetworkError","includes","code"],"sourceRoot":"../../../../src","sources":["ui/hooks/useIdentityMutations.ts"],"mappings":"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","ignoreList":[]}

package/lib/typescript/types/bip39.d.ts

@@ -1,32 +0,0 @@
-declare module 'bip39' {
-  export interface Wordlist {
-    [index: number]: string;
-    length: number;
-    getWord(index: number): string;
-    getWordIndex(word: string): number;
-  }
-
-  export const wordlists: {
-    english: string[];
-    chinese_simplified: string[];
-    chinese_traditional: string[];
-    french: string[];
-    italian: string[];
-    japanese: string[];
-    korean: string[];
-    spanish: string[];
-  };
-
-  // Use Uint8Array instead of Buffer for React Native compatibility
-  // In Node.js, Buffer extends Uint8Array so this is compatible
-  export function generateMnemonic(strength?: number, rng?: (size: number) => Uint8Array, wordlist?: string[]): string;
-  export function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
-  export function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
-  export function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): string;
-  export function entropyToMnemonic(entropy: string, wordlist?: string[]): string;
-  export function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;
-  export function mnemonicToSeedHex(mnemonic: string, passphrase?: string): Promise<string>;
-  export function mnemonicToSeedHexSync(mnemonic: string, passphrase?: string): string;
-}
-
-

package/lib/typescript/ui/hooks/useIdentityMutations.d.ts

@@ -1,41 +0,0 @@
-/**
- * TanStack Query mutations for identity operations
- * Provides offline-first mutations for identity creation, import, and sync
- * Never deletes identity on errors - preserves user data
- */
-import type { User } from '../../models/interfaces';
-export interface CreateIdentityResult {
-    synced: boolean;
-}
-export interface ImportIdentityResult {
-    synced: boolean;
-}
-/**
- * Hook for creating a new identity with offline support
- * Never deletes identity on error - preserves user data
- */
-export declare function useCreateIdentity(createIdentityFn: () => Promise<CreateIdentityResult>): import("@tanstack/react-query").UseMutationResult<CreateIdentityResult, Error, void, unknown>;
-/**
- * Hook for importing an identity from backup file
- * Never deletes identity on error - preserves user data
- */
-export declare function useImportIdentity(importIdentityFn: (backupData: {
-    encrypted: string;
-    salt: string;
-    iv: string;
-    publicKey: string;
-}, password: string) => Promise<ImportIdentityResult>): import("@tanstack/react-query").UseMutationResult<ImportIdentityResult, Error, {
-    backupData: {
-        encrypted: string;
-        salt: string;
-        iv: string;
-        publicKey: string;
-    };
-    password: string;
-}, unknown>;
-/**
- * Hook for syncing identity with server
- * Never deletes identity on error - only logs and allows retry
- */
-export declare function useSyncIdentity(syncIdentityFn: () => Promise<User>): import("@tanstack/react-query").UseMutationResult<User, Error, void, unknown>;
-//# sourceMappingURL=useIdentityMutations.d.ts.map

package/lib/typescript/ui/hooks/useIdentityMutations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useIdentityMutations.d.ts","sourceRoot":"","sources":["../../../../src/ui/hooks/useIdentityMutations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,MAAM,OAAO,CAAC,oBAAoB,CAAC,iGAqBtD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,CAAC,UAAU,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,oBAAoB,CAAC;gBAK7G;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;cAAY,MAAM;YAe7H;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,iFAoCpC"}

package/src/types/bip39.d.ts

@@ -1,32 +0,0 @@
-declare module 'bip39' {
-  export interface Wordlist {
-    [index: number]: string;
-    length: number;
-    getWord(index: number): string;
-    getWordIndex(word: string): number;
-  }
-
-  export const wordlists: {
-    english: string[];
-    chinese_simplified: string[];
-    chinese_traditional: string[];
-    french: string[];
-    italian: string[];
-    japanese: string[];
-    korean: string[];
-    spanish: string[];
-  };
-
-  // Use Uint8Array instead of Buffer for React Native compatibility
-  // In Node.js, Buffer extends Uint8Array so this is compatible
-  export function generateMnemonic(strength?: number, rng?: (size: number) => Uint8Array, wordlist?: string[]): string;
-  export function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
-  export function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
-  export function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): string;
-  export function entropyToMnemonic(entropy: string, wordlist?: string[]): string;
-  export function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;
-  export function mnemonicToSeedHex(mnemonic: string, passphrase?: string): Promise<string>;
-  export function mnemonicToSeedHexSync(mnemonic: string, passphrase?: string): string;
-}
-
-

package/src/ui/hooks/useIdentityMutations.ts

@@ -1,115 +0,0 @@
-/**
- * TanStack Query mutations for identity operations
- * Provides offline-first mutations for identity creation, import, and sync
- * Never deletes identity on errors - preserves user data
- */
-
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { User } from '../../models/interfaces';
-
-export interface CreateIdentityResult {
-  synced: boolean;
-}
-
-export interface ImportIdentityResult {
-  synced: boolean;
-}
-
-/**
- * Hook for creating a new identity with offline support
- * Never deletes identity on error - preserves user data
- */
-export function useCreateIdentity(
-  createIdentityFn: () => Promise<CreateIdentityResult>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: createIdentityFn,
-    onSuccess: (data) => {
-      // Invalidate user queries to refetch after identity creation
-      queryClient.invalidateQueries({ queryKey: ['user'] });
-      queryClient.invalidateQueries({ queryKey: ['identity'] });
-    },
-    onError: (error) => {
-      // Never delete identity on error - just log it
-      // User can recover using backup file
-      if (__DEV__) {
-        console.warn('[useCreateIdentity] Identity creation error (identity may still exist):', error);
-      }
-    },
-    retry: false, // Don't retry identity creation
-    networkMode: 'offlineFirst',
-  });
-}
-
-/**
- * Hook for importing an identity from backup file
- * Never deletes identity on error - preserves user data
- */
-export function useImportIdentity(
-  importIdentityFn: (backupData: { encrypted: string; salt: string; iv: string; publicKey: string }, password: string) => Promise<ImportIdentityResult>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (variables: { backupData: { encrypted: string; salt: string; iv: string; publicKey: string }; password: string }) => 
-      importIdentityFn(variables.backupData, variables.password),
-    onSuccess: (data) => {
-      queryClient.invalidateQueries({ queryKey: ['user'] });
-      queryClient.invalidateQueries({ queryKey: ['identity'] });
-    },
-    onError: (error) => {
-      // Never delete identity on error - just log it
-      if (__DEV__) {
-        console.warn('[useImportIdentity] Identity import error (identity may still exist):', error);
-      }
-    },
-    retry: false,
-    networkMode: 'offlineFirst',
-  });
-}
-
-/**
- * Hook for syncing identity with server
- * Never deletes identity on error - only logs and allows retry
- */
-export function useSyncIdentity(
-  syncIdentityFn: () => Promise<User>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: syncIdentityFn,
-    onSuccess: (user) => {
-      // Update user cache
-      queryClient.setQueryData(['user', 'current'], user);
-      queryClient.invalidateQueries({ queryKey: ['user'] });
-      queryClient.invalidateQueries({ queryKey: ['identity'] });
-    },
-    onError: (error) => {
-      // Never delete identity on error - just log it
-      // User can retry sync later or use backup file
-      if (__DEV__) {
-        console.warn('[useSyncIdentity] Sync failed, but identity is preserved:', error);
-      }
-    },
-    retry: (failureCount, error: any) => {
-      // Retry up to 2 times for sync operations
-      // Don't retry if it's a network error - user can retry when online
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const isNetworkError = 
-        errorMessage.includes('Network') ||
-        errorMessage.includes('Failed to fetch') ||
-        error?.code === 'NETWORK_ERROR';
-      
-      if (isNetworkError) {
-        return false; // Don't retry network errors - user will retry when online
-      }
-      
-      return failureCount < 2;
-    },
-    networkMode: 'offlineFirst',
-  });
-}
-