matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/homeserver.js

@@ -0,0 +1,302 @@
+import { loadSigningKey, randomString } from "./core/crypto.js";
+import "./core/m.js";
+import { SUPPORTED_ROOM_VERSIONS } from "./core/events.js";
+import { PartialStateService } from "./core/partialstate.js";
+import { RoomService } from "./core/rooms.js";
+import { FederationService } from "./federation/index.js";
+import { PolicyServers } from "./core/policy.js";
+import { ThreepidService } from "./core/threepid.js";
+import { IdentityServers } from "./core/identity.js";
+import { AuthService } from "./core/auth.js";
+import { KeyService } from "./core/keys.js";
+import { Notifier } from "./core/notifier.js";
+import { StreamManager, localCluster, newInstanceId } from "./core/cluster.js";
+import { TypingService } from "./core/typing.js";
+import { PushService } from "./core/push.js";
+import { AdminService } from "./core/admin.js";
+import { OAuthDelegation } from "./core/oauth.js";
+import { SsoService } from "./core/sso.js";
+import { DelayedEventService } from "./core/delayed.js";
+import { AuditService } from "./core/audit.js";
+import { SettingsService } from "./core/settings.js";
+import { AdminRoomService } from "./core/adminroom.js";
+import { AppServiceService } from "./core/appservices.js";
+import { RateLimits, memoryRateLimiter } from "./core/ratelimit.js";
+import { resolveUserAuth } from "./adapters/auth.js";
+import { memoryMedia } from "./adapters/media.js";
+import { memoryAdapter } from "./storage/memory.js";
+import { schema } from "./storage/schema.js";
+import { Router } from "./http/router.js";
+import { registerRoutes } from "./api/index.js";
+import { EventEmitter } from "node:events";
+//#region src/homeserver.ts
+const consoleLogger = {
+	debug: () => {},
+	info: (...a) => console.info("[matrix]", ...a),
+	warn: (...a) => console.warn("[matrix]", ...a),
+	error: (...a) => console.error("[matrix]", ...a)
+};
+const STREAM_TABLES = [
+	["events", "stream"],
+	["account_data", "stream"],
+	["receipts", "stream"],
+	["to_device", "stream"],
+	["device_keys", "stream"],
+	["cross_signing_keys", "stream"],
+	["device_list_changes", "stream"],
+	["presence", "stream"],
+	["memberships", "stream"]
+];
+var Homeserver = class extends EventEmitter {
+	serverName;
+	config;
+	db;
+	media;
+	userAuth;
+	logger;
+	router = new Router();
+	cluster;
+	instanceId;
+	streams;
+	notifier;
+	auth;
+	rooms;
+	keys;
+	typing;
+	push;
+	rateLimits;
+	admin;
+	oauth;
+	sso;
+	federation;
+	delayedEvents;
+	audit;
+	settings;
+	adminRoom;
+	appservices;
+	partialState;
+	policyServers;
+	threepids;
+	identityServers;
+	/** `fetch` used for outgoing requests (push gateways, URL previews, OAuth). Overridable for testing. */
+	fetch;
+	/** Resolves once storage is migrated and the server is ready to serve requests. */
+	ready;
+	_signingKey = null;
+	cleanupTimer = null;
+	closed = false;
+	constructor(options) {
+		super();
+		if (!options.homeserver) throw new Error("`homeserver` (server name) is required");
+		this.serverName = options.homeserver;
+		this.logger = options.logger ?? consoleLogger;
+		const defaultRoomVersion = options.defaultRoomVersion ?? "10";
+		if (!SUPPORTED_ROOM_VERSIONS.includes(defaultRoomVersion)) throw new Error(`Unsupported room version ${defaultRoomVersion}`);
+		this.config = {
+			serverName: options.homeserver,
+			publicBaseUrl: options.publicBaseUrl ?? null,
+			federationAddress: options.federationAddress ?? null,
+			support: options.support && (options.support.contacts?.length || options.support.supportPage) ? {
+				contacts: options.support.contacts ?? [],
+				...options.support.supportPage ? { support_page: options.support.supportPage } : {}
+			} : null,
+			loginViaExistingSession: options.loginViaExistingSession ?? true,
+			threepid: {
+				...options.threepid,
+				identityServerProtocol: options.threepid?.identityServerProtocol ?? "https"
+			},
+			registrationSharedSecret: options.registrationSharedSecret ?? null,
+			defaultRoomVersion,
+			accessTokenLifetimeMs: options.accessTokenLifetimeMs ?? null,
+			maxSyncTimeoutMs: options.maxSyncTimeoutMs ?? 3e4,
+			urlPreviews: options.urlPreviews ? { allowPrivateAddresses: typeof options.urlPreviews === "object" && !!options.urlPreviews.allowPrivateAddresses } : null,
+			thumbnailer: options.thumbnailer ?? null,
+			rtc: options.rtc ?? {},
+			serverNotices: {
+				localpart: options.serverNotices?.localpart ?? "server",
+				displayName: options.serverNotices?.displayName ?? "Server Notices",
+				roomName: options.serverNotices?.roomName ?? "Server Notices"
+			}
+		};
+		const db = options.databaseAdapter;
+		if (db && typeof db.findOne === "function") this.db = db;
+		else {
+			this.logger.warn("No database adapter given; using in-memory storage (data is lost on restart)");
+			this.db = memoryAdapter();
+		}
+		const media = options.mediaAdapter;
+		this.media = media && typeof media.put === "function" ? media : memoryMedia();
+		this.userAuth = resolveUserAuth(options.userAuthAdapter);
+		this.cluster = options.cluster ?? localCluster();
+		this.instanceId = newInstanceId();
+		this.streams = new StreamManager(this.cluster, this.instanceId);
+		this.notifier = new Notifier(this.cluster, this.instanceId);
+		this.auth = new AuthService(this);
+		this.rooms = new RoomService(this, !options.cluster);
+		this.keys = new KeyService(this);
+		this.typing = new TypingService(this);
+		this.push = new PushService(this);
+		this.admin = new AdminService(this);
+		this.oauth = options.oauth ? new OAuthDelegation(this, options.oauth) : null;
+		this.federation = new FederationService(this, options.federation);
+		this.delayedEvents = new DelayedEventService(this, options.delayedEvents);
+		this.audit = new AuditService(this, options.audit);
+		this.settings = new SettingsService(this);
+		this.appservices = new AppServiceService(this, options.appservices ?? []);
+		this.partialState = new PartialStateService(this);
+		this.policyServers = new PolicyServers(this);
+		this.threepids = new ThreepidService(this);
+		this.identityServers = new IdentityServers(this);
+		const adminRoom = options.adminRoom === true ? {} : options.adminRoom || null;
+		this.adminRoom = adminRoom && adminRoom.enabled !== false ? new AdminRoomService(this, adminRoom) : null;
+		this.sso = options.sso?.providers.length ? new SsoService(this, options.sso) : null;
+		if (this.sso && !options.publicBaseUrl) throw new Error("`publicBaseUrl` is required when SSO is configured");
+		this.rateLimits = options.rateLimits === false ? new RateLimits(null) : new RateLimits(options.rateLimits?.limiter ?? memoryRateLimiter(), options.rateLimits?.rules);
+		const cleanupEvery = options.cleanupIntervalMs ?? 6e5;
+		if (cleanupEvery > 0) {
+			this.cleanupTimer = setInterval(() => void this.cleanup().catch((err) => this.logger.warn("Cleanup failed", err)), cleanupEvery);
+			this.cleanupTimer.unref?.();
+		}
+		this.fetch = options.fetch ?? globalThis.fetch;
+		registerRoutes(this.router);
+		this.ready = this.init(options);
+		this.ready.catch((err) => this.logger.error("Homeserver failed to start", err));
+	}
+	get signingKey() {
+		if (!this._signingKey) throw new Error("Homeserver not ready");
+		return this._signingKey;
+	}
+	async init(options) {
+		await this.cluster.lock("startup", async () => {
+			await this.db.migrate?.(schema);
+			if (options.signingKey) this._signingKey = loadSigningKey(options.signingKey.keyId, options.signingKey.seed);
+			else {
+				const row = await this.db.findOne("server_keys", []);
+				if (row) this._signingKey = loadSigningKey(row.key_id, row.seed);
+				else {
+					this._signingKey = loadSigningKey(`a_${randomString(4)}`);
+					await this.db.create("server_keys", {
+						key_id: this._signingKey.keyId,
+						seed: this._signingKey.seed
+					});
+				}
+			}
+		});
+		for (const [table, field] of STREAM_TABLES) {
+			const max = await this.db.max(table, field);
+			if (max !== null) await this.streams.advanceTo(max);
+		}
+		const snap = await this.db.max("state_snapshots", "id");
+		if (snap !== null) await this.streams.advanceTo(snap);
+		const oldest = await this.db.findMany("events", {
+			sortBy: {
+				field: "stream",
+				direction: "asc"
+			},
+			limit: 1
+		});
+		if (oldest[0] && oldest[0].stream < 0) await this.streams.lowerBackfillTo(oldest[0].stream);
+		const oldestSnap = await this.db.findMany("state_snapshots", {
+			sortBy: {
+				field: "id",
+				direction: "asc"
+			},
+			limit: 1
+		});
+		if (oldestSnap[0] && oldestSnap[0].id < 0) await this.streams.lowerBackfillTo(oldestSnap[0].id);
+		await this.cluster.advance("federation_outbox", await this.db.max("federation_outbox", "id") ?? 0);
+		if (this.federation.enabled) this.federation.sender.start();
+		this.delayedEvents.start();
+		this.appservices.start();
+		if (this.federation.enabled) await this.partialState.resume();
+	}
+	/** Remove expired tokens, abandoned uploads and old notifications. */
+	async cleanup() {
+		const now = Date.now();
+		await this.db.delete("access_tokens", [{
+			field: "expires_ts",
+			operator: "lt",
+			value: now - 6048e5
+		}]);
+		await this.db.delete("login_tokens", [{
+			field: "expires_ts",
+			operator: "lt",
+			value: now
+		}]);
+		for (const m of await this.db.findMany("media", { where: [{
+			field: "pending",
+			value: true
+		}, {
+			field: "created_ts",
+			operator: "lt",
+			value: now - 864e5
+		}] })) {
+			await this.media.delete?.(m.media_id);
+			await this.db.delete("media", [{
+				field: "media_id",
+				value: m.media_id
+			}]);
+		}
+		await this.db.delete("notifications", [{
+			field: "ts",
+			operator: "lt",
+			value: now - 2592e6
+		}]);
+		await this.audit.prune();
+	}
+	/** Stop background work and release long-polling requests. Call before shutting down your HTTP server. */
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		if (this.cleanupTimer) clearInterval(this.cleanupTimer);
+		this.federation.sender.stop();
+		this.delayedEvents.stop();
+		this.appservices.stop();
+		this.partialState.stop();
+		await this.streams.stop();
+		await this.cluster.close?.();
+		this.notifier.notifyAll();
+		this.emit("close");
+	}
+	get isClosed() {
+		return this.closed;
+	}
+	/**
+	* Effective registration mode: an admin's runtime setting overrides the configuration.
+	* "open" | "token" | "closed".
+	*/
+	async registrationMode() {
+		const setting = await this.settings.get("registration");
+		if (setting === "open" || setting === "token" || setting === "closed") return setting;
+		if (!this.userAuth.registrationEnabled) return "closed";
+		return this.userAuth.registrationRequiresToken ? "token" : "open";
+	}
+	/** Whether `/register` is allowed right now, including the first-user exception. */
+	async registrationAllowed() {
+		if (await this.registrationMode() !== "closed") return true;
+		return !!this.adminRoom?.options.firstUserCanRegister && await this.adminRoom.noUsersYet();
+	}
+	/** Run `fn` atomically when the database adapter supports transactions. */
+	transaction(fn) {
+		return this.db.transaction ? this.db.transaction(fn) : fn(this.db);
+	}
+	/** The user's current profile, as included in member events. */
+	async profile(userId) {
+		const user = await this.db.findOne("users", [{
+			field: "user_id",
+			value: userId
+		}]);
+		const out = {};
+		if (user?.displayname) out.displayname = user.displayname;
+		if (user?.avatar_url) out.avatar_url = user.avatar_url;
+		return out;
+	}
+	isLocalUser(userId) {
+		return userId.endsWith(`:${this.serverName}`);
+	}
+};
+function createHomeserver(options) {
+	return new Homeserver(options);
+}
+//#endregion
+export { Homeserver, createHomeserver };

