@ethora/chat-component-rn 26.8.5 → 26.8.7

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

@@ -1,4 +1,5 @@
 import { Element } from 'ltx';
+import { routeMamIq } from './mamRouter';
 import {
   onDeleteMessage,
   onEditMessage,
@@ -19,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
@@ -48,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
@@ -60,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);
@@ -80,6 +130,7 @@ export function handleStanza(stanza: Element, xmppWs: XmppClient) {
       onPresenceInRoom(stanza);
       break;
     case 'iq':
+      if (routeMamIq(stanza)) {break;}
       onGetChatRooms(stanza, xmppWs);
       onRealtimeMessage(stanza);
       onPresenceInRoom(stanza);

package/src/networking/xmpp/mamRouter.ts

@@ -0,0 +1,176 @@
+import { store } from '../../roomStore';
+import { addRoomMessages, setReactions } from '../../roomStore/roomsSlice';
+import { IMessage } from '../../types/types';
+import { applyMamReactions, type ExtractedReaction } from '../../helpers/mamReactions';
+
+interface PendingQuery {
+  roomJID: string;
+  apply: boolean;
+  messages: IMessage[];
+  reactions: ExtractedReaction[];
+  inflight: number;
+  closed: null | { error: boolean };
+  resolve: (messages: IMessage[]) => void;
+  reject: (error: Error) => void;
+}
+
+const pending = new Map<string, PendingQuery>();
+
+const flush = (query: PendingQuery) => {
+  // Every step is guarded: a failure in one (a middleware throwing on a
+  // reaction, say) used to escape `settle` before the waiting request was
+  // resolved — the page was lost and the room stayed empty until opened.
+  let deferred: ExtractedReaction[] = [];
+  try {
+    // Reactions ride in the archive as their own entries: fold them onto
+    // the page's messages first, so they are stored together.
+    deferred = applyMamReactions(query.messages, query.reactions);
+  } catch (e) {
+    console.warn('[mam] applying reactions to a page failed', e);
+  }
+  if (query.apply && query.messages.length > 0) {
+    try {
+      store.dispatch(
+        addRoomMessages({ roomJID: query.roomJID, messages: query.messages })
+      );
+    } catch (e) {
+      console.warn('[mam] applying a history page failed', e);
+    }
+  }
+  for (const reaction of deferred) {
+    try {
+      store.dispatch(
+        setReactions({
+          roomJID: reaction.roomJID || query.roomJID,
+          messageId: reaction.messageId,
+          from: reaction.from,
+          reactions: reaction.emoji,
+          data: reaction.data,
+          latestReactionTimestamp: reaction.ts,
+        })
+      );
+    } catch (e) {
+      console.warn('[mam] applying a reaction failed', e);
+    }
+  }
+};
+
+export const beginMamQuery = (
+  queryId: string,
+  roomJID: string,
+  apply = true
+): Promise<IMessage[]> =>
+  new Promise((resolve, reject) => {
+    pending.set(queryId, {
+      roomJID,
+      apply,
+      messages: [],
+      reactions: [],
+      inflight: 0,
+      closed: null,
+      resolve,
+      reject,
+    });
+  });
+
+/**
+ * Give up waiting (timeout). Whatever arrived is still applied — a late
+ * page is better than a lost one — and handed back.
+ */
+export const cancelMamQuery = (queryId: string): IMessage[] => {
+  const query = pending.get(queryId);
+  if (!query) {return [];}
+  pending.delete(queryId);
+  flush(query);
+  query.resolve(query.messages);
+  return query.messages;
+};
+
+const bareLower = (jid: unknown): string =>
+  String(jid || '').split('/')[0].toLowerCase();
+
+// By the echoed `queryid` when the server provides one; otherwise by the
+// room the result came from — the oldest still-open query for that room.
+// (Results are per room anyway: a query only ever asks one archive.)
+const queryOf = (stanza: any): PendingQuery | undefined => {
+  const queryId = stanza?.getChild?.('result')?.attrs?.queryid;
+  const byId = queryId ? pending.get(queryId) : undefined;
+  if (byId) {return byId;}
+  const room = bareLower(stanza?.attrs?.from);
+  if (!room) {return undefined;}
+  for (const query of pending.values()) {
+    if (!query.closed && bareLower(query.roomJID) === room) {return query;}
+  }
+  return undefined;
+};
+
+const settle = (queryId: string, query: PendingQuery) => {
+  if (pending.get(queryId) === query) {pending.delete(queryId);}
+  try {
+    flush(query);
+  } finally {
+    // The waiting request is always answered, whatever happened above.
+    if (query.closed?.error) {
+      query.reject(new Error('mam query error'));
+    } else {
+      query.resolve(query.messages);
+    }
+  }
+};
+
+const settleIfDone = (query: PendingQuery) => {
+  if (!query.closed || query.inflight > 0) {return;}
+  const entry = [...pending.entries()].find(([, q]) => q === query);
+  settle(entry ? entry[0] : '', query);
+};
+
+/**
+ * Claim a result for its pending query — synchronously, the moment the
+ * stanza arrives — so the router knows a parse is outstanding. Returns
+ * true when a pending query owns it (the caller must then always follow
+ * up with `collectMamMessage`, even when the parse yields nothing).
+ */
+export const claimMamResult = (stanza: any): boolean => {
+  const query = queryOf(stanza);
+  if (!query) {return false;}
+  query.inflight += 1;
+  return true;
+};
+
+/** The parsed result of a claimed stanza (undefined: dropped). */
+export const collectMamReaction = (
+  stanza: any,
+  reaction: ExtractedReaction
+): boolean => {
+  const query = queryOf(stanza);
+  if (!query) {return false;}
+  query.reactions.push(reaction);
+  return true;
+};
+
+export const collectMamMessage = (
+  stanza: any,
+  message: IMessage | undefined
+): boolean => {
+  const query = queryOf(stanza);
+  if (!query) {return false;}
+  if (message) {query.messages.push(message);}
+  query.inflight = Math.max(0, query.inflight - 1);
+  settleIfDone(query);
+  return true;
+};
+
+/** The query's closing iq; true when it belonged to a pending query. */
+export const routeMamIq = (stanza: any): boolean => {
+  if (!stanza?.is?.('iq')) {return false;}
+  const query = pending.get(stanza.attrs?.id);
+  if (!query) {return false;}
+  query.closed = { error: stanza.attrs.type === 'error' };
+  // Results that are still being parsed settle the page when they land;
+  // until then the query stays registered so they can find it.
+  if (query.inflight === 0) {settle(stanza.attrs.id, query);}
+  return true;
+};
+
+/** Test hook. */
+export const __resetMamRouter = () => pending.clear();

package/src/networking/xmpp/presenceInRoom.xmpp.ts

@@ -6,10 +6,44 @@ let presenceIdCounter = 0;
 const nextPresenceId = () =>
   `presenceInRoom-${Date.now().toString(36)}-${(++presenceIdCounter).toString(36)}`;
 
-export const presenceInRoom = async (
+const joinedByClient = new WeakMap<Client, Map<string, Promise<Element>>>();
+
+const joinedRooms = (client: Client): Map<string, Promise<Element>> => {
+  let map = joinedByClient.get(client);
+  if (!map) {
+    map = new Map();
+    joinedByClient.set(client, map);
+    const forget = () => joinedByClient.get(client)?.clear();
+    client.on('disconnect', forget);
+    client.on('offline', forget);
+  }
+  return map;
+};
+
+export const __forgetJoinedRooms = (client: Client) =>
+  joinedByClient.get(client)?.clear();
+
+export const presenceInRoom = (
+  client: Client,
+  roomJID: string,
+  delay = 0
+): Promise<Element> => {
+  const joined = joinedRooms(client);
+  const existing = joined.get(roomJID);
+  if (existing) {return existing;}
+  const join = joinRoom(client, roomJID, delay);
+  joined.set(roomJID, join);
+  // A failed join is not a join: let the next caller try again.
+  join.catch(() => {
+    if (joined.get(roomJID) === join) {joined.delete(roomJID);}
+  });
+  return join;
+};
+
+const joinRoom = async (
   client: Client,
   roomJID: string,
-  delay = 2000
+  delay: number
 ): Promise<Element> => {
   let stanzaHandler: (stanza: Element) => void;
   const unsubscribe = () => client.off('stanza', stanzaHandler);
@@ -27,6 +61,11 @@ export const presenceInRoom = async (
       if (settled) {return;}
       settled = true;
 
+      if (delay <= 0) {
+        unsubscribe();
+        cb(value);
+        return;
+      }
       setTimeout(() => {
         unsubscribe();
         cb(value);
@@ -52,7 +91,11 @@ export const presenceInRoom = async (
         to: `${roomJID}/${client.jid?.getLocal()}`,
         id: stanzaId,
       },
-      xml('x', { xmlns: 'http://jabber.org/protocol/muc' })
+      xml(
+        'x',
+        { xmlns: 'http://jabber.org/protocol/muc' },
+        xml('history', { maxstanzas: '0' })
+      )
     );
 
     // Side-effects sequence: send the presence (handles its own

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.