@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/send-C4dDpAxm.mjs

@@ -0,0 +1,495 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { d as isPortableUri } from "./portable-key-id-Ca30-hOa.mjs";
+import { n as version, t as name } from "./deno-oR5aJKpU.mjs";
+import { n as getDurationMs, r as getFederationMetrics } from "./metrics-CYg9yxBL.mjs";
+import { n as doubleKnock } from "./http-siciWkmx.mjs";
+import { getLogger } from "@logtape/logtape";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+import { FetchError, UrlError, canonicalizePortableUri, getFe34Origin, isGatewayUrl, toCompatibleEf61Id, validatePublicUrl } from "@fedify/vocab-runtime";
+import { getPortableGatewayCandidates } from "@fedify/vocab-runtime/internal/portable-dereference";
+/**
+* Resolves a portable inbox, i.e., an `ap:` or `ap+ef61:` URI, to
+* the compatible identifiers of the inbox on the recipient's gateways.
+*
+* The gateways are taken from the recipient's `gateways`, or, if it has no
+* valid gateway, from the `@gateway` location hints of the inbox URI.  Both
+* come from the recipient object, so they are as trustworthy as its inbox.
+* Gateways whose origins are in `excludeBaseUris` are skipped.
+* @param recipient The recipient that owns the inbox.
+* @param inbox The portable inbox.
+* @param excludeBaseUris The base URIs whose origins are not delivered to.
+* @returns The delivery target, or `null` if the inbox is malformed, or no
+*          gateway is left to deliver through.
+*/
+function resolvePortableDeliveryTarget(recipient, inbox, excludeBaseUris) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
+	let portableInbox;
+	try {
+		portableInbox = canonicalizePortableUri(inbox.href);
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		logger.warn("Skipping the recipient {recipient}, as its portable inbox {inbox} is malformed.", {
+			recipient: recipient.id?.href,
+			inbox: inbox.href,
+			error
+		});
+		return null;
+	}
+	let gateways = (recipient.gateways ?? []).filter(isGatewayUrl);
+	if (gateways.length < 1) gateways = getPortableGatewayCandidates(inbox);
+	if (gateways.length < 1) {
+		logger.warn("Skipping the recipient {recipient}, as it has no gateway to deliver to its portable inbox {inbox} through.", {
+			recipient: recipient.id?.href,
+			inbox: portableInbox
+		});
+		return null;
+	}
+	const excludedOrigins = new Set(excludeBaseUris?.map((u) => u.origin));
+	const seen = /* @__PURE__ */ new Set();
+	const inboxes = [];
+	for (const gateway of gateways) {
+		if (inboxes.length >= 5) break;
+		if (seen.has(gateway.origin)) continue;
+		seen.add(gateway.origin);
+		if (excludedOrigins.has(gateway.origin)) continue;
+		try {
+			inboxes.push(toCompatibleEf61Id(inbox, gateway.origin));
+		} catch (error) {
+			if (!(error instanceof TypeError)) throw error;
+			logger.warn("Cannot deliver to the portable inbox {inbox} through the gateway {gateway}, as the inbox cannot be represented as its compatible identifier.", {
+				inbox: portableInbox,
+				gateway: gateway.origin,
+				error
+			});
+		}
+	}
+	if (inboxes.length < 1) {
+		logger.debug("Skipping the recipient {recipient}, as no gateway is left to deliver to its portable inbox {inbox} through.", {
+			recipient: recipient.id?.href,
+			inbox: portableInbox
+		});
+		return null;
+	}
+	return {
+		portableInbox,
+		inboxes
+	};
+}
+/**
+* Merges two ordered lists of compatible inbox URLs, keeping the first URL
+* for each gateway origin and at most {@link MAX_DELIVERY_GATEWAYS} URLs.
+* @param a The preferred list.
+* @param b The other list.
+* @returns The merged list.
+*/
+function mergeGatewayInboxes(a, b) {
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const inbox of [...a, ...b]) {
+		if (merged.length >= 5) break;
+		const { origin } = new URL(inbox);
+		if (seen.has(origin)) continue;
+		seen.add(origin);
+		merged.push(inbox);
+	}
+	return merged;
+}
+/**
+* Gets the part of a delivery's ordering key that tells its destination
+* apart: the DID of a portable inbox, so that deliveries to it stay in order
+* whichever gateway they go through, or the origin of any other inbox.
+* @param inbox The inbox URL.
+* @param portableInbox The canonical portable inbox, if the inbox is
+*                      the compatible identifier of one.
+* @returns The destination part of the ordering key.
+*/
+function getOrderingDestination(inbox, portableInbox) {
+	return portableInbox == null ? new URL(inbox).origin : getFe34Origin(portableInbox);
+}
+//#endregion
+//#region src/federation/send.ts
+/**
+* Extracts the inbox URLs from recipients.
+*
+* An [FEP-ef61] portable inbox, i.e., an `ap:` or `ap+ef61:` URI, is resolved
+* to its compatible identifiers on the recipient's gateways, or, if the
+* recipient has no valid gateway, on the gateways in the `@gateway` location
+* hints of the inbox URI.  The inbox is keyed by the compatible identifier on
+* the first gateway, and the others are listed in
+* {@link ExtractedInbox.gatewayInboxes}.  A recipient whose portable inbox
+* has no gateway to deliver through is skipped.  The shared inbox of
+* a recipient with a portable inbox is never preferred, since only a portable
+* inbox is synchronized between the gateways.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* @param parameters The parameters to extract the inboxes.
+*                   See also {@link ExtractInboxesParameters}.
+* @returns The inboxes as a map of inbox URL to actor URIs.
+*/
+function extractInboxes({ recipients, preferSharedInbox, excludeBaseUris }) {
+	const inboxes = {};
+	const portableKeys = /* @__PURE__ */ new Map();
+	const compatibleKeys = /* @__PURE__ */ new Map();
+	for (const recipient of recipients) {
+		if (recipient.id == null) continue;
+		let inbox;
+		let sharedInbox = false;
+		if (preferSharedInbox && recipient.endpoints?.sharedInbox != null && (recipient.inboxId == null || !isPortableUri(recipient.inboxId))) {
+			inbox = recipient.endpoints.sharedInbox;
+			sharedInbox = true;
+		} else inbox = recipient.inboxId;
+		if (inbox == null) continue;
+		if (isPortableUri(inbox)) {
+			const target = resolvePortableDeliveryTarget(recipient, inbox, excludeBaseUris);
+			if (target == null) continue;
+			const gatewayInboxes = target.inboxes.map((u) => u.href);
+			const existingKeys = /* @__PURE__ */ new Set();
+			const portableKey = portableKeys.get(target.portableInbox);
+			if (portableKey != null) existingKeys.add(portableKey);
+			for (const i of gatewayInboxes) {
+				const k = compatibleKeys.get(i) ?? i;
+				if (Object.hasOwn(inboxes, k)) existingKeys.add(k);
+			}
+			const [key = gatewayInboxes[0], ...otherKeys] = existingKeys;
+			portableKeys.set(target.portableInbox, key);
+			const entry = inboxes[key] ??= {
+				actorIds: /* @__PURE__ */ new Set(),
+				sharedInbox
+			};
+			for (const k of otherKeys) {
+				for (const actorId of inboxes[k].actorIds) entry.actorIds.add(actorId);
+				delete inboxes[k];
+			}
+			entry.sharedInbox = false;
+			entry.portableInbox = target.portableInbox;
+			entry.gatewayInboxes = mergeGatewayInboxes(entry.gatewayInboxes ?? [key], gatewayInboxes);
+			for (const i of entry.gatewayInboxes) compatibleKeys.set(i, key);
+			entry.actorIds.add(recipient.id.href);
+			continue;
+		}
+		if (excludeBaseUris != null && excludeBaseUris.some((u) => u.origin === inbox?.origin)) continue;
+		const key = compatibleKeys.get(inbox.href) ?? inbox.href;
+		inboxes[key] ??= {
+			actorIds: /* @__PURE__ */ new Set(),
+			sharedInbox
+		};
+		inboxes[key].actorIds.add(recipient.id.href);
+	}
+	return inboxes;
+}
+/**
+* Sends an {@link Activity} to an inbox.
+*
+* @param parameters The parameters for sending the activity.
+*                   See also {@link SendActivityParameters}.
+* @throws {Error} If the activity fails to send.
+*/
+function sendActivity(options) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	return tracerProvider.getTracer(name, version).startActiveSpan("activitypub.send_activity", {
+		kind: SpanKind.CLIENT,
+		attributes: { "activitypub.shared_inbox": options.sharedInbox ?? false }
+	}, async (span) => {
+		if (options.activityId != null) span.setAttribute("activitypub.activity.id", options.activityId);
+		if (options.activityType != null) span.setAttribute("activitypub.activity.type", options.activityType);
+		try {
+			await sendActivityInternal({
+				...options,
+				tracerProvider
+			}, span);
+		} catch (e) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(e)
+			});
+			throw e;
+		} finally {
+			span.end();
+		}
+	});
+}
+/**
+* Sends an activity to the first of the given inboxes that accepts it, i.e.,
+* the compatible identifiers of a portable inbox on its gateways, trying them
+* one after another.
+* @param parameters The parameters, except for the inbox.
+* @param inboxes The inboxes to try, in order.  Must not be empty.
+* @throws {Error} The error of the last inbox if no inbox accepts it.
+*/
+async function sendActivityThroughGateways(parameters, inboxes) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
+	let lastError;
+	for (const [i, inbox] of inboxes.entries()) try {
+		await sendActivity({
+			...parameters,
+			inbox
+		});
+		return;
+	} catch (error) {
+		lastError = error;
+		if (i < inboxes.length - 1) logger.warn("Failed to send activity {activityId} to {inbox}; trying the next gateway {next}:\n{error}", {
+			activityId: parameters.activityId,
+			inbox: inbox.href,
+			next: inboxes[i + 1].href,
+			error
+		});
+	}
+	throw lastError;
+}
+const MAX_ERROR_RESPONSE_BODY_BYTES = 1024;
+function getActivityActorId(activity) {
+	if (!isRecord(activity)) return void 0;
+	return getIdValue(activity.actor);
+}
+function getIdValue(value) {
+	if (typeof value === "string" && value !== "") return value;
+	if (value instanceof URL) return value.href;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const id = getIdValue(item);
+			if (id != null) return id;
+		}
+		return;
+	}
+	if (isRecord(value)) return getIdValue(value.id);
+}
+function isRecord(value) {
+	return typeof value === "object" && value != null;
+}
+async function readLimitedResponseBody(response, maxBytes) {
+	if (response.body == null) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	let totalBytes = 0;
+	let truncated = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (totalBytes + value.length > maxBytes) {
+				const remaining = maxBytes - totalBytes;
+				if (remaining > 0) chunks.push(decoder.decode(value.slice(0, remaining), { stream: true }));
+				truncated = true;
+				break;
+			}
+			chunks.push(decoder.decode(value, { stream: true }));
+			totalBytes += value.length;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	let result = chunks.join("");
+	if (truncated) result += "… (truncated)";
+	return result;
+}
+async function sendActivityInternal({ activity, activityId, activityType, keys, inbox, allowPrivateAddress, headers, specDeterminer, meterProvider, tracerProvider }, span) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"outbox"
+	]);
+	const federationMetrics = getFederationMetrics(meterProvider);
+	const started = performance.now();
+	let deliverySuccess = false;
+	async function validateUrl(url) {
+		if (!allowPrivateAddress) try {
+			await validatePublicUrl(url);
+		} catch (error) {
+			if (error instanceof UrlError && error.reason === "dns") {
+				logger.error("DNS resolution failed for URL: {url}", {
+					url,
+					error
+				});
+				const failure = new FetchError(url, error.message);
+				failure.cause = error;
+				throw failure;
+			}
+			if (error instanceof UrlError) logger.error("Disallowed private URL: {url}", {
+				url,
+				error
+			});
+			throw error;
+		}
+	}
+	try {
+		await validateUrl(inbox.href);
+	} catch (error) {
+		if (error instanceof FetchError) federationMetrics.recordDelivery(inbox, getDurationMs(started), false, activityType);
+		throw error;
+	}
+	headers = new Headers(headers);
+	headers.set("Content-Type", "application/activity+json");
+	const request = new Request(inbox, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(activity),
+		redirect: "manual"
+	});
+	let rsaKey = null;
+	for (const key of keys) if (key.privateKey.algorithm.name === "RSASSA-PKCS1-v1_5") {
+		rsaKey = key;
+		break;
+	}
+	if (rsaKey == null && keys.length < 1) logger.debug("Sending the activity {activityId} to {inbox} without a signature.", {
+		activityId,
+		inbox: inbox.href
+	});
+	else if (rsaKey == null) logger.warn("No supported key found to sign the request to {inbox}.  The request will be sent without a signature.  In order to sign the request, at least one RSASSA-PKCS1-v1_5 key must be provided.", {
+		inbox: inbox.href,
+		keys: keys.map((pair) => ({
+			keyId: pair.keyId.href,
+			privateKey: pair.privateKey
+		}))
+	});
+	let response;
+	try {
+		response = rsaKey == null ? await fetchWithValidatedRedirects(request, validateUrl) : await doubleKnock(request, rsaKey, {
+			tracerProvider,
+			specDeterminer,
+			validateRedirect: validateUrl
+		});
+	} catch (error) {
+		const failure = error instanceof FetchError || error instanceof UrlError ? error : createFetchError(inbox.href, error);
+		logger.error("Failed to send activity {activityId} to {inbox}:\n{error}", {
+			activityId,
+			inbox: inbox.href,
+			error: failure
+		});
+		federationMetrics.recordDelivery(inbox, getDurationMs(started), false, activityType);
+		throw failure;
+	}
+	try {
+		if (!response.ok) {
+			let error;
+			try {
+				error = await readLimitedResponseBody(response, MAX_ERROR_RESPONSE_BODY_BYTES);
+			} catch (_) {
+				error = "";
+			}
+			logger.error("Failed to send activity {activityId} to {inbox} ({status} {statusText}):\n{error}", {
+				activityId,
+				inbox: inbox.href,
+				status: response.status,
+				statusText: response.statusText,
+				error
+			});
+			throw new SendActivityError(inbox, response.status, `Failed to send activity ${activityId} to ${inbox.href} (${response.status} ${response.statusText}):\n${error}`, error, response.headers);
+		}
+		deliverySuccess = true;
+		const eventAttributes = {
+			"activitypub.inbox.url": inbox.href,
+			"activitypub.activity.id": activityId ?? ""
+		};
+		if (activityType != null) eventAttributes["activitypub.activity.type"] = activityType;
+		const actorId = getActivityActorId(activity);
+		if (actorId != null) eventAttributes["activitypub.actor.id"] = actorId;
+		span.addEvent("activitypub.activity.sent", eventAttributes);
+	} finally {
+		federationMetrics.recordDelivery(inbox, getDurationMs(started), deliverySuccess, activityType);
+	}
+}
+function createFetchError(url, cause) {
+	const error = new FetchError(url, cause instanceof Error ? cause.message : String(cause));
+	error.cause = cause;
+	return error;
+}
+async function fetchWithValidatedRedirects(request, validateUrl) {
+	let body = await request.clone().text();
+	for (let redirects = 0;; redirects++) {
+		const response = await fetch(request, { redirect: "manual" });
+		const location = response.headers.get("Location");
+		if (![
+			301,
+			302,
+			303,
+			307,
+			308
+		].includes(response.status) || location == null) return response;
+		await response.body?.cancel();
+		if (redirects >= 20) throw new TypeError("Too many redirects");
+		const url = new URL(location, request.url);
+		await validateUrl(url.href);
+		const headers = new Headers(request.headers);
+		if (url.origin !== new URL(request.url).origin) {
+			headers.delete("Authorization");
+			headers.delete("Proxy-Authorization");
+			headers.delete("Cookie");
+			headers.delete("Host");
+		}
+		let method = request.method;
+		if ((response.status === 301 || response.status === 302) && method === "POST" || response.status === 303 && method !== "GET" && method !== "HEAD") {
+			method = "GET";
+			body = void 0;
+			for (const name of [
+				"Content-Encoding",
+				"Content-Language",
+				"Content-Length",
+				"Content-Location",
+				"Content-Type"
+			]) headers.delete(name);
+		}
+		request = new Request(url, {
+			method,
+			headers,
+			body,
+			redirect: "manual"
+		});
+	}
+}
+/**
+* An error that is thrown when an activity fails to send to a remote inbox.
+* It contains structured information about the failure, including the HTTP
+* status code, the inbox URL, and the response body.
+* @since 2.0.0
+*/
+var SendActivityError = class extends Error {
+	/**
+	* The inbox URL that the activity was being sent to.
+	*/
+	inbox;
+	/**
+	* The HTTP status code returned by the inbox.
+	*/
+	statusCode;
+	/**
+	* The response body from the inbox, if any.  Note that this may be
+	* truncated to a maximum of 1 KiB to prevent excessive memory consumption
+	* when remote servers return large error pages (e.g., Cloudflare error pages).
+	* If truncated, the string will end with `"… (truncated)"`.
+	*/
+	responseBody;
+	/**
+	* The response headers from the inbox.
+	* @since 2.3.0
+	*/
+	responseHeaders;
+	/**
+	* Creates a new {@link SendActivityError}.
+	* @param inbox The inbox URL.
+	* @param statusCode The HTTP status code.
+	* @param message The error message.
+	* @param responseBody The response body.
+	* @param responseHeaders The response headers.
+	*/
+	constructor(inbox, statusCode, message, responseBody, responseHeaders) {
+		super(message);
+		this.name = "SendActivityError";
+		this.inbox = inbox;
+		this.statusCode = statusCode;
+		this.responseBody = responseBody;
+		this.responseHeaders = new Headers(responseHeaders);
+	}
+};
+//#endregion
+export { getOrderingDestination as a, sendActivityThroughGateways as i, extractInboxes as n, sendActivity as r, SendActivityError as t };

package/dist/sig/accept.test.mjs

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature, t as formatAcceptSignature } from "../accept-8PiolDP7.mjs";
+import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature, t as formatAcceptSignature } from "../accept-CPVqki78.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual, strictEqual } from "node:assert/strict";
 //#region src/sig/accept.test.ts

package/dist/sig/compound-proof-discovery.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";