@openclaw/matrix 2026.3.13 → 2026.5.10-beta.1

package/dist/storage-tC3ujLiW.js

@@ -0,0 +1,281 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-BWwIruri.js";
+import { t as getMatrixRuntime } from "./runtime-Dog86njy.js";
+import { n as resolveMatrixAccountStorageRoot, s as resolveMatrixLegacyFlatStoragePaths } from "./storage-paths-BJLdnCjV.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadJsonFile, saveJsonFile } from "openclaw/plugin-sdk/json-store";
+//#region extensions/matrix/src/matrix/client/storage.ts
+const DEFAULT_ACCOUNT_KEY = "default";
+const STORAGE_META_FILENAME = "storage-meta.json";
+const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
+const LEGACY_CRYPTO_MIGRATION_FILENAME = "legacy-crypto-migration.json";
+const RECOVERY_KEY_FILENAME = "recovery-key.json";
+const IDB_SNAPSHOT_FILENAME = "crypto-idb-snapshot.json";
+const STARTUP_VERIFICATION_FILENAME = "startup-verification.json";
+function resolveLegacyStoragePaths(env = process.env) {
+	const legacy = resolveMatrixLegacyFlatStoragePaths(getMatrixRuntime().state.resolveStateDir(env, os.homedir));
+	return {
+		storagePath: legacy.storagePath,
+		cryptoPath: legacy.cryptoPath
+	};
+}
+function assertLegacyMigrationAccountSelection(params) {
+	const cfg = getMatrixRuntime().config.current();
+	if (!cfg.channels?.matrix || typeof cfg.channels.matrix !== "object") return;
+	if (requiresExplicitMatrixDefaultAccount(cfg)) throw new Error("Legacy Matrix client storage cannot be migrated automatically because multiple Matrix accounts are configured and channels.matrix.defaultAccount is not set.");
+	const selectedAccountId = normalizeAccountId(resolveMatrixDefaultOrOnlyAccountId(cfg));
+	const currentAccountId = normalizeAccountId(params.accountKey);
+	if (selectedAccountId !== currentAccountId) throw new Error(`Legacy Matrix client storage targets account "${selectedAccountId}", but the current client is starting account "${currentAccountId}". Start the selected account first so flat legacy storage is not migrated into the wrong account directory.`);
+}
+function scoreStorageRoot(rootDir) {
+	let score = 0;
+	if (fs.existsSync(path.join(rootDir, "bot-storage.json"))) score += 8;
+	if (fs.existsSync(path.join(rootDir, "crypto"))) score += 8;
+	if (fs.existsSync(path.join(rootDir, THREAD_BINDINGS_FILENAME))) score += 4;
+	if (fs.existsSync(path.join(rootDir, LEGACY_CRYPTO_MIGRATION_FILENAME))) score += 3;
+	if (fs.existsSync(path.join(rootDir, RECOVERY_KEY_FILENAME))) score += 2;
+	if (fs.existsSync(path.join(rootDir, IDB_SNAPSHOT_FILENAME))) score += 2;
+	if (fs.existsSync(path.join(rootDir, STORAGE_META_FILENAME))) score += 1;
+	return score;
+}
+function resolveStorageRootMtimeMs(rootDir) {
+	try {
+		return fs.statSync(rootDir).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+function readStoredRootMetadata(rootDir) {
+	const metadata = {};
+	const parsed = loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME));
+	if (parsed) {
+		if (typeof parsed.homeserver === "string" && parsed.homeserver.trim()) metadata.homeserver = parsed.homeserver.trim();
+		if (typeof parsed.userId === "string" && parsed.userId.trim()) metadata.userId = parsed.userId.trim();
+		if (typeof parsed.accountId === "string" && parsed.accountId.trim()) metadata.accountId = parsed.accountId.trim();
+		if (typeof parsed.accessTokenHash === "string" && parsed.accessTokenHash.trim()) metadata.accessTokenHash = parsed.accessTokenHash.trim();
+		if (typeof parsed.deviceId === "string" && parsed.deviceId.trim()) metadata.deviceId = parsed.deviceId.trim();
+		if (parsed.currentTokenStateClaimed === true) metadata.currentTokenStateClaimed = true;
+		if (typeof parsed.createdAt === "string" && parsed.createdAt.trim()) metadata.createdAt = parsed.createdAt.trim();
+	}
+	const verification = loadJsonFile(path.join(rootDir, STARTUP_VERIFICATION_FILENAME));
+	if (!metadata.deviceId && typeof verification?.deviceId === "string" && verification.deviceId.trim()) metadata.deviceId = verification.deviceId.trim();
+	return metadata;
+}
+function isCompatibleStorageRoot(params) {
+	const metadata = readStoredRootMetadata(params.candidateRootDir);
+	if (metadata.homeserver && metadata.homeserver !== params.homeserver) return false;
+	if (metadata.userId && metadata.userId !== params.userId) return false;
+	if (metadata.accountId && normalizeAccountId(metadata.accountId) !== normalizeAccountId(params.accountKey)) return false;
+	if (params.deviceId && metadata.deviceId && metadata.deviceId.trim() && metadata.deviceId.trim() !== params.deviceId.trim()) return false;
+	if (params.requireExplicitDeviceMatch && params.deviceId && (!metadata.deviceId || metadata.deviceId.trim() !== params.deviceId.trim())) return false;
+	return true;
+}
+function resolvePreferredMatrixStorageRoot(params) {
+	const parentDir = path.dirname(params.canonicalRootDir);
+	const bestCurrentScore = scoreStorageRoot(params.canonicalRootDir);
+	let best = {
+		rootDir: params.canonicalRootDir,
+		tokenHash: params.canonicalTokenHash,
+		score: bestCurrentScore,
+		mtimeMs: resolveStorageRootMtimeMs(params.canonicalRootDir)
+	};
+	if (!params.deviceId?.trim()) return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+	const canonicalMetadata = readStoredRootMetadata(params.canonicalRootDir);
+	if (canonicalMetadata.accessTokenHash === params.canonicalTokenHash && canonicalMetadata.deviceId?.trim() === params.deviceId.trim() && canonicalMetadata.currentTokenStateClaimed === true) return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+	let siblingEntries = [];
+	try {
+		siblingEntries = fs.readdirSync(parentDir, { withFileTypes: true });
+	} catch {
+		return {
+			rootDir: best.rootDir,
+			tokenHash: best.tokenHash
+		};
+	}
+	for (const entry of siblingEntries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === params.canonicalTokenHash) continue;
+		const candidateRootDir = path.join(parentDir, entry.name);
+		if (!isCompatibleStorageRoot({
+			candidateRootDir,
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accountKey: params.accountKey,
+			deviceId: params.deviceId,
+			requireExplicitDeviceMatch: Boolean(params.deviceId)
+		})) continue;
+		const candidateScore = scoreStorageRoot(candidateRootDir);
+		if (candidateScore <= 0) continue;
+		const candidateMtimeMs = resolveStorageRootMtimeMs(candidateRootDir);
+		if (candidateScore > best.score || best.rootDir !== params.canonicalRootDir && candidateScore === best.score && candidateMtimeMs > best.mtimeMs) best = {
+			rootDir: candidateRootDir,
+			tokenHash: entry.name,
+			score: candidateScore,
+			mtimeMs: candidateMtimeMs
+		};
+	}
+	return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+}
+function resolveMatrixStoragePaths(params) {
+	const env = params.env ?? process.env;
+	const canonical = resolveMatrixAccountStorageRoot({
+		stateDir: params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accessToken: params.accessToken,
+		accountId: params.accountId
+	});
+	const { rootDir, tokenHash } = resolvePreferredMatrixStorageRoot({
+		canonicalRootDir: canonical.rootDir,
+		canonicalTokenHash: canonical.tokenHash,
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountKey: canonical.accountKey,
+		deviceId: params.deviceId
+	});
+	return {
+		rootDir,
+		storagePath: path.join(rootDir, "bot-storage.json"),
+		cryptoPath: path.join(rootDir, "crypto"),
+		metaPath: path.join(rootDir, STORAGE_META_FILENAME),
+		recoveryKeyPath: path.join(rootDir, "recovery-key.json"),
+		idbSnapshotPath: path.join(rootDir, IDB_SNAPSHOT_FILENAME),
+		accountKey: canonical.accountKey,
+		tokenHash
+	};
+}
+function resolveMatrixStateFilePath(params) {
+	const storagePaths = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.accountId ?? params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		env: params.env,
+		stateDir: params.stateDir
+	});
+	return path.join(storagePaths.rootDir, params.filename);
+}
+async function maybeMigrateLegacyStorage(params) {
+	const legacy = resolveLegacyStoragePaths(params.env);
+	const hasLegacyStorage = fs.existsSync(legacy.storagePath);
+	const hasLegacyCrypto = fs.existsSync(legacy.cryptoPath);
+	if (!hasLegacyStorage && !hasLegacyCrypto) return;
+	const hasTargetStorage = fs.existsSync(params.storagePaths.storagePath);
+	const hasTargetCrypto = fs.existsSync(params.storagePaths.cryptoPath);
+	const shouldMigrateStorage = hasLegacyStorage && !hasTargetStorage;
+	const shouldMigrateCrypto = hasLegacyCrypto && !hasTargetCrypto;
+	if (!shouldMigrateStorage && !shouldMigrateCrypto) return;
+	assertLegacyMigrationAccountSelection({ accountKey: params.storagePaths.accountKey });
+	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
+	const { maybeCreateMatrixMigrationSnapshot } = await import("./migration-snapshot.runtime-CKHE3xF9.js");
+	await maybeCreateMatrixMigrationSnapshot({
+		trigger: "matrix-client-fallback",
+		env: params.env,
+		log: logger
+	});
+	fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
+	const moved = [];
+	const skippedExistingTargets = [];
+	try {
+		if (shouldMigrateStorage) moveLegacyStoragePathOrThrow({
+			sourcePath: legacy.storagePath,
+			targetPath: params.storagePaths.storagePath,
+			label: "sync store",
+			moved
+		});
+		else if (hasLegacyStorage) skippedExistingTargets.push(`- sync store remains at ${legacy.storagePath} because ${params.storagePaths.storagePath} already exists`);
+		if (shouldMigrateCrypto) moveLegacyStoragePathOrThrow({
+			sourcePath: legacy.cryptoPath,
+			targetPath: params.storagePaths.cryptoPath,
+			label: "crypto store",
+			moved
+		});
+		else if (hasLegacyCrypto) skippedExistingTargets.push(`- crypto store remains at ${legacy.cryptoPath} because ${params.storagePaths.cryptoPath} already exists`);
+	} catch (err) {
+		const rollbackError = rollbackLegacyMoves(moved);
+		throw new Error(rollbackError ? `Failed migrating legacy Matrix client storage: ${String(err)}. Rollback also failed: ${rollbackError}` : `Failed migrating legacy Matrix client storage: ${String(err)}`, { cause: err });
+	}
+	if (moved.length > 0) logger.info(`matrix: migrated legacy client storage into ${params.storagePaths.rootDir}\n${moved.map((entry) => `- ${entry.label}: ${entry.sourcePath} -> ${entry.targetPath}`).join("\n")}`);
+	if (skippedExistingTargets.length > 0) logger.warn?.(`matrix: legacy client storage still exists in the flat path because some account-scoped targets already existed.\n${skippedExistingTargets.join("\n")}`);
+}
+function moveLegacyStoragePathOrThrow(params) {
+	if (!fs.existsSync(params.sourcePath)) return;
+	if (fs.existsSync(params.targetPath)) throw new Error(`legacy Matrix ${params.label} target already exists (${params.targetPath}); refusing to overwrite it automatically`);
+	fs.renameSync(params.sourcePath, params.targetPath);
+	params.moved.push({
+		sourcePath: params.sourcePath,
+		targetPath: params.targetPath,
+		label: params.label
+	});
+}
+function rollbackLegacyMoves(moved) {
+	for (const entry of moved.toReversed()) try {
+		if (!fs.existsSync(entry.targetPath) || fs.existsSync(entry.sourcePath)) continue;
+		fs.renameSync(entry.targetPath, entry.sourcePath);
+	} catch (err) {
+		return `${entry.label} (${entry.targetPath} -> ${entry.sourcePath}): ${String(err)}`;
+	}
+	return null;
+}
+function writeStoredRootMetadata(metaPath, payload) {
+	try {
+		saveJsonFile(metaPath, payload);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function writeStorageMeta(params) {
+	const existing = readStoredRootMetadata(params.storagePaths.rootDir);
+	return writeStoredRootMetadata(params.storagePaths.metaPath, {
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
+		accessTokenHash: params.storagePaths.tokenHash,
+		deviceId: params.deviceId ?? null,
+		currentTokenStateClaimed: params.currentTokenStateClaimed ?? existing.currentTokenStateClaimed === true,
+		createdAt: existing.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function claimCurrentTokenStorageState(params) {
+	const metadata = readStoredRootMetadata(params.rootDir);
+	if (!metadata.accessTokenHash?.trim()) return false;
+	return writeStoredRootMetadata(path.join(params.rootDir, STORAGE_META_FILENAME), {
+		homeserver: metadata.homeserver,
+		userId: metadata.userId,
+		accountId: metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
+		accessTokenHash: metadata.accessTokenHash,
+		deviceId: metadata.deviceId ?? null,
+		currentTokenStateClaimed: true,
+		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function repairCurrentTokenStorageMetaDeviceId(params) {
+	return writeStorageMeta({
+		storagePaths: resolveMatrixStoragePaths({
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accessToken: params.accessToken,
+			accountId: params.accountId,
+			env: params.env,
+			stateDir: params.stateDir
+		}),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountId: params.accountId,
+		deviceId: params.deviceId
+	});
+}
+//#endregion
+export { resolveMatrixStoragePaths as a, resolveMatrixStateFilePath as i, maybeMigrateLegacyStorage as n, writeStorageMeta as o, repairCurrentTokenStorageMetaDeviceId as r, claimCurrentTokenStorageState as t };

package/dist/subagent-hooks-DQbyqq9V.js

@@ -0,0 +1,149 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { a as resolveMatrixTargetIdentity } from "./target-ids-80nQ2gql.js";
+import { a as listBindingsForAccount, c as resolveBindingKey, i as listAllBindings, n as getMatrixThreadBindingManager, o as removeBindingRecord } from "./thread-bindings-shared-DK-d-oYX.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-binding-runtime";
+import { formatThreadBindingDisabledError, formatThreadBindingSpawnDisabledError, resolveThreadBindingSpawnPolicy } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleMatrixSubagentDeliveryTarget: () => handleMatrixSubagentDeliveryTarget,
+	handleMatrixSubagentEnded: () => handleMatrixSubagentEnded,
+	handleMatrixSubagentSpawning: () => handleMatrixSubagentSpawning
+});
+function summarizeError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return "error";
+}
+function resolveMatrixBindingThreadId(binding) {
+	const { conversationId, parentConversationId } = binding.conversation;
+	return parentConversationId && parentConversationId !== conversationId ? conversationId : void 0;
+}
+function resolveMatrixBindingDeliveryOrigin(binding, fallbackAccountId) {
+	const boundRoomId = binding.conversation.parentConversationId ?? binding.conversation.conversationId;
+	const threadId = resolveMatrixBindingThreadId(binding);
+	return {
+		channel: "matrix",
+		accountId: binding.conversation.accountId ?? fallbackAccountId,
+		to: `room:${boundRoomId}`,
+		...threadId ? { threadId } : {}
+	};
+}
+async function handleMatrixSubagentSpawning(api, event) {
+	if (!event.threadRequested) return;
+	if (event.requester?.channel?.trim().toLowerCase() !== "matrix") return;
+	const accountId = normalizeOptionalString(event.requester?.accountId) || DEFAULT_ACCOUNT_ID;
+	const policy = resolveThreadBindingSpawnPolicy({
+		cfg: api.config,
+		channel: "matrix",
+		accountId,
+		kind: "subagent"
+	});
+	if (!policy.enabled) return {
+		status: "error",
+		error: formatThreadBindingDisabledError({
+			channel: policy.channel,
+			accountId: policy.accountId,
+			kind: "subagent"
+		})
+	};
+	if (!policy.spawnEnabled) return {
+		status: "error",
+		error: formatThreadBindingSpawnDisabledError({
+			channel: policy.channel,
+			accountId: policy.accountId,
+			kind: "subagent"
+		})
+	};
+	const rawTo = normalizeOptionalString(event.requester?.to) ?? "";
+	const matrixTarget = rawTo ? resolveMatrixTargetIdentity(rawTo) : null;
+	const roomId = matrixTarget?.kind === "room" ? matrixTarget.id : "";
+	if (!roomId) return {
+		status: "error",
+		error: "Cannot create Matrix thread binding: no room target in spawn request (requester.to must be a Matrix room ID)."
+	};
+	const bindingService = getSessionBindingService();
+	const capabilities = bindingService.getCapabilities({
+		channel: "matrix",
+		accountId
+	});
+	if (!capabilities.adapterAvailable || !capabilities.bindSupported) return {
+		status: "error",
+		error: `No Matrix session binding adapter available for account "${accountId}". Is the Matrix channel running?`
+	};
+	if (!capabilities.placements.includes("child")) return {
+		status: "error",
+		error: `Matrix session binding adapter for account "${accountId}" does not support child thread bindings.`
+	};
+	try {
+		return {
+			status: "ok",
+			threadBindingReady: true,
+			deliveryOrigin: resolveMatrixBindingDeliveryOrigin(await bindingService.bind({
+				targetSessionKey: event.childSessionKey,
+				targetKind: "subagent",
+				conversation: {
+					channel: "matrix",
+					accountId,
+					conversationId: roomId
+				},
+				placement: "child",
+				metadata: {
+					agentId: event.agentId?.trim() || void 0,
+					label: normalizeOptionalString(event.label) || void 0,
+					boundBy: "system"
+				}
+			}), accountId)
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			error: `Matrix thread bind failed: ${summarizeError(err)}`
+		};
+	}
+}
+async function handleMatrixSubagentEnded(event) {
+	const accountId = normalizeOptionalString(event.accountId) || void 0;
+	const matching = (accountId ? listBindingsForAccount(accountId) : listAllBindings()).filter((entry) => entry.targetSessionKey === event.targetSessionKey && entry.targetKind === "subagent");
+	const removedBindingKeys = /* @__PURE__ */ new Set();
+	if (event.sendFarewell) {
+		const bindingService = getSessionBindingService();
+		const reason = normalizeOptionalString(event.reason) || "subagent-ended";
+		for (const binding of matching) {
+			const bindingId = resolveBindingKey(binding);
+			if ((await bindingService.unbind({
+				bindingId,
+				reason
+			})).some((entry) => entry.bindingId === bindingId)) removedBindingKeys.add(bindingId);
+		}
+	}
+	const affectedAccountIds = /* @__PURE__ */ new Set();
+	for (const binding of matching) {
+		if (removedBindingKeys.has(resolveBindingKey(binding))) continue;
+		if (removeBindingRecord(binding)) affectedAccountIds.add(binding.accountId);
+	}
+	for (const acctId of affectedAccountIds) await getMatrixThreadBindingManager(acctId)?.persist();
+}
+function handleMatrixSubagentDeliveryTarget(event) {
+	if (!event.expectsCompletionMessage) return;
+	if (event.requesterOrigin?.channel?.trim().toLowerCase() !== "matrix") return;
+	const requesterAccountId = normalizeOptionalString(event.requesterOrigin?.accountId);
+	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? String(event.requesterOrigin.threadId).trim() : "";
+	const bindings = (requesterAccountId ? listBindingsForAccount(requesterAccountId) : listAllBindings()).filter((entry) => entry.targetSessionKey === event.childSessionKey && entry.targetKind === "subagent");
+	if (bindings.length === 0) return;
+	let binding;
+	if (requesterThreadId) binding = bindings.find((entry) => entry.conversationId === requesterThreadId && (!requesterAccountId || entry.accountId === requesterAccountId));
+	if (!binding && bindings.length === 1) binding = bindings[0];
+	if (!binding) return;
+	const roomId = binding.parentConversationId ?? binding.conversationId;
+	const threadId = binding.parentConversationId && binding.parentConversationId !== binding.conversationId ? binding.conversationId : void 0;
+	return { origin: {
+		channel: "matrix",
+		accountId: binding.accountId,
+		to: `room:${roomId}`,
+		...threadId ? { threadId } : {}
+	} };
+}
+//#endregion
+export { subagent_hooks_exports as i, handleMatrixSubagentEnded as n, handleMatrixSubagentSpawning as r, handleMatrixSubagentDeliveryTarget as t };

package/dist/subagent-hooks-api.js

@@ -0,0 +1,23 @@
+import { n as handleMatrixSubagentEnded, r as handleMatrixSubagentSpawning, t as handleMatrixSubagentDeliveryTarget } from "./subagent-hooks-DQbyqq9V.js";
+//#region extensions/matrix/subagent-hooks-api.ts
+let matrixSubagentHooksPromise = null;
+function loadMatrixSubagentHooksModule() {
+	matrixSubagentHooksPromise ??= import("./subagent-hooks-DQbyqq9V.js").then((n) => n.i);
+	return matrixSubagentHooksPromise;
+}
+function registerMatrixSubagentHooks(api) {
+	api.on("subagent_spawning", async (event) => {
+		const { handleMatrixSubagentSpawning } = await loadMatrixSubagentHooksModule();
+		return await handleMatrixSubagentSpawning(api, event);
+	});
+	api.on("subagent_ended", async (event) => {
+		const { handleMatrixSubagentEnded } = await loadMatrixSubagentHooksModule();
+		await handleMatrixSubagentEnded(event);
+	});
+	api.on("subagent_delivery_target", async (event) => {
+		const { handleMatrixSubagentDeliveryTarget } = await loadMatrixSubagentHooksModule();
+		return handleMatrixSubagentDeliveryTarget(event);
+	});
+}
+//#endregion
+export { handleMatrixSubagentDeliveryTarget, handleMatrixSubagentEnded, handleMatrixSubagentSpawning, registerMatrixSubagentHooks };

package/dist/sync-state-C_beeevA.js

@@ -0,0 +1,12 @@
+//#region extensions/matrix/src/matrix/sync-state.ts
+function isMatrixReadySyncState(state) {
+	return state === "PREPARED" || state === "SYNCING" || state === "CATCHUP";
+}
+function isMatrixDisconnectedSyncState(state) {
+	return state === "RECONNECTING" || state === "ERROR" || state === "STOPPED";
+}
+function isMatrixTerminalSyncState(state) {
+	return state === "STOPPED";
+}
+//#endregion
+export { isMatrixReadySyncState as n, isMatrixTerminalSyncState as r, isMatrixDisconnectedSyncState as t };

package/dist/target-ids-80nQ2gql.js

@@ -0,0 +1,77 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/target-ids.ts
+const MATRIX_PREFIX = "matrix:";
+const ROOM_PREFIX = "room:";
+const CHANNEL_PREFIX = "channel:";
+const USER_PREFIX = "user:";
+function stripKnownPrefixes(raw, prefixes) {
+	let normalized = raw.trim();
+	while (normalized) {
+		const lowered = normalizeLowercaseStringOrEmpty(normalized);
+		const matched = prefixes.find((prefix) => lowered.startsWith(prefix));
+		if (!matched) return normalized;
+		normalized = normalized.slice(matched.length).trim();
+	}
+	return normalized;
+}
+function resolveMatrixTargetIdentity(raw) {
+	const normalized = stripKnownPrefixes(raw, [MATRIX_PREFIX]);
+	if (!normalized) return null;
+	const lowered = normalizeLowercaseStringOrEmpty(normalized);
+	if (lowered.startsWith(USER_PREFIX)) {
+		const id = normalized.slice(5).trim();
+		return id ? {
+			kind: "user",
+			id
+		} : null;
+	}
+	if (lowered.startsWith(ROOM_PREFIX)) {
+		const id = normalized.slice(5).trim();
+		return id ? {
+			kind: "room",
+			id
+		} : null;
+	}
+	if (lowered.startsWith(CHANNEL_PREFIX)) {
+		const id = normalized.slice(8).trim();
+		return id ? {
+			kind: "room",
+			id
+		} : null;
+	}
+	if (isMatrixQualifiedUserId(normalized)) return {
+		kind: "user",
+		id: normalized
+	};
+	return {
+		kind: "room",
+		id: normalized
+	};
+}
+function isMatrixQualifiedUserId(raw) {
+	const trimmed = raw.trim();
+	return trimmed.startsWith("@") && trimmed.includes(":");
+}
+function normalizeMatrixResolvableTarget(raw) {
+	return stripKnownPrefixes(raw, [
+		MATRIX_PREFIX,
+		ROOM_PREFIX,
+		CHANNEL_PREFIX
+	]);
+}
+function normalizeMatrixMessagingTarget(raw) {
+	return stripKnownPrefixes(raw, [
+		MATRIX_PREFIX,
+		ROOM_PREFIX,
+		CHANNEL_PREFIX,
+		USER_PREFIX
+	]) || void 0;
+}
+function resolveMatrixDirectUserId(params) {
+	if (params.chatType !== "direct") return;
+	if (!normalizeMatrixResolvableTarget(params.to ?? "").startsWith("!")) return;
+	const userId = stripKnownPrefixes(params.from ?? "", [MATRIX_PREFIX, USER_PREFIX]);
+	return isMatrixQualifiedUserId(userId) ? userId : void 0;
+}
+//#endregion
+export { resolveMatrixTargetIdentity as a, resolveMatrixDirectUserId as i, normalizeMatrixMessagingTarget as n, normalizeMatrixResolvableTarget as r, isMatrixQualifiedUserId as t };

package/dist/test-api.js

@@ -0,0 +1,4 @@
+import { r as setMatrixRuntime } from "./runtime-Dog86njy.js";
+import { t as matrixPlugin } from "./channel-H_6lMgwf.js";
+import { t as MatrixClient } from "./sdk-B2vZA27-.js";
+export { MatrixClient, matrixPlugin, setMatrixRuntime };

package/dist/thread-binding-api-Cq_E-E1K.js

@@ -0,0 +1,17 @@
+import { a as resolveMatrixTargetIdentity } from "./target-ids-80nQ2gql.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/thread-binding-api.ts
+const defaultTopLevelPlacement = "child";
+function resolveMatrixInboundConversation(params) {
+	const rawTarget = params.to?.trim() || params.conversationId?.trim() || "";
+	const target = rawTarget ? resolveMatrixTargetIdentity(rawTarget) : null;
+	const parentConversationId = target?.kind === "room" ? target.id : void 0;
+	const threadId = params.threadId != null ? normalizeOptionalString(String(params.threadId)) : void 0;
+	if (threadId) return {
+		conversationId: threadId,
+		...parentConversationId ? { parentConversationId } : {}
+	};
+	return parentConversationId ? { conversationId: parentConversationId } : null;
+}
+//#endregion
+export { resolveMatrixInboundConversation as n, defaultTopLevelPlacement as t };

package/dist/thread-binding-api.js

@@ -0,0 +1,2 @@
+import { n as resolveMatrixInboundConversation, t as defaultTopLevelPlacement } from "./thread-binding-api-Cq_E-E1K.js";
+export { defaultTopLevelPlacement, resolveMatrixInboundConversation as resolveInboundConversation };