@oxyhq/services 5.16.24 → 5.16.25

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

@@ -4,6 +4,7 @@ import { useEffect, useRef } from 'react';
 import io from 'socket.io-client';
 import { toast } from '../../lib/sonner';
 import { logger } from '../../utils/loggerUtils';
+import { tokenService } from '../../core/services/TokenService';
 export function useSessionSocket({
   userId,
   activeSessionId,
@@ -22,6 +23,9 @@ export function useSessionSocket({
   const joinedRoomRef = useRef(null);
   const accessTokenRef = useRef(null);
   const handlersSetupRef = useRef(false);
+  const lastRegisteredSocketIdRef = useRef(null);
+  const getAccessTokenRef = useRef(getAccessToken);
+  const getTransferCodeRef = useRef(getTransferCode);
 
   // Store callbacks in refs to avoid re-joining when they change
   const refreshSessionsRef = useRef(refreshSessions);
@@ -43,7 +47,9 @@ export function useSessionSocket({
     onIdentityTransferCompleteRef.current = onIdentityTransferComplete;
     activeSessionIdRef.current = activeSessionId;
     currentDeviceIdRef.current = currentDeviceId;
-  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, onIdentityTransferComplete, activeSessionId, currentDeviceId]);
+    getAccessTokenRef.current = getAccessToken;
+    getTransferCodeRef.current = getTransferCode;
+  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, onIdentityTransferComplete, activeSessionId, currentDeviceId, getAccessToken, getTransferCode]);
   useEffect(() => {
     if (!userId || !baseURL) {
       // Clean up if userId or baseURL becomes invalid
@@ -54,416 +60,431 @@ export function useSessionSocket({
       }
       return;
     }
-    const accessToken = getAccessToken();
-    // Recreate socket if token changed or socket doesn't exist
-    const tokenChanged = accessTokenRef.current !== accessToken;
-    if (!socketRef.current || tokenChanged) {
-      // Disconnect old socket if exists
-      if (socketRef.current) {
-        socketRef.current.disconnect();
-        socketRef.current = null;
-      }
-
-      // Create new socket with authentication
-      const socketOptions = {
-        transports: ['websocket']
-      };
-      if (accessToken) {
-        socketOptions.auth = {
-          token: accessToken
-        };
-        if (__DEV__) {
-          console.log('[useSessionSocket] Creating socket with auth token', {
-            userId,
-            hasToken: !!accessToken,
-            tokenLength: accessToken.length
-          });
-        }
-      } else {
-        if (__DEV__) {
-          console.warn('[useSessionSocket] No access token available for socket authentication');
-        }
-      }
-      socketRef.current = io(baseURL, socketOptions);
-      accessTokenRef.current = accessToken;
-      joinedRoomRef.current = null; // Reset room tracking
-      handlersSetupRef.current = false; // Reset handlers flag for new socket
-    }
-    const socket = socketRef.current;
 
-    // Server auto-joins room on connection when authenticated, so we don't need to manually join
-    // Just track that we're in the room
-    if (!joinedRoomRef.current && socket.connected) {
-      joinedRoomRef.current = `user:${userId}`;
-      if (__DEV__) {
-        console.log('[useSessionSocket] Socket connected, should be auto-joined to room', {
+    // Initialize socket with token refresh
+    const initializeSocket = async () => {
+      try {
+        // Refresh token if expiring soon before creating socket connection
+        await tokenService.refreshTokenIfNeeded();
+      } catch (error) {
+        // If refresh fails, log but continue with current token
+        logger.debug('Token refresh failed before socket connection', {
+          component: 'useSessionSocket',
           userId,
-          room: `user:${userId}`
+          error
         });
       }
-    }
+      const accessToken = getAccessTokenRef.current();
+      // Recreate socket if token changed or socket doesn't exist
+      const tokenChanged = accessTokenRef.current !== accessToken;
+      if (!socketRef.current || tokenChanged) {
+        // Disconnect old socket if exists
+        if (socketRef.current) {
+          socketRef.current.disconnect();
+          socketRef.current = null;
+        }
 
-    // Set up event handlers (only once per socket instance)
-    // Define handlers outside if block so they're always available
-    const handleConnect = () => {
-      const currentToken = getAccessToken();
-      if (__DEV__) {
-        console.log('[useSessionSocket] Socket connected', {
-          socketId: socket.id,
-          userId,
-          room: `user:${userId}`,
-          hasAuth: !!currentToken
-        });
-        logger.debug('Socket connected', {
-          component: 'useSessionSocket',
-          socketId: socket.id,
-          userId
-        });
+        // Create new socket with authentication
+        const socketOptions = {
+          transports: ['websocket']
+        };
+
+        // Get fresh token after potential refresh
+        const freshToken = getAccessTokenRef.current();
+        if (freshToken) {
+          socketOptions.auth = {
+            token: freshToken
+          };
+        } else {
+          logger.debug('No access token available for socket authentication', {
+            component: 'useSessionSocket',
+            userId
+          });
+        }
+        socketRef.current = io(baseURL, socketOptions);
+        accessTokenRef.current = freshToken;
+        joinedRoomRef.current = null; // Reset room tracking
+        handlersSetupRef.current = false; // Reset handlers flag for new socket
       }
-      // Server auto-joins room on connection when authenticated
-      // Just track that we're connected
-      if (userId) {
+      const socket = socketRef.current;
+      if (!socket) return;
+      if (!joinedRoomRef.current && socket.connected) {
         joinedRoomRef.current = `user:${userId}`;
       }
-    };
-    const handleDisconnect = reason => {
-      if (__DEV__) {
-        console.log('[useSessionSocket] Socket disconnected:', reason);
+
+      // Set up event handlers (only once per socket instance)
+      // Define handlers - they reference socket from closure
+      const handleConnect = () => {
+        const currentToken = getAccessTokenRef.current();
+        if (__DEV__) {
+          console.log('[useSessionSocket] Socket connected', {
+            socketId: socket.id,
+            userId,
+            room: `user:${userId}`,
+            hasAuth: !!currentToken
+          });
+          logger.debug('Socket connected', {
+            component: 'useSessionSocket',
+            socketId: socket.id,
+            userId
+          });
+        }
+        // Server auto-joins room on connection when authenticated
+        // Just track that we're connected
+        if (userId) {
+          joinedRoomRef.current = `user:${userId}`;
+        }
+      };
+      const handleDisconnect = async reason => {
         logger.debug('Socket disconnected', {
           component: 'useSessionSocket',
           reason,
           userId
         });
-      }
-      joinedRoomRef.current = null; // Reset room tracking on disconnect
-    };
-    const handleError = error => {
-      if (__DEV__) {
-        console.error('[useSessionSocket] Socket error', error);
+        joinedRoomRef.current = null;
+
+        // If disconnected due to auth error, try to refresh token and reconnect
+        if (reason === 'io server disconnect' || reason.includes('auth') || reason.includes('Authentication')) {
+          try {
+            // Refresh token and reconnect
+            await tokenService.refreshTokenIfNeeded();
+            const freshToken = getAccessTokenRef.current();
+            if (freshToken && socketRef.current) {
+              // Update auth and reconnect
+              socketRef.current.auth = {
+                token: freshToken
+              };
+              socketRef.current.connect();
+            }
+          } catch (error) {
+            logger.debug('Failed to refresh token after disconnect', {
+              component: 'useSessionSocket',
+              userId,
+              error
+            });
+          }
+        }
+      };
+      const handleError = error => {
         logger.error('Socket error', error, {
           component: 'useSessionSocket',
           userId
         });
-      }
-    };
-    const handleSessionUpdate = async data => {
-      if (__DEV__) {
-        console.log('[useSessionSocket] Received session_update event:', {
+      };
+      const handleConnectError = async error => {
+        logger.debug('Socket connection error', {
+          component: 'useSessionSocket',
+          userId,
+          error: error.message
+        });
+
+        // If error is due to expired/invalid token, try to refresh and reconnect
+        if (error.message.includes('Authentication') || error.message.includes('expired') || error.message.includes('token')) {
+          try {
+            await tokenService.refreshTokenIfNeeded();
+            const freshToken = getAccessTokenRef.current();
+            if (freshToken && socketRef.current) {
+              // Update auth and reconnect
+              socketRef.current.auth = {
+                token: freshToken
+              };
+              socketRef.current.connect();
+            }
+          } catch (refreshError) {
+            logger.debug('Failed to refresh token after connection error', {
+              component: 'useSessionSocket',
+              userId,
+              error: refreshError
+            });
+          }
+        }
+      };
+      const handleSessionUpdate = async data => {
+        logger.debug('Received session_update event', {
+          component: 'useSessionSocket',
           type: data.type,
           socketId: socket.id,
           socketConnected: socket.connected,
           roomId: joinedRoomRef.current
         });
-      }
-      const currentActiveSessionId = activeSessionIdRef.current;
-      const currentDeviceId = currentDeviceIdRef.current;
+        const currentActiveSessionId = activeSessionIdRef.current;
+        const currentDeviceId = currentDeviceIdRef.current;
 
-      // Handle different event types
-      if (data.type === 'session_removed') {
-        // Track removed session
-        if (data.sessionId && onSessionRemovedRef.current) {
-          onSessionRemovedRef.current(data.sessionId);
-        }
-
-        // If the removed sessionId matches the current activeSessionId, immediately clear state
-        if (data.sessionId === currentActiveSessionId) {
-          if (onRemoteSignOutRef.current) {
-            onRemoteSignOutRef.current();
-          } else {
-            toast.info('You have been signed out remotely.');
+        // Handle different event types
+        if (data.type === 'session_removed') {
+          // Track removed session
+          if (data.sessionId && onSessionRemovedRef.current) {
+            onSessionRemovedRef.current(data.sessionId);
           }
-          // Use clearSessionState since session was already removed server-side
-          // Await to ensure storage cleanup completes before continuing
-          try {
-            await clearSessionStateRef.current();
-          } catch (error) {
-            if (__DEV__) {
-              logger.error('Failed to clear session state after session_removed', error instanceof Error ? error : new Error(String(error)), {
-                component: 'useSessionSocket'
-              });
+
+          // If the removed sessionId matches the current activeSessionId, immediately clear state
+          if (data.sessionId === currentActiveSessionId) {
+            if (onRemoteSignOutRef.current) {
+              onRemoteSignOutRef.current();
+            } else {
+              toast.info('You have been signed out remotely.');
             }
-          }
-        } else {
-          // Otherwise, just refresh the sessions list (with error handling)
-          refreshSessionsRef.current().catch(error => {
-            // Silently handle errors from refresh - they're expected if sessions were removed
-            if (__DEV__) {
-              logger.debug('Failed to refresh sessions after session_removed', {
-                component: 'useSessionSocket'
-              }, error);
+            // Use clearSessionState since session was already removed server-side
+            // Await to ensure storage cleanup completes before continuing
+            try {
+              await clearSessionStateRef.current();
+            } catch (error) {
+              if (__DEV__) {
+                logger.error('Failed to clear session state after session_removed', error instanceof Error ? error : new Error(String(error)), {
+                  component: 'useSessionSocket'
+                });
+              }
             }
-          });
-        }
-      } else if (data.type === 'device_removed') {
-        // Track all removed sessions from this device
-        if (data.sessionIds && onSessionRemovedRef.current) {
-          for (const sessionId of data.sessionIds) {
-            onSessionRemovedRef.current(sessionId);
-          }
-        }
-
-        // If the removed deviceId matches the current device, immediately clear state
-        if (data.deviceId && data.deviceId === currentDeviceId) {
-          if (onRemoteSignOutRef.current) {
-            onRemoteSignOutRef.current();
           } else {
-            toast.info('This device has been removed. You have been signed out.');
-          }
-          // Use clearSessionState since sessions were already removed server-side
-          // Await to ensure storage cleanup completes before continuing
-          try {
-            await clearSessionStateRef.current();
-          } catch (error) {
-            if (__DEV__) {
-              logger.error('Failed to clear session state after device_removed', error instanceof Error ? error : new Error(String(error)), {
-                component: 'useSessionSocket'
-              });
-            }
+            // Otherwise, just refresh the sessions list (with error handling)
+            refreshSessionsRef.current().catch(error => {
+              // Silently handle errors from refresh - they're expected if sessions were removed
+              if (__DEV__) {
+                logger.debug('Failed to refresh sessions after session_removed', {
+                  component: 'useSessionSocket'
+                }, error);
+              }
+            });
           }
-        } else {
-          // Otherwise, refresh sessions and device list (with error handling)
-          refreshSessionsRef.current().catch(error => {
-            // Silently handle errors from refresh - they're expected if sessions were removed
-            if (__DEV__) {
-              logger.debug('Failed to refresh sessions after device_removed', {
-                component: 'useSessionSocket'
-              }, error);
+        } else if (data.type === 'device_removed') {
+          // Track all removed sessions from this device
+          if (data.sessionIds && onSessionRemovedRef.current) {
+            for (const sessionId of data.sessionIds) {
+              onSessionRemovedRef.current(sessionId);
             }
-          });
-        }
-      } else if (data.type === 'sessions_removed') {
-        // Track all removed sessions
-        if (data.sessionIds && onSessionRemovedRef.current) {
-          for (const sessionId of data.sessionIds) {
-            onSessionRemovedRef.current(sessionId);
           }
-        }
 
-        // If the current activeSessionId is in the removed sessionIds list, immediately clear state
-        if (data.sessionIds && currentActiveSessionId && data.sessionIds.includes(currentActiveSessionId)) {
-          if (onRemoteSignOutRef.current) {
-            onRemoteSignOutRef.current();
+          // If the removed deviceId matches the current device, immediately clear state
+          if (data.deviceId && data.deviceId === currentDeviceId) {
+            if (onRemoteSignOutRef.current) {
+              onRemoteSignOutRef.current();
+            } else {
+              toast.info('This device has been removed. You have been signed out.');
+            }
+            // Use clearSessionState since sessions were already removed server-side
+            // Await to ensure storage cleanup completes before continuing
+            try {
+              await clearSessionStateRef.current();
+            } catch (error) {
+              if (__DEV__) {
+                logger.error('Failed to clear session state after device_removed', error instanceof Error ? error : new Error(String(error)), {
+                  component: 'useSessionSocket'
+                });
+              }
+            }
           } else {
-            toast.info('You have been signed out remotely.');
+            // Otherwise, refresh sessions and device list (with error handling)
+            refreshSessionsRef.current().catch(error => {
+              // Silently handle errors from refresh - they're expected if sessions were removed
+              if (__DEV__) {
+                logger.debug('Failed to refresh sessions after device_removed', {
+                  component: 'useSessionSocket'
+                }, error);
+              }
+            });
           }
-          // Use clearSessionState since sessions were already removed server-side
-          // Await to ensure storage cleanup completes before continuing
-          try {
-            await clearSessionStateRef.current();
-          } catch (error) {
-            if (__DEV__) {
-              logger.error('Failed to clear session state after sessions_removed', error instanceof Error ? error : new Error(String(error)), {
-                component: 'useSessionSocket'
-              });
+        } else if (data.type === 'sessions_removed') {
+          // Track all removed sessions
+          if (data.sessionIds && onSessionRemovedRef.current) {
+            for (const sessionId of data.sessionIds) {
+              onSessionRemovedRef.current(sessionId);
             }
           }
-        } else {
-          // Otherwise, refresh sessions list (with error handling)
-          refreshSessionsRef.current().catch(error => {
-            // Silently handle errors from refresh - they're expected if sessions were removed
-            if (__DEV__) {
-              logger.debug('Failed to refresh sessions after sessions_removed', {
-                component: 'useSessionSocket'
-              }, error);
+
+          // If the current activeSessionId is in the removed sessionIds list, immediately clear state
+          if (data.sessionIds && currentActiveSessionId && data.sessionIds.includes(currentActiveSessionId)) {
+            if (onRemoteSignOutRef.current) {
+              onRemoteSignOutRef.current();
+            } else {
+              toast.info('You have been signed out remotely.');
             }
-          });
-        }
-      } else if (data.type === 'identity_transfer_complete') {
-        // Handle identity transfer completion notification
-        const transferData = data;
-        if (__DEV__) {
-          console.log('[useSessionSocket] Received identity_transfer_complete event', {
+            // Use clearSessionState since sessions were already removed server-side
+            // Await to ensure storage cleanup completes before continuing
+            try {
+              await clearSessionStateRef.current();
+            } catch (error) {
+              if (__DEV__) {
+                logger.error('Failed to clear session state after sessions_removed', error instanceof Error ? error : new Error(String(error)), {
+                  component: 'useSessionSocket'
+                });
+              }
+            }
+          } else {
+            // Otherwise, refresh sessions list (with error handling)
+            refreshSessionsRef.current().catch(error => {
+              // Silently handle errors from refresh - they're expected if sessions were removed
+              if (__DEV__) {
+                logger.debug('Failed to refresh sessions after sessions_removed', {
+                  component: 'useSessionSocket'
+                }, error);
+              }
+            });
+          }
+        } else if (data.type === 'identity_transfer_complete') {
+          // Handle identity transfer completion notification
+          const transferData = data;
+          logger.debug('Received identity_transfer_complete event', {
+            component: 'useSessionSocket',
             transferId: transferData.transferId,
             sourceDeviceId: transferData.sourceDeviceId,
             currentDeviceId,
-            hasActiveSession: activeSessionIdRef.current !== null,
-            socketConnected: socket.connected
+            activeSessionId: activeSessionIdRef.current,
+            socketConnected: socket.connected,
+            userId,
+            room: joinedRoomRef.current,
+            publicKey: transferData.publicKey.substring(0, 16) + '...'
           });
-        }
-        logger.debug('Received identity_transfer_complete event', {
-          component: 'useSessionSocket',
-          transferId: transferData.transferId,
-          sourceDeviceId: transferData.sourceDeviceId,
-          currentDeviceId,
-          activeSessionId: activeSessionIdRef.current,
-          socketConnected: socket.connected,
-          userId,
-          room: joinedRoomRef.current,
-          publicKey: transferData.publicKey.substring(0, 16) + '...'
-        });
 
-        // Only call handler on the SOURCE device (the one that initiated the transfer)
-        // The source device is identified by:
-        // 1. Matching deviceId with sourceDeviceId, OR
-        // 2. Having a stored transfer code for this transferId (most reliable check)
-        const deviceIdMatches = transferData.sourceDeviceId && transferData.sourceDeviceId === currentDeviceId;
+          // CRITICAL: Only call handler on the SOURCE device (the one that initiated the transfer)
+          // The new device (target) should NEVER process this event - it would delete its own identity!
 
-        // Check if this device has a stored transfer code (meaning it's the source device)
-        const hasStoredTransferCode = getTransferCode && !!getTransferCode(transferData.transferId);
+          // Check if this device has a stored transfer code (most reliable check - only source device has this)
+          const hasStoredTransferCode = getTransferCodeRef.current && !!getTransferCodeRef.current(transferData.transferId);
 
-        // Only call handler if this is the source device
-        // We check both deviceId match AND stored transfer code to handle cases where
-        // deviceId might be null (logged out device) but transfer code still exists
-        const shouldCallHandler = !!transferData.transferId && (deviceIdMatches || hasStoredTransferCode);
-        if (shouldCallHandler) {
-          const matchReason = deviceIdMatches ? 'deviceId-exact' : activeSessionIdRef.current !== null ? 'active-session' : 'transferId-only';
-          if (__DEV__) {
-            console.log('[useSessionSocket] Matched source device, calling handler', {
+          // Also check deviceId match (exact match required)
+          const deviceIdMatches = transferData.sourceDeviceId && currentDeviceId && transferData.sourceDeviceId === currentDeviceId;
+
+          // ONLY call handler if BOTH conditions are met:
+          // 1. Has stored transfer code (definitive proof this is the source device)
+          // 2. DeviceId matches (additional verification)
+          // If deviceId is null/undefined, we still allow if stored code exists (logged out source device)
+          // But we NEVER process if no stored code exists (definitely not the source device)
+          const shouldCallHandler = !!transferData.transferId && hasStoredTransferCode && (deviceIdMatches || !currentDeviceId); // Allow if deviceId matches OR device is logged out (but has stored code)
+
+          if (shouldCallHandler) {
+            const matchReason = deviceIdMatches ? 'deviceId-exact-with-stored-code' : currentDeviceId ? 'deviceId-mismatch-but-has-stored-code' : 'logged-out-source-device-with-stored-code';
+            logger.debug('Matched source device, calling transfer complete handler', {
+              component: 'useSessionSocket',
               transferId: transferData.transferId,
-              matchReason,
               sourceDeviceId: transferData.sourceDeviceId,
-              currentDeviceId
+              currentDeviceId,
+              matchReason,
+              hasHandler: !!onIdentityTransferCompleteRef.current,
+              socketConnected: socket.connected,
+              socketId: socket.id
             });
-          }
-          logger.debug('Matched source device, calling transfer complete handler', {
-            component: 'useSessionSocket',
-            transferId: transferData.transferId,
-            sourceDeviceId: transferData.sourceDeviceId,
-            currentDeviceId,
-            matchReason,
-            hasHandler: !!onIdentityTransferCompleteRef.current,
-            socketConnected: socket.connected,
-            socketId: socket.id
-          });
-
-          // Call the handler - it will verify using stored transfer codes
-          if (onIdentityTransferCompleteRef.current) {
-            try {
-              if (__DEV__) {
-                console.log('[useSessionSocket] Calling onIdentityTransferComplete handler', {
+            if (onIdentityTransferCompleteRef.current) {
+              try {
+                logger.debug('Calling onIdentityTransferComplete handler', {
+                  component: 'useSessionSocket',
                   transferId: transferData.transferId
                 });
-              }
-              logger.debug('Calling onIdentityTransferComplete handler', {
-                component: 'useSessionSocket',
-                transferId: transferData.transferId
-              });
-              onIdentityTransferCompleteRef.current({
-                transferId: transferData.transferId,
-                sourceDeviceId: transferData.sourceDeviceId,
-                publicKey: transferData.publicKey,
-                transferCode: transferData.transferCode,
-                completedAt: transferData.completedAt
-              });
-              if (__DEV__) {
-                console.log('[useSessionSocket] Handler called successfully', {
+                onIdentityTransferCompleteRef.current({
+                  transferId: transferData.transferId,
+                  sourceDeviceId: transferData.sourceDeviceId,
+                  publicKey: transferData.publicKey,
+                  transferCode: transferData.transferCode,
+                  completedAt: transferData.completedAt
+                });
+                logger.debug('onIdentityTransferComplete handler called successfully', {
+                  component: 'useSessionSocket',
+                  transferId: transferData.transferId
+                });
+              } catch (error) {
+                logger.error('Error calling onIdentityTransferComplete handler', error instanceof Error ? error : new Error(String(error)), {
+                  component: 'useSessionSocket',
                   transferId: transferData.transferId
                 });
               }
-              logger.debug('onIdentityTransferComplete handler called successfully', {
-                component: 'useSessionSocket',
-                transferId: transferData.transferId
-              });
-            } catch (error) {
-              if (__DEV__) {
-                console.error('[useSessionSocket] Error calling handler', error);
-              }
-              logger.error('Error calling onIdentityTransferComplete handler', error instanceof Error ? error : new Error(String(error)), {
+            } else {
+              logger.debug('No onIdentityTransferComplete handler registered', {
                 component: 'useSessionSocket',
                 transferId: transferData.transferId
               });
             }
           } else {
-            if (__DEV__) {
-              console.warn('[useSessionSocket] No handler registered');
-            }
-            logger.debug('No onIdentityTransferComplete handler registered', {
+            logger.debug('Not the source device, ignoring transfer completion', {
               component: 'useSessionSocket',
-              transferId: transferData.transferId
-            });
-          }
-        } else {
-          if (__DEV__) {
-            console.log('[useSessionSocket] Not matched, ignoring', {
               sourceDeviceId: transferData.sourceDeviceId,
               currentDeviceId,
               hasActiveSession: activeSessionIdRef.current !== null
             });
           }
-          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 => {
+            // Log but don't throw - refresh errors shouldn't break the socket handler
+            if (__DEV__) {
+              logger.debug('Failed to refresh sessions after session_update', {
+                component: 'useSessionSocket'
+              }, error);
+            }
           });
-        }
-      } else {
-        // For other event types (e.g., session_created), refresh sessions (with error handling)
-        refreshSessionsRef.current().catch(error => {
-          // Log but don't throw - refresh errors shouldn't break the socket handler
-          if (__DEV__) {
-            logger.debug('Failed to refresh sessions after session_update', {
-              component: 'useSessionSocket'
-            }, error);
-          }
-        });
 
-        // If the current session was logged out (legacy behavior), handle it specially
-        if (data.sessionId === currentActiveSessionId) {
-          if (onRemoteSignOutRef.current) {
-            onRemoteSignOutRef.current();
-          } else {
-            toast.info('You have been signed out remotely.');
+          // If the current session was logged out (legacy behavior), handle it specially
+          if (data.sessionId === currentActiveSessionId) {
+            if (onRemoteSignOutRef.current) {
+              onRemoteSignOutRef.current();
+            } else {
+              toast.info('You have been signed out remotely.');
+            }
+            // Use clearSessionState since session was already removed server-side
+            // Await to ensure storage cleanup completes before continuing
+            try {
+              await clearSessionStateRef.current();
+            } catch (error) {
+              logger.error('Failed to clear session state after session_update', error instanceof Error ? error : new Error(String(error)), {
+                component: 'useSessionSocket'
+              });
+            }
           }
-          // Use clearSessionState since session was already removed server-side
-          // Await to ensure storage cleanup completes before continuing
+        }
+      };
+
+      // Register event handlers (only once per socket instance)
+      // Track by socket.id to prevent duplicate registrations when socket reconnects
+      const currentSocketId = socket.id || 'pending';
+      if (!handlersSetupRef.current || lastRegisteredSocketIdRef.current !== currentSocketId) {
+        // Remove old handlers if socket changed (reconnection)
+        if (socketRef.current && handlersSetupRef.current && lastRegisteredSocketIdRef.current) {
           try {
-            await clearSessionStateRef.current();
+            socketRef.current.off('connect', handleConnect);
+            socketRef.current.off('disconnect', handleDisconnect);
+            socketRef.current.off('error', handleError);
+            socketRef.current.off('session_update', handleSessionUpdate);
           } catch (error) {
-            if (__DEV__) {
-              console.error('Failed to clear session state after session_update:', error);
-            }
+            // Ignore errors when removing handlers
           }
         }
-      }
-    };
 
-    // Register event handlers (only once per socket instance)
-    if (!handlersSetupRef.current) {
-      socket.on('connect', handleConnect);
-      socket.on('disconnect', handleDisconnect);
-      socket.on('error', handleError);
-      socket.on('session_update', handleSessionUpdate);
-      handlersSetupRef.current = true;
-      if (__DEV__) {
-        console.log('[useSessionSocket] Event handlers set up', {
+        // Register handlers on current socket
+        socket.on('connect', handleConnect);
+        socket.on('disconnect', handleDisconnect);
+        socket.on('error', handleError);
+        socket.on('connect_error', handleConnectError);
+        socket.on('session_update', handleSessionUpdate);
+        handlersSetupRef.current = true;
+        lastRegisteredSocketIdRef.current = currentSocketId;
+        logger.debug('Event handlers set up', {
+          component: 'useSessionSocket',
           socketId: socket.id,
           userId
         });
       }
-    }
-
-    // Ensure socket is connected before proceeding
-    if (!socket.connected) {
-      if (__DEV__) {
-        console.log('[useSessionSocket] Socket not connected, connecting...', {
-          userId
-        });
-        logger.debug('Socket not connected, waiting for connection', {
+      if (!socket.connected) {
+        logger.debug('Socket not connected, connecting...', {
           component: 'useSessionSocket',
           userId
         });
+        socket.connect();
       }
-      socket.connect();
-    } else {
-      if (__DEV__) {
-        console.log('[useSessionSocket] Socket already connected', {
-          socketId: socket.id,
-          userId,
-          connected: socket.connected
-        });
-      }
-    }
+    };
+    initializeSocket();
     return () => {
       // Only clean up handlers if socket still exists and handlers were set up
       if (socketRef.current && handlersSetupRef.current) {
-        socketRef.current.off('connect', handleConnect);
-        socketRef.current.off('disconnect', handleDisconnect);
-        socketRef.current.off('error', handleError);
-        socketRef.current.off('session_update', handleSessionUpdate);
+        try {
+          socketRef.current.off('connect');
+          socketRef.current.off('disconnect');
+          socketRef.current.off('error');
+          socketRef.current.off('connect_error');
+          socketRef.current.off('session_update');
+        } catch (error) {
+          // Ignore errors when removing handlers
+        }
         handlersSetupRef.current = false;
       }
     };
-  }, [userId, baseURL, getAccessToken]); // Depend on userId, baseURL, and getAccessToken
+  }, [userId, baseURL]); // Only depend on userId and baseURL - functions are in refs
 }
 //# sourceMappingURL=useSessionSocket.js.map