@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/probe.runtime-BJOvCHnZ.js

@@ -1,3 +0,0 @@
-import { t as createMatrixClient } from "./create-client-f-CkRllE.js";
-import "./client-BFRg0kd4.js";
-export { createMatrixClient };

package/dist/profile-update-z3aM46KS.js

@@ -1,68 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { l as resolveMatrixConfigPath, s as syncMatrixOwnProfile, u as updateMatrixAccountConfig } from "./setup-core-a542Ernq.js";
-import { n as withResolvedActionClient } from "./client-CitERujx.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-//#region extensions/matrix/src/matrix/actions/profile.ts
-async function updateMatrixOwnProfile(opts = {}) {
-	const displayName = opts.displayName?.trim();
-	const avatarUrl = opts.avatarUrl?.trim();
-	const avatarPath = opts.avatarPath?.trim();
-	const runtime = getMatrixRuntime();
-	return await withResolvedActionClient(opts, async (client) => {
-		return await syncMatrixOwnProfile({
-			client,
-			userId: await client.getUserId(),
-			displayName: displayName || void 0,
-			avatarUrl: avatarUrl || void 0,
-			avatarPath: avatarPath || void 0,
-			loadAvatarFromUrl: async (url, maxBytes) => await runtime.media.loadWebMedia(url, maxBytes),
-			loadAvatarFromPath: async (path, maxBytes) => await runtime.media.loadWebMedia(path, {
-				maxBytes,
-				localRoots: opts.mediaLocalRoots
-			})
-		});
-	}, "persist");
-}
-//#endregion
-//#region extensions/matrix/src/profile-update.ts
-async function applyMatrixProfileUpdate(params) {
-	const runtime = getMatrixRuntime();
-	const persistedCfg = runtime.config.current();
-	const accountId = normalizeAccountId(params.account);
-	const displayName = params.displayName?.trim() || null;
-	const avatarUrl = params.avatarUrl?.trim() || null;
-	const avatarPath = params.avatarPath?.trim() || null;
-	if (!displayName && !avatarUrl && !avatarPath) throw new Error("Provide name/displayName and/or avatarUrl/avatarPath.");
-	const synced = await updateMatrixOwnProfile({
-		cfg: params.cfg,
-		accountId,
-		displayName: displayName ?? void 0,
-		avatarUrl: avatarUrl ?? void 0,
-		avatarPath: avatarPath ?? void 0,
-		mediaLocalRoots: params.mediaLocalRoots
-	});
-	const persistedAvatarUrl = synced.uploadedAvatarSource && synced.resolvedAvatarUrl ? synced.resolvedAvatarUrl : avatarUrl;
-	const updated = updateMatrixAccountConfig(persistedCfg, accountId, {
-		name: displayName ?? void 0,
-		avatarUrl: persistedAvatarUrl ?? void 0
-	});
-	await runtime.config.replaceConfigFile({
-		nextConfig: updated,
-		afterWrite: { mode: "auto" }
-	});
-	return {
-		accountId,
-		displayName,
-		avatarUrl: persistedAvatarUrl ?? null,
-		profile: {
-			displayNameUpdated: synced.displayNameUpdated,
-			avatarUpdated: synced.avatarUpdated,
-			resolvedAvatarUrl: synced.resolvedAvatarUrl,
-			uploadedAvatarSource: synced.uploadedAvatarSource,
-			convertedAvatarFromHttp: synced.convertedAvatarFromHttp
-		},
-		configPath: resolveMatrixConfigPath(updated, accountId)
-	};
-}
-//#endregion
-export { updateMatrixOwnProfile as n, applyMatrixProfileUpdate as t };

package/dist/reaction-events-DrK9Zua7.js

