@openclaw/matrix 2026.6.5-beta.2 → 2026.6.5-beta.5

package/dist/file-sync-store-Ni-pkFde.js

@@ -0,0 +1,402 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { o as isRecord } from "./account-selection-Bv_ZuOu4.js";
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
+import { O as resolveMatrixSqliteStateEnv } from "./crypto-state-store-DK2tcEyP.js";
+import { t as claimCurrentTokenStorageState } from "./storage-C10h2piS.js";
+import { t as createAsyncLock } from "./async-lock-BcLS4KOc.js";
+import { n as LogService } from "./logger-D0GCSDQq.js";
+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/client/file-sync-store.ts
+var file_sync_store_exports = /* @__PURE__ */ __exportAll({
+	SqliteBackedMatrixSyncStore: () => SqliteBackedMatrixSyncStore,
+	hasMatrixSyncCacheStateInStore: () => hasMatrixSyncCacheStateInStore,
+	openMatrixSyncCacheStoreOptions: () => openMatrixSyncCacheStoreOptions,
+	readLegacyMatrixSyncCacheState: () => readLegacyMatrixSyncCacheState,
+	writeMatrixSyncCacheStateToStore: () => writeMatrixSyncCacheStateToStore
+});
+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_STATE_KEY = "current";
+const SYNC_CACHE_CHUNK_BYTES = 24e3;
+function normalizeRoomsData(value) {
+	if (!isRecord(value)) return null;
+	return {
+		[Category.Join]: isRecord(value[Category.Join]) ? value[Category.Join] : {},
+		[Category.Invite]: isRecord(value[Category.Invite]) ? value[Category.Invite] : {},
+		[Category.Leave]: isRecord(value[Category.Leave]) ? value[Category.Leave] : {},
+		[Category.Knock]: isRecord(value[Category.Knock]) ? value[Category.Knock] : {}
+	};
+}
+function toPersistedSyncData(value) {
+	if (!isRecord(value)) return null;
+	if (typeof value.nextBatch === "string" && value.nextBatch.trim()) {
+		const roomsData = normalizeRoomsData(value.roomsData);
+		if (!Array.isArray(value.accountData) || !roomsData) return null;
+		return {
+			nextBatch: value.nextBatch,
+			accountData: value.accountData,
+			roomsData
+		};
+	}
+	if (typeof value.next_batch === "string" && value.next_batch.trim()) {
+		const roomsData = normalizeRoomsData(value.rooms);
+		if (!roomsData) return null;
+		return {
+			nextBatch: value.next_batch,
+			accountData: isRecord(value.account_data) && Array.isArray(value.account_data.events) ? value.account_data.events : [],
+			roomsData
+		};
+	}
+	return null;
+}
+function normalizePersistedStore(value) {
+	if (!isRecord(value) || value.version !== STORE_VERSION) return null;
+	return {
+		version: STORE_VERSION,
+		savedSync: toPersistedSyncData(value.savedSync),
+		clientOptions: isRecord(value.clientOptions) ? value.clientOptions : void 0,
+		cleanShutdown: value.cleanShutdown === true
+	};
+}
+function normalizeLegacyPersistedStore(value) {
+	const persisted = normalizePersistedStore(value);
+	if (persisted) return persisted;
+	return {
+		version: STORE_VERSION,
+		savedSync: toPersistedSyncData(value),
+		cleanShutdown: false
+	};
+}
+function cloneJson(value) {
+	return structuredClone(value);
+}
+function syncDataToSyncResponse(syncData) {
+	return {
+		next_batch: syncData.nextBatch,
+		rooms: syncData.roomsData,
+		account_data: { events: syncData.accountData }
+	};
+}
+var SqliteBackedMatrixSyncStore = class extends MemoryStore {
+	constructor(storageRootDir) {
+		super();
+		this.storageRootDir = storageRootDir;
+		this.persistLock = createAsyncLock();
+		this.accumulator = new SyncAccumulator();
+		this.savedSync = null;
+		this.cleanShutdown = false;
+		this.dirty = false;
+		this.persistTimer = null;
+		this.persistPromise = null;
+		this.stateKey = resolveSyncCacheStateKey(storageRootDir);
+		let restoredSavedSync = null;
+		let restoredClientOptions;
+		let restoredCleanShutdown = false;
+		let syncCacheStore = createNoopMatrixSyncCacheStore();
+		let syncCacheStoreUnavailableError;
+		try {
+			syncCacheStore = openMatrixSyncCacheStore(storageRootDir);
+			const persisted = readPersistedStoreFromSyncStore(syncCacheStore, this.stateKey);
+			if (persisted) {
+				restoredSavedSync = persisted.savedSync;
+				restoredClientOptions = persisted.clientOptions;
+				restoredCleanShutdown = persisted.cleanShutdown === true;
+			}
+		} catch (err) {
+			syncCacheStoreUnavailableError = err;
+			LogService.warn("MatrixSyncCacheStore", "Failed to load Matrix sync cache:", err);
+		}
+		this.store = syncCacheStore;
+		this.storeUnavailableError = syncCacheStoreUnavailableError;
+		this.savedSync = restoredSavedSync;
+		this.savedClientOptions = restoredClientOptions;
+		this.hadSavedSyncOnLoad = restoredSavedSync !== null;
+		this.hadCleanShutdownOnLoad = this.hadSavedSyncOnLoad && restoredCleanShutdown;
+		this.cleanShutdown = this.hadCleanShutdownOnLoad;
+		if (this.savedSync) {
+			this.accumulator.accumulate(syncDataToSyncResponse(this.savedSync), true);
+			super.setSyncToken(this.savedSync.nextBatch);
+		}
+		if (this.savedClientOptions) super.storeClientOptions(this.savedClientOptions);
+	}
+	hasSavedSync() {
+		return this.hadSavedSyncOnLoad;
+	}
+	hasSavedSyncFromCleanShutdown() {
+		return this.hadCleanShutdownOnLoad;
+	}
+	getSavedSync() {
+		return Promise.resolve(this.savedSync ? cloneJson(this.savedSync) : null);
+	}
+	getSavedSyncToken() {
+		return Promise.resolve(this.savedSync?.nextBatch ?? null);
+	}
+	setSyncData(syncData) {
+		this.accumulator.accumulate(syncData);
+		this.savedSync = this.accumulator.getJSON();
+		this.markDirtyAndSchedulePersist();
+		return Promise.resolve();
+	}
+	getClientOptions() {
+		return Promise.resolve(this.savedClientOptions ? cloneJson(this.savedClientOptions) : void 0);
+	}
+	storeClientOptions(options) {
+		this.savedClientOptions = cloneJson(options);
+		super.storeClientOptions(options);
+		this.markDirtyAndSchedulePersist();
+		return Promise.resolve();
+	}
+	save(force = false) {
+		if (force) return this.flush();
+		return Promise.resolve();
+	}
+	wantsSave() {
+		return false;
+	}
+	async deleteAllData() {
+		this.assertStoreAvailable();
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		this.dirty = false;
+		await this.persistPromise?.catch(() => void 0);
+		await super.deleteAllData();
+		this.savedSync = null;
+		this.savedClientOptions = void 0;
+		this.cleanShutdown = false;
+		this.store.delete(metaKey(this.stateKey));
+		for (const row of this.store.entries()) if (row.key.startsWith(chunkKeyPrefix(this.stateKey))) this.store.delete(row.key);
+		await fs.rm(resolveLegacySyncCachePath(this.storageRootDir), { force: true }).catch(() => void 0);
+	}
+	markCleanShutdown() {
+		this.cleanShutdown = true;
+		this.dirty = true;
+	}
+	async flush() {
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		while (this.dirty || this.persistPromise) {
+			if (this.dirty && !this.persistPromise) this.persistPromise = this.persist().finally(() => {
+				this.persistPromise = null;
+			});
+			await this.persistPromise;
+		}
+	}
+	markDirtyAndSchedulePersist() {
+		this.cleanShutdown = false;
+		this.dirty = true;
+		if (this.persistTimer) return;
+		this.persistTimer = setTimeout(() => {
+			this.persistTimer = null;
+			this.flush().catch((err) => {
+				LogService.warn("MatrixSyncCacheStore", "Failed to persist Matrix sync store:", err);
+			});
+		}, PERSIST_DEBOUNCE_MS);
+		this.persistTimer.unref?.();
+	}
+	async persist() {
+		this.assertStoreAvailable();
+		this.dirty = false;
+		const payload = {
+			version: STORE_VERSION,
+			savedSync: this.savedSync ? cloneJson(this.savedSync) : null,
+			cleanShutdown: this.cleanShutdown,
+			...this.savedClientOptions ? { clientOptions: cloneJson(this.savedClientOptions) } : {}
+		};
+		try {
+			await this.persistLock(async () => {
+				this.writePersistedStore(payload);
+				claimCurrentTokenStorageState({ rootDir: this.storageRootDir });
+			});
+		} catch (err) {
+			this.dirty = true;
+			throw err;
+		}
+	}
+	writePersistedStore(payload) {
+		const rows = buildSyncCacheRows(this.stateKey, payload);
+		for (const row of rows.chunks) this.store.register(row.key, row.value);
+		this.store.register(rows.meta.key, rows.meta.value);
+		for (const row of this.store.entries()) if (row.key.startsWith(chunkKeyPrefix(this.stateKey)) && !rows.nextChunkKeys.has(row.key)) this.store.delete(row.key);
+	}
+	assertStoreAvailable() {
+		if (this.storeUnavailableError == null) return;
+		throw new Error("Matrix sync cache SQLite store is unavailable; cannot persist sync state", { cause: this.storeUnavailableError });
+	}
+};
+function createNoopMatrixSyncCacheStore() {
+	return {
+		register: () => {},
+		registerIfAbsent: () => false,
+		lookup: () => void 0,
+		consume: () => void 0,
+		delete: () => false,
+		entries: () => [],
+		clear: () => {}
+	};
+}
+function readPersistedStoreFromSyncStore(store, stateKey) {
+	const meta = store.lookup(metaKey(stateKey));
+	if (!isSyncCacheMeta(meta)) return null;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = store.lookup(chunkKey(stateKey, meta.generation, index));
+		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return normalizePersistedStore({
+			version: STORE_VERSION,
+			savedSync: null,
+			clientOptions: meta.clientOptions,
+			cleanShutdown: false
+		});
+		chunks.push(chunk.data);
+	}
+	let savedSync = null;
+	if (chunks.length > 0) {
+		const syncJson = chunks.join("");
+		if (meta.syncDigest !== digestText(syncJson)) return normalizePersistedStore({
+			version: STORE_VERSION,
+			savedSync: null,
+			clientOptions: meta.clientOptions,
+			cleanShutdown: false
+		});
+		try {
+			savedSync = toPersistedSyncData(JSON.parse(syncJson));
+		} catch {
+			savedSync = null;
+		}
+	}
+	return normalizePersistedStore({
+		version: STORE_VERSION,
+		savedSync,
+		clientOptions: meta.clientOptions,
+		cleanShutdown: meta.cleanShutdown
+	});
+}
+function openMatrixSyncCacheStore(storageRootDir) {
+	return getMatrixRuntime().state.openSyncKeyedStore(openMatrixSyncCacheStoreOptions(storageRootDir));
+}
+function resolveSyncCacheStateKey(_storageRootDir) {
+	return SYNC_CACHE_STATE_KEY;
+}
+function metaKey(stateKey) {
+	return `${stateKey}:meta`;
+}
+function chunkKeyPrefix(stateKey) {
+	return `${stateKey}:sync:`;
+}
+function chunkKey(stateKey, generation, index) {
+	return `${chunkKeyPrefix(stateKey)}${generation}:${index}`;
+}
+function resolveLegacySyncCachePath(storageRootDir) {
+	return path.join(storageRootDir, "bot-storage.json");
+}
+function digestText(value) {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function isSyncCacheMeta(value) {
+	return isRecord(value) && value.kind === "meta" && value.version === STORE_VERSION && typeof value.generation === "string" && value.generation.trim() !== "" && typeof value.chunkCount === "number" && Number.isSafeInteger(value.chunkCount) && value.chunkCount >= 0 && value.chunkCount <= SYNC_CACHE_MAX_CHUNKS;
+}
+function isSyncCacheChunk(value) {
+	return isRecord(value) && value.kind === "sync-chunk" && typeof value.index === "number" && Number.isSafeInteger(value.index) && value.index >= 0 && typeof value.data === "string";
+}
+function chunkSyncCacheJson(value) {
+	const chunks = [];
+	const pushChunk = (chunk) => {
+		if (chunks.length >= SYNC_CACHE_MAX_CHUNKS) throw new Error("Matrix sync cache exceeds SQLite chunk limit");
+		chunks.push(chunk);
+	};
+	let current = "";
+	let currentBytes = 0;
+	for (const char of value) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current && currentBytes + charBytes > SYNC_CACHE_CHUNK_BYTES) {
+			pushChunk(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current) pushChunk(current);
+	return chunks;
+}
+function buildSyncCacheRows(stateKey, payload) {
+	const generation = randomUUID().replaceAll("-", "");
+	const syncJson = payload.savedSync ? JSON.stringify(payload.savedSync) : "";
+	const chunks = (syncJson ? chunkSyncCacheJson(syncJson) : []).map((data, index) => ({
+		key: chunkKey(stateKey, generation, index),
+		value: {
+			kind: "sync-chunk",
+			index,
+			data
+		}
+	}));
+	return {
+		chunks,
+		nextChunkKeys: new Set(chunks.map((chunk) => chunk.key)),
+		meta: {
+			key: metaKey(stateKey),
+			value: {
+				kind: "meta",
+				version: STORE_VERSION,
+				generation,
+				chunkCount: chunks.length,
+				...syncJson ? { syncDigest: digestText(syncJson) } : {},
+				...payload.clientOptions ? { clientOptions: payload.clientOptions } : {},
+				cleanShutdown: payload.cleanShutdown === true
+			}
+		}
+	};
+}
+async function readLegacyMatrixSyncCacheState(storageRootDir) {
+	try {
+		const raw = await fs.readFile(resolveLegacySyncCachePath(storageRootDir), "utf8");
+		const persisted = normalizeLegacyPersistedStore(JSON.parse(raw));
+		if (!persisted?.savedSync && !persisted?.clientOptions) return null;
+		return persisted;
+	} catch {
+		return null;
+	}
+}
+async function hasMatrixSyncCacheStateInStore(params) {
+	const stateKey = resolveSyncCacheStateKey(params.storageRootDir);
+	const meta = await params.store.lookup(metaKey(stateKey));
+	if (!isSyncCacheMeta(meta) || meta.chunkCount <= 0) return false;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = await params.store.lookup(chunkKey(stateKey, meta.generation, index));
+		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return false;
+		chunks.push(chunk.data);
+	}
+	const syncJson = chunks.join("");
+	if (meta.syncDigest !== digestText(syncJson)) return false;
+	try {
+		return toPersistedSyncData(JSON.parse(syncJson)) !== null;
+	} catch {
+		return false;
+	}
+}
+async function writeMatrixSyncCacheStateToStore(params) {
+	const stateKey = resolveSyncCacheStateKey(params.storageRootDir);
+	const rows = buildSyncCacheRows(stateKey, params.payload);
+	for (const row of rows.chunks) await params.store.register(row.key, row.value);
+	await params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of await params.store.entries()) if (row.key.startsWith(chunkKeyPrefix(stateKey)) && !rows.nextChunkKeys.has(row.key)) await params.store.delete(row.key);
+}
+function openMatrixSyncCacheStoreOptions(storageRootDir) {
+	return {
+		namespace: SYNC_CACHE_NAMESPACE,
+		maxEntries: SYNC_CACHE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+//#endregion
+export { readLegacyMatrixSyncCacheState as a, openMatrixSyncCacheStoreOptions as i, file_sync_store_exports as n, writeMatrixSyncCacheStateToStore as o, hasMatrixSyncCacheStateInStore as r, SqliteBackedMatrixSyncStore as t };

package/dist/helper-api.js

@@ -1,4 +1,4 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId, i as resolveMatrixChannelConfig, n as requiresExplicitMatrixDefaultAccount, r as resolveConfiguredMatrixAccountIds, t as findMatrixAccountEntry } from "./account-selection-DEMtY2cn.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, i as resolveMatrixChannelConfig, n as requiresExplicitMatrixDefaultAccount, r as resolveConfiguredMatrixAccountIds, t as findMatrixAccountEntry } from "./account-selection-Bv_ZuOu4.js";
 import { n as listMatrixEnvAccountIds, r as resolveMatrixEnvAccountToken, t as getMatrixScopedEnvVarNames } from "./env-vars-KzaYveuy.js";
 import { a as resolveMatrixCredentialsPath, c as resolveMatrixLegacyFlatStoreRoot, i as resolveMatrixCredentialsFilename, l as sanitizeMatrixPathSegment, n as resolveMatrixAccountStorageRoot, o as resolveMatrixHomeserverKey, r as resolveMatrixCredentialsDir, s as resolveMatrixLegacyFlatStoragePaths, t as hashMatrixAccessToken } from "./storage-paths-BWo_ZEMC.js";
 export { findMatrixAccountEntry, getMatrixScopedEnvVarNames, hashMatrixAccessToken, listMatrixEnvAccountIds, requiresExplicitMatrixDefaultAccount, resolveConfiguredMatrixAccountIds, resolveMatrixAccountStorageRoot, resolveMatrixChannelConfig, resolveMatrixCredentialsDir, resolveMatrixCredentialsFilename, resolveMatrixCredentialsPath, resolveMatrixDefaultOrOnlyAccountId, resolveMatrixEnvAccountToken, resolveMatrixHomeserverKey, resolveMatrixLegacyFlatStoragePaths, resolveMatrixLegacyFlatStoreRoot, sanitizeMatrixPathSegment };

package/dist/idb-persistence-BGY1CJ7J.js

@@ -0,0 +1,229 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { g as readMatrixIdbSnapshotJson, t as MATRIX_IDB_SNAPSHOT_FILENAME, x as writeMatrixIdbSnapshotJson } from "./crypto-state-store-DK2tcEyP.js";
+import { n as LogService } from "./logger-D0GCSDQq.js";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-DAJ49nZX.js";
+import fs from "node:fs";
+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
+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;
+	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(toLintErrorObject(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 new Promise((resolve, reject) => {
+			const r = idb.open(name, version);
+			r.addEventListener("success", () => resolve(r.result), { once: true });
+			r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
+		});
+		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) await new Promise((resolve, reject) => {
+		const r = idb.open(dbSnap.name, dbSnap.version);
+		r.addEventListener("upgradeneeded", () => {
+			const db = r.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
+				});
+			}
+		});
+		r.addEventListener("success", () => {
+			(async () => {
+				const db = r.result;
+				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((res) => {
+						tx.addEventListener("complete", () => res(), { once: true });
+					});
+				}
+				db.close();
+				resolve();
+			})().catch(reject);
+		}, { once: true });
+		r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
+	});
+}
+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 restoreIdbFromDisk(snapshotPath) {
+	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();
+	try {
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		const persistedCount = await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			const snapshot = await dumpIndexedDatabases(params?.databasePrefix);
+			if (snapshot.length === 0) return 0;
+			writeMatrixIdbSnapshotJson({
+				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) {
+		LogService.warn("IdbPersistence", "Failed to persist IndexedDB snapshot:", err);
+	}
+}
+async function readLegacyMatrixIdbSnapshotState(storageRootDir) {
+	const snapshotPath = path.join(storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
+	if (!fs.existsSync(snapshotPath)) return null;
+	try {
+		return await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			return parseSnapshotPayload(fs.readFileSync(snapshotPath, "utf8"));
+		});
+	} catch {
+		return null;
+	}
+}
+function archiveLegacyIdbSnapshotFile(snapshotPath) {
+	if (!fs.existsSync(snapshotPath)) return;
+	const archivedPath = `${snapshotPath}.migrated`;
+	if (fs.existsSync(archivedPath)) return;
+	fs.renameSync(snapshotPath, archivedPath);
+}
+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, readLegacyMatrixIdbSnapshotState as r, idb_persistence_exports as t };

