@openclaw/matrix 2026.7.2-beta.7 → 2026.7.34

package/dist/{env-auth-CQsYbz-p.js → .setup/env-auth-CYJL1jNl.mjs}

@@ -1,4 +1,4 @@
-import { t as getMatrixScopedEnvVarNames } from "./env-vars-B0NxQnPk.js";
+import { t as getMatrixScopedEnvVarNames } from "./env-vars-KzaYveuy.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/client/env-auth.ts
 function cleanEnv(value) {
@@ -60,4 +60,4 @@ function resolveMatrixEnvAuthReadiness(accountId, env = process.env) {
 	};
 }
 //#endregion
-export { resolveScopedMatrixEnvConfig as i, resolveGlobalMatrixEnvConfig as n, resolveMatrixEnvAuthReadiness as r, hasReadyMatrixEnvAuth as t };
+export { resolveMatrixEnvAuthReadiness as n, resolveScopedMatrixEnvConfig as r, resolveGlobalMatrixEnvConfig as t };

package/dist/{env-vars-B0NxQnPk.js → .setup/env-vars-KzaYveuy.mjs}

@@ -54,9 +54,7 @@ function listMatrixEnvAccountIds(env = process.env) {
 	for (const key of Object.keys(env)) {
 		const match = MATRIX_SCOPED_ENV_RE.exec(key);
 		if (!match) continue;
-		const encodedAccountId = match[1];
-		if (!encodedAccountId) continue;
-		const accountId = decodeMatrixEnvAccountToken(encodedAccountId);
+		const accountId = decodeMatrixEnvAccountToken(match[1]);
 		if (accountId) ids.add(accountId);
 	}
 	return Array.from(ids).toSorted((a, b) => a.localeCompare(b));

package/dist/{exec-approval-resolver-BCgqRtZS.js → .setup/exec-approval-resolver-f9j6staN.mjs}

@@ -2,10 +2,9 @@ import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 //#region extensions/matrix/src/exec-approval-resolver.ts
 async function resolveMatrixApproval(params) {
-	return await resolveApprovalOverGateway({
+	await resolveApprovalOverGateway({
 		cfg: params.cfg,
 		approvalId: params.approvalId,
-		approvalKind: params.approvalKind,
 		decision: params.decision,
 		senderId: params.senderId,
 		gatewayUrl: params.gatewayUrl,

package/dist/{file-sync-store-DiiFsayX.js → .setup/file-sync-store-DU0cnYAz.mjs}

@@ -1,30 +1,14 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as isRecord } from "./record-shared-CWWx6fvI.js";
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { M as resolveMatrixSqliteStateEnv, t as claimCurrentTokenStorageState } from "./storage-BvAkgzvT.js";
-import { n as LogService } from "./logger-D0GCSDQq.js";
-import { createHash, randomUUID } from "node:crypto";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { o as isRecord } from "./account-selection-BOQeTqax.mjs";
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
+import { O as resolveMatrixSqliteStateEnv } from "./crypto-state-store-B43k3z3W.mjs";
+import { t as claimCurrentTokenStorageState } from "./storage-NGZq5zet.mjs";
+import { t as createAsyncLock } from "./async-lock-BcLS4KOc.mjs";
+import { n as LogService } from "./logger-DpoogOgz.mjs";
 import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import { Category, MemoryStore, SyncAccumulator } from "matrix-js-sdk/lib/matrix.js";
-//#region extensions/matrix/src/matrix/async-lock.ts
-function createAsyncLock() {
-	let lock = Promise.resolve();
-	return async function withLock(fn) {
-		const previous = lock;
-		let release;
-		lock = new Promise((resolve) => {
-			release = resolve;
-		});
-		await previous;
-		try {
-			return await fn();
-		} finally {
-			release?.();
-		}
-	};
-}
-//#endregion
 //#region extensions/matrix/src/matrix/client/file-sync-store.ts
 var file_sync_store_exports = /* @__PURE__ */ __exportAll({
 	SqliteBackedMatrixSyncStore: () => SqliteBackedMatrixSyncStore,
@@ -37,7 +21,7 @@ const STORE_VERSION = 1;
 const PERSIST_DEBOUNCE_MS = 250;
 const SYNC_CACHE_NAMESPACE = "sync-cache";
 const SYNC_CACHE_MAX_ENTRIES = 2e4;
-const SYNC_CACHE_MAX_CHUNKS = Math.floor((SYNC_CACHE_MAX_ENTRIES - 1) / 2);
+const SYNC_CACHE_MAX_CHUNKS = Math.floor(19999 / 2);
 const SYNC_CACHE_STATE_KEY = "current";
 const SYNC_CACHE_CHUNK_BYTES = 24e3;
 function normalizeRoomsData(value) {
@@ -108,6 +92,7 @@ var SqliteBackedMatrixSyncStore = class extends MemoryStore {
 		this.savedSync = null;
 		this.cleanShutdown = false;
 		this.dirty = false;
+		this.frozen = false;
 		this.persistTimer = null;
 		this.persistPromise = null;
 		this.stateKey = SYNC_CACHE_STATE_KEY;
@@ -154,6 +139,7 @@ var SqliteBackedMatrixSyncStore = class extends MemoryStore {
 		return Promise.resolve(this.savedSync?.nextBatch ?? null);
 	}
 	setSyncData(syncData) {
+		if (this.frozen) return Promise.resolve();
 		this.accumulator.accumulate(syncData);
 		this.savedSync = this.accumulator.getJSON();
 		this.markDirtyAndSchedulePersist();
@@ -163,6 +149,7 @@ var SqliteBackedMatrixSyncStore = class extends MemoryStore {
 		return Promise.resolve(this.savedClientOptions ? cloneJson(this.savedClientOptions) : void 0);
 	}
 	storeClientOptions(options) {
+		if (this.frozen) return Promise.resolve();
 		this.savedClientOptions = cloneJson(options);
 		super.storeClientOptions(options);
 		this.markDirtyAndSchedulePersist();
@@ -195,6 +182,23 @@ var SqliteBackedMatrixSyncStore = class extends MemoryStore {
 		this.cleanShutdown = true;
 		this.dirty = true;
 	}
+	async freezeSyncCursorPersistence() {
+		this.frozen = true;
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		await this.persistPromise;
+	}
+	discardPendingSyncCursorPersistence() {
+		this.frozen = true;
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		this.cleanShutdown = false;
+		this.dirty = false;
+	}
 	async flush() {
 		if (this.persistTimer) {
 			clearTimeout(this.persistTimer);
@@ -208,6 +212,7 @@ var SqliteBackedMatrixSyncStore = class extends MemoryStore {
 		}
 	}
 	markDirtyAndSchedulePersist() {
+		if (this.frozen) return;
 		this.cleanShutdown = false;
 		this.dirty = true;
 		if (this.persistTimer) return;

package/dist/{http-client-CycYxU9-.js → .setup/http-client-C954In2D.mjs}

@@ -1,39 +1,48 @@
-import { t as buildTimeoutAbortSignal } from "./timeout-abort-signal-DMrgRFIy.js";
-import { parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
+import { t as buildTimeoutAbortSignal } from "./timeout-abort-signal-DMrgRFIy.mjs";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
 import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-dispatcher";
 //#region extensions/matrix/src/matrix/sdk/event-helpers.ts
 function matrixEventToRaw(event, opts = {}) {
-	const originalContent = event.getOriginalContent();
-	const content = opts.contentMode === "original" ? originalContent : event.getContent();
-	const relation = originalContent["m.relates_to"] || event.getWireContent()["m.relates_to"];
-	const normalizedContent = relation && !Object.hasOwn(content, "m.relates_to") ? {
-		...content,
-		"m.relates_to": relation
-	} : content;
+	const unsigned = event.getUnsigned?.() ?? {};
+	const eventWithOriginalContent = event;
+	const normalizedContent = preserveMatrixRelation(event, (opts.contentMode === "original" ? eventWithOriginalContent.getOriginalContent?.() ?? event.getContent?.() ?? {} : event.getContent?.() ?? eventWithOriginalContent.getOriginalContent?.() ?? {}) || {});
 	const raw = {
 		event_id: event.getId() ?? "",
 		sender: event.getSender() ?? "",
 		type: event.getType() ?? "",
 		origin_server_ts: event.getTs() ?? 0,
 		content: normalizedContent,
-		unsigned: event.getUnsigned()
+		unsigned
 	};
-	const stateKey = event.getStateKey() ?? event.getWireStateKey();
+	const stateKey = resolveMatrixStateKey(event);
 	if (typeof stateKey === "string") raw.state_key = stateKey;
 	return raw;
 }
+function preserveMatrixRelation(event, content) {
+	if (Object.hasOwn(content, "m.relates_to")) return content;
+	const relation = resolveMatrixRelation(event);
+	return relation ? {
+		...content,
+		"m.relates_to": relation
+	} : content;
+}
+function resolveMatrixRelation(event) {
+	const originalRelation = (event.getOriginalContent?.())?.["m.relates_to"];
+	if (originalRelation) return originalRelation;
+	const wireRelation = (event.getWireContent?.())?.["m.relates_to"];
+	if (wireRelation) return wireRelation;
+	const rawContent = event.event?.content;
+	if (rawContent && typeof rawContent === "object") return rawContent["m.relates_to"];
+}
 function parseMxc(url) {
 	const match = /^mxc:\/\/([^/]+)\/(.+)$/.exec(url.trim());
 	if (!match) return null;
-	const server = match[1];
-	const mediaId = match[2];
-	if (!server || !mediaId) return null;
 	return {
-		server,
-		mediaId
+		server: match[1],
+		mediaId: match[2]
 	};
 }
 function buildHttpError(statusCode, bodyText) {
@@ -47,6 +56,14 @@ function buildHttpError(statusCode, bodyText) {
 	}
 	return Object.assign(new Error(message), { statusCode });
 }
+function resolveMatrixStateKey(event) {
+	const direct = event.getStateKey?.();
+	if (typeof direct === "string") return direct;
+	const wireContent = event.getWireContent?.();
+	if (wireContent && typeof wireContent.state_key === "string") return wireContent.state_key;
+	const rawEvent = event.event;
+	if (rawEvent && typeof rawEvent.state_key === "string") return rawEvent.state_key;
+}
 //#endregion
 //#region extensions/matrix/src/matrix/media-errors.ts
 const MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE = "Matrix media exceeds configured size limit";
@@ -72,8 +89,8 @@ async function readResponseWithLimit$1(res, maxBytes, opts) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/sdk/transport.ts
-const MATRIX_JSON_RESPONSE_MAX_BYTES = 8 * 1024 * 1024;
-const MATRIX_SDK_RESPONSE_MAX_BYTES = 64 * 1024 * 1024;
+const MATRIX_JSON_RESPONSE_MAX_BYTES = 8388608;
+const MATRIX_SDK_RESPONSE_MAX_BYTES = 67108864;
 function normalizeEndpoint(endpoint) {
 	if (!endpoint) return "/";
 	return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
@@ -160,7 +177,8 @@ async function fetchWithMatrixGuardedRedirects(params) {
 	for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
 		let dispatcher;
 		try {
-			dispatcher = createPinnedDispatcher(await resolvePinnedHostnameWithPolicy(currentUrl.hostname, { policy: params.ssrfPolicy }), params.dispatcherPolicy, params.ssrfPolicy);
+			const pinned = await resolvePinnedHostnameWithPolicy(currentUrl.hostname, { policy: params.ssrfPolicy });
+			dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.ssrfPolicy);
 			const response = await fetchWithMatrixDispatcher({
 				url: currentUrl.toString(),
 				init: {
@@ -211,7 +229,7 @@ async function fetchWithMatrixGuardedRedirects(params) {
 				headers.delete("content-type");
 				headers.delete("content-length");
 			}
-			response.body?.cancel().catch(() => void 0);
+			response.body?.cancel();
 			await closeDispatcher(dispatcher);
 			currentUrl = nextUrl;
 		} catch (error) {
@@ -260,10 +278,12 @@ async function performMatrixRequest(params) {
 	headers.set("Accept", params.raw ? "*/*" : "application/json");
 	if (params.accessToken) headers.set("Authorization", `Bearer ${params.accessToken}`);
 	let body;
-	if (params.body !== void 0) if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") body = params.body;
-	else {
-		headers.set("Content-Type", "application/json");
-		body = JSON.stringify(params.body);
+	if (params.body !== void 0) {
+		if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") body = params.body;
+		else {
+			headers.set("Content-Type", "application/json");
+			body = JSON.stringify(params.body);
+		}
 	}
 	const { response, release } = await fetchWithMatrixGuardedRedirects({
 		url: baseUrl.toString(),
@@ -337,7 +357,7 @@ var MatrixAuthedHttpClient = class {
 			allowAbsoluteEndpoint: params.allowAbsoluteEndpoint
 		});
 		if (!response.ok) throw buildHttpError(response.status, text);
-		if ((response.headers.get("content-type") ?? "").split(";", 1)[0]?.trim().toLowerCase() === "application/json") {
+		if ((response.headers.get("content-type") ?? "").includes("application/json")) {
 			if (!text.trim()) return {};
 			try {
 				return JSON.parse(text);

package/dist/{idb-persistence-B6x7dMsF.js → .setup/idb-persistence-_HKTXkVC.mjs}

@@ -1,25 +1,17 @@
-import { D as writeMatrixIdbSnapshotJson, f as MATRIX_IDB_SNAPSHOT_FILENAME, w as readMatrixIdbSnapshotJson } from "./storage-BvAkgzvT.js";
-import { n as LogService } from "./logger-D0GCSDQq.js";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-DAJ49nZX.js";
-import path from "node:path";
-import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { g as readMatrixIdbSnapshotJson, t as MATRIX_IDB_SNAPSHOT_FILENAME, x as writeMatrixIdbSnapshotJson } from "./crypto-state-store-B43k3z3W.mjs";
+import { n as LogService } from "./logger-DpoogOgz.mjs";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.mjs";
 import fs from "node:fs";
-import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+import path from "node:path";
 import { indexedDB } from "fake-indexeddb";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
 //#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: "openclaw doctor --fix"
-};
-var MatrixIdbSnapshotMigrationRequiredError = class extends Error {
-	constructor() {
-		super(`${LEGACY_SNAPSHOT_DIAGNOSTIC.message}; run ${LEGACY_SNAPSHOT_DIAGNOSTIC.remediation}`);
-		this.code = LEGACY_SNAPSHOT_DIAGNOSTIC.code;
-		this.remediation = LEGACY_SNAPSHOT_DIAGNOSTIC.remediation;
-		this.name = "MatrixIdbSnapshotMigrationRequiredError";
-	}
-};
+var idb_persistence_exports = /* @__PURE__ */ __exportAll({
+	persistIdbToDisk: () => persistIdbToDisk,
+	readLegacyMatrixIdbSnapshotState: () => readLegacyMatrixIdbSnapshotState,
+	restoreIdbFromDisk: () => restoreIdbFromDisk
+});
 function isValidIdbIndexSnapshot(value) {
 	if (!value || typeof value !== "object") return false;
 	const candidate = value;
@@ -46,17 +38,10 @@ function parseSnapshotPayload(data) {
 	if (!parsed.every((entry) => isValidIdbDatabaseSnapshot(entry))) throw new Error("Malformed IndexedDB snapshot payload");
 	return parsed;
 }
-function isValidMatrixIdbSnapshotJson(data) {
-	try {
-		return parseSnapshotPayload(data) !== null;
-	} catch {
-		return false;
-	}
-}
 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 });
+		req.addEventListener("error", () => reject(toLintErrorObject(req.error, "Non-Error rejection")), { once: true });
 	});
 }
 async function dumpIndexedDatabases(databasePrefix) {
@@ -70,7 +55,7 @@ async function dumpIndexedDatabases(databasePrefix) {
 		const db = await new Promise((resolve, reject) => {
 			const r = idb.open(name, version);
 			r.addEventListener("success", () => resolve(r.result), { once: true });
-			r.addEventListener("error", () => reject(toErrorObject(r.error, "Non-Error rejection")), { once: true });
+			r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
 		});
 		const stores = [];
 		for (const storeName of db.objectStoreNames) {
@@ -142,7 +127,7 @@ async function restoreIndexedDatabases(snapshot) {
 				resolve();
 			})().catch(reject);
 		}, { once: true });
-		r.addEventListener("error", () => reject(toErrorObject(r.error, "Non-Error rejection")), { once: true });
+		r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
 	});
 }
 function resolveDefaultIdbSnapshotPath() {
@@ -150,83 +135,96 @@ function resolveDefaultIdbSnapshotPath() {
 	return path.join(stateDir, "matrix", "crypto-idb-snapshot.json");
 }
 async function restoreIdbFromDisk(snapshotPath) {
-	const resolvedPath = snapshotPath ?? resolveDefaultIdbSnapshotPath();
-	const storageRootDir = path.dirname(resolvedPath);
-	let callbackStarted = false;
-	try {
-		return await withFileLock(resolvedPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
-			callbackStarted = true;
-			let storedSnapshotJson;
-			try {
-				storedSnapshotJson = readMatrixIdbSnapshotJson(storageRootDir);
-			} catch (err) {
-				if (fs.existsSync(resolvedPath)) throwLegacySnapshotMigrationRequired();
-				throw err;
-			}
-			throwIfLegacySnapshotNeedsDoctor(resolvedPath, storedSnapshotJson);
-			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;
+	const candidatePaths = snapshotPath ? [snapshotPath] : [resolveDefaultIdbSnapshotPath()];
+	for (const resolvedPath of candidatePaths) {
+		const storageRootDir = path.dirname(resolvedPath);
+		try {
+			if (await withFileLock(resolvedPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+				try {
+					const storedSnapshotJson = readMatrixIdbSnapshotJson(storageRootDir);
+					if (storedSnapshotJson) {
+						const snapshot = parseSnapshotPayload(storedSnapshotJson);
+						if (snapshot) {
+							await restoreIndexedDatabases(snapshot);
+							LogService.info("IdbPersistence", `Restored ${snapshot.length} IndexedDB database(s) from Matrix SQLite state`);
+							return true;
+						}
+					}
+				} catch (err) {
+					LogService.warn("IdbPersistence", "Failed to restore IndexedDB snapshot from SQLite:", err);
+				}
+				if (!fs.existsSync(resolvedPath)) return false;
+				const data = fs.readFileSync(resolvedPath, "utf8");
+				const snapshot = parseSnapshotPayload(data);
+				if (!snapshot) return false;
+				let migratedToSqlite = false;
+				try {
+					writeMatrixIdbSnapshotJson({
+						storageRootDir,
+						snapshotJson: data,
+						databaseCount: snapshot.length
+					});
+					archiveLegacyIdbSnapshotFile(resolvedPath);
+					migratedToSqlite = true;
+				} catch (err) {
+					LogService.warn("IdbPersistence", `Failed to migrate IndexedDB snapshot to SQLite from ${resolvedPath}:`, err);
+				}
+				await restoreIndexedDatabases(snapshot);
+				LogService.info("IdbPersistence", migratedToSqlite ? `Migrated and restored ${snapshot.length} IndexedDB database(s) from ${resolvedPath}` : `Restored ${snapshot.length} IndexedDB database(s) from legacy snapshot ${resolvedPath}`);
+				return true;
+			})) return true;
+		} catch (err) {
+			LogService.warn("IdbPersistence", `Failed to restore IndexedDB snapshot from ${resolvedPath}:`, err);
+			continue;
+		}
 	}
+	return false;
 }
 async function persistIdbToDisk(params) {
 	const snapshotPath = params?.snapshotPath ?? resolveDefaultIdbSnapshotPath();
-	let callbackStarted = false;
 	try {
 		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);
-			let storedSnapshotJson;
-			try {
-				storedSnapshotJson = readMatrixIdbSnapshotJson(storageRootDir);
-			} catch (err) {
-				if (fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
-				throw err;
-			}
-			throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson);
 			const snapshot = await dumpIndexedDatabases(params?.databasePrefix);
 			if (snapshot.length === 0) return 0;
 			writeMatrixIdbSnapshotJson({
-				storageRootDir,
+				storageRootDir: path.dirname(snapshotPath),
 				snapshotJson: JSON.stringify(snapshot),
 				databaseCount: snapshot.length
 			});
+			archiveLegacyIdbSnapshotFile(snapshotPath);
 			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 readLegacyMatrixIdbSnapshotStateUnlocked(storageRootDir) {
+async function readLegacyMatrixIdbSnapshotState(storageRootDir) {
 	const snapshotPath = path.join(storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
 	if (!fs.existsSync(snapshotPath)) return null;
-	const data = fs.readFileSync(snapshotPath, "utf8");
 	try {
-		return parseSnapshotPayload(data);
+		return await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			return parseSnapshotPayload(fs.readFileSync(snapshotPath, "utf8"));
+		});
 	} catch {
 		return null;
 	}
 }
-function throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson) {
-	if (fs.existsSync(snapshotPath) && (!storedSnapshotJson || !isValidMatrixIdbSnapshotJson(storedSnapshotJson))) throwLegacySnapshotMigrationRequired();
+function archiveLegacyIdbSnapshotFile(snapshotPath) {
+	if (!fs.existsSync(snapshotPath)) return;
+	const archivedPath = `${snapshotPath}.migrated`;
+	if (fs.existsSync(archivedPath)) return;
+	fs.renameSync(snapshotPath, archivedPath);
 }
-function throwLegacySnapshotMigrationRequired() {
-	LogService.warn("IdbPersistence", LEGACY_SNAPSHOT_DIAGNOSTIC);
-	throw new MatrixIdbSnapshotMigrationRequiredError();
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
 }
 //#endregion
-export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotStateUnlocked as r, isValidMatrixIdbSnapshotJson as t };
+export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotState as r, idb_persistence_exports as t };

package/dist/{idb-persistence-lock-DAJ49nZX.js → .setup/idb-persistence-lock-B3fZXyF_.mjs}

@@ -1,6 +1,6 @@
 //#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
 const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
-const IDB_SNAPSHOT_LOCK_STALE_MS = 5 * 6e4;
+const IDB_SNAPSHOT_LOCK_STALE_MS = 3e5;
 const IDB_SNAPSHOT_LOCK_RETRY_BASE = {
 	factor: 2,
 	minTimeout: 50,

package/dist/.setup/legacy-crypto-inspector-Byp8LCys.mjs

@@ -0,0 +1,42 @@
+import { t as ensureMatrixCryptoRuntime } from "./deps-Dy6yreL4.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region extensions/matrix/src/matrix/legacy-crypto-inspector.ts
+const MATRIX_CRYPTO_STORE_SQLITE = 0;
+function resolveLegacyMachineStorePath(params) {
+	const hashedDir = path.join(params.cryptoRootDir, crypto.createHash("sha256").update(params.deviceId).digest("hex"));
+	if (fs.existsSync(path.join(hashedDir, "matrix-sdk-crypto.sqlite3"))) return hashedDir;
+	if (fs.existsSync(path.join(params.cryptoRootDir, "matrix-sdk-crypto.sqlite3"))) return params.cryptoRootDir;
+	const match = fs.readdirSync(params.cryptoRootDir, { withFileTypes: true }).find((entry) => entry.isDirectory() && fs.existsSync(path.join(params.cryptoRootDir, entry.name, "matrix-sdk-crypto.sqlite3")));
+	return match ? path.join(params.cryptoRootDir, match.name) : null;
+}
+async function inspectLegacyMatrixCryptoStore(params) {
+	const machineStorePath = resolveLegacyMachineStorePath(params);
+	if (!machineStorePath) throw new Error(`Matrix legacy crypto store not found for device ${params.deviceId}`);
+	const requireFn = createRequire(import.meta.url);
+	await ensureMatrixCryptoRuntime({
+		requireFn,
+		resolveFn: requireFn.resolve.bind(requireFn),
+		log: params.log
+	});
+	const { DeviceId, OlmMachine, UserId } = requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+	const machine = await OlmMachine.initialize(new UserId(params.userId), new DeviceId(params.deviceId), machineStorePath, "", MATRIX_CRYPTO_STORE_SQLITE);
+	try {
+		const [backupKeys, roomKeyCounts] = await Promise.all([machine.getBackupKeys(), machine.roomKeyCounts()]);
+		return {
+			deviceId: params.deviceId,
+			roomKeyCounts: roomKeyCounts ? {
+				total: typeof roomKeyCounts.total === "number" ? roomKeyCounts.total : 0,
+				backedUp: typeof roomKeyCounts.backedUp === "number" ? roomKeyCounts.backedUp : 0
+			} : null,
+			backupVersion: typeof backupKeys?.backupVersion === "string" && backupKeys.backupVersion.trim() ? backupKeys.backupVersion : null,
+			decryptionKeyBase64: typeof backupKeys?.decryptionKeyBase64 === "string" && backupKeys.decryptionKeyBase64.trim() ? backupKeys.decryptionKeyBase64 : null
+		};
+	} finally {
+		machine.close();
+	}
+}
+//#endregion
+export { inspectLegacyMatrixCryptoStore };

package/dist/.setup/legacy-crypto-restore-YQVoK1B2.mjs

@@ -0,0 +1,93 @@
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
+import { C as writeMatrixLegacyCryptoMigrationState, _ as readMatrixLegacyCryptoMigrationState, s as migrateLegacyMatrixLegacyCryptoMigrationFileToStore } from "./crypto-state-store-B43k3z3W.mjs";
+import { l as resolveMatrixStoragePaths } from "./storage-NGZq5zet.mjs";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region extensions/matrix/src/matrix/monitor/legacy-crypto-restore.ts
+async function resolvePendingMigrationStateRoot(params) {
+	const { rootDir } = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		stateDir: params.stateDir
+	});
+	try {
+		migrateLegacyMatrixLegacyCryptoMigrationFileToStore(rootDir);
+	} catch {}
+	const directValue = readMatrixLegacyCryptoMigrationState(rootDir);
+	if (directValue?.restoreStatus === "pending") return {
+		storageRootDir: rootDir,
+		value: directValue
+	};
+	const accountStorageDir = path.dirname(rootDir);
+	let siblingEntries;
+	try {
+		siblingEntries = (await fs.readdir(accountStorageDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((entry) => path.join(accountStorageDir, entry) !== rootDir).toSorted((left, right) => left.localeCompare(right));
+	} catch {
+		return {
+			storageRootDir: rootDir,
+			value: directValue
+		};
+	}
+	for (const sibling of siblingEntries) {
+		const siblingRootDir = path.join(accountStorageDir, sibling);
+		try {
+			migrateLegacyMatrixLegacyCryptoMigrationFileToStore(siblingRootDir);
+		} catch {}
+		const value = readMatrixLegacyCryptoMigrationState(siblingRootDir);
+		if (value?.restoreStatus === "pending") return {
+			storageRootDir: siblingRootDir,
+			value
+		};
+	}
+	return {
+		storageRootDir: rootDir,
+		value: directValue
+	};
+}
+async function maybeRestoreLegacyMatrixBackup(params) {
+	const env = params.env ?? process.env;
+	const { storageRootDir, value } = await resolvePendingMigrationStateRoot({
+		stateDir: params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir),
+		auth: params.auth
+	});
+	if (value?.restoreStatus !== "pending") return { kind: "skipped" };
+	const restore = await params.client.restoreRoomKeyBackup();
+	const localOnlyKeys = value.roomKeyCounts && value.roomKeyCounts.total > value.roomKeyCounts.backedUp ? value.roomKeyCounts.total - value.roomKeyCounts.backedUp : 0;
+	if (restore.success) {
+		writeMatrixLegacyCryptoMigrationState({
+			storageRootDir,
+			state: {
+				...value,
+				restoreStatus: "completed",
+				restoredAt: restore.restoredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+				importedCount: restore.imported,
+				totalCount: restore.total,
+				lastError: null
+			}
+		});
+		return {
+			kind: "restored",
+			imported: restore.imported,
+			total: restore.total,
+			localOnlyKeys
+		};
+	}
+	writeMatrixLegacyCryptoMigrationState({
+		storageRootDir,
+		state: {
+			...value,
+			lastError: restore.error ?? "unknown"
+		}
+	});
+	return {
+		kind: "failed",
+		error: restore.error ?? "unknown",
+		localOnlyKeys
+	};
+}
+//#endregion
+export { maybeRestoreLegacyMatrixBackup };

package/dist/{logger-D0GCSDQq.js → .setup/logger-DpoogOgz.mjs}

@@ -1,4 +1,4 @@
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
 import { format } from "node:util";
 import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
 //#region extensions/matrix/src/matrix/sdk/logger.ts