@kodelyth/matrix 2026.5.39 → 2026.5.42

package/dist/create-client-J0htTaRj.js

@@ -0,0 +1,64 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-DlrXNjAE.js";
+import { a as resolveMatrixStoragePaths, n as maybeMigrateLegacyStorage, o as writeStorageMeta } from "./storage-nyO0DOFE.js";
+import "./shared-D6MFMnpG.js";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs";
+import { ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "klaw/plugin-sdk/ssrf-runtime";
+//#region extensions/matrix/src/matrix/client/create-client.ts
+var create_client_exports = /* @__PURE__ */ __exportAll({ createMatrixClient: () => createMatrixClient });
+let matrixCreateClientRuntimeDepsPromise;
+async function loadMatrixCreateClientRuntimeDeps() {
+	matrixCreateClientRuntimeDepsPromise ??= Promise.all([import("./sdk-Jhq7mLtD.js").then((n) => n.n), import("./logging-Df7aPD1z.js").then((n) => n.n)]).then(([sdkModule, loggingModule]) => ({
+		MatrixClient: sdkModule.MatrixClient,
+		ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
+	}));
+	return await matrixCreateClientRuntimeDepsPromise;
+}
+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 ? `klaw-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,
+		storagePath: storagePaths?.storagePath,
+		recoveryKeyPath: storagePaths?.recoveryKeyPath,
+		idbSnapshotPath: storagePaths?.idbSnapshotPath,
+		cryptoDatabasePrefix,
+		autoBootstrapCrypto: params.autoBootstrapCrypto,
+		ssrfPolicy: params.ssrfPolicy ?? ssrfPolicyFromDangerouslyAllowPrivateNetwork(params.allowPrivateNetwork),
+		dispatcherPolicy: params.dispatcherPolicy
+	});
+}
+//#endregion
+export { create_client_exports as n, createMatrixClient as t };

package/dist/credentials-B7GsBbgQ.js

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

package/dist/credentials-read-8fE4qoWs.js

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

package/dist/credentials-write.runtime-BibplB4Y.js

@@ -0,0 +1,17 @@
+//#region extensions/matrix/src/matrix/credentials-write.runtime.ts
+let matrixCredentialsRuntimePromise;
+function loadMatrixCredentialsRuntime() {
+	matrixCredentialsRuntimePromise ??= import("./credentials-B7GsBbgQ.js");
+	return matrixCredentialsRuntimePromise;
+}
+async function saveMatrixCredentials(...args) {
+	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
+}
+async function saveBackfilledMatrixDeviceId(...args) {
+	return (await loadMatrixCredentialsRuntime()).saveBackfilledMatrixDeviceId(...args);
+}
+async function touchMatrixCredentials(...args) {
+	return (await loadMatrixCredentialsRuntime()).touchMatrixCredentials(...args);
+}
+//#endregion
+export { saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };

package/dist/crypto-node.runtime-D9qxgRPa.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+//#region extensions/matrix/src/matrix/sdk/crypto-node.runtime.ts
+const require = createRequire(import.meta.url);
+function loadMatrixCryptoNodeBindings() {
+	const { Attachment, EncryptedAttachment } = require("@matrix-org/matrix-sdk-crypto-nodejs");
+	return {
+		Attachment,
+		EncryptedAttachment
+	};
+}
+//#endregion
+export { loadMatrixCryptoNodeBindings };