@ethora/chat-component-rn 26.8.1 → 26.8.2

package/src/roomStore/index.ts

@@ -1,14 +1,18 @@
 import { configureStore, combineReducers } from '@reduxjs/toolkit';
 import chatSettingsReducer, { setUser } from './chatSettingsSlice';
 import roomsSlice, { addRoom } from './roomsSlice';
-import { roomHeapSlice } from './roomHeapSlice';
+import { roomHeapSlice, markMessageFailed } from './roomHeapSlice';
 import callReducer from './callSlice';
 import { IRoom } from '../types/types';
 import { unreadMiddleware } from './Middleware/unreadMidlleware';
 import { logoutMiddleware } from './Middleware/logoutMiddleware';
 import { newMessageMidlleware } from './Middleware/newMessageMidlleware';
 import { reactionsMiddleware } from './Middleware/reactionsMiddleware';
-import { persistenceMiddleware, readPersistedState } from './persistence';
+import {
+  persistenceMiddleware,
+  readPersistedState,
+  computeBootTimeFailures,
+} from './persistence';
 
 const rootReducer = combineReducers({
   chatSettingStore: chatSettingsReducer,
@@ -68,11 +72,12 @@ export const getActiveRoom = (state: RootState): IRoom | null => {
     : null;
 };
 
-// Async rehydrate — read persisted slices and replay them as standard
+// Async rehydrate: read persisted slices and replay them as standard
+// actions.
 export const persistorReady =
   globalScope.__CHAT_PERSISTOR_READY__ ||
   (globalScope.__CHAT_PERSISTOR_READY__ = (async () => {
-    const { chat, rooms } = await readPersistedState();
+    const { chat, rooms, heap } = await readPersistedState();
     if (chat?.user && chat.user.walletAddress) {
       store.dispatch(setUser(chat.user));
     }
@@ -82,4 +87,35 @@ export const persistorReady =
         store.dispatch(addRoom({ roomData: room as IRoom }));
       }
     }
+
+    // bug #39: restore failures that were already flagged (watchdog or
+    // an explicit send error) before the app was killed, so the bubble
+    // still shows "Failed / tap to retry" instead of quietly reverting
+    // to a normal sent bubble.
+    // Skip entries whose bubble no longer exists in the restored cache.
+    // A failure flag is only ever READ as `failedMessages[message.id]`,
+    // so one with no matching message is dead weight that would be
+    // replayed and re-persisted on every launch forever. This happens
+    // for real: a send that reached the server but whose echo was lost
+    // gets flagged failed at boot, then the history merge replaces the
+    // optimistic bubble with the archived copy under its server id (see
+    // mergeHistoryIntoCache), leaving the flag behind.
+    const restoredFailed = heap?.failedMessages || {};
+    for (const payload of Object.values(restoredFailed)) {
+      const stillRendered = (
+        rooms?.rooms?.[payload.roomJID]?.messages || []
+      ).some((m) => m?.id === payload.id);
+      if (!stillRendered) {continue;}
+      store.dispatch(markMessageFailed(payload));
+    }
+
+    // bug #39: a message that was still `pending: true` at kill time
+    // never got a server echo AND never got the chance to trip the
+    // in-session send watchdog (messageHeap is process-lifetime only,
+    // never persisted). Treat every such message as failed so it gets
+    // a working retry instead of silently rendering as delivered.
+    const bootFailures = computeBootTimeFailures(rooms?.rooms, restoredFailed);
+    for (const payload of bootFailures) {
+      store.dispatch(markMessageFailed(payload));
+    }
   })());

package/src/roomStore/persistence.ts

@@ -1,6 +1,8 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { Middleware } from '@reduxjs/toolkit';
 import { IMessage, IRoom, User } from '../types/types';
+import { encryptForPersist, decryptFromPersist } from '../helpers/persistCrypto';
+import type { FailedMessagePayload } from './roomHeapSlice';
 
 // -------------------------------------------------------------------
 // Lightweight RN persistence layer. Mirrors what redux-persist gives
@@ -11,17 +13,33 @@ import { IMessage, IRoom, User } from '../types/types';
 //   - cap each room's messages to the most recent MESSAGE_LIMIT (100)
 //   - debounced writes (200ms) on relevant action types
 //
