@ethora/chat-component-rn 26.6.12 → 26.6.13

package/src/helpers/resolveInitBeforeLoadUser.ts

@@ -1,4 +1,5 @@
-import http, { setBaseURL } from '../networking/apiClient';
+import { setBaseURL } from '../networking/apiClient';
+import { refreshAuthTokens, isRefreshFatalError } from '../networking/authRefresh';
 import { loginViaJwt } from '../networking/api-requests/auth.api';
 import { getMyUser } from '../networking/api-requests/user.api';
 import { IConfig, User } from '../types/types';
@@ -46,15 +47,109 @@ const normalizeUserForXmpp = (user?: User | null): User | null => {
   return { ...user, xmppUsername: normalizedXmppUsername };
 };
 
+// Hermes has no atob/Buffer; hand-decode just enough base64url to read a
+// JWT's `iat`. Claims are ASCII so the byte-per-char string is fine.
+const B64_ALPHABET =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+const readJwtIat = (token?: string | null): number => {
+  if (!token || typeof token !== 'string') {return 0;}
+  const part = token.split('.')[1];
+  if (!part) {return 0;}
+  try {
+    const clean = part.replace(/-/g, '+').replace(/_/g, '/');
+    let out = '';
+    let buffer = 0;
+    let bits = 0;
+    for (let i = 0; i < clean.length; i++) {
+      const idx = B64_ALPHABET.indexOf(clean[i]);
+      if (idx === -1) {continue;}
+      buffer = (buffer << 6) | idx;
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        out += String.fromCharCode((buffer >> bits) & 0xff);
+      }
+    }
+    const iat = JSON.parse(out)?.iat;
+    return typeof iat === 'number' ? iat : 0;
+  } catch {
+    return 0;
+  }
+};
+
+/**
+ * A `userLogin.user` is typically a snapshot the host captured at ITS
+ * login time and re-presents verbatim on every mount, while this SDK
+ * keeps rotating the session and persisting the newest pair to
+ * `ETHORA_USER`. Taking the snapshot as-is therefore discards the live
+ * session in favour of an ever-aging copy: media goes blank the moment
+ * the snapshot has no `fileToken` (secure-files URLs 401 without it),
+ * and once the snapshot's refresh token ages out entirely the account
+ * looks dead even though the SDK held a working session all along.
+ *
+ * So, for the SAME account only, prefer whichever refresh pair was
+ * minted later (JWT `iat` decides — a host that genuinely re-logged-in
+ * hands us newer tokens and wins), and fill in a missing `fileToken`
+ * from the persisted copy either way.
+ */
+const adoptFresherPersistedSession = async (candidate: User): Promise<User> => {
+  try {
+    const stored = await asyncLocalStorage<User>(
+      localStorageConstants.ETHORA_USER
+    ).get();
+    if (!stored) {return candidate;}
+
+    const sameUser =
+      (candidate._id && stored._id && candidate._id === stored._id) ||
+      (candidate.xmppUsername &&
+        stored.xmppUsername &&
+        candidate.xmppUsername === stored.xmppUsername);
+    if (!sameUser) {return candidate;}
+
+    const merged = { ...candidate };
+
+    if (
+      stored.refreshToken &&
+      readJwtIat(stored.refreshToken) > readJwtIat(candidate.refreshToken)
+    ) {
+      merged.refreshToken = stored.refreshToken;
+      if (stored.token) {merged.token = stored.token;}
+      if (stored.fileToken) {merged.fileToken = stored.fileToken;}
+    }
+
+    if (!merged.fileToken && stored.fileToken) {
+      merged.fileToken = stored.fileToken;
+    }
+
+    return merged;
+  } catch {
+    return candidate;
+  }
+};
+
+/**
+ * Bootstrap rotation.
+ *
+ * Was a second, independent `/users/login/refresh` caller that bypassed
+ * every lock in the SDK — and, worse, only wrote the rotated token to
+ * the store on the happy path, so several of the early-return branches
+ * below used to drop it. Under the backend's reuse detection a dropped
+ * rotation means the next launch presents a burned token and the
+ * session is killed.
+ *
+ * `refreshAuthTokens` persists the new pair before it resolves, so by
+ * the time this returns the rotation is safe no matter which branch the
+ * caller takes afterwards. The explicit token is required here: during
+ * bootstrap the candidate session isn't in the store yet.
+ */
 const refreshWithToken = async (refreshToken: string) => {
-  const response = await http.post(
-    '/users/login/refresh',
-    {},
-    { headers: { Authorization: refreshToken } }
-  );
+  const result = await refreshAuthTokens({ refreshToken });
   return {
-    token: response?.data?.token || '',
-    refreshToken: response?.data?.refreshToken || refreshToken,
+    token: result.token,
+    refreshToken: result.refreshToken || refreshToken,
+    xmppPassword: result.xmppPassword || '',
+    fileToken: result.fileToken || '',
   };
 };
 
