matrix-nodejs-homeserver 0.0.0-stage → 0.2.0

package/dist/core/partialstate.js

@@ -0,0 +1,197 @@
+import { eventIdOf, roomVersionFeatures, stateKey } from "./events.js";
+import { EventEmitter } from "node:events";
+//#region src/core/partialstate.ts
+const RESYNC_CLAIM_MS = 6e5;
+var PartialStateService = class {
+	hs;
+	partial = /* @__PURE__ */ new Map();
+	completed = new EventEmitter();
+	running = /* @__PURE__ */ new Set();
+	completedStreams = /* @__PURE__ */ new Map();
+	stopped = false;
+	constructor(hs) {
+		this.hs = hs;
+		this.completed.setMaxListeners(0);
+		hs.cluster.subscribe("partial-state", (msg) => {
+			if (typeof msg?.roomId !== "string") return;
+			this.partial.delete(msg.roomId);
+			this.completedStreams.delete(msg.roomId);
+			this.completed.emit(msg.roomId);
+		});
+	}
+	async isPartial(roomId) {
+		const cached = this.partial.get(roomId);
+		if (cached !== void 0) return cached;
+		const row = await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]);
+		const partial = !!row && row.completed_stream === null;
+		if (this.partial.size > 1e4) this.partial.clear();
+		this.partial.set(roomId, partial);
+		return partial;
+	}
+	/** Servers the joining server told us were in the room (used as destinations and resync sources). */
+	async servers(roomId) {
+		if (!await this.isPartial(roomId)) return [];
+		const row = await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]);
+		return Array.isArray(row?.servers) ? row.servers : [];
+	}
+	/** Stream position at which the room got its full state (null if it never was partial). */
+	async completedAt(roomId) {
+		if (this.partial.get(roomId) === false && this.completedStreams.has(roomId)) return this.completedStreams.get(roomId);
+		const at = (await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]))?.completed_stream ?? null;
+		if (this.completedStreams.size > 1e4) this.completedStreams.clear();
+		this.completedStreams.set(roomId, at);
+		return at;
+	}
+	/**
+	* A device list update for a user we do not share a (known) room with: if they may be a member
+	* of a partial-state room hosted by the sender, remember them for when the state is complete.
+	*/
+	async notePendingDeviceUpdate(userId, origin) {
+		const rows = (await this.hs.db.findMany("partial_state_rooms", {})).filter((r) => r.completed_stream === null && (r.servers ?? []).includes(origin));
+		for (const row of rows) {
+			const pending = Array.isArray(row.pending_device_users) ? row.pending_device_users : [];
+			if (pending.includes(userId)) continue;
+			await this.hs.db.update("partial_state_rooms", [{
+				field: "room_id",
+				value: row.room_id
+			}], { pending_device_users: [...pending, userId] });
+		}
+	}
+	async markPartial(roomId, joinEventId, origin, servers) {
+		await this.hs.db.upsert("partial_state_rooms", {
+			room_id: roomId,
+			join_event_id: joinEventId,
+			origin,
+			servers: [.../* @__PURE__ */ new Set([origin, ...servers])],
+			created_ts: Date.now(),
+			completed_stream: null,
+			pending_device_users: []
+		});
+		this.partial.set(roomId, true);
+		this.completedStreams.delete(roomId);
+		this.hs.cluster.publish("partial-state", { roomId }).catch(() => {});
+		this.startResync(roomId);
+	}
+	/** Resolve once the room has its full state (or the signal aborts / the server closes). */
+	async waitForFullState(roomId, signal) {
+		if (!await this.isPartial(roomId)) return;
+		await new Promise((resolve) => {
+			const done = () => {
+				clearInterval(poll);
+				this.completed.off(roomId, check);
+				signal?.removeEventListener("abort", done);
+				this.hs.off?.("close", done);
+				resolve();
+			};
+			const check = () => void this.isPartial(roomId).then((p) => {
+				if (!p) done();
+			}).catch(() => {});
+			this.completed.on(roomId, check);
+			signal?.addEventListener("abort", done);
+			this.hs.once?.("close", done);
+			const poll = setInterval(() => {
+				this.partial.delete(roomId);
+				check();
+			}, 5e3);
+			poll.unref?.();
+		});
+	}
+	/** Resume resyncs of rooms left partial (e.g. by a restart). */
+	async resume() {
+		const rows = (await this.hs.db.findMany("partial_state_rooms", {})).filter((r) => r.completed_stream === null);
+		this.hs.logger.debug("Resuming partial state resyncs", rows.map((r) => r.room_id));
+		for (const row of rows) this.startResync(row.room_id);
+	}
+	stop() {
+		this.stopped = true;
+	}
+	startResync(roomId) {
+		if (this.running.has(roomId)) return;
+		this.running.add(roomId);
+		this.resync(roomId).catch((err) => this.hs.logger.warn("Partial state resync failed", roomId, err)).finally(() => this.running.delete(roomId));
+	}
+	async resync(roomId) {
+		const claim = `partial-resync:${roomId}`;
+		if (!await this.hs.cluster.setIfAbsent(claim, this.hs.instanceId, RESYNC_CLAIM_MS)) {
+			this.hs.logger.debug("Partial state resync of", roomId, "is claimed elsewhere");
+			return;
+		}
+		this.hs.logger.debug("Partial state resync of", roomId, "started");
+		try {
+			let delay = 1e3;
+			for (let attempt = 0; !this.stopped && !this.hs.isClosed; attempt++) {
+				const row = await this.hs.db.findOne("partial_state_rooms", [{
+					field: "room_id",
+					value: roomId
+				}]);
+				if (!row || row.completed_stream !== null) return;
+				if (await this.tryResync(roomId, row)) return;
+				if (this.stopped || this.hs.isClosed) return;
+				if (!await this.hs.rooms.serverIsJoined(roomId)) {
+					await this.finish(roomId);
+					return;
+				}
+				await new Promise((r) => setTimeout(r, delay).unref?.());
+				delay = Math.min(delay * 2, 6e4);
+				await this.hs.cluster.set(claim, this.hs.instanceId, RESYNC_CLAIM_MS);
+			}
+		} finally {
+			await this.hs.cluster.delete(claim).catch(() => {});
+		}
+	}
+	async tryResync(roomId, row) {
+		const version = await this.hs.rooms.roomVersion(roomId);
+		const join = await this.hs.rooms.getEvent(row.join_event_id);
+		if (!version || !join) {
+			await this.finish(roomId);
+			return true;
+		}
+		const prevIds = (join.pdu.prev_events ?? []).map(eventIdOf);
+		const servers = [.../* @__PURE__ */ new Set([row.origin, ...row.servers ?? []])].filter((s) => s && s !== this.hs.serverName);
+		for (const server of servers) {
+			if (this.stopped || this.hs.isClosed) return true;
+			try {
+				const fullBefore = await this.hs.federation.stateFromPrevs(server, roomId, version, prevIds, { remote: true });
+				if (this.stopped || this.hs.isClosed) return true;
+				if (!fullBefore[stateKey("m.room.create", "")] && !roomVersionFeatures(version).v12) throw new Error("Resynced state lacks the create event");
+				const notified = /* @__PURE__ */ new Set([...row.servers ?? [], ...this.hs.federation.serversInRoom(await this.hs.rooms.currentState(roomId), false)]);
+				const missed = await this.hs.rooms.withLock(roomId, () => this.hs.rooms.completePartialState(roomId, version, row.join_event_id, fullBefore, notified));
+				await this.finish(roomId);
+				if (missed.length) for (const userId of (await this.hs.rooms.joinedMembers(roomId)).filter((u) => this.hs.isLocalUser(u))) await this.hs.federation.onDeviceListChange(userId, void 0, new Set(missed)).catch(() => {});
+				return true;
+			} catch (err) {
+				this.hs.logger.debug("Partial state resync from", server, "failed", err);
+			}
+		}
+		return false;
+	}
+	async finish(roomId) {
+		await this.hs.streams.write((stream) => this.hs.db.update("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}], { completed_stream: stream }));
+		this.partial.set(roomId, false);
+		this.completedStreams.delete(roomId);
+		this.completed.emit(roomId);
+		this.hs.cluster.publish("partial-state", { roomId }).catch(() => {});
+		const members = await this.hs.rooms.joinedMembers(roomId);
+		this.hs.notifier.notify(members.filter((u) => this.hs.isLocalUser(u)));
+		const row = await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]);
+		const pending = Array.isArray(row?.pending_device_users) ? row.pending_device_users : [];
+		await this.hs.keys.onPartialStateComplete(roomId, pending).catch((err) => this.hs.logger.warn("Device list refresh failed", err));
+	}
+};
+//#endregion
+export { PartialStateService };

