@openclaw/matrix 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/storage-BXS2cB2i.mjs

@@ -1,288 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { n as isMatrixActiveTokenRootDirectory, r as resolveMatrixAccountStorageRoot } from "./storage-paths-B51JM-pC.mjs";
-import { S as scoreMatrixCryptoStateInStore, c as MATRIX_RECOVERY_KEY_FILENAME, d as migrateLegacyMatrixLegacyCryptoMigrationFileToStore, f as migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync, i as openMatrixStorageMetaStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, r as normalizeMatrixStorageMetadata, s as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, t as STORAGE_META_STATE_KEY } from "./storage-metadata-BDRZ7vpX.mjs";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import path from "node:path";
-import fs from "node:fs";
-import os from "node:os";
-import { loadJsonFile } from "openclaw/plugin-sdk/json-store";
-//#region extensions/matrix/src/matrix/client/storage.ts
-const DEFAULT_ACCOUNT_KEY = "default";
-const STORAGE_META_FILENAME = "storage-meta.json";
-const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
-function openStorageMetaStore(rootDir) {
-	return getMatrixRuntime().state.openKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
-}
-async function scoreStorageRoot(rootDir, metadata) {
-	let score = 0;
-	if (Object.keys(metadata).length > 0) score += 1;
-	if (metadata.currentTokenStateClaimed === true) score += 8;
-	for (const [filename, weight] of [
-		["crypto", 8],
-		[THREAD_BINDINGS_FILENAME, 4],
-		[MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, 3],
-		[MATRIX_RECOVERY_KEY_FILENAME, 2],
-		[MATRIX_IDB_SNAPSHOT_FILENAME, 2]
-	]) if (fs.existsSync(path.join(rootDir, filename))) score += weight;
-	score += await scoreMatrixCryptoStateInStore(rootDir);
-	return score;
-}
-function resolveStorageRootMtimeMs(rootDir) {
-	try {
-		return fs.statSync(rootDir).mtimeMs;
-	} catch {
-		return 0;
-	}
-}
-async function readStoredRootMetadata(rootDir) {
-	if (fs.existsSync(path.join(rootDir, "state", "openclaw.sqlite"))) try {
-		const stored = normalizeMatrixStorageMetadata(await openStorageMetaStore(rootDir).lookup(STORAGE_META_STATE_KEY));
-		if (stored) return stored;
-	} catch {}
-	return normalizeMatrixStorageMetadata(loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME))) ?? {};
-}
-function isCompatibleStorageRoot(params) {
-	const { metadata } = params;
-	if (metadata.homeserver && metadata.homeserver !== params.homeserver) return false;
-	if (metadata.userId && metadata.userId !== params.userId) return false;
-	if (metadata.accountId && normalizeAccountId(metadata.accountId) !== normalizeAccountId(params.accountKey)) return false;
-	return metadata.deviceId?.trim() === params.deviceId.trim();
-}
-async function resolvePreferredMatrixStorageRoot(params) {
-	const canonical = {
-		rootDir: params.canonicalRootDir,
-		tokenHash: params.canonicalTokenHash
-	};
-	const deviceId = params.deviceId?.trim();
-	if (!deviceId) return canonical;
-	const canonicalMetadata = await readStoredRootMetadata(params.canonicalRootDir);
-	if (canonicalMetadata.accessTokenHash === params.canonicalTokenHash && canonicalMetadata.deviceId?.trim() === deviceId && canonicalMetadata.currentTokenStateClaimed === true) return canonical;
-	const parentDir = path.dirname(params.canonicalRootDir);
-	const bestCurrentScore = await scoreStorageRoot(params.canonicalRootDir, canonicalMetadata);
-	const bestCurrentMtimeMs = resolveStorageRootMtimeMs(params.canonicalRootDir);
-	let best = {
-		rootDir: params.canonicalRootDir,
-		tokenHash: params.canonicalTokenHash,
-		score: bestCurrentScore,
-		mtimeMs: bestCurrentMtimeMs
-	};
-	let siblingEntries;
-	try {
-		siblingEntries = fs.readdirSync(parentDir, { withFileTypes: true });
-	} catch {
-		return {
-			rootDir: best.rootDir,
-			tokenHash: best.tokenHash
-		};
-	}
-	const compatiblePopulatedSiblings = [];
-	const populatedTokenHashes = bestCurrentScore > 0 ? [params.canonicalTokenHash] : [];
-	for (const entry of siblingEntries.toSorted((a, b) => a.name.localeCompare(b.name))) {
-		if (!entry.isDirectory()) continue;
-		if (entry.name === params.canonicalTokenHash) continue;
-		if (!isMatrixActiveTokenRootDirectory(entry.name)) continue;
-		const candidateRootDir = path.join(parentDir, entry.name);
-		const metadata = await readStoredRootMetadata(candidateRootDir);
-		if (!isCompatibleStorageRoot({
-			metadata,
-			homeserver: params.homeserver,
-			userId: params.userId,
-			accountKey: params.accountKey,
-			deviceId
-		})) continue;
-		const candidateScore = await scoreStorageRoot(candidateRootDir, metadata);
-		if (candidateScore <= 0) continue;
-		populatedTokenHashes.push(entry.name);
-		compatiblePopulatedSiblings.push({
-			rootDir: candidateRootDir,
-			tokenHash: entry.name,
-			score: candidateScore,
-			mtimeMs: resolveStorageRootMtimeMs(candidateRootDir)
-		});
-	}
-	for (const candidate of compatiblePopulatedSiblings) if (candidate.score > best.score || best.rootDir !== params.canonicalRootDir && candidate.score === best.score && candidate.mtimeMs > best.mtimeMs) best = candidate;
-	if (populatedTokenHashes.length > 1) getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" }).warn("matrix: multiple populated token-hash storage roots detected", {
-		parentDir,
-		canonicalTokenHash: params.canonicalTokenHash,
-		selectedTokenHash: best.tokenHash,
-		populatedTokenHashes,
-		populatedSiblingTokenHashes: compatiblePopulatedSiblings.map((root) => root.tokenHash),
-		populatedRootCount: populatedTokenHashes.length
-	});
-	return {
-		rootDir: best.rootDir,
-		tokenHash: best.tokenHash
-	};
-}
-async function resolveMatrixStoragePaths(params) {
-	const env = params.env ?? process.env;
-	const stateDir = params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir);
-	const canonical = resolveMatrixAccountStorageRoot({
-		stateDir,
-		homeserver: params.homeserver,
-		userId: params.userId,
-		accessToken: params.accessToken,
-		accountId: params.accountId
-	});
-	const { rootDir, tokenHash } = await resolvePreferredMatrixStorageRoot({
-		canonicalRootDir: canonical.rootDir,
-		canonicalTokenHash: canonical.tokenHash,
-		homeserver: params.homeserver,
-		userId: params.userId,
-		accountKey: canonical.accountKey,
-		deviceId: params.deviceId
-	});
-	return {
-		rootDir,
-		storagePath: path.join(rootDir, "bot-storage.json"),
-		cryptoPath: path.join(rootDir, "crypto"),
-		recoveryKeyPath: path.join(rootDir, MATRIX_RECOVERY_KEY_FILENAME),
-		idbSnapshotPath: path.join(rootDir, MATRIX_IDB_SNAPSHOT_FILENAME),
-		accountKey: canonical.accountKey,
-		tokenHash
-	};
-}
-async function resolveMatrixStateFilePath(params) {
-	const storagePaths = await resolveMatrixStoragePaths({
-		homeserver: params.auth.homeserver,
-		userId: params.auth.userId,
-		accessToken: params.auth.accessToken,
-		accountId: params.accountId ?? params.auth.accountId,
-		deviceId: params.auth.deviceId,
-		env: params.env,
-		stateDir: params.stateDir
-	});
-	return path.join(storagePaths.rootDir, params.filename);
-}
-async function maybeMigrateLegacyStorage({ storagePaths }) {
-	const { rootDir, storagePath, recoveryKeyPath } = storagePaths;
-	const cryptoMigrationPath = path.join(rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME);
-	const hasAccountScopedLegacyStorageFile = fs.existsSync(storagePath);
-	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-C6sEmvJK.mjs").then((n) => n.s) : null;
-	const hasAccountScopedLegacyStorage = hasAccountScopedLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(rootDir) !== null;
-	const hasAccountScopedRecoveryKey = fs.existsSync(recoveryKeyPath);
-	const hasAccountScopedLegacyCryptoMigration = fs.existsSync(cryptoMigrationPath);
-	if (!hasAccountScopedLegacyStorage && !hasAccountScopedRecoveryKey && !hasAccountScopedLegacyCryptoMigration) return;
-	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
-	fs.mkdirSync(rootDir, { recursive: true });
-	const migrations = [];
-	let archiveSyncCache = false;
-	try {
-		if (syncCache && hasAccountScopedLegacyStorage) {
-			const persisted = await syncCache.readLegacyMatrixSyncCacheState(rootDir);
-			if (persisted) {
-				const store = getMatrixRuntime().state.openKeyedStore(syncCache.openMatrixSyncCacheStoreOptions(rootDir));
-				if (!await syncCache.hasMatrixSyncCacheStateInStore({
-					storageRootDir: rootDir,
-					store
-				})) {
-					await syncCache.writeMatrixSyncCacheStateToStore({
-						storageRootDir: rootDir,
-						payload: persisted,
-						store
-					});
-					await claimCurrentTokenStorageState({ rootDir });
-					migrations.push(`- account sync cache: ${storagePath} -> ${rootDir} SQLite sync cache`);
-				}
-				archiveSyncCache = true;
-			}
-		}
-		if (hasAccountScopedRecoveryKey) {
-			await migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(recoveryKeyPath, getMatrixRuntime().state);
-			migrations.push(`- recovery key: ${recoveryKeyPath} -> ${rootDir} SQLite recovery key state`);
-		}
-		if (hasAccountScopedLegacyCryptoMigration) {
-			await migrateLegacyMatrixLegacyCryptoMigrationFileToStore(rootDir);
-			migrations.push(`- legacy crypto migration: ${cryptoMigrationPath} -> ${rootDir} SQLite legacy crypto migration state`);
-		}
-	} catch (err) {
-		throw new Error(`Failed migrating legacy Matrix client storage: ${String(err)}`, { cause: err });
-	}
-	const archivePath = `${storagePath}.migrated`;
-	const skippedArchive = archiveSyncCache && fs.existsSync(archivePath);
-	if (archiveSyncCache && !skippedArchive) fs.renameSync(storagePath, archivePath);
-	if (migrations.length > 0) logger.info(`matrix: migrated legacy client storage into ${rootDir}\n${migrations.join("\n")}`);
-	if (skippedArchive) logger.warn?.(`matrix: legacy client storage files were left in place because their migrated targets already existed.
-- account sync cache remains at ${storagePath} because ${archivePath} already exists`);
-}
-function prepareStorageMetaMutation(metadata, mutation) {
-	if (mutation.kind !== "initialize" && !metadata.accessTokenHash?.trim()) return null;
-	return normalizeMatrixStorageMetadata({
-		...mutation.kind === "initialize" ? mutation.metadata : metadata,
-		accountId: mutation.kind === "initialize" ? mutation.metadata.accountId : metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
-		deviceId: mutation.kind === "device" ? mutation.deviceId : mutation.kind === "initialize" ? mutation.metadata.deviceId ?? metadata.deviceId : metadata.deviceId,
-		currentTokenStateClaimed: mutation.kind === "claim" || (mutation.kind === "initialize" ? mutation.metadata.currentTokenStateClaimed ?? metadata.currentTokenStateClaimed === true : metadata.currentTokenStateClaimed === true),
-		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-	});
-}
-async function mutateStorageMeta(rootDir, mutation) {
-	try {
-		const store = openStorageMetaStore(rootDir);
-		const decode = (value) => normalizeMatrixStorageMetadata(value) ?? normalizeMatrixStorageMetadata(loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME))) ?? {};
-		if (!store.observe || !store.compareAndApply) {
-			const legacyStore = getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
-			const next = prepareStorageMetaMutation(decode(legacyStore.lookup(STORAGE_META_STATE_KEY)), mutation);
-			if (!next) return false;
-			legacyStore.register(STORAGE_META_STATE_KEY, next);
-			return true;
-		}
-		let observation = await store.observe(STORAGE_META_STATE_KEY);
-		for (;;) {
-			const next = prepareStorageMetaMutation(decode(observation.value), mutation);
-			if (!next) return false;
-			const result = await store.compareAndApply(STORAGE_META_STATE_KEY, observation.comparison, {
-				operation: "update",
-				action: "set",
-				value: next
-			});
-			if (result.status !== "conflict") return true;
-			observation = result.current;
-		}
-	} catch {
-		return false;
-	}
-}
-async function writeStorageMeta(params) {
-	return mutateStorageMeta(params.storagePaths.rootDir, {
-		kind: "initialize",
-		metadata: {
-			homeserver: params.homeserver,
-			userId: params.userId,
-			accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
-			accessTokenHash: params.storagePaths.tokenHash,
-			deviceId: params.deviceId ?? null,
-			currentTokenStateClaimed: params.currentTokenStateClaimed
-		}
-	});
-}
-async function claimCurrentTokenStorageState(params) {
-	return mutateStorageMeta(params.rootDir, { kind: "claim" });
-}
-async function recordCurrentStorageMetaDeviceId(params) {
-	const rootDir = params.rootDir;
-	const deviceId = params.deviceId.trim();
-	if (!deviceId || !(await readStoredRootMetadata(rootDir)).accessTokenHash?.trim()) return false;
-	return mutateStorageMeta(rootDir, {
-		kind: "device",
-		deviceId
-	});
-}
-async function repairCurrentTokenStorageMetaDeviceId(params) {
-	const { homeserver, userId, accessToken, accountId, deviceId, env, stateDir } = params;
-	return writeStorageMeta({
-		storagePaths: await resolveMatrixStoragePaths({
-			homeserver,
-			userId,
-			accessToken,
-			accountId,
-			env,
-			stateDir
-		}),
-		homeserver,
-		userId,
-		accountId,
-		deviceId
-	});
-}
-//#endregion
-export { resolveMatrixStateFilePath as a, repairCurrentTokenStorageMetaDeviceId as i, maybeMigrateLegacyStorage as n, resolveMatrixStoragePaths as o, recordCurrentStorageMetaDeviceId as r, writeStorageMeta as s, claimCurrentTokenStorageState as t };

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

@@ -1,371 +0,0 @@
-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/node_modules/@openclaw/fs-safe/dist/watch-alias.d.ts

@@ -1,6 +0,0 @@
-import { type RootContext } from "./root-context.js";
-import type { NativeWatchBatch } from "./watch-native.js";
-import type { WatchSnapshot } from "./watch-scan.js";
-import type { WatchChange, WatchScope } from "./watch-types.js";
-/** Resolve native spelling aliases without treating case folding as identity. */
-export declare function admittedNativeChanges(root: RootContext, scopes: readonly WatchScope[], before: WatchSnapshot | undefined, after: WatchSnapshot, batch: NativeWatchBatch, signal: AbortSignal, limit: number): Promise<WatchChange[] | undefined>;