matrix-js-sdk 42.4.0 → 43.0.0

package/src/oauth/tokenRefresher.ts

@@ -14,7 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { type AccessTokens, HTTPError, type TokenRefreshFunction, TokenRefreshLogoutError } from "../http-api/index.ts";
+import { HTTPError, TokenRefreshLogoutError } from "../http-api/errors.ts";
+import { type AccessTokens } from "../http-api/interface.ts";
 import { OAuth2HTTPError } from "./error.ts";
 import { type OAuth2 } from "./index.ts";
 
@@ -26,16 +27,15 @@ export class TokenRefresher {
 
     public constructor(
         private readonly auth: OAuth2,
-        private readonly onRefresh: (tokens: AccessTokens) => Promise<void>,
+        private readonly onRefresh: (tokens: AccessTokens) => void | Promise<void>,
     ) {}
 
     /**
      * Attempt token refresh using given refresh token
      * @param refreshToken - refresh token to use in request with token issuer
-     * @returns tokens - Promise that resolves with new access and refresh tokens
      * @throws when token refresh fails
      */
-    public tokenRefreshFunction: TokenRefreshFunction = async (refreshToken: string): Promise<AccessTokens> => {
+    public async refreshTokens(refreshToken: string): Promise<AccessTokens> {
         if (!this.inflightRefreshRequest) {
             this.inflightRefreshRequest = this.getNewTokens(refreshToken);
         }
@@ -52,7 +52,17 @@ export class TokenRefresher {
         } finally {
             this.inflightRefreshRequest = undefined;
         }
-    };
+    }
+
+    /**
+     * Revoke a token with the OP, e.g. as part of logging out.
+     * @param token - the token to revoke
+     * @param type - the type of token, acts as a hint to the OP
+     * @throws when revocation fails
+     */
+    public async revokeToken(token: string, type?: "access_token" | "refresh_token"): Promise<void> {
+        await this.auth.revokeToken(token, type);
+    }
 
     private shouldLogoutOnError(error: HTTPError): boolean {
         // Treat as logout as per https://spec.matrix.org/v1.18/client-server-api/#refresh-token-grant

package/src/receipt-accumulator.ts

@@ -37,50 +37,57 @@ interface AccumulatedReceipt {
  * the most recently received receipt in each thread.
  */
 export class ReceiptAccumulator {
-    /** user_id -\> most-recently-received unthreaded receipt */
-    private unthreadedReadReceipts: Map<string, AccumulatedReceipt> = new Map();
-
-    /** thread_id -\> user_id -\> most-recently-received receipt for this thread */
-    private threadedReadReceipts: MapWithDefault<string, Map<string, AccumulatedReceipt>> = new MapWithDefault(
+    /** user_id -\> receipt_type -\> most-recently-received unthreaded receipt */
+    private unthreadedReadReceipts: MapWithDefault<string, Map<ReceiptType, AccumulatedReceipt>> = new MapWithDefault(
         () => new Map(),
     );
 
+    /** thread_id -\> user_id -\> receipt_type -\> most-recently-received receipt for this thread */
+    private threadedReadReceipts: MapWithDefault<string, MapWithDefault<string, Map<ReceiptType, AccumulatedReceipt>>> =
+        new MapWithDefault(() => new MapWithDefault(() => new Map()));
+
     /**
      * Provide an unthreaded receipt for this user. Overwrites any other
-     * unthreaded receipt we have for this user.
+     * unthreaded receipt of this type we have for this user.
      */
     private setUnthreaded(userId: string, receipt: AccumulatedReceipt): void {
-        this.unthreadedReadReceipts.set(userId, receipt);
+        this.unthreadedReadReceipts.getOrCreate(userId).set(receipt.type, receipt);
     }
 
     /**
      * Provide a receipt for this user in this thread. Overwrites any other
-     * receipt we have for this user in this thread.
+     * receipt of this type we have for this user in this thread.
      */
     private setThreaded(threadId: string, userId: string, receipt: AccumulatedReceipt): void {
-        this.threadedReadReceipts.getOrCreate(threadId).set(userId, receipt);
+        this.threadedReadReceipts.getOrCreate(threadId).getOrCreate(userId).set(receipt.type, receipt);
     }
 
     /**
-     * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the
-     *          most recently-received unthreaded receipts for each user.
-     * @yields pairs of [userId, AccumulatedReceipt]
+     * @yields pairs of [userId, AccumulatedReceipt] for every receipt type.
      */
-    private allUnthreaded(): IterableIterator<[string, AccumulatedReceipt]> {
-        return this.unthreadedReadReceipts.entries();
+    private *allForUsers(
+        receiptsByUser: ReadonlyMap<string, ReadonlyMap<ReceiptType, AccumulatedReceipt>>,
+    ): IterableIterator<[string, AccumulatedReceipt]> {
+        for (const [userId, receiptsForUser] of receiptsByUser) {
+            for (const receipt of receiptsForUser.values()) {
+                yield [userId, receipt];
+            }
+        }
     }
 
     /**
-     * @returns an iterator of pairs of [userId, AccumulatedReceipt] - all the
-     *          most recently-received threaded receipts for each user, in all
-     *          threads.
-     * @yields pairs of [userId, AccumulatedReceipt]
+     * @yields all unthreaded receipts of each type for each user.
+     */
+    private *allUnthreaded(): IterableIterator<[string, AccumulatedReceipt]> {
+        yield* this.allForUsers(this.unthreadedReadReceipts);
+    }
+
+    /**
+     * @yields all threaded receipts of each type for each user, in all threads.
      */
     private *allThreaded(): IterableIterator<[string, AccumulatedReceipt]> {
         for (const receiptsForThread of this.threadedReadReceipts.values()) {
-            for (const e of receiptsForThread.entries()) {
-                yield e;
-            }
+            yield* this.allForUsers(receiptsForThread);
         }
     }
 
@@ -101,11 +108,8 @@ export class ReceiptAccumulator {
             // but they are keyed in the event as:
             //   content:{ $event_id: { $receipt_type: { $user_id: {json} }}}
             // so store them in the former so we can accumulate receipt deltas
-            // quickly and efficiently (we expect a lot of them). Fold the
-            // receipt type into the key name since we only have 1 at the
-            // moment (m.read) and nested JSON objects are slower and more
-            // of a hassle to work with. We'll inflate this back out when
-            // getJSON() is called.
+            // quickly and efficiently (we expect a lot of them). We'll inflate
+            // this back out when getJSON() is called.
             Object.keys(e.content).forEach((eventId) => {
                 Object.entries<ReceiptContent>(e.content[eventId]).forEach(([key, value]) => {
                     if (!isSupportedReceiptType(key)) return;

package/src/room-summary-api.ts

@@ -0,0 +1,114 @@
+/*
+Copyright 2026 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * The room summary endpoint, which describes a room the user may not be in.
+ * https://spec.matrix.org/latest/client-server-api/#room-summaries
+ *
+ * Not to be confused with {@link RoomSummary} in `./models/room-summary.ts`, which holds the
+ * heroes and member counts that `/sync` sends for rooms we are in.
+ */
+
+import { type IPublicRoomsChunkRoom, type IServerVersions } from "./client.ts";
+import { ClientPrefix, type IHttpOpts, type MatrixHttpApi, Method } from "./http-api/index.ts";
+import { type JoinRule } from "./@types/partials.ts";
+import { type Membership } from "./@types/membership.ts";
+import * as utils from "./utils.ts";
+
+/**
+ * The summary of a room, as returned by the room summary endpoint.
+ * https://spec.matrix.org/latest/client-server-api/#get_matrixclientv1room_summaryroomidoralias
+ *
+ * Also covers the initial version of MSC3266 implemented in older versions of Synapse, which
+ * prefixed some of the fields. See {@link MatrixClient.getRoomSummary}.
+ */
+export interface RoomSummary extends Omit<IPublicRoomsChunkRoom, "canonical_alias" | "aliases" | "join_rule"> {
+    /**
+     * The current membership of this user in the room.
+     */
+    "membership"?: Membership;
+    /**
+     * The join rule of the room. Unlike the join rule of a public rooms chunk, this may be any
+     * join rule, since the room does not have to be published to the room directory.
+     */
+    "join_rule"?: JoinRule;
+    /**
+     * The canonical alias of the room, if any.
+     */
+    "canonical_alias"?: string;
+    /**
+     * Version of the room.
+     */
+    "room_version"?: string;
+    /**
+     * The encryption algorithm used for this room, if the room is encrypted.
+     */
+    "encryption"?: string;
+    /**
+     * For restricted rooms, the room IDs which are specified by the join rule.
+     */
+    "allowed_room_ids"?: string[];
+    /**
+     * Version of the room.
+     * @deprecated Only returned by the unstable endpoint; use {@link RoomSummary.room_version}.
+     */
+    "im.nheko.summary.room_version"?: string;
+    /**
+     * The encryption algorithm used for this room, if the room is encrypted.
+     * @deprecated Only returned by the unstable endpoint; use {@link RoomSummary.encryption}.
+     */
+    "im.nheko.summary.encryption"?: string;
+}
+
+/** The endpoint stabilised in Matrix 1.15. */
+const STABLE_ENDPOINT = { path: "/room_summary/$roomid", prefix: ClientPrefix.V1 };
+
+/** The endpoint used by the initial version of MSC3266, as implemented in older versions of Synapse. */
+const UNSTABLE_ENDPOINT = { path: "/summary/$roomid", prefix: "/_matrix/client/unstable/im.nheko.summary" };
+
+/** The spec version which stabilised MSC3266 as `/_matrix/client/v1/room_summary/{roomIdOrAlias}`. */
+const STABLE_VERSION = "v1.15";
+
+/** The unstable feature flag advertised for MSC3266. */
+const UNSTABLE_FEATURE = "org.matrix.msc3266";
+
+/** Whether the server advertises the stable room summary endpoint in its `/versions` response. */
+function supportsStableEndpoint(versions: IServerVersions): boolean {
+    return versions.versions?.includes(STABLE_VERSION) || !!versions.unstable_features?.[UNSTABLE_FEATURE];
+}
+
+/**
+ * Fetch the summary of a room.
+ *
+ * Uses the path from the initial version of MSC3266, as implemented in older versions of Synapse,
+ * unless the server advertises support for the spec version which stabilised it.
+ *
+ * @param http - The HTTP API to make the request with.
+ * @param versions - The server's `/versions` response, used to pick the endpoint.
+ * @param roomIdOrAlias - The ID or alias of the room to get the summary of.
+ * @param via - The servers to attempt to request the summary from, when the local server cannot
+ *              generate it (for instance, because it has no local user in the room).
+ */
+export function fetchRoomSummary(
+    http: MatrixHttpApi<IHttpOpts & { onlyData: true }>,
+    versions: IServerVersions,
+    roomIdOrAlias: string,
+    via?: string[],
+): Promise<RoomSummary> {
+    const endpoint = supportsStableEndpoint(versions) ? STABLE_ENDPOINT : UNSTABLE_ENDPOINT;
+    const path = utils.encodeUri(endpoint.path, { $roomid: roomIdOrAlias });
+    return http.authedRequest<RoomSummary>(Method.Get, path, { via }, undefined, { prefix: endpoint.prefix });
+}

package/src/rust-crypto/backup.ts

@@ -31,7 +31,7 @@ import {
 import { type Logger } from "../logger.ts";
 import { ClientPrefix, type IHttpOpts, MatrixError, type MatrixHttpApi, Method } from "../http-api/index.ts";
 import { TypedEventEmitter } from "../models/typed-event-emitter.ts";
-import { encodeUri, logDuration } from "../utils.ts";
+import { encodeUri } from "../utils.ts";
 import { type OutgoingRequestProcessor } from "./OutgoingRequestProcessor.ts";
 import { sleep } from "../utils.ts";
 import { type BackupDecryptor } from "../common-crypto/CryptoBackend.ts";
@@ -61,6 +61,14 @@ interface KeyBackupCreationInfo {
  * @internal
  */
 export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents, RustBackupCryptoEventMap> {
+    /**
+     * When the backup upload loop starts, we delay the first request by a random amount to avoid backup
+     * requests from different clients hitting the server all at the same time when a new key is sent.
+     *
+     * This defines the maximum delay. It can be reduced in tests to make the test run faster.
+     */
+    public static readonly maxBackupLoopStartDelayMillis: number = 10000;
+
     /** Have we checked if there is a backup on the server which we can use */
     private checkedForBackup = false;
 
@@ -418,19 +426,21 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
         this.emit(CryptoEvent.KeyBackupStatus, false);
     }
 
-    private async backupKeysLoop(maxDelay = 10000): Promise<void> {
+    private async backupKeysLoop(): Promise<void> {
+        const logger = this.logger.getChild("[backupKeysLoop]");
+
         if (this.backupKeysLoopRunning) {
-            this.logger.debug(`Backup loop already running`);
+            logger.debug(`Backup loop already running`);
             return;
         }
         this.backupKeysLoopRunning = true;
 
-        this.logger.debug(`Backup: Starting keys upload loop for backup version:${this.activeBackupVersion}.`);
-
-        // wait between 0 and `maxDelay` seconds, to avoid backup
-        // requests from different clients hitting the server all at
-        // the same time when a new key is sent
-        const delay = Math.random() * maxDelay;
+        // Wait between 0 and `maxBackupLoopStartDelayMillis` milliseconds, to avoid backup requests from different
+        // clients hitting the server all at the same time when a new key is sent.
+        const delay = Math.random() * RustBackupManager.maxBackupLoopStartDelayMillis;
+        logger.debug(
+            `Starting keys upload loop for backup version ${this.activeBackupVersion}, but delaying startup by ${delay}ms`,
+        );
         await sleep(delay);
 
         try {
@@ -444,25 +454,28 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
 
             while (!this.stopped) {
                 // Get a batch of room keys to upload
-                let request: RustSdkCryptoJs.KeysBackupRequest | undefined = undefined;
+                let request;
                 try {
-                    request = await logDuration(
-                        this.logger,
-                        "BackupRoomKeys: Get keys to backup from rust crypto-sdk",
-                        async () => {
-                            return await this.olmMachine.backupRoomKeys();
-                        },
-                    );
+                    request = await this.olmMachine.backupRoomKeys();
+                    if (request) {
+                        logger.debug("Got keys to back up from crypto-sdk");
+                    } else {
+                        logger.debug(`No more keys to back up: ending loop for version ${this.activeBackupVersion}.`);
+                        this.emit(CryptoEvent.KeyBackupSessionsRemaining, 0);
+                        return;
+                    }
                 } catch (err) {
-                    this.logger.error("Backup: Failed to get keys to backup from rust crypto-sdk", err);
+                    logger.error("Failed to get keys to backup from rust crypto-sdk: ending backup loop", err);
+                    return;
                 }
 
-                if (!request || this.stopped || !this.activeBackupVersion) {
-                    this.logger.debug(`Backup: Ending loop for version ${this.activeBackupVersion}.`);
-                    if (!request) {
-                        // nothing more to upload
-                        this.emit(CryptoEvent.KeyBackupSessionsRemaining, 0);
-                    }
+                if (this.stopped) {
+                    logger.debug(`Client stopping: ending loop for version ${this.activeBackupVersion}.`);
+                    return;
+                }
+
+                if (!this.activeBackupVersion) {
+                    logger.debug(`Backup no longer active: ending loop.`);
                     return;
                 }
 
@@ -485,7 +498,7 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
                             const keyCount = await this.olmMachine.roomKeyCounts();
                             remainingToUploadCount = keyCount.total - keyCount.backedUp;
                         } catch (err) {
-                            this.logger.error("Backup: Failed to get key counts from rust crypto-sdk", err);
+                            logger.error("Failed to get key counts from rust crypto-sdk", err);
                         }
                     }
 
@@ -501,15 +514,15 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
                     }
                 } catch (err) {
                     numFailures++;
-                    this.logger.error("Backup: Error processing backup request for rust crypto-sdk", err);
+                    logger.error("Error processing backup request for rust crypto-sdk", err);
                     if (err instanceof MatrixError) {
                         const errCode = err.data.errcode;
                         if (errCode == "M_NOT_FOUND" || errCode == "M_WRONG_ROOM_KEYS_VERSION") {
-                            this.logger.debug(`Backup: Failed to upload keys to current vesion: ${errCode}.`);
+                            logger.debug(`Failed to upload keys to current version: ${errCode}.`);
                             try {
                                 await this.disableKeyBackup();
                             } catch (error) {
-                                this.logger.error("Backup: An error occurred while disabling key backup:", error);
+                                logger.error("An error occurred while disabling key backup:", error);
                             }
                             this.emit(CryptoEvent.KeyBackupFailed, err.data.errcode!);
                             // There was an active backup and we are out of sync with the server
@@ -522,21 +535,21 @@ export class RustBackupManager extends TypedEventEmitter<RustBackupCryptoEvents,
                             try {
                                 const waitTime = err.getRetryAfterMs();
                                 if (waitTime && waitTime > 0) {
+                                    logger.debug(`Sleeping ${waitTime}ms after ratelimit`);
                                     await sleep(waitTime);
                                     continue;
                                 }
                             } catch (error) {
-                                this.logger.warn(
-                                    "Backup: An error occurred while retrieving a rate-limit retry delay",
-                                    error,
-                                );
+                                logger.warn("An error occurred while retrieving a rate-limit retry delay", error);
                             } // else go to the normal backoff
                         }
                     }
 
                     // Some other errors (mx, network, or CORS or invalid urls?) anyhow backoff
                     // exponential backoff if we have failures
-                    await sleep(1000 * Math.pow(2, Math.min(numFailures - 1, 4)));
+                    const waitTime = 1000 * Math.pow(2, Math.min(numFailures - 1, 4));
+                    logger.debug(`Sleeping ${waitTime}ms after failure #${numFailures}`);
+                    await sleep(waitTime);
                 }
                 isFirstIteration = false;
             }

package/src/sync.ts

@@ -1486,7 +1486,15 @@ export class SyncApi {
                 // this fires a couple of times for some events. (eg state events are in the timeline and the state)
                 // should this get a sync section as an additional event emission param (e, syncSection))?
                 stateEvents.forEach(emitEvent);
-                timelineEvents.forEach(emitEvent);
+                stateAfterEvents.forEach(emitEvent);
+                // have to filter out all state events from the timeline when MSC4222 is enabled, in this case:
+                // all state events are emitted by "state_after"
+                // all state events in the timeline are either duplicates or are outdated and should be ignored
+                const filteredTimelineEvents =
+                    "org.matrix.msc4222.state_after" in joinObj
+                        ? timelineEvents.filter((timelineEvent) => !timelineEvent.isState())
+                        : timelineEvents;
+                filteredTimelineEvents.forEach(emitEvent);
                 ephemeralEvents.forEach(emitEvent);
                 accountDataEvents.forEach(emitEvent);
                 stickyEvents