package/dist/core/phone.js

@@ -0,0 +1,268 @@
+//#region src/core/phone.ts
+/** Country calling codes by ISO 3166-1 alpha-2 code. */
+const CALLING_CODES = {
+	AD: "376",
+	AE: "971",
+	AF: "93",
+	AG: "1",
+	AI: "1",
+	AL: "355",
+	AM: "374",
+	AO: "244",
+	AR: "54",
+	AS: "1",
+	AT: "43",
+	AU: "61",
+	AW: "297",
+	AX: "358",
+	AZ: "994",
+	BA: "387",
+	BB: "1",
+	BD: "880",
+	BE: "32",
+	BF: "226",
+	BG: "359",
+	BH: "973",
+	BI: "257",
+	BJ: "229",
+	BL: "590",
+	BM: "1",
+	BN: "673",
+	BO: "591",
+	BQ: "599",
+	BR: "55",
+	BS: "1",
+	BT: "975",
+	BW: "267",
+	BY: "375",
+	BZ: "501",
+	CA: "1",
+	CC: "61",
+	CD: "243",
+	CF: "236",
+	CG: "242",
+	CH: "41",
+	CI: "225",
+	CK: "682",
+	CL: "56",
+	CM: "237",
+	CN: "86",
+	CO: "57",
+	CR: "506",
+	CU: "53",
+	CV: "238",
+	CW: "599",
+	CX: "61",
+	CY: "357",
+	CZ: "420",
+	DE: "49",
+	DJ: "253",
+	DK: "45",
+	DM: "1",
+	DO: "1",
+	DZ: "213",
+	EC: "593",
+	EE: "372",
+	EG: "20",
+	EH: "212",
+	ER: "291",
+	ES: "34",
+	ET: "251",
+	FI: "358",
+	FJ: "679",
+	FK: "500",
+	FM: "691",
+	FO: "298",
+	FR: "33",
+	GA: "241",
+	GB: "44",
+	GD: "1",
+	GE: "995",
+	GF: "594",
+	GG: "44",
+	GH: "233",
+	GI: "350",
+	GL: "299",
+	GM: "220",
+	GN: "224",
+	GP: "590",
+	GQ: "240",
+	GR: "30",
+	GT: "502",
+	GU: "1",
+	GW: "245",
+	GY: "592",
+	HK: "852",
+	HN: "504",
+	HR: "385",
+	HT: "509",
+	HU: "36",
+	ID: "62",
+	IE: "353",
+	IL: "972",
+	IM: "44",
+	IN: "91",
+	IO: "246",
+	IQ: "964",
+	IR: "98",
+	IS: "354",
+	IT: "39",
+	JE: "44",
+	JM: "1",
+	JO: "962",
+	JP: "81",
+	KE: "254",
+	KG: "996",
+	KH: "855",
+	KI: "686",
+	KM: "269",
+	KN: "1",
+	KP: "850",
+	KR: "82",
+	KW: "965",
+	KY: "1",
+	KZ: "7",
+	LA: "856",
+	LB: "961",
+	LC: "1",
+	LI: "423",
+	LK: "94",
+	LR: "231",
+	LS: "266",
+	LT: "370",
+	LU: "352",
+	LV: "371",
+	LY: "218",
+	MA: "212",
+	MC: "377",
+	MD: "373",
+	ME: "382",
+	MF: "590",
+	MG: "261",
+	MH: "692",
+	MK: "389",
+	ML: "223",
+	MM: "95",
+	MN: "976",
+	MO: "853",
+	MP: "1",
+	MQ: "596",
+	MR: "222",
+	MS: "1",
+	MT: "356",
+	MU: "230",
+	MV: "960",
+	MW: "265",
+	MX: "52",
+	MY: "60",
+	MZ: "258",
+	NA: "264",
+	NC: "687",
+	NE: "227",
+	NF: "672",
+	NG: "234",
+	NI: "505",
+	NL: "31",
+	NO: "47",
+	NP: "977",
+	NR: "674",
+	NU: "683",
+	NZ: "64",
+	OM: "968",
+	PA: "507",
+	PE: "51",
+	PF: "689",
+	PG: "675",
+	PH: "63",
+	PK: "92",
+	PL: "48",
+	PM: "508",
+	PR: "1",
+	PS: "970",
+	PT: "351",
+	PW: "680",
+	PY: "595",
+	QA: "974",
+	RE: "262",
+	RO: "40",
+	RS: "381",
+	RU: "7",
+	RW: "250",
+	SA: "966",
+	SB: "677",
+	SC: "248",
+	SD: "249",
+	SE: "46",
+	SG: "65",
+	SH: "290",
+	SI: "386",
+	SJ: "47",
+	SK: "421",
+	SL: "232",
+	SM: "378",
+	SN: "221",
+	SO: "252",
+	SR: "597",
+	SS: "211",
+	ST: "239",
+	SV: "503",
+	SX: "1",
+	SY: "963",
+	SZ: "268",
+	TC: "1",
+	TD: "235",
+	TG: "228",
+	TH: "66",
+	TJ: "992",
+	TK: "690",
+	TL: "670",
+	TM: "993",
+	TN: "216",
+	TO: "676",
+	TR: "90",
+	TT: "1",
+	TV: "688",
+	TW: "886",
+	TZ: "255",
+	UA: "380",
+	UG: "256",
+	US: "1",
+	UY: "598",
+	UZ: "998",
+	VA: "39",
+	VC: "1",
+	VE: "58",
+	VG: "1",
+	VI: "1",
+	VN: "84",
+	VU: "678",
+	WF: "681",
+	WS: "685",
+	XK: "383",
+	YE: "967",
+	YT: "262",
+	ZA: "27",
+	ZM: "260",
+	ZW: "263"
+};
+/**
+* The MSISDN for a phone number entered in a country (`country` is an ISO 3166-1 alpha-2 code).
+* Numbers given in international form ("+48 ...", "0048 ...") keep their own country code.
+* Returns null for numbers that cannot be valid.
+*/
+function toMsisdn(country, phoneNumber) {
+	let digits = phoneNumber.trim().replace(/[\s().\-/]/g, "");
+	if (!/^\+?\d+$/.test(digits)) return null;
+	let msisdn;
+	if (digits.startsWith("+")) msisdn = digits.slice(1);
+	else if (digits.startsWith("00")) msisdn = digits.slice(2);
+	else {
+		const code = CALLING_CODES[country.toUpperCase()];
+		if (!code) return null;
+		if (digits.startsWith("0") && code !== "39") digits = digits.replace(/^0+/, "");
+		msisdn = code + digits;
+	}
+	return msisdn.length >= 7 && msisdn.length <= 15 ? msisdn : null;
+}
+//#endregion
+export { toMsisdn };

