@openclaw/matrix 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{crypto-runtime-DPjIDF8H.mjs → crypto-runtime-B2AjWo-i.mjs}

@@ -1,17 +1,25 @@
-import { t as ensureMatrixCryptoRuntime } from "./deps-CLQ4EOq7.mjs";
-import { n as LogService, r as noop } from "./logger-CVv56jzH.mjs";
-import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-DBvfre1X.mjs";
-import { n as isRepairableSecretStorageAccessError } from "./sdk-DmRVM0VA.mjs";
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { t as ensureMatrixCryptoRuntime } from "./deps-CFNl7tQo.mjs";
+import { n as RETIRED_MATRIX_STATE_REMEDIATION } from "./retired-state-BXUQ2I-C.mjs";
+import { c as readMatrixIdbSnapshotJson, u as writeMatrixIdbSnapshotJson } from "./storage-D7agewjH.mjs";
+import { r as noop, t as LogService } from "./logger-CXQnpXCt.mjs";
+import { a as isRepairableSecretStorageAccessError, i as trustMatrixOwnIdentity, n as isMatrixDeviceOwnerVerified, o as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, r as isMatrixDeviceVerifiedInCurrentClient } from "./sdk-CgQGkCsS.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { formatErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
+import { filterStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
+import { formatErrorMessage, toErrorObject, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import fs from "node:fs";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { MatrixEventEvent } from "matrix-js-sdk/lib/matrix.js";
-import { IDBDatabase } from "fake-indexeddb";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
 import "fake-indexeddb/auto";
+import { IDBDatabase, indexedDB } from "fake-indexeddb";
 import { CryptoEvent } from "matrix-js-sdk/lib/crypto-api/CryptoEvent.js";
 import { DecryptionFailureCode } from "matrix-js-sdk/lib/crypto-api/index.js";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
 import { VerificationPhase, VerificationRequestEvent, VerifierEvent } from "matrix-js-sdk/lib/crypto-api/verification.js";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 //#region extensions/matrix/src/matrix/sdk/fake-indexeddb-prune.ts
@@ -52,14 +60,6 @@ function installFakeIndexedDbTransactionPruner() {
 	};
 }
 //#endregion
-//#region extensions/matrix/src/matrix/sdk/verification-status.ts
-function isMatrixDeviceOwnerVerified(status) {
-	return status?.crossSigningVerified === true;
-}
-function isMatrixDeviceVerifiedInCurrentClient(status) {
-	return status?.isVerified?.() === true || status?.localVerified === true || isMatrixDeviceOwnerVerified(status);
-}
-//#endregion
 //#region extensions/matrix/src/matrix/sdk/crypto-bootstrap.ts
 const CROSS_SIGNING_PUBLICATION_WAIT_MS = 5e3;
 var MatrixCryptoBootstrapper = class {
@@ -173,7 +173,7 @@ var MatrixCryptoBootstrapper = class {
 					setupNewCrossSigning: true,
 					authUploadDeviceSigningKeys
 				});
-				await this.trustFreshOwnIdentity(crypto);
+				await trustMatrixOwnIdentity(crypto);
 			} catch (err) {
 				LogService.warn("MatrixClientLite", "Forced cross-signing reset failed:", err);
 				if (options.strict) {
@@ -239,7 +239,7 @@ var MatrixCryptoBootstrapper = class {
 				setupNewCrossSigning: true,
 				authUploadDeviceSigningKeys
 			});
-			await this.trustFreshOwnIdentity(crypto);
+			await trustMatrixOwnIdentity(crypto);
 		} catch (err) {
 			LogService.warn("MatrixClientLite", "Fallback cross-signing bootstrap failed:", err);
 			if (options.strict) throw toStringifiedError(err);
@@ -250,16 +250,6 @@ var MatrixCryptoBootstrapper = class {
 		}
 		return await finalize();
 	}
