@oxyhq/services 6.9.46 → 6.10.2

package/src/ui/hooks/useFileDownloadUrl.ts

@@ -1,11 +1,5 @@
 import { useEffect, useState } from 'react';
-import { OxyServices } from '@oxyhq/core';
-
-let oxyInstance: OxyServices | null = null;
-
-export const setOxyFileUrlInstance = (instance: OxyServices) => {
-  oxyInstance = instance;
-};
+import type { OxyServices } from '@oxyhq/core';
 
 export interface UseFileDownloadUrlOptions {
   variant?: string;
@@ -21,38 +15,21 @@ export interface UseFileDownloadUrlResult {
 /**
  * Hook to resolve a file's download URL asynchronously.
  *
- * Prefers the provided `oxyServices` instance, falls back to the module-level
- * singleton set via `setOxyFileUrlInstance`.
- *
  * Uses `getFileDownloadUrlAsync` first, falling back to the synchronous
  * `getFileDownloadUrl` if the async call fails.
  */
 export const useFileDownloadUrl = (
-  fileIdOrServices?: string | OxyServices | null,
-  fileIdOrOptions?: string | UseFileDownloadUrlOptions | null,
-  maybeOptions?: UseFileDownloadUrlOptions
+  oxyServices: OxyServices | null | undefined,
+  fileId: string | null | undefined,
+  options?: UseFileDownloadUrlOptions,
 ): UseFileDownloadUrlResult => {
-  // Support two call signatures:
-  // 1. useFileDownloadUrl(oxyServices, fileId, options)  — preferred
-  // 2. useFileDownloadUrl(fileId, options)               — legacy (uses singleton)
-  let services: OxyServices | null;
-  let fileId: string | null | undefined;
-  let options: UseFileDownloadUrlOptions | undefined;
-
-  if (fileIdOrServices instanceof OxyServices) {
-    services = fileIdOrServices;
-    fileId = typeof fileIdOrOptions === 'string' ? fileIdOrOptions : null;
-    options = maybeOptions;
-  } else {
-    services = oxyInstance;
-    fileId = typeof fileIdOrServices === 'string' ? fileIdOrServices : null;
-    options = typeof fileIdOrOptions === 'object' && fileIdOrOptions !== null ? fileIdOrOptions as UseFileDownloadUrlOptions : undefined;
-  }
-
   const [url, setUrl] = useState<string | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
+  const variant = options?.variant;
+  const expiresIn = options?.expiresIn;
+
   useEffect(() => {
     if (!fileId) {
       setUrl(null);
@@ -61,7 +38,7 @@ export const useFileDownloadUrl = (
       return;
     }
 
-    if (!services) {
+    if (!oxyServices) {
       setUrl(null);
       setLoading(false);
       setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
@@ -69,22 +46,22 @@ export const useFileDownloadUrl = (
     }
 
     let cancelled = false;
-    const instance = services;
+    const instance = oxyServices;
+    const targetFileId = fileId;
 
     const load = async () => {
       setLoading(true);
       setError(null);
 
       try {
-        const { variant, expiresIn } = options || {};
         let resolvedUrl: string | null = null;
 
         if (typeof instance.getFileDownloadUrlAsync === 'function') {
-          resolvedUrl = await instance.getFileDownloadUrlAsync(fileId!, variant, expiresIn);
+          resolvedUrl = await instance.getFileDownloadUrlAsync(targetFileId, variant, expiresIn);
         }
 
         if (!resolvedUrl && typeof instance.getFileDownloadUrl === 'function') {
-          resolvedUrl = instance.getFileDownloadUrl(fileId!, variant, expiresIn);
+          resolvedUrl = instance.getFileDownloadUrl(targetFileId, variant, expiresIn);
         }
 
         if (!cancelled) {
@@ -94,8 +71,7 @@ export const useFileDownloadUrl = (
         // Fallback to sync URL on error where possible
         try {
           if (typeof instance.getFileDownloadUrl === 'function') {
-            const { variant, expiresIn } = options || {};
-            const fallbackUrl = instance.getFileDownloadUrl(fileId!, variant, expiresIn);
+            const fallbackUrl = instance.getFileDownloadUrl(targetFileId, variant, expiresIn);
             if (!cancelled) {
               setUrl(fallbackUrl || null);
               setError(err instanceof Error ? err : new Error(String(err)));
@@ -103,7 +79,7 @@ export const useFileDownloadUrl = (
             return;
           }
         } catch {
-          // ignore secondary failure
+          // Secondary failure: surface the original error below.
         }
 
         if (!cancelled) {
@@ -121,7 +97,7 @@ export const useFileDownloadUrl = (
     return () => {
       cancelled = true;
     };
-  }, [fileId, services, options?.variant, options?.expiresIn]);
+  }, [fileId, oxyServices, variant, expiresIn]);
 
   return { url, loading, error };
 };

package/src/ui/hooks/useMutationStatus.ts

@@ -0,0 +1,111 @@
+/**
+ * useMutationStatus
+ *
+ * Aggregates counts of in-flight, paused (offline), and errored mutations
+ * from the TanStack Query mutation cache. Useful for showing a global
+ * "Syncing..." indicator in the app shell.
+ */
+
+import { useCallback, useRef, useSyncExternalStore } from 'react';
+import { useQueryClient, type Mutation, type QueryClient } from '@tanstack/react-query';
+
+export interface MutationStatus {
+  /** Mutations currently running (status === 'pending', not paused). */
+  pending: number;
+  /** Mutations paused waiting for the network to come back. */
+  paused: number;
+  /** Mutations that failed and have not been retried. */
+  erroring: number;
+  /** Total of `pending + paused + erroring`. */
+  total: number;
+  /** True if any mutation is paused (i.e. waiting for connectivity). */
+  isOffline: boolean;
+  /** True if any work is in flight or pending sync. */
+  isSyncing: boolean;
+}
+
+function computeStatus(queryClient: QueryClient): MutationStatus {
+  const mutations: Mutation[] = queryClient.getMutationCache().getAll();
+  let pending = 0;
+  let paused = 0;
+  let erroring = 0;
+
+  for (const m of mutations) {
+    const { status, isPaused } = m.state;
+    if (isPaused) {
+      paused += 1;
+      continue;
+    }
+    if (status === 'pending') {
+      pending += 1;
+      continue;
+    }
+    if (status === 'error') {
+      erroring += 1;
+    }
+  }
+
+  const total = pending + paused + erroring;
+  return {
+    pending,
+    paused,
+    erroring,
+    total,
+    isOffline: paused > 0,
+    isSyncing: pending > 0 || paused > 0,
+  };
+}
+
+const EMPTY_SNAPSHOT: MutationStatus = {
+  pending: 0,
+  paused: 0,
+  erroring: 0,
+  total: 0,
+  isOffline: false,
+  isSyncing: false,
+};
+
+function snapshotsEqual(a: MutationStatus, b: MutationStatus): boolean {
+  return (
+    a.pending === b.pending &&
+    a.paused === b.paused &&
+    a.erroring === b.erroring &&
+    a.total === b.total &&
+    a.isOffline === b.isOffline &&
+    a.isSyncing === b.isSyncing
+  );
+}
+
+export function useMutationStatus(): MutationStatus {
+  const queryClient = useQueryClient();
+
+  // Cache the last returned snapshot so `useSyncExternalStore`'s tearing
+  // check sees the same reference between renders unless the underlying
+  // mutation cache actually changed. Without this React 19 enters an
+  // infinite render loop because every call to `computeStatus` returns
+  // a fresh object literal.
+  const cachedRef = useRef<MutationStatus>(EMPTY_SNAPSHOT);
+
+  const subscribe = useCallback(
+    (notify: () => void): (() => void) => {
+      const cache = queryClient.getMutationCache();
+      return cache.subscribe(() => {
+        notify();
+      });
+    },
+    [queryClient],
+  );
+
+  const getSnapshot = useCallback((): MutationStatus => {
+    const next = computeStatus(queryClient);
+    if (snapshotsEqual(cachedRef.current, next)) {
+      return cachedRef.current;
+    }
+    cachedRef.current = next;
+    return next;
+  }, [queryClient]);
+
+  const getServerSnapshot = useCallback((): MutationStatus => EMPTY_SNAPSHOT, []);
+
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}

package/src/ui/hooks/useOnlineStatus.ts

@@ -0,0 +1,29 @@
+/**
+ * useOnlineStatus
+ *
+ * Reactive boolean reflecting TanStack Query's `onlineManager` state.
+ * Mirrors browser `online`/`offline` events on web and NetInfo updates on
+ * native (both wired up in `OxyProvider`).
+ *
+ * Use this for surfacing offline UI — an OfflineBanner, a disabled "Sync"
+ * button, an inline "queued" badge on pending writes, etc. For pending /
+ * paused mutation counts use `useMutationStatus()` instead.
+ */
+
+import { useSyncExternalStore } from 'react';
+import { onlineManager } from '@tanstack/react-query';
+
+const getOnlineSnapshot = (): boolean => onlineManager.isOnline();
+
+const subscribeOnline = (notify: () => void): (() => void) => {
+  return onlineManager.subscribe(() => {
+    notify();
+  });
+};
+
+// SSR: assume online so SSR-rendered markup doesn't show offline banners.
+const getServerSnapshot = (): boolean => true;
+
+export function useOnlineStatus(): boolean {
+  return useSyncExternalStore(subscribeOnline, getOnlineSnapshot, getServerSnapshot);
+}

package/src/ui/hooks/useSessionSocket.ts

@@ -1,17 +1,38 @@
 import { useEffect, useRef } from 'react';
-import io from 'socket.io-client';
-import { toast } from '../../lib/sonner';
+import io, { type Socket } from 'socket.io-client';
+import { toast } from '@oxyhq/bloom';
 import { logger } from '@oxyhq/core';
 import { createDebugLogger } from '@oxyhq/core';
 
 const debug = createDebugLogger('SessionSocket');
 
+/**
+ * Server-emitted event types on the `session_update` channel.
+ *
+ * `session_removed`, `device_removed`, `sessions_removed` are the ONLY
+ * events that may sign the user out. Anything else (e.g. `session_created`
+ * fired right after a successful sign-in) MUST NOT trigger sign-out — see
+ * the comment on the `default` branch below.
+ */
+type SessionEventType =
+  | 'session_removed'
+  | 'device_removed'
+  | 'sessions_removed'
+  | 'session_created'
+  | 'session_update';
+
+interface SessionUpdatePayload {
+  type: SessionEventType | string;
+  sessionId?: string;
+  deviceId?: string;
+  sessionIds?: string[];
+}
+
 interface UseSessionSocketProps {
   userId: string | null | undefined;
   activeSessionId: string | null | undefined;
   currentDeviceId: string | null | undefined;
   refreshSessions: () => Promise<void>;
-  logout: () => Promise<void>;
   clearSessionState: () => Promise<void>;
   baseURL: string;
   getAccessToken: () => string | null;
@@ -19,12 +40,21 @@ interface UseSessionSocketProps {
   onSessionRemoved?: (sessionId: string) => void;
 }
 
-export function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, getAccessToken, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps) {
-  const socketRef = useRef<any>(null);
+export function useSessionSocket({
+  userId,
+  activeSessionId,
+  currentDeviceId,
+  refreshSessions,
+  clearSessionState,
+  baseURL,
+  getAccessToken,
+  onRemoteSignOut,
+  onSessionRemoved,
+}: UseSessionSocketProps) {
+  const socketRef = useRef<Socket | null>(null);
 
   // Store callbacks in refs to avoid reconnecting when they change
   const refreshSessionsRef = useRef(refreshSessions);
-  const logoutRef = useRef(logout);
   const clearSessionStateRef = useRef(clearSessionState);
   const onRemoteSignOutRef = useRef(onRemoteSignOut);
   const onSessionRemovedRef = useRef(onSessionRemoved);
@@ -35,14 +65,13 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
   // Update refs when callbacks change
   useEffect(() => {
     refreshSessionsRef.current = refreshSessions;
-    logoutRef.current = logout;
     clearSessionStateRef.current = clearSessionState;
     onRemoteSignOutRef.current = onRemoteSignOut;
     onSessionRemovedRef.current = onSessionRemoved;
     activeSessionIdRef.current = activeSessionId;
     currentDeviceIdRef.current = currentDeviceId;
     getAccessTokenRef.current = getAccessToken;
-  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId, getAccessToken]);
+  }, [refreshSessions, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId, getAccessToken]);
 
   useEffect(() => {
     if (!userId || !baseURL) {
@@ -75,138 +104,119 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
       debug.log('Socket connected:', socket.id);
     };
 
-    const handleSessionUpdate = async (data: {
-      type: string;
-      sessionId?: string;
-      deviceId?: string;
-      sessionIds?: string[]
-    }) => {
+    const refreshSessionsSafe = () => {
+      refreshSessionsRef.current().catch((error: unknown) => {
+        // Refresh errors shouldn't break the socket handler. They happen
+        // routinely when sessions are removed mid-fetch — log and move on.
+        if (__DEV__) {
+          logger.debug(
+            'Failed to refresh sessions after session_update',
+            { component: 'useSessionSocket' },
+            error,
+          );
+        }
+      });
+    };
+
+    const triggerLocalSignOut = async (toastMessage: string, errorContext: string) => {
+      if (onRemoteSignOutRef.current) {
+        onRemoteSignOutRef.current();
+      } else {
+        toast.info(toastMessage);
+      }
+      // Clear local state since the server has already removed the session.
+      // Await so storage cleanup completes before any subsequent navigation.
+      try {
+        await clearSessionStateRef.current();
+      } catch (error) {
+        if (__DEV__) {
+          logger.error(
+            `Failed to clear session state after ${errorContext}`,
+            error instanceof Error ? error : new Error(String(error)),
+            { component: 'useSessionSocket' },
+          );
+        }
+      }
+    };
+
+    const handleSessionUpdate = async (data: SessionUpdatePayload) => {
       debug.log('Received session_update:', data);
-      
+
       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.');
+      const currentDeviceIdValue = currentDeviceIdRef.current;
+
+      // Strict whitelist. Every event type that may sign the user out must
+      // appear in the switch. Anything unknown falls through to `default`,
+      // which is intentionally a no-op for session lifecycle — it only logs
+      // in dev. This guards against future server-side event additions
+      // (e.g. `session_created`) accidentally triggering sign-out via a
+      // "legacy fallback" branch.
+      switch (data.type) {
+        case 'session_removed': {
+          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 (data.sessionId && data.sessionId === currentActiveSessionId) {
+            await triggerLocalSignOut('You have been signed out remotely.', 'session_removed');
+          } else {
+            refreshSessionsSafe();
           }
-        } 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 as unknown);
-            }
-          });
+          break;
         }
-      } 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);
+        case 'device_removed': {
+          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();
+          if (data.deviceId && currentDeviceIdValue && data.deviceId === currentDeviceIdValue) {
+            await triggerLocalSignOut(
+              'This device has been removed. You have been signed out.',
+              'device_removed',
+            );
           } 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' });
-            }
+            refreshSessionsSafe();
           }
-        } 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 as unknown);
-            }
-          });
+          break;
         }
-      } else if (data.type === 'sessions_removed') {
-        // Track all removed sessions
-        if (data.sessionIds && onSessionRemovedRef.current) {
-          for (const sessionId of data.sessionIds) {
-            onSessionRemovedRef.current(sessionId);
+        case 'sessions_removed': {
+          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 (
+            data.sessionIds &&
+            currentActiveSessionId &&
+            data.sessionIds.includes(currentActiveSessionId)
+          ) {
+            await triggerLocalSignOut('You have been signed out remotely.', 'sessions_removed');
           } else {
-            toast.info('You have been signed out remotely.');
+            refreshSessionsSafe();
           }
-          // 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 as unknown);
-            }
-          });
+          break;
         }
-      } 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
+        case 'session_created':
+        case 'session_update': {
+          // Lifecycle event for the current user. Just resync the sessions
+          // list — never sign out. Historically this branch had a legacy
+          // fallback that compared `data.sessionId === currentActiveSessionId`
+          // and signed the user out if true, which was catastrophic: a
+          // `session_created` event fired immediately after a successful
+          // sign-in carries the user's NEW (now-active) session id, which
+          // matched and triggered an instant remote sign-out toast on every
+          // login. Whitelist explicitly; never fall through.
+          refreshSessionsSafe();
+          break;
+        }
+        default: {
           if (__DEV__) {
-            logger.debug('Failed to refresh sessions after session_update', { component: 'useSessionSocket' }, error as unknown);
-          }
-        });
-        
-        // 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) {
-            debug.error('Failed to clear session state after session_update:', error);
+            logger.warn('Unknown session socket event type', {
+              component: 'useSessionSocket',
+              type: data.type,
+            });
           }
