@openclaw/matrix 2026.9.5 → 2026.9.6

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

@@ -1,12 +1,13 @@
 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 { c as resolveGlobalMatrixEnvConfig, d as resolveMatrixAccountStringValues, i as requiresExplicitMatrixDefaultAccount, s as resolveMatrixDefaultOrOnlyAccountId, u as resolveScopedMatrixEnvConfig } from "./account-selection-BHkfU1eC.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 { i as repairCurrentTokenStorageMetaDeviceId } from "./storage-BXaFc0S4.mjs";
 import { createLazyRuntimeMethod, createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-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";
@@ -17,25 +18,15 @@ 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";
-//#region extensions/matrix/src/matrix/client/config.ts
-const loadMatrixAuthClientDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-BkKE4ANj.mjs").then((n) => n.t), import("./logging-rgm8ep9H.mjs").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
+//#region extensions/matrix/src/matrix/client/auth-request.ts
+const loadMatrixAuthClientDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-rqFjgltR.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-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));
 }
-function isAbortSignalTriggered(signal) {
-	return signal?.aborted === true;
-}
-function credentialsMatchBackfillAuthLineage(params) {
-	if (!params.stored) return true;
-	return params.stored.homeserver === params.auth.homeserver && params.stored.userId === params.auth.userId && params.stored.accessToken === params.auth.accessToken;
-}
 async function retryMatrixAuthRequest(label, run, signal) {
 	return await retryAsync(run, {
 		attempts: 3,
@@ -47,15 +38,68 @@ async function retryMatrixAuthRequest(label, run, signal) {
 		sleep: (ms) => sleepWithAbort(ms, signal)
 	});
 }
+var MatrixWhoamiCleanupError = class extends AggregateError {};
 async function fetchMatrixWhoamiIdentity(params) {
 	const { MatrixClient, ensureMatrixSdkLoggingConfigured } = await loadMatrixAuthClientDeps();
+	params.signal?.throwIfAborted();
 	ensureMatrixSdkLoggingConfigured();
 	const tempClient = new MatrixClient(params.homeserver, params.accessToken, {
 		userId: params.userId,
 		ssrfPolicy: params.ssrfPolicy,
 		dispatcherPolicy: params.dispatcherPolicy
 	});
-	return await retryMatrixAuthRequest("matrix auth whoami", async () => await tempClient.doRequest("GET", "/_matrix/client/v3/account/whoami"), params.signal);
+	let stopping;
+	const stop = () => stopping ??= tempClient.stopWithoutPersist();
+	const onAbort = () => {
+		stop().catch(() => {});
+	};
+	params.signal?.addEventListener("abort", onAbort, { once: true });
+	let outcome;
+	let cleanupFailure;
+	try {
+		params.signal?.throwIfAborted();
+		outcome = {
+			ok: true,
+			value: await retryMatrixAuthRequest("matrix auth whoami", async () => {
+				const identity = await tempClient.doRequest("GET", "/_matrix/client/v3/account/whoami");
+				if (!isRecord(identity)) throw new Error("Matrix whoami returned an invalid identity");
+				const userId = identity.user_id ?? void 0;
+				const deviceId = identity.device_id ?? void 0;
+				if (userId !== void 0 && typeof userId !== "string" || deviceId !== void 0 && typeof deviceId !== "string") throw new Error("Matrix whoami returned an invalid identity");
+				return {
+					user_id: userId,
+					device_id: deviceId
+				};
+			}, params.signal)
+		};
+	} catch (error) {
+		outcome = {
+			ok: false,
+			error
+		};
+	} finally {
+		params.signal?.removeEventListener("abort", onAbort);
+		try {
+			await stop();
+		} catch (error) {
+			cleanupFailure = { error };
+		}
+	}
+	if (cleanupFailure) throw new MatrixWhoamiCleanupError(outcome.ok ? [cleanupFailure.error] : [outcome.error, cleanupFailure.error], "Matrix identity request cleanup failed", { cause: outcome.ok ? cleanupFailure.error : outcome.error });
+	if (!outcome.ok) throw outcome.error;
+	return outcome.value;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/client/config.ts
+const loadMatrixCredentialsReadDeps = createLazyRuntimeModule(() => import("./credentials-read-Q5sHkkHv.mjs").then((n) => n.i));
+const loadMatrixCredentialsWriteRuntime = createLazyRuntimeModule(() => import("./credentials-write.runtime-DxbXh-pK.mjs"));
+const loadMatrixSecretInputDeps = createLazyRuntimeModule(() => import("./config-secret-input.runtime-CwsP3--c.mjs"));
+function isAbortSignalTriggered(signal) {
+	return signal?.aborted === true;
+}
+function credentialsMatchBackfillAuthLineage(params) {
+	if (!params.stored) return true;
+	return params.stored.homeserver === params.auth.homeserver && params.stored.userId === params.auth.userId && params.stored.accessToken === params.auth.accessToken;
 }
 const MATRIX_CONFIG_STRING_FIELDS = [
 	"homeserver",
@@ -383,7 +427,7 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 			signal: params.abortSignal
 		});
 	} catch (err) {
-		if (isAbortSignalTriggered(params.abortSignal)) return;
+		if (isAbortSignalTriggered(params.abortSignal) && !(err instanceof MatrixWhoamiCleanupError)) return;
 		throw err;
 	}
 	const deviceId = whoami.device_id?.trim();
