matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/api/filters.js

@@ -0,0 +1,88 @@
+import { isObject } from "../core/json.js";
+import { M, UNSTABLE } from "../core/m.js";
+import { errors } from "../core/errors.js";
+import { globMatch as globMatch$1 } from "../core/glob.js";
+//#region src/api/filters.ts
+function globMatch(pattern, value) {
+	return globMatch$1(pattern, value, { questionMark: false });
+}
+function matchesFilter(filter, ev) {
+	if (!filter) return true;
+	if (filter.not_types?.some((t) => globMatch(t, ev.type))) return false;
+	if (filter.types && !filter.types.some((t) => globMatch(t, ev.type))) return false;
+	if (ev.sender !== void 0) {
+		if (filter.not_senders?.includes(ev.sender)) return false;
+		if (filter.senders && !filter.senders.includes(ev.sender)) return false;
+	}
+	if (ev.room_id !== void 0) {
+		if (filter.not_rooms?.includes(ev.room_id)) return false;
+		if (filter.rooms && !filter.rooms.includes(ev.room_id)) return false;
+	}
+	const relTypes = filter.rel_types ?? filter[UNSTABLE.ORG.MATRIX.MSC3874.REL_TYPES];
+	const notRelTypes = filter.not_rel_types ?? filter[UNSTABLE.ORG.MATRIX.MSC3874.NOT_REL_TYPES];
+	if (relTypes || notRelTypes) {
+		const relType = ev.content?.[M.RELATES_TO]?.rel_type;
+		if (relTypes && !relTypes.includes(relType)) return false;
+		if (notRelTypes && typeof relType === "string" && notRelTypes.includes(relType)) return false;
+	}
+	if (filter.contains_url !== void 0) {
+		if (typeof ev.content?.url === "string" !== filter.contains_url) return false;
+	}
+	return true;
+}
+function roomAllowed(filter, roomId) {
+	const r = filter.room;
+	if (!r) return true;
+	if (r.not_rooms?.includes(roomId)) return false;
+	if (r.rooms && !r.rooms.includes(roomId)) return false;
+	return true;
+}
+function validateEventFilter(f, name) {
+	if (f === void 0) return;
+	if (!isObject(f)) throw errors.badJson(`${name} must be an object`);
+	for (const key of [
+		"types",
+		"not_types",
+		"senders",
+		"not_senders",
+		"rooms",
+		"not_rooms"
+	]) if (f[key] !== void 0 && (!Array.isArray(f[key]) || !f[key].every((x) => typeof x === "string"))) throw errors.badJson(`${name}.${key} must be a list of strings`);
+	if (f.rooms?.some((r) => !r.startsWith("!")) || f.not_rooms?.some((r) => !r.startsWith("!"))) throw errors.badJson(`${name}: rooms must be room IDs`);
+	if (f.senders?.some((u) => !u.startsWith("@")) || f.not_senders?.some((u) => !u.startsWith("@"))) throw errors.badJson(`${name}: senders must be user IDs`);
+	if (f.limit !== void 0 && (!Number.isInteger(f.limit) || f.limit < 0)) throw errors.badJson(`${name}.limit must be a non-negative integer`);
+}
+function validateSyncFilter(f) {
+	if (!isObject(f)) throw errors.badJson("Filter must be an object");
+	for (const k of ["presence", "account_data"]) validateEventFilter(f[k], k);
+	if (f.room !== void 0) {
+		if (!isObject(f.room)) throw errors.badJson("room must be an object");
+		for (const k of [
+			"timeline",
+			"state",
+			"ephemeral",
+			"account_data"
+		]) validateEventFilter(f.room[k], `room.${k}`);
+		validateEventFilter({
+			rooms: f.room.rooms,
+			not_rooms: f.room.not_rooms
+		}, "room");
+	}
+	if (f.event_format !== void 0 && !["client", "federation"].includes(f.event_format)) throw errors.badJson("Invalid event_format");
+	return f;
+}
+/** Parse the `filter` query param of /messages and /context (a JSON RoomEventFilter). */
+function parseRoomEventFilter(ctx) {
+	const raw = ctx.query.get("filter");
+	if (!raw) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw errors.badJson("Invalid filter JSON");
+	}
+	validateEventFilter(parsed, "filter");
+	return parsed;
+}
+//#endregion
+export { matchesFilter, parseRoomEventFilter, roomAllowed, validateSyncFilter };

