@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/node_modules/matrix-js-sdk/src/@types/type-guards.ts

@@ -0,0 +1,126 @@
+/*
+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.
+*/
+
+import { logger } from "../logger.ts";
+
+/**
+ * Type guard to check the given value is a Record type with string keys.
+ * @param value - the value to check
+ */
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+    !!value && typeof value === "object" && !Array.isArray(value);
+
+/**
+ * Type guard to check the given record has a key and its value is a string
+ * @param metadata - the record to check
+ * @param key - the key to check
+ */
+export const hasRequiredStringProperty = <K extends string>(
+    metadata: Record<string, unknown>,
+    key: K,
+): metadata is Record<string, unknown> & Record<K, string> => {
+    if (!metadata[key] || !hasOptionalStringProperty(metadata, key)) {
+        logger.error(`Missing or invalid property: ${key}`);
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Type guard to check that if the given record has a key then its value is a string
+ * @param metadata - the record to check
+ * @param key - the key to check
+ */
+export const hasOptionalStringProperty = <K extends string>(
+    metadata: Record<string, unknown>,
+    key: K,
+): metadata is Record<string, unknown> & Record<K, string | undefined> => {
+    if (!!metadata[key] && typeof metadata[key] !== "string") {
+        logger.error(`Invalid property: ${key}`);
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Type guard to check the given record has a key and its value is a number
+ * @param metadata - the record to check
+ * @param key - the key to check
+ */
+export const hasRequiredNumberProperty = <K extends string>(
+    metadata: Record<string, unknown>,
+    key: K,
+): metadata is Record<string, unknown> & Record<K, number> => {
+    if (!metadata[key] || !hasOptionalNumberProperty(metadata, key)) {
+        logger.error(`Missing or invalid property: ${key}`);
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Type guard to check that if the given record has a key then its value is a number
+ * @param metadata - the record to check
+ * @param key - the key to check
+ */
+export const hasOptionalNumberProperty = <K extends string>(
+    metadata: Record<string, unknown>,
+    key: K,
+): metadata is Record<string, unknown> & Record<K, number | undefined> => {
+    if (!!metadata[key] && typeof metadata[key] !== "number") {
+        logger.error(`Invalid property: ${key}`);
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Type guard to check that if the given record has a key then its value is an array containing only strings
+ * @param metadata - the record to check
+ * @param key - the key to check
+ */
+export const optionalStringArrayProperty = <K extends string>(
+    metadata: Record<string, unknown>,
+    key: K,
+): metadata is Record<string, unknown> & Record<K, string[] | undefined> => {
+    if (
+        !!metadata[key] &&
+        (!Array.isArray(metadata[key]) || !(<unknown[]>metadata[key]).every((v) => typeof v === "string"))
+    ) {
+        logger.error(`Invalid property: ${key}`);
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Type guard to check the given record has a key and its value is an array of strings containing at least the given value
+ * @param metadata - the record to check
+ * @param key - the key to check
+ * @param value - the value to require to be present in the array
+ */
+export const requiredArrayValue = <K extends string, V>(
+    metadata: Record<string, unknown>,
+    key: K,
+    value: V,
+): metadata is Record<string, unknown> & Record<K, V[]> => {
+    const array = metadata[key];
+    if (!array || !Array.isArray(array) || !array.includes(value)) {
+        logger.error(`Invalid property: ${key}. ${value} is required.`);
+        return false;
+    }
+    return true;
+};

package/node_modules/matrix-js-sdk/src/ToDeviceMessageQueue.ts

@@ -105,8 +105,6 @@ export class ToDeviceMessageQueue {
             this.logger.debug("All queued to-device messages sent");
         } catch (e) {
             ++this.retryAttempts;
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            // eslint-disable-next-line new-cap
             const retryDelay = MatrixScheduler.RETRY_BACKOFF_RATELIMIT(null, this.retryAttempts, <MatrixError>e);
             if (retryDelay === -1) {
                 // the scheduler function doesn't differentiate between fatal errors and just getting

package/node_modules/matrix-js-sdk/src/autodiscovery.ts

@@ -193,7 +193,7 @@ export class AutoDiscovery {
 
         // Step 3.1: Non-spec check to ensure the server will actually work for us. We need to check if
         // any of the versions in `SUPPORTED_MATRIX_VERSIONS` are listed in the /versions response.
-        const hsVersionSet = new Set(hsVersions.raw!["versions"]);
+        const hsVersionSet = new Set(hsVersions.raw["versions"]);
         let supportedVersionFound = false;
         for (const version of SUPPORTED_MATRIX_VERSIONS) {
             if (hsVersionSet.has(version)) {
@@ -358,7 +358,7 @@ export class AutoDiscovery {
         }
 
         // Step 2: Validate and parse the config
-        return AutoDiscovery.fromDiscoveryConfig(wellknown.raw!);
+        return AutoDiscovery.fromDiscoveryConfig(wellknown.raw);
     }
 
     /**

package/node_modules/matrix-js-sdk/src/browser-index.ts

@@ -18,10 +18,8 @@ import * as sdk from "./matrix.ts";
 
 type BrowserMatrix = typeof sdk;
 declare global {
-    /* eslint-disable no-var, camelcase */
     var __js_sdk_entrypoint: boolean;
     var matrixcs: BrowserMatrix;
-    /* eslint-enable no-var */
 }
 
 if (globalThis.__js_sdk_entrypoint) {
@@ -33,11 +31,13 @@ globalThis.__js_sdk_entrypoint = true;
 let indexedDB: IDBFactory | undefined;
 try {
     indexedDB = globalThis.indexedDB;
-} catch {}
+} catch {
+    // Do nothing
+}
 
 // if our browser (appears to) support indexeddb, use an indexeddb crypto store.
 if (indexedDB) {
-    sdk.setCryptoStoreFactory(() => new sdk.IndexedDBCryptoStore(indexedDB!, "matrix-js-sdk:crypto"));
+    sdk.setCryptoStoreFactory(() => new sdk.IndexedDBCryptoStore(indexedDB, "matrix-js-sdk:crypto"));
 }
 
 export * from "./matrix.ts";