package/dist/core/policy.d.ts

@@ -0,0 +1,29 @@
+import { PDU } from "./events.js";
+import { Homeserver } from "../homeserver.js";
+import { KeyObject } from "node:crypto";
+//#region src/core/policy.d.ts
+interface RoomPolicy {
+  via: string;
+  key: KeyObject;
+}
+export declare class PolicyServers {
+  private readonly hs;
+  constructor(hs: Homeserver);
+  /** The room's policy server, if the room uses one (valid `m.room.policy` and a joined user on `via`). */
+  policyOf(roomId: string): Promise<RoomPolicy | null>;
+  /** The policy state event itself is never sent to the policy server. */
+  private exempt;
+  private validSignature;
+  /** Ask the policy server to sign `pdu`; adds the signature to it. Throws the server's error. */
+  private requestSignature;
+  /**
+   * Before a local event is sent: get the policy server's signature, or refuse the event with the
+   * policy server's error. If the policy server cannot be reached the event is sent unsigned (other
+   * servers may then soft-fail it), so an unavailable policy server does not lock up the room.
+   */
+  signLocal(roomId: string, version: string, pdu: PDU): Promise<void>;
+  /** Whether a remote event is recommended for inclusion (otherwise it is soft-failed). */
+  recommended(roomId: string, version: string, pdu: PDU): Promise<boolean>;
+}
+//#endregion
+export {};

