@ethora/chat-component-rn 26.7.9 → 26.8.1

package/src/networking/apiClient.ts

@@ -1,13 +1,8 @@
 import axios from 'axios';
 import { store } from '../roomStore';
 
-import { logout } from '../roomStore/chatSettingsSlice';
+import { logout, refreshTokens } from '../roomStore/chatSettingsSlice';
 import { installAxiosCapture } from '../utils/devLogger';
-import {
-  refreshAuthTokens,
-  isRefreshFatalError,
-  RefreshResult,
-} from './authRefresh';
 
 // Per product-code-policy: no compiled-in Ethora endpoints or tokens.
 // Consumers must call `setBaseURL(baseUrl, appToken)` (or pass
@@ -26,21 +21,10 @@ const http = axios.create({
 // `http` instance.
 installAxiosCapture(http);
 
-const stripApiVersion = (baseUrl: string): string =>
-  baseUrl.replace(/\/+$/, '').replace(/\/v\d+$/, '');
-
-export const normalizeApiPath = (path?: string): string | undefined => {
-  if (!path) {return path;}
-  if (/^https?:\/\//i.test(path)) {return path;}
-  if (/^\/v\d+\//.test(path)) {return path;}
-  return `/v1${path.startsWith('/') ? '' : '/'}${path}`;
-};
-
 export function setBaseURL(baseUrl?: string, appToken?: string) {
-  const normalized = baseUrl ? stripApiVersion(baseUrl) : baseUrl;
-  if (normalized && normalized !== currentBaseURL) {
-    currentBaseURL = normalized;
-    http.defaults.baseURL = normalized;
+  if (baseUrl && baseUrl !== currentBaseURL) {
+    currentBaseURL = baseUrl;
+    http.defaults.baseURL = baseUrl;
   }
   if (appToken && appToken !== currentAppToken) {
     currentAppToken = appToken;
@@ -55,78 +39,149 @@ export function getCurrentBaseURL() {
   return currentBaseURL;
 }
 
-/**
- * @deprecated Import `refreshAuthTokens` from `./authRefresh` instead.
- *
- * Kept as a thin forwarder so existing call sites keep working while
- * they migrate. Declared as a function (not `const refresh =
- * refreshAuthTokens`) on purpose: this module and `authRefresh` import
- * each other, and a const would capture the binding before the other
- * module finished evaluating.
- */
-export function refresh(): Promise<RefreshResult> {
-  return refreshAuthTokens();
+export function refresh(): Promise<{
+  data: { refreshToken: string; token: string };
+}> {
+  return new Promise((resolve, reject) => {
+    const user = store.getState().chatSettingStore.user;
+    try {
+      http
+        .post(
+          '/users/login/refresh',
+          {},
+          { headers: { Authorization: user.refreshToken } }
+        )
+        .then((response) => {
+          store.dispatch(
+            refreshTokens({
+              token: response.data.token,
+              refreshToken: response.data.refreshToken,
+            })
+          );
+          // BUGFIX: previously the `.then` only dispatched and never
+          // resolved, so every `await refresh()` callsite hung forever
+          // on the happy path. Resolve with the axios response shape so
+          // the interceptor can read `tokens.data.token` to retry.
+          resolve(response);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    } catch (error) {
+      // BUGFIX: previously the outer-try catch dispatched logout but
+      // never rejected, so a synchronous throw from `http.post` (e.g.
+      // a bad URL) would hang the promise. Reject explicitly.
+      console.log('errr');
+      store.dispatch(logout());
+      reject(error);
+    }
+  });
 }
 
+let isRefreshing = false;
+let failedQueue: any[] = [];
+
+const addRequestToQueue = (config: any) => {
+  return new Promise((resolve, reject) => {
+    failedQueue.push({ resolve, reject, config });
+  });
+};
+
+const processQueue = (newAccessToken: string) => {
+  for (const request of failedQueue) {
+    if (newAccessToken) {
+      request.config.headers.Authorization = newAccessToken;
+    }
+
+    request.resolve(http(request.config));
+  }
+
+  failedQueue = [];
+};
+
 http.interceptors.response.use(
   (response) => response,
   async (error) => {
+    // BUGFIX: the original condition was `if (!enabled)` — inverted, so
+    // turning `refreshTokens.enabled: true` actually DISABLED the refresh
+    // path on 401. Use the correct sense.
+    if (!store.getState().chatSettingStore?.config?.refreshTokens?.enabled) {
+      // BUGFIX: previously this branch fell off the end of the async
+      // function and returned `undefined`, which axios treats as a
+      // resolved-with-undefined response. Callers expecting an error
+      // got `undefined` instead, silently swallowing every failure
+      // when the refresh path isn't configured. Re-reject so the
+      // original error reaches the caller.
+      return Promise.reject(error);
+    }
+
     const originalRequest = error.config;
     const status = error.response?.status;
 
     // Refresh paths only fire on 401. Anything else passes through.
-    if (!error.response || status !== 401 || !originalRequest) {
+    if (!error.response || status !== 401) {
       return Promise.reject(error);
     }
 
-    // Never retry twice, and never touch the auth endpoints themselves —
-    // both would recurse. (`_retry` was set but never checked before,
-    // so a request could bounce between 401 and replay indefinitely.)
     if (
-      originalRequest._retry ||
-      originalRequest.url === '/v1/users/login/refresh' ||
-      originalRequest.url === '/v1/users/login'
+      store.getState().chatSettingStore?.config?.refreshTokens?.refreshFunction
     ) {
-      return Promise.reject(error);
-    }
-
-    const refreshConfig =
-      store.getState().chatSettingStore?.config?.refreshTokens;
-
-    // BUGFIX (kept): the original condition here was inverted, so
-    // `refreshTokens.enabled: true` actually DISABLED the refresh path.
-    if (!refreshConfig?.enabled) {
-      return Promise.reject(error);
+      // Consumer-supplied refresh function. Call it, dispatch the new
+      // tokens, retry the original request.
+      try {
+        const fn = store.getState().chatSettingStore?.config?.refreshTokens?.refreshFunction;
+        if (!fn) return Promise.reject(error);
+        const result = await fn();
+        const { refreshToken: newRefreshToken, accessToken } = result || { refreshToken: '', accessToken: '' };
+        store.dispatch(
+          refreshTokens({
+            token: accessToken,
+            refreshToken: newRefreshToken || '',
+          })
+        );
+        // BUGFIX: previously this branch returned `undefined` after
+        // dispatching, so the original request was never retried and
+        // the caller resolved with undefined. Stamp the new token on
+        // the original config and replay.
+        if (originalRequest?.headers) {
+          originalRequest.headers.Authorization = accessToken;
+        }
+        return http(originalRequest);
+      } catch (refreshErr) {
+        return Promise.reject(refreshErr);
+      }
     }
 
-    // Nothing to rotate with — reject rather than firing a doomed
-    // refresh that would look like a bad-token event to the backend.
-    const hasRefreshableSession = Boolean(
-      refreshConfig.refreshFunction ||
-        store.getState().chatSettingStore.user?.refreshToken
-    );
-    if (!hasRefreshableSession) {
+    // Built-in `/users/login/refresh` path. Skip if the failing request
+    // IS the refresh / login itself — otherwise we'd loop forever.
+    if (
+      originalRequest.url === '/users/login/refresh' ||
+      originalRequest.url === '/users/login'
+    ) {
       return Promise.reject(error);
     }
 
     originalRequest._retry = true;
 
+    if (isRefreshing) {
+      const retryOriginalRequest = addRequestToQueue(originalRequest);
+      return retryOriginalRequest;
+    }
+
+    isRefreshing = true;
     try {
-      // One shared rotation for every 401 in flight — `refreshAuthTokens`
-      // dedupes internally, which replaces the old isRefreshing/
-      // failedQueue machinery entirely.
-      const tokens = await refreshAuthTokens();
-      originalRequest.headers = originalRequest.headers || {};
-      originalRequest.headers.Authorization = tokens.token;
+      const tokens = await refresh();
+      // (was: console.log('tokens', tokens) — dumped the full response
+      // incl. access/refresh/ws tokens on every refresh; removed.)
+      isRefreshing = false;
+      originalRequest.headers.Authorization = tokens.data.token;
+      processQueue(tokens.data.token);
       return http(originalRequest);
     } catch (refreshErr) {
-      // Only a genuinely dead session logs the user out. A network
-      // blip, a 5xx, or a REFRESH_IN_PROGRESS race must leave the
-      // session alone — logging out on those is exactly the mass-logout
-      // failure mode the new backend scheme would otherwise cause.
-      if (isRefreshFatalError(refreshErr)) {
-        store.dispatch(logout());
-      }
+      isRefreshing = false;
+      // BUGFIX: previously this returned the error (resolving the
+      // promise with the error as value) instead of rejecting, so
+      // axios callers got the error as a "successful" response body.
       return Promise.reject(refreshErr);
     }
   }

package/src/networking/stanzaHandlers.ts

@@ -9,7 +9,6 @@ import {
   setCurrentRoom,
   setRoomRole,
   updateRoom,
-  mergeUsersSet,
 } from '../roomStore/roomsSlice';
 import { IRoom, RoomMember } from '../types/types';
 import { createMessageFromXml } from '../helpers/createMessageFromXml';
@@ -17,6 +16,7 @@ import { getDataFromXml } from '../helpers/getDataFromXml';
 import { setDeleteModal } from '../roomStore/chatSettingsSlice';
 import { messageNotificationManager } from '../utils/messageNotificationManager';
 import { transformCallLogMessage } from '../helpers/callLogMessage';
+import { translateKey } from '../i18n/strings';
 
 // TO DO: we are thinking to refactor this code in the following way:
 // each stanza will be parsed for 'type'
@@ -121,13 +121,24 @@ const onRealtimeMessage = async (stanza: Element) => {
       }
       const room = state.rooms.rooms[roomJID];
       const roomName = room?.title || room?.name || '';
+      // Fallback when we don't have a display name for the sender. This is
+      // user-visible — it renders as the sender line in the in-app
+      // notification toast (see MessageNotificationContext's ToastRow:
+      // `{senderName}: {message.body}`) — so it goes through the static
+      // i18n table like any other UI caption. We're outside React here
+      // (stanza handler, not a component), so resolve the locale from the
+      // store directly and call `translateKey` instead of `useT()`.
+      const locale =
+        state.chatSettingStore.config?.i18n?.locale ||
+        state.chatSettingStore.langSource;
+      const overrides = state.chatSettingStore.config?.i18n?.strings;
       const senderName = [
         data.attrs.senderFirstName,
         data.attrs.senderLastName,
       ]
         .filter(Boolean)
         .join(' ')
-        .trim() || 'New message';
+        .trim() || translateKey('notification.senderFallback', locale, overrides);
       messageNotificationManager.showNotification(
         message,
         roomName,
@@ -227,11 +238,11 @@ const onMessageHistory = async (stanza: any) => {
     // what senderJID would have held — fall back to it. createMessageFromXml
     // already derives a display name from the jid when senderFirstName/
     // senderLastName are absent.
-    const forwardedMessage = stanza
-      .getChild('result')
-      ?.getChild('forwarded')
-      ?.getChild('message');
-    const innerFrom = forwardedMessage?.attrs?.from || stanza.attrs.from;
+    const innerFrom =
+      stanza
+        .getChild('result')
+        ?.getChild('forwarded')
+        ?.getChild('message')?.attrs?.from || stanza.attrs.from;
     const senderJID = data?.attrs?.senderJID || innerFrom;
     if (!data?.attrs || !senderJID) {
       // console.log(
@@ -240,29 +251,27 @@ const onMessageHistory = async (stanza: any) => {
       // );
       return;
     }
-    const mergedAttrs = { ...data.attrs };
-    if (!mergedAttrs.senderJID) {mergedAttrs.senderJID = senderJID;}
-    // The forwarded <message>'s own stanza id is our original send id
-    // (what `xmppId` holds on the live/wrapped paths) - capture it so
-    // this MAM-replayed message dedupes against its live echo /
-    // optimistic pending bubble the same way, instead of never carrying
-    // an xmppId at all.
-    if (forwardedMessage?.attrs?.id) {mergedAttrs.xmppId = forwardedMessage.attrs.id;}
-    const rawMessage = await createMessageFromXml(
-      mergedAttrs,
-      body,
-      id,
-      // Bug #41: pass the resource-bearing occupant `from`
-      // (room@conference/sender-id) here, not the outer envelope's
-      // `stanza.attrs.from` (which has no resource for a MAM result).
-      // createMessageFromXml derives `user.id` from this field's
-      // resource - the same authoritative source getDataFromXml uses
-      // for live messages - so catch-up rows resolve the correct
-      // sender from the very first render instead of needing a later
-      // correction once the "official" history fetch lands.
-      innerFrom,
-      !!deleted
-    );
+    // Parse the FULL stanza the same way the realtime path does (and the
+    // web SDK's history path does): the positional call used here before
+    // read only <data> attrs + <body>, so the <translations> payload and
+    // the <translate source> tag never made it onto archived messages.
+    // Since every transcript is MAM-backfilled on room open, that alone
+    // made translation look completely dead — the translations existed on
+    // the wire and were dropped at this exact parse. getDataFromXml also
+    // supplies xmppId (dedupe against the optimistic copy) and the
+    // resource||senderJID-localpart sender id.
+    const parsed = await getDataFromXml(stanza);
+    const { data: pData, id: pId, body: pBody, ...pRest } =
+      parsed ?? ({} as Partial<NonNullable<typeof parsed>>);
+    const mergedData: Record<string, unknown> = { ...(pData || data.attrs) };
+    if (!mergedData.senderJID) {mergedData.senderJID = senderJID;}
+    const rawMessage = await createMessageFromXml({
+      data: mergedData,
+      id: pId || id,
+      body: pBody ?? (typeof body === 'string' ? body : body?.getText?.() || ''),
+      ...pRest,
+      isDeleted: !!deleted || !!pRest?.deleted,
+    } as Parameters<typeof createMessageFromXml>[0]);
 
     // Same call-log transform as the realtime path, applied to archived
     // history so calls received while offline still render as log entries.
@@ -363,68 +372,18 @@ const onChatInvite = async (stanza: Element, client: any) => {
 
 const onGetMembers = (stanza: Element) => {
   if (String(stanza.attrs?.id || '') !== 'roomMemberInfo') {return;}
-
-  try {
-    const queries: Element[] = stanza.getChildren('query') ?? [];
-    const activities: Element[] = [];
-    let roomJid = '';
-    for (const q of queries) {
-      if (!roomJid && q.attrs?.room) {roomJid = q.attrs.room;}
-      const acts = q.getChildren('activity') ?? [];
-      for (const a of acts) {activities.push(a);}
-    }
-
-    const jid = roomJid || store.getState().rooms.activeRoomJID;
-    if (!jid || activities.length === 0) {return;}
-
-    const existingRoom = store.getState().rooms.rooms[jid];
-    const existingMembers: RoomMember[] = existingRoom?.roomMembers ?? [];
-    const existingByJid = new Map<string, RoomMember>(
-      existingMembers
-        .filter((m): m is RoomMember & { jid: string } => !!m.jid)
-        .map((m) => [m.jid, m])
-    );
-
-    const roomMembers: RoomMember[] = activities.map((a) => {
-      const memberJid: string | undefined = a.attrs?.jid;
-      const existing = memberJid ? existingByJid.get(memberJid) : undefined;
-      // The activity stanza carries only the XMPP-side fields
-      // (name/role/ban_status/last_active/jid). REST-loaded existing
-      // members supply firstName/lastName/xmppUsername/_id; when there's
-      // no REST match yet we leave those as empty strings.
-      return {
-        firstName: existing?.firstName ?? '',
-        lastName: existing?.lastName ?? '',
-        xmppUsername: existing?.xmppUsername ?? '',
-        _id: existing?._id ?? '',
-        ...existing,
-        name: a.attrs?.name,
-        role: a.attrs?.role,
-        ban_status: a.attrs?.ban_status,
-        last_active: Number(a.attrs?.last_active),
-        jid: memberJid,
-      };
-    });
-
-    store.dispatch(updateRoom({ jid, updates: { roomMembers } }));
-
-    // Also feed the identity cache Message.tsx reads sender names from
-    // (state.rooms.usersSet). Keyed by both the bare local part and the
-    // full jid since a message's `user.id` can be either depending on
-    // how it was parsed (see createUserNameFromSetUser).
-    const usersSetUpdates: Record<string, RoomMember> = {};
-    for (const member of roomMembers) {
-      if (!member.jid) {continue;}
-      const local = member.jid.split('@')[0];
-      usersSetUpdates[local] = member;
-      usersSetUpdates[member.jid] = member;
-    }
-    if (Object.keys(usersSetUpdates).length > 0) {
-      store.dispatch(mergeUsersSet({ members: usersSetUpdates }));
-    }
-  } catch (err) {
-    console.warn('onGetMembers parse failed', err);
-  }
+  // Deliberately dispatches NOTHING — mirroring the web SDK, where this
+  // handler parses the activity list into a local and never touches the
+  // store. The activity stanza carries no firstName/lastName, and both of
+  // the old dispatches poisoned good REST data with empty-named entries:
+  //   - updateRoom wholesale-replaced room.roomMembers (REST members carry
+  //     no jid, so the existing-by-jid lookup always missed), blanking the
+  //     ChatProfileModal member list;
+  //   - mergeUsersSet overwrote REST-hydrated identity entries under the
+  //     exact localpart key the sender-name resolver reads first, which is
+  //     why most of usersSet ended up empty.
+  // REST (/chats/my → dispatchUsersSetFromRestItems + the roomMembers
+  // build in rooms.api.ts) is the one hydration path for both stores.
 };
 
 const onGetRoomInfo = (stanza: Element) => {

package/src/networking/xmpp/flushLastViewedToPrivateStore.ts

@@ -1,45 +1,21 @@
 import { getChatsPrivateStoreRequest } from './getChatsPrivateStoreRequest.xmpp';
 import { setChatsPrivateStoreRequest } from './setChatsPrivateStoreRequest.xmpp';
-import {
-  getServerReadTimestamp,
-  isCorruptFutureReadMarker,
-  type ReadTimestampHeapState,
-} from '../../helpers/getServerReadTimestamp';
-import type { IMessage } from '../../types/types';
 
 interface RoomLike {
   jid: string;
   lastViewedTimestamp?: number;
   unreadMessages?: number;
-  // Needed to resolve a SERVER-timestamp read marker via
-  // getServerReadTimestamp instead of the device clock - see bug #38.
-  messages?: IMessage[];
 }
 
 interface FlushOpts {
   // When visibleRoomJID is set, treat it as "user just viewed everything
-  // up to now" and stamp it with the newest server-acknowledged message
-  // timestamp for that room - even if its in-memory lastViewedTimestamp
-  // has not been updated yet.
+  // up to now" and stamp it with Date.now() — even if its in-memory
+  // lastViewedTimestamp has not been updated yet.
   visibleRoomJID?: string | null;
-  // Explicit read boundary for the visible room, used INSTEAD of the
-  // newest-message fallback. ChatRoom passes the timestamp of the newest
-  // message the user actually reached when they leave a room while
-  // scrolled up - without it, the default writes "read everything" to
-  // the server and the messages they never scrolled down to come back as
-  // read on the next login, even though the local count was correct.
-  // Customer-reported #33 (server half).
-  visibleRoomTs?: number | null;
   // If true, only write entries for rooms where unreadMessages === 0
   // (or the visible room). Used at logout time: rooms with outstanding
   // unread keep their old marker so the next login still surfaces them.
   onlyIfNoUnread?: boolean;
-  // Pending/failed-send state (store.getState().roomHeapSlice), combined
-  // with each room's `messages` to resolve the newest SERVER-acked
-  // message timestamp via getServerReadTimestamp. Passed in rather than
-  // read from the store here so this module stays a pure function of its
-  // arguments - existing jest coverage builds `rooms` by hand.
-  heapState?: ReadTimestampHeapState;
 }
 
 /**
@@ -49,11 +25,8 @@ interface FlushOpts {
  * each other's entries.
  *
  * Called on: tab change away from chat, AppState background/inactive,
- * and (with onlyIfNoUnread=true) logout. ChatRoom's own unmount path also
- * goes through this (via flushLastViewedToPrivateStoreStanza) for the
- * single-room case - actionSetTimestampToPrivateStore is a separate,
- * unconditional low-level write primitive kept for direct/external use
- * and is not part of this merge path.
+ * and (with onlyIfNoUnread=true) logout. ChatRoom's own unmount path
+ * still uses actionSetTimestampToPrivateStore for the single-room case.
  */
 export async function flushLastViewedToPrivateStore(
   client: any,
@@ -61,7 +34,7 @@ export async function flushLastViewedToPrivateStore(
   opts: FlushOpts = {}
 ): Promise<boolean> {
   if (!client?.client) {return false;}
-  const { visibleRoomJID, visibleRoomTs, onlyIfNoUnread, heapState } = opts;
+  const { visibleRoomJID, onlyIfNoUnread } = opts;
   const roomList = Object.values(rooms || {});
   if (roomList.length === 0) {return false;}
 
@@ -73,6 +46,7 @@ export async function flushLastViewedToPrivateStore(
   }
   if (!storeObj || typeof storeObj !== 'object') {storeObj = {};}
 
+  const nowMs = Date.now();
   let dirty = false;
 
   for (const room of roomList) {
@@ -80,56 +54,21 @@ export async function flushLastViewedToPrivateStore(
     const isVisible = !!visibleRoomJID && room.jid === visibleRoomJID;
     const hasUnread = Number(room.unreadMessages || 0) > 0;
 
-    // Newest message this room actually has server-side proof of. Used
-    // both as the "read up to now" fallback for the visible room and as
-    // the yardstick for detecting a corrupt (future) stored marker below
-    // - never as a substitute for the device clock (bug #38: a device
-    // with a fast clock previously stamped Date.now() here, and once
-    // that future value reached the server the forward-only check a few
-    // lines down rejected every later correct write, forever).
-    const newestAckedMs = getServerReadTimestamp(room as any, heapState);
-
-    // For the visible room, persist "read up to the newest message we
-    // know the server has" - read state is driven by room visibility,
-    // not by a sentinel timestamp. The exception is an explicit
-    // `visibleRoomTs`: the caller knows the user only read up to a
-    // certain point (left the room while scrolled up), so stamping
-    // "everything" here would mark genuinely-unread messages as read.
+    // For the visible room, persist "now" — read state is driven by
+    // room visibility, not by a sentinel timestamp.
     let ts: number | undefined;
     if (isVisible) {
-      ts =
-        typeof visibleRoomTs === 'number' && visibleRoomTs > 0
-          ? visibleRoomTs
-          : newestAckedMs || undefined;
+      ts = nowMs;
     } else if (room.lastViewedTimestamp && room.lastViewedTimestamp > 0) {
       ts = room.lastViewedTimestamp;
     }
 
-    // Nothing to anchor a write to (no boundary, no existing marker, no
-    // known messages yet) - skip rather than write a device-clock guess.
     if (!ts) {continue;}
     if (onlyIfNoUnread && hasUnread && !isVisible) {continue;}
 
     const prev = storeObj[room.jid];
     const prevNum = prev != null ? Number(prev) : 0;
-    // A currently-stored value that sits well past the newest message we
-    // know this room has is not "fresher" - it's a leftover future
-    // marker (bug #38). Forward-only logic normally protects a fresher
-    // read from being clobbered by a stale fetch, but applied to a
-    // corrupt future value it does the opposite: it permanently blocks
-    // the correct (smaller) value from ever landing. Detect that case
-    // and waive the forward-only check for it specifically; sane values
-    // keep the normal forward-only protection.
-    //
-    // "Well past the newest message we know about" is deliberately NOT
-    // sufficient on its own - see isCorruptFutureReadMarker. THIS device's
-    // copy of the room can simply be stale (history not synced yet this
-    // session), in which case a legitimate marker written by another
-    // device that HAS seen newer messages looks exactly like a corrupt
-    // one, and "healing" it here would push the server marker BACKWARDS
-    // and resurrect already-read messages on every device.
-    const prevLooksCorrupt = isCorruptFutureReadMarker(prevNum, newestAckedMs);
-    if (!prevLooksCorrupt && Number.isFinite(prevNum) && prevNum >= ts) {continue;}
+    if (Number.isFinite(prevNum) && prevNum >= ts) {continue;}
     storeObj[room.jid] = String(ts);
     dirty = true;
   }

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

@@ -70,12 +70,7 @@ export const presenceInRoom = async (
       try {
         await createTimeoutPromise(2000, unsubscribe);
       } catch (err) {
-        // The room's reply schedules resolve() `delay` ms later (2000 by
-        // default) — the same length as this timeout, so the timeout used
-        // to win the race and reject a join that had actually succeeded
-        // (allRoomPresences "failed" with undefined on every bootstrap).
-        // Only a join that never got an answer is a failure.
-        if (!settled) {reject(err);}
+        reject(err);
       }
     })();
   });

package/src/networking/xmpp/subscribeToRoomMessages.xmpp.ts

@@ -2,14 +2,12 @@ import { Client, xml } from '@xmpp/client';
 import { Element } from '@xmpp/xml';
 import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
 
-let subscribeIdCounter = 0;
-
 export async function subscribeToRoomMessages(
   client: Client,
   roomJID: string,
   userNick?: string
 ): Promise<boolean> {
-  const id = `newSubscription:${Date.now().toString(36)}-${(++subscribeIdCounter).toString(36)}`;
+  const id = `newSubscription:${Date.now().toString()}`;
   let stanzaHandler: (stanza: Element) => void;
 
   const unsubscribe = () => {
@@ -35,15 +33,6 @@ export async function subscribeToRoomMessages(
         if (stanza.attrs.type === 'result') {
           finish(resolve, true);
         } else if (stanza.attrs.type === 'error') {
-          const errorEl = typeof stanza.getChild === 'function' ? stanza.getChild('error') : null;
-          const condition = errorEl?.children?.find(
-            (c: any) => c?.name && c.name !== 'text'
-          ) as Element | undefined;
-          console.warn(
-            '[PushService] MucSub subscribe error for',
-            roomJID,
-            condition?.name ?? 'unknown'
-          );
           finish(resolve, false);
         }
       }