@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/client-bootstrap-Be8jvNle.mjs

@@ -0,0 +1,74 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as isBunRuntime } from "./runtime-BefyhPWv.mjs";
+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(() => import("./client-DFBQtzCe.mjs").then((n) => n.t).then((clientModule) => ({
+	acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
+	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext
+})));
+async function ensureResolvedClientReadiness(params) {
+	if (params.readiness === "started") {
+		if (params.lease) await params.lease.start();
+		else 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 resolveRuntimeMatrixClientWithReadiness(opts) {
+	ensureMatrixNodeRuntime();
+	if (opts.client) {
+		await ensureResolvedClientReadiness({
+			client: opts.client,
+			readiness: opts.readiness,
+			preparedByDefault: false
+		});
+		return { client: opts.client };
+	}
+	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, resolveMatrixAuthContext } = await loadMatrixSharedClientRuntimeDeps();
+	const authContext = resolveMatrixAuthContext({
+		cfg,
+		accountId: opts.accountId
+	});
+	const lease = await acquireSharedMatrixClient({
+		cfg,
+		timeoutMs: opts.timeoutMs,
+		accountId: authContext.accountId,
+		startClient: false,
+		role: "transient"
+	});
+	try {
+		await ensureResolvedClientReadiness({
+			client: lease.client,
+			lease,
+			readiness: opts.readiness,
+			preparedByDefault: true
+		});
+	} catch (err) {
+		await lease.release({ mode: "stop" });
+		throw err;
+	}
+	return {
+		client: lease.client,
+		lease
+	};
+}
+async function withResolvedRuntimeMatrixClient(opts, run, stopMode = "stop") {
+	const resolved = await resolveRuntimeMatrixClientWithReadiness(opts);
+	try {
+		return await run(resolved.client, resolved.lease?.abortSignal);
+	} finally {
+		await resolved.lease?.release({ mode: stopMode });
+	}
+}
+//#endregion
+export { withResolvedRuntimeMatrixClient as n, client_bootstrap_exports as t };

package/dist/.setup/config-schema-D9J_vUF6.mjs

@@ -0,0 +1,321 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-BZWN9tGS.mjs";
+import { g as resolveMatrixAccount, h as resolveDefaultMatrixAccountId, p as listMatrixAccountIds } from "./setup-core-bhdcEo7v.mjs";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+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 { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
+import { AllowFromListSchema, ContextVisibilityModeSchema, GroupPolicySchema, MarkdownConfigSchema, MentionPatternsPolicySchema, ToolPolicySchema, 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);
+	return value;
+}
+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);
+	const candidates = [
+		{
+			value: userId,
+			source: "id"
+		},
+		{
+			value: userId ? `matrix:${userId}` : "",
+			source: "prefixed-id"
+		},
+		{
+			value: userId ? `user:${userId}` : "",
+			source: "prefixed-user"
+		}
+	];
+	return resolveAllowlistMatchByCandidates({
+		allowList,
+		candidates
+	});
+}
+//#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 = {
+	mentionPatterns: {
+		label: "Matrix Mention Pattern Policy",
+		help: "Scopes configured groupChat mentionPatterns to selected Matrix room IDs. Native Matrix mention evidence still triggers even when regex patterns are denied."
+	},
+	"mentionPatterns.mode": {
+		label: "Matrix Mention Pattern Mode",
+		help: "\"allow\" enables configured regex mention patterns unless denyIn matches; \"deny\" disables them unless allowIn matches."
+	},
+	"mentionPatterns.allowIn": {
+		label: "Matrix Mention Pattern Allowlist",
+		help: "Matrix room IDs where configured regex mention patterns are enabled when mode is deny."
+	},
+	"mentionPatterns.denyIn": {
+		label: "Matrix Mention Pattern Denylist",
+		help: "Matrix room IDs where configured regex mention patterns are disabled. 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."
+	},
+	"streaming.progress.label": {
+		label: "Matrix Progress Label",
+		help: "Initial progress draft title. Use \"auto\" for built-in single-word labels, a custom string, or false to hide the title."
+	},
+	"streaming.progress.labels": {
+		label: "Matrix Progress Label Pool",
+		help: "Candidate labels for streaming.progress.label=\"auto\". Leave unset to use OpenClaw built-in progress labels."
+	},
+	"streaming.progress.maxLines": {
+		label: "Matrix Progress Max Lines",
+		help: "Maximum number of compact progress lines to keep below the draft label (default: 8)."
+	},
+	"streaming.progress.maxLineChars": {
+		label: "Matrix Progress Max Line Chars",
+		help: "Maximum characters per compact progress line before truncation (default: 120). Prose cuts at word boundaries; commands and paths keep useful suffixes."
+	},
+	"streaming.progress.toolProgress": {
+		label: "Matrix Progress Tool Lines",
+		help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery."
+	},
+	"streaming.progress.commandText": {
+		label: "Matrix Progress Command Text",
+		help: "Command/exec detail in progress draft lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
+	}
+};
+//#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(),
+	spawnSubagentSessions: z.boolean().optional(),
+	spawnAcpSessions: z.boolean().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 = z.object({
+	account: z.string().optional(),
+	enabled: z.boolean().optional(),
+	requireMention: z.boolean().optional(),
+	allowBots: z.union([z.boolean(), z.literal("mentions")]).optional(),
+	botLoopProtection: botLoopProtectionSchema,
+	tools: ToolPolicySchema,
+	autoReply: z.boolean().optional(),
+	users: AllowFromListSchema,
+	skills: z.array(z.string()).optional(),
+	systemPrompt: z.string().optional()
+}).optional();
+const matrixNetworkSchema = z.object({ dangerouslyAllowPrivateNetwork: z.boolean().optional() }).strict().optional();
+const matrixStreamingSchema = z.object({
+	mode: z.enum([
+		"partial",
+		"quiet",
+		"progress",
+		"off"
+	]).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()
+	}).strict().optional(),
+	preview: z.object({ toolProgress: z.boolean().optional() }).strict().optional()
+}).strict();
+const MatrixConfigSchema = z.object({
+	name: z.string().optional(),
+	enabled: z.boolean().optional(),
+	defaultAccount: z.string().optional(),
+	accounts: z.record(z.string(), z.unknown()).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(),
+	blockStreaming: z.boolean().optional(),
+	streaming: z.union([
+		z.enum([
+			"partial",
+			"quiet",
+			"progress",
+			"off"
+		]),
+		z.boolean(),
+		matrixStreamingSchema
+	]).optional(),
+	replyToMode: z.enum([
+		"off",
+		"first",
+		"all",
+		"batched"
+	]).optional(),
+	threadReplies: z.enum([
+		"off",
+		"inbound",
+		"always"
+	]).optional(),
+	textChunkLimit: z.number().optional(),
+	chunkMode: z.enum(["length", "newline"]).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
+});
+const MatrixChannelConfigSchema = buildChannelConfigSchema(MatrixConfigSchema, { 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/.setup/credentials-BhZlA0kL.mjs

@@ -0,0 +1,56 @@
+import { a as resolveMatrixCredentialsDir, i as loadMatrixCredentials, n as credentialsMatchConfig, o as resolveMatrixCredentialsPath, t as clearMatrixCredentials } from "./credentials-read-CRHg6XPm.mjs";
+import { t as createAsyncLock } from "./async-lock-BcLS4KOc.mjs";
+import { writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
+//#region extensions/matrix/src/matrix/credentials.ts
+const credentialWriteLocks = /* @__PURE__ */ new Map();
+function withCredentialWriteLock(credPath, fn) {
+	let withLock = credentialWriteLocks.get(credPath);
+	if (!withLock) {
+		withLock = createAsyncLock();
+		credentialWriteLocks.set(credPath, withLock);
+	}
+	return withLock(fn);
+}
+async function writeMatrixCredentialsUnlocked(params) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const toSave = {
+		...params.credentials,
+		createdAt: params.existing?.createdAt ?? now,
+		lastUsedAt: now
+	};
+	await writeJsonFileAtomically(params.credPath, toSave);
+}
+async function saveMatrixCredentials(credentials, env = process.env, accountId) {
+	const credPath = resolveMatrixCredentialsPath(env, accountId);
+	await withCredentialWriteLock(credPath, async () => {
+		await writeMatrixCredentialsUnlocked({
+			credPath,
+			credentials,
+			existing: loadMatrixCredentials(env, accountId)
+		});
+	});
+}
+async function saveBackfilledMatrixDeviceId(credentials, env = process.env, accountId) {
+	const credPath = resolveMatrixCredentialsPath(env, accountId);
+	return await withCredentialWriteLock(credPath, async () => {
+		const existing = loadMatrixCredentials(env, accountId);
+		if (existing && (existing.homeserver !== credentials.homeserver || existing.userId !== credentials.userId || existing.accessToken !== credentials.accessToken)) return "skipped";
+		await writeMatrixCredentialsUnlocked({
+			credPath,
+			credentials,
+			existing
+		});
+		return "saved";
+	});
+}
+async function touchMatrixCredentials(env = process.env, accountId) {
+	const credPath = resolveMatrixCredentialsPath(env, accountId);
+	await withCredentialWriteLock(credPath, async () => {
+		const existing = loadMatrixCredentials(env, accountId);
+		if (!existing) return;
+		existing.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeJsonFileAtomically(credPath, existing);
+	});
+}
+//#endregion
+export { clearMatrixCredentials, credentialsMatchConfig, loadMatrixCredentials, resolveMatrixCredentialsDir, resolveMatrixCredentialsPath, saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };

package/dist/.setup/credentials-read-CRHg6XPm.mjs

@@ -0,0 +1,114 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-BOQeTqax.mjs";
+import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.mjs";
+import { a as resolveMatrixCredentialsPath$1, r as resolveMatrixCredentialsDir$1 } from "./storage-paths-BWo_ZEMC.mjs";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+//#region extensions/matrix/src/matrix/credentials-read.ts
+var credentials_read_exports = /* @__PURE__ */ __exportAll({
+	clearMatrixCredentials: () => clearMatrixCredentials,
+	credentialsMatchConfig: () => credentialsMatchConfig,
+	loadMatrixCredentials: () => loadMatrixCredentials,
+	resolveMatrixCredentialsDir: () => resolveMatrixCredentialsDir,
+	resolveMatrixCredentialsPath: () => resolveMatrixCredentialsPath
+});
+function resolveStateDir(env) {
+	try {
+		return getMatrixRuntime().state.resolveStateDir(env, os.homedir);
+	} catch {
+		const override = env.OPENCLAW_STATE_DIR?.trim();
+		if (override) return path.resolve(override);
+		const homeDir = env.OPENCLAW_HOME?.trim() || env.HOME?.trim() || os.homedir();
+		return path.join(homeDir, ".openclaw");
+	}
+}
+function resolveLegacyMatrixCredentialsPath(env) {
+	return path.join(resolveMatrixCredentialsDir(env), "credentials.json");
+}
+function shouldReadLegacyCredentialsForAccount(accountId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const cfg = getMatrixRuntime().config.current();
+	if (!cfg.channels?.matrix || typeof cfg.channels.matrix !== "object") return normalizedAccountId === DEFAULT_ACCOUNT_ID;
+	if (requiresExplicitMatrixDefaultAccount(cfg)) return false;
+	return normalizeAccountId(resolveMatrixDefaultOrOnlyAccountId(cfg)) === normalizedAccountId;
+}
+function resolveLegacyMigrationSourcePath(env, accountId) {
+	if (!shouldReadLegacyCredentialsForAccount(accountId)) return null;
+	const legacyPath = resolveLegacyMatrixCredentialsPath(env);
+	return legacyPath === resolveMatrixCredentialsPath(env, accountId) ? null : legacyPath;
+}
+function parseMatrixCredentialsFile(filePath) {
+	const raw = fs.readFileSync(filePath, "utf-8");
+	const parsed = JSON.parse(raw);
+	if (typeof parsed.homeserver !== "string" || typeof parsed.userId !== "string" || typeof parsed.accessToken !== "string") return null;
+	return parsed;
+}
+function loadMatrixCredentialsFile(filePath, source) {
+	try {
+		return {
+			kind: "loaded",
+			source,
+			credentials: parseMatrixCredentialsFile(filePath)
+		};
+	} catch (error) {
+		if (error?.code === "ENOENT") return { kind: "missing" };
+		throw error;
+	}
+}
+function loadLegacyMatrixCredentialsWithCurrentFallback(params) {
+	const legacy = loadMatrixCredentialsFile(params.legacyPath, "legacy");
+	if (legacy.kind === "loaded") return legacy;
+	return loadMatrixCredentialsFile(params.currentPath, "current");
+}
+function resolveMatrixCredentialsDir(env = process.env, stateDir) {
+	const resolvedStateDir = stateDir ?? resolveStateDir(env);
+	return resolveMatrixCredentialsDir$1(resolvedStateDir);
+}
+function resolveMatrixCredentialsPath(env = process.env, accountId) {
+	const resolvedStateDir = resolveStateDir(env);
+	return resolveMatrixCredentialsPath$1({
+		stateDir: resolvedStateDir,
+		accountId
+	});
+}
+function loadMatrixCredentials(env = process.env, accountId) {
+	const currentPath = resolveMatrixCredentialsPath(env, accountId);
+	try {
+		const current = loadMatrixCredentialsFile(currentPath, "current");
+		if (current.kind === "loaded") return current.credentials;
+		const legacyPath = resolveLegacyMigrationSourcePath(env, accountId);
+		if (!legacyPath) return null;
+		const loaded = loadLegacyMatrixCredentialsWithCurrentFallback({
+			legacyPath,
+			currentPath
+		});
+		if (loaded.kind !== "loaded" || !loaded.credentials) return null;
+		if (loaded.source === "legacy") try {
+			fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+			fs.renameSync(legacyPath, currentPath);
+		} catch {}
+		return loaded.credentials;
+	} catch {
+		return null;
+	}
+}
+function clearMatrixCredentials(env = process.env, accountId) {
+	const paths = [resolveMatrixCredentialsPath(env, accountId), resolveLegacyMigrationSourcePath(env, accountId)];
+	for (const filePath of paths) {
+		if (!filePath) continue;
+		try {
+			fs.unlinkSync(filePath);
+		} catch {}
+	}
+}
+function credentialsMatchConfig(stored, config) {
+	if (!config.userId) {
+		if (!config.accessToken) return false;
+		return stored.homeserver === config.homeserver && stored.accessToken === config.accessToken;
+	}
+	return stored.homeserver === config.homeserver && stored.userId === config.userId;
+}
+//#endregion
+export { resolveMatrixCredentialsDir as a, loadMatrixCredentials as i, credentialsMatchConfig as n, resolveMatrixCredentialsPath as o, credentials_read_exports as r, clearMatrixCredentials as t };

package/dist/.setup/credentials-write.runtime-dWuLafsk.mjs

@@ -0,0 +1,14 @@
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+//#region extensions/matrix/src/matrix/credentials-write.runtime.ts
+const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-BhZlA0kL.mjs"));
+async function saveMatrixCredentials(...args) {
+	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
+}
+async function saveBackfilledMatrixDeviceId(...args) {
+	return (await loadMatrixCredentialsRuntime()).saveBackfilledMatrixDeviceId(...args);
+}
+async function touchMatrixCredentials(...args) {
+	return (await loadMatrixCredentialsRuntime()).touchMatrixCredentials(...args);
+}
+//#endregion
+export { saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };