matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

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,97 @@
+import { publicKeyFromBase64, verifyJsonSignature } from "./crypto.js";
+import { M } from "./m.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,46 @@
+import { ClientEvent } from "./events.js";
+import { StateMap } from "./authrules.js";
+import { StoredEvent } from "./rooms.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