package/dist/core/policy.js

@@ -0,0 +1,96 @@
+import { publicKeyFromBase64, verifyJsonSignature } from "./crypto.js";
+import { redact } from "./events.js";
+import { MatrixError } from "./errors.js";
+import { getState } from "./authrules.js";
+import { domainOf } from "../federation/index.js";
+//#region src/core/policy.ts
+const KEY_ID = "ed25519:policy_server";
+var PolicyServers = class {
+	hs;
+	constructor(hs) {
+		this.hs = hs;
+	}
+	/** The room's policy server, if the room uses one (valid `m.room.policy` and a joined user on `via`). */
+	async policyOf(roomId) {
+		const state = await this.hs.rooms.currentState(roomId);
+		const content = getState(state, "m.room.policy", "")?.content;
+		const via = content?.via;
+		const ed25519 = content?.public_keys?.ed25519;
+		if (typeof via !== "string" || typeof ed25519 !== "string") return null;
+		let key;
+		try {
+			key = publicKeyFromBase64(ed25519);
+		} catch {
+			return null;
+		}
+		for (const ev of state.values()) if (ev.type === "m.room.member" && ev.content?.membership === "join" && typeof ev.state_key === "string" && domainOf(ev.state_key) === via) return {
+			via,
+			key
+		};
+		return null;
+	}
+	/** The policy state event itself is never sent to the policy server. */
+	exempt(pdu) {
+		return pdu.type === "m.room.policy" && pdu.state_key === "";
+	}
+	validSignature(pdu, version, policy) {
+		const wire = this.hs.federation.toFederationPdu(pdu, version);
+		return verifyJsonSignature(redact(wire, version), policy.via, KEY_ID, policy.key);
+	}
+	/** Ask the policy server to sign `pdu`; adds the signature to it. Throws the server's error. */
+	async requestSignature(pdu, version, policy) {
+		const sig = (await this.hs.federation.client.request(policy.via, "POST", "/_matrix/policy/v1/sign", {
+			body: this.hs.federation.toFederationPdu(pdu, version),
+			timeoutMs: 1e4
+		}))?.[policy.via]?.[KEY_ID];
+		if (typeof sig !== "string") throw new MatrixError(403, "M_FORBIDDEN", "The policy server did not sign the event");
+		pdu.signatures = {
+			...pdu.signatures,
+			[policy.via]: {
+				...pdu.signatures?.[policy.via],
+				[KEY_ID]: sig
+			}
+		};
+	}
+	/**
+	* Before a local event is sent: get the policy server's signature, or refuse the event with the
+	* policy server's error. If the policy server cannot be reached the event is sent unsigned (other
+	* servers may then soft-fail it), so an unavailable policy server does not lock up the room.
+	*/
+	async signLocal(roomId, version, pdu) {
+		if (this.exempt(pdu) || !this.hs.federation.enabled) return;
+		const policy = await this.policyOf(roomId);
+		if (!policy) return;
+		if (policy.via === this.hs.serverName) {
+			this.hs.logger.warn("Room", roomId, "names this server as its policy server, which it does not implement");
+			return;
+		}
+		try {
+			await this.requestSignature(pdu, version, policy);
+		} catch (err) {
+			if (err instanceof MatrixError && err.status < 500) throw err;
+			this.hs.logger.warn("Policy server", policy.via, "unreachable; sending", pdu.event_id, "without its signature", err);
+			return;
+		}
+		if (!this.validSignature(pdu, version, policy)) throw new MatrixError(403, "M_FORBIDDEN", "The policy server's signature is invalid");
+	}
+	/** Whether a remote event is recommended for inclusion (otherwise it is soft-failed). */
+	async recommended(roomId, version, pdu) {
+		if (this.exempt(pdu)) return true;
+		const policy = await this.policyOf(roomId);
+		if (!policy) return true;
+		if (this.validSignature(pdu, version, policy)) return true;
+		if (policy.via === this.hs.serverName) return false;
+		const copy = structuredClone(pdu);
+		try {
+			await this.requestSignature(copy, version, policy);
+		} catch {
+			return false;
+		}
+		if (!this.validSignature(copy, version, policy)) return false;
+		pdu.signatures = copy.signatures;
+		return true;
+	}
+};
+//#endregion
+export { PolicyServers };