@@ -1,164 +0,0 @@
-import { a as resolveMatrixAccountConfig } from "./account-config-BZWN9tGS.js";
-import { a as extractMatrixReactionAnnotation } from "./reaction-common-DkrQdBSZ.js";
-import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-D-BxBK_L.js";
-import { i as resolveMatrixThreadRouting, r as resolveMatrixThreadRootId, t as resolveMatrixInboundRoute } from "./route-DY6at4qJ.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-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("./approval-reaction-auth-CCAWWkbu.js"));
-const loadExecApprovalResolver = createLazyRuntimeModule(() => import("./exec-approval-resolver-BCgqRtZS.js"));
-const loadMatrixSend = createLazyRuntimeModule(() => import("./send-C9Ssx-iV.js").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";
-	return `${result.applied ? "Resolved" : "Already resolved"}: ${terminalLabel}\n\nID: ${approval.id}`;
-}
-async function retireMatrixApprovalReactionTargets(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const registeredTargets = await unregisterMatrixApprovalReactionTargetsForApproval({
-		accountId,
-		approvalId: params.approvalId,
-		approvalKind: params.approvalKind
-	});
-	const targets = /* @__PURE__ */ new Map();
-	for (const target of [...registeredTargets, {
-		accountId,
-		roomId: params.roomId,
-		eventId: params.targetEventId
-	}]) targets.set(JSON.stringify([
-		target.accountId,
-		target.roomId,
-		target.eventId
-	]), target);
-	const { editMessageMatrix } = await loadMatrixSend();
-	const terminalText = buildMatrixApprovalTerminalText(params.result);
-	const failedUpdates = (await Promise.allSettled(Array.from(targets.values(), async (target) => {
-		await editMessageMatrix(target.roomId, target.eventId, terminalText, {
-			cfg: params.cfg,
-			accountId: target.accountId,
-			client: params.client
-		});
-	}))).filter((update) => update.status === "rejected").length;
-	if (failedUpdates > 0) params.logVerboseMessage(`matrix: failed to terminalize ${failedUpdates} approval prompt(s) id=${params.approvalId}`);
-}
-function resolveMatrixReactionNotificationMode(params) {
-	const matrixConfig = params.cfg.channels?.matrix;
-	return resolveMatrixAccountConfig({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).reactionNotifications ?? matrixConfig?.reactionNotifications ?? "own";
-}
-async function maybeResolveMatrixApprovalReaction(params) {
-	if (!params.target) return false;
-	const { isMatrixApprovalReactionAuthorizedSender } = await loadApprovalReactionAuth();
-	if (!isMatrixApprovalReactionAuthorizedSender({
-		...params,
-		approvalKind: params.target.approvalKind
-	})) return false;
-	const { isApprovalNotFoundError, resolveMatrixApproval } = await loadExecApprovalResolver();
-	try {
-		const result = await resolveMatrixApproval({
-			cfg: params.cfg,
-			approvalId: params.target.approvalId,
-			approvalKind: params.target.approvalKind,
-			decision: params.target.decision,
-			senderId: params.senderId
-		});
-		await retireMatrixApprovalReactionTargets({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			client: params.client,
-			roomId: params.roomId,
-			targetEventId: params.targetEventId,
-			approvalId: params.target.approvalId,
-			approvalKind: params.target.approvalKind,
-			result,
-			logVerboseMessage: params.logVerboseMessage
-		});
-		const canonicalDecision = "decision" in result.approval ? result.approval.decision : "none";
-		params.logVerboseMessage(`matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} applied=${result.applied} status=${result.approval.status} decision=${canonicalDecision}`);
-		return true;
-	} catch (err) {
-		if (isApprovalNotFoundError(err)) {
-			await unregisterMatrixApprovalReactionTargetsForApproval({
-				accountId: params.accountId,
-				approvalId: params.target.approvalId,
-				approvalKind: params.target.approvalKind
-			});
-			params.logVerboseMessage(`matrix: approval reaction ignored for expired approval id=${params.target.approvalId} sender=${params.senderId}`);
-			return true;
-		}
-		params.logVerboseMessage(`matrix: approval reaction failed id=${params.target.approvalId} sender=${params.senderId}: ${String(err)}`);
-		return true;
-	}
-}
-async function handleInboundMatrixReaction(params) {
-	const reaction = extractMatrixReactionAnnotation(params.event.content);
-	if (!reaction?.eventId) return;
-	if (params.senderId === params.selfUserId) return;
-	const approvalTarget = await resolveMatrixApprovalReactionTargetWithPersistence({
-		accountId: params.accountId,
-		roomId: params.roomId,
-		eventId: reaction.eventId,
-		reactionKey: reaction.key
-	});
-	if (await maybeResolveMatrixApprovalReaction({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		senderId: params.senderId,
-		target: approvalTarget,
-		targetEventId: reaction.eventId,
-		roomId: params.roomId,
-		client: params.client,
-		logVerboseMessage: params.logVerboseMessage
-	})) return;
-	const notificationMode = resolveMatrixReactionNotificationMode({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	if (notificationMode === "off") return;
-	const targetEvent = await params.client.getEvent(params.roomId, reaction.eventId).catch((err) => {
-		params.logVerboseMessage(`matrix: failed resolving reaction target room=${params.roomId} id=${reaction.eventId}: ${String(err)}`);
-		return null;
-	});
-	const targetSender = targetEvent && typeof targetEvent.sender === "string" ? targetEvent.sender.trim() : "";
-	if (!targetSender) return;
-	if (notificationMode === "own" && targetSender !== params.selfUserId) return;
-	const targetContent = targetEvent && targetEvent.content && typeof targetEvent.content === "object" ? targetEvent.content : void 0;
-	const threadRootId = targetContent ? resolveMatrixThreadRootId({
-		event: targetEvent,
-		content: targetContent
-	}) : void 0;
-	const accountConfig = resolveMatrixAccountConfig({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const thread = resolveMatrixThreadRouting({
-		isDirectMessage: params.isDirectMessage,
-		threadReplies: accountConfig.threadReplies ?? "inbound",
-		dmThreadReplies: accountConfig.dm?.threadReplies,
-		messageId: reaction.eventId,
-		threadRootId
-	});
-	const { route, runtimeBindingId } = resolveMatrixInboundRoute({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		roomId: params.roomId,
-		senderId: params.senderId,
-		isDirectMessage: params.isDirectMessage,
-		dmSessionScope: accountConfig.dm?.sessionScope ?? "per-user",
-		threadId: thread.threadId,
-		eventTs: params.event.origin_server_ts,
-		resolveAgentRoute: params.core.channel.routing.resolveAgentRoute
-	});
-	if (runtimeBindingId) getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts);
-	const text = `Matrix reaction added: ${reaction.key} by ${params.senderLabel} on msg ${reaction.eventId}`;
-	params.core.system.enqueueSystemEvent(text, {
-		sessionKey: route.sessionKey,
-		contextKey: `matrix:reaction:add:${params.roomId}:${reaction.eventId}:${params.senderId}:${reaction.key}`
-	});
-	params.logVerboseMessage(`matrix: reaction event enqueued room=${params.roomId} target=${reaction.eventId} sender=${params.senderId} emoji=${reaction.key}`);
-}
-//#endregion
-export { handleInboundMatrixReaction };

package/dist/record-shared-CWWx6fvI.js

@@ -1,2 +0,0 @@
-import { isRecord as isRecord$1 } from "openclaw/plugin-sdk/string-coerce-runtime";
-export { isRecord$1 as t };

package/dist/recovery-key-store-BNnHvXdk.js

@@ -1,275 +0,0 @@
-import { n as formatMatrixErrorReason, t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
-import { A as writeMatrixRecoveryKeyStateForPath, E as readMatrixRecoveryKeyStateForPath, S as readLegacyMatrixRecoveryKeyFile, _ as migrateLegacyMatrixRecoveryKeyFilePathToStore } from "./storage-BvAkgzvT.js";
-import { n as LogService } from "./logger-D0GCSDQq.js";
-import path from "node:path";
-import { decodeRecoveryKey } from "matrix-js-sdk/lib/crypto-api/recovery-key.js";
-//#region extensions/matrix/src/matrix/sdk/recovery-key-store.ts
-function isRepairableSecretStorageAccessError(err) {
-	const message = formatMatrixErrorReason(err);
-	if (!message) return false;
-	if (message.includes("getsecretstoragekey callback returned falsey")) return true;
-	if (message.includes("decrypting secret") && message.includes("bad mac")) return true;
-	return false;
-}
-var MatrixRecoveryKeyStore = class {
-	constructor(recoveryKeyPath) {
-		this.secretStorageKeyCache = /* @__PURE__ */ new Map();
-		this.stagedRecoveryKey = null;
-		this.stagedRecoveryKeyUsed = false;
-		this.stagedCacheKeyIds = /* @__PURE__ */ new Set();
-		this.recoveryKeyPath = recoveryKeyPath;
-		this.storageRootDir = recoveryKeyPath ? path.dirname(recoveryKeyPath) : void 0;
-		if (this.recoveryKeyPath) try {
-			migrateLegacyMatrixRecoveryKeyFilePathToStore(this.recoveryKeyPath);
-		} catch (err) {
-			this.legacyRecoveryKeyPathOnMigrationFailure = this.recoveryKeyPath;
-			LogService.warn("MatrixClientLite", "Failed to migrate Matrix recovery key state:", err);
-		}
-	}
-	buildCryptoCallbacks() {
-		return {
-			getSecretStorageKey: async ({ keys }) => {
-				const requestedKeyIds = Object.keys(keys ?? {});
-				if (requestedKeyIds.length === 0) return null;
-				const staged = this.resolveStagedSecretStorageKey(requestedKeyIds);
-				if (staged) return staged;
-				for (const keyId of requestedKeyIds) {
-					const cached = this.secretStorageKeyCache.get(keyId);
-					if (cached) return [keyId, new Uint8Array(cached.key)];
-				}
-				const stored = this.loadStoredRecoveryKey();
-				if (!stored?.privateKeyBase64) return null;
-				const privateKey = new Uint8Array(Buffer.from(stored.privateKeyBase64, "base64"));
-				if (privateKey.length === 0) return null;
-				if (stored.keyId && requestedKeyIds.includes(stored.keyId)) {
-					this.rememberSecretStorageKey(stored.keyId, privateKey, stored.keyInfo);
-					return [stored.keyId, privateKey];
-				}
-				const firstRequestedKeyId = requestedKeyIds[0];
-				if (!firstRequestedKeyId) return null;
-				this.rememberSecretStorageKey(firstRequestedKeyId, privateKey, stored.keyInfo);
-				return [firstRequestedKeyId, privateKey];
-			},
-			cacheSecretStorageKey: (keyId, keyInfo, key) => {
-				const privateKey = new Uint8Array(key);
-				const normalizedKeyInfo = {
-					passphrase: keyInfo?.passphrase,
-					name: typeof keyInfo?.name === "string" ? keyInfo.name : void 0
-				};
-				this.rememberSecretStorageKey(keyId, privateKey, normalizedKeyInfo);
-				const stored = this.loadStoredRecoveryKey();
-				this.saveRecoveryKeyToDisk({
-					keyId,
-					keyInfo: normalizedKeyInfo,
-					privateKey,
-					encodedPrivateKey: stored?.encodedPrivateKey
-				});
-			}
-		};
-	}
-	getRecoveryKeySummary() {
-		const stored = this.loadStoredRecoveryKey();
-		if (!stored) return null;
-		return {
-			encodedPrivateKey: stored.encodedPrivateKey,
-			keyId: stored.keyId,
-			createdAt: stored.createdAt
-		};
-	}
-	getSecretStorageKeyCandidate(keyId) {
-		const normalizedKeyId = keyId.trim();
-		if (!normalizedKeyId) return null;
-		const staged = this.resolveStagedSecretStorageKey([normalizedKeyId]);
-		if (staged) return staged[1];
-		const stored = this.loadStoredRecoveryKey();
-		if (!stored?.privateKeyBase64) return null;
-		const privateKey = new Uint8Array(Buffer.from(stored.privateKeyBase64, "base64"));
-		if (privateKey.length === 0) return null;
-		this.rememberSecretStorageKey(normalizedKeyId, privateKey, stored.keyInfo);
-		return privateKey;
-	}
-	resolveEncodedRecoveryKeyInput(params) {
-		const encodedPrivateKey = params.encodedPrivateKey.trim();
-		if (!encodedPrivateKey) throw new Error("Matrix recovery key is required");
-		let privateKey;
-		try {
-			privateKey = decodeRecoveryKey(encodedPrivateKey);
-		} catch (err) {
-			throw new Error(`Invalid Matrix recovery key: ${formatMatrixErrorMessage(err)}`, { cause: err });
-		}
-		const keyId = typeof params.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : null;
-		return {
-			encodedPrivateKey,
-			privateKey,
-			keyId,
-			keyInfo: params.keyInfo ?? this.loadStoredRecoveryKey()?.keyInfo
-		};
-	}
-	storeEncodedRecoveryKey(params) {
-		const prepared = this.resolveEncodedRecoveryKeyInput(params);
-		this.saveRecoveryKeyToDisk({
-			keyId: prepared.keyId,
-			keyInfo: prepared.keyInfo,
-			privateKey: prepared.privateKey,
-			encodedPrivateKey: prepared.encodedPrivateKey
-		});
-		if (prepared.keyId) this.rememberSecretStorageKey(prepared.keyId, prepared.privateKey, prepared.keyInfo);
-		return this.getRecoveryKeySummary() ?? {};
-	}
-	stageEncodedRecoveryKey(params) {
-		const prepared = this.resolveEncodedRecoveryKeyInput(params);
-		this.discardStagedRecoveryKey();
-		this.stagedRecoveryKey = {
-			version: 1,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			keyId: prepared.keyId,
-			encodedPrivateKey: prepared.encodedPrivateKey,
-			privateKeyBase64: Buffer.from(prepared.privateKey).toString("base64"),
-			keyInfo: prepared.keyInfo
-		};
-	}
-	hasStagedRecoveryKeyBeenUsed() {
-		return this.stagedRecoveryKeyUsed;
-	}
-	commitStagedRecoveryKey(params) {
-		if (!this.stagedRecoveryKey) return this.getRecoveryKeySummary();
-		const staged = this.stagedRecoveryKey;
-		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
-		const keyId = typeof params?.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : staged.keyId;
-		this.saveRecoveryKeyToDisk({
-			keyId,
-			keyInfo: params?.keyInfo ?? staged.keyInfo,
-			privateKey,
-			encodedPrivateKey: staged.encodedPrivateKey
-		});
-		this.clearStagedRecoveryKeyTracking();
-		return this.getRecoveryKeySummary();
-	}
-	discardStagedRecoveryKey() {
-		for (const keyId of this.stagedCacheKeyIds) this.secretStorageKeyCache.delete(keyId);
-		this.clearStagedRecoveryKeyTracking();
-	}
-	async bootstrapSecretStorageWithRecoveryKey(crypto, options = {}) {
-		let status = null;
-		const getSecretStorageStatus = crypto.getSecretStorageStatus;
-		if (typeof getSecretStorageStatus === "function") try {
-			status = await getSecretStorageStatus.call(crypto);
-		} catch (err) {
-			LogService.warn("MatrixClientLite", "Failed to read secret storage status:", err);
-		}
-		const hasDefaultSecretStorageKey = Boolean(status?.defaultKeyId);
-		const hasKnownInvalidSecrets = Object.values(status?.secretStorageKeyValidityMap ?? {}).some((valid) => !valid);
-		let generatedRecoveryKey = false;
-		const storedRecovery = this.loadStoredRecoveryKey();
-		const stagedRecovery = this.stagedRecoveryKey;
-		const sourceRecovery = options.forceNewRecoveryKey === true ? null : stagedRecovery ?? storedRecovery;
-		let recoveryKey = sourceRecovery ? {
-			keyInfo: sourceRecovery.keyInfo,
-			privateKey: new Uint8Array(Buffer.from(sourceRecovery.privateKeyBase64, "base64")),
-			encodedPrivateKey: sourceRecovery.encodedPrivateKey
-		} : null;
-		if (recoveryKey && status?.defaultKeyId) {
-			const defaultKeyId = status.defaultKeyId;
-			if (!stagedRecovery) {
-				this.rememberSecretStorageKey(defaultKeyId, recoveryKey.privateKey, recoveryKey.keyInfo);
-				if (storedRecovery && storedRecovery.keyId !== defaultKeyId) this.saveRecoveryKeyToDisk({
-					keyId: defaultKeyId,
-					keyInfo: recoveryKey.keyInfo,
-					privateKey: recoveryKey.privateKey,
-					encodedPrivateKey: recoveryKey.encodedPrivateKey
-				});
-			}
-		}
-		const ensureRecoveryKey = async () => {
-			if (recoveryKey) {
-				if (stagedRecovery) this.stagedRecoveryKeyUsed = true;
-				return recoveryKey;
-			}
-			if (typeof crypto.createRecoveryKeyFromPassphrase !== "function") throw new Error("Matrix crypto backend does not support recovery key generation (createRecoveryKeyFromPassphrase missing)");
-			recoveryKey = await crypto.createRecoveryKeyFromPassphrase();
-			this.saveRecoveryKeyToDisk(recoveryKey);
-			generatedRecoveryKey = true;
-			return recoveryKey;
-		};
-		const shouldRecreateSecretStorage = options.forceNewSecretStorage === true || !hasDefaultSecretStorageKey || !recoveryKey && status?.ready === false || hasKnownInvalidSecrets;
-		if (hasKnownInvalidSecrets) recoveryKey = null;
-		const secretStorageOptions = { setupNewKeyBackup: options.setupNewKeyBackup === true };
-		if (shouldRecreateSecretStorage) {
-			secretStorageOptions.setupNewSecretStorage = true;
-			secretStorageOptions.createSecretStorageKey = ensureRecoveryKey;
-		}
-		try {
-			await crypto.bootstrapSecretStorage(secretStorageOptions);
-		} catch (err) {
-			if (!(options.allowSecretStorageRecreateWithoutRecoveryKey === true && hasDefaultSecretStorageKey && isRepairableSecretStorageAccessError(err))) throw err;
-			recoveryKey = null;
-			LogService.warn("MatrixClientLite", "Secret storage exists on the server but local recovery material cannot unlock it; recreating secret storage during explicit bootstrap.");
-			await crypto.bootstrapSecretStorage({
-				setupNewSecretStorage: true,
-				setupNewKeyBackup: options.setupNewKeyBackup === true,
-				createSecretStorageKey: ensureRecoveryKey
-			});
-		}
-		if (generatedRecoveryKey && this.storageRootDir) LogService.warn("MatrixClientLite", "Generated Matrix recovery key and saved it to Matrix SQLite state. Keep the displayed recovery key secure.");
-	}
-	clearStagedRecoveryKeyTracking() {
-		this.stagedRecoveryKey = null;
-		this.stagedRecoveryKeyUsed = false;
-		this.stagedCacheKeyIds.clear();
-	}
-	resolveStagedSecretStorageKey(requestedKeyIds) {
-		const staged = this.stagedRecoveryKey;
-		if (!staged?.privateKeyBase64) return null;
-		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
-		if (privateKey.length === 0) return null;
-		const keyId = staged.keyId && requestedKeyIds.includes(staged.keyId) ? staged.keyId : requestedKeyIds[0];
-		if (!keyId) return null;
-		this.rememberStagedSecretStorageKey(keyId, privateKey, staged.keyInfo);
-		this.stagedCacheKeyIds.add(keyId);
-		return [keyId, privateKey];
-	}
-	rememberStagedSecretStorageKey(keyId, key, keyInfo) {
-		this.stagedRecoveryKeyUsed = true;
-		this.rememberSecretStorageKey(keyId, key, keyInfo);
-	}
-	rememberSecretStorageKey(keyId, key, keyInfo) {
-		if (!keyId.trim()) return;
-		this.secretStorageKeyCache.set(keyId, {
-			key: new Uint8Array(key),
-			keyInfo
-		});
-	}
-	loadStoredRecoveryKey() {
-		if (!this.recoveryKeyPath) return null;
-		try {
-			const stored = readMatrixRecoveryKeyStateForPath(this.recoveryKeyPath);
-			if (stored) return stored;
-		} catch {}
-		if (this.legacyRecoveryKeyPathOnMigrationFailure) return readLegacyMatrixRecoveryKeyFile(this.legacyRecoveryKeyPathOnMigrationFailure);
-		return null;
-	}
-	saveRecoveryKeyToDisk(params) {
-		if (!this.recoveryKeyPath) return;
-		try {
-			const payload = {
-				version: 1,
-				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-				keyId: typeof params.keyId === "string" ? params.keyId : null,
-				encodedPrivateKey: params.encodedPrivateKey,
-				privateKeyBase64: Buffer.from(params.privateKey).toString("base64"),
-				keyInfo: params.keyInfo ? {
-					passphrase: params.keyInfo.passphrase,
-					name: params.keyInfo.name
-				} : void 0
-			};
-			writeMatrixRecoveryKeyStateForPath({
-				recoveryKeyPath: this.recoveryKeyPath,
-				payload
-			});
-		} catch (err) {
-			LogService.warn("MatrixClientLite", "Failed to persist recovery key:", err);
-		}
-	}
-};
-//#endregion
-export { isRepairableSecretStorageAccessError as n, MatrixRecoveryKeyStore as t };

package/dist/resolve-targets-nNMcrV3W.js

@@ -1,140 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.js";
-import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-YRgYDx2w.js";
-import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/matrix/src/resolve-targets.ts
-var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });
-function normalizeLookupQuery(query) {
-	return normalizeOptionalLowercaseString(query) ?? "";
-}
-function findExactDirectoryMatches(matches, query) {
-	const normalized = normalizeLookupQuery(query);
-	if (!normalized) return [];
-	return matches.filter((match) => {
-		const id = normalizeOptionalLowercaseString(match.id);
-		const name = normalizeOptionalLowercaseString(match.name);
-		const handle = normalizeOptionalLowercaseString(match.handle);
-		return normalized === id || normalized === name || normalized === handle;
-	});
-}
-function pickBestGroupMatch(matches, query) {
-	if (matches.length === 0) return {};
-	const exact = findExactDirectoryMatches(matches, query);
-	if (exact.length > 1) return {
-		best: exact[0],
-		note: "multiple exact matches; chose first"
-	};
-	if (exact.length === 1) return { best: exact[0] };
-	return {
-		best: matches[0],
-		note: matches.length > 1 ? "multiple matches; chose first" : void 0
-	};
-}
-function pickBestUserMatch(matches, query) {
-	if (matches.length === 0) return;
-	const exact = findExactDirectoryMatches(matches, query);
-	if (exact.length === 1) return exact[0];
-}
-function describeUserMatchFailure(matches, query) {
-	if (matches.length === 0) return "no matches";
-	const normalized = normalizeLookupQuery(query);
-	if (!normalized) return "empty input";
-	const exact = findExactDirectoryMatches(matches, normalized);
-	if (exact.length === 0) return "no exact match; use full Matrix ID";
-	if (exact.length > 1) return "multiple exact matches; use full Matrix ID";
-	return "no exact match; use full Matrix ID";
-}
-async function readCachedMatches(cache, query, lookup) {
-	const key = normalizeLookupQuery(query);
-	if (!key) return [];
-	const cached = cache.get(key);
-	if (cached) return cached;
-	const matches = await lookup(query.trim());
-	cache.set(key, matches);
-	return matches;
-}
-async function resolveMatrixTargets(params) {
-	const results = [];
-	const userLookupCache = /* @__PURE__ */ new Map();
-	const groupLookupCache = /* @__PURE__ */ new Map();
-	for (const input of params.inputs) {
-		const trimmed = input.trim();
-		if (!trimmed) {
-			results.push({
-				input,
-				resolved: false,
-				note: "empty input"
-			});
-			continue;
-		}
-		if (params.kind === "user") {
-			const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
-			if (normalizedTarget && isMatrixQualifiedUserId(normalizedTarget)) {
-				results.push({
-					input,
-					resolved: true,
-					id: normalizedTarget
-				});
-				continue;
-			}
-			try {
-				const matches = await readCachedMatches(userLookupCache, trimmed, (query) => listMatrixDirectoryPeersLive({
-					cfg: params.cfg,
-					accountId: params.accountId,
-					query,
-					limit: 5
-				}));
-				const best = pickBestUserMatch(matches, trimmed);
-				results.push({
-					input,
-					resolved: Boolean(best?.id),
-					id: best?.id,
-					name: best?.name,
-					note: best ? void 0 : describeUserMatchFailure(matches, trimmed)
-				});
-			} catch (err) {
-				params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
-				results.push({
-					input,
-					resolved: false,
-					note: "lookup failed"
-				});
-			}
-			continue;
-		}
-		const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
-		if (normalizedTarget?.startsWith("!")) {
-			results.push({
-				input,
-				resolved: true,
-				id: normalizedTarget
-			});
-			continue;
-		}
-		try {
-			const { best, note } = pickBestGroupMatch(await readCachedMatches(groupLookupCache, trimmed, (query) => listMatrixDirectoryGroupsLive({
-				cfg: params.cfg,
-				accountId: params.accountId,
-				query,
-				limit: 5
-			})), trimmed);
-			results.push({
-				input,
-				resolved: Boolean(best?.id),
-				id: best?.id,
-				name: best?.name,
-				note
-			});
-		} catch (err) {
-			params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
-			results.push({
-				input,
-				resolved: false,
-				note: "lookup failed"
-			});
-		}
-	}
-	return results;
-}
-//#endregion
-export { resolve_targets_exports as n, resolveMatrixTargets as t };

package/dist/resolver.runtime-BvaFlVLg.js

@@ -1,5 +0,0 @@
-import { t as resolveMatrixTargets } from "./resolve-targets-nNMcrV3W.js";
-//#region extensions/matrix/src/resolver.runtime.ts
-const matrixResolverRuntime = { resolveMatrixTargets };
-//#endregion
-export { matrixResolverRuntime };