@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/cli-metadata-DnXxNCoj.js

@@ -1,22 +0,0 @@
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-//#region extensions/matrix/src/cli-metadata.ts
-function registerMatrixCliMetadata(api) {
-	api.registerCli(async ({ program }) => {
-		const { registerMatrixCli } = await import("./cli-0CNHkps5.js");
-		registerMatrixCli({ program });
-	}, { descriptors: [{
-		name: "matrix",
-		description: "Manage Matrix accounts, verification, devices, and profile state",
-		hasSubcommands: true
-	}] });
-}
-//#endregion
-//#region extensions/matrix/cli-metadata.ts
-var cli_metadata_default = definePluginEntry({
-	id: "matrix",
-	name: "Matrix",
-	description: "Matrix channel plugin (matrix-js-sdk)",
-	register: registerMatrixCliMetadata
-});
-//#endregion
-export { registerMatrixCliMetadata as n, cli_metadata_default as t };

package/dist/client-BFRg0kd4.js

@@ -1,30 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as getMatrixScopedEnvVarNames } from "./env-vars-B0NxQnPk.js";
-import { i as resolveScopedMatrixEnvConfig, r as resolveMatrixEnvAuthReadiness, t as hasReadyMatrixEnvAuth } from "./env-auth-CQsYbz-p.js";
-import { n as validateMatrixHomeserverUrl, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
-import { t as isBunRuntime } from "./runtime-BefyhPWv.js";
-import { d as backfillMatrixAuthDeviceIdAfterStartup, f as resolveMatrixAuth, i as resolveSharedMatrixClient, m as resolveMatrixConfigForAccount, n as releaseSharedClientInstance, o as stopSharedClientForAccount, p as resolveMatrixAuthContext, r as removeSharedClientInstance, s as stopSharedClientInstance, t as acquireSharedMatrixClient } from "./shared-CUH5otj8.js";
-import { t as createMatrixClient } from "./create-client-f-CkRllE.js";
-//#region extensions/matrix/src/matrix/client.ts
-var client_exports = /* @__PURE__ */ __exportAll({
-	acquireSharedMatrixClient: () => acquireSharedMatrixClient,
-	backfillMatrixAuthDeviceIdAfterStartup: () => backfillMatrixAuthDeviceIdAfterStartup,
-	createMatrixClient: () => createMatrixClient,
-	getMatrixScopedEnvVarNames: () => getMatrixScopedEnvVarNames,
-	hasReadyMatrixEnvAuth: () => hasReadyMatrixEnvAuth,
-	isBunRuntime: () => isBunRuntime,
-	releaseSharedClientInstance: () => releaseSharedClientInstance,
-	removeSharedClientInstance: () => removeSharedClientInstance,
-	resolveMatrixAuth: () => resolveMatrixAuth,
-	resolveMatrixAuthContext: () => resolveMatrixAuthContext,
-	resolveMatrixConfigForAccount: () => resolveMatrixConfigForAccount,
-	resolveMatrixEnvAuthReadiness: () => resolveMatrixEnvAuthReadiness,
-	resolveScopedMatrixEnvConfig: () => resolveScopedMatrixEnvConfig,
-	resolveSharedMatrixClient: () => resolveSharedMatrixClient,
-	resolveValidatedMatrixHomeserverUrl: () => resolveValidatedMatrixHomeserverUrl,
-	stopSharedClientForAccount: () => stopSharedClientForAccount,
-	stopSharedClientInstance: () => stopSharedClientInstance,
-	validateMatrixHomeserverUrl: () => validateMatrixHomeserverUrl
-});
-//#endregion
-export { client_exports as t };

package/dist/client-CitERujx.js

@@ -1,25 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { c as resolveMatrixRoomId } from "./send-C9Ssx-iV.js";
-import { n as withResolvedRuntimeMatrixClient } from "./client-bootstrap-CkAnkzB6.js";
-//#region extensions/matrix/src/matrix/actions/client.ts
-var client_exports = /* @__PURE__ */ __exportAll({
-	withResolvedActionClient: () => withResolvedActionClient,
-	withResolvedRoomAction: () => withResolvedRoomAction,
-	withStartedActionClient: () => withStartedActionClient
-});
-async function withResolvedActionClient(opts, run, mode = "stop") {
-	return await withResolvedRuntimeMatrixClient(opts, run, mode);
-}
-async function withStartedActionClient(opts, run) {
-	return await withResolvedActionClient({
-		...opts,
-		readiness: "started"
-	}, run, "persist");
-}
-async function withResolvedRoomAction(roomId, opts, run) {
-	return await withResolvedActionClient(opts, async (client) => {
-		return await run(client, await resolveMatrixRoomId(client, roomId));
-	});
-}
-//#endregion
-export { withStartedActionClient as i, withResolvedActionClient as n, withResolvedRoomAction as r, client_exports as t };

package/dist/client-bootstrap-CkAnkzB6.js

@@ -1,110 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as getActiveMatrixClient } from "./active-client-DXvz2gCo.js";
-import { t as isBunRuntime } from "./runtime-BefyhPWv.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
-//#region extensions/matrix/src/matrix/client-bootstrap.ts
-var client_bootstrap_exports = /* @__PURE__ */ __exportAll({
-	resolveRuntimeMatrixClientWithReadiness: () => resolveRuntimeMatrixClientWithReadiness,
-	withResolvedRuntimeMatrixClient: () => withResolvedRuntimeMatrixClient
-});
-const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./client-BFRg0kd4.js").then((n) => n.t), import("./shared-CUH5otj8.js").then((n) => n.a)]).then(([clientModule, sharedModule]) => ({
-	acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
-	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext,
-	releaseSharedClientInstance: sharedModule.releaseSharedClientInstance
-})));
-async function ensureResolvedClientReadiness(params) {
-	if (params.readiness === "started") {
-		await params.client.start();
-		return;
-	}
-	if (params.readiness === "prepared" || !params.readiness && params.preparedByDefault) await params.client.prepareForOneOff();
-}
-function ensureMatrixNodeRuntime() {
-	if (isBunRuntime()) throw new Error("Matrix support requires Node (bun runtime not supported)");
-}
-async function resolveRuntimeMatrixClient(opts) {
-	ensureMatrixNodeRuntime();
-	if (opts.client) {
-		await opts.onResolved?.(opts.client, { preparedByDefault: false });
-		return {
-			client: opts.client,
-			stopOnDone: false
-		};
-	}
-	if (!opts.cfg) throw new Error("Matrix runtime client requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
-	const cfg = requireRuntimeConfig(opts.cfg, "Matrix runtime client");
-	const { acquireSharedMatrixClient, releaseSharedClientInstance, resolveMatrixAuthContext } = await loadMatrixSharedClientRuntimeDeps();
-	const authContext = resolveMatrixAuthContext({
-		cfg,
-		accountId: opts.accountId
-	});
-	const active = getActiveMatrixClient(authContext.accountId);
-	if (active) {
-		await opts.onResolved?.(active, { preparedByDefault: false });
-		return {
-			client: active,
-			stopOnDone: false
-		};
-	}
-	const client = await acquireSharedMatrixClient({
-		cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: authContext.accountId,
-		startClient: false
-	});
-	try {
-		await opts.onResolved?.(client, { preparedByDefault: true });
-	} catch (err) {
-		await releaseSharedClientInstance(client, "stop");
-		throw err;
-	}
-	return {
-		client,
-		stopOnDone: true,
-		cleanup: async (mode) => {
-			await releaseSharedClientInstance(client, mode);
-		}
-	};
-}
-async function resolveRuntimeMatrixClientWithReadiness(opts) {
-	return await resolveRuntimeMatrixClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId,
-		onResolved: async (client, context) => {
-			await ensureResolvedClientReadiness({
-				client,
-				readiness: opts.readiness,
-				preparedByDefault: context.preparedByDefault
-			});
-		}
-	});
-}
-async function stopResolvedRuntimeMatrixClient(resolved, mode = "stop") {
-	if (!resolved.stopOnDone) return;
-	if (resolved.cleanup) {
-		await resolved.cleanup(mode);
-		return;
-	}
-	if (mode === "persist") {
-		await resolved.client.stopAndPersist();
-		return;
-	}
-	if (mode === "discard") {
-		resolved.client.stopWithoutPersist();
-		return;
-	}
-	resolved.client.stop();
-}
-async function withResolvedRuntimeMatrixClient(opts, run, stopMode = "stop") {
-	const resolved = await resolveRuntimeMatrixClientWithReadiness(opts);
-	try {
-		return await run(resolved.client);
-	} finally {
-		await stopResolvedRuntimeMatrixClient(resolved, stopMode);
-	}
-}
-//#endregion
-export { withResolvedRuntimeMatrixClient as n, client_bootstrap_exports as t };