package/dist/core/profile.js

@@ -0,0 +1,39 @@
+import { canonicalJson } from "./json.js";
+//#region src/core/profile.ts
+const BUILTIN_FIELDS = /* @__PURE__ */ new Set(["displayname", "avatar_url"]);
+const MAX_PROFILE_BYTES = 65536;
+async function fullProfile(hs, userId) {
+	const user = await hs.db.findOne("users", [{
+		field: "user_id",
+		value: userId
+	}]);
+	if (!user || user.deactivated) return null;
+	const out = {};
+	for (const row of await hs.db.findMany("profile_fields", { where: [{
+		field: "user_id",
+		value: userId
+	}] })) if (row.value !== null && row.value !== void 0 && !BUILTIN_FIELDS.has(row.field)) out[row.field] = row.value;
+	if (user.displayname) out.displayname = user.displayname;
+	if (user.avatar_url) out.avatar_url = user.avatar_url;
+	return out;
+}
+function profileSize(profile) {
+	return Buffer.byteLength(canonicalJson(profile));
+}
+/** Set (or with `null`, clear) one profile field and notify users sharing a room. */
+async function setProfileField(hs, userId, field, value) {
+	if (BUILTIN_FIELDS.has(field)) await hs.db.update("users", [{
+		field: "user_id",
+		value: userId
+	}], { [field]: value || null });
+	await hs.streams.write((stream) => hs.db.upsert("profile_fields", {
+		user_id: userId,
+		field,
+		value: value ?? null,
+		stream
+	}));
+	if (BUILTIN_FIELDS.has(field)) await hs.rooms.propagateProfile(userId);
+	hs.notifier.notify([...await hs.rooms.usersSharingRooms(userId)]);
+}
+//#endregion
+export { BUILTIN_FIELDS, MAX_PROFILE_BYTES, fullProfile, profileSize, setProfileField };

