@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/http-client-CycYxU9-.js

@@ -1,370 +0,0 @@
-import { t as buildTimeoutAbortSignal } from "./timeout-abort-signal-DMrgRFIy.js";
-import { parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-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 raw = {
-		event_id: event.getId() ?? "",
-		sender: event.getSender() ?? "",
-		type: event.getType() ?? "",
-		origin_server_ts: event.getTs() ?? 0,
-		content: normalizedContent,
-		unsigned: event.getUnsigned()
-	};
-	const stateKey = event.getStateKey() ?? event.getWireStateKey();
-	if (typeof stateKey === "string") raw.state_key = stateKey;
-	return raw;
-}
-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
-	};
-}
-function buildHttpError(statusCode, bodyText) {
-	let message = `Matrix HTTP ${statusCode}`;
-	if (bodyText.trim()) try {
-		const parsed = JSON.parse(bodyText);
-		if (typeof parsed.error === "string" && parsed.error.trim()) message = parsed.error.trim();
-		else message = truncateUtf16Safe(bodyText, 500);
-	} catch {
-		message = truncateUtf16Safe(bodyText, 500);
-	}
-	return Object.assign(new Error(message), { statusCode });
-}
-//#endregion
-//#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/read-response-with-limit.ts
-async function readResponseWithLimit$1(res, maxBytes, opts) {
-	return await readResponseWithLimit(res, maxBytes, {
-		...opts,
-		onIdleTimeout: opts?.onIdleTimeout ?? (({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Matrix media download stalled: no data received for ${chunkTimeoutMs}ms`))
-	});
-}
-//#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;
-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 fetchWithMatrixDispatcher(params) {
-	return await fetchWithRuntimeDispatcherOrMockedGlobal(params.url, params.init);
-}
-async function fetchWithMatrixGuardedRedirects(params) {
-	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
-	});
-	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 response = await fetchWithMatrixDispatcher({
-				url: currentUrl.toString(),
-				init: {
-					...params.init,
-					method,
-					body,
-					headers,
-					redirect: "manual",
-					signal,
-					dispatcher
-				}
-			});
-			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);
-			throw error;
-		}
-	}
-	cleanup();
-	throw new Error(`Too many redirects while requesting ${params.url}`);
-}
-function createMatrixGuardedFetch(params) {
-	return (async (resource, init) => {
-		const url = withoutMatrixStateAfterSyncParam(toFetchUrl(resource));
-		const { signal, ...requestInit } = init ?? {};
-		const { response, release } = await fetchWithMatrixGuardedRedirects({
-			url,
-			init: requestInit,
-			signal: signal ?? void 0,
-			ssrfPolicy: params.ssrfPolicy,
-			dispatcherPolicy: params.dispatcherPolicy
-		});
-		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$1(response, MATRIX_SDK_RESPONSE_MAX_BYTES, { onOverflow: ({ maxBytes, size }) => /* @__PURE__ */ new Error(`Matrix SDK response exceeds size limit (${size} bytes > ${maxBytes} bytes)`) });
-			return buildBufferedResponse({
-				source: response,
-				body: Uint8Array.from(body),
-				url
-			});
-		} finally {
-			await release();
-		}
-	});
-}
-async function performMatrixRequest(params) {
-	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
-	});
-	try {
-		if (params.raw) {
-			const rawMaxBytes = params.maxBytes ?? MATRIX_SDK_RESPONSE_MAX_BYTES;
-			await enforceDeclaredResponseSize({
-				response,
-				maxBytes: rawMaxBytes,
-				createError: (length) => new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${length} bytes > ${rawMaxBytes} bytes)`)
-			});
-			const bytes = await readResponseWithLimit$1(response, rawMaxBytes, {
-				onOverflow: ({ maxBytes, size }) => new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`),
-				chunkTimeoutMs: params.readIdleTimeoutMs
-			});
-			return {
-				response,
-				text: bytes.toString("utf8"),
-				buffer: bytes
-			};
-		}
-		const jsonMaxBytes = params.maxBytes ?? MATRIX_JSON_RESPONSE_MAX_BYTES;
-		await enforceDeclaredResponseSize({
-			response,
-			maxBytes: jsonMaxBytes,
-			createError: (length) => /* @__PURE__ */ new Error(`Matrix JSON response exceeds configured size limit (${length} bytes > ${jsonMaxBytes} bytes)`)
-		});
-		const buffer = await readResponseWithLimit$1(response, jsonMaxBytes, {
-			onOverflow: ({ maxBytes, size }) => /* @__PURE__ */ new Error(`Matrix JSON response exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`),
-			chunkTimeoutMs: params.readIdleTimeoutMs,
-			onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Matrix JSON response stalled: no data received for ${chunkTimeoutMs}ms`)
-		});
-		return {
-			response,
-			text: buffer.toString("utf8"),
-			buffer
-		};
-	} finally {
-		await release();
-	}
-}
-//#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;
-	}
-	async requestJson(params) {
-		const { response, text } = await performMatrixRequest({
-			homeserver: this.homeserver,
-			accessToken: this.accessToken,
-			method: params.method,
-			endpoint: params.endpoint,
-			qs: params.qs,
-			body: params.body,
-			timeoutMs: params.timeoutMs,
-			ssrfPolicy: this.ssrfPolicy,
-			dispatcherPolicy: this.dispatcherPolicy,
-			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 (!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 { response, buffer } = await performMatrixRequest({
-			homeserver: this.homeserver,
-			accessToken: this.accessToken,
-			method: params.method,
-			endpoint: params.endpoint,
-			qs: params.qs,
-			timeoutMs: params.timeoutMs,
-			raw: true,
-			maxBytes: params.maxBytes,
-			readIdleTimeoutMs: params.readIdleTimeoutMs,
-			ssrfPolicy: this.ssrfPolicy,
-			dispatcherPolicy: this.dispatcherPolicy,
-			allowAbsoluteEndpoint: params.allowAbsoluteEndpoint
-		});
-		if (!response.ok) throw buildHttpError(response.status, buffer.toString("utf8"));
-		return buffer;
-	}
-};
-//#endregion
-export { matrixEventToRaw as a, isMatrixMediaSizeLimitError as i, createMatrixGuardedFetch as n, parseMxc as o, MatrixMediaSizeLimitError as r, MatrixAuthedHttpClient as t };

package/dist/idb-persistence-B6x7dMsF.js

@@ -1,232 +0,0 @@
-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 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 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 });
-		});
-		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(toErrorObject(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 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;
-	}
-}
-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,
-				snapshotJson: JSON.stringify(snapshot),
-				databaseCount: snapshot.length
-			});
-			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);
-	}
-}
-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/idb-persistence-lock-DAJ49nZX.js

@@ -1,32 +0,0 @@
-//#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/inbound-dedupe-CaBLblef.js

@@ -1,48 +0,0 @@
-import { n as LogService } from "./logger-D0GCSDQq.js";
-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 = 720 * 60 * 60 * 1e3;
-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 { resolveMatrixInboundDedupeStateNamespace as a, createMatrixInboundEventDeduper as i, MATRIX_INBOUND_DEDUPE_TTL_MS as n, buildMatrixInboundDedupeEventKey as r, MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES as t };