-// Not encrypted. We rely on AsyncStorage's per-app sandbox.
+// AES-256-CBC at rest (see `helpers/persistCrypto.ts`): the JSON blob
+// under each key below is encrypted before it reaches AsyncStorage, with
+// the symmetric key held in the platform Keychain/Keystore. `user` here
+// is already secret-free (see `sanitizeUser`) — the encryption is for
+// the message bodies in `rooms`, which aren't.
 // -------------------------------------------------------------------
 
 const KEY_CHAT = '@ethora/persist:chatSettingStore';
 const KEY_ROOMS = '@ethora/persist:rooms';
+// bug #39: a failed send needs to survive a relaunch as "failed / tap
+// to retry", not silently render as delivered. `roomHeapStore.failedMessages`
+// is the map the bubble reads (`isFailed = failedMessages[id]`, see
+// Message.tsx / useMessageHeapState): it lives in a separate, previously
+// non-persisted slice from `rooms`, so it gets its own key here.
+const KEY_HEAP = '@ethora/persist:roomHeap';
 
 // Per-room message cap on disk. Mirror this value in `roomsSlice`'s
 // in-memory cap (see `enforceMessageCap`) so the runtime and persisted
 // shapes stay aligned.
 export const MESSAGE_LIMIT = 100;
 
+// Defensive cap on the number of failed-message payloads written to
+// disk. In practice this map only grows while the user is actively
+// sending offline, but a runaway sender (or a bug that never clears an
+// entry) must not turn this key into an unbounded write.
+export const MAX_PERSISTED_FAILED_MESSAGES = 200;
+
 interface PersistedChatState {
   user: User;
 }
@@ -31,6 +49,14 @@ interface PersistedRoomsState {
   // intentionally NOT persisted: activeRoomJID, editAction, isLoading
 }
 
