@oxyhq/services 10.2.9 → 10.2.11

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

@@ -11,11 +11,6 @@ import { SignatureService } from '@oxyhq/core';
 import { isWebBrowser } from '../../hooks/useWebSSO';
 import { clearActiveAuthuser, clearSsoBounceState } from '../../utils/activeAuthuser';
 
-/** Type guard for error objects with optional code and status properties */
-function isErrorWithCodeOrStatus(error: unknown): error is { code?: string; status?: number; message?: string } {
-  return typeof error === 'object' && error !== null;
-}
-
 export interface UseAuthOperationsOptions {
   oxyServices: OxyServices;
   storage: StorageInterface | null;
@@ -55,7 +50,6 @@ const LOGOUT_ALL_ERROR_CODE = 'LOGOUT_ALL_ERROR';
  */
 export const useAuthOperations = ({
   oxyServices,
-  storage,
   sessions,
   activeSessionId,
   setActiveSessionId,
@@ -77,7 +71,7 @@ export const useAuthOperations = ({
   sessionsRef.current = sessions;
 
   /**
-   * Internal function to perform challenge-response sign in (works offline)
+   * Internal function to perform challenge-response sign in.
    */
   const performSignIn = useCallback(
     async (publicKey: string): Promise<User> => {
@@ -86,36 +80,8 @@ export const useAuthOperations = ({
       const deviceInfo = await DeviceManager.getDeviceInfo();
       const deviceName = deviceInfo.deviceName || DeviceManager.getDefaultDeviceName();
 
-      let challenge: string;
-      let isOffline = false;
-
-      // Try to request challenge from server (online)
-      try {
-        const challengeResponse = await oxyServices.requestChallenge(publicKey);
-        challenge = challengeResponse.challenge;
-      } catch (error) {
-        // Network error - generate challenge locally for offline sign-in
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const isNetworkError = 
-          errorMessage.includes('Network') ||
-          errorMessage.includes('network') ||
-          errorMessage.includes('Failed to fetch') ||
-          errorMessage.includes('fetch failed') ||
-          (isErrorWithCodeOrStatus(error) && error.code === 'NETWORK_ERROR') ||
-          (isErrorWithCodeOrStatus(error) && error.status === 0);
-
-        if (isNetworkError) {
-          if (__DEV__ && logger) {
-            logger('Network unavailable, performing offline sign-in');
-          }
-          // Generate challenge locally
-          challenge = await SignatureService.generateChallenge();
-          isOffline = true;
-        } else {
-          // Re-throw non-network errors
-          throw error;
-        }
-      }
+      const challengeResponse = await oxyServices.requestChallenge(publicKey);
+      const challenge = challengeResponse.challenge;
 
       // Note: Biometric authentication check should be handled by the app layer
       // (e.g., accounts app) before calling signIn. The biometric preference is stored
@@ -127,123 +93,65 @@ export const useAuthOperations = ({
       let fullUser: User;
       let sessionResponse: SessionLoginResponse;
 
-      if (isOffline) {
-        // Offline sign-in: create local session and minimal user object
-        if (__DEV__ && logger) {
-          logger('Creating offline session');
-        }
-
-        // Generate a local session ID using cryptographically secure randomness
-        const Crypto = await import('expo-crypto');
-        const localSessionId = `offline_${Crypto.randomUUID()}`;
-        const localDeviceId = `device_${Crypto.randomUUID()}`;
-        const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(); // 7 days
-
-        // Create minimal user object with publicKey as id
-        fullUser = {
-          id: publicKey, // Use publicKey as id (per migration document)
-          publicKey,
-          username: '',
-          privacySettings: {},
-        } as User;
-
-        sessionResponse = {
-          sessionId: localSessionId,
-          deviceId: localDeviceId,
-          expiresAt,
-          user: {
-            id: publicKey,
-            username: '',
-          },
-        };
-
-        // Store offline session locally
-        const offlineSession: ClientSession = {
-          sessionId: localSessionId,
-          deviceId: localDeviceId,
-          expiresAt,
-          lastActive: new Date().toISOString(),
-          userId: publicKey,
-          isCurrent: true,
-        };
-
-        setActiveSessionId(localSessionId);
-        await saveActiveSessionId(localSessionId);
-        updateSessions([offlineSession], { merge: true });
-
-        // Mark session as offline for later sync
-        if (storage) {
-          await storage.setItem(`oxy_session_${localSessionId}_offline`, 'true');
-        }
-
+      // `verifyChallenge` plants the first access token internally, mirroring
+      // `claimSessionByToken`, so the client is authenticated as soon as this
+      // resolves.
+      sessionResponse = await oxyServices.verifyChallenge(
+        publicKey,
+        challenge,
+        signature,
+        timestamp,
+        deviceName,
+        deviceFingerprint,
+      );
+
+      // Get full user data
+      fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
+
+      // Fetch device sessions
+      let allDeviceSessions: ClientSession[] = [];
+      try {
+        allDeviceSessions = await fetchSessionsWithFallback(oxyServices, sessionResponse.sessionId, {
+          fallbackDeviceId: sessionResponse.deviceId,
+          fallbackUserId: fullUser.id,
+          logger,
+        });
+      } catch (error) {
         if (__DEV__ && logger) {
-          logger('Offline sign-in successful');
+          logger('Failed to fetch device sessions after login', error);
         }
-      } else {
-        // Online sign-in: use normal flow.
-        // Verify and create session. `verifyChallenge` plants the first
-        // access token (and refresh token) from the `/auth/verify` response
-        // body internally — mirroring `claimSessionByToken` — so the client is
-        // authenticated as soon as this resolves. Session IDs are not public
-        // token-minting credentials; a token-less verify response simply leaves
-        // the client without a bearer here.
-        sessionResponse = await oxyServices.verifyChallenge(
-          publicKey,
-          challenge,
-          signature,
-          timestamp,
-          deviceName,
-          deviceFingerprint,
-        );
+      }
 
-        // Get full user data
-        fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
+      // Check for existing session for same user and switch to it to avoid duplicates
+      const existingSession = allDeviceSessions.find(
+        (session) =>
+          session.userId?.toString() === fullUser.id?.toString() &&
+          session.sessionId !== sessionResponse.sessionId,
+      );
 
-        // Fetch device sessions
-        let allDeviceSessions: ClientSession[] = [];
+      if (existingSession) {
+        // Switch to existing session instead of creating duplicate
         try {
-          allDeviceSessions = await fetchSessionsWithFallback(oxyServices, sessionResponse.sessionId, {
-            fallbackDeviceId: sessionResponse.deviceId,
-            fallbackUserId: fullUser.id,
-            logger,
-          });
-        } catch (error) {
+          await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
+        } catch (logoutError) {
+          // Non-critical - continue to switch session even if logout fails
           if (__DEV__ && logger) {
-            logger('Failed to fetch device sessions after login', error);
+            logger('Failed to logout duplicate session, continuing with switch', logoutError);
           }
         }
-
-        // Check for existing session for same user and switch to it to avoid duplicates
-        const existingSession = allDeviceSessions.find(
-          (session) =>
-            session.userId?.toString() === fullUser.id?.toString() &&
-            session.sessionId !== sessionResponse.sessionId,
+        await switchSession(existingSession.sessionId);
+        updateSessions(
+          allDeviceSessions.filter((session) => session.sessionId !== sessionResponse.sessionId),
+          { merge: false },
         );
-
-        if (existingSession) {
-          // Switch to existing session instead of creating duplicate
-          try {
-            await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
-          } catch (logoutError) {
-            // Non-critical - continue to switch session even if logout fails
-            if (__DEV__ && logger) {
-              logger('Failed to logout duplicate session, continuing with switch', logoutError);
-            }
-          }
-          await switchSession(existingSession.sessionId);
-          updateSessions(
-            allDeviceSessions.filter((session) => session.sessionId !== sessionResponse.sessionId),
-            { merge: false },
-          );
-          onAuthStateChange?.(fullUser);
-          return fullUser;
-        }
-
-        setActiveSessionId(sessionResponse.sessionId);
-        await saveActiveSessionId(sessionResponse.sessionId);
-        updateSessions(allDeviceSessions, { merge: true });
+        onAuthStateChange?.(fullUser);
+        return fullUser;
       }
 
+      setActiveSessionId(sessionResponse.sessionId);
+      await saveActiveSessionId(sessionResponse.sessionId);
+      updateSessions(allDeviceSessions, { merge: true });
+
       await applyLanguagePreference(fullUser);
       loginSuccess(fullUser);
       onAuthStateChange?.(fullUser);
@@ -260,7 +168,6 @@ export const useAuthOperations = ({
       setActiveSessionId,
       switchSession,
       updateSessions,
-      storage,
     ],
   );
 

package/src/ui/hooks/mutations/useAccountMutations.ts

@@ -7,6 +7,7 @@ import type {
   User,
   UserPreferences,
 } from '@oxyhq/core';
+import type { UserProfileUpdate } from '@oxyhq/contracts';
 import {
   queryKeys,
   invalidateAccountQueries,
@@ -29,7 +30,7 @@ export const useUpdateProfile = () => {
 
   return useMutation({
     mutationKey: [...mutationKeys.account.updateProfile],
-    mutationFn: async (updates: Partial<User>) => {
+    mutationFn: async (updates: UserProfileUpdate) => {
       return authenticatedApiCall<User>(
         oxyServices,
         activeSessionId,
@@ -46,17 +47,18 @@ export const useUpdateProfile = () => {
 
       // Optimistically update
       if (previousUser) {
-        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+        const optimisticUser: User = {
           ...previousUser,
           ...updates,
-        });
+          name: updates.name
+            ? { ...previousUser.name, ...updates.name }
+            : previousUser.name,
+        };
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), optimisticUser);
 
         // Also update profile query if sessionId is available
         if (activeSessionId) {
-          queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), {
-            ...previousUser,
-            ...updates,
-          });
+          queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), optimisticUser);
         }
       }
 
@@ -684,4 +686,3 @@ export const useUploadFile = () => {
     },
   });
 };
-

package/src/ui/hooks/useDeviceAccounts.ts

@@ -252,19 +252,16 @@ export function useDeviceAccounts(): UseDeviceAccountsResult {
 
         if (fromSharedApex) {
             // Shared apex path: every entry carries a real per-account user.
-            built = sharedAccounts.map((entry): DeviceAccount => {
-                // `entry.user` is non-null on the refresh-all path; the core
-                // mixin skips entries without a valid user. The fallback below
-                // keeps rendering defensive if a server response is incomplete.
-                const accountUser: DeviceAccountUser = entry.user ?? {
-                    id: '',
-                    username: '',
-                };
+            built = sharedAccounts.flatMap((entry): DeviceAccount[] => {
+                if (!entry.user) {
+                    return [];
+                }
+                const accountUser: DeviceAccountUser = entry.user;
                 const displayName = getAccountDisplayName(accountUser, locale);
                 const handle = getAccountFallbackHandle(accountUser);
-                const email = entry.user?.email ?? null;
+                const email = entry.user.email ?? null;
                 const secondaryHandle = handle ? `@${handle}` : null;
-                return {
+                return [{
                     sessionId: entry.sessionId,
                     authuser: entry.authuser,
                     // Provisional; finalised by `markCurrentAccount` below so the
@@ -274,37 +271,36 @@ export function useDeviceAccounts(): UseDeviceAccountsResult {
                     // Real email, or null (NEVER synthesized). The UI uses the
                     // `@handle` line only when email is genuinely absent.
                     email: email ?? secondaryHandle,
-                    avatarUrl: resolveAvatarUrl(entry.user?.avatar),
-                    color: entry.user?.color ?? null,
+                    avatarUrl: resolveAvatarUrl(entry.user.avatar),
+                    color: entry.user.color ?? null,
                     user: accountUser,
-                };
+                }];
             });
         } else {
             // Local fallback path: build from the SDK's multi-session store. The
             // active session row gets the full loaded `user`; inactive fallback
             // rows carry only what the `ClientSession` exposes (no synthesized
             // identity — they show the active user's data only when active).
-            built = (sessions ?? []).map((session: ClientSession): DeviceAccount => {
+            built = (sessions ?? []).flatMap((session: ClientSession): DeviceAccount[] => {
                 const isCurrent = session.sessionId === activeSessionId;
-                const accountUser: DeviceAccountUser = isCurrent && user
-                    ? user
-                    : { id: session.userId ?? '', username: '' };
+                if (!isCurrent || !user) {
+                    return [];
+                }
+                const accountUser: DeviceAccountUser = user;
                 const displayName = getAccountDisplayName(accountUser, locale);
                 const handle = getAccountFallbackHandle(accountUser);
-                const email = isCurrent && user?.email ? user.email : null;
+                const email = user.email ?? null;
                 const secondaryHandle = handle ? `@${handle}` : null;
-                const avatar = isCurrent && user ? user.avatar : undefined;
-                const color = isCurrent && user?.color ? user.color : null;
-                return {
+                return [{
                     sessionId: session.sessionId,
                     authuser: session.authuser,
                     isCurrent,
                     displayName,
                     email: email ?? secondaryHandle,
-                    avatarUrl: resolveAvatarUrl(avatar),
-                    color,
+                    avatarUrl: resolveAvatarUrl(user.avatar),
+                    color: user.color ?? null,
                     user: accountUser,
-                };
+                }];
             });
         }
 

package/src/ui/hooks/useProfileEditing.ts

@@ -1,38 +1,51 @@
 import { useCallback } from 'react';
-import { useI18n } from './useI18n';
 import { useUpdateProfile } from './mutations/useAccountMutations';
 import { useAuthStore } from '../stores/authStore';
+import type { UserProfileUpdate } from '@oxyhq/contracts';
+
+interface ProfileLocation {
+    id: string;
+    name: string;
+    label?: string;
+    coordinates?: { lat: number; lon: number };
+}
+
+interface ProfileLinkMetadata {
+    url: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    id: string;
+}
 
 export interface ProfileUpdateData {
-    displayName?: string;
+    firstName?: string;
     lastName?: string;
     username?: string;
     email?: string;
     bio?: string;
     location?: string;
-    locations?: Array<{
-        id: string;
-        name: string;
-        label?: string;
-        coordinates?: { lat: number; lon: number };
-    }>;
+    locations?: ProfileLocation[];
     links?: string[];
-    linksMetadata?: Array<{
-        url: string;
-        title?: string;
-        description?: string;
-        image?: string;
-        id: string;
-    }>;
+    linksMetadata?: ProfileLinkMetadata[];
     avatar?: string;
 }
 
+type ProfileFieldValue = string | ProfileLocation[] | ProfileLinkMetadata[];
+
+function isProfileLocationArray(value: ProfileFieldValue): value is ProfileLocation[] {
+    return Array.isArray(value) && value.every((item) => typeof item === 'object' && item !== null && 'name' in item);
+}
+
+function isProfileLinkMetadataArray(value: ProfileFieldValue): value is ProfileLinkMetadata[] {
+    return Array.isArray(value) && value.every((item) => typeof item === 'object' && item !== null && 'url' in item);
+}
+
 /**
  * Hook for managing profile editing operations
  * Provides functions to update profile fields and handle saving
  */
 export const useProfileEditing = () => {
-    const { t } = useI18n();
     const updateProfileMutation = useUpdateProfile();
 
     /**
@@ -40,7 +53,7 @@ export const useProfileEditing = () => {
      */
     const saveProfile = useCallback(async (updates: ProfileUpdateData) => {
         // Prepare update object
-        const updateData: Record<string, any> = {};
+        const updateData: UserProfileUpdate = {};
 
         if (updates.username !== undefined) {
             updateData.username = updates.username;
@@ -70,11 +83,11 @@ export const useProfileEditing = () => {
         }
 
         // Handle name field
-        if (updates.displayName !== undefined || updates.lastName !== undefined) {
+        if (updates.firstName !== undefined || updates.lastName !== undefined) {
             const currentUser = useAuthStore.getState().user;
             const currentName = currentUser?.name;
             updateData.name = {
-                first: updates.displayName ?? (typeof currentName === 'object' ? currentName?.first : '') ?? '',
+                first: updates.firstName ?? (typeof currentName === 'object' ? currentName?.first : '') ?? '',
                 last: updates.lastName ?? (typeof currentName === 'object' ? currentName?.last : '') ?? '',
             };
         }
@@ -86,33 +99,39 @@ export const useProfileEditing = () => {
             // Error toast is handled by the mutation
             return false;
         }
-    }, [updateProfileMutation, t]);
+    }, [updateProfileMutation]);
 
     /**
      * Update a single profile field
      */
-    const updateField = useCallback(async (field: string, value: any) => {
+    const updateField = useCallback(async (field: string, value: ProfileFieldValue) => {
         const updates: ProfileUpdateData = {};
         
         switch (field) {
-            case 'displayName':
-                updates.displayName = value;
+            case 'firstName':
+                if (typeof value !== 'string') return false;
+                updates.firstName = value;
                 break;
             case 'username':
+                if (typeof value !== 'string') return false;
                 updates.username = value;
                 break;
             case 'email':
+                if (typeof value !== 'string') return false;
                 updates.email = value;
                 break;
             case 'bio':
+                if (typeof value !== 'string') return false;
                 updates.bio = value;
                 break;
             case 'location':
+                if (!isProfileLocationArray(value)) return false;
                 updates.locations = value;
                 break;
             case 'links':
+                if (!isProfileLinkMetadataArray(value)) return false;
                 updates.linksMetadata = value;
-                updates.links = value.map((link: any) => link.url || link);
+                updates.links = value.map((link) => link.url);
                 break;
             default:
                 return false;
@@ -129,9 +148,3 @@ export const useProfileEditing = () => {
 };
 
 
-
-
-
-
-
-

package/src/ui/screens/AppInfoScreen.tsx

@@ -20,7 +20,7 @@ import { SettingsIcon } from '../components/SettingsIcon';
 import { useTheme } from '@oxyhq/bloom/theme';
 import { useColorScheme } from '../hooks/useColorScheme';
 import { Colors } from '../constants/theme';
-import { normalizeColorScheme } from '../utils/themeUtils';
+import { normalizeColorScheme } from '@oxyhq/core';
 import { useOxy } from '../context/OxyContext';
 import { useI18n } from '../hooks/useI18n';
 import { SettingsListGroup, SettingsListItem } from '@oxyhq/bloom/settings-list';

package/src/ui/screens/AvatarCropScreen.tsx

@@ -93,6 +93,7 @@ const ZOOM_CHIP_FADE_DURATION_MS = 200;
 const CANVAS_BG = '#000000';
 const RING_COLOR = '#ffffff';
 const RING_WIDTH = 2;
+const REMOTE_HTTP_URI_PATTERN = /^https?:\/\//i;
 
 /**
  * Clamp the translation so the image edges never leave the viewport at any
@@ -154,6 +155,64 @@ async function loadImageManipulator(): Promise<ImageManipulatorModule> {
     }
 }
 
+interface PreparedManipulatorImage {
+    uri: string;
+    cleanup?: () => void;
+}
+
+function isCanvasLoadFailure(err: unknown): boolean {
+    return (
+        Platform.OS === 'web' &&
+        typeof HTMLCanvasElement !== 'undefined' &&
+        err instanceof HTMLCanvasElement
+    );
+}
+
+function normalizeCropError(err: unknown): Error {
+    if (err instanceof Error) return err;
+    if (isCanvasLoadFailure(err)) {
+        return new Error('Image could not be loaded for cropping');
+    }
+    if (typeof err === 'string' && err.trim()) {
+        return new Error(err.trim());
+    }
+    return new Error('Failed to crop image');
+}
+
+async function prepareImageForManipulator(uri: string): Promise<PreparedManipulatorImage> {
+    if (Platform.OS !== 'web' || !REMOTE_HTTP_URI_PATTERN.test(uri)) {
+        return { uri };
+    }
+
+    let response: Response;
+    try {
+        response = await fetch(uri);
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Image could not be loaded for cropping: ${message}`);
+    }
+
+    if (!response.ok) {
+        throw new Error(`Image could not be loaded for cropping (${response.status})`);
+    }
+
+    const blob = await response.blob();
+    if (blob.size <= 0) {
+        throw new Error('Image could not be loaded for cropping');
+    }
+
+    const contentType = response.headers.get('content-type') || blob.type;
+    if (contentType && !contentType.toLowerCase().startsWith('image/')) {
+        throw new Error('Selected file is not an image');
+    }
+
+    const objectUrl = URL.createObjectURL(blob);
+    return {
+        uri: objectUrl,
+        cleanup: () => URL.revokeObjectURL(objectUrl),
+    };
+}
+
 /**
  * Haptic feedback wrapper. `expo-haptics` is an optional dependency — when not
  * installed (or on web), all calls degrade silently. We resolve the module once
@@ -622,6 +681,7 @@ const AvatarCropScreen: React.FC<AvatarCropScreenProps> = ({
         }
 
         setIsProcessing(true);
+        let preparedImageCleanup: (() => void) | undefined;
         try {
             const { manipulateAsync, SaveFormat } = await loadImageManipulator();
 
@@ -665,8 +725,10 @@ const AvatarCropScreen: React.FC<AvatarCropScreenProps> = ({
                 },
             );
 
+            const preparedImage = await prepareImageForManipulator(imageUri);
+            preparedImageCleanup = preparedImage.cleanup;
             const result = await manipulateAsync(
-                imageUri,
+                preparedImage.uri,
                 [
                     {
                         crop: {
@@ -701,13 +763,14 @@ const AvatarCropScreen: React.FC<AvatarCropScreenProps> = ({
             // success toast (uploads typically toast their own outcome).
             onClose?.();
         } catch (err) {
-            logger.error('handleConfirm failed', err, { component: LOG_COMPONENT });
-            const message = err instanceof Error ? err.message : undefined;
+            const normalizedError = normalizeCropError(err);
+            logger.error('handleConfirm failed', normalizedError, { component: LOG_COMPONENT });
             void hapticNotification('error');
             toast.error(
-                message || t('editProfile.toasts.cropFailed') || 'Failed to crop image',
+                normalizedError.message || t('editProfile.toasts.cropFailed') || 'Failed to crop image',
             );
         } finally {
+            preparedImageCleanup?.();
             setIsProcessing(false);
         }
     }, [baseFit, imageUri, naturalSize, onClose, onConfirm, t]);

package/src/ui/screens/ConnectedAppsScreen.tsx

@@ -15,7 +15,7 @@ import { useAuthorizedApps } from '../hooks/queries/useAccountQueries';
 import { useRevokeAuthorizedApp } from '../hooks/mutations/useAccountMutations';
 import { useColorScheme } from '../hooks/useColorScheme';
 import { Colors } from '../constants/theme';
-import { normalizeColorScheme, normalizeTheme } from '../utils/themeUtils';
+import { normalizeColorScheme, normalizeTheme } from '@oxyhq/core';
 
 /**
  * Format an ISO-8601 timestamp as a human-readable relative time. Mirrors the