+          break;
         }
       }
     };
@@ -221,4 +231,4 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
       socketRef.current = null;
     };
   }, [userId, baseURL]); // Only depend on userId and baseURL - callbacks are in refs
-} 
+}

package/src/ui/hooks/useSettingToggle.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback, useEffect } from 'react';
-import { toast } from '../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 
 interface UseSettingToggleOptions {
     /** Initial value of the setting */

package/src/ui/index.ts

@@ -34,9 +34,6 @@ let useFollow;
 let ProfileScreen;
 let useAuthStore;
 let useAccountStore;
-let fontFamilies;
-let fontStyles;
-let toast;
 let useStorage;
 
 if (isFrontend) {
@@ -55,9 +52,6 @@ if (isFrontend) {
   ProfileScreen = require('./screens/ProfileScreen').default;
   useAuthStore = require('./stores/authStore').useAuthStore;
   useAccountStore = require('./stores/accountStore').useAccountStore;
-  fontFamilies = require('./styles/fonts').fontFamilies;
-  fontStyles = require('./styles/fonts').fontStyles;
-  toast = require('../lib/sonner').toast;
   useStorage = require('./hooks/useStorage').useStorage;
 } else {
   // Backend: no-op fallbacks
@@ -80,9 +74,6 @@ if (isFrontend) {
   ProfileScreen = noopComponent;
   useAuthStore = noopHook;
   useAccountStore = noopHook;
-  fontFamilies = {};
-  fontStyles = {};
-  toast = () => {};
   useStorage = () => noopStorageResult;
 }
 
@@ -102,9 +93,6 @@ export {
   ProfileScreen,
   useAuthStore,
   useAccountStore,
-  fontFamilies,
-  fontStyles,
-  toast,
   useStorage,
 };