-	async trustFreshOwnIdentity(crypto) {
-		const ownIdentity = typeof crypto.getOwnIdentity === "function" ? await crypto.getOwnIdentity().catch(() => void 0) : void 0;
-		if (!ownIdentity) return;
-		try {
-			if (typeof ownIdentity.isVerified === "function" && ownIdentity.isVerified()) return;
-			await ownIdentity.verify?.();
-		} finally {
-			ownIdentity.free?.();
-		}
-	}
 	async bootstrapSecretStorage(crypto, options) {
 		try {
 			await this.deps.recoveryKeyStore.bootstrapSecretStorageWithRecoveryKey(crypto, { allowSecretStorageRecreateWithoutRecoveryKey: options.allowSecretStorageRecreateWithoutRecoveryKey });
@@ -287,12 +277,14 @@ var MatrixCryptoBootstrapper = class {
 		const deviceId = this.deps.getDeviceId()?.trim();
 		if (!deviceId) return null;
 		const userId = await this.deps.getUserId();
-		if (isMatrixDeviceOwnerVerified(typeof crypto.getDeviceVerificationStatus === "function" ? await crypto.getDeviceVerificationStatus(userId, deviceId).catch(() => null) : null)) return true;
+		const deviceStatus = typeof crypto.getDeviceVerificationStatus === "function" ? await crypto.getDeviceVerificationStatus(userId, deviceId).catch(() => null) : null;
+		if (isMatrixDeviceOwnerVerified(deviceStatus)) return true;
 		if (typeof crypto.setDeviceVerified === "function") await crypto.setDeviceVerified(userId, deviceId, true);
 		if (typeof crypto.crossSignDevice === "function") {
 			if (typeof crypto.isCrossSigningReady === "function" ? await crypto.isCrossSigningReady() : true) await crypto.crossSignDevice(deviceId);
 		}
-		const verified = isMatrixDeviceOwnerVerified(typeof crypto.getDeviceVerificationStatus === "function" ? await crypto.getDeviceVerificationStatus(userId, deviceId).catch(() => null) : null);
+		const refreshedStatus = typeof crypto.getDeviceVerificationStatus === "function" ? await crypto.getDeviceVerificationStatus(userId, deviceId).catch(() => null) : null;
+		const verified = isMatrixDeviceOwnerVerified(refreshedStatus);
 		if (!verified && options.strict) throw new Error(`Matrix own device ${deviceId} does not have full Matrix identity trust after bootstrap`);
 		return verified;
 	}
@@ -324,10 +316,6 @@ function createMatrixCryptoFacade(deps) {
 	}
 	return {
 		isRoomEncrypted: deps.isRoomEncrypted,
-		requestOwnUserVerification: async () => {
-			const crypto = deps.client.getCrypto();
-			return await deps.verificationManager.requestOwnUserVerification(crypto);
-		},
 		encryptMedia: async (buffer) => {
 			const { Attachment } = await loadMatrixCryptoNodeBindings();
 			const encrypted = Attachment.encrypt(new Uint8Array(buffer));
@@ -515,17 +503,9 @@ var MatrixDecryptBridge = class {
 			}
 			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);
-		}
+		await raceWithTimeout(Promise.all([Promise.allSettled(pendingSdkDecryptions), this.waitForActiveRetryRunsToFinish()]), MATRIX_DECRYPT_DRAIN_TIMEOUT_MS, () => {
+			throw new Error(`Matrix decryption drain did not finish within ${MATRIX_DECRYPT_DRAIN_TIMEOUT_MS}ms`);
+		}, { ref: false });
 	}
 	handleEncryptedEventDecrypted(params) {
 		if (this.stopped) return;
@@ -646,11 +626,7 @@ var MatrixDecryptBridge = class {
 	}
 	pruneExhaustedDecryptRetries(now) {
 		for (const [retryKey, state] of this.exhaustedDecryptRetries) if (now - state.exhaustedAt > MATRIX_DECRYPT_EXHAUSTED_RETRY_TTL_MS) this.exhaustedDecryptRetries.delete(retryKey);
-		while (this.exhaustedDecryptRetries.size > MATRIX_DECRYPT_EXHAUSTED_RETRY_MAX_ENTRIES) {
-			const oldest = this.exhaustedDecryptRetries.keys().next().value;
-			if (oldest === void 0) break;
-			this.exhaustedDecryptRetries.delete(oldest);
-		}
+		pruneMapToMaxSize(this.exhaustedDecryptRetries, MATRIX_DECRYPT_EXHAUSTED_RETRY_MAX_ENTRIES);
 	}
 	rememberDecryptedMessage(roomId, eventId) {
 		if (!eventId) return;
@@ -661,21 +637,12 @@ var MatrixDecryptBridge = class {
 	pruneDecryptedMessageDedupe(now) {
 		const ttlMs = 3e4;
 		for (const [key, createdAt] of this.decryptedMessageDedupe) if (now - createdAt > ttlMs) this.decryptedMessageDedupe.delete(key);
-		const maxEntries = 2048;
-		while (this.decryptedMessageDedupe.size > maxEntries) {
-			const oldest = this.decryptedMessageDedupe.keys().next().value;
-			if (oldest === void 0) break;
-			this.decryptedMessageDedupe.delete(oldest);
-		}
+		pruneMapToMaxSize(this.decryptedMessageDedupe, 2048);
 	}
 	async waitForActiveRetryRunsToFinish() {
 		if (this.activeRetryRuns === 0) return;
 		await new Promise((resolve) => {
 			this.retryIdleResolvers.add(resolve);
-			if (this.activeRetryRuns === 0) {
-				this.retryIdleResolvers.delete(resolve);
-				resolve();
-			}
 		});
 	}
 	resolveRetryIdleIfNeeded() {
@@ -685,6 +652,199 @@ var MatrixDecryptBridge = class {
 	}
 };
 //#endregion
+//#region extensions/matrix/src/matrix/sdk/idb-persistence.ts
+const LEGACY_SNAPSHOT_DIAGNOSTIC = {
+	code: "matrix-idb-snapshot-requires-doctor",
+	message: "Matrix IndexedDB snapshot exists outside canonical SQLite state",
+	remediation: RETIRED_MATRIX_STATE_REMEDIATION
+};
+var MatrixIdbSnapshotMigrationRequiredError = class extends Error {
+	constructor() {
+		super(`${LEGACY_SNAPSHOT_DIAGNOSTIC.message}; ${LEGACY_SNAPSHOT_DIAGNOSTIC.remediation}`);
+		this.code = LEGACY_SNAPSHOT_DIAGNOSTIC.code;
+		this.remediation = LEGACY_SNAPSHOT_DIAGNOSTIC.remediation;
+		this.name = "MatrixIdbSnapshotMigrationRequiredError";
+	}
+};
+function isValidIdbIndexSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.name === "string" && (typeof candidate.keyPath === "string" || Array.isArray(candidate.keyPath) && candidate.keyPath.every((entry) => typeof entry === "string")) && typeof candidate.multiEntry === "boolean" && typeof candidate.unique === "boolean";
+}
+function isValidIdbRecordSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	return "key" in value && "value" in value;
+}
+function isValidIdbStoreSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	const validKeyPath = candidate.keyPath === null || typeof candidate.keyPath === "string" || Array.isArray(candidate.keyPath) && candidate.keyPath.every((entry) => typeof entry === "string");
+	return typeof candidate.name === "string" && validKeyPath && typeof candidate.autoIncrement === "boolean" && Array.isArray(candidate.indexes) && candidate.indexes.every((entry) => isValidIdbIndexSnapshot(entry)) && Array.isArray(candidate.records) && candidate.records.every((entry) => isValidIdbRecordSnapshot(entry));
+}
+function isValidIdbDatabaseSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.name === "string" && typeof candidate.version === "number" && Number.isFinite(candidate.version) && candidate.version > 0 && Array.isArray(candidate.stores) && candidate.stores.every((entry) => isValidIdbStoreSnapshot(entry));
+}
+function parseSnapshotPayload(data) {
+	const parsed = JSON.parse(data);
+	if (!Array.isArray(parsed) || parsed.length === 0) return null;
+	if (!parsed.every((entry) => isValidIdbDatabaseSnapshot(entry))) throw new Error("Malformed IndexedDB snapshot payload");
+	return parsed;
+}
+function idbReq(req) {
+	return new Promise((resolve, reject) => {
+		req.addEventListener("success", () => resolve(req.result), { once: true });
+		req.addEventListener("error", () => reject(toErrorObject(req.error, "Non-Error rejection")), { once: true });
+	});
+}
+async function dumpIndexedDatabases(databasePrefix) {
+	const idb = indexedDB;
+	const dbList = await idb.databases();
+	const snapshot = [];
+	const expectedPrefix = databasePrefix ? `${databasePrefix}::` : null;
+	for (const { name, version } of dbList) {
+		if (!name || !version) continue;
+		if (expectedPrefix && !name.startsWith(expectedPrefix)) continue;
+		const db = await idbReq(idb.open(name, version));
+		const stores = [];
+		for (const storeName of db.objectStoreNames) {
+			const store = db.transaction(storeName, "readonly").objectStore(storeName);
+			const storeInfo = {
+				name: storeName,
+				keyPath: store.keyPath,
+				autoIncrement: store.autoIncrement,
+				indexes: [],
+				records: []
+			};
+			for (const idxName of store.indexNames) {
+				const idx = store.index(idxName);
+				storeInfo.indexes.push({
+					name: idxName,
+					keyPath: idx.keyPath,
+					multiEntry: idx.multiEntry,
+					unique: idx.unique
+				});
+			}
+			const keys = await idbReq(store.getAllKeys());
+			const values = await idbReq(store.getAll());
+			storeInfo.records = keys.map((k, i) => ({
+				key: k,
+				value: values[i]
+			}));
+			stores.push(storeInfo);
+		}
+		snapshot.push({
+			name,
+			version,
+			stores
+		});
+		db.close();
+	}
+	return snapshot;
+}
+async function restoreIndexedDatabases(snapshot) {
+	const idb = indexedDB;
+	for (const dbSnap of snapshot) {
+		const request = idb.open(dbSnap.name, dbSnap.version);
+		request.addEventListener("upgradeneeded", () => {
+			const db = request.result;
+			for (const storeSnap of dbSnap.stores) {
+				const opts = {};
+				if (storeSnap.keyPath !== null) opts.keyPath = storeSnap.keyPath;
+				if (storeSnap.autoIncrement) opts.autoIncrement = true;
+				const store = db.createObjectStore(storeSnap.name, opts);
+				for (const idx of storeSnap.indexes) store.createIndex(idx.name, idx.keyPath, {
+					unique: idx.unique,
+					multiEntry: idx.multiEntry
+				});
+			}
+		});
+		const db = await idbReq(request);
+		try {
+			for (const storeSnap of dbSnap.stores) {
+				if (storeSnap.records.length === 0) continue;
+				const tx = db.transaction(storeSnap.name, "readwrite");
+				const store = tx.objectStore(storeSnap.name);
+				for (const rec of storeSnap.records) if (storeSnap.keyPath !== null) store.put(rec.value);
+				else store.put(rec.value, rec.key);
+				await new Promise((resolve, reject) => {
+					tx.addEventListener("complete", () => resolve(), { once: true });
+					tx.addEventListener("abort", () => reject(toErrorObject(tx.error, "IndexedDB restore transaction aborted")), { once: true });
+				});
+			}
+		} finally {
+			db.close();
+		}
+	}
+}
+function resolveDefaultIdbSnapshotPath() {
+	const stateDir = process.env.OPENCLAW_STATE_DIR || path.join(process.env.HOME || "/tmp", ".openclaw");
+	return path.join(stateDir, "matrix", "crypto-idb-snapshot.json");
+}
+async function readCanonicalSnapshotJson(snapshotPath, stateRuntime) {
+	throwIfLegacySnapshotNeedsDoctor(snapshotPath);
+	return await readMatrixIdbSnapshotJson(path.dirname(snapshotPath), stateRuntime);
+}
+async function restoreIdbFromDisk(snapshotPath, stateRuntime) {
+	const resolvedPath = snapshotPath ?? resolveDefaultIdbSnapshotPath();
+	let callbackStarted = false;
+	try {
+		const snapshotStateRuntime = stateRuntime ?? getMatrixRuntime().state;
+		return await withFileLock(resolvedPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			callbackStarted = true;
+			const storedSnapshotJson = await readCanonicalSnapshotJson(resolvedPath, snapshotStateRuntime);
+			if (!storedSnapshotJson) return false;
+			const snapshot = parseSnapshotPayload(storedSnapshotJson);
+			if (!snapshot) return false;
+			await restoreIndexedDatabases(snapshot);
+			LogService.info("IdbPersistence", `Restored ${snapshot.length} IndexedDB database(s) from Matrix SQLite state`);
+			return true;
+		});
+	} catch (err) {
+		if (err instanceof MatrixIdbSnapshotMigrationRequiredError) throw err;
+		if (!callbackStarted && fs.existsSync(resolvedPath)) throwLegacySnapshotMigrationRequired();
+		LogService.warn("IdbPersistence", "Failed to restore IndexedDB snapshot from SQLite:", err);
+		return false;
+	}
+}
+async function persistIdbToDisk(params) {
+	const snapshotPath = params?.snapshotPath ?? resolveDefaultIdbSnapshotPath();
+	let callbackStarted = false;
+	try {
+		const stateRuntime = params?.stateRuntime ?? getMatrixRuntime().state;
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		const persistedCount = await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			callbackStarted = true;
+			const storageRootDir = path.dirname(snapshotPath);
+			await readCanonicalSnapshotJson(snapshotPath, stateRuntime);
+			const snapshot = await dumpIndexedDatabases(params?.databasePrefix);
+			if (params?.abortSignal?.aborted || snapshot.length === 0) return 0;
+			await writeMatrixIdbSnapshotJson({
+				storageRootDir,
+				snapshotJson: JSON.stringify(snapshot),
+				databaseCount: snapshot.length,
+				stateRuntime
+			});
+			return snapshot.length;
+		});
+		if (persistedCount === 0) return;
+		LogService.debug("IdbPersistence", `Persisted ${persistedCount} IndexedDB database(s) to Matrix SQLite state`);
+	} catch (err) {
+		if (err instanceof MatrixIdbSnapshotMigrationRequiredError) throw err;
+		if (!callbackStarted && fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
+		LogService.warn("IdbPersistence", "Failed to persist IndexedDB snapshot:", err);
+		if (params?.strict) throw err;
+	}
+}
+function throwIfLegacySnapshotNeedsDoctor(snapshotPath) {
+	if (fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
+}
+function throwLegacySnapshotMigrationRequired() {
+	LogService.warn("IdbPersistence", LEGACY_SNAPSHOT_DIAGNOSTIC);
+	throw new MatrixIdbSnapshotMigrationRequiredError();
+}
+//#endregion
 //#region extensions/matrix/src/matrix/sdk/verification-manager.ts
 const MATRIX_VERIFICATION_PHASES = /* @__PURE__ */ new Set([
 	-1,
@@ -708,7 +868,6 @@ var MatrixVerificationManager = class {
 		this.verificationSessionCounter = 0;
 		this.trackedVerificationRequests = /* @__PURE__ */ new WeakSet();
 		this.trackedVerificationVerifiers = /* @__PURE__ */ new WeakSet();
-		this.summaryListeners = /* @__PURE__ */ new Set();
 	}
 	readRequestValue(reader, fallback) {
 		try {
@@ -747,14 +906,11 @@ var MatrixVerificationManager = class {
 		if (this.verificationSessions.size <= MAX_TRACKED_VERIFICATION_SESSIONS) return;
 		const sortedByAge = Array.from(this.verificationSessions.entries()).toSorted((a, b) => a[1].updatedAtMs - b[1].updatedAtMs);
 		const overflow = this.verificationSessions.size - MAX_TRACKED_VERIFICATION_SESSIONS;
-		for (let i = 0; i < overflow; i += 1) {
-			const entry = sortedByAge[i];
-			if (entry) this.verificationSessions.delete(entry[0]);
-		}
+		for (const [id] of sortedByAge.slice(0, overflow)) this.verificationSessions.delete(id);
 	}
 	emitVerificationSummary(session) {
 		const summary = this.buildVerificationSummary(session);
-		for (const listener of this.summaryListeners) listener(summary);
+		this.opts.onSummaryChanged?.(summary);
 	}
 	touchVerificationSession(session) {
 		session.updatedAtMs = resolveDateTimestampMs(Date.now());
@@ -772,7 +928,7 @@ var MatrixVerificationManager = class {
 		const declining = this.readRequestValue(() => request.declining, false);
 		const pending = this.readRequestValue(() => request.pending, false);
 		const methodsRaw = this.readRequestValue(() => request.methods, []);
-		const methods = Array.isArray(methodsRaw) ? methodsRaw.filter((entry) => typeof entry === "string") : [];
+		const methods = filterStringEntries(methodsRaw);
 		const sasCallbacks = session.sasCallbacks ?? session.activeVerifier?.getShowSasCallbacks();
 		if (sasCallbacks) session.sasCallbacks = sasCallbacks;
 		const canAccept = phase < VerificationPhase.Ready && !accepting && !declining;
@@ -850,7 +1006,7 @@ var MatrixVerificationManager = class {
 		const phase = this.readVerificationPhase(session.request, VerificationPhase.Requested);
 		if (phase < VerificationPhase.Ready || phase >= VerificationPhase.Cancelled) return;
 		const methodsRaw = this.readRequestValue(() => session.request.methods, []);
-		const methods = Array.isArray(methodsRaw) ? methodsRaw.filter((entry) => typeof entry === "string") : [];
+		const methods = filterStringEntries(methodsRaw);
 		const chosenMethod = this.readRequestValue(() => session.request.chosenMethod, null);
 		if (!(methods.includes(VerificationMethod.Sas) || chosenMethod === VerificationMethod.Sas)) return;
 		session.startRequested = true;
@@ -931,12 +1087,6 @@ var MatrixVerificationManager = class {
 		if (!deviceId || !this.opts.trustOwnDeviceAfterSas) return;
 		await this.opts.trustOwnDeviceAfterSas(deviceId);
 	}
-	onSummaryChanged(listener) {
-		this.summaryListeners.add(listener);
-		return () => {
-			this.summaryListeners.delete(listener);
-		};
-	}
 	trackVerificationRequest(request) {
 		this.pruneVerificationSessions(Date.now());
 		const requestObj = request;
@@ -974,12 +1124,6 @@ var MatrixVerificationManager = class {
 		this.emitVerificationSummary(session);
 		return this.buildVerificationSummary(session);
 	}
-	async requestOwnUserVerification(crypto) {
-		if (!crypto) return null;
-		const request = await crypto.requestOwnUserVerification();
-		if (!request) return null;
-		return this.trackVerificationRequest(request);
-	}
 	listVerifications() {
 		this.pruneVerificationSessions(Date.now());
 		return Array.from(this.verificationSessions.values()).map((session) => this.buildVerificationSummary(session)).toSorted((a, b) => b.updatedAt.localeCompare(a.updatedAt));
@@ -1036,7 +1180,7 @@ var MatrixVerificationManager = class {
 		session.sasCallbacks = callbacks;
 		session.sasAutoConfirmStarted = true;
 		await this.confirmSasForSession(session, callbacks);
-		if (session.verifyPromise) await session.verifyPromise;
+		await session.verifyPromise;
 		this.touchVerificationSession(session);
 		return this.buildVerificationSummary(session);
 	}

package/dist/.setup/{deps-CLQ4EOq7.mjs → deps-CFNl7tQo.mjs}

@@ -26,34 +26,6 @@ function isMatrixSdkAvailable() {
 	return resolveMissingMatrixPackages().length === 0;
 }
 let defaultMatrixCryptoRuntimeEnsurePromise = null;
-async function runFixedCommandWithTimeout(params) {
-	if (!params.argv[0]) return {
-		code: 1,
-		stdout: "",
-		stderr: "command is required"
-	};
-	try {
-		const result = await runCommandWithTimeout(params.argv, {
-			cwd: params.cwd,
-			env: params.env,
-			killProcessTree: true,
-			maxOutputBytes: MATRIX_COMMAND_OUTPUT_TAIL_BYTES,
-			outputCapture: "tail",
-			timeoutMs: params.timeoutMs
-		});
-		return {
-			code: result.termination === "timeout" ? 124 : result.code ?? 1,
-			stdout: result.stdout,
-			stderr: result.stderr || (result.termination === "timeout" ? `command timed out after ${params.timeoutMs}ms` : "")
-		};
-	} catch (error) {
-		return {
-			code: 1,
-			stdout: "",
-			stderr: error instanceof Error ? error.message : String(error)
-		};
-	}
-}
 const defaultRequireFn = createRequire(import.meta.url);
 const defaultResolveFn = defaultRequireFn.resolve;
 function isMissingMatrixCryptoRuntimeError(error) {
@@ -134,23 +106,26 @@ async function ensureMatrixCryptoRuntimeOnce(params) {
 	}
 	const scriptPath = resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js");
 	params.log?.("matrix: bootstrapping native crypto runtime");
-	const result = await runFixedCommandWithTimeout({
-		argv: [process.execPath, scriptPath],
-		cwd: path.dirname(scriptPath),
-		timeoutMs: 3e5,
-		env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" }
-	});
-	if (result.code !== 0) {
-		removeIncompleteMatrixCryptoNativeBinding({
-			bindingPath: nativeBindingPath,
-			log: params.log
+	let failure;
+	try {
+		const result = await runCommandWithTimeout([process.execPath, scriptPath], {
+			cwd: path.dirname(scriptPath),
+			env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" },
+			killProcessTree: true,
+			maxOutputBytes: MATRIX_COMMAND_OUTPUT_TAIL_BYTES,
+			outputCapture: "tail",
+			timeoutMs: 3e5
 		});
-		throw new Error(result.stderr.trim() || result.stdout.trim() || "Matrix crypto runtime bootstrap failed.");
+		const timedOut = result.termination === "timeout";
+		if (timedOut || (result.code ?? 1) !== 0) failure = (result.stderr || (timedOut ? "command timed out after 300000ms" : "")).trim() || result.stdout.trim();
+	} catch (error) {
+		failure = (error instanceof Error ? error.message : String(error)).trim();
 	}
 	removeIncompleteMatrixCryptoNativeBinding({
 		bindingPath: nativeBindingPath,
 		log: params.log
 	});
+	if (failure !== void 0) throw new Error(failure || "Matrix crypto runtime bootstrap failed.");
 	requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
 }
 async function ensureMatrixSdkInstalled(params) {

package/dist/.setup/{device-health-U-yoVjPw.mjs → device-health-Be60VF1w.mjs}

@@ -1,4 +1,4 @@
-import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 //#region extensions/matrix/src/matrix/device-health.ts
 var device_health_exports = /* @__PURE__ */ __exportAll({
 	isOpenClawManagedMatrixDevice: () => isOpenClawManagedMatrixDevice,

package/dist/.setup/{direct-management-Cn2t8n1V.mjs → direct-management-DJtQhLKH.mjs}

@@ -1,4 +1,4 @@
-import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
 import { a as MATRIX_REACTION_EVENT_TYPE, i as MATRIX_ANNOTATION_RELATION_TYPE } from "./send-currentness-C2rMVVIQ.mjs";
 import { asOptionalRecord, normalizeNullableString, normalizeOptionalString, normalizeTrimmedStringList, normalizeUniqueTrimmedStringList, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -128,12 +128,8 @@ var direct_management_exports = /* @__PURE__ */ __exportAll({
 const DIRECT_ACCOUNT_DATA_QUEUE_KEY = EventType.Direct;
 const directAccountDataWriteQueues = /* @__PURE__ */ new WeakMap();
 async function readMatrixDirectAccountData(client) {
-	try {
-		const direct = await client.getAccountData(EventType.Direct);
-		return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
-	} catch {
-		return {};
-	}
+	const direct = await client.getAccountData(EventType.Direct);
+	return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
 }
 function normalizeRemoteUserId(remoteUserId) {
 	const normalized = normalizeOptionalString(remoteUserId) ?? "";
@@ -234,7 +230,7 @@ async function promoteMatrixDirectRoomCandidate(params) {
 async function inspectMatrixDirectRooms(params) {
 	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
 	const selfUserId = normalizeOptionalString(await params.client.getUserId().catch(() => null)) ?? null;
-	const directContent = await readMatrixDirectAccountData(params.client);
+	const directContent = await readMatrixDirectAccountData(params.client).catch(() => ({}));
 	const mappedRoomIds = normalizeUniqueTrimmedStringList(directContent[remoteUserId]);
 	const mappedRooms = await Promise.all(mappedRoomIds.map(async (roomId) => await classifyDirectRoomCandidate({
 		client: params.client,

package/dist/.setup/{directory-live-_sw-Q7KO.mjs → directory-live-DW5UykLL.mjs}

@@ -1,7 +1,7 @@
-import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
-import { u as resolveMatrixAuth } from "./client-Ccv77kwh.mjs";
-import { t as MatrixAuthedHttpClient } from "./http-client-C1XvVD3K.mjs";
+import { u as resolveMatrixAuth } from "./client-kmih04ng.mjs";
+import { t as MatrixAuthedHttpClient } from "./http-client-DfJY5Ck0.mjs";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({