@openclaw/matrix 2026.9.4 → 2026.9.5

package/dist/{client-CPcRv6ab.js → .setup/client-DsJUnWlV.mjs}

@@ -1,33 +1,31 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { l as resolveScopedMatrixEnvConfig, o as resolveMatrixDefaultOrOnlyAccountId, r as requiresExplicitMatrixDefaultAccount, s as resolveGlobalMatrixEnvConfig, u as resolveMatrixAccountStringValues } from "./account-selection-Bbtc483D.js";
-import { t as getMatrixScopedEnvVarNames } from "./env-vars-dGqak9dN.js";
-import { o as resolveMatrixBaseConfig, r as listNormalizedMatrixAccountIds, t as findMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
-import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
-import { i as repairCurrentTokenStorageMetaDeviceId, n as maybeMigrateLegacyStorage, o as resolveMatrixStoragePaths, s as writeStorageMeta } from "./storage-CV-pfV_2.js";
-import { n as LogService } from "./logger-B_71hN6W.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { n as getMatrixRuntimeLifecycle } from "./runtime-1kn1P6io.mjs";
+import { l as resolveScopedMatrixEnvConfig, o as resolveMatrixDefaultOrOnlyAccountId, r as requiresExplicitMatrixDefaultAccount, s as resolveGlobalMatrixEnvConfig, u as resolveMatrixAccountStringValues } from "./account-selection-5koohRSQ.mjs";
+import { t as getMatrixScopedEnvVarNames } from "./env-vars-dGqak9dN.mjs";
+import { o as resolveMatrixBaseConfig, r as listNormalizedMatrixAccountIds, t as findMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
+import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.mjs";
+import { i as repairCurrentTokenStorageMetaDeviceId } from "./storage-DJ-oUgmX.mjs";
+import { createLazyRuntimeMethod, createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 import { coerceSecretRef, isBuiltInDefaultSecretProviderRef, normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { formatErrorMessage, toErrorObject, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 import { isPrivateNetworkOptInEnabled, ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "openclaw/plugin-sdk/ssrf-runtime";
-import fs from "node:fs";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { AsyncLocalStorage } from "node:async_hooks";
 //#region extensions/matrix/src/matrix/client/config.ts
-const loadMatrixAuthClientDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-B4By16Bt.js").then((n) => n.t), import("./logging-DRjvUOIh.js").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
+const loadMatrixAuthClientDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-BkKE4ANj.mjs").then((n) => n.t), import("./logging-rgm8ep9H.mjs").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
 	MatrixClient: sdkModule.MatrixClient,
 	ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
 })));
 const MATRIX_AUTH_REQUEST_RETRY_RE = /\b(fetch failed|econnreset|econnrefused|enotfound|etimedout|ehostunreach|enetunreach|eai_again|und_err_|socket hang up|network|headers timeout|body timeout|connect timeout)\b/i;
-const loadMatrixCredentialsReadDeps = createLazyRuntimeModule(() => import("./credentials-read-WWpqi88V.js").then((n) => n.r));
-const loadMatrixCredentialsWriteRuntime = createLazyRuntimeModule(() => import("./credentials-write.runtime-D22lPwRO.js"));
-const loadMatrixSecretInputDeps = createLazyRuntimeModule(() => import("./config-secret-input.runtime-CwsP3--c.js"));
+const loadMatrixCredentialsReadDeps = createLazyRuntimeModule(() => import("./credentials-read-Dp7BoEdm.mjs").then((n) => n.r));
+const loadMatrixCredentialsWriteRuntime = createLazyRuntimeModule(() => import("./credentials-write.runtime-M_bUf3rL.mjs"));
+const loadMatrixSecretInputDeps = createLazyRuntimeModule(() => import("./config-secret-input.runtime-CwsP3--c.mjs"));
 function shouldRetryMatrixAuthRequest(err) {
 	return MATRIX_AUTH_REQUEST_RETRY_RE.test(formatErrorMessage(err));
 }
@@ -271,8 +269,8 @@ async function resolveMatrixAuth(params) {
 	}) ?? resolved.accessToken;
 	const tokenAuthPassword = resolved.password;
 	const homeserver = await resolveValidatedMatrixHomeserverUrl(resolved.homeserver, { dangerouslyAllowPrivateNetwork: resolved.allowPrivateNetwork });
-	const { loadMatrixCredentials, credentialsMatchConfig } = await loadMatrixCredentialsReadDeps();
-	const cached = loadMatrixCredentials(env, accountId);
+	const { loadMatrixCredentialsAsync, credentialsMatchConfig } = await loadMatrixCredentialsReadDeps();
+	const cached = await loadMatrixCredentialsAsync(env, accountId);
 	const cachedCredentials = cached && credentialsMatchConfig(cached, {
 		homeserver,
 		userId: resolved.userId || "",
@@ -392,11 +390,12 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 	if (!deviceId) return;
 	if (isAbortSignalTriggered(params.abortSignal)) return;
 	const env = params.env ?? process.env;
-	const { loadMatrixCredentials } = await loadMatrixCredentialsReadDeps();
+	const { loadMatrixCredentialsAsync } = await loadMatrixCredentialsReadDeps();
 	if (!credentialsMatchBackfillAuthLineage({
-		stored: loadMatrixCredentials(env, params.auth.accountId),
+		stored: await loadMatrixCredentialsAsync(env, params.auth.accountId),
 		auth: params.auth
 	})) return;
+	if (isAbortSignalTriggered(params.abortSignal)) return;
 	if (!repairCurrentTokenStorageMetaDeviceId({
 		homeserver: params.auth.homeserver,
 		userId: params.auth.userId,
@@ -414,58 +413,6 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 	}, env, params.auth.accountId) === "saved" ? deviceId : void 0;
 }
 //#endregion
-//#region extensions/matrix/src/matrix/client/create-client.ts
-var create_client_exports = /* @__PURE__ */ __exportAll({ createMatrixClient: () => createMatrixClient });
-const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-B4By16Bt.js").then((n) => n.t), import("./logging-DRjvUOIh.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
 //#region extensions/matrix/src/matrix/monitor/task-runner.ts
 const monitorTaskSignal = new AsyncLocalStorage();
 function getMatrixMonitorTaskSignal() {
@@ -536,7 +483,7 @@ async function awaitMatrixStartupWithAbort(promise, abortSignal) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/client/shared.ts
-const loadMatrixCreateClientDeps = createLazyRuntimeModule(() => Promise.resolve().then(() => create_client_exports).then((runtime) => ({ createMatrixClient: runtime.createMatrixClient })));
+const loadMatrixCreateClientDeps = createLazyRuntimeModule(() => import("./create-client-DQXAZjTw.mjs").then((runtime) => ({ createMatrixClient: runtime.createMatrixClient })));
 const MATRIX_RETIREMENT_DRAIN_TIMEOUT_MS = 5e3;
 const sharedClientStates = /* @__PURE__ */ new Map();
 const sharedClientPromises = /* @__PURE__ */ new Map();
@@ -572,7 +519,6 @@ async function createSharedMatrixClient(params) {
 		client,
 		key: buildSharedClientKey(params.auth),
 		started: false,
-		cryptoReady: false,
 		startPromise: null,
 		phase: "open",
 		leases: /* @__PURE__ */ new Set(),
@@ -580,12 +526,35 @@ async function createSharedMatrixClient(params) {
 		noLeases: createDeferred(),
 		retirementPromise: null,
 		poisonError: null,
-		releaseMode: "discard"
+		releaseMode: "discard",
+		ownerSignal: params.lifecycle?.signal
 	};
 }
 function deleteSharedClientState(state) {
 	if (sharedClientStates.get(state.key) === state) sharedClientStates.delete(state.key);
-	sharedClientPromises.delete(state.key);
+	const detachLifecycle = state.detachLifecycle;
+	state.detachLifecycle = void 0;
+	detachLifecycle?.();
+}
+function bindSharedClientLifecycle(state, lifecycle) {
+	if (!lifecycle) return;
+	const retire = () => forceRetireState(state);
+	const onAbort = () => {
+		retire().catch(() => void 0);
+	};
+	lifecycle.signal.addEventListener("abort", onAbort, { once: true });
+	let removeDisposer;
+	try {
+		removeDisposer = lifecycle.onDispose(retire);
+	} catch (error) {
+		lifecycle.signal.removeEventListener("abort", onAbort);
+		throw error;
+	}
+	state.detachLifecycle = () => {
+		lifecycle.signal.removeEventListener("abort", onAbort);
+		removeDisposer();
+	};
+	if (lifecycle.signal.aborted) onAbort();
 }
 async function ensureSharedClientStarted(state, abortSignal) {
 	if (state.started) return;
@@ -594,15 +563,6 @@ async function ensureSharedClientStarted(state, abortSignal) {
 		return;
 	}
 	const guardedStart = (async () => {
-		if (state.auth.encryption && !state.cryptoReady) try {
-			const joinedRooms = await state.client.getJoinedRooms();
-			if (state.client.crypto) {
-				await state.client.crypto.prepare(joinedRooms);
-				state.cryptoReady = true;
-			}
-		} catch (err) {
-			LogService.warn("MatrixClientLite", "Failed to prepare crypto:", err);
-		}
 		await state.client.start({ abortSignal });
 		throwIfMatrixStartupAborted(abortSignal);
 		state.started = true;
@@ -628,18 +588,22 @@ async function resolveSharedMatrixAuth(params) {
 		accountId: authContext.accountId
 	});
 }
-async function resolveOpenSharedMatrixClientState(params) {
+async function resolveOpenSharedMatrixClientState(params, lifecycle) {
 	const auth = await resolveSharedMatrixAuth(params);
 	throwIfMatrixStartupAborted(params.abortSignal);
 	const key = buildSharedClientKey(auth);
 	while (true) {
 		const existing = sharedClientStates.get(key);
 		if (existing?.poisonError) throw existing.poisonError;
-		if (existing?.phase === "open") return existing;
+		if (existing?.phase === "open" && existing.ownerSignal === lifecycle?.signal) return existing;
 		if (existing?.retirementPromise) {
 			await awaitMatrixStartupWithAbort(existing.retirementPromise, params.abortSignal);
 			continue;
 		}
+		if (existing) {
+			await awaitMatrixStartupWithAbort(existing.noLeases.promise, params.abortSignal);
+			continue;
+		}
 		const pending = sharedClientPromises.get(key);
 		if (pending) {
 			await awaitMatrixStartupWithAbort(pending, params.abortSignal);
@@ -647,15 +611,22 @@ async function resolveOpenSharedMatrixClientState(params) {
 		}
 		const creationPromise = createSharedMatrixClient({
 			auth,
-			timeoutMs: params.timeoutMs
+			timeoutMs: params.timeoutMs,
+			lifecycle
 		});
 		sharedClientPromises.set(key, creationPromise);
 		try {
 			const created = await creationPromise;
 			sharedClientStates.set(key, created);
+			try {
+				bindSharedClientLifecycle(created, lifecycle);
+			} catch (error) {
+				await forceRetireState(created);
+				throw error;
+			}
 			return created;
 		} finally {
-			sharedClientPromises.delete(key);
+			if (sharedClientPromises.get(key) === creationPromise) sharedClientPromises.delete(key);
 		}
 	}
 }
@@ -685,6 +656,14 @@ function mergeReleaseMode(current, requested) {
 function abortTransientLeases(state) {
 	for (const lease of state.leases) if (lease.role === "transient") lease.abortController.abort();
 }
+function forceReleaseLeases(state, releasePromise) {
+	for (const lease of state.leases) {
+		lease.releasePromise ??= lease.role === "monitor" ? releasePromise : Promise.resolve();
+		lease.abortController.abort();
+	}
+	state.leases.clear();
+	state.noLeases.resolve();
+}
 async function waitForRetirementDrain(state, task, isPending, timeoutMessage) {
 	if (!isPending()) return;
 	let deadline;
@@ -705,6 +684,7 @@ function beginGenerationRetirement(params) {
 	const { state } = params;
 	if (state.retirementPromise) return state.retirementPromise;
 	state.phase = "quiescing";
+	if (state.leases.size === 0) state.noLeases.resolve();
 	const result = createDeferred();
 	state.retirementPromise = result.promise;
 	Promise.resolve().then(async () => {
@@ -827,15 +807,20 @@ function createSharedMatrixClientLease(state, role) {
 	};
 }
 async function acquireSharedMatrixClient(params = {}) {
-	const taskSignal = getMatrixMonitorTaskSignal();
-	const abortSignal = taskSignal && params.abortSignal ? AbortSignal.any([taskSignal, params.abortSignal]) : taskSignal ?? params.abortSignal;
+	const lifecycle = getMatrixRuntimeLifecycle();
+	const signals = [
+		getMatrixMonitorTaskSignal(),
+		params.abortSignal,
+		lifecycle?.signal
+	].filter((signal) => signal !== void 0);
+	const abortSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
 	const acquisition = {
 		...params,
 		abortSignal
 	};
 	while (true) {
 		throwIfMatrixStartupAborted(abortSignal);
-		const state = await resolveOpenSharedMatrixClientState(acquisition);
+		const state = await resolveOpenSharedMatrixClientState(acquisition, lifecycle);
 		if (abortSignal?.aborted) {
 			if (state.phase === "open" && state.leases.size === 0) await beginGenerationRetirement({ state });
 			throwIfMatrixStartupAborted(abortSignal);
@@ -851,11 +836,28 @@ async function acquireSharedMatrixClient(params = {}) {
 		return lease;
 	}
 }
+async function forceRetireState(state) {
+	if (state.phase === "late-drain") throw state.poisonError ?? /* @__PURE__ */ new Error("Matrix client generation is still retiring");
+	state.releaseMode = mergeReleaseMode(state.releaseMode, "stop");
+	const retirementPromise = beginGenerationRetirement({
+		state,
+		monitorLeases: Array.from(state.leases).filter((lease) => lease.role === "monitor")
+	});
+	forceReleaseLeases(state, retirementPromise);
+	try {
+		await retirementPromise;
+	} catch (error) {
+		if (sharedClientStates.get(state.key) === state) throw state.poisonError ?? error;
+	}
+}
 //#endregion
 //#region extensions/matrix/src/matrix/client.ts
 var client_exports = /* @__PURE__ */ __exportAll({
 	acquireSharedMatrixClient: () => acquireSharedMatrixClient,
+	createMatrixClient: () => createMatrixClient,
 	resolveMatrixAuthContext: () => resolveMatrixAuthContext
 });
+const loadMatrixClientRuntime = createLazyRuntimeModule(() => import("./create-client-DQXAZjTw.mjs"));
+const createMatrixClient = createLazyRuntimeMethod(loadMatrixClientRuntime, (runtime) => runtime.createMatrixClient);
 //#endregion
-export { throwIfMatrixStartupAborted as a, backfillMatrixAuthDeviceIdAfterStartup as c, isMatrixStartupAbortError as i, resolveMatrixAuth as l, acquireSharedMatrixClient as n, createMatrixMonitorTaskRunner as o, createMatrixStartupAbortError as r, createMatrixClient as s, client_exports as t, resolveMatrixAuthContext as u };
+export { createMatrixStartupAbortError as a, createMatrixMonitorTaskRunner as c, resolveMatrixAuthContext as d, awaitMatrixStartupWithAbort as i, backfillMatrixAuthDeviceIdAfterStartup as l, createMatrixClient as n, isMatrixStartupAbortError as o, acquireSharedMatrixClient as r, throwIfMatrixStartupAborted as s, client_exports as t, resolveMatrixAuth as u };

package/dist/{client-bootstrap-DLN-K8Xb.js → .setup/client-bootstrap-DGX0f-4x.mjs}

@@ -1,12 +1,8 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { captureChannelReadAuthority } from "openclaw/plugin-sdk/fetch-runtime";
 //#region extensions/matrix/src/matrix/client-bootstrap.ts
-var client_bootstrap_exports = /* @__PURE__ */ __exportAll({
-	resolveRuntimeMatrixClientWithReadiness: () => resolveRuntimeMatrixClientWithReadiness,
-	withResolvedRuntimeMatrixClient: () => withResolvedRuntimeMatrixClient
-});
-const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-CPcRv6ab.js").then((n) => n.t).then((clientModule) => ({
+const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-DsJUnWlV.mjs").then((n) => n.t).then((clientModule) => ({
 	acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
 	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext
 })));
@@ -19,17 +15,21 @@ async function ensureResolvedClientReadiness(params) {
 	if (params.readiness === "prepared" || !params.readiness && params.preparedByDefault) await params.client.prepareForOneOff();
 }
 async function resolveRuntimeMatrixClientWithReadiness(opts) {
+	const assertCurrent = captureChannelReadAuthority();
+	assertCurrent?.();
 	if (opts.client) {
 		await ensureResolvedClientReadiness({
 			client: opts.client,
 			readiness: opts.readiness,
 			preparedByDefault: false
 		});
+		assertCurrent?.();
 		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();
+	assertCurrent?.();
 	const authContext = resolveMatrixAuthContext({
 		cfg,
 		accountId: opts.accountId
@@ -42,12 +42,14 @@ async function resolveRuntimeMatrixClientWithReadiness(opts) {
 		role: "transient"
 	});
 	try {
+		assertCurrent?.();
 		await ensureResolvedClientReadiness({
 			client: lease.client,
 			lease,
 			readiness: opts.readiness,
 			preparedByDefault: true
 		});
+		assertCurrent?.();
 	} catch (err) {
 		await lease.release({ mode: "stop" });
 		throw err;
@@ -58,12 +60,19 @@ async function resolveRuntimeMatrixClientWithReadiness(opts) {
 	};
 }
 async function withResolvedRuntimeMatrixClient(opts, run, stopMode = "stop") {
+	const assertCurrent = captureChannelReadAuthority();
+	assertCurrent?.();
 	const resolved = await resolveRuntimeMatrixClientWithReadiness(opts);
 	try {
+		assertCurrent?.();
 		return await run(resolved.client, resolved.lease?.abortSignal);
 	} finally {
-		await resolved.lease?.release({ mode: stopMode });
+		try {
+			await resolved.lease?.release({ mode: stopMode });
+		} finally {
+			assertCurrent?.();
+		}
 	}
 }
 //#endregion
-export { withResolvedRuntimeMatrixClient as n, client_bootstrap_exports as t };
+export { resolveRuntimeMatrixClientWithReadiness, withResolvedRuntimeMatrixClient };

package/dist/{client-support-DLj4vDeu.js → .setup/client-support-Bn9Bk0-H.mjs}

@@ -1,4 +1,4 @@
-import { t as formatMatrixErrorReason } from "./errors-DKVS3_DO.js";
+import { t as formatMatrixErrorReason } from "./errors-DKVS3_DO.mjs";
 //#region extensions/matrix/src/matrix/sync-state.ts
 function isMatrixReadySyncState(state) {
 	return state === "PREPARED" || state === "SYNCING" || state === "CATCHUP";

package/dist/{config-update-BnX26jCO.js → .setup/config-update-B_4qZ5bV.mjs}

@@ -1,6 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as findMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { n as resolveMatrixConfigPath$1, r as shouldStoreMatrixAccountAtTopLevel, t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as findMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { n as resolveMatrixConfigPath$1, r as shouldStoreMatrixAccountAtTopLevel, t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { coerceSecretRef, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";

package/dist/.setup/create-client-DQXAZjTw.mjs

@@ -0,0 +1,61 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.mjs";
+import { n as maybeMigrateLegacyStorage, o as resolveMatrixStoragePaths, s as writeStorageMeta } from "./storage-DJ-oUgmX.mjs";
+import "./client-DsJUnWlV.mjs";
+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
+const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-BkKE4ANj.mjs").then((n) => n.t), import("./logging-rgm8ep9H.mjs").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,
+		stateRuntime: getMatrixRuntime().state
+	});
+}
+//#endregion
+export { createMatrixClient };

package/dist/{credentials-DysXbkv2.js → .setup/credentials-CeRipapZ.mjs}

@@ -1,20 +1,20 @@
-import { i as normalizeMatrixStoredCredentials, n as isMatrixCredentialRevocation, r as matrixCredentialsStoreKey } from "./credentials-state-B3cuUFwZ.js";
-import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.js";
-import { a as openMatrixCredentialsStore, i as loadMatrixCredentials, n as credentialsMatchConfig, t as clearMatrixCredentials } from "./credentials-read-WWpqi88V.js";
+import { i as normalizeMatrixStoredCredentials, n as isMatrixCredentialRevocation, r as matrixCredentialsStoreKey } from "./credentials-state-B3cuUFwZ.mjs";
+import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.mjs";
+import { a as openMatrixCredentialsAsyncStore, i as loadMatrixCredentials, n as credentialsMatchConfig, o as openMatrixCredentialsStore, t as clearMatrixCredentials } from "./credentials-read-Dp7BoEdm.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/credentials.ts
 async function saveMatrixCredentials(credentials, env = process.env, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	const store = openMatrixCredentialsStore(env);
+	const preparedCredentials = { ...credentials };
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	store.update(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
+	await updateMatrixCredentials(env, 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 } : {},
+			homeserver: preparedCredentials.homeserver,
+			userId: preparedCredentials.userId,
+			accessToken: preparedCredentials.accessToken,
+			...typeof preparedCredentials.deviceId === "string" ? { deviceId: preparedCredentials.deviceId } : {},
 			createdAt: existing?.createdAt ?? now,
 			lastUsedAt: now
 		};
@@ -22,25 +22,26 @@ async function saveMatrixCredentials(credentials, env = process.env, accountId)
 }
 async function saveBackfilledMatrixDeviceId(credentials, env = process.env, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	const store = openMatrixCredentialsStore(env);
+	const preparedCredentials = { ...credentials };
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	let result = "saved";
-	store.update(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
+	await updateMatrixCredentials(env, normalizedAccountId, (current) => {
+		result = "saved";
 		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)) {
+		if (existing && (existing.homeserver !== preparedCredentials.homeserver || existing.userId !== preparedCredentials.userId || existing.accessToken !== preparedCredentials.accessToken)) {
 			result = "skipped";
 			return existing;
 		}
 		return {
 			accountId: normalizedAccountId,
-			homeserver: credentials.homeserver,
-			userId: credentials.userId,
-			accessToken: credentials.accessToken,
-			...typeof credentials.deviceId === "string" ? { deviceId: credentials.deviceId } : {},
+			homeserver: preparedCredentials.homeserver,
+			userId: preparedCredentials.userId,
+			accessToken: preparedCredentials.accessToken,
+			...typeof preparedCredentials.deviceId === "string" ? { deviceId: preparedCredentials.deviceId } : {},
 			createdAt: existing?.createdAt ?? now,
 			lastUsedAt: now
 		};
@@ -49,7 +50,7 @@ async function saveBackfilledMatrixDeviceId(credentials, env = process.env, acco
 }
 async function touchMatrixCredentials(env = process.env, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	openMatrixCredentialsStore(env).update(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
+	await updateMatrixCredentials(env, normalizedAccountId, (current) => {
 		if (isMatrixCredentialRevocation(current, normalizedAccountId)) return current;
 		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
 		return existing ? {
@@ -58,5 +59,27 @@ async function touchMatrixCredentials(env = process.env, accountId) {
 		} : void 0;
 	});
 }
+async function updateMatrixCredentials(env, accountId, update) {
+	const store = openMatrixCredentialsAsyncStore(env);
+	const key = matrixCredentialsStoreKey(accountId);
+	if (!store.observe || !store.compareAndApply) {
+		openMatrixCredentialsStore(env).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;
+	}
+}
 //#endregion
 export { clearMatrixCredentials, credentialsMatchConfig, loadMatrixCredentials, resolveMatrixCredentialsDir, resolveMatrixCredentialsPath, saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };

package/dist/{credentials-read-WWpqi88V.js → .setup/credentials-read-Dp7BoEdm.mjs}

@@ -1,7 +1,7 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as getOptionalMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { i as normalizeMatrixStoredCredentials, r as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-state-B3cuUFwZ.js";
-import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { r as getOptionalMatrixRuntime, t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { i as normalizeMatrixStoredCredentials, r as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-state-B3cuUFwZ.mjs";
+import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { createPluginStateSyncKeyedStore } from "openclaw/plugin-sdk/plugin-state-store-runtime";
 //#region extensions/matrix/src/matrix/credentials-read.ts
@@ -9,26 +9,39 @@ var credentials_read_exports = /* @__PURE__ */ __exportAll({
 	clearMatrixCredentials: () => clearMatrixCredentials,
 	credentialsMatchConfig: () => credentialsMatchConfig,
 	loadMatrixCredentials: () => loadMatrixCredentials,
+	loadMatrixCredentialsAsync: () => loadMatrixCredentialsAsync,
+	openMatrixCredentialsAsyncStore: () => openMatrixCredentialsAsyncStore,
 	openMatrixCredentialsStore: () => openMatrixCredentialsStore,
 	resolveMatrixCredentialsDir: () => resolveMatrixCredentialsDir,
 	resolveMatrixCredentialsPath: () => resolveMatrixCredentialsPath
 });
-function openMatrixCredentialsStore(env = process.env) {
+function matrixCredentialsStoreOptions(env) {
 	const runtime = getOptionalMatrixRuntime();
 	const resolvedEnv = env.OPENCLAW_STATE_DIR?.trim() || !runtime ? env : {
 		...env,
 		OPENCLAW_STATE_DIR: runtime.state.resolveStateDir(env)
 	};
-	return createPluginStateSyncKeyedStore("matrix", {
+	return {
 		namespace: MATRIX_CREDENTIALS_NAMESPACE,
 		maxEntries: 256,
 		overflowPolicy: "reject-new",
 		env: resolvedEnv
-	});
+	};
+}
+function openMatrixCredentialsStore(env = process.env) {
+	return createPluginStateSyncKeyedStore("matrix", matrixCredentialsStoreOptions(env));
+}
+function openMatrixCredentialsAsyncStore(env = process.env) {
+	return getMatrixRuntime().state.openKeyedStore(matrixCredentialsStoreOptions(env));
+}
+async function loadMatrixCredentialsAsync(env = process.env, accountId) {
+	return decodeMatrixCredentials(await openMatrixCredentialsAsyncStore(env).lookup(matrixCredentialsStoreKey(accountId)), accountId);
 }
 function loadMatrixCredentials(env = process.env, accountId) {
+	return decodeMatrixCredentials(openMatrixCredentialsStore(env).lookup(matrixCredentialsStoreKey(accountId)), accountId);
+}
+function decodeMatrixCredentials(stored, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	const stored = openMatrixCredentialsStore(env).lookup(matrixCredentialsStoreKey(accountId));
 	const parsed = normalizeMatrixStoredCredentials(stored, normalizedAccountId);
 	if (!parsed || parsed.accountId !== normalizedAccountId) return null;
 	const { accountId: _accountId, ...credentials } = parsed;
@@ -50,4 +63,4 @@ function credentialsMatchConfig(stored, config) {
 	return stored.homeserver === config.homeserver && stored.userId === config.userId;
 }
 //#endregion
-export { openMatrixCredentialsStore as a, loadMatrixCredentials as i, credentialsMatchConfig as n, credentials_read_exports as r, clearMatrixCredentials as t };
+export { openMatrixCredentialsAsyncStore as a, loadMatrixCredentials as i, credentialsMatchConfig as n, openMatrixCredentialsStore as o, credentials_read_exports as r, clearMatrixCredentials as t };

package/dist/{credentials-write.runtime-D22lPwRO.js → .setup/credentials-write.runtime-M_bUf3rL.mjs}

@@ -1,6 +1,6 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/matrix/src/matrix/credentials-write.runtime.ts
-const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-DysXbkv2.js"));
+const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-CeRipapZ.mjs"));
 async function saveMatrixCredentials(...args) {
 	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
 }