@openclaw/matrix 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/{crypto-runtime-D9_6J5tZ.js → crypto-runtime-Bnz3zEcS.js}

@@ -1,9 +1,9 @@
-import { t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
 import { t as ensureMatrixCryptoRuntime } from "./deps-CcVJfvRM.js";
-import { n as LogService, r as noop } from "./logger-D0GCSDQq.js";
-import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-B6x7dMsF.js";
-import { n as isRepairableSecretStorageAccessError } from "./recovery-key-store-BNnHvXdk.js";
+import { n as LogService, r as noop } from "./logger-B_71hN6W.js";
+import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-BM0P27Zg.js";
+import { n as isRepairableSecretStorageAccessError } from "./recovery-key-store-CognuDys.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { formatErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { MatrixEventEvent } from "matrix-js-sdk/lib/matrix.js";
 import { IDBDatabase } from "fake-indexeddb";
@@ -199,7 +199,7 @@ var MatrixCryptoBootstrapper = class {
 						await this.trustFreshOwnIdentity(crypto);
 					} catch (repairErr) {
 						LogService.warn("MatrixClientLite", "Forced cross-signing reset failed:", repairErr);
-						if (options.strict) throw repairErr instanceof Error ? repairErr : new Error(String(repairErr));
+						if (options.strict) throw toStringifiedError(repairErr);
 						return {
 							ready: false,
 							published: false
@@ -210,7 +210,7 @@ var MatrixCryptoBootstrapper = class {
 				LogService.warn("MatrixClientLite", "Forced cross-signing reset failed:", err);
 				if (options.strict) {
 					if (isRepairableSecretStorageAccessError(err)) throw new Error("Forced cross-signing reset cannot access secret storage; restore the Matrix recovery key before retrying", { cause: err });
-					throw err instanceof Error ? err : new Error(String(err));
+					throw toStringifiedError(err);
 				}
 				return {
 					ready: false,
@@ -245,7 +245,7 @@ var MatrixCryptoBootstrapper = class {
 					});
 				} catch (resetErr) {
 					LogService.warn("MatrixClientLite", "Failed to bootstrap cross-signing:", resetErr);
-					if (options.strict) throw resetErr instanceof Error ? resetErr : new Error(String(resetErr));
+					if (options.strict) throw toStringifiedError(resetErr);
 					return {
 						ready: false,
 						published: false
@@ -274,7 +274,7 @@ var MatrixCryptoBootstrapper = class {
 			await this.trustFreshOwnIdentity(crypto);
 		} catch (err) {
 			LogService.warn("MatrixClientLite", "Fallback cross-signing bootstrap failed:", err);
-			if (options.strict) throw err instanceof Error ? err : new Error(String(err));
+			if (options.strict) throw toStringifiedError(err);
 			return {
 				ready: false,
 				published: false
@@ -298,7 +298,7 @@ var MatrixCryptoBootstrapper = class {
 			LogService.info("MatrixClientLite", "Secret storage bootstrap complete");
 		} catch (err) {
 			LogService.warn("MatrixClientLite", "Failed to bootstrap secret storage:", err);
-			if (options.strict) throw err instanceof Error ? err : new Error(String(err));
+			if (options.strict) throw toStringifiedError(err);
 		}
 	}
 	registerVerificationRequestHandler(crypto) {
@@ -354,15 +354,7 @@ function createMatrixCryptoFacade(deps) {
 	return {
 		prepare: async (_joinedRooms) => {},
 		updateSyncData: async (_toDeviceMessages, _otkCounts, _unusedFallbackKeyAlgs, _changedDeviceLists, _leftDeviceLists) => {},
-		isRoomEncrypted: async (roomId) => {
-			if (deps.client.getRoom(roomId)?.hasEncryptionStateEvent()) return true;
-			try {
-				const event = await deps.getRoomStateEvent(roomId, "m.room.encryption", "");
-				return typeof event.algorithm === "string" && event.algorithm.length > 0;
-			} catch {
-				return false;
-			}
-		},
+		isRoomEncrypted: deps.isRoomEncrypted,
 		requestOwnUserVerification: async () => {
 			const crypto = deps.client.getCrypto();
 			return await deps.verificationManager.requestOwnUserVerification(crypto);
@@ -457,6 +449,7 @@ function createMatrixCryptoFacade(deps) {
 const MATRIX_DECRYPT_RETRY_BASE_DELAY_MS = 1500;
 const MATRIX_DECRYPT_RETRY_MAX_DELAY_MS = 3e4;
 const MATRIX_DECRYPT_RETRY_MAX_ATTEMPTS = 8;
+const MATRIX_DECRYPT_DRAIN_TIMEOUT_MS = 5e3;
 const MATRIX_DECRYPT_EXHAUSTED_RETRY_TTL_MS = 60 * 6e4;
 const MATRIX_DECRYPT_EXHAUSTED_RETRY_MAX_ENTRIES = 512;
 function resolveDecryptRetryKey(roomId, eventId) {
@@ -472,6 +465,7 @@ var MatrixDecryptBridge = class {
 	constructor(deps) {
 		this.deps = deps;
 		this.trackedEncryptedEvents = /* @__PURE__ */ new WeakSet();
+		this.pendingSdkDecryptions = /* @__PURE__ */ new Set();
 		this.decryptedMessageDedupe = /* @__PURE__ */ new Map();
 		this.decryptRetries = /* @__PURE__ */ new Map();
 		this.failedDecryptionsNotified = /* @__PURE__ */ new Set();
@@ -479,6 +473,7 @@ var MatrixDecryptBridge = class {
 		this.activeRetryRuns = 0;
 		this.retryIdleResolvers = /* @__PURE__ */ new Set();
 		this.cryptoRetrySignalsBound = false;
+		this.quiescing = false;
 		this.stopped = false;
 	}
 	shouldEmitUnencryptedMessage(roomId, eventId) {
@@ -489,9 +484,17 @@ var MatrixDecryptBridge = class {
 		return false;
 	}
 	attachEncryptedEvent(event, roomId) {
-		if (this.stopped) return;
+		if (this.quiescing || this.stopped) return;
 		if (this.trackedEncryptedEvents.has(event)) return;
 		this.trackedEncryptedEvents.add(event);
+		const sdkDecryption = event.getDecryptionPromise();
+		if (sdkDecryption) {
+			this.pendingSdkDecryptions.add(sdkDecryption);
+			const forgetSdkDecryption = () => {
+				this.pendingSdkDecryptions.delete(sdkDecryption);
+			};
+			sdkDecryption.then(forgetSdkDecryption, forgetSdkDecryption);
+		}
 		event.on(MatrixEventEvent.Decrypted, (decryptedEvent, err) => {
 			this.handleEncryptedEventDecrypted({
 				roomId,
@@ -510,7 +513,7 @@ var MatrixDecryptBridge = class {
 		}
 	}
 	retryPendingNow(reason, options) {
-		if (this.stopped) return;
+		if (this.quiescing || this.stopped) return;
 		if (options?.includeExhausted) {
 			this.pruneExhaustedDecryptRetries(Date.now());
 			for (const [retryKey, state] of this.exhaustedDecryptRetries) {
@@ -556,16 +559,33 @@ var MatrixDecryptBridge = class {
 		});
 	}
 	stop() {
+		this.quiescing = true;
 		this.stopped = true;
 		for (const retryKey of this.decryptRetries.keys()) this.clearDecryptRetry(retryKey);
+		this.pendingSdkDecryptions.clear();
 		this.exhaustedDecryptRetries.clear();
 	}
-	async drainPendingDecryptions(reason) {
-		for (let attempts = 0; attempts < MATRIX_DECRYPT_RETRY_MAX_ATTEMPTS; attempts += 1) {
-			if (this.decryptRetries.size === 0) return;
-			this.retryPendingNow(reason);
-			await this.waitForActiveRetryRunsToFinish();
-			if (!Array.from(this.decryptRetries.values()).some((state) => state.timer || state.inFlight)) return;
+	async drainPendingDecryptions(_reason) {
+		this.quiescing = true;
+		const pendingSdkDecryptions = Array.from(this.pendingSdkDecryptions);
+		const pending = Array.from(this.decryptRetries.entries());
+		for (const [retryKey, state] of pending) {
+			if (state.timer) {
+				clearTimeout(state.timer);
+				state.timer = null;
+			}
+			if (!state.inFlight) this.runDecryptRetry(retryKey).catch(noop);
+		}
+		let timeout;
+		try {
+			await Promise.race([Promise.all([Promise.allSettled(pendingSdkDecryptions), this.waitForActiveRetryRunsToFinish()]), new Promise((_, reject) => {
+				timeout = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error(`Matrix decryption drain did not finish within ${MATRIX_DECRYPT_DRAIN_TIMEOUT_MS}ms`));
+				}, MATRIX_DECRYPT_DRAIN_TIMEOUT_MS);
+				timeout.unref?.();
+			})]);
+		} finally {
+			if (timeout !== void 0) clearTimeout(timeout);
 		}
 	}
 	handleEncryptedEventDecrypted(params) {
@@ -607,7 +627,7 @@ var MatrixDecryptBridge = class {
 		this.deps.emitFailedDecryption(roomId, event, error);
 	}
 	scheduleDecryptRetry(params) {
-		if (this.stopped) return;
+		if (this.quiescing || this.stopped) return;
 		const retryKey = resolveDecryptRetryKey(params.roomId, params.eventId);
 		if (!retryKey) return;
 		const existing = this.decryptRetries.get(retryKey);
@@ -670,7 +690,10 @@ var MatrixDecryptBridge = class {
 			this.resolveRetryIdleIfNeeded();
 		}
 		if (this.decryptRetries.get(retryKey) !== state) return;
-		if (this.stopped) return;
+		if (this.stopped || this.quiescing && state.event.isDecryptionFailure()) {
+			this.clearDecryptRetry(retryKey);
+			return;
+		}
 		if (state.event.isDecryptionFailure()) {
 			if (!shouldRetryDecryptionFailure(state.event)) {
 				this.clearDecryptRetry(retryKey);
@@ -898,7 +921,7 @@ var MatrixVerificationManager = class {
 			this.touchVerificationSession(session);
 		}).catch((err) => {
 			session.acceptRequested = false;
-			session.error = formatMatrixErrorMessage(err);
+			session.error = formatErrorMessage(err);
 			this.touchVerificationSession(session);
 		});
 	}
@@ -947,7 +970,7 @@ var MatrixVerificationManager = class {
 		});
 		verifier.on(VerifierEvent.Cancel, (err) => {
 			this.clearSasAutoConfirmTimer(session);
-			session.error = formatMatrixErrorMessage(err);
+			session.error = formatErrorMessage(err);
 			this.touchVerificationSession(session);
 		});
 		this.ensureVerificationStarted(session);
@@ -965,7 +988,7 @@ var MatrixVerificationManager = class {
 			this.confirmSasForSession(session, callbacks, { trustOwnDevice: true }).then(() => {
 				this.touchVerificationSession(session);
 			}).catch((err) => {
-				session.error = formatMatrixErrorMessage(err);
+				session.error = formatErrorMessage(err);
 				this.touchVerificationSession(session);
 			});
 		}, SAS_AUTO_CONFIRM_DELAY_MS);
@@ -980,7 +1003,7 @@ var MatrixVerificationManager = class {
 		session.verifyPromise = session.activeVerifier.verify().then(() => {
 			this.touchVerificationSession(session);
 		}).catch((err) => {
-			session.error = formatMatrixErrorMessage(err);
+			session.error = formatErrorMessage(err);
 			this.touchVerificationSession(session);
 		});
 	}

package/dist/direct-room-RinHjtqX.js

@@ -0,0 +1,71 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { normalizeNullableString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/direct-room.ts
+var direct_room_exports = /* @__PURE__ */ __exportAll({
+	hasDirectMatrixMemberFlag: () => hasDirectMatrixMemberFlag,
+	inspectMatrixDirectRoomEvidence: () => inspectMatrixDirectRoomEvidence,
+	isStrictDirectMembership: () => isStrictDirectMembership,
+	isStrictDirectRoom: () => isStrictDirectRoom,
+	readJoinedMatrixMembers: () => readJoinedMatrixMembers
+});
+function normalizeJoinedMatrixMembers(joinedMembers) {
+	if (!Array.isArray(joinedMembers)) return [];
+	return joinedMembers.map((entry) => normalizeNullableString(entry)).filter((entry) => Boolean(entry));
+}
+function isStrictDirectMembership(params) {
+	const selfUserId = normalizeNullableString(params.selfUserId);
+	const remoteUserId = normalizeNullableString(params.remoteUserId);
+	const joinedMembers = params.joinedMembers ?? [];
+	return Boolean(selfUserId && remoteUserId && joinedMembers.length === 2 && joinedMembers.includes(selfUserId) && joinedMembers.includes(remoteUserId));
+}
+async function readJoinedMatrixMembers(client, roomId) {
+	try {
+		return normalizeJoinedMatrixMembers(await client.getJoinedRoomMembers(roomId));
+	} catch {
+		return null;
+	}
+}
+async function hasDirectMatrixMemberFlag(client, roomId, userId) {
+	const normalizedUserId = normalizeNullableString(userId);
+	if (!normalizedUserId) return null;
+	try {
+		const state = await client.getRoomStateEvent(roomId, "m.room.member", normalizedUserId);
+		if (state?.is_direct === true) return true;
+		if (state?.is_direct === false) return false;
+		return null;
+	} catch {
+		return null;
+	}
+}
+async function inspectMatrixDirectRoomEvidence(params) {
+	const selfUserId = params.selfUserId !== void 0 ? normalizeNullableString(params.selfUserId) : normalizeNullableString(await params.client.getUserId().catch(() => null));
+	const joinedMembers = await readJoinedMatrixMembers(params.client, params.roomId);
+	const strict = isStrictDirectMembership({
+		selfUserId,
+		remoteUserId: params.remoteUserId,
+		joinedMembers
+	});
+	if (!strict) return {
+		joinedMembers,
+		strict: false,
+		viaMemberState: false,
+		memberStateFlag: null
+	};
+	const memberStateFlag = await hasDirectMatrixMemberFlag(params.client, params.roomId, selfUserId);
+	return {
+		joinedMembers,
+		strict,
+		viaMemberState: memberStateFlag === true,
+		memberStateFlag
+	};
+}
+async function isStrictDirectRoom(params) {
+	return (await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId: params.remoteUserId,
+		selfUserId: params.selfUserId
+	})).strict;
+}
+//#endregion
+export { isStrictDirectRoom as a, isStrictDirectMembership as i, hasDirectMatrixMemberFlag as n, readJoinedMatrixMembers as o, inspectMatrixDirectRoomEvidence as r, direct_room_exports as t };

package/dist/{directory-live-YRgYDx2w.js → directory-live-Bvg2wAnR.js}

@@ -1,7 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.js";
-import { f as resolveMatrixAuth } from "./shared-CUH5otj8.js";
-import "./client-BFRg0kd4.js";
+import { c as resolveMatrixAuth } from "./client-CeGw0G5S.js";
 import { t as MatrixAuthedHttpClient } from "./http-client-CycYxU9-.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/directory-live.ts

package/dist/{doctor-CM8ijNpW.js → doctor-EWf9CDso.js}

@@ -1,5 +1,5 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BMSJkkAE.js";
-import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/runtime-doctor";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DEt4O4Zt.js";
+import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/doctor-repair-runtime";
 //#region extensions/matrix/src/doctor.ts
 async function collectMatrixInstallPathWarnings(cfg) {
 	const issue = await detectPluginInstallPathIssue({

package/dist/{doctor-contract-BMSJkkAE.js → doctor-contract-DEt4O4Zt.js}

@@ -1,6 +1,5 @@
-import { t as isRecord } from "./record-shared-CWWx6fvI.js";
-import { defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries, stripRetiredChannelKeys } from "openclaw/plugin-sdk/runtime-doctor";
-import { hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias } from "openclaw/plugin-sdk/ssrf-runtime";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias, normalizeChannelConfigEntries, stripRetiredChannelKeys } from "openclaw/plugin-sdk/runtime-doctor-migrations";
 //#region extensions/matrix/src/doctor-contract.ts
 function parseMatrixStreamingMode(value) {
 	if (typeof value !== "string") return null;