+interface PersistedHeapState {
+  failedMessages: Record<string, FailedMessagePayload>;
+  // intentionally NOT persisted: messageHeap, a process-lifetime
+  // "in flight" buffer (see roomHeapSlice.ts); anything still in it when
+  // the app dies is handled by the boot-time pending->failed scan below,
+  // not by replaying the heap itself.
+}
+
 const sanitizeUser = (user?: User): User | null => {
   if (!user) {return null;}
   // Drop secrets we don't want at rest — destructure to omit, then
@@ -92,6 +118,13 @@ const PERSISTED_MESSAGE_FIELDS: (keyof IMessage)[] = [
   // paint already be translated, the way the live path already is.
   'translations',
   'callLog',
+  // bug #39: without this, a message that was still in flight (no
+  // server echo yet) at kill time comes back from disk indistinguishable
+  // from a normal delivered message, so the bubble renders it as sent.
+  // Persisting `pending` lets the boot-time scan (see
+  // computeBootTimeFailures below) find exactly the messages that never
+  // got confirmed and flip them to failed instead.
+  'pending',
 ];
 
 // The sender identity that rides along on every message over the wire
@@ -191,6 +224,154 @@ const sanitizeRooms = (
   return out;
 };
 
+// Only the fields retryMessage actually needs to replay the send (see
+// FailedMessagePayload / useSendMessage.retryMessage). In particular, the
+// media `data` blob is trimmed to `uri/type/name/size` (the picker never
+// hands us auth material, but this stays defensive against a future
+// picker change smuggling extra fields, or a huge inline payload, into
+// `data`).
+const sanitizeMediaData = (
+  data: any
+): { uri?: string; type?: string; name?: string; size?: number } => {
+  if (!data || typeof data !== 'object') {return {};}
+  const out: { uri?: string; type?: string; name?: string; size?: number } = {};
+  if (typeof data.uri === 'string') {out.uri = data.uri;}
+  if (typeof data.type === 'string') {out.type = data.type;}
+  if (typeof data.name === 'string') {out.name = data.name;}
+  if (typeof data.size === 'number') {out.size = data.size;}
+  return out;
+};
+
+const sanitizeFailedMessagePayload = (
+  payload: FailedMessagePayload
+): FailedMessagePayload | null => {
+  if (!payload || typeof payload !== 'object') {return null;}
+  if (!payload.id || typeof payload.id !== 'string') {return null;}
+  if (!payload.roomJID || typeof payload.roomJID !== 'string') {return null;}
+  if (payload.kind === 'media') {
+    return {
+      kind: 'media',
+      id: payload.id,
+      roomJID: payload.roomJID,
+      data: sanitizeMediaData(payload.data),
+      type: typeof payload.type === 'string' ? payload.type : '',
+      isReply: payload.isReply,
+      isChecked: payload.isChecked,
+      mainMessage: payload.mainMessage,
+    };
+  }
+  if (payload.kind === 'text') {
+    return {
+      kind: 'text',
+      id: payload.id,
+      roomJID: payload.roomJID,
+      body: typeof payload.body === 'string' ? payload.body : '',
+      isReply: payload.isReply,
+      isChecked: payload.isChecked,
+      mainMessage: payload.mainMessage,
+    };
+  }
+  return null;
+};
+
+const sanitizeFailedMessages = (
+  failedMessages: Record<string, FailedMessagePayload> | undefined
+): Record<string, FailedMessagePayload> => {
+  if (!failedMessages || typeof failedMessages !== 'object') {return {};}
+  const out: Record<string, FailedMessagePayload> = {};
+  let count = 0;
+  for (const [id, payload] of Object.entries(failedMessages)) {
+    if (count >= MAX_PERSISTED_FAILED_MESSAGES) {break;}
+    const clean = sanitizeFailedMessagePayload(payload);
+    if (clean) {
+      out[id] = clean;
+      count++;
+    }
+  }
+  return out;
+};
+
+// -------------------------------------------------------------------
+// Boot-time pending -> failed conversion (bug #39).
+//
+// `messageHeap` (the "still sending" buffer) is intentionally NOT
+// persisted: it's a process-lifetime thing. That means on a cold start
+// there is no such thing as "still sending": a persisted message that
+// carries `pending: true` never got a server echo NOR got the chance to
+// trip the in-session watchdog (see PENDING_WATCHDOG_MS in
+// useSendMessage.tsx) before the process died. It must render as failed
+// with a working retry, not as delivered and not as stuck "sending...".
+//
+// Reconstructs the same FailedMessagePayload shape the live send path
+// builds in useSendMessage (markMessageFailed calls), from the fields we
+// persist per message.
+// -------------------------------------------------------------------
+
+export function reconstructFailedMessagePayload(
+  message: IMessage,
+  roomJID: string
+): FailedMessagePayload | null {
+  if (!message?.id || !roomJID) {return null;}
+  const isReply = !!message.isReply;
+  const isChecked = message.showInChannel === 'true';
+  const mainMessage = message.mainMessage;
+  if (message.isMediafile === 'true') {
+    return {
+      kind: 'media',
+      id: message.id,
+      roomJID,
+      data: sanitizeMediaData({
+        uri: message.location,
+        name: message.fileName,
+        type: message.mimetype,
+        size:
+          message.size !== undefined && message.size !== null
+            ? Number(message.size)
+            : undefined,
+      }),
+      type: message.mimetype || '',
+      isReply,
+      isChecked,
+      mainMessage,
+    };
+  }
+  return {
+    kind: 'text',
+    id: message.id,
+    roomJID,
+    body: message.body || '',
+    isReply,
+    isChecked,
+    mainMessage,
+  };
+}
+
+/**
+ * Scan every persisted room for messages still `pending: true` that
+ * DON'T already have a restored failure entry (those are handled by the
+ * caller separately, from the persisted `failedMessages` map), and
+ * synthesize a retry-able FailedMessagePayload for each. Pure function:
+ * the caller (roomStore/index.ts) is responsible for dispatching
+ * `markMessageFailed` for the results.
+ */
+export function computeBootTimeFailures(
+  rooms: Record<string, IRoom> | null | undefined,
+  alreadyFailed: Record<string, FailedMessagePayload> | null | undefined
+): FailedMessagePayload[] {
+  if (!rooms || typeof rooms !== 'object') {return [];}
+  const out: FailedMessagePayload[] = [];
+  for (const [jid, room] of Object.entries(rooms)) {
+    const messages = Array.isArray(room?.messages) ? room.messages : [];
+    for (const message of messages) {
+      if (!message || !message.pending) {continue;}
+      if (alreadyFailed && alreadyFailed[message.id]) {continue;}
+      const payload = reconstructFailedMessagePayload(message, jid);
+      if (payload) {out.push(payload);}
+    }
+  }
+  return out;
+}
+
 let writeTimer: ReturnType<typeof setTimeout> | null = null;
 
 /**
@@ -205,6 +386,7 @@ export const persistenceMiddleware: Middleware = (storeAPI) => (next) => (
   const type: string = action?.type || '';
   if (
     !type.startsWith('roomMessages/') &&
+    !type.startsWith('roomHeapStore/') &&
     !type.startsWith('chat/setUser') &&
     !type.startsWith('chat/updateUser') &&
     !type.startsWith('chat/refreshTokens') &&
@@ -215,21 +397,34 @@ export const persistenceMiddleware: Middleware = (storeAPI) => (next) => (
 
   if (writeTimer) {clearTimeout(writeTimer);}
   writeTimer = setTimeout(() => {
-    try {
-      const state = storeAPI.getState();
-      const chatPayload: PersistedChatState = {
-        user: sanitizeUser(state.chatSettingStore?.user) as User,
-      };
-      const roomsPayload: PersistedRoomsState = {
-        rooms: sanitizeRooms(state.rooms?.rooms || {}),
-      };
-      AsyncStorage.multiSet([
-        [KEY_CHAT, JSON.stringify(chatPayload)],
-        [KEY_ROOMS, JSON.stringify(roomsPayload)],
-      ]).catch((e) => console.warn('persist write failed', e));
-    } catch (e) {
-      console.warn('persist serialize failed', e);
-    }
+    (async () => {
+      try {
+        const state = storeAPI.getState();
+        const chatPayload: PersistedChatState = {
+          user: sanitizeUser(state.chatSettingStore?.user) as User,
+        };
+        const roomsPayload: PersistedRoomsState = {
+          rooms: sanitizeRooms(state.rooms?.rooms || {}),
+        };
+        const heapPayload: PersistedHeapState = {
+          failedMessages: sanitizeFailedMessages(
+            state.roomHeapSlice?.failedMessages
+          ),
+        };
+        const [chatCipher, roomsCipher, heapCipher] = await Promise.all([
+          encryptForPersist(JSON.stringify(chatPayload)),
+          encryptForPersist(JSON.stringify(roomsPayload)),
+          encryptForPersist(JSON.stringify(heapPayload)),
+        ]);
+        await AsyncStorage.multiSet([
+          [KEY_CHAT, chatCipher],
+          [KEY_ROOMS, roomsCipher],
+          [KEY_HEAP, heapCipher],
+        ]);
+      } catch (e) {
+        console.warn('persist write failed', e);
+      }
+    })();
   }, 200);
 
   return result;
@@ -243,29 +438,44 @@ export const persistenceMiddleware: Middleware = (storeAPI) => (next) => (
 export async function readPersistedState(): Promise<{
   chat: PersistedChatState | null;
   rooms: PersistedRoomsState | null;
+  heap: PersistedHeapState | null;
 }> {
   try {
-    const [chatRaw, roomsRaw] = await AsyncStorage.multiGet([
+    const [chatRaw, roomsRaw, heapRaw] = await AsyncStorage.multiGet([
       KEY_CHAT,
       KEY_ROOMS,
+      KEY_HEAP,
     ]);
-    const chat = chatRaw[1] ? (JSON.parse(chatRaw[1]) as PersistedChatState) : null;
-    const rooms = roomsRaw[1]
-      ? (JSON.parse(roomsRaw[1]) as PersistedRoomsState)
+    const [chatPlain, roomsPlain, heapPlain] = await Promise.all([
+      chatRaw[1] ? decryptFromPersist(chatRaw[1]) : Promise.resolve(null),
+      roomsRaw[1] ? decryptFromPersist(roomsRaw[1]) : Promise.resolve(null),
+      heapRaw[1] ? decryptFromPersist(heapRaw[1]) : Promise.resolve(null),
+    ]);
+    // `decryptFromPersist` returns null both for "nothing stored" and
+    // for "stored value isn't a valid envelope for the current key" —
+    // notably a plaintext blob left over from a pre-encryption install.
+    // Either way there is nothing safe to parse, so the caller treats it
+    // as a cold start and re-hydrates from the server.
+    const chat = chatPlain ? (JSON.parse(chatPlain) as PersistedChatState) : null;
+    const rooms = roomsPlain
+      ? (JSON.parse(roomsPlain) as PersistedRoomsState)
+      : null;
+    const heap = heapPlain
+      ? (JSON.parse(heapPlain) as PersistedHeapState)
       : null;
-    return { chat, rooms };
+    return { chat, rooms, heap };
   } catch (e) {
     console.warn('persist read failed', e);
-    return { chat: null, rooms: null };
+    return { chat: null, rooms: null, heap: null };
   }
 }
 
 export async function clearPersistedState(): Promise<void> {
   try {
-    await AsyncStorage.multiRemove([KEY_CHAT, KEY_ROOMS]);
+    await AsyncStorage.multiRemove([KEY_CHAT, KEY_ROOMS, KEY_HEAP]);
   } catch (e) {
     console.warn('persist clear failed', e);
   }
 }
 
-export const PERSIST_KEYS = { KEY_CHAT, KEY_ROOMS };
+export const PERSIST_KEYS = { KEY_CHAT, KEY_ROOMS, KEY_HEAP };