package/dist/http/adapters.d.ts

@@ -0,0 +1,40 @@
+import { Homeserver } from "../homeserver.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+//#region src/http/adapters.d.ts
+/** Paths this library serves. Framework adapters forward only these. */
+export declare function isMatrixPath(pathname: string): boolean;
+/** A web-standard fetch handler: `(Request) => Promise<Response>`. Works with Hono, Bun, Deno, workers… */
+export declare function getFetchHandler(hs: Homeserver): (request: Request) => Promise<Response>;
+export type NodeHandler = (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => void;
+/**
+ * A request listener for `node:http` / `node:https` / `node:http2` (compat).
+ * Also usable directly as Express/Connect middleware: non-Matrix paths are
+ * passed to `next()` when it is provided, otherwise answered with 404.
+ */
+export declare function getNodeHandler(hs: Homeserver): NodeHandler;
+/** Express / Connect middleware. Mount with `app.use(getExpressHandler(hs))`. */
+export declare function getExpressHandler(hs: Homeserver): (req: any, res: any, next: (err?: unknown) => void) => void;
+/** Minimal structural Fastify types so that fastify is not a dependency. */
+interface FastifyLike {
+  removeAllContentTypeParsers(): void;
+  addContentTypeParser(type: string, opts: {
+    parseAs: "buffer";
+  }, parser: (req: any, body: Buffer, done: (err: Error | null, body?: unknown) => void) => void): void;
+  route(opts: {
+    method: string[];
+    url: string;
+    handler: (request: any, reply: any) => unknown;
+  }): void;
+}
+/**
+ * Fastify plugin. Register with `fastify.register(getFastifyPlugin(hs))`.
+ * The plugin is encapsulated so its raw body parser does not leak into your app.
+ */
+export declare function getFastifyPlugin(hs: Homeserver): (fastify: FastifyLike, opts: unknown, done?: (err?: Error) => void) => Promise<void>;
+/**
+ * Hono handler. Mount with `app.all("*", getHonoHandler(hs))` or
+ * `app.mount("/", getFetchHandler(hs))`. Non-Matrix paths call `next()`.
+ */
+export declare function getHonoHandler(hs: Homeserver): (c: any, next: () => Promise<void>) => Promise<Response | void>;
+//#endregion
+export {};

package/dist/http/adapters.js

@@ -0,0 +1,130 @@
+import { handleRequest } from "./handler.js";
+import { Readable } from "node:stream";
+//#region src/http/adapters.ts
+/** Paths this library serves. Framework adapters forward only these. */
+function isMatrixPath(pathname) {
+	return pathname.startsWith("/_matrix/") || pathname.startsWith("/.well-known/matrix/") || pathname.startsWith("/_synapse/");
+}
+/** A web-standard fetch handler: `(Request) => Promise<Response>`. Works with Hono, Bun, Deno, workers… */
+function getFetchHandler(hs) {
+	return (request) => handleRequest(hs, request);
+}
+async function toWebRequest(req, presetBody) {
+	const proto = req.socket?.encrypted ? "https" : "http";
+	const host = req.headers.host ?? "localhost";
+	const url = new URL(req.originalUrl ?? req.url ?? "/", `${proto}://${host}`);
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value === void 0 || key.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+		else headers.set(key, value);
+	}
+	const method = req.method ?? "GET";
+	let body = void 0;
+	if (method !== "GET" && method !== "HEAD") {
+		const pre = presetBody !== void 0 ? presetBody : req.body;
+		if (pre !== void 0 && pre !== null && req.readableEnded !== false) {
+			if (pre instanceof Uint8Array || typeof pre === "string") body = pre;
+			else if (typeof pre === "object" && Object.keys(pre).length === 0 && headers.get("content-length") === null) body = void 0;
+			else body = JSON.stringify(pre);
+			headers.delete("content-length");
+		} else {
+			const chunks = [];
+			for await (const chunk of req) chunks.push(chunk);
+			body = Buffer.concat(chunks);
+		}
+	}
+	return new Request(url, {
+		method,
+		headers,
+		body
+	});
+}
+async function writeWebResponse(res, response) {
+	res.statusCode = response.status;
+	response.headers.forEach((value, key) => res.setHeader(key, value));
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	const nodeStream = Readable.fromWeb(response.body);
+	nodeStream.on("error", () => res.destroy());
+	nodeStream.pipe(res);
+}
+/**
+* A request listener for `node:http` / `node:https` / `node:http2` (compat).
+* Also usable directly as Express/Connect middleware: non-Matrix paths are
+* passed to `next()` when it is provided, otherwise answered with 404.
+*/
+function getNodeHandler(hs) {
+	return (req, res, next) => {
+		const path = (req.url ?? "/").split("?")[0];
+		if (next && !isMatrixPath(path)) {
+			next();
+			return;
+		}
+		(async () => {
+			const request = await toWebRequest(req);
+			await writeWebResponse(res, await handleRequest(hs, request, { ip: req.socket?.remoteAddress ?? null }));
+		})().catch((err) => {
+			if (next) next(err);
+			else {
+				hs.logger.error("Node handler failure", err);
+				if (!res.headersSent) res.statusCode = 500;
+				res.end();
+			}
+		});
+	};
+}
+/** Express / Connect middleware. Mount with `app.use(getExpressHandler(hs))`. */
+function getExpressHandler(hs) {
+	return getNodeHandler(hs);
+}
+/**
+* Fastify plugin. Register with `fastify.register(getFastifyPlugin(hs))`.
+* The plugin is encapsulated so its raw body parser does not leak into your app.
+*/
+function getFastifyPlugin(hs) {
+	return async (fastify) => {
+		fastify.removeAllContentTypeParsers();
+		fastify.addContentTypeParser("*", { parseAs: "buffer" }, (_req, body, done) => done(null, body));
+		const handler = async (request, reply) => {
+			const webRequest = await toWebRequest(request.raw, request.body ?? /* @__PURE__ */ new Uint8Array());
+			const response = await handleRequest(hs, webRequest, { ip: request.ip ?? null });
+			reply.status(response.status);
+			response.headers.forEach((value, key) => reply.header(key, value));
+			return reply.send(response.body ? Buffer.from(await response.arrayBuffer()) : null);
+		};
+		const methods = [
+			"GET",
+			"POST",
+			"PUT",
+			"DELETE",
+			"OPTIONS",
+			"HEAD"
+		];
+		for (const url of [
+			"/_matrix/*",
+			"/.well-known/matrix/*",
+			"/_synapse/*"
+		]) fastify.route({
+			method: methods,
+			url,
+			handler
+		});
+	};
+}
+/**
+* Hono handler. Mount with `app.all("*", getHonoHandler(hs))` or
+* `app.mount("/", getFetchHandler(hs))`. Non-Matrix paths call `next()`.
+*/
+function getHonoHandler(hs) {
+	return async (c, next) => {
+		const request = c.req.raw;
+		if (!isMatrixPath(new URL(request.url).pathname)) return next();
+		const ip = c.env?.incoming?.socket?.remoteAddress ?? null;
+		return handleRequest(hs, request, { ip });
+	};
+}
+//#endregion
+export { getExpressHandler, getFastifyPlugin, getFetchHandler, getHonoHandler, getNodeHandler, isMatrixPath };