@@ -87,11 +182,15 @@ const tryHydrateViaMy = async (
 
   let workingToken = candidate?.token || '';
   let workingRefresh = candidate?.refreshToken || '';
+  let rotatedXmppPassword = '';
+  let workingFileToken = candidate?.fileToken || '';
 
   const candidateWithCurrentTokens = (): User => ({
     ...candidate,
     token: workingToken || candidate.token,
     refreshToken: workingRefresh || candidate.refreshToken,
+    xmppPassword: rotatedXmppPassword || candidate.xmppPassword,
+    fileToken: workingFileToken || candidate.fileToken,
   });
 
   const fallbackWithCreds = (): User | null => {
@@ -107,6 +206,8 @@ const tryHydrateViaMy = async (
       if (merged) {
         merged.token = workingToken || merged.token;
         merged.refreshToken = workingRefresh || merged.refreshToken;
+        merged.xmppPassword = rotatedXmppPassword || merged.xmppPassword;
+        merged.fileToken = workingFileToken || merged.fileToken;
       }
       return merged;
     } catch (error) {
@@ -127,6 +228,8 @@ const tryHydrateViaMy = async (
     const refreshed = await refreshWithToken(workingRefresh);
     workingToken = refreshed.token;
     workingRefresh = refreshed.refreshToken;
+    rotatedXmppPassword = refreshed.xmppPassword || rotatedXmppPassword;
+    workingFileToken = refreshed.fileToken || workingFileToken;
 
     try {
       const myUser = await getMyUser({ token: workingToken, endpoint: myEndpoint });
@@ -136,6 +239,8 @@ const tryHydrateViaMy = async (
       if (merged) {
         merged.token = workingToken || merged.token;
         merged.refreshToken = workingRefresh || merged.refreshToken;
+        merged.xmppPassword = rotatedXmppPassword || merged.xmppPassword;
+        merged.fileToken = workingFileToken || merged.fileToken;
       }
       return merged;
     } catch (myError) {
@@ -147,6 +252,11 @@ const tryHydrateViaMy = async (
     }
   } catch (error) {
     if (signal?.aborted || isAbortError(error)) {return null;}
+    // A fatal refresh verdict (reuse detected / token not found / stale
+    // with nothing newer around) carries no HTTP response, so it would
+    // otherwise fall through to `throw` — the session is simply dead,
+    // which for bootstrap means "nothing to restore".
+    if (isRefreshFatalError(error)) {return null;}
     if (isAuthError(error)) {return null;}
     throw error;
   }
@@ -162,13 +272,15 @@ export const resolveInitBeforeLoadUser = async (
     setBaseURL(config.baseUrl, config.customAppToken);
   }
 
-  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/v1/users/my';
 
   // Priority 1: explicit userLogin
   const explicitUser = config?.userLogin?.enabled ? config?.userLogin?.user : null;
   if (explicitUser) {
     const candidate = normalizeUserForXmpp(explicitUser);
-    if (candidate && hasXmppCredentials(candidate)) {return candidate;}
+    if (candidate && hasXmppCredentials(candidate)) {
+      return await adoptFresherPersistedSession(candidate);
+    }
 
     const hydrated = await tryHydrateViaMy(explicitUser, myEndpoint, signal).catch(
       () => null
@@ -275,7 +387,7 @@ export const refreshUserCredentialsForXmpp = async (
     }
   }
 
-  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/users/my';
+  const myEndpoint = config?.initBeforeLoadAuth?.myEndpoint || '/v1/users/my';
 
   // Priority 2: redux store user (covers userLogin + customLogin +
   // anything previously persisted into chatSettingStore.user). The

package/src/helpers/secureFileUrl.ts

@@ -0,0 +1,103 @@
+import { store } from '../roomStore';
+import { getCurrentBaseURL } from '../networking/apiClient';
+import { refreshAuthTokens } from '../networking/authRefresh';
+
+const SECURE_FILES_HOST_PREFIX = 'secure-files.';
+const SECURE_MEDIA_PATH_PREFIX = '/secure-media/';
+
+const FILE_TOKEN_PARAM = 'ft';
+
+export const resolveFileUrl = (url?: string | null): string => {
+  if (!url) {return '';}
+  // Any scheme at all — http(s), data, file, content, blob.
+  if (/^[a-z][a-z0-9+.-]*:/i.test(url)) {return url;}
+  if (!url.startsWith('/')) {return url;}
+
+  const base = getCurrentBaseURL().replace(/\/+$/, '');
+  return base ? `${base}${url}` : url;
+};
+
+export const isSecureFileUrl = (url?: string | null): boolean => {
+  if (!url) {return false;}
+
+  const path = url.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, '');
+  if (path.startsWith(SECURE_MEDIA_PATH_PREFIX)) {return true;}
+
+  const match = /^https?:\/\/(?:[^@/]+@)?([^:/?#]+)/i.exec(url);
+  if (!match) {return false;}
+  return match[1].toLowerCase().startsWith(SECURE_FILES_HOST_PREFIX);
+};
+
+export const appendFileToken = (
+  url: string | null | undefined,
+  fileToken: string | null | undefined
+): string => {
+  if (!url) {return '';}
+
+  const resolved = resolveFileUrl(url);
+  if (!fileToken || !isSecureFileUrl(resolved)) {return resolved;}
+  url = resolved;
+
+  const hashIndex = url.indexOf('#');
+  const hash = hashIndex === -1 ? '' : url.slice(hashIndex);
+  const withoutHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
+
+  const queryIndex = withoutHash.indexOf('?');
+  const base = queryIndex === -1 ? withoutHash : withoutHash.slice(0, queryIndex);
+  const query = queryIndex === -1 ? '' : withoutHash.slice(queryIndex + 1);
+
+  const params = query
+    .split('&')
+    .filter(Boolean)
+    .filter((pair) => pair.split('=')[0] !== FILE_TOKEN_PARAM);
+
+  params.push(`${FILE_TOKEN_PARAM}=${encodeURIComponent(fileToken)}`);
+
+  return `${base}?${params.join('&')}${hash}`;
+};
+
+export const withFileToken = (url?: string | null): string =>
+  appendFileToken(
+    url,
+    store.getState().chatSettingStore?.user?.fileToken || ''
+  );
+
+const RECOVERY_COOLDOWN_MS = 30_000;
+let recoveryInFlight: Promise<boolean> | null = null;
+let lastRecoveryAt = 0;
+
+export const requestFileTokenRecovery = (): Promise<boolean> => {
+  if (recoveryInFlight) {return recoveryInFlight;}
+
+  const now = Date.now();
+  if (now - lastRecoveryAt < RECOVERY_COOLDOWN_MS) {
+    return Promise.resolve(false);
+  }
+  lastRecoveryAt = now;
+
+  const state = store.getState();
+  const refreshConfig = state.chatSettingStore?.config?.refreshTokens;
+  const user = state.chatSettingStore?.user;
+
+  if (!refreshConfig?.enabled) {return Promise.resolve(false);}
+
+  const run = async (): Promise<boolean> => {
+    if (!refreshConfig.refreshFunction && !user?.refreshToken) {return false;}
+
+    const tokens = await refreshAuthTokens();
+    return Boolean(tokens.fileToken);
+  };
+
+  recoveryInFlight = run()
+    .catch(() => false)
+    .finally(() => {
+      recoveryInFlight = null;
+    });
+
+  return recoveryInFlight;
+};
+
+export const __resetFileTokenRecoveryForTests = (): void => {
+  recoveryInFlight = null;
+  lastRecoveryAt = 0;
+};

package/src/hooks/useChatWrapperInit.ts

@@ -10,7 +10,7 @@ import { chatAutoEnterer } from '../helpers/chatAutoEnterer';
 import { initRoomsPresence } from '../helpers/initRoomsPresence';
 import { updatedChatLastTimestamps } from '../helpers/updatedChatLastTimestamps';
 import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
-import { refresh } from '../networking/apiClient';
+import { refreshAuthTokensQuietly } from '../networking/authRefresh';
 import { setLangSource, setConfig } from '../roomStore/chatSettingsSlice';
 import { setIsLoading } from '../roomStore/roomsSlice';
 import { useRoomState } from './useRoomState';
@@ -179,7 +179,7 @@ const useChatWrapperInit = ({
               }
 
               {
-                config?.refreshTokens?.enabled && refresh();
+                config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
               }
             } catch (error) {
               console.error(' Error during initialization', error);
@@ -233,7 +233,7 @@ const useChatWrapperInit = ({
               setConnectionLost(false);
             }
             {
-              config?.refreshTokens?.enabled && refresh();
+              config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
             }
           }
         }

package/src/hooks/useFileToken.ts

@@ -0,0 +1,7 @@
+import { useSelector } from 'react-redux';
+import { RootState } from '../roomStore';
+
+export const useFileToken = (): string =>
+  useSelector(
+    (state: RootState) => state.chatSettingStore.user?.fileToken || ''
+  );

package/src/hooks/useSendMessage.tsx

@@ -9,7 +9,7 @@ import {
   clearMessageFailure,
   markMessageFailed,
 } from '../roomStore/roomHeapSlice';
-import { uploadFileMultipart } from '../networking/api-requests/auth.api';
+import { uploadFileV2 } from '../networking/api-requests/auth.api';
 import { enqueueOutboundSend } from '../networking/outboundQueue';
 import { RootState, store } from '../roomStore';
 import { getGlobalXmppClient } from '../utils/clientRegistry';
@@ -182,13 +182,34 @@ export const useSendMessage = (_configOverride?: IConfig) => {
       // PENDING_WATCHDOG_MS, flip the bubble to "failed → tap to
       // retry". We check at fire-time whether the message is still
       // pending and not already marked failed by the catch path.
-      const watchdogTimer = setTimeout(() => {
+      // One-shot extension for the case below. Declared outside the
+      // timer so the rescheduled run can't extend again.
+      let watchdogExtended = false;
+      const runWatchdog = () => {
         const state = reduxStore.getState();
         const roomMsgs = state.rooms?.rooms?.[activeRoomJID]?.messages || [];
         const stillPending = roomMsgs.find(
           (m: any) => m.id === optimisticId && m.pending
         );
         const alreadyFailed = state.roomHeapSlice?.failedMessages?.[optimisticId];
+
+        // Don't call it a failure while the stream is still coming back.
+        // A reconnect tears the old client down and builds a new one, and
+        // any echo in flight during that window is simply lost — the
+        // message may well have been delivered (it has been observed
+        // arriving twice on the receiving side). Failing it here shows a
+        // red "tap to retry" under a message that actually went through.
+        // Give the reconnect one more window to produce an echo, once.
+        const streamOnline = getGlobalXmppClient()?.status === 'online';
+        if (stillPending && !alreadyFailed && !streamOnline && !watchdogExtended) {
+          watchdogExtended = true;
+          console.warn(
+            `Send watchdog — ${optimisticId} still pending but the stream is not online; extending one window`
+          );
+          watchdogTimer = setTimeout(runWatchdog, PENDING_WATCHDOG_MS);
+          return;
+        }
+
         if (stillPending && !alreadyFailed) {
           console.warn(
             `Send watchdog fired — message ${optimisticId} stuck pending > ${PENDING_WATCHDOG_MS}ms; marking failed`
@@ -211,7 +232,9 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             messageType: 'text',
           });
         }
-      }, PENDING_WATCHDOG_MS);
+      };
+
+      let watchdogTimer = setTimeout(runWatchdog, PENDING_WATCHDOG_MS);
 
       try {
         // The single send closure, used both for the immediate send and for
@@ -467,19 +490,11 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         name: data?.name || data?.fileName || `media_${Date.now()}`,
       };
 
-      // Mirror the web client: a single multipart POST to /files/ with
-      // the file under the plural "files" field. We send it via fetch
-      // (not axios) because RN's fetch sets the multipart boundary on the
-      // Content-Type header correctly. The previous axios fallback omitted
-      // a valid boundary, so the server mis-parsed one file as many and
-      // rejected the request with HTTP 413 "TOO_MANY_FILES". The only
-      // retry is the documented singular-"file" fallback for deployments
-      // that 500 on the plural field (bug #10).
       const tryUpload = async () => {
         const fd = new FormData();
         fd.append('files', fileBlob as any);
         try {
-          return await uploadFileMultipart(fd);
+          return await uploadFileV2(fd, activeRoomJID);
         } catch (err: any) {
           if (err?.response?.status === 500) {
             console.warn(
@@ -488,7 +503,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             );
             const fd2 = new FormData();
             fd2.append('file', fileBlob as any);
-            return await uploadFileMultipart(fd2);
+            return await uploadFileV2(fd2, activeRoomJID);
           }
           throw err;
         }

package/src/main.ts

@@ -7,7 +7,10 @@
  *
  *   <Chat
  *     config={{
- *       baseUrl: 'https://api.chat.ethora.com/v1',
+ *       // The API ROOT — the SDK versions every path itself
+ *       // (`/v1/...`, `/v2/...`). A legacy `.../v1` is accepted and
+ *       // normalised, so existing integrations keep working.
+ *       baseUrl: 'https://api.chat.ethora.com',
  *       xmppSettings: { host: 'xmpp.chat.ethora.com' },
  *       jwtLogin: { enabled: true, token: '<paste JWT>' },
  *       initBeforeLoad: true,
@@ -66,3 +69,21 @@ export type {
 } from './types/types';
 export type { Iso639_1Codes } from './types/models/language.model';
 export type { TranslateMode } from './utils/translateModePolicy';
+
+// Auth-token rotation. Exposed so hosts can drive a refresh themselves
+// (it is deduped and shares the SDK's lock) and, more importantly, so
+// they can tell a dead session from a transient failure: only
+// `RefreshFatalError` means "log the user out". Every other rejection —
+// network, 5xx, a lost REFRESH_IN_PROGRESS race — must leave the
+// session alone.
+export {
+  refreshAuthTokens,
+  refreshAuthTokensQuietly,
+  RefreshFatalError,
+  isRefreshFatalError,
+} from './networking/authRefresh';
+export type {
+  RefreshErrorCode,
+  RefreshResult,
+  RefreshOptions,
+} from './networking/authRefresh';