@openclaw/matrix 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{http-client-BmrgOZTL.js → http-client-CycYxU9-.js}

@@ -211,7 +211,7 @@ async function fetchWithMatrixGuardedRedirects(params) {
 				headers.delete("content-type");
 				headers.delete("content-length");
 			}
-			response.body?.cancel();
+			response.body?.cancel().catch(() => void 0);
 			await closeDispatcher(dispatcher);
 			currentUrl = nextUrl;
 		} catch (error) {
@@ -254,7 +254,7 @@ function createMatrixGuardedFetch(params) {
 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(normalizeEndpoint(params.endpoint), params.homeserver);
+	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");

package/dist/{idb-persistence-Dyy6ipgU.js → idb-persistence-B6x7dMsF.js}

@@ -1,17 +1,25 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { D as writeMatrixIdbSnapshotJson, T as readMatrixIdbSnapshotJson, f as MATRIX_IDB_SNAPSHOT_FILENAME } from "./storage-CzHxeF5E.js";
+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 { indexedDB } from "fake-indexeddb";
 import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+import { indexedDB } from "fake-indexeddb";
 //#region extensions/matrix/src/matrix/sdk/idb-persistence.ts
-var idb_persistence_exports = /* @__PURE__ */ __exportAll({
-	persistIdbToDisk: () => persistIdbToDisk,
-	readLegacyMatrixIdbSnapshotState: () => readLegacyMatrixIdbSnapshotState,
-	restoreIdbFromDisk: () => restoreIdbFromDisk
-});
+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;
@@ -38,10 +46,17 @@ 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(toLintErrorObject(req.error, "Non-Error rejection")), { once: true });
+		req.addEventListener("error", () => reject(toErrorObject(req.error, "Non-Error rejection")), { once: true });
 	});
 }
 async function dumpIndexedDatabases(databasePrefix) {
@@ -55,7 +70,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(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
+			r.addEventListener("error", () => reject(toErrorObject(r.error, "Non-Error rejection")), { once: true });
 		});
 		const stores = [];
 		for (const storeName of db.objectStoreNames) {
@@ -127,7 +142,7 @@ async function restoreIndexedDatabases(snapshot) {
 				resolve();
 			})().catch(reject);
 		}, { once: true });
-		r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
+		r.addEventListener("error", () => reject(toErrorObject(r.error, "Non-Error rejection")), { once: true });
 	});
 }
 function resolveDefaultIdbSnapshotPath() {
@@ -135,95 +150,83 @@ function resolveDefaultIdbSnapshotPath() {
 	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;
-		}
+	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;
 	}
-	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: path.dirname(snapshotPath),
+				storageRootDir,
 				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);
 	}
 }
-async function readLegacyMatrixIdbSnapshotState(storageRootDir) {
+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 await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
-			return parseSnapshotPayload(fs.readFileSync(snapshotPath, "utf8"));
-		});
+		return parseSnapshotPayload(data);
 	} 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 throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson) {
+	if (fs.existsSync(snapshotPath) && (!storedSnapshotJson || !isValidMatrixIdbSnapshotJson(storedSnapshotJson))) throwLegacySnapshotMigrationRequired();
 }
-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;
+function throwLegacySnapshotMigrationRequired() {
+	LogService.warn("IdbPersistence", LEGACY_SNAPSHOT_DIAGNOSTIC);
+	throw new MatrixIdbSnapshotMigrationRequiredError();
 }
 //#endregion
-export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotState as r, idb_persistence_exports as t };
+export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotStateUnlocked as r, isValidMatrixIdbSnapshotJson as t };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerMatrixCliMetadata } from "./cli-metadata-Xq1Xb15R.js";
+import { n as registerMatrixCliMetadata } from "./cli-metadata-DnXxNCoj.js";
 import { registerMatrixSubagentHooks } from "./subagent-hooks-api.js";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";

package/dist/{logging-QH-48Gr6.js → logging-DV-p52N0.js}

@@ -1,6 +1,13 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { i as setMatrixConsoleLogging, n as LogService, t as ConsoleLogger } from "./logger-D0GCSDQq.js";
 import { logger } from "matrix-js-sdk/lib/logger.js";
 //#region extensions/matrix/src/matrix/client/logging.ts
+var logging_exports = /* @__PURE__ */ __exportAll({
+	createMatrixJsSdkClientLogger: () => createMatrixJsSdkClientLogger,
+	ensureMatrixSdkLoggingConfigured: () => ensureMatrixSdkLoggingConfigured,
+	setMatrixSdkConsoleLogging: () => setMatrixSdkConsoleLogging,
+	setMatrixSdkLogMode: () => setMatrixSdkLogMode
+});
 let matrixSdkLoggingConfigured = false;
 let matrixSdkLogMode = "default";
 const matrixSdkBaseLogger = new ConsoleLogger();
@@ -89,4 +96,4 @@ function createMatrixJsSdkLoggerInstance(prefix) {
 	};
 }
 //#endregion
-export { createMatrixJsSdkClientLogger, ensureMatrixSdkLoggingConfigured, setMatrixSdkConsoleLogging, setMatrixSdkLogMode };
+export { setMatrixSdkLogMode as i, logging_exports as n, setMatrixSdkConsoleLogging as r, createMatrixJsSdkClientLogger as t };

package/dist/{media-text-BMXEXb1j.js → media-text-DlQC_k_K.js}

@@ -1,4 +1,4 @@
-import { C as formatPollResultsAsText, D as parsePollStartContent, O as resolvePollReferenceEventId, S as formatPollAsText, T as isPollStartType, w as isPollEventType, x as buildPollResultsSummary } from "./send-BJbrdmNm.js";
+import { C as formatPollResultsAsText, D as parsePollStartContent, O as resolvePollReferenceEventId, S as formatPollAsText, T as isPollStartType, w as isPollEventType, x as buildPollResultsSummary } from "./send-C9Ssx-iV.js";
 import path from "node:path";
 //#region extensions/matrix/src/matrix/poll-summary.ts
 function resolveMatrixPollRootEventId(event) {

package/dist/{messages-3UBHfZrN.js → messages-Bf_s--M9.js}

@@ -1,8 +1,8 @@
 import { r as isMatrixNotFoundError } from "./errors-C47hvAF8.js";
-import { T as isPollStartType, a as sendMessageMatrix, n as editMessageMatrix, w as isPollEventType } from "./send-BJbrdmNm.js";
+import { T as isPollStartType, r as sendMessageMatrix, t as editMessageMatrix, w as isPollEventType } from "./send-C9Ssx-iV.js";
 import { n as MATRIX_REACTION_EVENT_TYPE } from "./reaction-common-DkrQdBSZ.js";
-import { a as resolveMatrixMessageAttachment, l as resolveMatrixPollRootEventId, o as resolveMatrixMessageBody, s as fetchMatrixPollMessageSummary } from "./media-text-BMXEXb1j.js";
-import { r as withResolvedRoomAction } from "./client-BtG4quUl.js";
+import { a as resolveMatrixMessageAttachment, l as resolveMatrixPollRootEventId, o as resolveMatrixMessageBody, s as fetchMatrixPollMessageSummary } from "./media-text-DlQC_k_K.js";
+import { r as withResolvedRoomAction } from "./client-CitERujx.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 //#region extensions/matrix/src/matrix/actions/limits.ts