@@ -396,7 +440,7 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 		auth: params.auth
 	})) return;
 	if (isAbortSignalTriggered(params.abortSignal)) return;
-	if (!repairCurrentTokenStorageMetaDeviceId({
+	if (!await repairCurrentTokenStorageMetaDeviceId({
 		homeserver: params.auth.homeserver,
 		userId: params.auth.userId,
 		accessToken: params.auth.accessToken,
@@ -405,7 +449,13 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 		env: params.env
 	})) throw new Error("Matrix deviceId backfill failed to repair current-token storage metadata");
 	if (isAbortSignalTriggered(params.abortSignal)) return;
-	return await (await loadMatrixCredentialsWriteRuntime()).saveBackfilledMatrixDeviceId({
+	const credentialsWriter = await loadMatrixCredentialsWriteRuntime();
+	const currentCredentials = await loadMatrixCredentialsAsync(env, params.auth.accountId);
+	if (isAbortSignalTriggered(params.abortSignal) || !credentialsMatchBackfillAuthLineage({
+		stored: currentCredentials,
+		auth: params.auth
+	})) return;
+	return await credentialsWriter.saveBackfilledMatrixDeviceId({
 		homeserver: params.auth.homeserver,
 		userId: params.auth.userId,
 		accessToken: params.auth.accessToken,
@@ -414,17 +464,25 @@ async function backfillMatrixAuthDeviceIdAfterStartup(params) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/monitor/task-runner.ts
-const monitorTaskSignal = new AsyncLocalStorage();
+const monitorTaskContext = new AsyncLocalStorage();
 function getMatrixMonitorTaskSignal() {
-	return monitorTaskSignal.getStore();
+	const context = monitorTaskContext.getStore();
+	return context?.settled ? context.runner.shutdownSignal : context?.signal;
 }
 function createMatrixMonitorTaskRunner(params) {
 	const inFlight = /* @__PURE__ */ new Map();
+	const shutdownController = new AbortController();
+	const runner = { shutdownSignal: shutdownController.signal };
 	let closed = false;
 	const runDetachedTask = (label, task) => {
 		if (closed) return Promise.resolve();
 		const controller = new AbortController();
-		const trackedTask = monitorTaskSignal.run(controller.signal, () => Promise.resolve().then(task)).catch((error) => {
+		const context = {
+			runner,
+			settled: false,
+			signal: AbortSignal.any([controller.signal, runner.shutdownSignal])
+		};
+		const trackedTask = monitorTaskContext.run(context, () => Promise.resolve().then(task)).catch((error) => {
 			const message = String(error);
 			params.logVerboseMessage(`matrix: ${label} failed (${message})`);
 			params.logger.warn("matrix background task failed", {
@@ -432,7 +490,7 @@ function createMatrixMonitorTaskRunner(params) {
 				error: message
 			});
 		}).finally(() => {
-			controller.abort();
+			context.settled = true;
 			inFlight.delete(trackedTask);
 		});
 		inFlight.set(trackedTask, controller);
@@ -444,6 +502,7 @@ function createMatrixMonitorTaskRunner(params) {
 	return {
 		close: () => {
 			closed = true;
+			shutdownController.abort();
 			for (const controller of inFlight.values()) controller.abort();
 		},
 		runDetachedTask,
@@ -483,7 +542,7 @@ async function awaitMatrixStartupWithAbort(promise, abortSignal) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/client/shared.ts
-const loadMatrixCreateClientDeps = createLazyRuntimeModule(() => import("./create-client-DQXAZjTw.mjs").then((runtime) => ({ createMatrixClient: runtime.createMatrixClient })));
+const loadMatrixCreateClientDeps = createLazyRuntimeModule(() => import("./create-client-CHxcron_.mjs").then((runtime) => ({ createMatrixClient: runtime.createMatrixClient })));
 const MATRIX_RETIREMENT_DRAIN_TIMEOUT_MS = 5e3;
 const sharedClientStates = /* @__PURE__ */ new Map();
 const sharedClientPromises = /* @__PURE__ */ new Map();
@@ -857,7 +916,7 @@ var client_exports = /* @__PURE__ */ __exportAll({
 	createMatrixClient: () => createMatrixClient,
 	resolveMatrixAuthContext: () => resolveMatrixAuthContext
 });
-const loadMatrixClientRuntime = createLazyRuntimeModule(() => import("./create-client-DQXAZjTw.mjs"));
+const loadMatrixClientRuntime = createLazyRuntimeModule(() => import("./create-client-CHxcron_.mjs"));
 const createMatrixClient = createLazyRuntimeMethod(loadMatrixClientRuntime, (runtime) => runtime.createMatrixClient);
 //#endregion
-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 };
+export { createMatrixStartupAbortError as a, createMatrixMonitorTaskRunner as c, resolveMatrixAuth as d, resolveMatrixAuthContext as f, awaitMatrixStartupWithAbort as i, getMatrixMonitorTaskSignal as l, createMatrixClient as n, isMatrixStartupAbortError as o, acquireSharedMatrixClient as r, throwIfMatrixStartupAborted as s, client_exports as t, backfillMatrixAuthDeviceIdAfterStartup as u };

package/dist/.setup/{client-bootstrap-DGX0f-4x.mjs → client-bootstrap-BSnUAoz1.mjs}

@@ -2,7 +2,7 @@ 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
-const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-DsJUnWlV.mjs").then((n) => n.t).then((clientModule) => ({
+const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-ChrXpxos.mjs").then((n) => n.t).then((clientModule) => ({
 	acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
 	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext
 })));

package/dist/.setup/{create-client-DQXAZjTw.mjs → create-client-CHxcron_.mjs}

@@ -1,23 +1,28 @@
 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 { n as maybeMigrateLegacyStorage, o as resolveMatrixStoragePaths, s as writeStorageMeta } from "./storage-BXaFc0S4.mjs";
+import "./client-ChrXpxos.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]) => ({
+const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([
+	import("./sdk-rqFjgltR.mjs").then((n) => n.t),
+	import("./logging-rgm8ep9H.mjs").then((n) => n.n),
+	import("./file-sync-store-CsalA4yI.mjs")
+]).then(([sdkModule, loggingModule, syncStoreModule]) => ({
 	MatrixClient: sdkModule.MatrixClient,
+	SqliteBackedMatrixSyncStore: syncStoreModule.SqliteBackedMatrixSyncStore,
 	ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
 })));
 async function createMatrixClient(params) {
-	const { MatrixClient, ensureMatrixSdkLoggingConfigured } = await loadMatrixCreateClientRuntimeDeps();
+	const { MatrixClient, SqliteBackedMatrixSyncStore, 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({
+	const storagePaths = params.persistStorage !== false ? await resolveMatrixStoragePaths({
 		homeserver,
 		userId,
 		accessToken: params.accessToken,
@@ -31,7 +36,7 @@ async function createMatrixClient(params) {
 			env: process.env
 		});
 		fs.mkdirSync(storagePaths.rootDir, { recursive: true });
-		writeStorageMeta({
+		await writeStorageMeta({
 			storagePaths,
 			homeserver,
 			userId,
@@ -40,6 +45,7 @@ async function createMatrixClient(params) {
 		});
 	}
 	const cryptoDatabasePrefix = storagePaths ? `openclaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}` : void 0;
+	const syncStore = storagePaths ? await SqliteBackedMatrixSyncStore.create(storagePaths.rootDir) : void 0;
 	return new MatrixClient(homeserver, params.accessToken, {
 		userId: matrixClientUserId,
 		password: params.password,
@@ -47,7 +53,7 @@ async function createMatrixClient(params) {
 		encryption: params.encryption,
 		localTimeoutMs: params.localTimeoutMs,
 		initialSyncLimit: params.initialSyncLimit,
-		storageRootDir: storagePaths?.rootDir,
+		syncStore,
 		recoveryKeyPath: storagePaths?.recoveryKeyPath,
 		idbSnapshotPath: storagePaths?.idbSnapshotPath,
 		cryptoDatabasePrefix,

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

@@ -1,6 +1,6 @@
 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 { a as loadMatrixCredentials, c as openMatrixCredentialsStore, n as clearMatrixCredentials, r as credentialsMatchConfig, s as openMatrixCredentialsAsyncStore } from "./credentials-read-Q5sHkkHv.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/credentials.ts
 async function saveMatrixCredentials(credentials, env = process.env, accountId) {

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

@@ -6,6 +6,7 @@ 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
 var credentials_read_exports = /* @__PURE__ */ __exportAll({
+	captureMatrixCredentialsEnv: () => captureMatrixCredentialsEnv,
 	clearMatrixCredentials: () => clearMatrixCredentials,
 	credentialsMatchConfig: () => credentialsMatchConfig,
 	loadMatrixCredentials: () => loadMatrixCredentials,
@@ -34,6 +35,13 @@ function openMatrixCredentialsStore(env = process.env) {
 function openMatrixCredentialsAsyncStore(env = process.env) {
 	return getMatrixRuntime().state.openKeyedStore(matrixCredentialsStoreOptions(env));
 }
+function captureMatrixCredentialsEnv(env) {
+	return {
+		...env,
+		OPENCLAW_STATE_DIR: getMatrixRuntime().state.resolveStateDir(env),
+		OPENCLAW_SUPERVISOR_MODE: env.OPENCLAW_SUPERVISOR_MODE
+	};
+}
 async function loadMatrixCredentialsAsync(env = process.env, accountId) {
 	return decodeMatrixCredentials(await openMatrixCredentialsAsyncStore(env).lookup(matrixCredentialsStoreKey(accountId)), accountId);
 }
@@ -63,4 +71,4 @@ function credentialsMatchConfig(stored, config) {
 	return stored.homeserver === config.homeserver && stored.userId === config.userId;
 }
 //#endregion
-export { openMatrixCredentialsAsyncStore as a, loadMatrixCredentials as i, credentialsMatchConfig as n, openMatrixCredentialsStore as o, credentials_read_exports as r, clearMatrixCredentials as t };
+export { loadMatrixCredentials as a, openMatrixCredentialsStore as c, credentials_read_exports as i, clearMatrixCredentials as n, loadMatrixCredentialsAsync as o, credentialsMatchConfig as r, openMatrixCredentialsAsyncStore as s, captureMatrixCredentialsEnv as t };

package/dist/.setup/{credentials-write.runtime-M_bUf3rL.mjs → credentials-write.runtime-DxbXh-pK.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-CeRipapZ.mjs"));
+const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-BGKfiaJW.mjs"));
 async function saveMatrixCredentials(...args) {
 	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
 }

package/dist/.setup/{crypto-runtime-9oxuU30y.mjs → crypto-runtime-D9qn_Pbj.mjs}

@@ -1,13 +1,13 @@
 import { t as ensureMatrixCryptoRuntime } from "./deps-mtxF2mHI.mjs";
 import { n as LogService, r as noop } from "./logger-xBjiRIp1.mjs";
-import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-CIfFUjP3.mjs";
-import { n as isRepairableSecretStorageAccessError } from "./sdk-BkKE4ANj.mjs";
+import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-c8uxcofH.mjs";
+import { n as isRepairableSecretStorageAccessError } from "./sdk-rqFjgltR.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { formatErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { IDBDatabase } from "fake-indexeddb";
 import { MatrixEventEvent } from "matrix-js-sdk/lib/matrix.js";
+import { IDBDatabase } from "fake-indexeddb";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
 import "fake-indexeddb/auto";
 import { CryptoEvent } from "matrix-js-sdk/lib/crypto-api/CryptoEvent.js";

package/dist/.setup/{crypto-snapshot-doctor.runtime-DXpLbQ7y.mjs → crypto-snapshot-doctor.runtime-CMWa1d9Y.mjs}

@@ -1,6 +1,6 @@
-import { T as writeMatrixIdbSnapshotJsonToStore, m as openMatrixIdbSnapshotStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, x as readMatrixIdbSnapshotJsonFromStore } from "./storage-metadata-BQJjHC_i.mjs";
+import { b as readMatrixIdbSnapshotJsonFromStore, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as openMatrixIdbSnapshotStoreOptions, w as writeMatrixIdbSnapshotJsonToStore } from "./storage-metadata-fHN6Df2m.mjs";
 import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.mjs";
-import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-CIfFUjP3.mjs";
+import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-c8uxcofH.mjs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import fs from "node:fs";

package/dist/.setup/{directory-live-CatwztQc.mjs → directory-live-CxqkcYbT.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
-import { u as resolveMatrixAuth } from "./client-DsJUnWlV.mjs";
-import { t as MatrixAuthedHttpClient } from "./http-client-BJjo-iw5.mjs";
+import { d as resolveMatrixAuth } from "./client-ChrXpxos.mjs";
+import { t as MatrixAuthedHttpClient } from "./http-client-Bi6uKmzh.mjs";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({

package/dist/.setup/{draft-stream-DIFZDNrb.mjs → draft-stream-y0Vq5f38.mjs}

@@ -1,6 +1,6 @@
 import { _ as MsgType } from "./direct-management-B2Bno2xL.mjs";
-import { a as sendSingleTextMessageMatrix, m as prepareMatrixSingleText, t as editMessageMatrix } from "./send-h0gZ_-qk.mjs";
-import { createFinalizableDraftStreamControlsForState } from "openclaw/plugin-sdk/channel-outbound";
+import { a as sendSingleTextMessageMatrix, m as prepareMatrixSingleText, t as editMessageMatrix } from "./send-aVdC5NJO.mjs";
+import { createFinalizableDraftLifecycle } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/matrix/src/matrix/draft-stream.ts
 const DEFAULT_THROTTLE_MS = 1e3;
 function resolveDraftPreviewOptions(mode) {
@@ -82,10 +82,22 @@ function createMatrixDraftStream(params) {
 			return false;
 		}
 	};
-	const { loop, update, stop: stopDraft, discardPending } = createFinalizableDraftStreamControlsForState({
+	const { loop, update, stop: stopDraft, discardPending, seal, clear, retire, cleanupPending } = createFinalizableDraftLifecycle({
 		throttleMs: DEFAULT_THROTTLE_MS,
 		state: streamState,
-		sendOrEditStreamMessage: sendOrEdit
+		sendOrEditStreamMessage: sendOrEdit,
+		readMessageId: () => currentEventId,
+		clearMessageId: () => {
+			currentEventId = void 0;
+			lastSentText = "";
+			lastSentContent = "";
+		},
+		isValidMessageId: (id) => typeof id === "string" && id.length > 0,
+		deleteMessage: async (id) => {
+			await client.redactEvent(roomId, id);
+		},
+		warn: log,
+		warnPrefix: "matrix draft preview cleanup failed"
 	});
 	log?.(`draft-stream: ready (throttleMs=${DEFAULT_THROTTLE_MS})`);
 	const finalizeLive = async () => {
@@ -134,14 +146,18 @@ function createMatrixDraftStream(params) {
 	const deleteCurrentMessage = async () => {
 		loop.resetPending();
 		await loop.waitForInFlight();
-		if (currentEventId) await client.redactEvent(roomId, currentEventId);
+		const retiredEventId = currentEventId;
 		resetCurrentMessage();
+		if (retiredEventId) await retire(retiredEventId);
 	};
 	return {
 		update,
 		flush: loop.flush,
 		stop,
 		discardPending,
+		seal,
+		clear,
+		cleanupPending,
 		deleteCurrentMessage,
 		finalizeLive,
 		reset,

package/dist/.setup/{encryption-guidance-DYEbeYj-.mjs → encryption-guidance-CMWXiBzJ.mjs}

@@ -1,4 +1,4 @@
-import { o as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-5koohRSQ.mjs";
+import { s as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-BHkfU1eC.mjs";
 import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/encryption-guidance.ts

package/dist/.setup/file-sync-store-CsalA4yI.mjs

@@ -0,0 +1,213 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { t as claimCurrentTokenStorageState } from "./storage-BXaFc0S4.mjs";
+import { c as writeMatrixSyncCacheStateToStore, i as openMatrixSyncCacheStoreOptions, n as deleteMatrixSyncCacheStateFromStore, o as readPersistedStoreFromStore } from "./sync-cache-state-BMtGMxU1.mjs";
+import { n as LogService } from "./logger-xBjiRIp1.mjs";
+import { MemoryStore, SyncAccumulator } from "matrix-js-sdk/lib/matrix.js";
+//#region extensions/matrix/src/matrix/async-lock.ts
+function createAsyncLock() {
+	let lock = Promise.resolve();
+	return async function withLock(fn) {
+		const previous = lock;
+		let release;
+		lock = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await fn();
+		} finally {
+			release?.();
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/client/file-sync-store.ts
+const PERSIST_DEBOUNCE_MS = 250;
+function cloneJson(value) {
+	return structuredClone(value);
+}
+function syncDataToSyncResponse(syncData) {
+	return {
+		next_batch: syncData.nextBatch,
+		rooms: syncData.roomsData,
+		account_data: { events: syncData.accountData }
+	};
+}
+var SqliteBackedMatrixSyncStore = class SqliteBackedMatrixSyncStore extends MemoryStore {
+	static async create(storageRootDir) {
+		let store;
+		let persisted = null;
+		let unavailableError;
+		try {
+			store = getMatrixRuntime().state.openKeyedStore(openMatrixSyncCacheStoreOptions(storageRootDir));
+			persisted = await readPersistedStoreFromStore({
+				storageRootDir,
+				store
+			});
+		} catch (error) {
+			unavailableError = error;
+			LogService.warn("MatrixSyncCacheStore", "Failed to load Matrix sync cache:", error);
+		}
+		return new SqliteBackedMatrixSyncStore(storageRootDir, store, persisted, unavailableError);
+	}
+	constructor(storageRootDir, store, persisted, storeUnavailableError) {
+		super();
+		this.storageRootDir = storageRootDir;
+		this.store = store;
+		this.storeUnavailableError = storeUnavailableError;
+		this.persistLock = createAsyncLock();
+		this.accumulator = new SyncAccumulator();
+		this.savedSync = null;
+		this.cleanShutdown = false;
+		this.dirty = false;
+		this.frozen = false;
+		this.persistTimer = null;
+		this.persistPromise = null;
+		const restoredSavedSync = persisted?.savedSync ?? null;
+		const restoredClientOptions = persisted?.clientOptions;
+		const restoredCleanShutdown = persisted?.cleanShutdown === true;
+		this.savedSync = restoredSavedSync;
+		this.savedClientOptions = restoredClientOptions;
+		this.hadSavedSyncOnLoad = restoredSavedSync !== null;
+		this.hadCleanShutdownOnLoad = this.hadSavedSyncOnLoad && restoredCleanShutdown;
+		this.cleanShutdown = this.hadCleanShutdownOnLoad;
+		if (this.savedSync) {
+			this.accumulator.accumulate(syncDataToSyncResponse(this.savedSync), true);
+			super.setSyncToken(this.savedSync.nextBatch);
+		}
+		if (this.savedClientOptions) super.storeClientOptions(this.savedClientOptions);
+	}
+	hasSavedSync() {
+		return this.hadSavedSyncOnLoad;
+	}
+	hasSavedSyncFromCleanShutdown() {
+		return this.hadCleanShutdownOnLoad;
+	}
+	getSavedSync() {
+		return Promise.resolve(this.savedSync ? cloneJson(this.savedSync) : null);
+	}
+	getSavedSyncToken() {
+		return Promise.resolve(this.savedSync?.nextBatch ?? null);
+	}
+	setSyncData(syncData) {
+		if (this.frozen) return Promise.resolve();
+		this.accumulator.accumulate(syncData);
+		this.savedSync = this.accumulator.getJSON();
+		this.markDirtyAndSchedulePersist();
+		return Promise.resolve();
+	}
+	getClientOptions() {
+		return Promise.resolve(this.savedClientOptions ? cloneJson(this.savedClientOptions) : void 0);
+	}
+	storeClientOptions(options) {
+		if (this.frozen) return Promise.resolve();
+		this.savedClientOptions = cloneJson(options);
+		super.storeClientOptions(options);
+		this.markDirtyAndSchedulePersist();
+		return Promise.resolve();
+	}
+	save(force = false) {
+		if (force) return this.flush();
+		return Promise.resolve();
+	}
+	wantsSave() {
+		return false;
+	}
+	async deleteAllData() {
+		const store = this.requireStore();
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		this.dirty = false;
+		await this.enqueuePersistence(async () => {
+			await super.deleteAllData();
+			this.savedSync = null;
+			this.savedClientOptions = void 0;
+			this.cleanShutdown = false;
+			this.dirty = false;
+			await deleteMatrixSyncCacheStateFromStore({
+				storageRootDir: this.storageRootDir,
+				store
+			});
+		});
+	}
+	markCleanShutdown() {
+		this.cleanShutdown = true;
+		this.dirty = true;
+	}
+	async freezeSyncCursorPersistence() {
+		this.frozen = true;
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		while (this.persistPromise) await this.persistPromise;
+	}
+	discardPendingSyncCursorPersistence() {
+		this.frozen = true;
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		this.cleanShutdown = false;
+		this.dirty = false;
+	}
+	async flush() {
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		while (this.dirty || this.persistPromise) {
+			if (this.dirty && !this.persistPromise) this.enqueuePersistence(() => this.persist());
+			await this.persistPromise;
+		}
+	}
+	markDirtyAndSchedulePersist() {
+		if (this.frozen) return;
+		this.cleanShutdown = false;
+		this.dirty = true;
+		if (this.persistTimer) return;
+		this.persistTimer = setTimeout(() => {
+			this.persistTimer = null;
+			this.flush().catch((err) => {
+				LogService.warn("MatrixSyncCacheStore", "Failed to persist Matrix sync store:", err);
+			});
+		}, PERSIST_DEBOUNCE_MS);
+		this.persistTimer.unref?.();
+	}
+	async persist() {
+		const store = this.requireStore();
+		this.dirty = false;
+		const payload = {
+			version: 1,
+			savedSync: this.savedSync ? cloneJson(this.savedSync) : null,
+			cleanShutdown: this.cleanShutdown,
+			...this.savedClientOptions ? { clientOptions: cloneJson(this.savedClientOptions) } : {}
+		};
+		try {
+			await writeMatrixSyncCacheStateToStore({
+				storageRootDir: this.storageRootDir,
+				payload,
+				store
+			});
+			await claimCurrentTokenStorageState({ rootDir: this.storageRootDir });
+		} catch (err) {
+			this.dirty = true;
+			throw err;
+		}
+	}
+	enqueuePersistence(operation) {
+		const pending = this.persistLock(operation).finally(() => {
+			if (this.persistPromise === pending) this.persistPromise = null;
+		});
+		this.persistPromise = pending;
+		return pending;
+	}
+	requireStore() {
+		if (this.store && this.storeUnavailableError == null) return this.store;
+		throw new Error("Matrix sync cache SQLite store is unavailable; cannot persist sync state", { cause: this.storeUnavailableError });
+	}
+};
+//#endregion
+export { SqliteBackedMatrixSyncStore };