package/dist/idb-persistence-lock-DAJ49nZX.js

@@ -0,0 +1,32 @@
+//#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_RETRY_BASE = {
+	factor: 2,
+	minTimeout: 50,
+	maxTimeout: 5e3,
+	randomize: true
+};
+function computeRetryDelayMs(retries, attempt) {
+	return Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt));
+}
+function computeMinimumRetryWindowMs(retries) {
+	let total = 0;
+	const attempts = Math.max(1, retries.retries + 1);
+	for (let attempt = 0; attempt < attempts - 1; attempt += 1) total += computeRetryDelayMs(retries, attempt);
+	return total;
+}
+function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
+	const resolved = {
+		...retries,
+		retries: 0
+	};
+	while (computeMinimumRetryWindowMs(resolved) < minimumWindowMs) resolved.retries += 1;
+	return resolved;
+}
+const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
+	retries: resolveRetriesForMinimumWindowMs(IDB_SNAPSHOT_LOCK_RETRY_BASE, MATRIX_IDB_PERSIST_INTERVAL_MS),
+	stale: IDB_SNAPSHOT_LOCK_STALE_MS
+};
+//#endregion
+export { MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS as n, MATRIX_IDB_PERSIST_INTERVAL_MS as t };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerMatrixCliMetadata } from "./cli-metadata-CW6xSM2K.js";
+import { n as registerMatrixCliMetadata } from "./cli-metadata-C9_um_Yj.js";
 import { registerMatrixSubagentHooks } from "./subagent-hooks-api.js";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/matrix/index.ts