matrix-nodejs-homeserver 0.0.0-stage → 0.2.0

package/dist/core/threepid.js

@@ -0,0 +1,275 @@
+import { randomString } from "./crypto.js";
+import { MatrixError, errors } from "./errors.js";
+import { toMsisdn } from "./phone.js";
+import { randomInt } from "node:crypto";
+//#region src/core/threepid.ts
+const CLIENT_SECRET_RE = /^[0-9a-zA-Z.=_-]{1,255}$/;
+const EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+const SUBMIT_PATH = "/_matrix/client/unstable/threepid/submit_token";
+const PURPOSE_TEXT = {
+	register: "create your account",
+	password_reset: "reset your password",
+	add_threepid: "add this address to your account"
+};
+function isMedium(m) {
+	return m === "email" || m === "msisdn";
+}
+/** Canonical form of an address: lower-case email, digits-only phone number. */
+function canonicalAddress(medium, address) {
+	if (medium === "email") {
+		const email = address.trim().toLowerCase();
+		return EMAIL_RE.test(email) && email.length <= 320 ? email : null;
+	}
+	const msisdn = address.replace(/^\+/, "");
+	return /^\d{7,15}$/.test(msisdn) ? msisdn : null;
+}
+var ThreepidService = class {
+	hs;
+	constructor(hs) {
+		this.hs = hs;
+	}
+	get options() {
+		return this.hs.config.threepid;
+	}
+	/** Whether this server can validate addresses of `medium` itself. */
+	canValidate(medium) {
+		return medium === "email" ? !!this.options.sendEmail : !!this.options.sendSms;
+	}
+	/** Account changes involving 3PIDs are possible at all (the m.3pid_changes capability). */
+	get enabled() {
+		return this.canValidate("email") || this.canValidate("msisdn");
+	}
+	async userFor(medium, address) {
+		return (await this.hs.db.findOne("user_threepids", [{
+			field: "medium",
+			value: medium
+		}, {
+			field: "address",
+			value: address
+		}]))?.user_id ?? null;
+	}
+	async list(userId) {
+		return (await this.hs.db.findMany("user_threepids", { where: [{
+			field: "user_id",
+			value: userId
+		}] })).map((r) => ({
+			medium: r.medium,
+			address: r.address,
+			validated_at: r.validated_ts,
+			added_at: r.added_ts
+		}));
+	}
+	async add(userId, threepid) {
+		const owner = await this.userFor(threepid.medium, threepid.address);
+		if (owner && owner !== userId) throw new MatrixError(400, "M_THREEPID_IN_USE", "This address is already in use");
+		await this.hs.db.upsert("user_threepids", {
+			user_id: userId,
+			medium: threepid.medium,
+			address: threepid.address,
+			validated_ts: threepid.validatedTs,
+			added_ts: Date.now()
+		});
+	}
+	async remove(userId, medium, address) {
+		return await this.hs.db.delete("user_threepids", [
+			{
+				field: "user_id",
+				value: userId
+			},
+			{
+				field: "medium",
+				value: medium
+			},
+			{
+				field: "address",
+				value: address
+			}
+		]) > 0;
+	}
+	/**
+	* Unbind a 3PID from the identity servers it was bound on through this server (or `idServer`).
+	* Returns "success" if every unbind succeeded, "no-support" otherwise.
+	*/
+	async unbindAll(userId, medium, address, idServer) {
+		const where = [
+			{
+				field: "user_id",
+				value: userId
+			},
+			{
+				field: "medium",
+				value: medium
+			},
+			{
+				field: "address",
+				value: address
+			}
+		];
+		const servers = idServer ? [idServer] : (await this.hs.db.findMany("threepid_bindings", { where })).map((b) => b.id_server);
+		if (servers.length === 0) return "no-support";
+		let result = "success";
+		for (const server of servers) {
+			let ok = false;
+			try {
+				ok = await this.hs.identityServers.unbind(server, userId, medium, address);
+			} catch (err) {
+				this.hs.logger.warn("Unbind from", server, "failed", err);
+			}
+			if (ok) await this.hs.db.delete("threepid_bindings", [...where, {
+				field: "id_server",
+				value: server
+			}]);
+			else result = "no-support";
+		}
+		return result;
+	}
+	/** Remove every 3PID of a (deactivated) account, unbinding them from identity servers. */
+	async removeAll(userId) {
+		let result = "success";
+		const bound = await this.hs.db.findMany("threepid_bindings", { where: [{
+			field: "user_id",
+			value: userId
+		}] });
+		for (const b of bound) if (await this.unbindAll(userId, b.medium, b.address, b.id_server) !== "success") result = "no-support";
+		await this.hs.db.delete("user_threepids", [{
+			field: "user_id",
+			value: userId
+		}]);
+		return bound.length ? result : "no-support";
+	}
+	/**
+	* Start (or continue) validating an address: `POST .../{medium}/requestToken`. Repeating a
+	* request with the same `client_secret`, address and `send_attempt` does not send again.
+	*/
+	async requestToken(purpose, medium, body) {
+		if (!this.enabled) throw errors.threepidDenied();
+		if (!this.canValidate(medium)) throw new MatrixError(400, "M_THREEPID_MEDIUM_NOT_SUPPORTED", `This server cannot validate ${medium === "email" ? "email addresses" : "phone numbers"}`);
+		if (typeof body.client_secret !== "string" || !CLIENT_SECRET_RE.test(body.client_secret)) throw errors.invalidParam("Invalid client_secret");
+		if (!Number.isInteger(body.send_attempt)) throw errors.invalidParam("send_attempt must be an integer");
+		let address;
+		if (medium === "email") {
+			if (typeof body.email !== "string") throw errors.missingParam("Missing email");
+			address = canonicalAddress("email", body.email);
+			if (!address) throw errors.invalidParam("Invalid email address");
+		} else {
+			if (typeof body.country !== "string" || typeof body.phone_number !== "string") throw errors.missingParam("Missing country or phone_number");
+			address = toMsisdn(body.country, body.phone_number);
+			if (!address) throw errors.invalidParam("Invalid phone number");
+		}
+		const owner = await this.userFor(medium, address);
+		if (purpose === "password_reset" && !owner) throw new MatrixError(400, "M_THREEPID_NOT_FOUND", "No account uses this address");
+		if (purpose !== "password_reset" && owner) throw new MatrixError(400, "M_THREEPID_IN_USE", "This address is already in use");
+		const nextLink = typeof body.next_link === "string" ? body.next_link : null;
+		if (nextLink && !/^https?:\/\//i.test(nextLink)) throw errors.invalidParam("next_link must be an http(s) URL");
+		const existing = (await this.hs.db.findMany("threepid_sessions", { where: [{
+			field: "client_secret",
+			value: body.client_secret
+		}] })).find((s) => s.medium === medium && s.address === address && !this.expired(s));
+		let session = existing;
+		if (existing && body.send_attempt <= existing.send_attempt) return this.tokenResponse(existing);
+		if (existing) await this.hs.db.update("threepid_sessions", [{
+			field: "sid",
+			value: existing.sid
+		}], {
+			send_attempt: body.send_attempt,
+			next_link: nextLink
+		});
+		else {
+			session = {
+				sid: randomString(24),
+				client_secret: body.client_secret,
+				medium,
+				address,
+				send_attempt: body.send_attempt,
+				next_link: nextLink,
+				token: medium === "email" ? randomString(32) : String(randomInt(0, 1e6)).padStart(6, "0"),
+				created_ts: Date.now(),
+				validated_ts: null
+			};
+			await this.hs.db.create("threepid_sessions", session);
+		}
+		await this.send(purpose, session);
+		return this.tokenResponse(session);
+	}
+	tokenResponse(session) {
+		const out = { sid: session.sid };
+		if (this.hs.config.publicBaseUrl) out.submit_url = `${this.hs.config.publicBaseUrl.replace(/\/$/, "")}${SUBMIT_PATH}`;
+		if (session.medium === "msisdn") Object.assign(out, {
+			msisdn: session.address,
+			intl_fmt: `+${session.address}`
+		});
+		return out;
+	}
+	async send(purpose, session) {
+		const what = PURPOSE_TEXT[purpose];
+		try {
+			if (session.medium === "email") {
+				const link = `${this.hs.config.publicBaseUrl?.replace(/\/$/, "") ?? ""}${SUBMIT_PATH}?${new URLSearchParams({
+					sid: session.sid,
+					client_secret: session.client_secret,
+					token: session.token
+				})}`;
+				await this.options.sendEmail({
+					to: session.address,
+					purpose,
+					token: session.token,
+					link,
+					subject: `Confirm your email address for ${this.hs.serverName}`,
+					text: `To ${what} on ${this.hs.serverName}, open this link:\n\n${link}\n\nIf you did not request this, ignore this message.`,
+					html: `<p>To ${what} on ${escapeHtml(this.hs.serverName)}, <a href="${escapeHtml(link)}">confirm your email address</a>.</p><p>If you did not request this, ignore this message.</p>`
+				});
+			} else await this.options.sendSms({
+				to: session.address,
+				purpose,
+				token: session.token,
+				text: `Your ${this.hs.serverName} code to ${what}: ${session.token}`
+			});
+		} catch (err) {
+			this.hs.logger.warn("Sending a 3PID validation message failed", err);
+			throw new MatrixError(500, "M_UNKNOWN", "Could not send the validation message");
+		}
+	}
+	expired(session) {
+		return session.created_ts + (this.options.sessionLifetimeMs ?? 864e5) < Date.now();
+	}
+	/** Validate a session with the token the user received. Returns the session's `next_link`. */
+	async submitToken(sid, clientSecret, token) {
+		const session = await this.hs.db.findOne("threepid_sessions", [{
+			field: "sid",
+			value: sid
+		}]);
+		if (!session || session.client_secret !== clientSecret || this.expired(session)) throw new MatrixError(400, "M_NO_VALID_SESSION", "Unknown or expired session");
+		if (session.token !== token.trim()) throw new MatrixError(400, "M_INVALID_PARAM", "Invalid token");
+		if (session.validated_ts === null) await this.hs.db.update("threepid_sessions", [{
+			field: "sid",
+			value: sid
+		}], { validated_ts: Date.now() });
+		return session.next_link;
+	}
+	/** The address a client proved ownership of, given its `threepid_creds`. */
+	async validated(creds) {
+		const c = creds;
+		if (!c || typeof c.sid !== "string" || typeof c.client_secret !== "string") return null;
+		const session = await this.hs.db.findOne("threepid_sessions", [{
+			field: "sid",
+			value: c.sid
+		}]);
+		if (!session || session.client_secret !== c.client_secret || session.validated_ts === null || this.expired(session)) return null;
+		return {
+			medium: session.medium,
+			address: session.address,
+			validatedTs: session.validated_ts
+		};
+	}
+};
+function escapeHtml(s) {
+	return s.replace(/[&<>"']/g, (c) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	})[c]);
+}
+//#endregion
+export { ThreepidService, canonicalAddress, isMedium };

package/dist/core/typing.d.ts

@@ -0,0 +1,16 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/core/typing.d.ts
+/**
+ * Ephemeral typing notifications. Changes are replicated to every instance via the
+ * cluster adapter; each instance keeps the typing set in memory.
+ */
+export declare class TypingService {
+  private hs;
+  private rooms;
+  constructor(hs: Homeserver);
+  setTyping(roomId: string, userId: string, typing: boolean, timeoutMs?: number): Promise<void>;
+  private apply;
+  /** Typing users in a room if they changed after `since` (or always when `since` is null). */
+  typingSince(roomId: string, since: number | null): string[] | null;
+}
+//#endregion

package/dist/core/typing.js

@@ -0,0 +1,60 @@
+//#region src/core/typing.ts
+/**
+* Ephemeral typing notifications. Changes are replicated to every instance via the
+* cluster adapter; each instance keeps the typing set in memory.
+*/
+var TypingService = class {
+	hs;
+	rooms = /* @__PURE__ */ new Map();
+	constructor(hs) {
+		this.hs = hs;
+		hs.cluster.subscribe("typing", (msg) => this.apply(msg));
+	}
+	async setTyping(roomId, userId, typing, timeoutMs = 3e4) {
+		const wasTyping = !!this.rooms.get(roomId)?.users.has(userId);
+		if (!typing && !wasTyping) return;
+		const stream = await this.hs.streams.write(async (id) => id);
+		const msg = {
+			roomId,
+			userId,
+			typing,
+			timeoutMs: Math.min(Math.max(timeoutMs, 1e3), 12e4),
+			stream
+		};
+		this.apply(msg);
+		await this.hs.cluster.publish("typing", msg);
+		this.hs.notifier.notify(await this.hs.rooms.joinedMembers(roomId));
+		if (this.hs.isLocalUser(userId) && typing !== wasTyping || typing && this.hs.isLocalUser(userId)) await this.hs.federation.onTyping(roomId, userId, typing).catch(() => {});
+	}
+	apply(msg) {
+		let room = this.rooms.get(msg.roomId);
+		if (!room) this.rooms.set(msg.roomId, room = {
+			users: /* @__PURE__ */ new Map(),
+			stream: 0
+		});
+		const existing = room.users.get(msg.userId);
+		if (existing) clearTimeout(existing);
+		if (msg.typing) {
+			const timer = setTimeout(() => {
+				const r = this.rooms.get(msg.roomId);
+				if (r?.users.get(msg.userId) === timer) {
+					r.users.delete(msg.userId);
+					r.stream = Math.max(r.stream, msg.stream) + .5;
+					this.hs.rooms.joinedMembers(msg.roomId).then((m) => this.hs.notifier.notify(m)).catch(() => {});
+				}
+			}, msg.timeoutMs);
+			timer.unref?.();
+			room.users.set(msg.userId, timer);
+		} else room.users.delete(msg.userId);
+		room.stream = Math.max(room.stream, msg.stream);
+	}
+	/** Typing users in a room if they changed after `since` (or always when `since` is null). */
+	typingSince(roomId, since) {
+		const room = this.rooms.get(roomId);
+		if (!room) return since === null ? [] : null;
+		if (since !== null && room.stream <= since) return null;
+		return [...room.users.keys()];
+	}
+};
+//#endregion
+export { TypingService };

package/dist/federation/client.d.ts

@@ -0,0 +1,51 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/federation/client.d.ts
+interface Resolved {
+  /** Host to connect to (IP or hostname). */
+  host: string;
+  port: number;
+  /** Value for the Host header and TLS SNI/certificate name. */
+  hostHeader: string;
+  tlsName: string;
+  expires: number;
+}
+export interface FederationRequestOptions {
+  body?: unknown;
+  query?: Record<string, string | string[] | undefined>;
+  /** Sign the request with X-Matrix auth. Default: true. */
+  signed?: boolean;
+  timeoutMs?: number;
+}
+export interface RawResponse {
+  status: number;
+  headers: Record<string, string | string[] | undefined>;
+  body: Buffer;
+}
+/** Signs and sends server-server requests, implementing Matrix server discovery. */
+export declare class FederationClient {
+  private hs;
+  private resolved;
+  /** One connection pool per destination, so a dead peer's sockets can be dropped without affecting others. */
+  private agents;
+  private rejectUnauthorized;
+  constructor(hs: Homeserver, opts?: {
+    rejectUnauthorized?: boolean;
+  });
+  private agentFor;
+  /** Drop pooled connections to a destination (after errors, the peer may have restarted). */
+  resetConnections(destination: string): void;
+  /** Build the X-Matrix Authorization header value for a request. */
+  authHeader(destination: string, method: string, uri: string, content?: unknown): string;
+  resolve(serverName: string): Promise<Resolved>;
+  private discover;
+  private wellKnown;
+  private srv;
+  private raw;
+  private pathWithQuery;
+  /** Send a request and return the raw response (used for media). */
+  requestRaw(destination: string, method: string, path: string, opts?: FederationRequestOptions): Promise<RawResponse>;
+  /** Send a request and parse the JSON response; non-2xx responses throw a MatrixError. */
+  request(destination: string, method: string, path: string, opts?: FederationRequestOptions): Promise<any>;
+}
+//#endregion
+export {};

package/dist/federation/client.js

@@ -0,0 +1,278 @@
+import { canonicalJson } from "../core/json.js";
+import { unpaddedBase64 } from "../core/crypto.js";
+import { MatrixError } from "../core/errors.js";
+import { sign } from "node:crypto";
+import { resolveSrv } from "node:dns/promises";
+import { Agent, request } from "node:https";
+import { isIP } from "node:net";
+//#region src/federation/client.ts
+function splitHostPort(name) {
+	const ipv6 = /^\[([^\]]+)\](?::(\d+))?$/.exec(name);
+	if (ipv6) return {
+		host: ipv6[1],
+		port: ipv6[2] ? Number(ipv6[2]) : null
+	};
+	const idx = name.lastIndexOf(":");
+	if (idx > 0 && /^\d+$/.test(name.slice(idx + 1))) return {
+		host: name.slice(0, idx),
+		port: Number(name.slice(idx + 1))
+	};
+	return {
+		host: name,
+		port: null
+	};
+}
+/** Signs and sends server-server requests, implementing Matrix server discovery. */
+var FederationClient = class {
+	hs;
+	resolved = /* @__PURE__ */ new Map();
+	/** One connection pool per destination, so a dead peer's sockets can be dropped without affecting others. */
+	agents = /* @__PURE__ */ new Map();
+	rejectUnauthorized;
+	constructor(hs, opts = {}) {
+		this.hs = hs;
+		this.rejectUnauthorized = opts.rejectUnauthorized ?? true;
+	}
+	agentFor(key) {
+		let agent = this.agents.get(key);
+		if (!agent) {
+			agent = new Agent({
+				keepAlive: true,
+				maxSockets: 16,
+				rejectUnauthorized: this.rejectUnauthorized
+			});
+			this.agents.set(key, agent);
+		}
+		return agent;
+	}
+	/** Drop pooled connections to a destination (after errors, the peer may have restarted). */
+	resetConnections(destination) {
+		const agent = this.agents.get(destination);
+		if (agent) {
+			agent.destroy();
+			this.agents.delete(destination);
+		}
+		this.resolved.delete(destination);
+	}
+	/** Build the X-Matrix Authorization header value for a request. */
+	authHeader(destination, method, uri, content) {
+		const key = this.hs.signingKey;
+		const toSign = {
+			method,
+			uri,
+			origin: this.hs.serverName,
+			destination
+		};
+		if (content !== void 0) toSign.content = content;
+		const sig = unpaddedBase64(sign(null, Buffer.from(canonicalJson(toSign)), key.privateKey));
+		return `X-Matrix origin="${this.hs.serverName}",destination="${destination}",key="ed25519:${key.keyId}",sig="${sig}"`;
+	}
+	async resolve(serverName) {
+		const cached = this.resolved.get(serverName);
+		if (cached && cached.expires > Date.now()) return cached;
+		const r = await this.discover(serverName);
+		this.resolved.set(serverName, r);
+		return r;
+	}
+	async discover(serverName) {
+		const day = Date.now() + 864e5;
+		const { host, port } = splitHostPort(serverName);
+		if (isIP(host)) return {
+			host,
+			port: port ?? 8448,
+			hostHeader: serverName,
+			tlsName: host,
+			expires: day
+		};
+		if (port !== null) return {
+			host,
+			port,
+			hostHeader: serverName,
+			tlsName: host,
+			expires: day
+		};
+		const delegated = await this.wellKnown(host);
+		if (delegated) {
+			const d = splitHostPort(delegated);
+			if (isIP(d.host)) return {
+				host: d.host,
+				port: d.port ?? 8448,
+				hostHeader: delegated,
+				tlsName: d.host,
+				expires: day
+			};
+			if (d.port !== null) return {
+				host: d.host,
+				port: d.port,
+				hostHeader: delegated,
+				tlsName: d.host,
+				expires: day
+			};
+			const srv = await this.srv(d.host);
+			if (srv) return {
+				...srv,
+				hostHeader: d.host,
+				tlsName: d.host,
+				expires: day
+			};
+			return {
+				host: d.host,
+				port: 8448,
+				hostHeader: d.host,
+				tlsName: d.host,
+				expires: day
+			};
+		}
+		const srv = await this.srv(host);
+		if (srv) return {
+			...srv,
+			hostHeader: host,
+			tlsName: host,
+			expires: Date.now() + 36e5
+		};
+		return {
+			host,
+			port: 8448,
+			hostHeader: host,
+			tlsName: host,
+			expires: Date.now() + 36e5
+		};
+	}
+	async wellKnown(host) {
+		try {
+			const res = await this.raw({
+				host,
+				port: 443,
+				hostHeader: host,
+				tlsName: host,
+				expires: 0
+			}, "GET", "/.well-known/matrix/server", void 0, {}, 5e3);
+			if (res.status !== 200) return null;
+			const body = JSON.parse(res.body.toString("utf8"));
+			return typeof body["m.server"] === "string" && body["m.server"] ? body["m.server"] : null;
+		} catch {
+			return null;
+		}
+	}
+	async srv(host) {
+		for (const name of [`_matrix-fed._tcp.${host}`, `_matrix._tcp.${host}`]) try {
+			const records = await resolveSrv(name);
+			if (records.length) {
+				records.sort((a, b) => a.priority - b.priority || b.weight - a.weight);
+				return {
+					host: records[0].name,
+					port: records[0].port
+				};
+			}
+		} catch {}
+		return null;
+	}
+	raw(target, method, pathWithQuery, body, headers, timeoutMs, poolKey = target.hostHeader) {
+		return new Promise((resolve, reject) => {
+			let connectTimer = null;
+			const req = request({
+				host: target.host,
+				port: target.port,
+				method,
+				path: pathWithQuery,
+				servername: isIP(target.tlsName) ? void 0 : target.tlsName,
+				agent: this.agentFor(poolKey),
+				headers: {
+					host: target.hostHeader,
+					...headers,
+					...body ? { "content-length": String(body.length) } : {}
+				},
+				timeout: timeoutMs
+			}, (res) => {
+				const chunks = [];
+				let size = 0;
+				res.on("data", (c) => {
+					size += c.length;
+					if (size > 104857600) {
+						req.destroy(/* @__PURE__ */ new Error("Response too large"));
+						return;
+					}
+					chunks.push(c);
+				});
+				res.on("end", () => resolve({
+					status: res.statusCode ?? 0,
+					headers: res.headers,
+					body: Buffer.concat(chunks)
+				}));
+				res.on("error", reject);
+			});
+			req.on("socket", (socket) => {
+				if (socket.connecting) {
+					connectTimer = setTimeout(() => req.destroy(/* @__PURE__ */ new Error("Connection timed out")), Math.min(5e3, timeoutMs));
+					socket.once("connect", () => {
+						if (connectTimer) clearTimeout(connectTimer);
+					});
+					socket.once("secureConnect", () => {
+						if (connectTimer) clearTimeout(connectTimer);
+					});
+				}
+			});
+			req.on("timeout", () => req.destroy(/* @__PURE__ */ new Error("Federation request timed out")));
+			req.on("error", (err) => {
+				if (connectTimer) clearTimeout(connectTimer);
+				reject(err);
+			});
+			req.on("close", () => {
+				if (connectTimer) clearTimeout(connectTimer);
+			});
+			if (body) req.write(body);
+			req.end();
+		});
+	}
+	pathWithQuery(path, query) {
+		const params = new URLSearchParams();
+		for (const [k, v] of Object.entries(query ?? {})) {
+			if (v === void 0) continue;
+			for (const item of Array.isArray(v) ? v : [v]) params.append(k, item);
+		}
+		const qs = params.toString();
+		return qs ? `${path}?${qs}` : path;
+	}
+	/** Send a request and return the raw response (used for media). */
+	async requestRaw(destination, method, path, opts = {}) {
+		if (destination === this.hs.serverName) throw new Error("Refusing to send a federation request to ourselves");
+		const uri = this.pathWithQuery(path, opts.query);
+		const body = opts.body === void 0 ? void 0 : Buffer.from(JSON.stringify(opts.body));
+		const headers = { accept: "application/json" };
+		if (body) headers["content-type"] = "application/json";
+		if (opts.signed !== false) headers.authorization = this.authHeader(destination, method, uri, opts.body);
+		const target = await this.resolve(destination);
+		try {
+			return await this.raw(target, method, uri, body, headers, opts.timeoutMs ?? 3e4, destination);
+		} catch (err) {
+			this.resetConnections(destination);
+			throw err;
+		}
+	}
+	/** Send a request and parse the JSON response; non-2xx responses throw a MatrixError. */
+	async request(destination, method, path, opts = {}) {
+		const res = await this.requestRaw(destination, method, path, opts);
+		let json = {};
+		try {
+			json = res.body.length ? JSON.parse(res.body.toString("utf8")) : {};
+		} catch {}
+		if (res.status < 200 || res.status >= 300) throw new MatrixError(res.status === 404 ? 404 : res.status >= 500 ? 502 : res.status, typeof json.errcode === "string" ? json.errcode : "M_UNKNOWN", typeof json.error === "string" ? json.error : `Remote server returned ${res.status}`);
+		return json;
+	}
+};
+/** Parse an `Authorization: X-Matrix ...` header. */
+function parseXMatrix(header) {
+	const m = /^X-Matrix\s+(.*)$/i.exec(header.trim());
+	if (!m) return null;
+	const params = {};
+	for (const part of m[1].matchAll(/([A-Za-z]+)=(?:"((?:[^"\\]|\\.)*)"|([^,\s]*))/g)) params[part[1].toLowerCase()] = (part[2] ?? part[3] ?? "").replace(/\\(.)/g, "$1");
+	if (!params.origin || !params.key || !params.sig) return null;
+	return {
+		origin: params.origin,
+		destination: params.destination,
+		key: params.key,
+		sig: params.sig
+	};
+}
+//#endregion
+export { FederationClient, parseXMatrix };