@openclaw/matrix 2026.9.6 → 2026.9.7

package/dist/.setup/storage-metadata-BDRZ7vpX.mjs

@@ -0,0 +1,371 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+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";
+import os from "node:os";
+//#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/crypto-state-store.ts
+const STATE_KEY = "current";
+const RECOVERY_KEY_NAMESPACE = "recovery-key";
+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(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";
+const MATRIX_IDB_SNAPSHOT_FILENAME = "crypto-idb-snapshot.json";
+function openMatrixRecoveryKeyStoreOptions(storageRootDir) {
+	return {
+		namespace: RECOVERY_KEY_NAMESPACE,
+		maxEntries: SMALL_STATE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir) {
+	return {
+		namespace: LEGACY_CRYPTO_MIGRATION_NAMESPACE,
+		maxEntries: SMALL_STATE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openMatrixIdbSnapshotStoreOptions(storageRootDir) {
+	return {
+		namespace: IDB_SNAPSHOT_NAMESPACE,
+		maxEntries: IDB_SNAPSHOT_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+async function readMatrixRecoveryKeyStateForPathAsync(recoveryKeyPath, stateRuntime) {
+	return normalizeMatrixStoredRecoveryKey(await stateRuntime.openKeyedStore(openMatrixRecoveryKeyStoreOptions(path.dirname(recoveryKeyPath))).lookup(resolveRecoveryKeyStateKeyForPath(recoveryKeyPath)));
+}
+async function writeMatrixRecoveryKeyStateForPathAsync(params) {
+	const payload = normalizeMatrixStoredRecoveryKey(params.payload);
+	if (!payload) throw new Error("Invalid Matrix recovery key state");
+	if (params.preserveEncodedPrivateKey) {
+		await updateMatrixRecoveryKeyState(params, (current) => normalizeMatrixStoredRecoveryKey({
+			...payload,
+			encodedPrivateKey: normalizeMatrixStoredRecoveryKey(current)?.encodedPrivateKey
+		}) ?? void 0);
+		return;
+	}
+	await params.stateRuntime.openKeyedStore(openMatrixRecoveryKeyStoreOptions(path.dirname(params.recoveryKeyPath))).register(resolveRecoveryKeyStateKeyForPath(params.recoveryKeyPath), payload);
+}
+async function updateMatrixRecoveryKeyState(params, update) {
+	const store = params.stateRuntime.openKeyedStore(openMatrixRecoveryKeyStoreOptions(path.dirname(params.recoveryKeyPath)));
+	const key = resolveRecoveryKeyStateKeyForPath(params.recoveryKeyPath);
+	if (!store.observe || !store.compareAndApply) {
+		if (!store.update) throw new Error("Matrix recovery key store does not support atomic updates");
+		await store.update(key, update);
+		return;
+	}
+	let observation = await store.observe(key);
+	for (;;) {
+		const value = update(observation.value);
+		const result = await store.compareAndApply(key, observation.comparison, value === void 0 ? {
+			operation: "update",
+			action: "keep"
+		} : {
+			operation: "update",
+			action: "set",
+			value
+		});
+		if (result.status !== "conflict") return;
+		observation = result.current;
+	}
+}
+async function hasMatrixRecoveryKeyStateInStore(params) {
+	return normalizeMatrixStoredRecoveryKey(await params.store.lookup(STATE_KEY)) !== null;
+}
+async function writeMatrixRecoveryKeyStateToStore(params) {
+	const payload = normalizeMatrixStoredRecoveryKey(params.payload);
+	if (!payload) throw new Error("Invalid Matrix recovery key state");
+	await params.store.register(STATE_KEY, payload);
+}
+async function readMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return normalizeMatrixLegacyCryptoMigrationState(await getMatrixRuntime().state.openKeyedStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir)).lookup(STATE_KEY));
+}
+async function hasMatrixLegacyCryptoMigrationStateInStore(params) {
+	return normalizeMatrixLegacyCryptoMigrationState(await params.store.lookup(STATE_KEY)) !== null;
+}
+async function writeMatrixLegacyCryptoMigrationStateToStore(params) {
+	const state = normalizeMatrixLegacyCryptoMigrationState(params.state);
+	if (!state) throw new Error("Invalid Matrix legacy crypto migration state");
+	await params.store.register(STATE_KEY, state);
+}
+async function readMatrixIdbSnapshotJson(storageRootDir, stateRuntime = getMatrixRuntime().state) {
+	return await readMatrixIdbSnapshotJsonFromStore({ store: stateRuntime.openKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)) });
+}
+async function hasMatrixIdbSnapshotState(storageRootDir) {
+	return isIdbSnapshotMeta(await getMatrixRuntime().state.openKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)).lookup(idbMetaKey()));
+}
+async function writeMatrixIdbSnapshotJson(params) {
+	await writeMatrixIdbSnapshotJsonToStore({
+		snapshotJson: params.snapshotJson,
+		databaseCount: params.databaseCount,
+		store: (params.stateRuntime ?? getMatrixRuntime().state).openKeyedStore(openMatrixIdbSnapshotStoreOptions(params.storageRootDir))
+	});
+}
+async function readMatrixIdbSnapshotJsonFromStore(params) {
+	const meta = await params.store.lookup(idbMetaKey());
+	if (!isIdbSnapshotMeta(meta)) return null;
+	const chunks = await readMatrixStateChunks(params.store, Array.from({ length: meta.chunkCount }, (_, index) => idbChunkKey(meta.generation, index)), "snapshot-chunk");
+	if (!chunks) return null;
+	const snapshotJson = chunks.join("");
+	return meta.digest === digestText(snapshotJson) ? snapshotJson : null;
+}
+async function writeMatrixIdbSnapshotJsonToStore(params) {
+	const rows = buildIdbSnapshotRows(params.snapshotJson, params.databaseCount);
+	await writeMatrixStateChunks(params.store, rows, idbChunkKeyPrefix());
+}
+async function migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(recoveryKeyPath, stateRuntime) {
+	const legacy = readLegacyMatrixRecoveryKeyFile(recoveryKeyPath);
+	if (legacy) await updateMatrixRecoveryKeyState({
+		recoveryKeyPath,
+		stateRuntime
+	}, (current) => normalizeMatrixStoredRecoveryKey(current) ? void 0 : legacy);
+	else await readMatrixRecoveryKeyStateForPathAsync(recoveryKeyPath, stateRuntime);
+	return archiveLegacyStateFileIfPossible(recoveryKeyPath);
+}
+async function migrateLegacyMatrixLegacyCryptoMigrationFileToStore(storageRootDir) {
+	const options = openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir);
+	const store = getMatrixRuntime().state.openKeyedStore(options);
+	const legacy = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
+	if (!legacy) await store.lookup(STATE_KEY);
+	else if (!store.observe || !store.compareAndApply) {
+		const legacyStore = getMatrixRuntime().state.openSyncKeyedStore(options);
+		if (!normalizeMatrixLegacyCryptoMigrationState(legacyStore.lookup(STATE_KEY))) legacyStore.register(STATE_KEY, legacy);
+	} else {
+		let observation = await store.observe(STATE_KEY);
+		for (;;) {
+			if (normalizeMatrixLegacyCryptoMigrationState(observation.value)) break;
+			const result = await store.compareAndApply(STATE_KEY, observation.comparison, {
+				operation: "update",
+				action: "set",
+				value: legacy
+			});
+			if (result.status !== "conflict") break;
+			observation = result.current;
+		}
+	}
+	return archiveLegacyStateFileIfPossible(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
+}
+function readLegacyMatrixRecoveryKeyState(storageRootDir) {
+	return readLegacyMatrixRecoveryKeyFile(path.join(storageRootDir, MATRIX_RECOVERY_KEY_FILENAME));
+}
+function readLegacyMatrixRecoveryKeyFile(filePath) {
+	return readJsonFileSync(filePath, normalizeMatrixStoredRecoveryKey);
+}
+function readLegacyMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return readJsonFileSync(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME), normalizeMatrixLegacyCryptoMigrationState);
+}
+async function scoreMatrixCryptoStateInStore(storageRootDir) {
+	if (!matrixCryptoStateDatabaseExists(storageRootDir)) return 0;
+	let score = 0;
+	try {
+		if (await readMatrixLegacyCryptoMigrationState(storageRootDir)) score += 3;
+	} catch {}
+	try {
+		if (await readMatrixRecoveryKeyStateForPathAsync(path.join(storageRootDir, "recovery-key.json"), getMatrixRuntime().state)) score += 2;
+	} catch {}
+	try {
+		if (await hasMatrixIdbSnapshotState(storageRootDir)) score += 2;
+	} catch {}
+	return score;
+}
+function matrixCryptoStateDatabaseExists(storageRootDir) {
+	return fs.existsSync(path.join(storageRootDir, "state", "openclaw.sqlite"));
+}
+function resolveRecoveryKeyStateKeyForPath(recoveryKeyPath) {
+	const basename = path.basename(recoveryKeyPath);
+	if (basename === "recovery-key.json") return STATE_KEY;
+	return `file:${createHash("sha256").update(basename, "utf8").digest("hex").slice(0, 32)}`;
+}
+function normalizeMatrixStoredRecoveryKey(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.createdAt !== "string" || typeof value.privateKeyBase64 !== "string" || !value.privateKeyBase64.trim()) return null;
+	return {
+		version: 1,
+		createdAt: value.createdAt,
+		keyId: typeof value.keyId === "string" ? value.keyId : null,
+		...typeof value.encodedPrivateKey === "string" ? { encodedPrivateKey: value.encodedPrivateKey } : {},
+		privateKeyBase64: value.privateKeyBase64,
+		...isRecord(value.keyInfo) ? { keyInfo: {
+			...value.keyInfo.passphrase !== void 0 ? { passphrase: value.keyInfo.passphrase } : {},
+			...typeof value.keyInfo.name === "string" ? { name: value.keyInfo.name } : {}
+		} } : {}
+	};
+}
+function normalizeMatrixLegacyCryptoMigrationState(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.accountId !== "string") return null;
+	if (value.restoreStatus !== "pending" && value.restoreStatus !== "completed" && value.restoreStatus !== "manual-action-required") return null;
+	const roomKeyCounts = isRecord(value.roomKeyCounts) && typeof value.roomKeyCounts.total === "number" && typeof value.roomKeyCounts.backedUp === "number" ? {
+		total: value.roomKeyCounts.total,
+		backedUp: value.roomKeyCounts.backedUp
+	} : null;
+	return {
+		version: 1,
+		...value.source === "matrix-bot-sdk-rust" ? { source: value.source } : {},
+		accountId: value.accountId,
+		...typeof value.deviceId === "string" || value.deviceId === null ? { deviceId: value.deviceId } : {},
+		roomKeyCounts,
+		...typeof value.backupVersion === "string" || value.backupVersion === null ? { backupVersion: value.backupVersion } : {},
+		...typeof value.decryptionKeyImported === "boolean" ? { decryptionKeyImported: value.decryptionKeyImported } : {},
+		restoreStatus: value.restoreStatus,
+		...typeof value.detectedAt === "string" ? { detectedAt: value.detectedAt } : {},
+		...typeof value.restoredAt === "string" ? { restoredAt: value.restoredAt } : {},
+		...typeof value.importedCount === "number" ? { importedCount: value.importedCount } : {},
+		...typeof value.totalCount === "number" ? { totalCount: value.totalCount } : {},
+		...typeof value.lastError === "string" || value.lastError === null ? { lastError: value.lastError } : {}
+	};
+}
+function readJsonFileSync(filePath, normalize) {
+	try {
+		return normalize(JSON.parse(fs.readFileSync(filePath, "utf8")));
+	} catch {
+		return null;
+	}
+}
+function archiveLegacyStateFileIfPossible(filePath) {
+	if (!fs.existsSync(filePath)) return false;
+	const archivedPath = `${filePath}.migrated`;
+	if (fs.existsSync(archivedPath)) return false;
+	fs.renameSync(filePath, archivedPath);
+	return true;
+}
+function buildIdbSnapshotRows(snapshotJson, databaseCount) {
+	const generation = randomUUID().replaceAll("-", "");
+	const chunks = chunkMatrixStateJson(snapshotJson, IDB_SNAPSHOT_CHUNK_BYTES, IDB_SNAPSHOT_MAX_CHUNKS, "Matrix IndexedDB snapshot exceeds SQLite chunk limit").map((data, index) => ({
+		key: idbChunkKey(generation, index),
+		value: {
+			kind: "snapshot-chunk",
+			index,
+			data
+		}
+	}));
+	return {
+		chunks,
+		nextChunkKeys: new Set(chunks.map((chunk) => chunk.key)),
+		meta: {
+			key: idbMetaKey(),
+			value: {
+				kind: "meta",
+				version: 1,
+				generation,
+				chunkCount: chunks.length,
+				digest: digestText(snapshotJson),
+				databaseCount,
+				persistedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		}
+	};
+}
+function idbMetaKey() {
+	return `${STATE_KEY}:meta`;
+}
+function idbChunkKeyPrefix() {
+	return `${STATE_KEY}:snapshot:`;
+}
+function idbChunkKey(generation, index) {
+	return `${idbChunkKeyPrefix()}${generation}:${index}`;
+}
+function digestText(value) {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function isIdbSnapshotMeta(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 <= IDB_SNAPSHOT_MAX_CHUNKS && typeof value.digest === "string" && typeof value.databaseCount === "number" && Number.isSafeInteger(value.databaseCount) && value.databaseCount >= 0 && typeof value.persistedAt === "string";
+}
+//#endregion
+//#region extensions/matrix/src/matrix/client/storage-metadata.ts
+const STORAGE_META_NAMESPACE = "storage-meta";
+const STORAGE_META_STATE_KEY = "current";
+const STORAGE_META_MAX_ENTRIES = 10;
+function openMatrixStorageMetaStoreOptions(storageRootDir) {
+	return {
+		namespace: STORAGE_META_NAMESPACE,
+		maxEntries: STORAGE_META_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function normalizeMatrixStorageMetadata(value) {
+	if (!isRecord(value)) return null;
+	const metadata = {};
+	for (const field of [
+		"homeserver",
+		"userId",
+		"accountId",
+		"accessTokenHash",
+		"deviceId",
+		"createdAt"
+	]) {
+		const entry = value[field];
+		if (typeof entry === "string" && entry.trim()) metadata[field] = entry.trim();
+	}
+	if (value.currentTokenStateClaimed === true) metadata.currentTokenStateClaimed = true;
+	return Object.keys(metadata).length > 0 ? metadata : null;
+}
+async function hasMatrixStorageMetaStateInStore(params) {
+	return normalizeMatrixStorageMetadata(await params.store.lookup(STORAGE_META_STATE_KEY)) !== null;
+}
+async function writeMatrixStorageMetaStateToStore(params) {
+	await params.store.register(STORAGE_META_STATE_KEY, params.payload);
+}
+//#endregion
+export { chunkMatrixStateJson as A, writeMatrixIdbSnapshotJson as C, writeMatrixRecoveryKeyStateToStore as D, writeMatrixRecoveryKeyStateForPathAsync as E, writeMatrixStateChunks as M, resolveMatrixSqliteStateEnv as O, scoreMatrixCryptoStateInStore as S, writeMatrixLegacyCryptoMigrationStateToStore as T, readLegacyMatrixRecoveryKeyFile as _, writeMatrixStorageMetaStateToStore as a, readMatrixIdbSnapshotJsonFromStore as b, MATRIX_RECOVERY_KEY_FILENAME as c, migrateLegacyMatrixLegacyCryptoMigrationFileToStore as d, migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync as f, readLegacyMatrixLegacyCryptoMigrationState as g, openMatrixRecoveryKeyStoreOptions as h, openMatrixStorageMetaStoreOptions as i, readMatrixStateChunks as j, resolveMatrixSqliteStateKey as k, hasMatrixLegacyCryptoMigrationStateInStore as l, openMatrixLegacyCryptoMigrationStoreOptions as m, hasMatrixStorageMetaStateInStore as n, MATRIX_IDB_SNAPSHOT_FILENAME as o, openMatrixIdbSnapshotStoreOptions as p, normalizeMatrixStorageMetadata as r, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME as s, STORAGE_META_STATE_KEY as t, hasMatrixRecoveryKeyStateInStore as u, readLegacyMatrixRecoveryKeyState as v, writeMatrixIdbSnapshotJsonToStore as w, readMatrixRecoveryKeyStateForPathAsync as x, readMatrixIdbSnapshotJson as y };

package/dist/.setup/storage-paths-B51JM-pC.mjs

@@ -0,0 +1,53 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import crypto from "node:crypto";
+import path from "node:path";
+//#region extensions/matrix/src/storage-paths.ts
+const MATRIX_TOKEN_HASH_DIRECTORY_PATTERN = /^[a-f0-9]{16}$/u;
+const MATRIX_SERVER_USER_DIRECTORY_PATTERN = /^.+__.+$/u;
+function isMatrixActiveTokenRootDirectory(name) {
+	return MATRIX_TOKEN_HASH_DIRECTORY_PATTERN.test(name);
+}
+function resolveMatrixStateLayoutChildDepth(depth, name) {
+	if (depth === 0) return name === "accounts" ? 1 : null;
+	if (depth === 1) return 2;
+	if (depth === 2) return MATRIX_SERVER_USER_DIRECTORY_PATTERN.test(name) ? 3 : null;
+	if (depth === 3) return isMatrixActiveTokenRootDirectory(name) ? 4 : null;
+	return null;
+}
+function sanitizeMatrixPathSegment(value) {
+	return normalizeLowercaseStringOrEmpty(value).replace(/[^a-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "unknown";
+}
+function resolveMatrixHomeserverKey(homeserver) {
+	try {
+		const url = new URL(homeserver);
+		if (url.host) return sanitizeMatrixPathSegment(url.host);
+	} catch {}
+	return sanitizeMatrixPathSegment(homeserver);
+}
+function hashMatrixAccessToken(accessToken) {
+	return crypto.createHash("sha256").update(accessToken).digest("hex").slice(0, 16);
+}
+function resolveMatrixCredentialsFilename(accountId) {
+	const normalized = normalizeAccountId(accountId);
+	return normalized === DEFAULT_ACCOUNT_ID ? "credentials.json" : `credentials-${normalized}.json`;
+}
+function resolveMatrixCredentialsDir(stateDir) {
+	return path.join(stateDir, "credentials", "matrix");
+}
+function resolveMatrixCredentialsPath(params) {
+	return path.join(resolveMatrixCredentialsDir(params.stateDir), resolveMatrixCredentialsFilename(params.accountId));
+}
+function resolveMatrixAccountStorageRoot(params) {
+	const accountKey = sanitizeMatrixPathSegment(params.accountId ?? DEFAULT_ACCOUNT_ID);
+	const userKey = sanitizeMatrixPathSegment(params.userId);
+	const serverKey = resolveMatrixHomeserverKey(params.homeserver);
+	const tokenHash = hashMatrixAccessToken(params.accessToken);
+	return {
+		rootDir: path.join(params.stateDir, "matrix", "accounts", accountKey, `${serverKey}__${userKey}`, tokenHash),
+		accountKey,
+		tokenHash
+	};
+}
+//#endregion
+export { resolveMatrixCredentialsFilename as a, resolveMatrixStateLayoutChildDepth as c, resolveMatrixCredentialsDir as i, sanitizeMatrixPathSegment as l, isMatrixActiveTokenRootDirectory as n, resolveMatrixCredentialsPath as o, resolveMatrixAccountStorageRoot as r, resolveMatrixHomeserverKey as s, hashMatrixAccessToken as t };

package/dist/.setup/subagent-hooks-D5kd_kzN.mjs

@@ -0,0 +1,52 @@
+import { a as listBindingsForAccount, i as listAllBindings, n as getMatrixThreadBindingManager, o as removeBindingRecord, s as resolveBindingKey } from "./thread-bindings-shared-hxKkYC1W.mjs";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-binding-runtime";
+//#region extensions/matrix/src/matrix/subagent-hooks.ts
+async function handleMatrixSubagentEnded(event) {
+	const accountId = normalizeOptionalString(event.accountId) || void 0;
+	const matching = (accountId ? listBindingsForAccount(accountId) : listAllBindings()).filter((entry) => entry.targetSessionKey === event.targetSessionKey && entry.targetKind === "subagent");
+	const removedBindingKeys = /* @__PURE__ */ new Set();
+	if (event.sendFarewell) {
+		const bindingService = getSessionBindingService();
+		const reason = normalizeOptionalString(event.reason) || "subagent-ended";
+		for (const binding of matching) {
+			const bindingId = resolveBindingKey(binding);
+			if ((await bindingService.unbind({
+				bindingId,
+				reason,
+				scope: {
+					channel: "matrix",
+					accountId: binding.accountId
+				}
+			})).some((entry) => entry.bindingId === bindingId)) removedBindingKeys.add(bindingId);
+		}
+	}
+	const affectedAccountIds = /* @__PURE__ */ new Set();
+	for (const binding of matching) {
+		if (removedBindingKeys.has(resolveBindingKey(binding))) continue;
+		if (removeBindingRecord(binding)) affectedAccountIds.add(binding.accountId);
+	}
+	for (const acctId of affectedAccountIds) await getMatrixThreadBindingManager(acctId)?.persist();
+}
+function handleMatrixSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (event.requesterOrigin?.channel?.trim().toLowerCase() !== "matrix") return;
+	const requesterAccountId = normalizeOptionalString(event.requesterOrigin?.accountId);
+	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? String(event.requesterOrigin.threadId).trim() : "";
+	const bindings = (requesterAccountId ? listBindingsForAccount(requesterAccountId) : listAllBindings()).filter((entry) => entry.targetSessionKey === event.childSessionKey && entry.targetKind === "subagent");
+	if (bindings.length === 0) return;
+	let binding;
+	if (requesterThreadId) binding = bindings.find((entry) => entry.conversationId === requesterThreadId && (!requesterAccountId || entry.accountId === requesterAccountId));
+	if (!binding && bindings.length === 1) binding = bindings[0];
+	if (!binding) return;
+	const roomId = binding.parentConversationId ?? binding.conversationId;
+	const threadId = binding.parentConversationId && binding.parentConversationId !== binding.conversationId ? binding.conversationId : void 0;
+	return { origin: {
+		channel: "matrix",
+		accountId: binding.accountId,
+		to: `room:${roomId}`,
+		...threadId ? { threadId } : {}
+	} };
+}
+//#endregion
+export { handleMatrixSubagentDeliveryTarget, handleMatrixSubagentEnded };

package/dist/.setup/sync-cache-state-C6sEmvJK.mjs

@@ -0,0 +1,192 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { A as chunkMatrixStateJson, M as writeMatrixStateChunks, O as resolveMatrixSqliteStateEnv, j as readMatrixStateChunks } from "./storage-metadata-BDRZ7vpX.mjs";
+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";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+//#region extensions/matrix/src/matrix/client/sync-cache-state.ts
+var sync_cache_state_exports = /* @__PURE__ */ __exportAll({
+	MATRIX_SYNC_CACHE_VERSION: () => 1,
+	deleteMatrixSyncCacheStateFromStore: () => deleteMatrixSyncCacheStateFromStore,
+	hasMatrixSyncCacheStateInStore: () => hasMatrixSyncCacheStateInStore,
+	openMatrixSyncCacheStoreOptions: () => openMatrixSyncCacheStoreOptions,
+	readLegacyMatrixSyncCacheState: () => readLegacyMatrixSyncCacheState,
+	readPersistedStoreFromStore: () => readPersistedStoreFromStore,
+	writeMatrixSyncCacheStateToStore: () => writeMatrixSyncCacheStateToStore
+});
+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;
+const syncCacheOperations = new KeyedAsyncQueue();
+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
+	};
+}
+async function readPersistedStoreFromStore(params) {
+	const { storageRootDir, store } = params;
+	return syncCacheOperations.enqueue(path.resolve(storageRootDir), () => readPersistedStore(store));
+}
+async function readPersistedStore(store) {
+	const stateKey = SYNC_CACHE_STATE_KEY;
+	const meta = await store.lookup(metaKey(stateKey));
+	if (!isSyncCacheMeta(meta)) return null;
+	const chunks = await readMatrixStateChunks(store, Array.from({ length: meta.chunkCount }, (_, index) => chunkKey(stateKey, meta.generation, index)), "sync-chunk");
+	if (!chunks) return normalizePersistedStore({
+		version: 1,
+		savedSync: null,
+		clientOptions: meta.clientOptions,
+		cleanShutdown: false
+	});
+	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 buildSyncCacheRows(stateKey, payload) {
+	const generation = randomUUID().replaceAll("-", "");
+	const syncJson = payload.savedSync ? JSON.stringify(payload.savedSync) : "";
+	const chunks = chunkMatrixStateJson(syncJson, SYNC_CACHE_CHUNK_BYTES, SYNC_CACHE_MAX_CHUNKS, "Matrix sync cache exceeds SQLite chunk limit").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) {
+	return Boolean((await readPersistedStoreFromStore(params))?.savedSync);
+}
+async function writeMatrixSyncCacheStateToStore(params) {
+	const { storageRootDir, store, payload } = params;
+	const stateKey = SYNC_CACHE_STATE_KEY;
+	const rows = buildSyncCacheRows(stateKey, payload);
+	return syncCacheOperations.enqueue(path.resolve(storageRootDir), () => writeMatrixStateChunks(store, rows, chunkKeyPrefix(stateKey)));
+}
+function openMatrixSyncCacheStoreOptions(storageRootDir) {
+	return {
+		namespace: SYNC_CACHE_NAMESPACE,
+		maxEntries: SYNC_CACHE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+async function deleteMatrixSyncCacheStateFromStore(params) {
+	const { storageRootDir, store } = params;
+	return syncCacheOperations.enqueue(path.resolve(storageRootDir), async () => {
+		await store.delete(metaKey(SYNC_CACHE_STATE_KEY));
+		for (const row of await store.entries()) if (row.key.startsWith(chunkKeyPrefix(SYNC_CACHE_STATE_KEY))) await store.delete(row.key);
+		await fs.rm(resolveLegacySyncCachePath(storageRootDir), { force: true }).catch(() => void 0);
+	});
+}
+//#endregion
+export { readLegacyMatrixSyncCacheState as a, writeMatrixSyncCacheStateToStore as c, openMatrixSyncCacheStoreOptions as i, deleteMatrixSyncCacheStateFromStore as n, readPersistedStoreFromStore as o, hasMatrixSyncCacheStateInStore as r, sync_cache_state_exports as s, MATRIX_SYNC_CACHE_VERSION as t };