package/dist/config-schema-BShrVROw.js

@@ -1,302 +0,0 @@
-import { a as resolveMatrixAccountConfig } from "./account-config-BZWN9tGS.js";
-import { _ as resolveMatrixAccount, g as resolveDefaultMatrixAccountId, m as listMatrixAccountIds } from "./setup-core-a542Ernq.js";
-import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
-import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
-import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
-import { normalizeStringEntries as normalizeStringEntries$1 } from "openclaw/plugin-sdk/string-normalization-runtime";
-import { AllowFromListSchema, BlockStreamingCoalesceSchema, ContextVisibilityModeSchema, GroupPolicySchema, MarkdownConfigSchema, MentionPatternsPolicySchema, buildChannelConfigSchema, buildGroupEntrySchema, buildNestedDmConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
-import { buildSecretInputSchema } from "openclaw/plugin-sdk/secret-input";
-import { z } from "zod";
-//#region extensions/matrix/src/matrix/monitor/allowlist.ts
-function normalizeAllowList(list) {
-	return normalizeStringEntries$1(list);
-}
-function normalizeMatrixUser(raw) {
-	const value = (raw ?? "").trim();
-	if (!value) return "";
-	if (!value.startsWith("@") || !value.includes(":")) return normalizeLowercaseStringOrEmpty(value);
-	const withoutAt = value.slice(1);
-	const splitIndex = withoutAt.indexOf(":");
-	if (splitIndex === -1) return normalizeLowercaseStringOrEmpty(value);
-	const localpart = normalizeLowercaseStringOrEmpty(withoutAt.slice(0, splitIndex));
-	const server = normalizeLowercaseStringOrEmpty(withoutAt.slice(splitIndex + 1));
-	if (!server) return normalizeLowercaseStringOrEmpty(value);
-	return `@${localpart}:${server}`;
-}
-function normalizeMatrixUserId(raw) {
-	const trimmed = (raw ?? "").trim();
-	if (!trimmed) return "";
-	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
-	if (lowered.startsWith("matrix:")) return normalizeMatrixUser(trimmed.slice(7));
-	if (lowered.startsWith("user:")) return normalizeMatrixUser(trimmed.slice(5));
-	return normalizeMatrixUser(trimmed);
-}
-function normalizeMatrixAllowListEntry(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return "";
-	if (trimmed === "*") return trimmed;
-	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
-	if (lowered.startsWith("matrix:")) return `matrix:${normalizeMatrixUser(trimmed.slice(7))}`;
-	if (lowered.startsWith("user:")) return `user:${normalizeMatrixUser(trimmed.slice(5))}`;
-	return normalizeMatrixUser(trimmed);
-}
-function normalizeMatrixAllowList(list) {
-	return normalizeAllowList(list).map((entry) => normalizeMatrixAllowListEntry(entry));
-}
-function resolveMatrixAllowListMatch(params) {
-	const allowList = params.allowList;
-	if (allowList.length === 0) return { allowed: false };
-	if (allowList.includes("*")) return {
-		allowed: true,
-		matchKey: "*",
-		matchSource: "wildcard"
-	};
-	const userId = normalizeMatrixUser(params.userId);
-	return resolveAllowlistMatchByCandidates({
-		allowList,
-		candidates: [
-			{
-				value: userId,
-				source: "id"
-			},
-			{
-				value: userId ? `matrix:${userId}` : "",
-				source: "prefixed-id"
-			},
-			{
-				value: userId ? `user:${userId}` : "",
-				source: "prefixed-user"
-			}
-		]
-	});
-}
-//#endregion
-//#region extensions/matrix/src/config-adapter.ts
-const matrixConfigAdapter = createScopedChannelConfigAdapter({
-	sectionKey: "matrix",
-	listAccountIds: listMatrixAccountIds,
-	resolveAccount: adaptScopedAccountAccessor(resolveMatrixAccount),
-	resolveAccessorAccount: ({ cfg, accountId }) => resolveMatrixAccountConfig({
-		cfg,
-		accountId
-	}),
-	defaultAccountId: resolveDefaultMatrixAccountId,
-	clearBaseFields: [
-		"name",
-		"homeserver",
-		"network",
-		"proxy",
-		"userId",
-		"accessToken",
-		"password",
-		"deviceId",
-		"deviceName",
-		"avatarUrl",
-		"initialSyncLimit"
-	],
-	resolveAllowFrom: (account) => account.dm?.allowFrom,
-	formatAllowFrom: (allowFrom) => normalizeMatrixAllowList(allowFrom)
-});
-//#endregion
-//#region extensions/matrix/src/config-ui-hints.ts
-const matrixChannelConfigUiHints = {
-	...createChannelConfigUiHints({
-		channelLabel: "Matrix",
-		mentionPatterns: {
-			targetDescription: "Matrix room IDs",
-			policyNote: "Native Matrix mention evidence still triggers even when regex patterns are denied.",
-			denyNote: "Native mention evidence still triggers."
-		}
-	}),
-	allowBots: {
-		label: "Matrix Allow Bot Messages",
-		help: "Allow messages from other configured Matrix bot accounts to trigger replies (default: false). Set \"mentions\" to require a visible room mention."
-	},
-	botLoopProtection: {
-		label: "Matrix Bot Loop Protection",
-		help: "Sliding-window guard for accepted Matrix configured-bot loops. Default is enabled whenever allowBots lets configured bot messages reach dispatch."
-	},
-	"botLoopProtection.enabled": {
-		label: "Matrix Bot Loop Protection Enabled",
-		help: "Enable the bot-pair loop guard. Defaults to true when allowBots is true or \"mentions\", and false when configured bot messages are ignored."
-	},
-	"botLoopProtection.maxEventsPerWindow": {
-		label: "Matrix Bot Loop Events per Window",
-		help: "Maximum accepted bot-pair messages within the sliding window before suppression starts. Default: 20."
-	},
-	"botLoopProtection.windowSeconds": {
-		label: "Matrix Bot Loop Window Seconds",
-		help: "Sliding window length for counting bot-pair messages. Default: 60."
-	},
-	"botLoopProtection.cooldownSeconds": {
-		label: "Matrix Bot Loop Cooldown Seconds",
-		help: "How long to suppress the bot pair after it exceeds the budget. Default: 60."
-	},
-	dangerouslyAllowNameMatching: {
-		label: "Matrix Display Name Matching",
-		help: "Compatibility opt-in for resolving Matrix display names and joined room names in allowlists. Prefer full @user:server IDs and room IDs or aliases because names are mutable."
-	},
-	...createChannelConfigUiHints({
-		channelLabel: "Matrix",
-		progress: {}
-	})
-};
-//#endregion
-//#region extensions/matrix/src/config-schema.ts
-const matrixActionSchema = z.object({
-	reactions: z.boolean().optional(),
-	messages: z.boolean().optional(),
-	pins: z.boolean().optional(),
-	profile: z.boolean().optional(),
-	memberInfo: z.boolean().optional(),
-	channelInfo: z.boolean().optional(),
-	verification: z.boolean().optional()
-}).optional();
-const matrixThreadBindingsSchema = z.object({
-	enabled: z.boolean().optional(),
-	idleHours: z.number().nonnegative().optional(),
-	maxAgeHours: z.number().nonnegative().optional(),
-	spawnSessions: z.boolean().optional(),
-	defaultSpawnContext: z.enum(["isolated", "fork"]).optional()
-}).optional();
-const matrixExecApprovalsSchema = z.object({
-	enabled: z.boolean().optional(),
-	approvers: AllowFromListSchema,
-	agentFilter: z.array(z.string()).optional(),
-	sessionFilter: z.array(z.string()).optional(),
-	target: z.enum([
-		"dm",
-		"channel",
-		"both"
-	]).optional()
-}).optional();
-const botLoopProtectionSchema = z.object({
-	enabled: z.boolean().optional(),
-	maxEventsPerWindow: z.number().int().positive().optional(),
-	windowSeconds: z.number().int().positive().optional(),
-	cooldownSeconds: z.number().int().positive().optional()
-}).strict().optional();
-const matrixRoomSchema = buildGroupEntrySchema({
-	account: z.string().optional(),
-	allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
-	botLoopProtection: botLoopProtectionSchema,
-	autoReply: z.boolean().optional(),
-	users: AllowFromListSchema
-}).omit({
-	toolsBySender: true,
-	allowFrom: true
-}).strict().optional();
-const matrixNetworkSchema = z.object({ dangerouslyAllowPrivateNetwork: z.boolean().optional() }).strict().optional();
-const matrixStreamingSchema = z.object({
-	mode: z.enum([
-		"partial",
-		"quiet",
-		"progress",
-		"off"
-	]).optional(),
-	chunkMode: z.enum(["length", "newline"]).optional(),
-	block: z.object({
-		enabled: z.boolean().optional(),
-		coalesce: BlockStreamingCoalesceSchema.optional()
-	}).strict().optional(),
-	progress: z.object({
-		label: z.union([z.string(), z.literal(false)]).optional(),
-		labels: z.array(z.string()).optional(),
-		maxLines: z.number().int().positive().optional(),
-		maxLineChars: z.number().int().positive().optional(),
-		toolProgress: z.boolean().optional(),
-		commandText: z.enum(["raw", "status"]).optional()
-	}).strict().optional(),
-	preview: z.object({ toolProgress: z.boolean().optional() }).strict().optional()
-}).strict();
-const retiredMatrixAccountStreamingKeys = [
-	"streamMode",
-	"chunkMode",
-	"blockStreaming",
-	"blockStreamingCoalesce",
-	"draftChunk"
-];
-function hasCanonicalMatrixAccountStreaming(account) {
-	if (typeof account !== "object" || account === null || Array.isArray(account)) return true;
-	if (retiredMatrixAccountStreamingKeys.some((key) => Object.hasOwn(account, key))) return false;
-	if (!Object.hasOwn(account, "streaming")) return true;
-	const streaming = account.streaming;
-	return typeof streaming === "object" && streaming !== null && !Array.isArray(streaming);
-}
-const MatrixChannelConfigSchema = buildChannelConfigSchema(z.object({
-	name: z.string().optional(),
-	enabled: z.boolean().optional(),
-	defaultAccount: z.string().optional(),
-	accounts: z.record(z.string(), z.unknown().refine(hasCanonicalMatrixAccountStreaming, { message: "flat or scalar streaming values are no longer supported; use streaming.* and run \"openclaw doctor --fix\"" })).optional(),
-	markdown: MarkdownConfigSchema,
-	homeserver: z.string().optional(),
-	network: matrixNetworkSchema,
-	proxy: z.string().optional(),
-	userId: z.string().optional(),
-	accessToken: buildSecretInputSchema().optional(),
-	password: buildSecretInputSchema().optional(),
-	deviceId: z.string().optional(),
-	deviceName: z.string().optional(),
-	avatarUrl: z.string().optional(),
-	initialSyncLimit: z.number().optional(),
-	encryption: z.boolean().optional(),
-	allowlistOnly: z.boolean().optional(),
-	dangerouslyAllowNameMatching: z.boolean().optional(),
-	allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
-	botLoopProtection: botLoopProtectionSchema,
-	groupPolicy: GroupPolicySchema.optional(),
-	mentionPatterns: MentionPatternsPolicySchema.optional(),
-	contextVisibility: ContextVisibilityModeSchema.optional(),
-	streaming: matrixStreamingSchema.optional(),
-	replyToMode: z.enum([
-		"off",
-		"first",
-		"all",
-		"batched"
-	]).optional(),
-	threadReplies: z.enum([
-		"off",
-		"inbound",
-		"always"
-	]).optional(),
-	textChunkLimit: z.number().optional(),
-	responsePrefix: z.string().optional(),
-	ackReaction: z.string().optional(),
-	ackReactionScope: z.enum([
-		"group-mentions",
-		"group-all",
-		"direct",
-		"all",
-		"none",
-		"off"
-	]).optional(),
-	reactionNotifications: z.enum(["off", "own"]).optional(),
-	threadBindings: matrixThreadBindingsSchema,
-	startupVerification: z.enum(["off", "if-unverified"]).optional(),
-	startupVerificationCooldownHours: z.number().optional(),
-	mediaMaxMb: z.number().optional(),
-	historyLimit: z.number().int().min(0).optional(),
-	autoJoin: z.enum([
-		"always",
-		"allowlist",
-		"off"
-	]).optional(),
-	autoJoinAllowlist: AllowFromListSchema,
-	groupAllowFrom: AllowFromListSchema,
-	dm: buildNestedDmConfigSchema({
-		sessionScope: z.enum(["per-user", "per-room"]).optional(),
-		threadReplies: z.enum([
-			"off",
-			"inbound",
-			"always"
-		]).optional()
-	}),
-	execApprovals: matrixExecApprovalsSchema,
-	groups: z.object({}).catchall(matrixRoomSchema).optional(),
-	rooms: z.object({}).catchall(matrixRoomSchema).optional(),
-	actions: matrixActionSchema
-}), { uiHints: matrixChannelConfigUiHints });
-//#endregion
-export { normalizeMatrixUserId as a, normalizeMatrixAllowList as i, DEFAULT_ACCOUNT_ID$1 as n, resolveMatrixAllowListMatch as o, matrixConfigAdapter as r, MatrixChannelConfigSchema as t };

package/dist/create-client-f-CkRllE.js

@@ -1,61 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
-import { d as writeStorageMeta, l as resolveMatrixStoragePaths, r as maybeMigrateLegacyStorage } from "./storage-BvAkgzvT.js";
-import "./shared-CUH5otj8.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "openclaw/plugin-sdk/ssrf-runtime";
-import fs from "node:fs";
-//#region extensions/matrix/src/matrix/client/create-client.ts
-var create_client_exports = /* @__PURE__ */ __exportAll({ createMatrixClient: () => createMatrixClient });
-const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-UzPd8tst.js"), import("./logging-DV-p52N0.js").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
-	MatrixClient: sdkModule.MatrixClient,
-	ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
-})));
-async function createMatrixClient(params) {
-	const { MatrixClient, ensureMatrixSdkLoggingConfigured } = await loadMatrixCreateClientRuntimeDeps();
-	ensureMatrixSdkLoggingConfigured();
-	const homeserver = await resolveValidatedMatrixHomeserverUrl(params.homeserver, { dangerouslyAllowPrivateNetwork: params.allowPrivateNetwork });
-	const matrixClientUserId = normalizeOptionalString(params.userId);
-	const userId = matrixClientUserId ?? "unknown";
-	const storagePaths = params.persistStorage !== false ? resolveMatrixStoragePaths({
-		homeserver,
-		userId,
-		accessToken: params.accessToken,
-		accountId: params.accountId,
-		deviceId: params.deviceId,
-		env: process.env
-	}) : null;
-	if (storagePaths) {
-		await maybeMigrateLegacyStorage({
-			storagePaths,
-			env: process.env
-		});
-		fs.mkdirSync(storagePaths.rootDir, { recursive: true });
-		writeStorageMeta({
-			storagePaths,
-			homeserver,
-			userId,
-			accountId: params.accountId,
-			deviceId: params.deviceId
-		});
-	}
-	const cryptoDatabasePrefix = storagePaths ? `openclaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}` : void 0;
-	return new MatrixClient(homeserver, params.accessToken, {
-		userId: matrixClientUserId,
-		password: params.password,
-		deviceId: params.deviceId,
-		encryption: params.encryption,
-		localTimeoutMs: params.localTimeoutMs,
-		initialSyncLimit: params.initialSyncLimit,
-		storageRootDir: storagePaths?.rootDir,
-		recoveryKeyPath: storagePaths?.recoveryKeyPath,
-		idbSnapshotPath: storagePaths?.idbSnapshotPath,
-		cryptoDatabasePrefix,
-		autoBootstrapCrypto: params.autoBootstrapCrypto,
-		ssrfPolicy: params.ssrfPolicy ?? ssrfPolicyFromDangerouslyAllowPrivateNetwork(params.allowPrivateNetwork),
-		dispatcherPolicy: params.dispatcherPolicy
-	});
-}
-//#endregion
-export { create_client_exports as n, createMatrixClient as t };