package/dist/http/handler.d.ts

@@ -0,0 +1,8 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/http/handler.d.ts
+export interface HandleOptions {
+  ip?: string | null;
+}
+/** Turn a web-standard Request into a Response. */
+export declare function handleRequest(hs: Homeserver, request: Request, options?: HandleOptions): Promise<Response>;
+//#endregion

package/dist/http/handler.js

@@ -0,0 +1,181 @@
+import { canonicalJson } from "../core/json.js";
+import { UNSTABLE } from "../core/m.js";
+import { MatrixError, errors } from "../core/errors.js";
+//#region src/http/handler.ts
+const CORS_HEADERS = {
+	"access-control-allow-origin": "*",
+	"access-control-allow-methods": "GET, POST, PUT, DELETE, OPTIONS",
+	"access-control-allow-headers": "X-Requested-With, Content-Type, Authorization"
+};
+/** JSON response with a canonical (sorted, compact) body, needed where clients verify signatures over the raw bytes. */
+function canonicalJsonResponse(body) {
+	return new Response(canonicalJson(body), {
+		status: 200,
+		headers: {
+			"content-type": "application/json",
+			...CORS_HEADERS
+		}
+	});
+}
+function jsonResponse(body, status = 200, headers = {}) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: {
+			"content-type": "application/json",
+			...CORS_HEADERS,
+			...headers
+		}
+	});
+}
+function withCors(res) {
+	const out = new Response(res.body, {
+		status: res.status,
+		statusText: res.statusText,
+		headers: res.headers
+	});
+	for (const [k, v] of Object.entries(CORS_HEADERS)) if (!out.headers.has(k)) out.headers.set(k, v);
+	return out;
+}
+/** Turn a web-standard Request into a Response. */
+async function handleRequest(hs, request, options = {}) {
+	if (request.method === "OPTIONS") return new Response(null, {
+		status: 204,
+		headers: CORS_HEADERS
+	});
+	const url = new URL(request.url);
+	const started = performance.now();
+	const response = await dispatch(hs, request, url, options);
+	const info = {
+		method: request.method,
+		path: url.pathname,
+		status: response.status,
+		durationMs: performance.now() - started
+	};
+	if (response.status >= 400 && response.headers.get("content-type") === "application/json" && hs.listenerCount("request") > 0) info.error = await response.clone().json().catch(() => void 0);
+	hs.emit("request", info);
+	return response;
+}
+async function dispatch(hs, request, url, options) {
+	try {
+		if (hs.isClosed) throw new MatrixError(503, "M_UNKNOWN", "Server is shutting down");
+		await hs.ready;
+		const matched = hs.router.match(request.method, url.pathname);
+		if (matched === "method") throw new MatrixError(405, "M_UNRECOGNIZED", "Method not allowed");
+		if (!matched) throw errors.unrecognized();
+		let bodyBytes = null;
+		const readBytes = () => bodyBytes ??= request.arrayBuffer().then((b) => new Uint8Array(b));
+		let session = null;
+		const token = () => extractToken(request, url);
+		const ctx = {
+			hs,
+			request,
+			url,
+			method: request.method,
+			params: matched.params,
+			query: url.searchParams,
+			ip: options.ip ?? null,
+			bytes: readBytes,
+			async json() {
+				const bytes = await readBytes();
+				if (bytes.length === 0) return {};
+				let parsed;
+				try {
+					parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+				} catch {
+					throw errors.notJson();
+				}
+				if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw errors.badJson("Body must be a JSON object");
+				return parsed;
+			},
+			accessToken: token,
+			auth() {
+				return session ??= (async () => {
+					const t = token();
+					if (!t) throw errors.missingToken();
+					const reg = hs.appservices.byToken(t);
+					if (reg) {
+						const userId = await hs.appservices.masquerade(reg, url.searchParams.get("user_id"));
+						const deviceId = url.searchParams.get("device_id") ?? url.searchParams.get(UNSTABLE.ORG.MATRIX.MSC3202.DEVICE_ID);
+						if (deviceId && !await hs.db.findOne("devices", [{
+							field: "user_id",
+							value: userId
+						}, {
+							field: "device_id",
+							value: deviceId
+						}])) throw errors.forbidden("Unknown device for this user");
+						const user = await hs.db.findOne("users", [{
+							field: "user_id",
+							value: userId
+						}]);
+						return {
+							userId,
+							deviceId: deviceId ?? "",
+							accessToken: t,
+							isGuest: false,
+							isAdmin: !!user?.is_admin,
+							appservice: reg
+						};
+					}
+					const session = await hs.auth.authenticate(t, ctx.ip);
+					if (session.locked && !/^\/_matrix\/client\/(?:r0|v3)\/logout(?:\/all)?$/.test(url.pathname)) throw errors.userLocked();
+					return session;
+				})();
+			},
+			async optionalAuth() {
+				return token() ? ctx.auth() : null;
+			},
+			async rateLimit(action) {
+				const s = token() ? await ctx.auth().catch(() => null) : null;
+				if (s?.isAdmin || s?.appservice && s.appservice.rate_limited === false) return;
+				await hs.rateLimits.check(action, s?.userId ?? ctx.ip ?? "unknown");
+			}
+		};
+		const result = await matched.handler(ctx);
+		if (result instanceof Response) return withCors(result);
+		return jsonResponse(result ?? {});
+	} catch (err) {
+		if (err instanceof MatrixError) return jsonResponse(err.toJSON(), err.status);
+		if (isNetworkError(err)) {
+			hs.logger.debug("Remote server unreachable", request.method, url.pathname, err);
+			return jsonResponse({
+				errcode: "M_UNKNOWN",
+				error: `Remote server unreachable: ${err.message}`
+			}, 502);
+		}
+		hs.logger.error("Unhandled error", request.method, url.pathname, err);
+		return jsonResponse({
+			errcode: "M_UNKNOWN",
+			error: "Internal server error"
+		}, 500);
+	}
+}
+const NETWORK_CODES = /* @__PURE__ */ new Set([
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"ETIMEDOUT",
+	"EPIPE",
+	"ERR_TLS_CERT_ALTNAME_INVALID",
+	"DEPTH_ZERO_SELF_SIGNED_CERT",
+	"SELF_SIGNED_CERT_IN_CHAIN",
+	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+	"CERT_HAS_EXPIRED"
+]);
+function isNetworkError(err) {
+	if (!(err instanceof Error)) return false;
+	const code = err.code;
+	return code !== void 0 && NETWORK_CODES.has(code) || /^(Connection timed out|Federation request timed out)$/.test(err.message);
+}
+function extractToken(request, url) {
+	const header = request.headers.get("authorization");
+	if (header) {
+		const m = /^Bearer\s+(.+)$/i.exec(header);
+		if (m) return m[1].trim();
+	}
+	return url.searchParams.get("access_token");
+}
+//#endregion
+export { canonicalJsonResponse, handleRequest, jsonResponse };

