@openclaw/matrix 2026.9.1-beta.1 → 2026.9.2

package/dist/doctor-contract-api.js

@@ -1,100 +1,75 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-CWuhuFn1.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-DA-jfx22.js";
 import { i as normalizeMatrixStoredCredentials, n as isMatrixCredentialRevocation, r as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-state-B3cuUFwZ.js";
 import { r as resolveMatrixCredentialsDir } from "./storage-paths-gUmSydsW.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DEt4O4Zt.js";
-import { C as readLegacyMatrixRecoveryKeyState, O as writeMatrixIdbSnapshotJsonToStore, T as readMatrixIdbSnapshotJsonFromStore, a as openMatrixStorageMetaStoreOptions, b as openMatrixRecoveryKeyStoreOptions, f as MATRIX_IDB_SNAPSHOT_FILENAME, g as hasMatrixRecoveryKeyStateInStore, h as hasMatrixLegacyCryptoMigrationStateInStore, i as normalizeMatrixStorageMetadata, j as writeMatrixRecoveryKeyStateToStore, k as writeMatrixLegacyCryptoMigrationStateToStore, m as MATRIX_RECOVERY_KEY_FILENAME, n as hasMatrixStorageMetaStateInStore, p as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, u as writeMatrixStorageMetaStateToStore, v as openMatrixIdbSnapshotStoreOptions, x as readLegacyMatrixLegacyCryptoMigrationState, y as openMatrixLegacyCryptoMigrationStoreOptions } from "./storage-BsGuHngK.js";
-import { a as readLegacyMatrixSyncCacheState, i as openMatrixSyncCacheStoreOptions, o as writeMatrixSyncCacheStateToStore, r as hasMatrixSyncCacheStateInStore } from "./file-sync-store-DjskBX2o.js";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-DAJ49nZX.js";
-import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-DfgW720p.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-HyWFZQVG.js";
+import { C as readLegacyMatrixRecoveryKeyState, M as resolveMatrixSqliteStateEnv, a as openMatrixStorageMetaStoreOptions, b as openMatrixRecoveryKeyStoreOptions, f as MATRIX_IDB_SNAPSHOT_FILENAME, g as hasMatrixRecoveryKeyStateInStore, h as hasMatrixLegacyCryptoMigrationStateInStore, i as normalizeMatrixStorageMetadata, j as writeMatrixRecoveryKeyStateToStore, k as writeMatrixLegacyCryptoMigrationStateToStore, m as MATRIX_RECOVERY_KEY_FILENAME, n as hasMatrixStorageMetaStateInStore, p as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, u as writeMatrixStorageMetaStateToStore, x as readLegacyMatrixLegacyCryptoMigrationState, y as openMatrixLegacyCryptoMigrationStoreOptions } from "./storage-BVf4uucD.js";
+import { a as readLegacyMatrixSyncCacheState, c as writeMatrixSyncCacheStateToStore, i as openMatrixSyncCacheStoreOptions, r as hasMatrixSyncCacheStateInStore } from "./sync-cache-state-d-A_OhbU.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { archiveLegacyStateSource } from "openclaw/plugin-sdk/runtime-doctor-migrations";
-import fs from "node:fs";
-import fs$1 from "node:fs/promises";
-import { isDeepStrictEqual } from "node:util";
-import { withFileLock } from "openclaw/plugin-sdk/file-lock";
-//#region extensions/matrix/src/matrix/crypto-snapshot-doctor.ts
-async function migrateLegacyMatrixIdbSnapshot(params) {
-	const snapshotPath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	try {
-		await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, () => migrateLegacyMatrixIdbSnapshotLocked(params));
-	} catch (err) {
-		params.warnings.push(`Failed locking Matrix IndexedDB snapshot for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
-	}
-}
-async function migrateLegacyMatrixIdbSnapshotLocked(params) {
-	const sourcePath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	let snapshot;
-	try {
-		snapshot = readLegacyMatrixIdbSnapshotStateUnlocked(params.storageRootDir);
-	} catch (err) {
-		params.warnings.push(`Failed reading Matrix IndexedDB snapshot legacy source for ${params.storageRootDir}: ${String(err)}; left source in place`);
-		return;
-	}
-	if (!snapshot) {
-		if (!fs.existsSync(sourcePath)) return;
-		const archived = await archiveLegacyMatrixIdbSnapshot(params);
-		params.warnings.push(archived ? `Matrix IndexedDB snapshot legacy source is invalid for ${params.storageRootDir}; archived without import` : `Matrix IndexedDB snapshot legacy source is invalid for ${params.storageRootDir}; left active because archival failed`);
-		return;
-	}
-	const snapshotJson = JSON.stringify(snapshot);
-	const store = params.context.openPluginStateKeyedStore(openMatrixIdbSnapshotStoreOptions(params.storageRootDir));
-	let persisted;
-	let hadPartialState;
-	try {
-		persisted = await readMatrixIdbSnapshotJsonFromStore({ store });
-		const persistedIsValid = persisted ? isValidMatrixIdbSnapshotJson(persisted) : false;
-		hadPartialState = !persistedIsValid && (await store.entries()).length > 0;
-		if (!persistedIsValid) persisted = null;
-	} catch (err) {
-		params.warnings.push(`Failed inspecting Matrix IndexedDB snapshot SQLite state for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
-		return;
-	}
-	if (persisted && !snapshotContentMatches(persisted, snapshot)) {
-		if (await archiveLegacyMatrixIdbSnapshot(params)) params.notices.push(`Kept the canonical Matrix IndexedDB snapshot in SQLite and archived a differing legacy source for ${params.storageRootDir}`);
-		return;
-	}
-	if (!persisted) {
+import fs from "node:fs/promises";
+//#region extensions/matrix/src/matrix/account-state-schema-doctor.ts
+const STATE_DATABASE_FILENAME = "openclaw.sqlite";
+async function collectMatrixAccountStateRoots(stateDir) {
+	const accountsRoot = path.join(stateDir, "matrix", "accounts");
+	const roots = /* @__PURE__ */ new Set();
+	async function visit(dir, allowMissing = false) {
+		let entries;
 		try {
-			await writeMatrixIdbSnapshotJsonToStore({
-				snapshotJson,
-				databaseCount: snapshot.length,
-				store
-			});
-			persisted = await readMatrixIdbSnapshotJsonFromStore({ store });
-		} catch (err) {
-			params.warnings.push(`Failed importing Matrix IndexedDB snapshot for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
-			return;
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch (error) {
+			if (allowMissing && typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return;
+			throw error;
 		}
-		if (!persisted || !snapshotContentMatches(persisted, snapshot)) {
-			params.warnings.push(`Failed verifying Matrix IndexedDB snapshot for ${params.storageRootDir}; left legacy source in place`);
-			return;
+		for (const entry of entries) {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isFile() && entry.name === STATE_DATABASE_FILENAME && path.basename(dir) === "state") roots.add(path.dirname(dir));
+			else if (entry.isDirectory()) await visit(entryPath);
 		}
-		params.changes.push(hadPartialState ? `Repaired partial or invalid Matrix IndexedDB snapshot SQLite state for ${params.storageRootDir}` : `Migrated Matrix IndexedDB snapshot JSON to SQLite for ${params.storageRootDir}`);
 	}
-	await archiveLegacyMatrixIdbSnapshot(params);
+	await visit(accountsRoot, true);
+	return [...roots].toSorted();
 }
-function snapshotContentMatches(persistedJson, snapshot) {
-	try {
-		return isDeepStrictEqual(JSON.parse(persistedJson), snapshot);
-	} catch {
-		return false;
-	}
+function describeMatrixAccountStateMigration(storageRootDir, migration) {
+	return `Matrix account SQLite schema migration (${migration.kind}): ${storageRootDir}`;
 }
-async function archiveLegacyMatrixIdbSnapshot(params) {
-	const sourcePath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	const archivePath = `${sourcePath}.migrated-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID()}`;
-	try {
-		await fs$1.rename(sourcePath, archivePath);
-		params.changes.push(`Archived Matrix IndexedDB snapshot legacy source -> ${archivePath}`);
-		return true;
-	} catch (err) {
-		params.warnings.push(`Failed archiving Matrix IndexedDB snapshot legacy source: ${String(err)}`);
-		return false;
+const matrixAccountStateSchemaMigration = {
+	id: "matrix-account-sqlite-schema",
+	label: "Matrix account SQLite schemas",
+	async detectLegacyState(params) {
+		const preview = [];
+		for (const storageRootDir of await collectMatrixAccountStateRoots(params.stateDir)) {
+			const { detectOpenClawStateDatabaseSchemaMigrations } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
+			const env = resolveMatrixSqliteStateEnv({
+				env: params.env,
+				stateDir: storageRootDir
+			});
+			preview.push(...detectOpenClawStateDatabaseSchemaMigrations({ env }).map((migration) => describeMatrixAccountStateMigration(storageRootDir, migration)));
+		}
+		return preview.length > 0 ? { preview } : null;
+	},
+	async migrateLegacyState(params) {
+		const changes = [];
+		const warnings = [];
+		for (const storageRootDir of await collectMatrixAccountStateRoots(params.stateDir)) {
+			const { detectOpenClawStateDatabaseSchemaMigrations, repairOpenClawStateDatabaseSchema } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
+			const env = resolveMatrixSqliteStateEnv({
+				env: params.env,
+				stateDir: storageRootDir
+			});
+			if (detectOpenClawStateDatabaseSchemaMigrations({ env }).length === 0) continue;
+			const repaired = repairOpenClawStateDatabaseSchema({ env });
+			changes.push(...repaired.changes.map((change) => `Matrix account SQLite ${storageRootDir}: ${change}`));
+			warnings.push(...repaired.warnings.map((warning) => `Matrix account SQLite ${storageRootDir}: ${warning}`));
+		}
+		return {
+			changes,
+			warnings
+		};
 	}
-}
+};
 //#endregion
 //#region extensions/matrix/src/matrix/monitor/inbound-dedupe-migration.ts
 const LEGACY_SQLITE_NAMESPACE = "inbound-dedupe";
@@ -143,7 +118,7 @@ async function collectMatrixInboundDedupeSources(stateDir) {
 	async function visit(dir, allowMissing = false) {
 		let entries;
 		try {
-			entries = await fs$1.readdir(dir, { withFileTypes: true });
+			entries = await fs.readdir(dir, { withFileTypes: true });
 		} catch (err) {
 			if (allowMissing && err.code === "ENOENT") return;
 			warnings.push(`Failed scanning Matrix inbound dedupe sources under ${dir}: ${String(err)}`);
@@ -269,7 +244,7 @@ async function verifyMatrixInboundDedupeSourcesRetired(stateDir) {
 }
 async function resolveJsonRootAccountId(storageRootDir) {
 	for (const filename of [STORAGE_META_FILENAME, `${STORAGE_META_FILENAME}.migrated`]) try {
-		const metadata = normalizeMatrixStorageMetadata(JSON.parse(await fs$1.readFile(path.join(storageRootDir, filename), "utf8")));
+		const metadata = normalizeMatrixStorageMetadata(JSON.parse(await fs.readFile(path.join(storageRootDir, filename), "utf8")));
 		if (metadata?.accountId) return metadata.accountId;
 	} catch {}
 	return "default";
@@ -281,7 +256,7 @@ async function resolveJsonRootAccountId(storageRootDir) {
 */
 async function readLegacyInboundDedupeJsonSource(storageRootDir) {
 	const jsonPath = path.join(storageRootDir, MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME);
-	const raw = await fs$1.readFile(jsonPath, "utf8");
+	const raw = await fs.readFile(jsonPath, "utf8");
 	let parsed;
 	try {
 		parsed = JSON.parse(raw);
@@ -317,7 +292,7 @@ async function readLegacyInboundDedupeJsonSource(storageRootDir) {
 */
 async function importNewestInboundDedupeMarkers(params) {
 	const { createPersistentDedupeImportEntry } = await import("openclaw/plugin-sdk/persistent-dedupe");
-	const { buildMatrixInboundDedupeEventKey, MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES, MATRIX_INBOUND_DEDUPE_TTL_MS, resolveMatrixInboundDedupeStateNamespace } = await import("./inbound-dedupe-RvSLqdsz.js");
+	const { buildMatrixInboundDedupeEventKey, MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES, MATRIX_INBOUND_DEDUPE_TTL_MS, resolveMatrixInboundDedupeStateNamespace } = await import("./inbound-dedupe-Ch33GU06.js");
 	const now = params.now ?? Date.now();
 	const stateMaxEntries = params.stateMaxEntries ?? MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES;
 	const newestByKey = /* @__PURE__ */ new Map();
@@ -389,7 +364,7 @@ async function collectLegacyMatrixCredentialSources(params) {
 	const credentialsDir = resolveMatrixCredentialsDir(params.stateDir);
 	let entries;
 	try {
-		entries = await fs$1.readdir(credentialsDir, { withFileTypes: true });
+		entries = await fs.readdir(credentialsDir, { withFileTypes: true });
 	} catch {
 		return [];
 	}
@@ -408,8 +383,8 @@ async function collectLegacyMatrixCredentialSources(params) {
 async function readLegacyMatrixCredentials(source) {
 	if (!source.accountId) return null;
 	try {
-		const raw = JSON.parse(await fs$1.readFile(source.filePath, "utf8"));
-		const createdAt = isRecord(raw) && typeof raw.createdAt === "string" && raw.createdAt ? raw.createdAt : (await fs$1.stat(source.filePath)).mtime.toISOString();
+		const raw = JSON.parse(await fs.readFile(source.filePath, "utf8"));
+		const createdAt = isRecord(raw) && typeof raw.createdAt === "string" && raw.createdAt ? raw.createdAt : (await fs.stat(source.filePath)).mtime.toISOString();
 		return normalizeMatrixStoredCredentials(isRecord(raw) ? {
 			...raw,
 			createdAt
@@ -424,7 +399,7 @@ async function collectLegacyMatrixStateRoots(stateDir, filename, options) {
 	async function visit(dir) {
 		let entries;
 		try {
-			entries = await fs$1.readdir(dir, { withFileTypes: true });
+			entries = await fs.readdir(dir, { withFileTypes: true });
 		} catch {
 			return;
 		}
@@ -440,12 +415,18 @@ async function collectLegacyMatrixStateRoots(stateDir, filename, options) {
 	await visit(matrixRoot);
 	return roots.filter((root) => options?.includeMatrixRoot || path.resolve(root) !== path.resolve(matrixRoot)).toSorted();
 }
-async function collectLegacySyncCacheRoots(stateDir) {
-	return collectLegacyMatrixStateRoots(stateDir, MATRIX_SYNC_CACHE_FILENAME);
+async function* readLegacyMatrixSyncCaches(stateDir) {
+	for (const storageRootDir of await collectLegacyMatrixStateRoots(stateDir, MATRIX_SYNC_CACHE_FILENAME)) {
+		const persisted = await readLegacyMatrixSyncCacheState(storageRootDir);
+		if (persisted) yield {
+			storageRootDir,
+			persisted
+		};
+	}
 }
 async function readLegacyMatrixStorageMetadata(storageRootDir) {
 	try {
-		return normalizeMatrixStorageMetadata(JSON.parse(await fs$1.readFile(path.join(storageRootDir, MATRIX_STORAGE_META_FILENAME), "utf8")));
+		return normalizeMatrixStorageMetadata(JSON.parse(await fs.readFile(path.join(storageRootDir, MATRIX_STORAGE_META_FILENAME), "utf8")));
 	} catch {
 		return null;
 	}
@@ -468,6 +449,7 @@ async function archiveLegacyMatrixStateFile(params) {
 	if (params.notice && params.warnings.length === warningCount) params.notices?.push(params.notice);
 }
 const stateMigrations = [
+	matrixAccountStateSchemaMigration,
 	{
 		id: "matrix-credentials-json-to-plugin-state",
 		label: "Matrix credentials",
@@ -698,19 +680,14 @@ const stateMigrations = [
 		label: "Matrix sync cache",
 		async detectLegacyState(params) {
 			const previews = [];
-			for (const storageRootDir of await collectLegacySyncCacheRoots(params.stateDir)) {
-				if (!await readLegacyMatrixSyncCacheState(storageRootDir)) continue;
-				previews.push(`Matrix sync cache JSON can migrate to SQLite: ${storageRootDir}`);
-			}
+			for await (const { storageRootDir } of readLegacyMatrixSyncCaches(params.stateDir)) previews.push(`Matrix sync cache JSON can migrate to SQLite: ${storageRootDir}`);
 			return previews.length > 0 ? { preview: previews } : null;
 		},
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
 			const notices = [];
-			for (const storageRootDir of await collectLegacySyncCacheRoots(params.stateDir)) {
-				const persisted = await readLegacyMatrixSyncCacheState(storageRootDir);
-				if (!persisted) continue;
+			for await (const { storageRootDir, persisted } of readLegacyMatrixSyncCaches(params.stateDir)) {
 				const store = params.context.openPluginStateKeyedStore(openMatrixSyncCacheStoreOptions(storageRootDir));
 				if (await hasMatrixSyncCacheStateInStore({
 					storageRootDir,
@@ -840,13 +817,16 @@ const stateMigrations = [
 					warnings
 				});
 			}
-			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME, { includeMatrixRoot: true })) await migrateLegacyMatrixIdbSnapshot({
-				storageRootDir,
-				context: params.context,
-				changes,
-				notices,
-				warnings
-			});
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME, { includeMatrixRoot: true })) {
+				const { migrateLegacyMatrixIdbSnapshot } = await import("./crypto-snapshot-doctor.runtime-D0v841D_.js");
+				await migrateLegacyMatrixIdbSnapshot({
+					storageRootDir,
+					context: params.context,
+					changes,
+					notices,
+					warnings
+				});
+			}
 			return {
 				changes,
 				warnings,

package/dist/{draft-stream-B_m79Ynb.js → draft-stream-DglwxWzJ.js}

@@ -1,4 +1,4 @@
-import { E as MsgType, a as sendSingleTextMessageMatrix, l as prepareMatrixSingleText, t as editMessageMatrix } from "./send-BKu9Ghi4.js";
+import { T as MsgType, a as sendSingleTextMessageMatrix, c as prepareMatrixSingleText, t as editMessageMatrix } from "./send-B5XChnvB.js";
 import { createFinalizableDraftStreamControlsForState } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/matrix/src/matrix/draft-stream.ts
 const DEFAULT_THROTTLE_MS = 1e3;

package/dist/{encryption-guidance-DmLY8NiO.js → encryption-guidance-BNcZNQZI.js}

@@ -1,9 +1,10 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-CWuhuFn1.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-DA-jfx22.js";
 import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/encryption-guidance.ts
 function resolveMatrixEncryptionConfigPath(cfg, accountId) {
-	return resolveMatrixConfigFieldPath(cfg, normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg), "encryption");
+	const effectiveAccountId = normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg);
+	return resolveMatrixConfigFieldPath(cfg, effectiveAccountId, "encryption");
 }
 function formatMatrixEncryptionUnavailableError(cfg, accountId) {
 	return `Matrix encryption is not available (enable ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true)`;

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-CWuhuFn1.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, i as resolveMatrixChannelConfig, n as requiresExplicitMatrixDefaultAccount, r as resolveConfiguredMatrixAccountIds, t as findMatrixAccountEntry } from "./account-selection-DA-jfx22.js";
 import { n as listMatrixEnvAccountIds, r as resolveMatrixEnvAccountToken, t as getMatrixScopedEnvVarNames } from "./env-vars-dGqak9dN.js";
 import { a as resolveMatrixCredentialsPath, i as resolveMatrixCredentialsFilename, n as resolveMatrixAccountStorageRoot, o as resolveMatrixHomeserverKey, r as resolveMatrixCredentialsDir, s as sanitizeMatrixPathSegment, t as hashMatrixAccessToken } from "./storage-paths-gUmSydsW.js";
 export { findMatrixAccountEntry, getMatrixScopedEnvVarNames, hashMatrixAccessToken, listMatrixEnvAccountIds, requiresExplicitMatrixDefaultAccount, resolveConfiguredMatrixAccountIds, resolveMatrixAccountStorageRoot, resolveMatrixChannelConfig, resolveMatrixCredentialsDir, resolveMatrixCredentialsFilename, resolveMatrixCredentialsPath, resolveMatrixDefaultOrOnlyAccountId, resolveMatrixEnvAccountToken, resolveMatrixHomeserverKey, sanitizeMatrixPathSegment };

package/dist/{http-client-D8o8b9u6.js → http-client-DOmFvKvB.js}

@@ -28,8 +28,8 @@ async function readResponseWithLimit$1(res, maxBytes, opts) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/sdk/transport.ts
-const MATRIX_JSON_RESPONSE_MAX_BYTES = 8 * 1024 * 1024;
-const MATRIX_SDK_RESPONSE_MAX_BYTES = 64 * 1024 * 1024;
+const MATRIX_JSON_RESPONSE_MAX_BYTES = 8388608;
+const MATRIX_SDK_RESPONSE_MAX_BYTES = 67108864;
 function normalizeEndpoint(endpoint) {
 	if (!endpoint) return "/";
 	return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
@@ -116,7 +116,8 @@ async function fetchWithMatrixGuardedRedirects(params) {
 	for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
 		let dispatcher;
 		try {
-			dispatcher = createPinnedDispatcher(await resolvePinnedHostnameWithPolicy(currentUrl.hostname, { policy: params.ssrfPolicy }), params.dispatcherPolicy, params.ssrfPolicy);
+			const pinned = await resolvePinnedHostnameWithPolicy(currentUrl.hostname, { policy: params.ssrfPolicy });
+			dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.ssrfPolicy);
 			const response = await fetchWithMatrixDispatcher({
 				url: currentUrl.toString(),
 				init: {
@@ -216,10 +217,12 @@ async function performMatrixRequest(params) {
 	headers.set("Accept", params.raw ? "*/*" : "application/json");
 	if (params.accessToken) headers.set("Authorization", `Bearer ${params.accessToken}`);
 	let body;
-	if (params.body !== void 0) if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") body = params.body;
-	else {
-		headers.set("Content-Type", "application/json");
-		body = JSON.stringify(params.body);
+	if (params.body !== void 0) {
+		if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") body = params.body;
+		else {
+			headers.set("Content-Type", "application/json");
+			body = JSON.stringify(params.body);
+		}
 	}
 	const { response, release } = await fetchWithMatrixGuardedRedirects({
 		url: baseUrl.toString(),

package/dist/{idb-persistence-DfgW720p.js → idb-persistence-CU7CNLlX.js}

@@ -1,6 +1,6 @@
-import { D as writeMatrixIdbSnapshotJson, f as MATRIX_IDB_SNAPSHOT_FILENAME, w as readMatrixIdbSnapshotJson } from "./storage-BsGuHngK.js";
+import { D as writeMatrixIdbSnapshotJson, f as MATRIX_IDB_SNAPSHOT_FILENAME, w as readMatrixIdbSnapshotJson } from "./storage-BVf4uucD.js";
 import { n as LogService } from "./logger-B_71hN6W.js";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-DAJ49nZX.js";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.js";
 import path from "node:path";
 import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import fs from "node:fs";

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

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

package/dist/{inbound-dedupe-RvSLqdsz.js → inbound-dedupe-Ch33GU06.js}

@@ -4,7 +4,7 @@ import { createChannelReplayGuard, resolvePersistentDedupePluginStateNamespace }
 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_TTL_MS = 2592e6;
 const MATRIX_INBOUND_DEDUPE_MEMORY_MAX = 5e3;
 const MATRIX_INBOUND_DEDUPE_STATE_MAX_ENTRIES = 2e4;
 function resolveMatrixInboundDedupeAccountId(accountId) {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerMatrixCliMetadata } from "./cli-metadata-DrYVwQ_r.js";
+import { n as registerMatrixCliMetadata } from "./cli-metadata-BGryAl2e.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/{messages-Dow9EOoJ.js → messages-Czn8lNEh.js}

@@ -1,14 +1,163 @@
 import { n as MATRIX_REACTION_EVENT_TYPE } from "./reaction-common-DkrQdBSZ.js";
-import { h as isPollStartType, m as isPollEventType, r as sendMessageMatrix, t as editMessageMatrix } from "./send-BKu9Ghi4.js";
-import { a as resolveBundledMatrixReplacementContent, l as resolveMatrixPollRootEventId, o as resolveMatrixMessageAttachment, s as fetchMatrixPollMessageSummary } from "./media-text-OR9uoC4W.js";
-import { r as withResolvedRoomAction } from "./client-BUtHbzib.js";
+import { _ as resolvePollReferenceEventId, d as formatPollAsText, f as formatPollResultsAsText, g as parsePollStartContent, m as isPollStartType, p as isPollEventType, r as sendMessageMatrix, t as editMessageMatrix, u as buildPollResultsSummary } from "./send-B5XChnvB.js";
+import { r as withResolvedRoomAction } from "./client-oNOlldJI.js";
 import { n as isMatrixNotFoundError } from "./errors-DKVS3_DO.js";
-import { asNullableObjectRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asNullableObjectRecord, asNullableRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
+//#region extensions/matrix/src/matrix/poll-summary.ts
+function resolveMatrixPollRootEventId(event) {
+	if (isPollStartType(event.type)) {
+		const eventId = event.event_id?.trim();
+		return eventId ? eventId : null;
+	}
+	return resolvePollReferenceEventId(event.content);
+}
+async function readAllPollRelations(client, roomId, pollEventId) {
+	const relationEvents = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let nextBatch;
+	do {
+		const page = await client.getRelations(roomId, pollEventId, "m.reference", void 0, { from: nextBatch });
+		relationEvents.push(...page.events);
+		nextBatch = page.nextBatch ?? void 0;
+		if (nextBatch && seenCursors.has(nextBatch)) throw new Error("Matrix poll pagination returned a repeated cursor");
+		if (nextBatch) seenCursors.add(nextBatch);
+	} while (nextBatch);
+	return relationEvents;
+}
+async function fetchMatrixPollSnapshot(client, roomId, event) {
+	if (!isPollEventType(event.type)) return null;
+	const pollEventId = resolveMatrixPollRootEventId(event);
+	if (!pollEventId) return null;
+	const rootEvent = isPollStartType(event.type) ? event : await client.getEvent(roomId, pollEventId);
+	if (!isPollStartType(rootEvent.type)) return null;
+	const pollStartContent = rootEvent.content;
+	const pollSummary = parsePollStartContent(pollStartContent);
+	if (!pollSummary) return null;
+	const relationEvents = await readAllPollRelations(client, roomId, pollEventId);
+	const pollResults = buildPollResultsSummary({
+		pollEventId,
+		roomId,
+		sender: rootEvent.sender,
+		senderName: rootEvent.sender,
+		content: pollStartContent,
+		relationEvents
+	});
+	return {
+		pollEventId,
+		triggerEvent: event,
+		rootEvent,
+		text: pollResults ? formatPollResultsAsText(pollResults) : formatPollAsText(pollSummary)
+	};
+}
+async function fetchMatrixPollMessageSummary(client, roomId, event) {
+	const snapshot = await fetchMatrixPollSnapshot(client, roomId, event);
+	if (!snapshot) return null;
+	return {
+		eventId: snapshot.pollEventId,
+		sender: snapshot.rootEvent.sender,
+		body: snapshot.text,
+		msgtype: "m.text",
+		timestamp: snapshot.triggerEvent.origin_server_ts || snapshot.rootEvent.origin_server_ts
+	};
+}
+//#endregion
 //#region extensions/matrix/src/matrix/actions/limits.ts
 function resolveMatrixActionLimit(raw, fallback) {
 	return Math.max(1, Math.floor(raw !== void 0 && Number.isFinite(raw) ? raw : fallback));
 }
 //#endregion
+//#region extensions/matrix/src/matrix/media-text.ts
+const MATRIX_MEDIA_KINDS = {
+	"m.audio": "audio",
+	"m.file": "file",
+	"m.image": "image",
+	"m.sticker": "sticker",
+	"m.video": "video"
+};
+function resolveMatrixMediaKind(msgtype) {
+	return MATRIX_MEDIA_KINDS[msgtype ?? ""] ?? null;
+}
+function resolveMatrixMediaLabel(kind, fallback = "media") {
+	return `${kind ?? fallback} attachment`;
+}
+function formatMatrixAttachmentMarker(params) {
+	const label = resolveMatrixMediaLabel(params.kind);
+	if (params.tooLarge) return `[matrix ${label} too large]`;
+	return params.unavailable ? `[matrix ${label} unavailable]` : `[matrix ${label}]`;
+}
+function isLikelyBareFilename(text) {
+	const trimmed = text.trim();
+	if (!trimmed || trimmed.includes("\n") || /\s/.test(trimmed)) return false;
+	if (path.basename(trimmed) !== trimmed) return false;
+	return path.extname(trimmed).length > 1;
+}
+function resolveCaptionOrFilename(params) {
+	const body = params.body?.trim() ?? "";
+	const filename = params.filename?.trim() ?? "";
+	if (filename) {
+		if (!body || body === filename) return { filename };
+		return {
+			caption: body,
+			filename
+		};
+	}
+	if (!body) return {};
+	if (isLikelyBareFilename(body)) return { filename: body };
+	return { caption: body };
+}
+function resolveBundledMatrixReplacementContent(event) {
+	const replacement = asNullableObjectRecord(event.unsigned?.["m.relations"]?.["m.replace"]);
+	if (!replacement || event.state_key !== void 0) return;
+	const content = asNullableObjectRecord(replacement.content);
+	const relation = asNullableObjectRecord(content?.["m.relates_to"]);
+	const newContent = content?.["m.new_content"];
+	if (replacement.sender !== event.sender || replacement.type !== event.type || replacement.state_key !== void 0 || asNullableObjectRecord(replacement.unsigned)?.redacted_because || !relation || relation.rel_type !== "m.replace" || relation.event_id !== event.event_id) return;
+	return asNullableRecord(newContent) ?? void 0;
+}
+function resolveMatrixMessageAttachment(params) {
+	const kind = resolveMatrixMediaKind(params.msgtype);
+	if (!kind) return;
+	const resolved = resolveCaptionOrFilename(params);
+	return {
+		kind,
+		caption: resolved.caption,
+		filename: resolved.filename
+	};
+}
+function formatMatrixAttachmentText(params) {
+	if (!params.attachment) return;
+	return formatMatrixAttachmentMarker({
+		kind: params.attachment.kind,
+		tooLarge: params.tooLarge,
+		unavailable: params.unavailable
+	});
+}
+function formatMatrixMessageText(params) {
+	const attachment = resolveMatrixMessageAttachment(params);
+	const body = attachment ? attachment.caption ?? "" : params.body?.trim() ?? "";
+	const marker = formatMatrixAttachmentText({
+		attachment,
+		tooLarge: params.tooLarge,
+		unavailable: params.unavailable
+	});
+	if (!marker) return body || void 0;
+	if (!body) return marker;
+	return `${body}\n\n${marker}`;
+}
+function formatMatrixMediaUnavailableText(params) {
+	return formatMatrixMessageText({
+		...params,
+		unavailable: true
+	}) ?? "";
+}
+function formatMatrixMediaTooLargeText(params) {
+	return formatMatrixMessageText({
+		...params,
+		tooLarge: true
+	}) ?? "";
+}
+//#endregion
 //#region extensions/matrix/src/matrix/actions/types.ts
 const EventType = {
 	RoomMessage: "m.room.message",
@@ -258,4 +407,4 @@ async function isMatrixPollRootThreaded(params) {
 	return hydratedRoot ? isMatrixThreadEvent(hydratedRoot) : false;
 }
 //#endregion
-export { fetchEventSummary as a, resolveMatrixActionLimit as c, sendMatrixMessage as i, editMatrixMessage as n, readPinnedEvents as o, readMatrixMessages as r, EventType as s, deleteMatrixMessage as t };
+export { fetchEventSummary as a, formatMatrixMediaTooLargeText as c, isLikelyBareFilename as d, resolveBundledMatrixReplacementContent as f, sendMatrixMessage as i, formatMatrixMediaUnavailableText as l, fetchMatrixPollSnapshot as m, editMatrixMessage as n, readPinnedEvents as o, resolveMatrixActionLimit as p, readMatrixMessages as r, EventType as s, deleteMatrixMessage as t, formatMatrixMessageText as u };