@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/dist/{storage-BsGuHngK.js → storage-BVf4uucD.js}

@@ -33,7 +33,7 @@ const LEGACY_CRYPTO_MIGRATION_NAMESPACE = "legacy-crypto-migration";
 const IDB_SNAPSHOT_NAMESPACE = "idb-snapshot";
 const SMALL_STATE_MAX_ENTRIES = 10;
 const IDB_SNAPSHOT_MAX_ENTRIES = 2e4;
-const IDB_SNAPSHOT_MAX_CHUNKS = Math.floor((IDB_SNAPSHOT_MAX_ENTRIES - 1) / 2);
+const IDB_SNAPSHOT_MAX_CHUNKS = Math.floor(19999 / 2);
 const IDB_SNAPSHOT_CHUNK_BYTES = 24e3;
 const MATRIX_RECOVERY_KEY_FILENAME = "recovery-key.json";
 const MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME = "legacy-crypto-migration.json";
@@ -487,8 +487,9 @@ function resolvePreferredMatrixStorageRoot(params) {
 }
 function resolveMatrixStoragePaths(params) {
 	const env = params.env ?? process.env;
+	const stateDir = params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir);
 	const canonical = resolveMatrixAccountStorageRoot({
-		stateDir: params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir),
+		stateDir,
 		homeserver: params.homeserver,
 		userId: params.userId,
 		accessToken: params.accessToken,
@@ -526,7 +527,7 @@ function resolveMatrixStateFilePath(params) {
 }
 async function maybeMigrateLegacyStorage(params) {
 	const hasAccountScopedLegacyStorageFile = fs.existsSync(params.storagePaths.storagePath);
-	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./file-sync-store-DjskBX2o.js").then((n) => n.n) : null;
+	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-d-A_OhbU.js").then((n) => n.s) : null;
 	const hasAccountScopedLegacyStorage = hasAccountScopedLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(params.storagePaths.rootDir) !== null;
 	const hasAccountScopedRecoveryKey = fs.existsSync(params.storagePaths.recoveryKeyPath);
 	const hasAccountScopedLegacyCryptoMigration = fs.existsSync(path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
@@ -573,7 +574,7 @@ async function maybeMigrateLegacyStorage(params) {
 	if (skippedExistingTargets.length > 0) logger.warn?.(`matrix: legacy client storage files were left in place because their migrated targets already existed.\n${skippedExistingTargets.join("\n")}`);
 }
 async function migrateLegacySyncCacheToSqlite(params) {
-	const syncCache = await import("./file-sync-store-DjskBX2o.js").then((n) => n.n);
+	const syncCache = await import("./sync-cache-state-d-A_OhbU.js").then((n) => n.s);
 	const persisted = await syncCache.readLegacyMatrixSyncCacheState(params.sourceRootDir);
 	if (!persisted) return;
 	const store = getMatrixRuntime().state.openKeyedStore(syncCache.openMatrixSyncCacheStoreOptions(params.targetRootDir));

package/dist/{subagent-hooks-CMoZaARG.js → subagent-hooks-DeICLbU5.js}

@@ -13,7 +13,11 @@ async function handleMatrixSubagentEnded(event) {
 			const bindingId = resolveBindingKey(binding);
 			if ((await bindingService.unbind({
 				bindingId,
-				reason
+				reason,
+				scope: {
+					channel: "matrix",
+					accountId: binding.accountId
+				}
 			})).some((entry) => entry.bindingId === bindingId)) removedBindingKeys.add(bindingId);
 		}
 	}

package/dist/subagent-hooks-api.js

@@ -1,6 +1,6 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/matrix/subagent-hooks-api.ts
-const loadMatrixSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-CMoZaARG.js"));
+const loadMatrixSubagentHooksModule = createLazyRuntimeModule(() => import("./subagent-hooks-DeICLbU5.js"));
 function registerMatrixSubagentHooks(api) {
 	api.on("subagent_ended", async (event) => {
 		const { handleMatrixSubagentEnded } = await loadMatrixSubagentHooksModule();

package/dist/sync-cache-state-d-A_OhbU.js

@@ -0,0 +1,234 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { M as resolveMatrixSqliteStateEnv } from "./storage-BVf4uucD.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region extensions/matrix/src/matrix/client/sync-cache-state.ts
+var sync_cache_state_exports = /* @__PURE__ */ __exportAll({
+	MATRIX_SYNC_CACHE_VERSION: () => 1,
+	deleteMatrixSyncCacheStateFromSyncStore: () => deleteMatrixSyncCacheStateFromSyncStore,
+	hasMatrixSyncCacheStateInStore: () => hasMatrixSyncCacheStateInStore,
+	openMatrixSyncCacheStoreOptions: () => openMatrixSyncCacheStoreOptions,
+	readLegacyMatrixSyncCacheState: () => readLegacyMatrixSyncCacheState,
+	readPersistedStoreFromSyncStore: () => readPersistedStoreFromSyncStore,
+	writeMatrixSyncCacheStateToStore: () => writeMatrixSyncCacheStateToStore,
+	writeMatrixSyncCacheStateToSyncStore: () => writeMatrixSyncCacheStateToSyncStore
+});
+const MATRIX_SYNC_CACHE_VERSION = 1;
+const SYNC_CACHE_NAMESPACE = "sync-cache";
+const SYNC_CACHE_MAX_ENTRIES = 2e4;
+const SYNC_CACHE_MAX_CHUNKS = Math.floor(19999 / 2);
+const SYNC_CACHE_STATE_KEY = "current";
+const SYNC_CACHE_CHUNK_BYTES = 24e3;
+function normalizeRoomsData(value) {
+	if (!isRecord(value)) return null;
+	return {
+		join: isRecord(value.join) ? value.join : {},
+		invite: isRecord(value.invite) ? value.invite : {},
+		leave: isRecord(value.leave) ? value.leave : {},
+		knock: isRecord(value.knock) ? value.knock : {}
+	};
+}
+function toPersistedSyncData(value) {
+	if (!isRecord(value)) return null;
+	if (typeof value.nextBatch === "string" && value.nextBatch.trim()) {
+		const roomsData = normalizeRoomsData(value.roomsData);
+		if (!Array.isArray(value.accountData) || !roomsData) return null;
+		return {
+			nextBatch: value.nextBatch,
+			accountData: value.accountData,
+			roomsData
+		};
+	}
+	if (typeof value.next_batch === "string" && value.next_batch.trim()) {
+		const roomsData = normalizeRoomsData(value.rooms);
+		if (!roomsData) return null;
+		return {
+			nextBatch: value.next_batch,
+			accountData: isRecord(value.account_data) && Array.isArray(value.account_data.events) ? value.account_data.events : [],
+			roomsData
+		};
+	}
+	return null;
+}
+function normalizePersistedStore(value) {
+	if (!isRecord(value) || value.version !== 1) return null;
+	return {
+		version: 1,
+		savedSync: toPersistedSyncData(value.savedSync),
+		clientOptions: isRecord(value.clientOptions) ? value.clientOptions : void 0,
+		cleanShutdown: value.cleanShutdown === true
+	};
+}
+function normalizeLegacyPersistedStore(value) {
+	const persisted = normalizePersistedStore(value);
+	if (persisted) return persisted;
+	return {
+		version: 1,
+		savedSync: toPersistedSyncData(value),
+		cleanShutdown: false
+	};
+}
+function readPersistedStoreFromSyncStore(store) {
+	const stateKey = SYNC_CACHE_STATE_KEY;
+	const meta = store.lookup(metaKey(stateKey));
+	if (!isSyncCacheMeta(meta)) return null;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = store.lookup(chunkKey(stateKey, meta.generation, index));
+		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return normalizePersistedStore({
+			version: 1,
+			savedSync: null,
+			clientOptions: meta.clientOptions,
+			cleanShutdown: false
+		});
+		chunks.push(chunk.data);
+	}
+	let savedSync = null;
+	if (chunks.length > 0) {
+		const syncJson = chunks.join("");
+		if (meta.syncDigest !== digestText(syncJson)) return normalizePersistedStore({
+			version: 1,
+			savedSync: null,
+			clientOptions: meta.clientOptions,
+			cleanShutdown: false
+		});
+		try {
+			savedSync = toPersistedSyncData(JSON.parse(syncJson));
+		} catch {
+			savedSync = null;
+		}
+	}
+	return normalizePersistedStore({
+		version: 1,
+		savedSync,
+		clientOptions: meta.clientOptions,
+		cleanShutdown: meta.cleanShutdown
+	});
+}
+function metaKey(stateKey) {
+	return `${stateKey}:meta`;
+}
+function chunkKeyPrefix(stateKey) {
+	return `${stateKey}:sync:`;
+}
+function chunkKey(stateKey, generation, index) {
+	return `${chunkKeyPrefix(stateKey)}${generation}:${index}`;
+}
+function resolveLegacySyncCachePath(storageRootDir) {
+	return path.join(storageRootDir, "bot-storage.json");
+}
+function digestText(value) {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function isSyncCacheMeta(value) {
+	return isRecord(value) && value.kind === "meta" && value.version === 1 && typeof value.generation === "string" && value.generation.trim() !== "" && typeof value.chunkCount === "number" && Number.isSafeInteger(value.chunkCount) && value.chunkCount >= 0 && value.chunkCount <= SYNC_CACHE_MAX_CHUNKS;
+}
+function isSyncCacheChunk(value) {
+	return isRecord(value) && value.kind === "sync-chunk" && typeof value.index === "number" && Number.isSafeInteger(value.index) && value.index >= 0 && typeof value.data === "string";
+}
+function chunkSyncCacheJson(value) {
+	const chunks = [];
+	const pushChunk = (chunk) => {
+		if (chunks.length >= SYNC_CACHE_MAX_CHUNKS) throw new Error("Matrix sync cache exceeds SQLite chunk limit");
+		chunks.push(chunk);
+	};
+	let current = "";
+	let currentBytes = 0;
+	for (const char of value) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current && currentBytes + charBytes > SYNC_CACHE_CHUNK_BYTES) {
+			pushChunk(current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current) pushChunk(current);
+	return chunks;
+}
+function buildSyncCacheRows(stateKey, payload) {
+	const generation = randomUUID().replaceAll("-", "");
+	const syncJson = payload.savedSync ? JSON.stringify(payload.savedSync) : "";
+	const chunks = (syncJson ? chunkSyncCacheJson(syncJson) : []).map((data, index) => ({
+		key: chunkKey(stateKey, generation, index),
+		value: {
+			kind: "sync-chunk",
+			index,
+			data
+		}
+	}));
+	return {
+		chunks,
+		nextChunkKeys: new Set(chunks.map((chunk) => chunk.key)),
+		meta: {
+			key: metaKey(stateKey),
+			value: {
+				kind: "meta",
+				version: 1,
+				generation,
+				chunkCount: chunks.length,
+				...syncJson ? { syncDigest: digestText(syncJson) } : {},
+				...payload.clientOptions ? { clientOptions: payload.clientOptions } : {},
+				cleanShutdown: payload.cleanShutdown === true
+			}
+		}
+	};
+}
+async function readLegacyMatrixSyncCacheState(storageRootDir) {
+	try {
+		const raw = await fs.readFile(resolveLegacySyncCachePath(storageRootDir), "utf8");
+		const persisted = normalizeLegacyPersistedStore(JSON.parse(raw));
+		if (!persisted?.savedSync && !persisted?.clientOptions) return null;
+		return persisted;
+	} catch {
+		return null;
+	}
+}
+async function hasMatrixSyncCacheStateInStore(params) {
+	const stateKey = SYNC_CACHE_STATE_KEY;
+	const meta = await params.store.lookup(metaKey(stateKey));
+	if (!isSyncCacheMeta(meta) || meta.chunkCount <= 0) return false;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = await params.store.lookup(chunkKey(stateKey, meta.generation, index));
+		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return false;
+		chunks.push(chunk.data);
+	}
+	const syncJson = chunks.join("");
+	if (meta.syncDigest !== digestText(syncJson)) return false;
+	try {
+		return toPersistedSyncData(JSON.parse(syncJson)) !== null;
+	} catch {
+		return false;
+	}
+}
+async function writeMatrixSyncCacheStateToStore(params) {
+	const stateKey = SYNC_CACHE_STATE_KEY;
+	const rows = buildSyncCacheRows(stateKey, params.payload);
+	for (const row of rows.chunks) await params.store.register(row.key, row.value);
+	await params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of await params.store.entries()) if (row.key.startsWith(chunkKeyPrefix(stateKey)) && !rows.nextChunkKeys.has(row.key)) await params.store.delete(row.key);
+}
+function openMatrixSyncCacheStoreOptions(storageRootDir) {
+	return {
+		namespace: SYNC_CACHE_NAMESPACE,
+		maxEntries: SYNC_CACHE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function writeMatrixSyncCacheStateToSyncStore(params) {
+	const rows = buildSyncCacheRows(SYNC_CACHE_STATE_KEY, params.payload);
+	for (const row of rows.chunks) params.store.register(row.key, row.value);
+	params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of params.store.entries()) if (row.key.startsWith(chunkKeyPrefix(SYNC_CACHE_STATE_KEY)) && !rows.nextChunkKeys.has(row.key)) params.store.delete(row.key);
+}
+async function deleteMatrixSyncCacheStateFromSyncStore(params) {
+	params.store.delete(metaKey(SYNC_CACHE_STATE_KEY));
+	for (const row of params.store.entries()) if (row.key.startsWith(chunkKeyPrefix(SYNC_CACHE_STATE_KEY))) params.store.delete(row.key);
+	await fs.rm(resolveLegacySyncCachePath(params.storageRootDir), { force: true }).catch(() => void 0);
+}
+//#endregion
+export { readLegacyMatrixSyncCacheState as a, writeMatrixSyncCacheStateToStore as c, openMatrixSyncCacheStoreOptions as i, writeMatrixSyncCacheStateToSyncStore as l, deleteMatrixSyncCacheStateFromSyncStore as n, readPersistedStoreFromSyncStore as o, hasMatrixSyncCacheStateInStore as r, sync_cache_state_exports as s, MATRIX_SYNC_CACHE_VERSION as t };

package/dist/{thread-bindings-BYEGfw3h.js → thread-bindings-2HN2AyLu.js}

@@ -1,13 +1,13 @@
 import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
 import { a as listBindingsForAccount, c as resolveEffectiveBindingExpiry, d as setMatrixThreadBindingManagerEntry, l as setBindingRecord, m as toSessionBindingRecord, o as removeBindingRecord, p as toMatrixBindingTargetKind, r as getMatrixThreadBindingManagerEntry, s as resolveBindingKey, t as deleteMatrixThreadBindingManagerEntry } from "./thread-bindings-shared-oNPiyMWY.js";
-import { M as resolveMatrixSqliteStateEnv, N as resolveMatrixSqliteStateKey, c as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-BsGuHngK.js";
-import { r as sendMessageMatrix } from "./send-ClHgDZLT.js";
+import { M as resolveMatrixSqliteStateEnv, N as resolveMatrixSqliteStateKey, c as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-BVf4uucD.js";
+import { r as sendMessageMatrix } from "./send-DfS5ciUL.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { registerSessionBindingAdapter, resolveThreadBindingFarewellText, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
 import fs from "node:fs/promises";
-import { resolveSessionAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { resolveSessionAgentIdStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import { resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 //#region extensions/matrix/src/matrix/thread-bindings.ts
@@ -358,7 +358,7 @@ async function createMatrixThreadBindingManager(params) {
 				...boundParentConversationId ? { parentConversationId: boundParentConversationId } : {},
 				targetKind: toMatrixBindingTargetKind(input.targetKind),
 				targetSessionKey,
-				agentId: normalizeOptionalString(input.metadata?.agentId) ?? resolveSessionAgentId({
+				agentId: normalizeOptionalString(input.metadata?.agentId) ?? resolveSessionAgentIdStrict({
 					config: params.cfg,
 					sessionKey: targetSessionKey
 				}),