@openclaw/matrix 2026.9.5 → 2026.9.7

package/dist/.setup/http-client-C1XvVD3K.mjs

@@ -0,0 +1,362 @@
+import { t as buildHttpError } from "./event-helpers-CspuhE9k.mjs";
+import { PlatformMessageNotDispatchedError } from "openclaw/plugin-sdk/error-runtime";
+import { parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
+import { buildTimeoutAbortSignal } from "openclaw/plugin-sdk/extension-shared";
+import { captureChannelReadAuthority } from "openclaw/plugin-sdk/fetch-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/media-errors.ts
+const MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE = "Matrix media exceeds configured size limit";
+var MatrixMediaSizeLimitError = class extends Error {
+	constructor(message = MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE, options) {
+		super(message, options);
+		this.code = "MATRIX_MEDIA_SIZE_LIMIT";
+		this.name = "MatrixMediaSizeLimitError";
+	}
+};
+function isMatrixMediaSizeLimitError(err) {
+	if (err instanceof MatrixMediaSizeLimitError) return true;
+	if (!(err instanceof Error) || err.cause === void 0) return false;
+	return isMatrixMediaSizeLimitError(err.cause);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/transport.ts
+var MatrixSdkAuthorityError = class extends Error {
+	constructor(cause) {
+		super(cause instanceof Error ? cause.message : "Matrix request authority expired", { cause });
+		this.name = "AbortError";
+	}
+};
+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}`;
+}
+function applyQuery(url, qs) {
+	if (!qs) return;
+	for (const [key, rawValue] of Object.entries(qs)) {
+		if (rawValue === void 0 || rawValue === null) continue;
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) {
+				if (item === void 0 || item === null) continue;
+				url.searchParams.append(key, String(item));
+			}
+			continue;
+		}
+		url.searchParams.set(key, String(rawValue));
+	}
+}
+function isRedirectStatus(statusCode) {
+	return statusCode >= 300 && statusCode < 400;
+}
+function toFetchUrl(resource) {
+	if (resource instanceof URL) return resource.toString();
+	if (typeof resource === "string") return resource;
+	return resource.url;
+}
+const MATRIX_STATE_AFTER_SYNC_PARAM = "org.matrix.msc4222.use_state_after";
+function withoutMatrixStateAfterSyncParam(rawUrl) {
+	let url;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		return rawUrl;
+	}
+	if (!url.pathname.endsWith("/sync") || !url.searchParams.has(MATRIX_STATE_AFTER_SYNC_PARAM)) return rawUrl;
+	url.searchParams.delete(MATRIX_STATE_AFTER_SYNC_PARAM);
+	return url.toString();
+}
+function buildBufferedResponse(params) {
+	const response = new Response(params.body, {
+		status: params.source.status,
+		statusText: params.source.statusText,
+		headers: new Headers(params.source.headers)
+	});
+	try {
+		Object.defineProperty(response, "url", {
+			value: params.source.url || params.url,
+			configurable: true
+		});
+	} catch {}
+	return response;
+}
+async function enforceDeclaredResponseSize(params) {
+	const contentLength = params.response.headers.get("content-length");
+	if (!contentLength) return;
+	let length;
+	try {
+		length = parseMediaContentLength(contentLength);
+	} catch (error) {
+		await params.response.body?.cancel(error).catch(() => void 0);
+		throw error;
+	}
+	if (length === null || length <= params.maxBytes) return;
+	const error = params.createError(length);
+	await params.response.body?.cancel(error).catch(() => void 0);
+	throw error;
+}
+async function fetchWithMatrixGuardedRedirects(params) {
+	const assertDispatchCurrent = () => {
+		params.assertCurrent?.();
+		params.assertSendCurrent?.();
+	};
+	assertDispatchCurrent();
+	let currentUrl = new URL(params.url);
+	let method = (params.init?.method ?? "GET").toUpperCase();
+	let body = params.init?.body;
+	let headers = new Headers(params.init?.headers ?? {});
+	const maxRedirects = 5;
+	const visited = /* @__PURE__ */ new Set();
+	const { signal, cleanup } = buildTimeoutAbortSignal({
+		timeoutMs: params.timeoutMs,
+		signal: params.signal,
+		operation: "matrix.guarded-redirect-fetch",
+		url: params.url
+	});
+	let dispatched = false;
+	for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
+		let dispatcher;
+		try {
+			assertDispatchCurrent();
+			signal?.throwIfAborted();
+			const pinned = await resolvePinnedHostnameWithPolicy(currentUrl.hostname, {
+				policy: params.ssrfPolicy,
+				signal
+			});
+			dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.ssrfPolicy);
+			assertDispatchCurrent();
+			signal?.throwIfAborted();
+			await params.beforeDispatch?.();
+			const fetchUrl = currentUrl.toString();
+			const requestInit = {
+				...params.init,
+				method,
+				body,
+				headers,
+				redirect: "manual",
+				signal,
+				dispatcher
+			};
+			assertDispatchCurrent();
+			signal?.throwIfAborted();
+			dispatched = true;
+			const response = await fetchWithRuntimeDispatcherOrMockedGlobal(fetchUrl, requestInit);
+			if (!isRedirectStatus(response.status)) return {
+				response,
+				release: async () => {
+					cleanup();
+					await closeDispatcher(dispatcher);
+				},
+				finalUrl: currentUrl.toString()
+			};
+			const location = response.headers.get("location");
+			if (!location) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error(`Matrix redirect missing location header (${currentUrl.toString()})`);
+			}
+			const nextUrl = new URL(location, currentUrl);
+			if (nextUrl.protocol !== currentUrl.protocol) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error(`Blocked cross-protocol redirect (${currentUrl.protocol} -> ${nextUrl.protocol})`);
+			}
+			const nextUrlString = nextUrl.toString();
+			if (visited.has(nextUrlString)) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error("Redirect loop detected");
+			}
+			visited.add(nextUrlString);
+			if (nextUrl.origin !== currentUrl.origin) {
+				headers = new Headers(headers);
+				headers.delete("authorization");
+			}
+			if (response.status === 303 || (response.status === 301 || response.status === 302) && method !== "GET" && method !== "HEAD") {
+				method = "GET";
+				body = void 0;
+				headers = new Headers(headers);
+				headers.delete("content-type");
+				headers.delete("content-length");
+			}
+			response.body?.cancel().catch(() => void 0);
+			await closeDispatcher(dispatcher);
+			currentUrl = nextUrl;
+		} catch (error) {
+			cleanup();
+			await closeDispatcher(dispatcher);
+			if (!dispatched) {
+				if (error instanceof PlatformMessageNotDispatchedError) throw error;
+				const rejected = new PlatformMessageNotDispatchedError(error instanceof Error ? error.message : "Matrix request rejected before dispatch", { cause: error });
+				if (error instanceof MatrixSdkAuthorityError) rejected.name = "AbortError";
+				throw rejected;
+			}
+			if (error instanceof PlatformMessageNotDispatchedError) throw new AggregateError([error, /* @__PURE__ */ new Error("An earlier Matrix request crossed the fetch boundary")], error.message, { cause: error });
+			throw error;
+		}
+	}
+	cleanup();
+	throw new Error(`Too many redirects while requesting ${params.url}`);
+}
+function createMatrixGuardedFetch(params) {
+	return (async (resource, init) => {
+		const authority = params.captureRequestAuthority?.() ?? captureChannelReadAuthority();
+		const assertCurrent = authority ? () => {
+			try {
+				authority();
+			} catch (error) {
+				throw new MatrixSdkAuthorityError(error);
+			}
+		} : void 0;
+		const assertSendCurrent = params.captureSendCurrentness?.(resource, init);
+		assertCurrent?.();
+		const url = withoutMatrixStateAfterSyncParam(toFetchUrl(resource));
+		const { signal, ...requestInit } = init ?? {};
+		const signals = [
+			params.signal,
+			signal,
+			params.captureRequestSignal?.()
+		].filter((candidate) => candidate != null);
+		const requestSignal = signals.length > 0 ? AbortSignal.any(signals) : void 0;
+		const beforeRequest = params.beforeRequest;
+		const { response, release } = await fetchWithMatrixGuardedRedirects({
+			url,
+			init: requestInit,
+			signal: requestSignal,
+			assertCurrent,
+			assertSendCurrent,
+			ssrfPolicy: params.ssrfPolicy,
+			dispatcherPolicy: params.dispatcherPolicy,
+			beforeDispatch: beforeRequest ? () => beforeRequest(resource, init) : void 0
+		});
+		try {
+			await enforceDeclaredResponseSize({
+				response,
+				maxBytes: MATRIX_SDK_RESPONSE_MAX_BYTES,
+				createError: (length) => /* @__PURE__ */ new Error(`Matrix SDK response exceeds size limit (${length} bytes > ${MATRIX_SDK_RESPONSE_MAX_BYTES} bytes)`)
+			});
+			const body = await readResponseWithLimit(response, MATRIX_SDK_RESPONSE_MAX_BYTES, { onOverflow: ({ maxBytes, size }) => /* @__PURE__ */ new Error(`Matrix SDK response exceeds size limit (${size} bytes > ${maxBytes} bytes)`) });
+			assertCurrent?.();
+			return buildBufferedResponse({
+				source: response,
+				body: Uint8Array.from(body),
+				url
+			});
+		} finally {
+			try {
+				await release();
+			} finally {
+				assertCurrent?.();
+			}
+		}
+	});
+}
+async function performMatrixRequest(params) {
+	const assertCurrent = params.assertCurrent ?? captureChannelReadAuthority();
+	assertCurrent?.();
+	const isAbsoluteEndpoint = params.endpoint.startsWith("http://") || params.endpoint.startsWith("https://");
+	if (isAbsoluteEndpoint && params.allowAbsoluteEndpoint !== true) throw new Error(`Absolute Matrix endpoint is blocked by default: ${params.endpoint}. Set allowAbsoluteEndpoint=true to opt in.`);
+	const baseUrl = isAbsoluteEndpoint ? new URL(params.endpoint) : new URL(`${params.homeserver.replace(/\/+$/u, "")}${normalizeEndpoint(params.endpoint)}`);
+	applyQuery(baseUrl, params.qs);
+	const headers = new Headers();
+	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);
+		}
+	}
+	const { response, release } = await fetchWithMatrixGuardedRedirects({
+		url: baseUrl.toString(),
+		init: {
+			method: params.method,
+			headers,
+			body
+		},
+		timeoutMs: params.timeoutMs,
+		ssrfPolicy: params.ssrfPolicy,
+		dispatcherPolicy: params.dispatcherPolicy,
+		assertCurrent,
+		assertSendCurrent: params.assertSendCurrent,
+		signal: params.signal
+	});
+	try {
+		const maxBytes = params.maxBytes ?? (params.raw ? MATRIX_SDK_RESPONSE_MAX_BYTES : MATRIX_JSON_RESPONSE_MAX_BYTES);
+		const createSizeError = (size) => params.raw ? new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`) : /* @__PURE__ */ new Error(`Matrix JSON response exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`);
+		await enforceDeclaredResponseSize({
+			response,
+			maxBytes,
+			createError: createSizeError
+		});
+		const buffer = await readResponseWithLimit(response, maxBytes, {
+			onOverflow: ({ size }) => createSizeError(size),
+			chunkTimeoutMs: params.readIdleTimeoutMs,
+			onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`${params.raw ? "Matrix media download" : "Matrix JSON response"} stalled: no data received for ${chunkTimeoutMs}ms`)
+		});
+		assertCurrent?.();
+		return {
+			response,
+			text: buffer.toString("utf8"),
+			buffer
+		};
+	} finally {
+		try {
+			await release();
+		} finally {
+			assertCurrent?.();
+		}
+	}
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/http-client.ts
+var MatrixAuthedHttpClient = class {
+	constructor(params) {
+		this.homeserver = params.homeserver;
+		this.accessToken = params.accessToken;
+		this.ssrfPolicy = params.ssrfPolicy;
+		this.dispatcherPolicy = params.dispatcherPolicy;
+		this.captureRequestAuthority = params.captureRequestAuthority;
+		this.captureSendCurrentness = params.captureSendCurrentness;
+		this.signal = params.signal;
+	}
+	async request(params) {
+		const result = await performMatrixRequest({
+			...params,
+			homeserver: this.homeserver,
+			accessToken: this.accessToken,
+			ssrfPolicy: this.ssrfPolicy,
+			dispatcherPolicy: this.dispatcherPolicy,
+			assertCurrent: this.captureRequestAuthority?.(),
+			assertSendCurrent: this.captureSendCurrentness?.(),
+			signal: this.signal
+		});
+		if (!result.response.ok) throw buildHttpError(result.response.status, result.text);
+		return result;
+	}
+	async requestJson(params) {
+		const { response, text } = await this.request(params);
+		if ((response.headers.get("content-type") ?? "").split(";", 1)[0]?.trim().toLowerCase() === "application/json") {
+			if (!text.trim()) return {};
+			try {
+				return JSON.parse(text);
+			} catch {
+				throw Object.assign(/* @__PURE__ */ new Error("Matrix homeserver returned malformed JSON"), { statusCode: response.status });
+			}
+		}
+		return text;
+	}
+	async requestRaw(params) {
+		const { buffer } = await this.request({
+			...params,
+			raw: true
+		});
+		return buffer;
+	}
+};
+//#endregion
+export { isMatrixMediaSizeLimitError as i, createMatrixGuardedFetch as n, MatrixMediaSizeLimitError as r, MatrixAuthedHttpClient as t };