package/dist/api/index.js

@@ -0,0 +1,47 @@
+import { registerThreadSubscriptionRoutes } from "./threadsubs.js";
+import { registerAccountRoutes } from "./account.js";
+import { registerBackupRoutes } from "./backup.js";
+import { registerRoomRoutes } from "./rooms.js";
+import { registerSearchRoutes } from "./search.js";
+import { registerPreviewRoutes } from "./preview.js";
+import { registerSpaceRoutes } from "./spaces.js";
+import { registerAdminRoutes } from "./admin.js";
+import { registerSyncRoutes } from "./sync.js";
+import { registerSlidingSyncRoutes } from "./slidingsync.js";
+import { registerRelationshipRoutes } from "./relationships.js";
+import { registerFederationRoutes } from "./federation.js";
+import { registerRtcRoutes } from "./rtc.js";
+import { registerAppServiceRoutes } from "./appservice.js";
+import { registerMediaRoutes } from "./media.js";
+import { registerLegacyRoutes } from "./legacy.js";
+import { registerThreepidRoutes } from "./threepid.js";
+import { registerMiscRoutes } from "./misc.js";
+import { registerProfileRoutes } from "./profile.js";
+import { registerPushRoutes } from "./push.js";
+import { registerUserRoutes } from "./user.js";
+//#region src/api/index.ts
+function registerRoutes(r) {
+	registerMiscRoutes(r);
+	registerAccountRoutes(r);
+	registerProfileRoutes(r);
+	registerRoomRoutes(r);
+	registerLegacyRoutes(r);
+	registerThreepidRoutes(r);
+	registerSyncRoutes(r);
+	registerUserRoutes(r);
+	registerPushRoutes(r);
+	registerMediaRoutes(r);
+	registerSearchRoutes(r);
+	registerBackupRoutes(r);
+	registerPreviewRoutes(r);
+	registerSpaceRoutes(r);
+	registerAdminRoutes(r);
+	registerSlidingSyncRoutes(r);
+	registerFederationRoutes(r);
+	registerRtcRoutes(r);
+	registerAppServiceRoutes(r);
+	registerThreadSubscriptionRoutes(r);
+	registerRelationshipRoutes(r);
+}
+//#endregion
+export { registerRoutes };

package/dist/api/legacy.js

@@ -0,0 +1,183 @@
+import { toClientEvent } from "../core/events.js";
+import { errors } from "../core/errors.js";
+import { isValidRoomId } from "../core/ids.js";
+import { procedure } from "../http/procedure.js";
+import { paginate, visibleState } from "./rooms.js";
+//#region src/api/legacy.ts
+const viewerOf = (s) => ({
+	userId: s.userId,
+	deviceId: s.deviceId
+});
+const parseStreamToken = (raw, fallback) => {
+	if (raw === null) return fallback;
+	const m = /^s(\d+)/.exec(raw);
+	if (!m) throw errors.invalidParam("Invalid from token");
+	return Number(m[1]);
+};
+async function roomAccountData(hs, userId, roomId) {
+	return (await hs.db.findMany("account_data", { where: [{
+		field: "user_id",
+		value: userId
+	}, {
+		field: "room_id",
+		value: roomId
+	}] })).map((r) => ({
+		type: r.type,
+		content: r.content
+	}));
+}
+/** Current state and latest messages of a room the user may see (also for peeking). */
+async function roomInfo(hs, s, roomId, limit) {
+	const state = await visibleState(hs, roomId, s.userId);
+	const membership = (await hs.db.findOne("memberships", [{
+		field: "room_id",
+		value: roomId
+	}, {
+		field: "user_id",
+		value: s.userId
+	}]))?.membership ?? void 0;
+	const position = await hs.streams.position();
+	const { events, end } = await paginate(hs, s.userId, roomId, {
+		from: {
+			depth: null,
+			stream: position
+		},
+		to: null,
+		dir: "b",
+		limit
+	});
+	const chunk = events.reverse();
+	const room = await hs.db.findOne("rooms", [{
+		field: "room_id",
+		value: roomId
+	}]);
+	return {
+		room_id: roomId,
+		...membership ? { membership } : {},
+		messages: {
+			chunk: chunk.map((e) => hs.rooms.formatEvent(e, viewerOf(s))),
+			start: end ?? (chunk.length ? `t${chunk[0].pdu.depth}_${chunk[0].stream}` : `s${position}`),
+			end: `s${position}`
+		},
+		state: [...state.values()].map((e) => toClientEvent(e)),
+		visibility: room?.is_public ? "public" : "private",
+		account_data: membership ? await roomAccountData(hs, s.userId, roomId) : [],
+		presence: [],
+		receipts: []
+	};
+}
+/** Events after `from` in the given rooms, oldest first. */
+async function eventsSince(hs, s, roomIds, from, limit) {
+	const all = [];
+	for (const roomId of roomIds) {
+		const { events } = await paginate(hs, s.userId, roomId, {
+			from: {
+				depth: null,
+				stream: from
+			},
+			to: null,
+			dir: "f",
+			limit
+		});
+		all.push(...events);
+	}
+	return all.sort((a, b) => a.stream - b.stream).slice(0, limit);
+}
+function registerLegacyRoutes(r) {
+	r.client("GET", "/initialSync", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const hs = ctx.hs;
+			const limit = Math.min(Math.max(Number.parseInt(ctx.query.get("limit") ?? "10", 10) || 10, 0), 100);
+			const memberships = [
+				"join",
+				"invite",
+				...ctx.query.get("archived") === "true" ? ["leave", "ban"] : []
+			];
+			const rooms = [];
+			for (const membership of memberships) for (const roomId of await hs.rooms.roomsForUser(s.userId, membership)) {
+				if (membership === "invite") {
+					const invite = await hs.rooms.membershipEvent(roomId, s.userId);
+					rooms.push({
+						room_id: roomId,
+						membership,
+						...invite ? { invite: hs.rooms.formatEvent(invite, viewerOf(s)) } : {}
+					});
+					continue;
+				}
+				try {
+					rooms.push(await roomInfo(hs, s, roomId, limit));
+				} catch {}
+			}
+			const account = await hs.db.findMany("account_data", { where: [{
+				field: "user_id",
+				value: s.userId
+			}, {
+				field: "room_id",
+				value: ""
+			}] });
+			return {
+				end: `s${await hs.streams.position()}`,
+				rooms,
+				presence: [],
+				account_data: account.map((a) => ({
+					type: a.type,
+					content: a.content
+				}))
+			};
+		}
+	}));
+	r.client("GET", "/rooms/:roomId/initialSync", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			if (!isValidRoomId(ctx.params.roomId)) throw errors.invalidParam("Invalid room ID");
+			const limit = Math.min(Math.max(Number.parseInt(ctx.query.get("limit") ?? "10", 10) || 10, 0), 100);
+			return roomInfo(ctx.hs, s, ctx.params.roomId, limit);
+		}
+	}));
+	r.client("GET", "/events/:eventId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const ev = await ctx.hs.rooms.getEvent(ctx.params.eventId);
+			if (!ev || !(await ctx.hs.rooms.filterVisible(s.userId, ev.pdu.room_id, [ev])).length) throw errors.notFound("Event not found");
+			return ctx.hs.rooms.formatEvent(ev, viewerOf(s), { includeRoomId: true });
+		}
+	}));
+	r.client("GET", "/events", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const hs = ctx.hs;
+			const now = await hs.streams.position();
+			const from = parseStreamToken(ctx.query.get("from"), now);
+			const timeout = Math.min(Math.max(Number(ctx.query.get("timeout") ?? 3e4) || 0, 0), hs.config.maxSyncTimeoutMs);
+			const peekRoom = ctx.query.get("room_id");
+			let roomIds;
+			if (peekRoom !== null) {
+				if (!isValidRoomId(peekRoom)) throw errors.invalidParam("Invalid room ID");
+				const { joined, worldReadable } = await hs.rooms.canPeek(peekRoom, s.userId);
+				if (!joined && !worldReadable) throw errors.forbidden("You cannot peek into this room");
+				roomIds = [peekRoom];
+			} else roomIds = await hs.rooms.roomsForUser(s.userId);
+			const deadline = Date.now() + timeout;
+			for (;;) {
+				const events = await eventsSince(hs, s, roomIds, from, 100);
+				const remaining = deadline - Date.now();
+				if (events.length || remaining <= 0 || ctx.request.signal.aborted) {
+					const end = events.length ? events[events.length - 1].stream : Math.max(from, await hs.streams.position());
+					return {
+						start: `s${from}`,
+						end: `s${end}`,
+						chunk: events.map((e) => hs.rooms.formatEvent(e, viewerOf(s), { includeRoomId: true }))
+					};
+				}
+				await Promise.race([hs.notifier.wait(s.userId, remaining, ctx.request.signal), new Promise((resolve) => setTimeout(resolve, Math.min(remaining, peekRoom !== null ? 1e3 : remaining)).unref?.())]);
+			}
+		}
+	}));
+}
+//#endregion
+export { registerLegacyRoutes };

package/dist/api/media.js

@@ -0,0 +1,271 @@
+import { randomString } from "../core/crypto.js";
+import { M } from "../core/m.js";
+import { MatrixError, errors } from "../core/errors.js";
+import { procedure } from "../http/procedure.js";
+//#region src/api/media.ts
+const DEFAULT_MAX_UPLOAD = 52428800;
+const INLINE_TYPES = /^(image\/(png|jpeg|gif|webp|avif|apng)|video\/(mp4|webm|ogg)|audio\/(mpeg|ogg|wav|webm|mp4|aac|flac)|text\/plain)$/;
+const maxUpload = (hs) => hs.media.maxUploadSize ?? DEFAULT_MAX_UPLOAD;
+async function storeUpload(ctx, mediaId) {
+	const hs = ctx.hs;
+	const data = await ctx.bytes();
+	if (data.length > maxUpload(hs)) throw errors.tooLarge("Upload too large");
+	const contentType = ctx.request.headers.get("content-type");
+	const filename = ctx.query.get("filename");
+	await hs.media.put(mediaId, data, {
+		contentType,
+		filename,
+		size: data.length
+	});
+	await hs.db.upsert("media", {
+		media_id: mediaId,
+		content_type: contentType,
+		filename,
+		size: data.length,
+		uploader: (await ctx.auth()).userId,
+		created_ts: Date.now(),
+		pending: false
+	});
+}
+function contentDisposition(contentType, filename) {
+	const type = INLINE_TYPES.test(contentType ?? "") ? "inline" : "attachment";
+	return filename ? `${type}; filename*=utf-8''${encodeURIComponent(filename)}` : type;
+}
+/** Fetch (and cache) media from another server. */
+async function remoteMedia(ctx) {
+	const hs = ctx.hs;
+	const { serverName, mediaId } = ctx.params;
+	if (ctx.query.get("allow_remote") === "false") throw errors.notFound("Remote media not allowed");
+	const cached = await hs.db.findOne("remote_media", [{
+		field: "server_name",
+		value: serverName
+	}, {
+		field: "media_id",
+		value: mediaId
+	}]);
+	if (cached) {
+		const data = await hs.media.get(cached.local_id);
+		if (data) return {
+			data,
+			contentType: cached.content_type,
+			filename: cached.filename
+		};
+	}
+	let fetched;
+	try {
+		fetched = await hs.federation.fetchMedia(serverName, mediaId);
+	} catch (err) {
+		if (err instanceof MatrixError) throw err;
+		throw new MatrixError(502, "M_UNKNOWN", "Could not fetch remote media");
+	}
+	if (fetched.data.length > maxUpload(hs)) throw errors.tooLarge("Remote media too large");
+	const localId = `remote_${randomString(24)}`;
+	await hs.media.put(localId, fetched.data, {
+		contentType: fetched.contentType,
+		filename: fetched.filename,
+		size: fetched.data.length
+	});
+	await hs.db.upsert("remote_media", {
+		server_name: serverName,
+		media_id: mediaId,
+		local_id: localId,
+		content_type: fetched.contentType,
+		filename: fetched.filename,
+		size: fetched.data.length,
+		fetched_ts: Date.now()
+	});
+	return fetched;
+}
+async function download(ctx) {
+	const hs = ctx.hs;
+	const { serverName, mediaId } = ctx.params;
+	if (serverName !== hs.serverName) {
+		const remote = await remoteMedia(ctx);
+		const filename = ctx.params.fileName ?? remote.filename;
+		return new Response(remote.data, {
+			status: 200,
+			headers: {
+				"content-type": remote.contentType ?? "application/octet-stream",
+				"content-disposition": contentDisposition(remote.contentType, filename),
+				"content-security-policy": "sandbox; default-src 'none'; script-src 'none'; plugin-types application/pdf; style-src 'unsafe-inline'; media-src 'self'; object-src 'self';",
+				"cross-origin-resource-policy": "cross-origin",
+				"cache-control": "public, max-age=86400, immutable"
+			}
+		});
+	}
+	const meta = await hs.db.findOne("media", [{
+		field: "media_id",
+		value: mediaId
+	}]);
+	if (!meta) throw errors.notFound("Media not found");
+	if (meta.pending) throw new MatrixError(504, "M_NOT_YET_UPLOADED", "Media has not been uploaded yet");
+	const data = await hs.media.get(mediaId);
+	if (!data) throw errors.notFound("Media not found");
+	const filename = ctx.params.fileName ?? meta.filename;
+	return new Response(data, {
+		status: 200,
+		headers: {
+			"content-type": meta.content_type ?? "application/octet-stream",
+			"content-disposition": contentDisposition(meta.content_type, filename),
+			"content-security-policy": "sandbox; default-src 'none'; script-src 'none'; plugin-types application/pdf; style-src 'unsafe-inline'; media-src 'self'; object-src 'self';",
+			"cross-origin-resource-policy": "cross-origin",
+			"cache-control": "public, max-age=86400, immutable"
+		}
+	});
+}
+/** Serve a thumbnail, generating and caching it with the configured thumbnailer. */
+async function thumbnail(ctx) {
+	const hs = ctx.hs;
+	const width = Number.parseInt(ctx.query.get("width") ?? "", 10);
+	const height = Number.parseInt(ctx.query.get("height") ?? "", 10);
+	if (!(width > 0) || !(height > 0)) throw errors.invalidParam("width and height must be positive integers");
+	const method = ctx.query.get("method") === "crop" ? "crop" : "scale";
+	const animated = ctx.query.get("animated") === "true";
+	const { serverName, mediaId } = ctx.params;
+	if (serverName !== hs.serverName || !hs.config.thumbnailer) return download(ctx);
+	const meta = await hs.db.findOne("media", [{
+		field: "media_id",
+		value: mediaId
+	}]);
+	if (!meta || meta.pending || !meta.content_type?.startsWith("image/")) return download(ctx);
+	const sizes = [
+		32,
+		96,
+		320,
+		640,
+		800,
+		1280
+	];
+	const w = sizes.find((s) => s >= width) ?? 1280;
+	const h = sizes.find((s) => s >= height) ?? 1280;
+	const thumbId = `${mediaId}_thumb_${w}x${h}_${method}${animated ? "_a" : ""}`;
+	let thumb = await hs.media.get(thumbId);
+	let contentType = (await hs.db.findOne("media", [{
+		field: "media_id",
+		value: thumbId
+	}]))?.content_type ?? null;
+	if (!thumb || !contentType) {
+		const original = await hs.media.get(mediaId);
+		if (!original) throw errors.notFound("Media not found");
+		const made = await hs.config.thumbnailer(original, meta.content_type, {
+			width: w,
+			height: h,
+			method,
+			animated
+		}).catch((err) => {
+			hs.logger.warn("Thumbnailing failed", mediaId, err);
+			return null;
+		});
+		if (!made) return download(ctx);
+		thumb = made.data;
+		contentType = made.contentType;
+		await hs.media.put(thumbId, thumb, {
+			contentType,
+			filename: null,
+			size: thumb.length
+		});
+		await hs.db.upsert("media", {
+			media_id: thumbId,
+			content_type: contentType,
+			filename: null,
+			size: thumb.length,
+			uploader: "",
+			created_ts: Date.now(),
+			pending: false
+		});
+	}
+	return new Response(thumb, {
+		status: 200,
+		headers: {
+			"content-type": contentType,
+			"content-disposition": "inline",
+			"cross-origin-resource-policy": "cross-origin",
+			"cache-control": "public, max-age=86400, immutable"
+		}
+	});
+}
+function registerMediaRoutes(r) {
+	const config = (ctx) => ({ [M.UPLOAD.SIZE]: maxUpload(ctx.hs) });
+	r.get("/_matrix/media/v3/config", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			return config(ctx);
+		}
+	}));
+	r.get("/_matrix/media/r0/config", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			return config(ctx);
+		}
+	}));
+	r.get("/_matrix/client/v1/media/config", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			return config(ctx);
+		}
+	}));
+	const upload = async (ctx) => {
+		await ctx.auth();
+		await ctx.rateLimit("upload");
+		const mediaId = randomString(24);
+		await storeUpload(ctx, mediaId);
+		return { content_uri: `mxc://${ctx.hs.serverName}/${mediaId}` };
+	};
+	r.post("/_matrix/media/v3/upload", procedure({ handler: upload }));
+	r.post("/_matrix/media/r0/upload", procedure({ handler: upload }));
+	r.post("/_matrix/media/v1/create", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const mediaId = randomString(24);
+			await ctx.hs.db.create("media", {
+				media_id: mediaId,
+				content_type: null,
+				filename: null,
+				size: 0,
+				uploader: s.userId,
+				created_ts: Date.now(),
+				pending: true
+			});
+			return {
+				content_uri: `mxc://${ctx.hs.serverName}/${mediaId}`,
+				unused_expires_at: Date.now() + 864e5
+			};
+		}
+	}));
+	r.put("/_matrix/media/v3/upload/:serverName/:mediaId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			if (ctx.params.serverName !== ctx.hs.serverName) throw errors.notFound("Unknown media");
+			const meta = await ctx.hs.db.findOne("media", [{
+				field: "media_id",
+				value: ctx.params.mediaId
+			}]);
+			if (!meta) throw errors.notFound("Unknown media");
+			if (meta.uploader !== s.userId) throw errors.forbidden("You did not create this media ID");
+			if (!meta.pending) throw new MatrixError(409, "M_CANNOT_OVERWRITE_MEDIA", "Media already uploaded");
+			await storeUpload(ctx, ctx.params.mediaId);
+			return {};
+		}
+	}));
+	for (const prefix of ["/_matrix/media/v3", "/_matrix/media/r0"]) {
+		r.get(`${prefix}/download/:serverName/:mediaId`, procedure({ handler: download }));
+		r.get(`${prefix}/download/:serverName/:mediaId/:fileName`, procedure({ handler: download }));
+		r.get(`${prefix}/thumbnail/:serverName/:mediaId`, procedure({ handler: thumbnail }));
+	}
+	const authed = async (ctx) => {
+		await ctx.auth();
+		return download(ctx);
+	};
+	r.get("/_matrix/client/v1/media/download/:serverName/:mediaId", procedure({ handler: authed }));
+	r.get("/_matrix/client/v1/media/download/:serverName/:mediaId/:fileName", procedure({ handler: authed }));
+	r.get("/_matrix/client/v1/media/thumbnail/:serverName/:mediaId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			return thumbnail(ctx);
+		}
+	}));
+}
+//#endregion
+export { registerMediaRoutes };

