@openclaw/matrix 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{profile-B3DD2jYa.mjs → profile-DS0xdJAi.mjs}

@@ -1,4 +1,4 @@
-import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/matrix/profile.ts
 var profile_exports = /* @__PURE__ */ __exportAll({
@@ -16,42 +16,22 @@ function isMatrixHttpAvatarUri(value) {
 function isSupportedMatrixAvatarSource(value) {
 	return isMatrixMxcUri(value) || isMatrixHttpAvatarUri(value);
 }
-async function uploadAvatarMedia(params) {
-	const media = await params.loadAvatar(params.avatarSource, params.avatarMaxBytes);
-	return await params.client.uploadContent(media.buffer, media.contentType, media.fileName || "avatar");
-}
 async function resolveAvatarUrl(params) {
 	const avatarPath = normalizeOptionalString(params.avatarPath) ?? null;
-	if (avatarPath) {
-		if (!params.loadAvatarFromPath) throw new Error("Matrix avatar path upload requires a media loader.");
-		return {
-			resolvedAvatarUrl: await uploadAvatarMedia({
-				client: params.client,
-				avatarSource: avatarPath,
-				avatarMaxBytes: params.avatarMaxBytes,
-				loadAvatar: params.loadAvatarFromPath
-			}),
-			uploadedAvatarSource: "path",
-			convertedAvatarFromHttp: false
-		};
-	}
-	const avatarUrl = normalizeOptionalString(params.avatarUrl) ?? null;
-	if (!avatarUrl || isMatrixMxcUri(avatarUrl)) return {
-		resolvedAvatarUrl: avatarUrl,
+	const avatarSource = avatarPath ?? normalizeOptionalString(params.avatarUrl) ?? null;
+	if (!avatarSource || !avatarPath && isMatrixMxcUri(avatarSource)) return {
+		resolvedAvatarUrl: avatarSource,
 		uploadedAvatarSource: null,
 		convertedAvatarFromHttp: false
 	};
-	if (!isMatrixHttpAvatarUri(avatarUrl)) throw new Error("Matrix avatar URL must be an mxc:// URI or an http(s) URL.");
-	if (!params.loadAvatarFromUrl) throw new Error("Matrix avatar URL conversion requires a media loader.");
+	if (!avatarPath && !isMatrixHttpAvatarUri(avatarSource)) throw new Error("Matrix avatar URL must be an mxc:// URI or an http(s) URL.");
+	const loadAvatar = avatarPath ? params.loadAvatarFromPath : params.loadAvatarFromUrl;
+	if (!loadAvatar) throw new Error(avatarPath ? "Matrix avatar path upload requires a media loader." : "Matrix avatar URL conversion requires a media loader.");
+	const media = await loadAvatar(avatarSource, params.avatarMaxBytes);
 	return {
-		resolvedAvatarUrl: await uploadAvatarMedia({
-			client: params.client,
-			avatarSource: avatarUrl,
-			avatarMaxBytes: params.avatarMaxBytes,
-			loadAvatar: params.loadAvatarFromUrl
-		}),
-		uploadedAvatarSource: "http",
-		convertedAvatarFromHttp: true
+		resolvedAvatarUrl: await params.client.uploadContent(media.buffer, media.contentType, media.fileName || "avatar"),
+		uploadedAvatarSource: avatarPath ? "path" : "http",
+		convertedAvatarFromHttp: !avatarPath
 	};
 }
 async function syncMatrixOwnProfile(params) {

package/dist/.setup/{profile-update-CmxIAd4c.mjs → profile-update-C1n8SRqH.mjs}

@@ -1,8 +1,8 @@
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
 import { n as resolveMatrixConfigPath } from "./config-paths-CnREYb1Y.mjs";
-import { n as updateMatrixAccountConfig } from "./config-update-5m1Un5gJ.mjs";
-import { r as syncMatrixOwnProfile } from "./profile-B3DD2jYa.mjs";
-import { n as withResolvedActionClient } from "./client-BXATebyo.mjs";
+import { n as updateMatrixAccountConfig } from "./config-update-CZndPxNd.mjs";
+import { r as syncMatrixOwnProfile } from "./profile-DS0xdJAi.mjs";
+import { n as withResolvedActionClient } from "./client-DY3HExqI.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/actions/profile.ts
 async function updateMatrixOwnProfile(opts = {}) {

package/dist/.setup/{reaction-events-mnzc_JvP.mjs → reaction-events-Cqq46xsG.mjs}

@@ -1,16 +1,16 @@
 import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
-import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRoute } from "./channel-DXenXmj0.mjs";
+import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRoute } from "./channel-CeRXEAEP.mjs";
 import { c as extractMatrixReactionAnnotation } from "./send-currentness-C2rMVVIQ.mjs";
-import { p as resolveMatrixThreadRootId } from "./direct-management-Cn2t8n1V.mjs";
-import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-BrS5ECU0.mjs";
+import { p as resolveMatrixThreadRootId } from "./direct-management-DJtQhLKH.mjs";
+import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-DhB6gNPU.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { getSessionBindingService } from "openclaw/plugin-sdk/session-binding-runtime";
 //#region extensions/matrix/src/matrix/monitor/reaction-events.ts
-const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./channel-DXenXmj0.mjs").then((n) => n.s));
+const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./channel-CeRXEAEP.mjs").then((n) => n.s));
 const loadExecApprovalResolver = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/approval-gateway-runtime"));
-const loadMatrixSend = createLazyRuntimeModule(() => import("./send-GOF64QRc.mjs").then((n) => n.s));
+const loadMatrixSend = createLazyRuntimeModule(() => import("./send-B1Y2L4wj.mjs").then((n) => n.s));
 function buildMatrixApprovalTerminalText(result) {
 	const approval = result.approval;
 	const terminalLabel = approval.status === "allowed" ? approval.decision === "allow-always" ? "Allowed always" : "Allowed once" : approval.status === "denied" ? "Denied" : approval.status === "expired" ? "Expired" : "Cancelled";

package/dist/.setup/{resolve-targets-BFq3q4c9.mjs → resolve-targets-DFeU1Ww6.mjs}

@@ -1,6 +1,6 @@
-import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
-import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-_sw-Q7KO.mjs";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-DW5UykLL.mjs";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/resolve-targets.ts
 var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });

package/dist/.setup/retired-state-BXUQ2I-C.mjs

@@ -0,0 +1,91 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
+import { extractErrorCode } from "openclaw/plugin-sdk/error-runtime";
+import os from "node:os";
+import fs from "node:fs/promises";
+//#region extensions/matrix/src/matrix/chunked-state.ts
+function chunkMatrixStateJson(value, maxBytes, maxChunks, limitMessage) {
+	const chunks = [];
+	const pushChunk = (chunk) => {
+		if (chunks.length >= maxChunks) throw new Error(limitMessage);
+		chunks.push(chunk);
+	};
+	let current = "";
+	let currentBytes = 0;
+	for (const char of value) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current && currentBytes + charBytes > maxBytes) {
+			pushChunk(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current) pushChunk(current);
+	return chunks;
+}
+async function readMatrixStateChunks(store, keys, kind) {
+	const records = await store.lookupMany?.(keys);
+	const chunks = [];
+	for (let index = 0; index < keys.length; index += 1) {
+		const result = records?.[index];
+		if (result && !result.ok) throw result.error;
+		const chunk = records ? result?.value : await store.lookup(keys[index]);
+		if (!isRecord(chunk) || chunk.kind !== kind || chunk.index !== index || typeof chunk.data !== "string") return null;
+		chunks.push(chunk.data);
+	}
+	return chunks;
+}
+async function writeMatrixStateChunks(store, rows, chunkKeyPrefix) {
+	for (const row of rows.chunks) await store.register(row.key, row.value);
+	await store.register(rows.meta.key, rows.meta.value);
+	for (const row of await store.entries()) if (row.key.startsWith(chunkKeyPrefix) && !rows.nextChunkKeys.has(row.key)) await store.delete(row.key);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sqlite-state.ts
+function resolveStateDirOverride(options) {
+	if (!options) return;
+	return options.stateDir || options.stateRootDir || getMatrixRuntime().state.resolveStateDir(options.env ?? process.env, os.homedir);
+}
+function resolveMatrixSqliteStateKey(options) {
+	return resolveStateDirOverride(options) ?? "";
+}
+function resolveMatrixSqliteStateEnv(options) {
+	const stateDir = resolveStateDirOverride(options);
+	if (!stateDir) return options?.env;
+	return {
+		...options?.env ?? process.env,
+		OPENCLAW_STATE_DIR: stateDir
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/retired-state.ts
+const RETIRED_MATRIX_STATE_FILENAMES = /* @__PURE__ */ new Set([
+	"thread-bindings.json",
+	"startup-verification.json",
+	"recovery-key.json",
+	"legacy-crypto-migration.json",
+	"crypto-idb-snapshot.json",
+	"storage-meta.json",
+	"inbound-dedupe.json"
+]);
+async function assertMatrixSupportedStateRoot(rootDir) {
+	for (const filename of RETIRED_MATRIX_STATE_FILENAMES) await assertMatrixSupportedStateFile(path.join(rootDir, filename));
+}
+const RETIRED_MATRIX_STATE_REMEDIATION = "Install OpenClaw 2026.9.5, run \"openclaw doctor --fix\", and start the Matrix channel once to migrate it, then upgrade to latest.";
+function describeRetiredMatrixState(filePath) {
+	return `Retired pre-July Matrix state at ${filePath} was left unchanged. ${RETIRED_MATRIX_STATE_REMEDIATION} See https://docs.openclaw.ai/channels/matrix-migration.`;
+}
+async function assertMatrixSupportedStateFile(filePath) {
+	try {
+		await fs.lstat(filePath);
+	} catch (error) {
+		if (extractErrorCode(error) === "ENOENT") return;
+		throw error;
+	}
+	throw new Error(describeRetiredMatrixState(filePath));
+}
+//#endregion
+export { describeRetiredMatrixState as a, chunkMatrixStateJson as c, assertMatrixSupportedStateRoot as i, readMatrixStateChunks as l, RETIRED_MATRIX_STATE_REMEDIATION as n, resolveMatrixSqliteStateEnv as o, assertMatrixSupportedStateFile as r, resolveMatrixSqliteStateKey as s, RETIRED_MATRIX_STATE_FILENAMES as t, writeMatrixStateChunks as u };

package/dist/.setup/{room-info-BbTGRJcR.mjs → room-info-BPMbwe8I.mjs}

@@ -1,12 +1,11 @@
-import { D as setBoundedMap, E as resolveMatrixRoomId } from "./send-GOF64QRc.mjs";
-import { c as EventType } from "./messages-Buz27pi5.mjs";
-import { n as withResolvedActionClient, r as withResolvedRoomAction } from "./client-BXATebyo.mjs";
+import { w as setBoundedMap } from "./send-B1Y2L4wj.mjs";
+import { c as EventType } from "./messages-uCbwLRKS.mjs";
+import { r as withResolvedRoomAction } from "./client-DY3HExqI.mjs";
 import { n as isMatrixNotFoundError } from "./errors-DKVS3_DO.mjs";
 import { filterStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/matrix/actions/room.ts
 async function getMatrixMemberInfo(userId, opts) {
-	return await withResolvedActionClient(opts, async (client) => {
-		const roomId = await resolveMatrixRoomId(client, opts.roomId);
+	return await withResolvedRoomAction(opts.roomId, opts, async (client, roomId) => {
 		if (!(await client.getJoinedRoomMembers(roomId)).includes(userId)) throw new Error(`User ${userId} is not a member of room ${roomId}`);
 		const profile = await client.getUserProfile(userId);
 		return {
@@ -48,63 +47,47 @@ async function getMatrixRoomInfo(roomId, opts = {}) {
 const MAX_ROOM_INFO = 1024;
 const MAX_MEMBER_DISPLAY_NAMES = 4096;
 function createMatrixRoomInfoResolver(client) {
-	const roomNameCache = /* @__PURE__ */ new Map();
-	const roomAliasCache = /* @__PURE__ */ new Map();
 	const memberDisplayNameCache = /* @__PURE__ */ new Map();
-	const getRoomName = async (roomId) => {
-		const cached = roomNameCache.get(roomId);
-		if (cached) return cached;
-		let name;
-		let nameResolved = false;
-		try {
-			const nameState = await client.getRoomStateEvent(roomId, "m.room.name", "");
-			nameResolved = true;
-			if (nameState && typeof nameState.name === "string") name = nameState.name;
-		} catch (err) {
-			if (isMatrixNotFoundError(err)) nameResolved = true;
-		}
-		const info = {
-			name,
-			nameResolved
+	function createRoomStateResolver(eventType, project) {
+		const cache = /* @__PURE__ */ new Map();
+		return async (roomId) => {
+			const cached = cache.get(roomId);
+			if (cached) return cached;
+			let state;
+			let resolved;
+			try {
+				state = await client.getRoomStateEvent(roomId, eventType, "");
+				resolved = true;
+			} catch (err) {
+				resolved = isMatrixNotFoundError(err);
+			}
+			const info = {
+				value: project(state),
+				resolved
+			};
+			if (resolved) setBoundedMap(cache, roomId, info, MAX_ROOM_INFO);
+			return info;
 		};
-		if (nameResolved) setBoundedMap(roomNameCache, roomId, info, MAX_ROOM_INFO);
-		return info;
-	};
-	const getRoomAliases = async (roomId) => {
-		const cached = roomAliasCache.get(roomId);
-		if (cached) return cached;
-		let canonicalAlias;
-		let altAliases = [];
-		let aliasesResolved = false;
-		try {
-			const aliasState = await client.getRoomStateEvent(roomId, "m.room.canonical_alias", "");
-			aliasesResolved = true;
-			if (aliasState && typeof aliasState.alias === "string") canonicalAlias = aliasState.alias;
-			const rawAliases = aliasState?.alt_aliases;
-			if (Array.isArray(rawAliases)) altAliases = rawAliases.filter((entry) => typeof entry === "string");
-		} catch (err) {
-			if (isMatrixNotFoundError(err)) aliasesResolved = true;
-		}
-		const info = {
-			canonicalAlias,
-			altAliases,
-			aliasesResolved
-		};
-		if (aliasesResolved) setBoundedMap(roomAliasCache, roomId, info, MAX_ROOM_INFO);
-		return info;
-	};
+	}
+	const getRoomName = createRoomStateResolver("m.room.name", (state) => typeof state?.name === "string" ? state.name : void 0);
+	const getRoomAliases = createRoomStateResolver("m.room.canonical_alias", (state) => ({
+		canonicalAlias: typeof state?.alias === "string" ? state.alias : void 0,
+		altAliases: Array.isArray(state?.alt_aliases) ? state.alt_aliases.filter((entry) => typeof entry === "string") : []
+	}));
 	const getRoomInfo = async (roomId, opts = {}) => {
-		const { name, nameResolved } = await getRoomName(roomId);
+		const { value: name, resolved: nameResolved } = await getRoomName(roomId);
 		if (!opts.includeAliases) return {
 			name,
 			altAliases: [],
 			nameResolved,
 			aliasesResolved: false
 		};
+		const { value: aliases, resolved: aliasesResolved } = await getRoomAliases(roomId);
 		return {
 			name,
 			nameResolved,
-			...await getRoomAliases(roomId)
+			...aliases,
+			aliasesResolved
 		};
 	};
 	const getMemberDisplayName = async (roomId, userId) => {