package/dist/.setup/idb-persistence-DBvfre1X.mjs

@@ -0,0 +1,227 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { C as writeMatrixIdbSnapshotJson, o as MATRIX_IDB_SNAPSHOT_FILENAME, y as readMatrixIdbSnapshotJson } from "./storage-metadata-BDRZ7vpX.mjs";
+import { n as LogService } from "./logger-CVv56jzH.mjs";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-D_mDu4Cf.mjs";
+import path from "node:path";
+import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import fs from "node:fs";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+import { indexedDB } from "fake-indexeddb";
+//#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";
+	}
+};
+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 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 });
+	});
+}
+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) {
+	let storedSnapshotJson;
+	try {
+		storedSnapshotJson = await readMatrixIdbSnapshotJson(path.dirname(snapshotPath), stateRuntime);
+	} catch (err) {
+		if (fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
+		throw err;
+	}
+	throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson);
+	return storedSnapshotJson;
+}
+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 readLegacyMatrixIdbSnapshotStateUnlocked(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);
+	} catch {
+		return null;
+	}
+}
+function throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson) {
+	if (fs.existsSync(snapshotPath) && (!storedSnapshotJson || !isValidMatrixIdbSnapshotJson(storedSnapshotJson))) throwLegacySnapshotMigrationRequired();
+}
+function throwLegacySnapshotMigrationRequired() {
+	LogService.warn("IdbPersistence", LEGACY_SNAPSHOT_DIAGNOSTIC);
+	throw new MatrixIdbSnapshotMigrationRequiredError();
+}
+//#endregion
+export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotStateUnlocked as r, isValidMatrixIdbSnapshotJson as t };