package/dist/api/misc.js

@@ -0,0 +1,95 @@
+import { signJson } from "../core/crypto.js";
+import { M, UNSTABLE } from "../core/m.js";
+import { SUPPORTED_ROOM_VERSIONS } from "../core/events.js";
+import { errors } from "../core/errors.js";
+import { procedure } from "../http/procedure.js";
+import { wellKnown } from "./account.js";
+import { canonicalJsonResponse } from "../http/handler.js";
+import { readFileSync } from "node:fs";
+//#region src/api/misc.ts
+const PACKAGE = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+const SPEC_VERSIONS = [
+	"r0.0.1",
+	"r0.1.0",
+	"r0.2.0",
+	"r0.3.0",
+	"r0.4.0",
+	"r0.5.0",
+	"r0.6.0",
+	"r0.6.1",
+	"v1.1",
+	"v1.2",
+	"v1.3",
+	"v1.4",
+	"v1.5",
+	"v1.6",
+	"v1.7",
+	"v1.8",
+	"v1.9",
+	"v1.10",
+	"v1.11"
+];
+function registerMiscRoutes(r) {
+	r.get("/_matrix/client/versions", procedure({ handler: () => ({
+		versions: SPEC_VERSIONS,
+		unstable_features: {
+			[UNSTABLE.ORG.MATRIX.SIMPLIFIED_MSC3575]: true,
+			[UNSTABLE.ORG.MATRIX.MSC3916.STABLE]: true,
+			[UNSTABLE.ORG.MATRIX.MSC4140._]: true,
+			[UNSTABLE.ORG.MATRIX.MSC4143._]: true,
+			[UNSTABLE.ORG.MATRIX.MSC4222._]: true,
+			[UNSTABLE.ORG.MATRIX.MSC4306]: true
+		}
+	}) }));
+	r.get("/.well-known/matrix/client", procedure({ handler: (ctx) => {
+		const wk = wellKnown(ctx.hs);
+		if (!wk) throw errors.notFound("No well-known configured");
+		return wk;
+	} }));
+	r.get("/.well-known/matrix/server", procedure({ handler: (ctx) => {
+		if (!ctx.hs.config.federationAddress) throw errors.notFound("No delegation configured");
+		return { [M.SERVER]: ctx.hs.config.federationAddress };
+	} }));
+	r.get("/.well-known/matrix/support", procedure({ handler: (ctx) => {
+		if (!ctx.hs.config.support) throw errors.notFound("No support information configured");
+		return ctx.hs.config.support;
+	} }));
+	r.client("GET", "/capabilities", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const available = {};
+			for (const v of SUPPORTED_ROOM_VERSIONS) available[v] = /^\d+$/.test(v) ? "stable" : "unstable";
+			return { capabilities: {
+				[M.CHANGE_PASSWORD]: { enabled: !ctx.hs.oauth && ctx.hs.userAuth.passwordLoginEnabled },
+				[M.ROOM_VERSIONS]: {
+					default: ctx.hs.config.defaultRoomVersion,
+					available
+				},
+				[M.SET_DISPLAYNAME]: { enabled: true },
+				[M.SET_AVATAR_URL]: { enabled: true },
+				[M.PROFILE_FIELDS]: { enabled: true },
+				[M.THREEPID_CHANGES]: { enabled: ctx.hs.threepids.enabled && !ctx.hs.oauth },
+				[M.GET_LOGIN_TOKEN]: { enabled: ctx.hs.config.loginViaExistingSession && !ctx.hs.oauth }
+			} };
+		}
+	}));
+	r.get("/_matrix/key/v2/server", procedure({ handler: (ctx) => {
+		const hs = ctx.hs;
+		const key = hs.signingKey;
+		return canonicalJsonResponse(signJson({
+			server_name: hs.serverName,
+			valid_until_ts: Date.now() + 864e5,
+			verify_keys: { [`ed25519:${key.keyId}`]: { key: key.publicKeyBase64 } },
+			old_verify_keys: {}
+		}, hs.serverName, key));
+	} }));
+	r.get("/_matrix/federation/v1/version", procedure({ handler: (ctx) => {
+		if (!ctx.hs.federation.enabled) throw errors.unrecognized("Federation is disabled");
+		return { server: {
+			name: PACKAGE.name,
+			version: PACKAGE.version
+		} };
+	} }));
+}
+//#endregion
+export { SPEC_VERSIONS, registerMiscRoutes };