@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/lib/rust-crypto/PerSessionKeyBackupDownloader.js

@@ -1,4 +1,3 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2023 - 2024 The Matrix.org Foundation C.I.C.
@@ -20,7 +19,7 @@ import { CryptoEvent } from "../crypto-api/index.js";
 import { ClientPrefix, MatrixError, Method } from "../http-api/index.js";
 import { encodeUri, sleep } from "../utils.js";
 // The minimum time to wait between two retries in case of errors. To avoid hammering the server.
-var KEY_BACKUP_BACKOFF = 5000; // ms
+const KEY_BACKUP_BACKOFF = 5000; // ms
 
 /**
  * Enumerates the different kind of errors that can occurs when downloading and importing a key from backup.
@@ -36,14 +35,14 @@ var KeyDownloadErrorCode = /*#__PURE__*/function (KeyDownloadErrorCode) {
 }(KeyDownloadErrorCode || {});
 class KeyDownloadError extends Error {
   constructor(code) {
-    super("Failed to get key from backup: ".concat(code));
+    super(`Failed to get key from backup: ${code}`);
     this.code = code;
     this.name = "KeyDownloadError";
   }
 }
 class KeyDownloadRateLimitError extends Error {
   constructor(retryMillis) {
-    super("Failed to get key from backup: rate limited");
+    super(`Failed to get key from backup: rate limited`);
     this.retryMillis = retryMillis;
     this.name = "KeyDownloadRateLimitError";
   }
@@ -87,6 +86,8 @@ export class PerSessionKeyBackupDownloader {
     /** We remember when a session was requested and not found in backup to avoid query again too soon.
      * Map of session_id to timestamp */
     _defineProperty(this, "sessionLastCheckAttemptedTime", new Map());
+    /** The logger to use */
+    _defineProperty(this, "logger", void 0);
     /** Whether the download loop is running. */
     _defineProperty(this, "downloadLoopRunning", false);
     /** The list of requests that are queued. */
@@ -122,7 +123,7 @@ export class PerSessionKeyBackupDownloader {
   /**
    * Check if key download is successfully configured and active.
    *
-   * @return `true` if key download is correctly configured and active; otherwise `false`.
+   * @returns `true` if key download is correctly configured and active; otherwise `false`.
    */
   isKeyBackupDownloadConfigured() {
     return this.configuration !== null;
@@ -133,11 +134,8 @@ export class PerSessionKeyBackupDownloader {
    *
    * This is just a convenience method to expose {@link RustBackupManager.getServerBackupInfo}.
    */
-  getServerBackupInfo() {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      return yield _this.backupManager.getServerBackupInfo();
-    })();
+  async getServerBackupInfo() {
+    return await this.backupManager.getServerBackupInfo();
   }
 
   /**
@@ -155,12 +153,12 @@ export class PerSessionKeyBackupDownloader {
     // so we need to be resistant and not query several time the same session.
     if (this.isAlreadyInQueue(roomId, megolmSessionId)) {
       // There is already a request queued for this session, no need to queue another one.
-      this.logger.trace("Not checking key backup for session ".concat(megolmSessionId, " as it is already queued"));
+      this.logger.trace(`Not checking key backup for session ${megolmSessionId} as it is already queued`);
       return;
     }
     if (this.wasRequestedRecently(megolmSessionId)) {
       // We already tried to download this session recently and it was not in backup, no need to try again.
-      this.logger.trace("Not checking key backup for session ".concat(megolmSessionId, " as it was already requested recently"));
+      this.logger.trace(`Not checking key backup for session ${megolmSessionId} as it was already requested recently`);
       return;
     }
 
@@ -196,7 +194,7 @@ export class PerSessionKeyBackupDownloader {
    * @param megolmSessionId - The megolm session ID that is missing.
    */
   markAsNotFoundInBackup(megolmSessionId) {
-    var now = Date.now();
+    const now = Date.now();
     this.sessionLastCheckAttemptedTime.set(megolmSessionId, now);
     // if too big make some cleaning to keep under control
     if (this.sessionLastCheckAttemptedTime.size > 100) {
@@ -208,19 +206,16 @@ export class PerSessionKeyBackupDownloader {
 
   /** Returns true if the session was requested recently. */
   wasRequestedRecently(megolmSessionId) {
-    var lastCheck = this.sessionLastCheckAttemptedTime.get(megolmSessionId);
+    const lastCheck = this.sessionLastCheckAttemptedTime.get(megolmSessionId);
     if (!lastCheck) return false;
     return Math.max(Date.now() - lastCheck, 0) < KEY_BACKUP_BACKOFF;
   }
-  getBackupDecryptionKey() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      try {
-        return yield _this2.olmMachine.getBackupKeys();
-      } catch (_unused) {
-        return null;
-      }
-    })();
+  async getBackupDecryptionKey() {
+    try {
+      return await this.olmMachine.getBackupKeys();
+    } catch {
+      return null;
+    }
   }
 
   /**
@@ -230,82 +225,76 @@ export class PerSessionKeyBackupDownloader {
    * @param roomId - The room ID of the room where the error occurred.
    * @param sessionId - The megolm session ID that is missing.
    */
-  requestRoomKeyFromBackup(version, roomId, sessionId) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      var path = encodeUri("/room_keys/keys/$roomId/$sessionId", {
-        $roomId: roomId,
-        $sessionId: sessionId
-      });
-      return yield _this3.http.authedRequest(Method.Get, path, {
-        version
-      }, undefined, {
-        prefix: ClientPrefix.V3
-      });
-    })();
+  async requestRoomKeyFromBackup(version, roomId, sessionId) {
+    const path = encodeUri("/room_keys/keys/$roomId/$sessionId", {
+      $roomId: roomId,
+      $sessionId: sessionId
+    });
+    return await this.http.authedRequest(Method.Get, path, {
+      version
+    }, undefined, {
+      prefix: ClientPrefix.V3
+    });
   }
-  downloadKeysLoop() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (_this4.downloadLoopRunning) return;
+  async downloadKeysLoop() {
+    if (this.downloadLoopRunning) return;
 
-      // If we have a configuration problem, we don't want to try to download.
-      // If any configuration change is detected, we will retry and restart the loop.
-      if (_this4.hasConfigurationProblem) return;
-      _this4.downloadLoopRunning = true;
-      try {
-        while (_this4.queuedRequests.length > 0) {
-          // we just peek the first one without removing it, so if a new request for same key comes in while we're
-          // processing this one, it won't queue another request.
-          var request = _this4.queuedRequests[0];
+    // If we have a configuration problem, we don't want to try to download.
+    // If any configuration change is detected, we will retry and restart the loop.
+    if (this.hasConfigurationProblem) return;
+    this.downloadLoopRunning = true;
+    try {
+      while (this.queuedRequests.length > 0) {
+        // we just peek the first one without removing it, so if a new request for same key comes in while we're
+        // processing this one, it won't queue another request.
+        const request = this.queuedRequests[0];
+        try {
+          // The backup could have changed between the time we queued the request and now, so we need to check
+          const configuration = await this.getOrCreateBackupConfiguration();
+          if (!configuration) {
+            // Backup is not configured correctly, so stop the loop.
+            this.downloadLoopRunning = false;
+            return;
+          }
+          const result = await this.queryKeyBackup(request.roomId, request.megolmSessionId, configuration);
+          if (this.stopped) {
+            return;
+          }
+          // We got the encrypted key from backup, let's try to decrypt and import it.
           try {
-            // The backup could have changed between the time we queued the request and now, so we need to check
-            var configuration = yield _this4.getOrCreateBackupConfiguration();
-            if (!configuration) {
-              // Backup is not configured correctly, so stop the loop.
-              _this4.downloadLoopRunning = false;
-              return;
-            }
-            var result = yield _this4.queryKeyBackup(request.roomId, request.megolmSessionId, configuration);
-            if (_this4.stopped) {
-              return;
-            }
-            // We got the encrypted key from backup, let's try to decrypt and import it.
-            try {
-              yield _this4.decryptAndImport(request, result, configuration);
-            } catch (e) {
-              _this4.logger.error("Error while decrypting and importing key backup for session ".concat(request.megolmSessionId), e);
-            }
-            // now remove the request from the queue as we've processed it.
-            _this4.queuedRequests.shift();
-          } catch (err) {
-            if (err instanceof KeyDownloadError) {
-              switch (err.code) {
-                case KeyDownloadErrorCode.MISSING_DECRYPTION_KEY:
-                  _this4.markAsNotFoundInBackup(request.megolmSessionId);
-                  // continue for next one
-                  _this4.queuedRequests.shift();
-                  break;
-                case KeyDownloadErrorCode.NETWORK_ERROR:
-                  // We don't want to hammer if there is a problem, so wait a bit.
-                  yield sleep(KEY_BACKUP_BACKOFF);
-                  break;
-                case KeyDownloadErrorCode.STOPPED:
-                  // If the downloader was stopped, we don't want to retry.
-                  _this4.downloadLoopRunning = false;
-                  return;
-              }
-            } else if (err instanceof KeyDownloadRateLimitError) {
-              // we want to retry after the backoff time
-              yield sleep(err.retryMillis);
+            await this.decryptAndImport(request, result, configuration);
+          } catch (e) {
+            this.logger.error(`Error while decrypting and importing key backup for session ${request.megolmSessionId}`, e);
+          }
+          // now remove the request from the queue as we've processed it.
+          this.queuedRequests.shift();
+        } catch (err) {
+          if (err instanceof KeyDownloadError) {
+            switch (err.code) {
+              case KeyDownloadErrorCode.MISSING_DECRYPTION_KEY:
+                this.markAsNotFoundInBackup(request.megolmSessionId);
+                // continue for next one
+                this.queuedRequests.shift();
+                break;
+              case KeyDownloadErrorCode.NETWORK_ERROR:
+                // We don't want to hammer if there is a problem, so wait a bit.
+                await sleep(KEY_BACKUP_BACKOFF);
+                break;
+              case KeyDownloadErrorCode.STOPPED:
+                // If the downloader was stopped, we don't want to retry.
+                this.downloadLoopRunning = false;
+                return;
             }
+          } else if (err instanceof KeyDownloadRateLimitError) {
+            // we want to retry after the backoff time
+            await sleep(err.retryMillis);
           }
         }
-      } finally {
-        // all pending request have been processed, we can stop the loop.
-        _this4.downloadLoopRunning = false;
       }
-    })();
+    } finally {
+      // all pending request have been processed, we can stop the loop.
+      this.downloadLoopRunning = false;
+    }
   }
 
   /**
@@ -315,60 +304,53 @@ export class PerSessionKeyBackupDownloader {
    * @param targetSessionId - ID of the session for which to check backup.
    * @param configuration - The backup configuration to use.
    */
-  queryKeyBackup(targetRoomId, targetSessionId, configuration) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      _this5.logger.debug("Checking key backup for session ".concat(targetSessionId));
-      if (_this5.stopped) throw new KeyDownloadError(KeyDownloadErrorCode.STOPPED);
-      try {
-        var res = yield _this5.requestRoomKeyFromBackup(configuration.backupVersion, targetRoomId, targetSessionId);
-        _this5.logger.debug("Got key from backup for sessionId:".concat(targetSessionId));
-        return res;
-      } catch (e) {
-        if (_this5.stopped) throw new KeyDownloadError(KeyDownloadErrorCode.STOPPED);
-        _this5.logger.info("No luck requesting key backup for session ".concat(targetSessionId, ": ").concat(e));
-        if (e instanceof MatrixError) {
-          var errCode = e.data.errcode;
-          if (errCode == "M_NOT_FOUND") {
-            // Unfortunately the spec doesn't give us a way to differentiate between a missing key and a wrong version.
-            // Synapse will return:
-            //     - "error": "Unknown backup version" if the version is wrong.
-            //     - "error": "No room_keys found" if the key is missing.
-            // It's useful to know if the key is missing or if the version is wrong.
-            // As it's not spec'ed, we fall back on considering the key is not in backup.
-            // Notice that this request will be lost if instead the backup got out of sync (updated from other session).
-            throw new KeyDownloadError(KeyDownloadErrorCode.MISSING_DECRYPTION_KEY);
+  async queryKeyBackup(targetRoomId, targetSessionId, configuration) {
+    this.logger.debug(`Checking key backup for session ${targetSessionId}`);
+    if (this.stopped) throw new KeyDownloadError(KeyDownloadErrorCode.STOPPED);
+    try {
+      const res = await this.requestRoomKeyFromBackup(configuration.backupVersion, targetRoomId, targetSessionId);
+      this.logger.debug(`Got key from backup for sessionId:${targetSessionId}`);
+      return res;
+    } catch (e) {
+      if (this.stopped) throw new KeyDownloadError(KeyDownloadErrorCode.STOPPED);
+      this.logger.info(`No luck requesting key backup for session ${targetSessionId}: ${e}`);
+      if (e instanceof MatrixError) {
+        const errCode = e.data.errcode;
+        if (errCode == "M_NOT_FOUND") {
+          // Unfortunately the spec doesn't give us a way to differentiate between a missing key and a wrong version.
+          // Synapse will return:
+          //     - "error": "Unknown backup version" if the version is wrong.
+          //     - "error": "No room_keys found" if the key is missing.
+          // It's useful to know if the key is missing or if the version is wrong.
+          // As it's not spec'ed, we fall back on considering the key is not in backup.
+          // Notice that this request will be lost if instead the backup got out of sync (updated from other session).
+          throw new KeyDownloadError(KeyDownloadErrorCode.MISSING_DECRYPTION_KEY);
+        }
+        if (e.isRateLimitError()) {
+          let waitTime;
+          try {
+            waitTime = e.getRetryAfterMs() ?? undefined;
+          } catch (error) {
+            this.logger.warn("Error while retrieving a rate-limit retry delay", error);
           }
-          if (e.isRateLimitError()) {
-            var waitTime;
-            try {
-              var _e$getRetryAfterMs;
-              waitTime = (_e$getRetryAfterMs = e.getRetryAfterMs()) !== null && _e$getRetryAfterMs !== void 0 ? _e$getRetryAfterMs : undefined;
-            } catch (error) {
-              _this5.logger.warn("Error while retrieving a rate-limit retry delay", error);
-            }
-            if (waitTime && waitTime > 0) {
-              _this5.logger.info("Rate limited by server, waiting ".concat(waitTime, "ms"));
-            }
-            throw new KeyDownloadRateLimitError(waitTime !== null && waitTime !== void 0 ? waitTime : KEY_BACKUP_BACKOFF);
+          if (waitTime && waitTime > 0) {
+            this.logger.info(`Rate limited by server, waiting ${waitTime}ms`);
           }
+          throw new KeyDownloadRateLimitError(waitTime ?? KEY_BACKUP_BACKOFF);
         }
-        throw new KeyDownloadError(KeyDownloadErrorCode.NETWORK_ERROR);
       }
-    })();
+      throw new KeyDownloadError(KeyDownloadErrorCode.NETWORK_ERROR);
+    }
   }
-  decryptAndImport(sessionInfo, data, configuration) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      var sessionsToImport = {
-        [sessionInfo.megolmSessionId]: data
-      };
-      var keys = yield configuration.decryptor.decryptSessions(sessionsToImport);
-      for (var k of keys) {
-        k.room_id = sessionInfo.roomId;
-      }
-      yield _this6.backupManager.importBackedUpRoomKeys(keys, configuration.backupVersion);
-    })();
+  async decryptAndImport(sessionInfo, data, configuration) {
+    const sessionsToImport = {
+      [sessionInfo.megolmSessionId]: data
+    };
+    const keys = await configuration.decryptor.decryptSessions(sessionsToImport);
+    for (const k of keys) {
+      k.room_id = sessionInfo.roomId;
+    }
+    await this.backupManager.importBackedUpRoomKeys(keys, configuration.backupVersion);
   }
 
   /**
@@ -379,89 +361,81 @@ export class PerSessionKeyBackupDownloader {
    *
    * @returns The backup configuration to use or null if there is a configuration problem.
    */
-  getOrCreateBackupConfiguration() {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      if (_this7.configuration) {
-        return _this7.configuration;
-      }
+  async getOrCreateBackupConfiguration() {
+    if (this.configuration) {
+      return this.configuration;
+    }
 
-      // We already tried to check the configuration and it failed.
-      // We don't want to try again immediately, we will retry if a configuration change is detected.
-      if (_this7.hasConfigurationProblem) {
-        return null;
-      }
+    // We already tried to check the configuration and it failed.
+    // We don't want to try again immediately, we will retry if a configuration change is detected.
+    if (this.hasConfigurationProblem) {
+      return null;
+    }
 
-      // This method can be called rapidly by several emitted CryptoEvent, so we need to make sure that we don't
-      // query the server several times.
-      if (_this7.currentBackupVersionCheck != null) {
-        _this7.logger.debug("Already checking server version, use current promise");
-        return yield _this7.currentBackupVersionCheck;
-      }
-      _this7.currentBackupVersionCheck = _this7.internalCheckFromServer();
-      try {
-        return yield _this7.currentBackupVersionCheck;
-      } finally {
-        _this7.currentBackupVersionCheck = null;
-      }
-    })();
+    // This method can be called rapidly by several emitted CryptoEvent, so we need to make sure that we don't
+    // query the server several times.
+    if (this.currentBackupVersionCheck != null) {
+      this.logger.debug(`Already checking server version, use current promise`);
+      return await this.currentBackupVersionCheck;
+    }
+    this.currentBackupVersionCheck = this.internalCheckFromServer();
+    try {
+      return await this.currentBackupVersionCheck;
+    } finally {
+      this.currentBackupVersionCheck = null;
+    }
   }
-  internalCheckFromServer() {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var _currentServerVersion, _currentServerVersion2, _currentServerVersion4;
-      var currentServerVersion = null;
-      try {
-        currentServerVersion = yield _this8.backupManager.getServerBackupInfo();
-      } catch (e) {
-        _this8.logger.debug("Backup: error while checking server version: ".concat(e));
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      _this8.logger.debug("Got current backup version from server: ".concat((_currentServerVersion = currentServerVersion) === null || _currentServerVersion === void 0 ? void 0 : _currentServerVersion.version));
-      if (((_currentServerVersion2 = currentServerVersion) === null || _currentServerVersion2 === void 0 ? void 0 : _currentServerVersion2.algorithm) != "m.megolm_backup.v1.curve25519-aes-sha2") {
-        var _currentServerVersion3;
-        _this8.logger.info("Unsupported algorithm ".concat((_currentServerVersion3 = currentServerVersion) === null || _currentServerVersion3 === void 0 ? void 0 : _currentServerVersion3.algorithm));
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      if (!((_currentServerVersion4 = currentServerVersion) !== null && _currentServerVersion4 !== void 0 && _currentServerVersion4.version)) {
-        _this8.logger.info("No current key backup");
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      var activeVersion = yield _this8.backupManager.getActiveBackupVersion();
-      if (activeVersion == null || currentServerVersion.version != activeVersion) {
-        // Either the current backup version on server side is not trusted, or it is out of sync with the active version on the client side.
-        _this8.logger.info("The current backup version on the server (".concat(currentServerVersion.version, ") is not trusted. Version we are currently backing up to: ").concat(activeVersion));
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      var backupKeys = yield _this8.getBackupDecryptionKey();
-      if (!(backupKeys !== null && backupKeys !== void 0 && backupKeys.decryptionKey)) {
-        _this8.logger.debug("Not checking key backup for session (no decryption key)");
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      if (activeVersion != backupKeys.backupVersion) {
-        _this8.logger.debug("Version for which we have a decryption key (".concat(backupKeys.backupVersion, ") doesn't match the version we are backing up to (").concat(activeVersion, ")"));
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      var authData = currentServerVersion.auth_data;
-      if (authData.public_key != backupKeys.decryptionKey.megolmV1PublicKey.publicKeyBase64) {
-        _this8.logger.debug("Key backup on server does not match our decryption key");
-        _this8.hasConfigurationProblem = true;
-        return null;
-      }
-      var backupDecryptor = _this8.backupManager.createBackupDecryptor(backupKeys.decryptionKey);
-      _this8.hasConfigurationProblem = false;
-      _this8.configuration = {
-        decryptor: backupDecryptor,
-        backupVersion: activeVersion
-      };
-      return _this8.configuration;
-    })();
+  async internalCheckFromServer() {
+    let currentServerVersion = null;
+    try {
+      currentServerVersion = await this.backupManager.getServerBackupInfo();
+    } catch (e) {
+      this.logger.debug(`Backup: error while checking server version: ${e}`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    this.logger.debug(`Got current backup version from server: ${currentServerVersion?.version}`);
+    if (currentServerVersion?.algorithm != "m.megolm_backup.v1.curve25519-aes-sha2") {
+      this.logger.info(`Unsupported algorithm ${currentServerVersion?.algorithm}`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    if (!currentServerVersion?.version) {
+      this.logger.info(`No current key backup`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    const activeVersion = await this.backupManager.getActiveBackupVersion();
+    if (activeVersion == null || currentServerVersion.version != activeVersion) {
+      // Either the current backup version on server side is not trusted, or it is out of sync with the active version on the client side.
+      this.logger.info(`The current backup version on the server (${currentServerVersion.version}) is not trusted. Version we are currently backing up to: ${activeVersion}`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    const backupKeys = await this.getBackupDecryptionKey();
+    if (!backupKeys?.decryptionKey) {
+      this.logger.debug(`Not checking key backup for session (no decryption key)`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    if (activeVersion != backupKeys.backupVersion) {
+      this.logger.debug(`Version for which we have a decryption key (${backupKeys.backupVersion}) doesn't match the version we are backing up to (${activeVersion})`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    const authData = currentServerVersion.auth_data;
+    if (authData.public_key != backupKeys.decryptionKey.megolmV1PublicKey.publicKeyBase64) {
+      this.logger.debug(`Key backup on server does not match our decryption key`);
+      this.hasConfigurationProblem = true;
+      return null;
+    }
+    const backupDecryptor = this.backupManager.createBackupDecryptor(backupKeys.decryptionKey);
+    this.hasConfigurationProblem = false;
+    this.configuration = {
+      decryptor: backupDecryptor,
+      backupVersion: activeVersion
+    };
+    return this.configuration;
   }
 }
 //# sourceMappingURL=PerSessionKeyBackupDownloader.js.map