package/dist/.setup/idb-persistence-lock-D_mDu4Cf.mjs

@@ -0,0 +1,27 @@
+//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
+const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
+const IDB_SNAPSHOT_LOCK_STALE_MS = 3e5;
+const IDB_SNAPSHOT_LOCK_RETRY_BASE = {
+	factor: 2,
+	minTimeout: 50,
+	maxTimeout: 5e3,
+	randomize: true
+};
+function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
+	const resolved = {
+		...retries,
+		retries: 0
+	};
+	let total = 0;
+	while (total < minimumWindowMs) {
+		total += Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** resolved.retries));
+		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/.setup/inbound-dedupe-BGrMrTTu.mjs

@@ -0,0 +1,48 @@
+import { n as LogService } from "./logger-CVv56jzH.mjs";
+import { createChannelReplayGuard, resolvePersistentDedupePluginStateNamespace } from "openclaw/plugin-sdk/persistent-dedupe";
+//#region extensions/matrix/src/matrix/monitor/inbound-dedupe.ts
+const MATRIX_INBOUND_DEDUPE_PLUGIN_ID = "matrix";
+const MATRIX_INBOUND_DEDUPE_NAMESPACE_PREFIX = "matrix.inbound-dedupe";
+const MATRIX_INBOUND_DEDUPE_NAMESPACE = "global";
+const MATRIX_INBOUND_DEDUPE_TTL_MS = 2592e6;
+const MATRIX_INBOUND_DEDUPE_MEMORY_MAX = 5e3;
+const MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES = 2e4;
+function resolveMatrixInboundDedupeAccountId(accountId) {
+	return accountId.trim() || "default";
+}
+function buildMatrixInboundDedupeEventKey(params) {
+	const roomId = params.roomId.trim();
+	const eventId = params.eventId.trim();
+	if (!roomId || !eventId) return null;
+	return `${resolveMatrixInboundDedupeAccountId(params.accountId)}\0${roomId}\0${eventId}`;
+}
+/** Persisted plugin-state namespace holding the inbound dedupe rows. */
+function resolveMatrixInboundDedupeStateNamespace() {
+	return resolvePersistentDedupePluginStateNamespace({
+		namespace: MATRIX_INBOUND_DEDUPE_NAMESPACE,
+		namespacePrefix: MATRIX_INBOUND_DEDUPE_NAMESPACE_PREFIX
+	});
+}
+function createMatrixInboundEventDeduper(params) {
+	const accountId = params.auth.accountId;
+	return createChannelReplayGuard({
+		dedupe: {
+			pluginId: MATRIX_INBOUND_DEDUPE_PLUGIN_ID,
+			namespacePrefix: MATRIX_INBOUND_DEDUPE_NAMESPACE_PREFIX,
+			ttlMs: MATRIX_INBOUND_DEDUPE_TTL_MS,
+			memoryMaxSize: MATRIX_INBOUND_DEDUPE_MEMORY_MAX,
+			stateMaxEntries: MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES,
+			...params.env ? { env: params.env } : {},
+			onDiskError: (err) => {
+				LogService.warn("MatrixInboundDedupe", "Matrix inbound dedupe persistence failed:", err);
+			}
+		},
+		buildReplayKey: (event) => buildMatrixInboundDedupeEventKey({
+			accountId,
+			...event
+		}),
+		namespace: () => MATRIX_INBOUND_DEDUPE_NAMESPACE
+	});
+}
+//#endregion
+export { MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES, MATRIX_INBOUND_DEDUPE_TTL_MS, buildMatrixInboundDedupeEventKey, createMatrixInboundEventDeduper, resolveMatrixInboundDedupeStateNamespace };