package/dist/credentials-W2EmwRhu.js

@@ -1,65 +0,0 @@
-import { a as resolveMatrixCredentialsPath, r as resolveMatrixCredentialsDir } from "./storage-paths-gUmSydsW.js";
-import { a as isMatrixCredentialRevocation, c as normalizeMatrixStoredCredentials, l as openMatrixCredentialsStore, n as clearMatrixCredentials, o as loadMatrixCredentials, r as credentialsMatchConfig, s as matrixCredentialsStoreKey } from "./credentials-read-DVmFCm7X.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-//#region extensions/matrix/src/matrix/credentials.ts
-function requireCredentialStoreUpdate(store) {
-	if (!store.update) throw new Error("Matrix credentials require atomic plugin-state updates");
-	return store.update;
-}
-async function saveMatrixCredentials(credentials, env = process.env, accountId) {
-	const normalizedAccountId = normalizeAccountId(accountId);
-	const store = openMatrixCredentialsStore(env);
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	requireCredentialStoreUpdate(store)(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
-		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
-		return {
-			accountId: normalizedAccountId,
-			homeserver: credentials.homeserver,
-			userId: credentials.userId,
-			accessToken: credentials.accessToken,
-			...typeof credentials.deviceId === "string" ? { deviceId: credentials.deviceId } : {},
-			createdAt: existing?.createdAt ?? now,
-			lastUsedAt: now
-		};
-	});
-}
-async function saveBackfilledMatrixDeviceId(credentials, env = process.env, accountId) {
-	const normalizedAccountId = normalizeAccountId(accountId);
-	const store = openMatrixCredentialsStore(env);
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	let result = "saved";
-	requireCredentialStoreUpdate(store)(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
-		if (isMatrixCredentialRevocation(current, normalizedAccountId)) {
-			result = "skipped";
-			return current;
-		}
-		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
-		if (existing && (existing.homeserver !== credentials.homeserver || existing.userId !== credentials.userId || existing.accessToken !== credentials.accessToken)) {
-			result = "skipped";
-			return existing;
-		}
-		return {
-			accountId: normalizedAccountId,
-			homeserver: credentials.homeserver,
-			userId: credentials.userId,
-			accessToken: credentials.accessToken,
-			...typeof credentials.deviceId === "string" ? { deviceId: credentials.deviceId } : {},
-			createdAt: existing?.createdAt ?? now,
-			lastUsedAt: now
-		};
-	});
-	return result;
-}
-async function touchMatrixCredentials(env = process.env, accountId) {
-	const normalizedAccountId = normalizeAccountId(accountId);
-	requireCredentialStoreUpdate(openMatrixCredentialsStore(env))(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
-		if (isMatrixCredentialRevocation(current, normalizedAccountId)) return current;
-		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
-		return existing ? {
-			...existing,
-			lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
-		} : void 0;
-	});
-}
-//#endregion
-export { clearMatrixCredentials, credentialsMatchConfig, loadMatrixCredentials, resolveMatrixCredentialsDir, resolveMatrixCredentialsPath, saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };