@oxyhq/services 5.13.27 → 5.13.30

package/src/ui/hooks/useSessionSocket.ts

@@ -5,13 +5,15 @@ import { toast } from '../../lib/sonner';
 interface UseSessionSocketProps {
   userId: string | null | undefined;
   activeSessionId: string | null | undefined;
+  currentDeviceId: string | null | undefined;
   refreshSessions: () => Promise<void>;
   logout: () => Promise<void>;
   baseURL: string;
   onRemoteSignOut?: () => void;
+  onSessionRemoved?: (sessionId: string) => void;
 }
 
-export function useSessionSocket({ userId, activeSessionId, refreshSessions, logout, baseURL, onRemoteSignOut }: UseSessionSocketProps) {
+export function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, baseURL, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps) {
   const socketRef = useRef<any>(null);
   const joinedRoomRef = useRef<string | null>(null);
   
@@ -19,15 +21,19 @@ export function useSessionSocket({ userId, activeSessionId, refreshSessions, log
   const refreshSessionsRef = useRef(refreshSessions);
   const logoutRef = useRef(logout);
   const onRemoteSignOutRef = useRef(onRemoteSignOut);
+  const onSessionRemovedRef = useRef(onSessionRemoved);
   const activeSessionIdRef = useRef(activeSessionId);
+  const currentDeviceIdRef = useRef(currentDeviceId);
 
   // Update refs when callbacks change
   useEffect(() => {
     refreshSessionsRef.current = refreshSessions;
     logoutRef.current = logout;
     onRemoteSignOutRef.current = onRemoteSignOut;
+    onSessionRemovedRef.current = onSessionRemoved;
     activeSessionIdRef.current = activeSessionId;
-  }, [refreshSessions, logout, onRemoteSignOut, activeSessionId]);
+    currentDeviceIdRef.current = currentDeviceId;
+  }, [refreshSessions, logout, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId]);
 
   useEffect(() => {
     if (!userId || !baseURL) {
@@ -71,22 +77,111 @@ export function useSessionSocket({ userId, activeSessionId, refreshSessions, log
       }
     };
 
-    const handleSessionUpdate = (data: { type: string; sessionId: string }) => {
+    const handleSessionUpdate = (data: { 
+      type: string; 
+      sessionId?: string; 
+      deviceId?: string; 
+      sessionIds?: string[] 
+    }) => {
       if (__DEV__) {
         console.log('Received session_update:', data);
       }
       
-      // Use refs to get latest callback versions
-      refreshSessionsRef.current();
+      const currentActiveSessionId = activeSessionIdRef.current;
+      const currentDeviceId = currentDeviceIdRef.current;
       
-      // If the current session was logged out, handle it specially
-      if (data.sessionId === activeSessionIdRef.current) {
-        if (onRemoteSignOutRef.current) {
-          onRemoteSignOutRef.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 logout
+        if (data.sessionId === currentActiveSessionId) {
+          if (onRemoteSignOutRef.current) {
+            onRemoteSignOutRef.current();
+          } else {
+            toast.info('You have been signed out remotely.');
+          }
+          logoutRef.current();
+        } 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__) {
+              console.debug('Failed to refresh sessions after session_removed:', 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);
+          }
+        }
+        
+        // If the removed deviceId matches the current device, immediately logout
+        if (data.deviceId && data.deviceId === currentDeviceId) {
+          if (onRemoteSignOutRef.current) {
+            onRemoteSignOutRef.current();
+          } else {
+            toast.info('This device has been removed. You have been signed out.');
+          }
+          logoutRef.current();
         } 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__) {
+              console.debug('Failed to refresh sessions after device_removed:', error);
+            }
+          });
+        }
+      } 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 logout
+        if (data.sessionIds && currentActiveSessionId && data.sessionIds.includes(currentActiveSessionId)) {
+          if (onRemoteSignOutRef.current) {
+            onRemoteSignOutRef.current();
+          } else {
+            toast.info('You have been signed out remotely.');
+          }
+          logoutRef.current();
+        } 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__) {
+              console.debug('Failed to refresh sessions after sessions_removed:', 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__) {
+            console.debug('Failed to refresh sessions after session_update:', 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.');
+          }
+          logoutRef.current();
         }
-        logoutRef.current();
       }
     };
 

package/src/ui/screens/AccountSettingsScreen.tsx

@@ -33,11 +33,12 @@ const locationSearchCache = new TTLCache<any[]>(60 * 60 * 1000); // 1 hour cache
 registerCacheForCleanup(linkMetadataCache);
 registerCacheForCleanup(locationSearchCache);
 
-const AccountSettingsScreen: React.FC<BaseScreenProps> = ({
+const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string }> = ({
     onClose,
     theme,
     goBack,
     navigate,
+    initialField,
 }) => {
     const { user: userFromContext, oxyServices, isLoading: authLoading, isAuthenticated, showBottomSheet, activeSessionId } = useOxy();
     const { t } = useI18n();
@@ -241,6 +242,24 @@ const AccountSettingsScreen: React.FC<BaseScreenProps> = ({
         }
     }, [user, avatarFileId, isUpdatingAvatar, optimisticAvatarId]);
 
+    // Set initial editing field if provided via props (e.g., from navigation)
+    // Use a ref to track if we've already set the initial field to avoid loops
+    const hasSetInitialFieldRef = useRef(false);
+    const previousInitialFieldRef = useRef<string | undefined>(undefined);
+    useEffect(() => {
+        // If initialField changed, reset the flag
+        if (previousInitialFieldRef.current !== initialField) {
+            hasSetInitialFieldRef.current = false;
+            previousInitialFieldRef.current = initialField;
+        }
+        
+        // Set the editing field if initialField is provided and we haven't set it yet
+        if (initialField && !hasSetInitialFieldRef.current) {
+            setEditingField(initialField);
+            hasSetInitialFieldRef.current = true;
+        }
+    }, [initialField]);
+
     const handleSave = async () => {
         if (!user) return;