package/dist/http/input.js

@@ -0,0 +1,24 @@
+import { MatrixError } from "../core/errors.js";
+import { looseObject } from "../vendor/zod/v4/classic/schemas.js";
+//#region src/http/input.ts
+/** A request body: a JSON object whose unknown keys are kept. */
+const body = (shape) => looseObject(shape);
+/**
+* Errors carry their Matrix errcode in the message, as `M_CODE: text`: `fail` builds the zod
+* error option for a field. Without one, a missing field is M_MISSING_PARAM and any other
+* problem M_BAD_JSON.
+*/
+const fail = (errcode, message, missing) => ({ error: (issue) => issue.input === void 0 && missing ? `M_MISSING_PARAM: ${missing}` : `${errcode}: ${message}` });
+/** A field that, when its value has the wrong type, is ignored (treated as absent), as Matrix clients expect for optional fields. */
+const lenient = (schema) => schema.optional().catch(void 0);
+/** Turn a failed body parse into the Matrix error the client sees. */
+function inputError(error) {
+	const issue = error.issues[0];
+	const path = issue?.path.join(".") ?? "";
+	const tagged = /^(M_[A-Z_]+): ([\s\S]*)$/.exec(issue?.message ?? "");
+	if (tagged) return new MatrixError(400, tagged[1], tagged[2]);
+	if (issue?.code === "invalid_type" && issue.input === void 0) return new MatrixError(400, "M_MISSING_PARAM", `Missing ${path || "parameter"}`);
+	return new MatrixError(400, "M_BAD_JSON", path ? `Invalid ${path}: ${issue.message}` : issue?.message ?? "Bad JSON");
+}
+//#endregion
+export { body, fail, inputError, lenient };