matrix-js-sdk 41.4.0 → 41.5.0

package/src/rendezvous/index.ts

@@ -14,6 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+import { type MatrixClient, OAuthGrantType, type OidcClientConfig } from "../matrix.ts";
+import { MSC4108FailureReason, type RendezvousFailureListener } from "./RendezvousFailureReason.ts";
+import { MSC4108SignInWithQR } from "./MSC4108SignInWithQR.ts";
+import { MSC4108RendezvousSession } from "./transports/MSC4108RendezvousSession.ts";
+import { MSC4108SecureChannel } from "./channels/MSC4108SecureChannel.ts";
+import { RendezvousIntent } from "./RendezvousIntent.ts";
+import { logger } from "../logger.ts";
+
 export * from "./MSC4108SignInWithQR.ts";
 export type * from "./RendezvousChannel.ts";
 export type * from "./RendezvousCode.ts";
@@ -23,3 +31,110 @@ export * from "./RendezvousIntent.ts";
 export type * from "./RendezvousTransport.ts";
 export * from "./transports/index.ts";
 export * from "./channels/index.ts";
+
+/**
+ * Check if the homeserver that the client is connected to supports a variant of sign-in with QR that we can use.
+ *
+ * @param client the client to check for sign-in with QR support
+ * @returns true if the homeserver that the client is connected to supports a variant of sign-in with QR that we can use, false otherwise.
+ */
+export async function isSignInWithQRAvailable(client: MatrixClient): Promise<boolean> {
+    let metadata: OidcClientConfig;
+    try {
+        metadata = await client.getAuthMetadata();
+    } catch (e) {
+        logger.warn("Failed to fetch auth metadata, assuming sign-in with QR is unavailable", e);
+        return false;
+    }
+
+    // check for support of device authorization grant
+    if (!metadata.grant_types_supported.includes(OAuthGrantType.DeviceAuthorization)) {
+        return false;
+    }
+
+    // check for unstable support for MSC4108 2024 version
+    return client.doesServerSupportUnstableFeature("org.matrix.msc4108");
+}
+
+/**
+ * Start a linking flow from an existing authenticated client by generating a QR code that can be scanned by the new device.
+ * The new device will then authenticate with the server and link itself to the same account as the existing client and
+ * share the end-to-end encryption keys.
+ *
+ * @param client the existing client
+ * @param onFailure callback for when the linking process fails
+ * @param abortSignal an AbortSignal that can be used to cancel the linking process,
+ *   for example when the user cancels out of the flow.
+ *   This will unbind the {@link onFailure} callback and prevent any further steps in the flow from being executed.
+ * @returns a promise that resolves to an instance of the linking flow
+ */
+export async function linkNewDeviceByGeneratingQR(
+    client: MatrixClient,
+    onFailure: RendezvousFailureListener,
+    abortSignal: AbortSignal,
+): Promise<MSC4108SignInWithQR> {
+    // we assume rust crypto is already initialised
+    return initGenerateQrFlow(RendezvousIntent.RECIPROCATE_LOGIN_ON_EXISTING_DEVICE, client, onFailure, abortSignal);
+}
+
+/**
+ * Start a sign-in flow by generating a QR code that can be scanned by an existing authenticated client.
+ * The existing client will then help complete the authentication of the new device and link it to the same account,
+ * sharing the end-to-end encryption keys.
+ *
+ * @param tempClient temporary client used during the flow for the rendezvous channel
+ * @param onFailure callback for when the sign-in process fails
+ * @param abortSignal an AbortSignal that can be used to cancel the linking process,
+ *   for example when the user cancels out of the flow.
+ *   This will unbind the {@link onFailure} callback and prevent any further steps in the flow from being executed.
+ * @returns a promise that resolves to an instance of the sign-in flow
+ */
+export async function signInByGeneratingQR(
+    tempClient: MatrixClient,
+    onFailure: RendezvousFailureListener,
+    abortSignal: AbortSignal,
+): Promise<MSC4108SignInWithQR> {
+    // ensure rust crypto is initialized as needed for the secure channel
+    const RustSdkCryptoJs = await import("@matrix-org/matrix-sdk-crypto-wasm");
+    await RustSdkCryptoJs.initAsync();
+
+    return initGenerateQrFlow(RendezvousIntent.LOGIN_ON_NEW_DEVICE, tempClient, onFailure, abortSignal);
+}
+
+async function initGenerateQrFlow(
+    intent: RendezvousIntent,
+    client: MatrixClient,
+    onFailure: RendezvousFailureListener,
+    abortSignal: AbortSignal,
+): Promise<MSC4108SignInWithQR> {
+    const session = new MSC4108RendezvousSession({
+        onFailure,
+        client,
+    });
+    const channel = new MSC4108SecureChannel(session, undefined, onFailure);
+    const flow = new MSC4108SignInWithQR(
+        channel,
+        false,
+        intent === RendezvousIntent.LOGIN_ON_NEW_DEVICE ? undefined : client,
+        onFailure,
+    );
+
+    if (abortSignal.aborted) return flow;
+
+    abortSignal.onabort = (): void => {
+        // Detach failure handlers
+        session.onFailure = undefined;
+        channel.onFailure = undefined;
+        flow.onFailure = undefined;
+        // Cancel the session
+        flow.cancel(MSC4108FailureReason.UserCancelled);
+    };
+
+    await session.send(""); // open channel
+
+    if (!abortSignal.aborted) {
+        await flow.generateCode();
+    }
+
+    return flow;
+}