package/dist/core/push.d.ts

@@ -0,0 +1,47 @@
+import { ClientEvent } from "./events.js";
+import { StateMap } from "./authrules.js";
+import { StoredEvent } from "./rooms.js";
+import "./pushrules.js";
+import { Homeserver } from "../homeserver.js";
+//#region src/core/push.d.ts
+/**
+ * Push rule evaluation and push gateway delivery. Every new event is evaluated for
+ * every local member; matches are stored for unread counts and `/notifications`.
+ */
+export declare class PushService {
+  private hs;
+  constructor(hs: Homeserver);
+  onEvent(ev: StoredEvent, state: StateMap, version: string): Promise<void>;
+  /** Unread notification counts since the user's read receipts. */
+  /** Stream positions up to which the user has read the room (unthreaded) and each thread. */
+  private readPositions;
+  isRead(row: Record<string, any>, read: {
+    unthreaded: number;
+    threads: Map<string, number>;
+  }): boolean;
+  unreadCounts(userId: string, roomId: string): Promise<{
+    room: {
+      notification_count: number;
+      highlight_count: number;
+    };
+    threads: Record<string, {
+      notification_count: number;
+      highlight_count: number;
+    }>;
+  }>;
+  private deliver;
+  /** Rows for `GET /notifications`. */
+  list(userId: string, opts: {
+    from: number | null;
+    limit: number;
+    onlyHighlight: boolean;
+  }): Promise<{
+    actions: any;
+    event: ClientEvent;
+    room_id: any;
+    ts: any;
+    read: boolean;
+    stream: any;
+  }[]>;
+}
+//#endregion