@ethora/chat-component-rn 26.10.6 → 26.10.8

package/src/helpers/incomingCallFromPush.ts

@@ -1,33 +1,61 @@
 import { store } from '../roomStore';
-import { setIncomingCallToken } from '../roomStore/callSlice';
+import { acceptIncomingCall, setIncomingCallToken } from '../roomStore/callSlice';
+import { endSystemIncomingCall } from '../components/VideoCalls/systemCall';
+import { declineActiveCallWhenOnline } from '../components/VideoCalls/callActions';
 import { isCallPush, parseCallPush } from './callPush';
+import { normalizeRoomJid } from './normalizeRoomJid';
 
-/**
- * Turn an incoming-call push into a ringing call.
- *
- * On mobile the XMPP socket dies whenever the OS backgrounds or kills the
- * app, and the `call-token` stanza that normally opens the ring screen is
- * lost with it. The backend also delivers the call as a data push, so this
- * is the path every call takes when the app was not in the foreground.
- *
- * Returns true when the payload WAS a call push (whether or not it could
- * be rung), so the caller knows to stop and not also show it as a chat
- * notification. A user should never get a "new message: call-state" toast.
- */
-export const handleCallPush = (
-  data: Record<string, any> | null | undefined
-): boolean => {
-  if (!isCallPush(data)) {
-    return false;
-  }
+const PENDING_CALL_PUSH_TTL_MS = 60_000;
+
+
+export type CallPushIntent = 'ring' | 'answer' | 'decline';
+
+let pendingPush: { data: Record<string, any>; intent: CallPushIntent; at: number } | null = null;
+let unwatch: (() => void) | null = null;
+
+const trace = (...args: unknown[]) => {
+  if (__DEV__) {console.log('[calls] push:', ...args);}
+};
+
+const callsConfigured = (): boolean =>
+  store.getState().chatSettingStore.config?.videoCalls !== undefined;
+
+const holdUntilConfigured = (data: Record<string, any>, intent: CallPushIntent): void => {
+  pendingPush = { data, intent, at: Date.now() };
+  if (unwatch) {return;}
+  unwatch = store.subscribe(() => {
+    if (!callsConfigured()) {return;}
+    unwatch?.();
+    unwatch = null;
+    const held = pendingPush;
+    pendingPush = null;
+    if (!held) {return;}
+    if (Date.now() - held.at > PENDING_CALL_PUSH_TTL_MS) {
+      trace('held call push expired');
+      endSystemIncomingCall(parseCallPush(held.data).callId);
+      return;
+    }
+    ringFromPush(held.data, held.intent);
+  });
+};
 
+const applyIntent = (intent: CallPushIntent): void => {
+  const call = store.getState().call;
+  if (call.direction !== 'incoming' || call.phase !== 'ringing-incoming') {return;}
+  if (intent === 'answer') {store.dispatch(acceptIncomingCall());}
+  if (intent === 'decline') {declineActiveCallWhenOnline();}
+};
+
+const ringFromPush = (data: Record<string, any>, intent: CallPushIntent): boolean => {
   const parsed = parseCallPush(data);
   const state = store.getState();
 
   // Calls off in this deployment: swallow the push rather than ringing a
   // screen the host never opted into.
   if (state.chatSettingStore.config?.videoCalls?.enabled !== true) {
-    return true;
+    trace('calls are off, dropping', parsed.callId);
+    endSystemIncomingCall(parsed.callId);
+    return false;
   }
 
   // Already ringing or in this exact call (the push raced the stanza, or
@@ -38,9 +66,15 @@ export const handleCallPush = (
     const sameCall =
       (!!parsed.callId && parsed.callId === current.callId) ||
       (!!parsed.roomBareName && parsed.roomBareName === current.roomBareName);
-    if (sameCall || current.phase === 'in-call') {
+    if (sameCall) {
+      applyIntent(intent);
       return true;
     }
+    if (current.phase === 'in-call') {
+      // Busy with another call: no second ring.
+      endSystemIncomingCall(parsed.callId);
+      return false;
+    }
   }
 
   // Without a LiveKit token there is nothing to accept: the push is only
@@ -48,7 +82,8 @@ export const handleCallPush = (
   // cannot work, so treat it as handled and let the stanza (once the
   // socket is back up) open the real ring screen.
   if (!parsed.token) {
-    return true;
+    endSystemIncomingCall(parsed.callId);
+    return false;
   }
 
   // Resolve the full room JID from the local room map. The push carries
@@ -60,11 +95,16 @@ export const handleCallPush = (
       room?.jid === parsed.roomRef
   ) as { jid?: string; name?: string; title?: string } | undefined;
 
-  const roomJid =
-    resolved?.jid ||
-    (parsed.roomRef && parsed.roomRef.includes('@') ? parsed.roomRef : '');
+  const conference =
+    state.chatSettingStore.config?.xmppSettings?.conference || '';
+  const fromRef = parsed.roomRef
+    ? normalizeRoomJid(parsed.roomRef, conference)
+    : '';
+  const roomJid = resolved?.jid || (fromRef.includes('@') ? fromRef : '');
   if (!roomJid) {
-    return true;
+    trace('no room for call push', parsed.roomRef);
+    endSystemIncomingCall(parsed.callId);
+    return false;
   }
 
   store.dispatch(
@@ -78,6 +118,37 @@ export const handleCallPush = (
       peerXmppUsername: parsed.callerXmppUsername,
     })
   );
+  trace('ringing', parsed.callId, intent);
+  applyIntent(intent);
+  return true;
+};
 
+export const handleCallPush = (
+  data: Record<string, any> | null | undefined,
+  intent: CallPushIntent = 'ring'
+): boolean => {
+  if (!isCallPush(data)) {
+    return false;
+  }
+  if (!callsConfigured()) {
+    trace('holding call push until the chat is configured');
+    holdUntilConfigured(data as Record<string, any>, intent);
+    return true;
+  }
+  ringFromPush(data as Record<string, any>, intent);
   return true;
 };
+
+export const answerCallFromPush = (
+  data: Record<string, any> | null | undefined
+): boolean => handleCallPush(data, 'answer');
+
+export const declineCallFromPush = (
+  data: Record<string, any> | null | undefined
+): boolean => handleCallPush(data, 'decline');
+
+export const __resetCallPushForTests = (): void => {
+  unwatch?.();
+  unwatch = null;
+  pendingPush = null;
+};

package/src/helpers/secureStoreRuntime.ts

@@ -12,10 +12,25 @@
  * AsyncStorage rather than crash (see `secureKeyValue.ts`).
  */
 
+/**
+ * The subset of expo-secure-store's options the SDK uses. `keychainService`
+ * must be repeated on every read of an item written with it; the
+ * accessibility constants come from `SecureStoreRuntime.accessible`.
+ */
+export interface SecureStoreOptions {
+  keychainService?: string;
+  /** iOS only: one of `accessible`; ignored on Android. */
+  keychainAccessible?: unknown;
+}
+
 export interface SecureStoreRuntime {
-  getItemAsync: (key: string) => Promise<string | null>;
-  setItemAsync: (key: string, value: string) => Promise<void>;
-  deleteItemAsync: (key: string) => Promise<void>;
+  getItemAsync: (key: string, options?: SecureStoreOptions) => Promise<string | null>;
+  setItemAsync: (key: string, value: string, options?: SecureStoreOptions) => Promise<void>;
+  deleteItemAsync: (key: string, options?: SecureStoreOptions) => Promise<void>;
+  /** expo-secure-store's iOS keychain accessibility constants (undefined on older versions). */
+  accessible: {
+    afterFirstUnlockThisDeviceOnly?: unknown;
+  };
 }
 
 let cached: SecureStoreRuntime | null | undefined;
@@ -45,6 +60,9 @@ export const loadSecureStore = (): SecureStoreRuntime | null => {
         getItemAsync: mod.getItemAsync,
         setItemAsync: mod.setItemAsync,
         deleteItemAsync: mod.deleteItemAsync,
+        accessible: {
+          afterFirstUnlockThisDeviceOnly: mod.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
+        },
       };
     }
   } catch {

package/src/main.ts

@@ -33,6 +33,14 @@ export { XmppProvider } from './context/xmppProvider';
 export { useUnread } from './hooks/useUnreadMessagesCounter';
 
 export { handlePushPayload, openRoomFromPush } from './helpers/pushPayload';
+export { callKitUuid } from './components/VideoCalls/systemCall';
+export {
+  answerCallFromPush,
+  declineCallFromPush,
+} from './helpers/incomingCallFromPush';
+export type { CallPushIntent } from './helpers/incomingCallFromPush';
+export { isCallPush, parseCallPush } from './helpers/callPush';
+export type { ParsedCallPush } from './helpers/callPush';
 export type { PushPayloadOutcome } from './helpers/pushPayload';
 export {
   registerPushToken,
@@ -56,6 +64,36 @@ export type {
   PushSubscriptionPayload,
 } from './networking/api-requests/push.api';
 export type { PushTokenType, PushTokenRegistration } from './types/types';
+// Encrypted (sealed) pushes: the device key and the Android renderer.
+// iOS renders them in the notification service extension the config
+// plugin adds. See README, "Encrypted pushes".
+export {
+  ensurePushKeyPair,
+  getPushKeyPair,
+  resetPushKeyPair,
+  clearPushKeyPair,
+  PUSH_KEY_KEYCHAIN_SERVICE,
+  PUSH_SECRET_KEY_ITEM,
+} from './push/pushKeyStore';
+export type { PushKeyPair } from './push/pushKeyStore';
+export {
+  registerSealedPushTask,
+  presentSealedPush,
+  SEALED_PUSH_TASK,
+} from './push/sealedPushTask';
+export type { SealedPushTaskOptions } from './push/sealedPushTask';
+export {
+  openSealedPush,
+  isSealedPush,
+  sealedPushEnvelopeOf,
+  SEALED_PUSH_ALG,
+} from './push/sealedPush';
+export type {
+  SealedPushEnvelope,
+  SealedPushContent,
+  SealedPushFailure,
+  OpenSealedPushResult,
+} from './push/sealedPush';
 export { useChatRoomFocus } from './hooks/useChatRoomFocus';
 export { logoutService, useLogout } from './hooks/useLogout';
 export { useQRCodeChat, handleQRChatId } from './hooks/useQRCodeChatHandler';

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

@@ -67,10 +67,20 @@ const isUnknownFieldError = (error: any): boolean =>
   error?.response?.status === 422 &&
   /not allowed/i.test(String(error?.response?.data?.error ?? ''));
 
+/** The only sealing scheme the push service knows (README, "Encrypted pushes"). */
+export const PUSH_KEY_ALG = 'sealed-box-x25519';
+
 export interface PushSubscriptionPayload {
   registrationToken: string;
   deviceType: PushDeviceType;
   tokenType?: PushTokenType;
+  /**
+   * Encrypted pushes: base64 of the device's 32-byte X25519 public key.
+   * Absent keeps whatever key the service holds for this token.
+   */
+  pushKey?: string;
+  pushKeyAlg?: typeof PUSH_KEY_ALG;
+  pushKeyId?: string;
 }
 
 export interface RegisterPushSubscriptionArgs {
@@ -78,15 +88,23 @@ export interface RegisterPushSubscriptionArgs {
   token: string;
   tokenType: PushTokenType;
   authToken: string;
+  /** Base64 public key for encrypted pushes (`ensurePushKeyPair().publicKey`). */
+  pushKey?: string;
+  pushKeyId?: string;
 }
 
 export const buildPushSubscriptionPayload = (
   token: string,
-  tokenType: PushTokenType
+  tokenType: PushTokenType,
+  pushKey?: string,
+  pushKeyId?: string
 ): PushSubscriptionPayload => ({
   registrationToken: token,
   deviceType: resolvePushDeviceType(),
   tokenType,
+  ...(pushKey
+    ? { pushKey, pushKeyAlg: PUSH_KEY_ALG, ...(pushKeyId ? { pushKeyId } : {}) }
+    : {}),
 });
 
 export async function registerPushSubscription({
@@ -94,22 +112,29 @@ export async function registerPushSubscription({
   token,
   tokenType,
   authToken,
+  pushKey,
+  pushKeyId,
 }: RegisterPushSubscriptionArgs): Promise<void> {
   const path = `/v1/push/subscription/${encodeURIComponent(appId)}`;
   const headers = { Authorization: authToken };
-  const payload = buildPushSubscriptionPayload(token, tokenType);
+  const payload = buildPushSubscriptionPayload(token, tokenType, pushKey, pushKeyId);
 
   try {
     await http.post(path, payload, { headers });
     return;
   } catch (error: any) {
-    const canDowngrade = tokenType === 'apns' || tokenType === 'fcm';
+    // A backend that predates `tokenType` still delivers to apns / fcm
+    // tokens. One that predates `pushKey` would deliver in the clear: the
+    // host asked for encryption, so that is an error, never a quiet fallback.
+    const canDowngrade = (tokenType === 'apns' || tokenType === 'fcm') && !pushKey;
     if (!(canDowngrade && isUnknownFieldError(error))) {
       throw toRegistrationError(
         error,
         tokenType === 'expo'
           ? 'Push registration (the backend does not accept Expo push tokens yet)'
-          : 'Push registration'
+          : pushKey && isUnknownFieldError(error)
+            ? 'Push registration (the backend does not support encrypted pushes)'
+            : 'Push registration'
       );
     }
   }

package/src/networking/callTokenStanza.ts

@@ -528,6 +528,16 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         return true;
       }
 
+      if (
+        callState.direction === 'incoming' &&
+        callState.phase !== 'idle' &&
+        !!callId &&
+        callState.callId === callId
+      ) {
+        callTrace('drop call-token: call already known from push', { callId });
+        return true;
+      }
+
       store.dispatch(
         setIncomingCallToken({
           roomJid,

package/src/networking/xmpp/sendMessageReaction.xmpp.ts

@@ -1,18 +1,51 @@
 import { Client, xml } from '@xmpp/client';
+import { shouldEncrypt } from '../../e2ee/send';
+
+export interface ReactionStanzaData {
+  firstName?: string;
+  lastName?: string;
+  photoURL?: string;
+  push?: boolean;
+  messageAuthor?: string;
+  messageText?: string;
+  isMediafile?: string;
+  mimetype?: string;
+  fileName?: string;
+}
+
+export const REACTION_MESSAGE_TEXT_MAX = 120;
 
 export function sendMessageReaction(
   client: Client,
   messageId: string,
   roomJid: string,
   reactionsList: string[],
-  data: any,
-  reactionSymbol?: any,
+  data: ReactionStanzaData = {}
 ) {
   const id = `message-reaction:${Date.now().toString()}`;
 
-  const dataReaction = {
-    senderFirstName: data.firstName,
-    senderLastName: data.lastName,
+  const push = Boolean(data.push) && reactionsList.length > 0;
+  const messageText =
+    push && !shouldEncrypt(roomJid)
+      ? String(data.messageText ?? '').slice(0, REACTION_MESSAGE_TEXT_MAX)
+      : '';
+
+  const dataReaction: Record<string, string> = {
+    senderFirstName: data.firstName ?? '',
+    senderLastName: data.lastName ?? '',
+    senderJID: client.jid?.toString() ?? '',
+    roomJid,
+    ...(data.photoURL ? { photoURL: data.photoURL } : {}),
+    ...(push
+      ? {
+          push: 'true',
+          messageAuthor: data.messageAuthor ?? '',
+          messageText,
+          isMediafile: data.isMediafile ?? '',
+          mimetype: data.mimetype ?? '',
+          fileName: data.fileName ?? '',
+        }
+      : {}),
   };
 
   const message = xml(
@@ -31,7 +64,6 @@ export function sendMessageReaction(
         xmlns: 'urn:xmpp:reactions:0',
       },
       ...reactionsList.map((reaction) => xml('reaction', {}, reaction ?? ''))
-      // xml('reaction', {}, reactionSymbol ?? '👋'),
     ),
     xml('data', dataReaction),
     xml('store', { xmlns: 'urn:xmpp:hints' })

package/src/networking/xmppClient.ts

@@ -16,7 +16,7 @@ import {
   HistoryPageCursor,
 } from './xmpp/getHistory.xmpp';
 import { sendTextMessage } from './xmpp/sendTextMessage.xmpp';
-import { sendMessageReaction } from './xmpp/sendMessageReaction.xmpp';
+import { sendMessageReaction, type ReactionStanzaData } from './xmpp/sendMessageReaction.xmpp';
 import { sendReceivedReceipt } from './xmpp/sendReceivedReceipt.xmpp';
 import { sendDisplayedMarker } from './xmpp/sendDisplayedMarker.xmpp';
 import { sendTextMessageWithTranslateTag } from './xmpp/sendTextMessageWithTranslateTag.xmpp';
@@ -1646,7 +1646,7 @@ export class XmppClient {
     messageId: string,
     roomJid: string,
     reactionsList: string[],
-    data?: { firstName?: string; lastName?: string }
+    data?: ReactionStanzaData
   ) {
     sendMessageReaction(
       this.client,

package/src/push/pushKeyStore.ts

@@ -0,0 +1,163 @@
+import { fromBase64, toBase64 } from '../e2ee/crypto';
+import { loadSecureStore, type SecureStoreOptions } from '../helpers/secureStoreRuntime';
+import { pushLog } from '../utils/devLogger';
+import {
+  SEALED_BOX_PUBLIC_KEY_BYTES,
+  SEALED_BOX_SECRET_KEY_BYTES,
+  generateSealedBoxKeyPair,
+  sealedBoxKeyId,
+  sealedBoxPublicKeyOf,
+} from './sealedBox';
+import type { SealedPushKey } from './sealedPush';
+
+// The device key for encrypted pushes: one X25519 pair per install, in the
+// platform keychain / keystore through expo-secure-store. The public half
+// goes to the push service with the token (`pushKey`); the secret half
+// never leaves the device and is read by whoever renders a sealed push —
+// the Android background task (`sealedPushTask.ts`, same process, same
+// store) and the iOS notification service extension, which reads the
+// keychain item directly (plugins/notification-service), so the item's
+// attributes below are a contract with the Swift side:
+//   service   `ethora.push` (expo-secure-store stores it as `ethora.push:no-auth`)
+//   account   `ethora_push_secret_key`, UTF-8
+//   value     base64 of the 32-byte secret key, UTF-8
+//   group     the app's first keychain access group, which the config
+//             plugin shares with the extension
+// Readable after the first unlock so a push that arrives while the phone
+// is locked still decrypts; this device only, so an iCloud keychain copy
+// on another device is never a key for pushes that go to this one.
+
+export const PUSH_KEY_KEYCHAIN_SERVICE = 'ethora.push';
+export const PUSH_SECRET_KEY_ITEM = 'ethora_push_secret_key';
+export const PUSH_PUBLIC_KEY_ITEM = 'ethora_push_public_key';
+
+export interface PushKeyPair {
+  /** Base64 of the raw 32-byte X25519 public key — the `pushKey` of the registration. */
+  publicKey: string;
+  /** The `pushKeyId` the service derives for it, for logs and the kid check. */
+  keyId: string;
+}
+
+let warnedMissingStore = false;
+const warnMissingStoreOnce = () => {
+  if (warnedMissingStore) {return;}
+  warnedMissingStore = true;
+  pushLog(
+    'warn',
+    'push: expo-secure-store is not installed, so no device key for encrypted ' +
+      'pushes can be kept; pushes stay in the clear.'
+  );
+};
+
+const storeOptions = (): SecureStoreOptions | null => {
+  const store = loadSecureStore();
+  if (!store) {return null;}
+  const accessible = store.accessible.afterFirstUnlockThisDeviceOnly;
+  return {
+    keychainService: PUSH_KEY_KEYCHAIN_SERVICE,
+    ...(accessible !== undefined ? { keychainAccessible: accessible } : {}),
+  };
+};
+
+const readItem = async (item: string): Promise<string | null> => {
+  const store = loadSecureStore();
+  const options = storeOptions();
+  if (!store || !options) {return null;}
+  try {
+    return await store.getItemAsync(item, options);
+  } catch (e) {
+    pushLog('warn', `push: reading ${item} failed`, e);
+    return null;
+  }
+};
+
+const decodeKey = (raw: string | null, length: number): Uint8Array | null => {
+  if (!raw) {return null;}
+  try {
+    const bytes = fromBase64(raw);
+    return bytes.length === length ? bytes : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The stored pair, or null when there is none (or it is unreadable).
+ * The public key is re-derived from the secret, so the pair is consistent
+ * even if only the secret item survived.
+ */
+export async function loadPushSecretKey(): Promise<SealedPushKey | null> {
+  const secretKey = decodeKey(await readItem(PUSH_SECRET_KEY_ITEM), SEALED_BOX_SECRET_KEY_BYTES);
+  if (!secretKey) {return null;}
+  const stored = decodeKey(await readItem(PUSH_PUBLIC_KEY_ITEM), SEALED_BOX_PUBLIC_KEY_BYTES);
+  return { publicKey: stored ?? sealedBoxPublicKeyOf(secretKey), secretKey };
+}
+
+const describe = (publicKey: Uint8Array): PushKeyPair => ({
+  publicKey: toBase64(publicKey),
+  keyId: sealedBoxKeyId(publicKey),
+});
+
+/** The public half of the stored pair, null when the device has no key. */
+export async function getPushKeyPair(): Promise<PushKeyPair | null> {
+  const key = await loadPushSecretKey();
+  return key ? describe(key.publicKey) : null;
+}
+
+/**
+ * Generate and store a new pair, replacing any existing one. Pushes sealed
+ * for the old key stop opening at once, so re-register the token with the
+ * new `publicKey` right after. Null when expo-secure-store is missing or
+ * the keychain refused the write.
+ */
+export async function resetPushKeyPair(): Promise<PushKeyPair | null> {
+  const store = loadSecureStore();
+  const options = storeOptions();
+  if (!store || !options) {
+    warnMissingStoreOnce();
+    return null;
+  }
+  const pair = generateSealedBoxKeyPair();
+  try {
+    await store.setItemAsync(PUSH_SECRET_KEY_ITEM, toBase64(pair.secretKey), options);
+    await store.setItemAsync(PUSH_PUBLIC_KEY_ITEM, toBase64(pair.publicKey), options);
+  } catch (e) {
+    pushLog('warn', 'push: storing the device key failed', e);
+    return null;
+  }
+  const check = await loadPushSecretKey();
+  if (!check || toBase64(check.publicKey) !== toBase64(pair.publicKey)) {
+    pushLog('warn', 'push: the device key was not kept');
+    return null;
+  }
+  pushLog('rn', `push: new device key ${sealedBoxKeyId(pair.publicKey)}`);
+  return describe(pair.publicKey);
+}
+
+/**
+ * The device key for encrypted pushes, created on first call. Hand
+ * `publicKey` to `registerPushToken` (or send it as `pushKey` yourself).
+ */
+export async function ensurePushKeyPair(): Promise<PushKeyPair | null> {
+  const existing = await getPushKeyPair();
+  return existing ?? resetPushKeyPair();
+}
+
+/** Remove the pair; the next `ensurePushKeyPair` creates a new one. */
+export async function clearPushKeyPair(): Promise<void> {
+  const store = loadSecureStore();
+  const options = storeOptions();
+  if (!store || !options) {return;}
+  for (const item of [PUSH_SECRET_KEY_ITEM, PUSH_PUBLIC_KEY_ITEM]) {
+    try {
+      await store.deleteItemAsync(item, options);
+    } catch {
+      // Not there — nothing to remove.
+    }
+  }
+}
+
+/** Test seam only. */
+export const __resetPushKeyStoreForTests = (): void => {
+  warnedMissingStore = false;
+};