package/src/rendezvous/transports/MSC4108RendezvousSession.ts

@@ -30,7 +30,7 @@ export class MSC4108RendezvousSession {
     private readonly client?: MatrixClient;
     private readonly fallbackRzServer?: string;
     private readonly fetchFn?: typeof globalThis.fetch;
-    private readonly onFailure?: RendezvousFailureListener;
+    public onFailure?: RendezvousFailureListener;
     private etag?: string;
     private expiresAt?: Date;
     private expiresTimer?: ReturnType<typeof setTimeout>;

package/src/rust-crypto/rust-crypto.ts

@@ -2596,7 +2596,7 @@ function rustEncryptionInfoToJsEncryptionInfo(
 }
 
 interface RoomKeyBundleMessage {
-    type: "io.element.msc4268.room_key_bundle";
+    type: "m.room_key_bundle" | "io.element.msc4268.room_key_bundle";
     content: {
         room_id: string;
     };
@@ -2606,13 +2606,16 @@ interface RoomKeyBundleMessage {
  * Determines if the given payload is a RoomKeyBundleMessage.
  *
  * A RoomKeyBundleMessage is identified by having a specific message type
- * ("io.element.msc4268.room_key_bundle") and a valid room_id in its content.
+ * ("m.room_key_bundle") and a valid room_id in its content.
  *
  * @param message - The received to-device message to check.
  * @returns True if the payload matches the RoomKeyBundleMessage structure, false otherwise.
  */
 function isRoomKeyBundleMessage(message: IToDeviceEvent): message is IToDeviceEvent & RoomKeyBundleMessage {
-    return message.type === "io.element.msc4268.room_key_bundle" && typeof message.content.room_id === "string";
+    return (
+        (message.type === "io.element.msc4268.room_key_bundle" || message.type === "m.room_key_bundle") &&
+        typeof message.content.room_id === "string"
+    );
 }
 
 type CryptoEvents = (typeof CryptoEvent)[keyof typeof CryptoEvent];

package/src/store/index.ts

@@ -16,7 +16,7 @@ limitations under the License.
 
 import { type EventType } from "../@types/event.ts";
 import { type Room } from "../models/room.ts";
-import { type User } from "../models/user.ts";
+import { type SyncUserProfile, type User } from "../models/user.ts";
 import { type IEvent, type MatrixEvent } from "../models/event.ts";
 import { type Filter } from "../filter.ts";
 import { type RoomSummary } from "../models/room-summary.ts";
@@ -254,6 +254,25 @@ export interface IStore {
      */
     removeToDeviceBatch(id: number): Promise<void>;
 
+    /**
+     * Store user profile details from a sync. Existing profiles will be overwritten.
+     * @param userProfiles - A map of userIds to profiles.
+     */
+    storeUserProfiles(userProfiles: Map<string, SyncUserProfile>): Promise<void>;
+
+    /**
+     * Delete stored profiles for the given users.
+     * @param userIds - The user IDs whose profiles should be deleted.
+     */
+    removeUserProfiles(userIds: string[]): Promise<void>;
+
+    /**
+     * Retrieve a stored user profile for the given user ID, if it exists.
+     * @param userId - The user ID to retrieve the profile for.
+     * @returns The stored profile, or undefined if no profile is stored for this user ID.
+     */
+    getUserProfile(userId: string): Promise<SyncUserProfile | undefined>;
+
     /**
      * Stop the store and perform any appropriate cleanup
      */

package/src/store/indexeddb-backend.ts

@@ -17,6 +17,7 @@ limitations under the License.
 import { type ISavedSync } from "./index.ts";
 import { type IEvent, type IStateEventWithRoomId, type IStoredClientOpts, type ISyncResponse } from "../matrix.ts";
 import { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from "../models/ToDeviceMessage.ts";
+import { type SyncUserProfile } from "../models/user.ts";
 
 export interface IIndexedDBBackend {
     connect(onClose?: () => void): Promise<void>;
@@ -35,6 +36,9 @@ export interface IIndexedDBBackend {
     saveToDeviceBatches(batches: ToDeviceBatchWithTxnId[]): Promise<void>;
     getOldestToDeviceBatch(): Promise<IndexedToDeviceBatch | null>;
     removeToDeviceBatch(id: number): Promise<void>;
+    getUserProfile(userId: string): Promise<SyncUserProfile | undefined>;
+    storeUserProfiles(userProfiles: Map<string, SyncUserProfile>): Promise<void>;
+    removeUserProfiles(userIds: string[]): Promise<void>;
     destroy(): Promise<void>;
 }
 

package/src/store/indexeddb-local-backend.ts

@@ -18,7 +18,7 @@ import { type IMinimalEvent, type ISyncData, type ISyncResponse, SyncAccumulator
 import { deepCopy, promiseTry } from "../utils.ts";
 import { exists as idbExists } from "../indexeddb-helpers.ts";
 import { logger } from "../logger.ts";
-import { type IStateEventWithRoomId, type IStoredClientOpts } from "../matrix.ts";
+import type { SyncUserProfile, IStateEventWithRoomId, IStoredClientOpts } from "../matrix.ts";
 import { type ISavedSync } from "./index.ts";
 import { type IIndexedDBBackend, type UserTuple } from "./indexeddb-backend.ts";
 import { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from "../models/ToDeviceMessage.ts";
@@ -48,6 +48,9 @@ const DB_MIGRATIONS: DbMigration[] = [
     (db): void => {
         db.createObjectStore("to_device_queue", { autoIncrement: true });
     },
+    (db): void => {
+        db.createObjectStore("user_profile", { keyPath: ["userId"] });
+    },
     // Expand as needed.
 ];
 const VERSION = DB_MIGRATIONS.length;
@@ -602,6 +605,34 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
         await txnAsPromise(txn);
     }
 
+    public async getUserProfile(userId: string): Promise<SyncUserProfile | undefined> {
+        return Promise.resolve().then(() => {
+            const txn = this.db!.transaction(["user_profile"], "readonly");
+            const store = txn.objectStore("user_profile");
+            return selectQuery(store, [userId], (cursor) => {
+                return cursor.value?.profile;
+            }).then((results) => results[0]);
+        });
+    }
+
+    public async storeUserProfiles(userProfiles: Map<string, SyncUserProfile>): Promise<void> {
+        const txn = this.db!.transaction(["user_profile"], "readwrite");
+        const store = txn.objectStore("user_profile");
+        for (const [userId, profile] of userProfiles.entries()) {
+            store.put({ profile, userId });
+        }
+        await txnAsPromise(txn);
+    }
+
+    public async removeUserProfiles(userIds: string[]): Promise<void> {
+        const txn = this.db!.transaction(["user_profile"], "readwrite");
+        const store = txn.objectStore("user_profile");
+        for (const userId of userIds) {
+            store.delete([userId]);
+        }
+        await txnAsPromise(txn);
+    }
+
     /*
      * Close the database
      */

package/src/store/indexeddb-remote-backend.ts

@@ -20,6 +20,7 @@ import { type IStoredClientOpts } from "../client.ts";
 import { type IStateEventWithRoomId, type ISyncResponse } from "../matrix.ts";
 import { type IIndexedDBBackend, type UserTuple } from "./indexeddb-backend.ts";
 import { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from "../models/ToDeviceMessage.ts";
+import { type SyncUserProfile } from "../models/user.ts";
 
 export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
     private worker?: Worker;
@@ -145,6 +146,18 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
         return this.doCmd("removeToDeviceBatch", [id]);
     }
 
+    public async getUserProfile(userId: string): Promise<SyncUserProfile | undefined> {
+        return this.doCmd("getUserProfile", [userId]);
+    }
+
+    public async storeUserProfiles(userProfiles: Map<string, SyncUserProfile>): Promise<void> {
+        await this.doCmd("storeUserProfiles", [userProfiles]);
+    }
+
+    public async removeUserProfiles(userIds: string[]): Promise<void> {
+        await this.doCmd("removeUserProfiles", [userIds]);
+    }
+
     private ensureStarted(): Promise<void> {
         if (!this.startPromise) {
             this.worker = this.workerFactory();

package/src/store/indexeddb-store-worker.ts

@@ -120,6 +120,15 @@ export class IndexedDBStoreWorker {
             case "removeToDeviceBatch":
                 prom = this.backend?.removeToDeviceBatch(msg.args[0]);
                 break;
+            case "getUserProfile":
+                prom = this.backend?.getUserProfile(msg.args[0]);
+                break;
+            case "storeUserProfiles":
+                prom = this.backend?.storeUserProfiles(msg.args[0]);
+                break;
+            case "removeUserProfiles":
+                prom = this.backend?.removeUserProfiles(msg.args[0]);
+                break;
         }
 
         if (prom === undefined) {

package/src/store/indexeddb.ts

@@ -28,6 +28,7 @@ import { type EventEmitterEvents, TypedEventEmitter } from "../models/typed-even
 import { type IStateEventWithRoomId } from "../@types/search.ts";
 import { type IndexedToDeviceBatch, type ToDeviceBatchWithTxnId } from "../models/ToDeviceMessage.ts";
 import { type IStoredClientOpts } from "../client.ts";
+import { type SyncUserProfile } from "../models/user.ts";
 
 /**
  * This is an internal module. See {@link IndexedDBStore} for the public class.
@@ -384,6 +385,18 @@ export class IndexedDBStore extends MemoryStore {
     public removeToDeviceBatch(id: number): Promise<void> {
         return this.backend.removeToDeviceBatch(id);
     }
+
+    public async getUserProfile(userId: string): Promise<SyncUserProfile | undefined> {
+        return this.backend.getUserProfile(userId);
+    }
+
+    public async storeUserProfiles(userProfiles: Map<string, SyncUserProfile>): Promise<void> {
+        return this.backend.storeUserProfiles(userProfiles);
+    }
+
+    public async removeUserProfiles(userIds: string[]): Promise<void> {
+        return this.backend.removeUserProfiles(userIds);
+    }
 }
 
 /**

package/src/store/memory.ts

@@ -20,7 +20,7 @@ limitations under the License.
 
 import { type EventType } from "../@types/event.ts";
 import { type Room } from "../models/room.ts";
-import { type User } from "../models/user.ts";
+import { type SyncUserProfile, type User } from "../models/user.ts";
 import { type IEvent, type MatrixEvent } from "../models/event.ts";
 import { type RoomState, RoomStateEvent } from "../models/room-state.ts";
 import { type RoomMember } from "../models/room-member.ts";
@@ -65,6 +65,7 @@ export class MemoryStore implements IStore {
     private pendingToDeviceBatches: IndexedToDeviceBatch[] = [];
     private nextToDeviceBatchId = 0;
     protected createUser?: UserCreator;
+    public readonly userProfiles = new Map<string, SyncUserProfile>();
 
     /**
      * Construct a new in-memory data store for the Matrix Client.
@@ -442,6 +443,18 @@ export class MemoryStore implements IStore {
         return Promise.resolve();
     }
 
+    public async getUserProfile(userId: string): Promise<SyncUserProfile | undefined> {
+        return this.userProfiles.get(userId);
+    }
+
+    public async storeUserProfiles(userProfiles: Map<string, SyncUserProfile>): Promise<void> {
+        userProfiles.forEach((profile, userId) => this.userProfiles.set(userId, profile));
+    }
+
+    public async removeUserProfiles(userIds: string[]): Promise<void> {
+        userIds.forEach((userId) => this.userProfiles.delete(userId));
+    }
+
     public async destroy(): Promise<void> {
         // Nothing to do
     }

package/src/store/stub.ts

@@ -274,6 +274,18 @@ export class StubStore implements IStore {
         return Promise.resolve();
     }
 
+    public async getUserProfile(): Promise<undefined> {
+        return undefined;
+    }
+
+    public async storeUserProfiles(): Promise<void> {
+        return;
+    }
+
+    public async removeUserProfiles(): Promise<void> {
+        return;
+    }
+
     public async destroy(): Promise<void> {
         // Nothing to do
     }

package/src/sync-accumulator.ts

@@ -26,6 +26,7 @@ import { type EventType } from "./@types/event.ts";
 import { UNREAD_THREAD_NOTIFICATIONS } from "./@types/sync.ts";
 import { ReceiptAccumulator } from "./receipt-accumulator.ts";
 import { type OlmEncryptionInfo } from "./crypto-api/index.ts";
+import { type SyncUserProfile } from "./matrix.ts";
 
 interface IOpts {
     /**
@@ -36,6 +37,10 @@ interface IOpts {
      * Default: 50.
      */
     maxTimelineEntries?: number;
+    /**
+     * Whether to use the stable or unstable fields for user profiles.
+     */
+    profileFieldsStable?: boolean;
 }
 
 export interface IMinimalEvent {
@@ -183,6 +188,15 @@ export interface IDeviceLists {
     left?: string[];
 }
 
+/**
+ * The "users" section of the sync update which contains extended profile updates.
+ */
+export interface UsersUpdate {
+    [userId: string]: {
+        profile_updates?: SyncUserProfile | null;
+    };
+}
+
 export interface ISyncResponse {
     "next_batch": string;
     "rooms": IRooms;
@@ -191,7 +205,8 @@ export interface ISyncResponse {
     "to_device"?: IToDevice;
     "device_lists"?: IDeviceLists;
     "device_one_time_keys_count"?: Record<string, number>;
-
+    "users"?: UsersUpdate;
+    "org.matrix.msc4429.users"?: UsersUpdate;
     "device_unused_fallback_key_types"?: string[];
     "org.matrix.msc2732.device_unused_fallback_key_types"?: string[];
 }

package/src/sync.ts

@@ -24,12 +24,12 @@ limitations under the License.
  */
 
 import type { SyncCryptoCallbacks } from "./common-crypto/CryptoBackend.ts";
-import { User } from "./models/user.ts";
+import { type SyncUserProfile, User } from "./models/user.ts";
 import { NotificationCountType, Room, RoomEvent } from "./models/room.ts";
 import { deepCopy, noUnsafeEventProps, unsafeProp } from "./utils.ts";
 import { Filter } from "./filter.ts";
 import { EventTimeline } from "./models/event-timeline.ts";
-import { type Logger } from "./logger.ts";
+import { logger, type Logger } from "./logger.ts";
 import {
     ClientEvent,
     type IStoredClientOpts,
@@ -622,7 +622,11 @@ export class SyncApi {
         return filter;
     };
 
-    private prepareLazyLoadingForSync = async (): Promise<void> => {
+    /**
+     * Sets up the sync filter options for lazy loading if enabled,
+     * (or force-disables lazy loading entirely if we're a guest).
+     */
+    private prepareSyncFilterLazyLoading = (): void => {
         this.syncOpts.logger.debug("Prepare lazy loading for sync...");
         if (this.client.isGuest()) {
             this.opts.lazyLoadMembers = false;
@@ -636,6 +640,22 @@ export class SyncApi {
         }
     };
 
+    /**
+     * Preare sync filter options for the unstable MSC4429 user profile fields if enabled.
+     */
+    private prepareSyncFilterUserProfiles = async (): Promise<void> => {
+        if (this.opts.unstableMSC4429SyncUserProfileFields?.length) {
+            this.syncOpts.logger.debug("Enabling EXPERIMENTAL user profiles on sync filter...");
+            if (!this.opts.filter) {
+                this.opts.filter = this.buildDefaultFilter();
+            }
+            this.opts.filter.setUnstableMSC4429SyncUserProfiles(
+                this.opts.unstableMSC4429SyncUserProfileFields,
+                await this.client.doesServerSupportUnstableFeature("org.matrix.msc4429.stable"),
+            );
+        }
+    };
+
     private storeClientOptions = async (): Promise<void> => {
         try {
             this.syncOpts.logger.debug("Storing client options...");
@@ -723,7 +743,8 @@ export class SyncApi {
         // take a while so if we set it going now, we can wait for it
         // to finish while we process our saved sync data.
         await this.getPushRules();
-        await this.prepareLazyLoadingForSync();
+        this.prepareSyncFilterLazyLoading();
+        await this.prepareSyncFilterUserProfiles();
         await this.storeClientOptions();
 
         const { filterId, filter } = await this.getFilter();
@@ -1138,6 +1159,29 @@ export class SyncApi {
             });
         }
 
+        // handle user profile updates (MSC4429)
+        const userUpdate = data["users"] ?? data["org.matrix.msc4429.users"];
+        if (typeof userUpdate === "object" && userUpdate !== null) {
+            const usersToRemove: string[] = [];
+            const profilesToAmend: Map<string, SyncUserProfile> = new Map();
+            for (const [userId, userData] of Object.entries(userUpdate)) {
+                logger.info(`Storing user profile ${userId}`, userData);
+                if (userData.profile_updates) {
+                    client.emit(ClientEvent.UserProfileUpdate, userId, userData.profile_updates);
+                    const existingProfile = await client.store.getUserProfile(userId);
+                    profilesToAmend.set(userId, { ...existingProfile, ...userData.profile_updates });
+                } else if (userData.profile_updates === null) {
+                    usersToRemove.push(userId);
+                }
+            }
+            if (usersToRemove.length) {
+                await client.store.removeUserProfiles(usersToRemove);
+            }
+            if (profilesToAmend.size) {
+                await client.store.storeUserProfiles(profilesToAmend);
+            }
+        }
+
         // handle to-device events
         if (data.to_device && Array.isArray(data.to_device.events) && data.to_device.events.length > 0) {
             const toDeviceMessages: IToDeviceEvent[] = data.to_device.events.filter(noUnsafeEventProps);

package/src/webrtc/call.ts

@@ -21,7 +21,6 @@ limitations under the License.
  * This is an internal module. See {@link createNewMatrixCall} for the public API.
  */
 
-import { v4 as uuidv4 } from "uuid";
 import { parse as parseSdp, write as writeSdp } from "sdp-transform";
 
 import { logger } from "../logger.ts";
@@ -2490,7 +2489,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                 sender_session_id: this.client.getSessionId(),
                 dest_session_id: this.opponentSessionId,
                 seq: toDeviceSeq,
-                [ToDeviceMessageId]: uuidv4(),
+                [ToDeviceMessageId]: globalThis.crypto.randomUUID(),
             };
 
             this.emit(