@ethora/chat-component-rn 26.8.6 → 26.8.8

package/src/networking/api-requests/auth.api.ts

@@ -266,10 +266,18 @@ const canFallBackToLegacyUpload = (error: unknown): boolean => {
 
 let secureUploadUnavailable = false;
 
+export interface UploadFileOptions {
+  clientEncrypted?: boolean;
+}
+
 export async function uploadFileV2(
   formData: FormData,
-  activeRoomJID: string
+  activeRoomJID: string,
+  options: UploadFileOptions = {}
 ): Promise<{ data: any }> {
+  if (options.clientEncrypted) {
+    formData.append('clientEncrypted', 'true');
+  }
   const chatName = (activeRoomJID || '').split('@')[0];
   const apiRoot = getCurrentBaseURL().replace(/\/$/, '');
 

package/src/networking/api-requests/rooms.api.ts

@@ -1,6 +1,6 @@
 import { ApiRoom, DeleteRoomMember, PostAddRoomMember, PostReportRoom, PostRoom, RoomMember } from '../../types/models/room.model';
 import { store } from '../../roomStore';
-import { addRoom, mergeUsersSet } from '../../roomStore/roomsSlice';
+import { addRoom, mergeUsersSet, updateRoom } from '../../roomStore/roomsSlice';
 import { IRoom } from '../../types/types';
 import http from '../apiClient';
 
@@ -19,6 +19,11 @@ import http from '../apiClient';
  *   - `_id`            (fallback)
  *   - `xmppUsername`   (raw + localpart) when the API does return one
  */
+const usableImage = (value: unknown): string => {
+  const url = typeof value === 'string' ? value.trim() : '';
+  return url && url !== 'none' ? url : '';
+};
+
 function dispatchUsersSetFromRestItems(items: ApiRoom[]): void {
   if (!items?.length) {return;}
   const ownXmpp = String(
@@ -26,16 +31,24 @@ function dispatchUsersSetFromRestItems(items: ApiRoom[]): void {
   );
   const appId = ownXmpp.includes('_') ? ownXmpp.split('_')[0] : '';
 
+  const known = (store.getState().rooms?.usersSet || {}) as Record<string, RoomMember>;
   const members: Record<string, RoomMember> = {};
   for (const item of items) {
     const list = Array.isArray((item as any)?.members) ? (item as any).members : [];
     for (const m of list) {
       if (!m) {continue;}
+      const before: RoomMember | undefined =
+        (m._id && (members[m._id] || known[m._id])) || undefined;
       const entry: RoomMember = {
-        firstName: m.firstName || '',
-        lastName: m.lastName || '',
+        firstName: m.firstName ?? before?.firstName ?? '',
+        lastName: m.lastName ?? before?.lastName ?? '',
         xmppUsername: m.xmppUsername || (appId && m._id ? `${appId}_${m._id}` : m._id || ''),
         _id: m._id || '',
+        profileImage:
+          m.profileImage !== undefined
+            ? usableImage(m.profileImage)
+            : before?.profileImage ?? '',
+        description: m.description ?? before?.description,
         role: m.role,
         ban_status: m.ban_status,
         last_active: m.last_active,
@@ -85,9 +98,53 @@ interface ApiRoomMember {
  *      manifested as a phantom "ethora" room stub on third-party servers,
  *      customer-reported #23)
  */
+export function memberAccount(member: any, appId: string): string {
+  const explicit = String(member?.xmppUsername || '').split('@')[0];
+  if (explicit) {return explicit;}
+  return appId && member?._id ? `${appId}_${member._id}` : '';
+}
+
+export function ownAppId(): string {
+  const ownXmpp = String(
+    store.getState().chatSettingStore?.user?.xmppUsername || ''
+  );
+  return ownXmpp.includes('_') ? ownXmpp.split('_')[0]! : '';
+}
+
+const toRoomMembers = (members: any[] | undefined): RoomMember[] => {
+  const known = (store.getState().rooms?.usersSet || {}) as Record<string, RoomMember>;
+  return (members || []).map((m: any) => ({
+    firstName: m.firstName,
+    lastName: m.lastName,
+    profileImage:
+      m.profileImage !== undefined
+        ? usableImage(m.profileImage)
+        : known[m._id]?.profileImage ?? '',
+    xmppUsername: m._id || '',
+    role: m.role,
+    ban_status: m.ban_status,
+    last_active: m.last_active,
+    jid: m.jid || '',
+  })) as any;
+};
+
+const toE2eeMembers = (members: any[] | undefined, appId: string): RoomMember[] =>
+  (members || [])
+    .map((m: any) => ({
+      _id: m._id || '',
+      firstName: m.firstName || '',
+      lastName: m.lastName || '',
+      xmppUsername: memberAccount(m, appId),
+    }))
+    .filter((m) => m.xmppUsername) as RoomMember[];
+
+const memberCount = (item: ApiRoom): number =>
+  item.usersCnt ?? item.participants ?? item.members?.length ?? 0;
+
 function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
   if (!items?.length) return;
   const config = store.getState().chatSettingStore?.config as any;
+  const appId = ownAppId();
   // Best: explicit xmpp settings.
   let host: string | undefined =
     config?.xmppSettings?.host ||
@@ -118,12 +175,16 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
       jid = `${item.name}@${conference}`;
     }
     if (!jid.includes('@')) continue;
+    const known = store.getState().rooms.rooms?.[jid];
+    const preview = (item.members?.length ?? 0) < memberCount(item);
+    const keep = <T,>(fresh: T[], existing: T[] | undefined): T[] =>
+      preview && (existing?.length ?? 0) > fresh.length ? existing! : fresh;
     const room: IRoom = {
       id: item._id || jid,
       jid,
       name: item.name,
       title: item.title || item.name,
-      usersCnt: item.participants ?? item.members?.length ?? 0,
+      usersCnt: memberCount(item),
       messages: [],
       isLoading: false,
       roomBg: '',
@@ -133,18 +194,14 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
       muted: item.muted === true,
       description: (item as any).description,
       type: (item as any).type,
-      // ChatProfileModal renders this list under the description/type
-      // fields. The REST API returns `members` (an array of {_id,
-      // firstName?, lastName?}); map to the shape RoomMember expects.
-      roomMembers: (item.members || []).map((m: any) => ({
-        firstName: m.firstName,
-        lastName: m.lastName,
-        xmppUsername: m._id || '',
-        role: m.role,
-        ban_status: m.ban_status,
-        last_active: m.last_active,
-        jid: m.jid || '',
-      })) as any,
+
+      ...(item.e2ee === true
+        ? {
+            e2ee: true,
+            members: keep(toE2eeMembers(item.members, appId), known?.members),
+          }
+        : {}),
+      roomMembers: keep(toRoomMembers(item.members), known?.roomMembers),
     };
     store.dispatch(addRoom({ roomData: room }));
   }
@@ -152,6 +209,51 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
   dispatchUsersSetFromRestItems(items);
 }
 
+const ROOM_MEMBERS_TTL_MS = 5 * 60_000;
+const roomMembersLoads = new Map<string, { at: number; done: Promise<boolean> }>();
+
+export function loadRoomMembers(roomJid: string): Promise<boolean> {
+  const jid = String(roomJid || '').split('/')[0]!;
+  const room = store.getState().rooms.rooms?.[jid];
+  if (!room) {return Promise.resolve(false);}
+  if ((room.roomMembers?.length ?? 0) >= Number(room.usersCnt || 0)) {
+    return Promise.resolve(false);
+  }
+  const running = roomMembersLoads.get(jid);
+  if (running && Date.now() - running.at < ROOM_MEMBERS_TTL_MS) {return running.done;}
+
+  const done = (async () => {
+    try {
+      const response: any = await getRoomByName(jid.split('@')[0]!);
+      const item: ApiRoom = response?.result ?? response;
+      const members = Array.isArray(item?.members) ? item.members : [];
+      if (members.length === 0) {return false;}
+      dispatchUsersSetFromRestItems([item]);
+      const current = store.getState().rooms.rooms?.[jid];
+      if (!current) {return false;}
+      store.dispatch(
+        updateRoom({
+          jid,
+          updates: {
+            roomMembers: toRoomMembers(members),
+            usersCnt: Math.max(memberCount(item), members.length),
+            ...(current.e2ee
+              ? { members: toE2eeMembers(members, ownAppId()) }
+              : {}),
+          },
+        })
+      );
+      return true;
+    } catch (error) {
+      roomMembersLoads.delete(jid);
+      console.warn('[ethora-rn] rooms.api: could not load room members', jid, error);
+      return false;
+    }
+  })();
+  roomMembersLoads.set(jid, { at: Date.now(), done });
+  return done;
+}
+
 const GET_ROOMS_CACHE_MS = 60_000;
 let getRoomsInFlight: Promise<{ items: ApiRoom[] }> | null = null;
 let getRoomsInFlightToken = '';
@@ -235,14 +337,14 @@ export async function postRoom(data: PostRoom) {
 
 export async function postPrivateRoom(
   username: string,
-  title: string = 'Private chat'
+  e2ee: boolean = false
 ): Promise<ApiRoom> {
   const token = store.getState().chatSettingStore.user.token || '';
 
   try {
     const response = await http.post(
       '/v1/chats/private',
-      { username },
+      e2ee === true ? { username, e2ee: true } : { username },
       {
         headers: {
           Authorization: token,
@@ -391,6 +493,7 @@ export async function createChatCall(
 }
 
 export function clearRoomsRestCache() {
+  roomMembersLoads.clear();
   lastGetRoomsResponse = null;
   lastGetRoomsResponseAt = 0;
   lastGetRoomsResponseToken = '';

package/src/networking/api-requests/user.api.ts

@@ -59,6 +59,15 @@ export function updateMe(data: any) {
   return http.put('/v1/users', data);
 }
 
+/**
+ * Change the account password. The backend checks `currentPassword` and
+ * answers with a 4xx and a reason when it does not match or the new one is
+ * not acceptable; the caller shows that reason.
+ */
+export function changePassword(currentPassword: string, newPassword: string) {
+  return http.put('/v2/users/me/password', { currentPassword, newPassword });
+}
+
 export async function updateProfile(fd: FormData): Promise<{ user: User }> {
   const token = store.getState().chatSettingStore.user.token || '';
 

package/src/networking/stanzaHandlers.ts

@@ -132,6 +132,7 @@ const onRealtimeMessage = async (stanza: Element) => {
       // (stanza handler, not a component), so resolve the locale from the
       // store directly and call `translateKey` instead of `useT()`.
       const locale =
+        state.chatSettingStore.uiLocale ||
         state.chatSettingStore.config?.i18n?.locale ||
         state.chatSettingStore.langSource;
       const overrides = state.chatSettingStore.config?.i18n?.strings;

package/src/networking/xmpp/handleStanzas.xmpp.ts

@@ -20,6 +20,12 @@ import {
 } from '../stanzaHandlers';
 import XmppClient from '../xmppClient';
 import { onCallTokenMessage } from '../callTokenStanza';
+import { accountDomain, isE2eeEnabled } from '../../e2ee';
+import {
+  decryptStanzaInPlace,
+  encryptedCarrier,
+  rewriteEncryptedStanza,
+} from '../../e2ee/stanza';
 
 /**
  * Unwrap a mucsub event wrapper so the chat handlers see the real inner
@@ -49,7 +55,46 @@ const unwrapMucsubMessage = (stanza: Element): Element => {
   return (inner as Element) || stanza;
 };
 
+let held = 0;
+let queue: Promise<void> = Promise.resolve();
+
 export function handleStanza(stanza: Element, xmppWs: XmppClient) {
+  if (!isE2eeEnabled()) {
+    dispatchStanza(stanza, xmppWs);
+    return;
+  }
+  const carrier =
+    stanza?.name === 'message' ? encryptedCarrier(stanza) : undefined;
+  if (!carrier && held === 0) {
+    dispatchStanza(stanza, xmppWs);
+    return;
+  }
+
+  held++;
+  queue = queue.then(async () => {
+    try {
+      if (carrier) {
+        const outcome = await decryptStanzaInPlace(
+          stanza,
+          accountDomain(xmppWs.client)
+        );
+        if (outcome === 'drop') {return;}
+      }
+      dispatchStanza(stanza, xmppWs);
+    } catch (err) {
+      console.warn('OMEMO: failed to handle stanza', err);
+    } finally {
+      held--;
+    }
+  });
+}
+
+export const __resetStanzaQueueForTests = (): void => {
+  held = 0;
+  queue = Promise.resolve();
+};
+
+function dispatchStanza(stanza: Element, xmppWs: XmppClient) {
   if (stanza?.attrs?.type === 'headline') {return;}
 
   // Call signaling is swallowed before any chat handler sees it. A
@@ -61,6 +106,10 @@ export function handleStanza(stanza: Element, xmppWs: XmppClient) {
     return;
   }
 
+  if (stanza?.name === 'message' && rewriteEncryptedStanza(stanza) === 'drop') {
+    return;
+  }
+
   switch (stanza.name) {
     case 'message': {
       const unwrapped = unwrapMucsubMessage(stanza);

package/src/networking/xmpp/sendMediaMessage.xmpp.ts

@@ -1,4 +1,5 @@
 import { Client, xml } from '@xmpp/client';
+import { sendSealedMedia, shouldEncrypt } from '../../e2ee/send';
 
 // Monotonic counter — see sendTextMessage for the rationale (avoids
 // Date.now() id collisions on <1ms-apart sends).
@@ -63,6 +64,23 @@ export function sendMediaMessage(
     push: 'true',
   };
 
+  const keys: string[] | undefined = data?.e2eeKeys;
+  if (keys?.length) {
+    (dataToSend as Record<string, unknown>).clientEncrypted = 'true';
+  }
+  const hints = xml('store', { xmlns: 'urn:xmpp:hints' });
+
+  if (keys?.length && shouldEncrypt(roomJID)) {
+    sendSealedMedia(
+      client,
+      roomJID,
+      id,
+      xml('body', {}, JSON.stringify({ v: 1, keys })),
+      [xml('data', dataToSend), hints]
+    );
+    return id;
+  }
+
   const message = xml(
     'message',
     {
@@ -72,7 +90,7 @@ export function sendMediaMessage(
       to: roomJID,
     },
     xml('body', {}, 'media'),
-    xml('store', { xmlns: 'urn:xmpp:hints' }),
+    hints,
     xml('data', dataToSend)
   );
 

package/src/networking/xmpp/sendTextMessage.xmpp.ts

@@ -1,4 +1,5 @@
 import { Client, xml } from '@xmpp/client';
+import { sendEncrypted, shouldEncrypt } from '../../e2ee/send';
 
 // Local monotonic counter — see comment in id construction below.
 let _sendTextSeq = 0;
@@ -52,14 +53,7 @@ export const sendTextMessage = (
 
   try {
     const dataXmlns = toServiceXmlns(devServer, client);
-    const message = xml(
-      'message',
-      {
-        to: roomJID,
-        type: 'groupchat',
-        id: id,
-      },
-      xml('data', {
+    const data = xml('data', {
         xmlns: dataXmlns,
         senderFirstName: firstName,
         senderLastName: lastName,
@@ -76,9 +70,22 @@ export const sendTextMessage = (
         isReply: isReply || false,
         mainMessage: mainMessage || '',
         push: 'true',
-      }),
-      xml('body', {}, userMessage)
+      });
+    const body = xml('body', {}, userMessage);
+    const message = xml(
+      'message',
+      {
+        to: roomJID,
+        type: 'groupchat',
+        id: id,
+      },
+      data,
+      body
     );
+    if (shouldEncrypt(roomJID)) {
+      sendEncrypted(client, roomJID, id, data, body, message);
+      return;
+    }
     const sendResult = client.send(message);
     if (sendResult && typeof (sendResult as any).then === 'function') {
       (sendResult as Promise<unknown>)

package/src/networking/xmpp/sendTextMessageWithTranslateTag.xmpp.ts

@@ -1,6 +1,7 @@
 import { Client, xml } from '@xmpp/client';
 import { Iso639_1Codes } from '../../types/types';
 import { toServiceXmlns } from './sendTextMessage.xmpp';
+import { sendEncrypted, shouldEncrypt } from '../../e2ee/send';
 
 /**
  * Same wire message as `sendTextMessage`, plus a `<translate source="xx"/>`
@@ -39,14 +40,7 @@ export const sendTextMessageWithTranslateTag = (
 
   try {
     const dataXmlns = toServiceXmlns(stanzaMessage.devServer, client);
-    const message = xml(
-      'message',
-      {
-        to: stanzaMessage.roomJID,
-        type: 'groupchat',
-        id,
-      },
-      xml('data', {
+    const data = xml('data', {
         xmlns: dataXmlns,
         senderFirstName: stanzaMessage.firstName,
         senderLastName: stanzaMessage.lastName,
@@ -63,8 +57,27 @@ export const sendTextMessageWithTranslateTag = (
         isReply: stanzaMessage.isReply || false,
         mainMessage: stanzaMessage.mainMessage || '',
         push: 'true',
-      }),
-      xml('body', {}, stanzaMessage.userMessage),
+      });
+    const body = xml('body', {}, stanzaMessage.userMessage);
+    const envelope = { to: stanzaMessage.roomJID, type: 'groupchat', id };
+
+    if (shouldEncrypt(stanzaMessage.roomJID)) {
+      sendEncrypted(
+        client,
+        stanzaMessage.roomJID,
+        id,
+        data,
+        body,
+        xml('message', envelope, data, body)
+      );
+      return true;
+    }
+
+    const message = xml(
+      'message',
+      envelope,
+      data,
+      body,
       // `<translate source>` only DECLARES the language this text is in; it
       // costs nothing to send and is what lets each reader translate the
       // message into their own language on their side.

package/src/networking/xmppClient.ts

@@ -24,6 +24,7 @@ import { editMessage } from './xmpp/editMessage.xmpp';
 import { inviteRoomRequest } from './xmpp/inviteRoomRequest.xmpp';
 import { getRooms } from './xmpp/getRooms.xmpp';
 import { handleStanza } from './xmpp/handleStanzas.xmpp';
+import { onOnline as e2eeOnOnline } from '../e2ee';
 import { pushLog as devPushLog, isDevLogActive } from '../utils/devLogger';
 import { normalizeRoomJid } from '../helpers/normalizeRoomJid';
 import { store } from '../roomStore';
@@ -569,6 +570,11 @@ export class XmppClient {
       } catch (err) {
         console.warn('onOnline callback failed', err);
       }
+      try {
+        e2eeOnOnline(this.client);
+      } catch (err) {
+        console.warn('e2ee onOnline failed', err);
+      }
       // Drain any sends that were buffered while the stream was down. The
       // presence stanzas from onOnlineCallback above were written to the
       // socket synchronously (allRoomPresences → presenceInRoom send the

package/src/roomStore/chatSettingsSlice.ts

@@ -38,6 +38,12 @@ export interface ChatState {
   themePreference?: ThemePreference;
   /** Push notifications toggle from Settings. `undefined` = on. */
   pushEnabled?: boolean;
+  /**
+   * The interface language the user picked in Settings (BCP-47, e.g.
+   * "fr-CA") - the backend's `user.appLanguage`. Wins over the host's
+   * `config.i18n.locale`, which is the default for a user who never chose.
+   */
+  uiLocale?: string;
 }
 
 export const unpackAndTransform = (input?: User): User => {
@@ -219,6 +225,12 @@ const reducers = {
   ) => {
     state.translateMode = action.payload;
   },
+  setUiLocale: (
+    state: WritableDraft<ChatState>,
+    action: PayloadAction<string | undefined>
+  ) => {
+    state.uiLocale = action.payload || undefined;
+  },
 };
 
 export const chatSlice: Slice<ChatState, typeof reducers, 'chat'> = createSlice({
@@ -242,6 +254,7 @@ export const {
   setTranslateMode,
   setThemePreference,
   setPushEnabled,
+  setUiLocale,
 } = chatSlice.actions;
 
 export default chatSlice.reducer;

package/src/roomStore/persistBackend.ts

@@ -1,5 +1,5 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { secureGet, secureSet } from '../helpers/secureKeyValue';
+import { secureGetOrCreate } from '../helpers/secureKeyValue';
 import { encryptForPersist, decryptFromPersist } from '../helpers/persistCrypto';
 
 
@@ -12,7 +12,7 @@ export interface PersistBackend {
 }
 
 const MMKV_INSTANCE_ID = 'ethora-chat-persist';
-const MMKV_KEY_STORE_KEY = '@ethora/persist:mmkvKey';
+const MMKV_KEY_STORE_KEY = 'ethora_persist_mmkv_key';
 const MMKV_KEY_LENGTH = 16;
 
 const randomKey = (length: number): string => {
@@ -25,13 +25,6 @@ const randomKey = (length: number): string => {
   return out;
 };
 
-const loadOrCreateMmkvKey = async (): Promise<string> => {
-  const existing = await secureGet(MMKV_KEY_STORE_KEY);
-  if (existing) {return existing;}
-  const key = randomKey(MMKV_KEY_LENGTH);
-  await secureSet(MMKV_KEY_STORE_KEY, key);
-  return key;
-};
 
 const createMmkvBackend = async (): Promise<PersistBackend | null> => {
   let MMKV: any;
@@ -42,9 +35,13 @@ const createMmkvBackend = async (): Promise<PersistBackend | null> => {
   }
   if (typeof MMKV !== 'function') {return null;}
   try {
-    const encryptionKey = await loadOrCreateMmkvKey();
+    const key = await secureGetOrCreate(MMKV_KEY_STORE_KEY, () =>
+      randomKey(MMKV_KEY_LENGTH)
+    );
+    if (!key) {return null;}
     // Throws when the native module is missing from the binary.
-    const storage = new MMKV({ id: MMKV_INSTANCE_ID, encryptionKey });
+    const storage = new MMKV({ id: MMKV_INSTANCE_ID, encryptionKey: key.value });
+    if (key.created) {storage.clearAll();}
     return {
       name: 'mmkv',
       getMany: async (keys) => keys.map((k) => storage.getString(k) ?? null),

package/src/roomStore/persistence.ts

@@ -132,6 +132,11 @@ const PERSISTED_MESSAGE_FIELDS: (keyof IMessage)[] = [
   // computeBootTimeFailures below) find exactly the messages that never
   // got confirmed and flip them to failed instead.
   'pending',
+  'unencrypted',
+  'undecryptable',
+  'e2eeError',
+  'clientEncrypted',
+  'e2eeKeys',
 ];
 
 // The sender identity that rides along on every message over the wire
@@ -164,6 +169,7 @@ const PERSISTED_MESSAGE_USER_FIELDS = ['id', 'name'] as const;
 // repopulates from /chats/my on the very next load. `usersCnt`, which the
 // header actually reads, is its own scalar field and is preserved below.
 const REFETCHED_ROOM_FIELDS = ['members'] as const;
+const PERSISTED_ROOM_MEMBERS = 30;
 
 const pickDefined = <T extends object>(
   source: T,
@@ -218,6 +224,15 @@ const sanitizeRooms = (
     for (const field of REFETCHED_ROOM_FIELDS) {
       delete compactRoom[field];
     }
+    // The same reasoning, one size down: the full roster a room gets once
+    // it is opened (loadRoomMembers) is re-fetched on the next open, so only
+    // the preview-sized head of it is worth a place in the cache.
+    if (
+      Array.isArray(compactRoom.roomMembers) &&
+      compactRoom.roomMembers.length > PERSISTED_ROOM_MEMBERS
+    ) {
+      compactRoom.roomMembers = compactRoom.roomMembers.slice(0, PERSISTED_ROOM_MEMBERS);
+    }
 
     out[jid] = {
       ...(compactRoom as IRoom),