@fedify/vocab-runtime 2.5.0-dev.2448 → 2.5.0-dev.2494

package/dist/public-fetch-Dvfvawei.cjs

@@ -0,0 +1,527 @@
+
+const require_url = require("./url-DIKZnaJv.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+let node_net = require("node:net");
+//#region src/pin-grant.ts
+const grants = /* @__PURE__ */ new WeakMap();
+/**
+* Issues a grant for the given URL's origin and addresses.  This does not
+* validate the addresses; callers validate them before issuing, and pinners
+* validate them again right before connecting.
+* @param url The URL whose origin the grant is bound to.
+* @param addresses The addresses to connect to.
+* @returns A new grant.
+*/
+function issuePinGrant(url, addresses) {
+	const grant = Object.freeze(Object.create(null));
+	let hostname = url.hostname;
+	if (hostname.startsWith("[") && hostname.endsWith("]")) hostname = hostname.slice(1, -1);
+	const record = Object.freeze({
+		origin: url.origin,
+		hostname,
+		addresses: Object.freeze(addresses.map(({ address, family }) => Object.freeze({
+			address,
+			family
+		})))
+	});
+	grants.set(grant, {
+		record,
+		revoked: false
+	});
+	return grant;
+}
+/**
+* Checks that the given grant was issued by {@link issuePinGrant}, has not
+* been revoked, and was issued for the origin of the given URL.
+* @param grant The grant to redeem.
+* @param url The URL to connect to.
+* @returns What the grant stands for.
+* @throws {TypeError} If the grant cannot be used for the URL.
+*/
+function redeemPinGrant(grant, url) {
+	const state = typeof grant === "object" && grant !== null ? grants.get(grant) : void 0;
+	if (state == null) throw new TypeError("Invalid pin grant.");
+	if (state.revoked) throw new TypeError("The pin grant has been revoked.");
+	if (url.origin !== state.record.origin) throw new TypeError(`The pin grant for ${state.record.origin} cannot be used for ${url.origin}.`);
+	return state.record;
+}
+/**
+* Revokes the given grant so that it can no longer be redeemed.
+* @param grant The grant to revoke.
+*/
+function revokePinGrant(grant) {
+	const state = grants.get(grant);
+	if (state != null) state.revoked = true;
+}
+//#endregion
+//#region src/pinners/bun.ts
+const logger$1 = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"runtime",
+	"fetch"
+]);
+/**
+* The first Bun version that honors `proxy: false` when proxy environment
+* variables are set at startup.  Earlier versions send pinned requests
+* through the proxy, with the validated IP address as the target.
+*/
+const PROXY_FALSE_MIN_VERSION = "1.4.3";
+const PROXY_VARIABLES = [
+	"HTTP_PROXY",
+	"http_proxy",
+	"HTTPS_PROXY",
+	"https_proxy",
+	"ALL_PROXY",
+	"all_proxy"
+];
+const FALLBACK_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ConnectionRefused",
+	"ECONNREFUSED",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"ETIMEDOUT"
+]);
+/**
+* Bun versions before 1.3.11 verify the server certificate against the `Host`
+* header, including a non-default port, instead of `tls.serverName`, so
+* pinned requests to HTTPS servers on non-default ports always fail the check
+* there.  A custom `checkServerIdentity` cannot stand in for it: these
+* versions send the whole request before a failing custom check aborts it
+* (and 1.3.10 even reuses the connection for the next request), so such
+* requests are refused instead.
+*/
+const HOST_HEADER_IDENTITY_RANGE = "<1.3.11";
+/**
+* Creates a pinner for Bun.  Every request is sent to an IP literal URL with
+* the original `Host` header, `tls.serverName` set to the original hostname
+* (so that the certificate is still verified against it), and `proxy: false`.
+*
+* GET and HEAD requests fall back to the next address on transport errors
+* raised before a response arrives.  Other methods use only the first
+* address, since a transport error does not guarantee that the request did
+* not reach the server, and retrying it could deliver an activity twice.
+* Together with the transport retries of `doubleKnock()`, a GET request is
+* attempted at most twice per address.  Note that Bun 1.4 also reports
+* a connection reset after the request was sent as a `TypeError`, so GET and
+* HEAD requests may be repeated against the next address in that case, which
+* is acceptable for these idempotent methods.
+*
+* Bun versions before 1.3.11 verify certificates against the `Host` header,
+* which includes a non-default port, and cannot safely check them against
+* the original hostname in any other way, so requests to HTTPS servers on
+* non-default ports fail there with a `TypeError` before connecting.
+*
+* Bun versions before 1.4.3 ignore `proxy: false` when proxy environment
+* variables are set, so requests go through the proxy with the validated IP
+* address as the target.  In that case a warning is logged once.
+* @param options The pinner options.
+* @returns The pinner.
+*/
+function createBunPinner({ verifyAddress }) {
+	let proxyWarningPending = ignoresProxyFalse() && hasProxyVariables();
+	return {
+		supports(url) {
+			return url.protocol === "http:" || url.protocol === "https:";
+		},
+		async fetch(grant, request, signal) {
+			const url = new URL(request.url);
+			const { hostname, addresses } = redeemPinGrant(grant, url);
+			if (proxyWarningPending) {
+				proxyWarningPending = false;
+				logger$1.warn("Bun {version} ignores proxy: false while proxy environment variables are set, so outbound requests go through the proxy instead of connecting directly to the validated addresses.  Upgrade to Bun {minVersion} or later, or unset the proxy environment variables; see {url}.", {
+					version: getBun()?.version,
+					minVersion: PROXY_FALSE_MIN_VERSION,
+					url: "https://fedify.dev/manual/deploy#bun-behind-an-http-proxy"
+				});
+			}
+			const fallback = request.method === "GET" || request.method === "HEAD";
+			const candidates = fallback ? addresses : addresses.slice(0, 1);
+			const body = request.body == null ? null : await request.arrayBuffer();
+			let lastError = /* @__PURE__ */ new TypeError(`No address to connect to for ${url.host}.`);
+			for (const address of candidates) {
+				throwIfAborted(signal, request.signal);
+				verifyAddress(address);
+				const headers = new Headers(request.headers);
+				headers.set("Host", url.host);
+				const init = {
+					method: request.method,
+					headers,
+					body,
+					redirect: "manual",
+					signal: signal == null || signal === request.signal ? request.signal : anySignal(signal, request.signal),
+					proxy: false
+				};
+				if (url.protocol === "https:") init.tls = getTlsOptions(url, hostname);
+				try {
+					return await fetch(toAddressUrl(url, address), init);
+				} catch (error) {
+					throwIfAborted(signal, request.signal);
+					if (!fallback || !isFallbackError(error)) throw error;
+					lastError = error;
+				}
+			}
+			throw lastError;
+		},
+		release() {}
+	};
+}
+function getTlsOptions(url, hostname) {
+	const bun = getBun();
+	if (url.port !== "" && bun != null && bun.semver.satisfies(bun.version, HOST_HEADER_IDENTITY_RANGE)) throw new TypeError(`Bun ${bun.version} cannot verify the certificate of ${url.host} when connecting to a validated address; upgrade to Bun 1.3.11 or later to fetch from HTTPS servers on non-default ports.`);
+	return (0, node_net.isIP)(hostname) === 0 ? { serverName: hostname } : {};
+}
+/**
+* Combines two signals without `AbortSignal.any()`, which Bun 1.1.0 lacks.
+*/
+function anySignal(a, b) {
+	if (a.aborted) return a;
+	if (b.aborted) return b;
+	const controller = new AbortController();
+	const abort = (event) => {
+		controller.abort(event.target.reason);
+		a.removeEventListener("abort", abort);
+		b.removeEventListener("abort", abort);
+	};
+	a.addEventListener("abort", abort);
+	b.addEventListener("abort", abort);
+	return controller.signal;
+}
+function toAddressUrl(url, address) {
+	const result = new URL(url);
+	result.hostname = address.family === 6 ? `[${address.address}]` : address.address;
+	return result;
+}
+function isFallbackError(error) {
+	if (error instanceof Error && error.name === "AbortError") return false;
+	if (error instanceof TypeError) return true;
+	const code = error?.code;
+	return typeof code === "string" && FALLBACK_ERROR_CODES.has(code);
+}
+function throwIfAborted(...signals) {
+	for (const signal of signals) signal?.throwIfAborted();
+}
+function getBun() {
+	return globalThis.Bun;
+}
+function ignoresProxyFalse() {
+	const bun = getBun();
+	if (bun == null) return false;
+	return !bun.semver.satisfies(bun.version, `>=${PROXY_FALSE_MIN_VERSION}`);
+}
+function hasProxyVariables() {
+	const env = globalThis.process?.env;
+	if (env == null) return false;
+	return PROXY_VARIABLES.some((name) => (env[name] ?? "") !== "");
+}
+//#endregion
+//#region src/pinners/node.ts
+/**
+* Creates a pinner for Node.js.  Every request is sent through the global
+* `fetch()` with an undici `Agent` as the `dispatcher`.  The agent's
+* `connect.lookup` answers only with the addresses of live grants for
+* the hostname, checking each of them again right before connecting, and
+* fails when there are none, so a connection can never be made to an address
+* that was not validated.
+*
+* The agent is shared by the requests of all grants, so keep-alive
+* connections are reused.  A pooled connection was made to an address of
+* a grant that was valid when it was connected, so reusing it from another
+* session of the same origin still reaches a validated address.  Response
+* bodies have to be consumed or cancelled for their connections to return to
+* the pool, which sessions do when they are closed.
+*
+* Since the dispatcher is passed explicitly, neither proxy environment
+* variables nor the global dispatcher (e.g., `NODE_USE_ENV_PROXY=1`) apply.
+* @param options The pinner options.
+* @returns The pinner.
+*/
+function createNodePinner({ verifyAddress, undici }) {
+	const grants = /* @__PURE__ */ new Map();
+	function lookup(hostname, options, callback) {
+		let addresses;
+		try {
+			addresses = getGrantedAddresses(hostname, options.family);
+		} catch (error) {
+			callback(error, []);
+			return;
+		}
+		if (options.all) callback(null, addresses);
+		else callback(null, addresses[0].address, addresses[0].family);
+	}
+	function getGrantedAddresses(hostname, family) {
+		const addresses = /* @__PURE__ */ new Map();
+		for (const [grant, record] of grants.get(hostname) ?? []) {
+			try {
+				redeemPinGrant(grant, new URL(record.origin));
+			} catch {
+				continue;
+			}
+			for (const address of record.addresses) addresses.set(address.address, address);
+		}
+		const familyNumber = family === "IPv4" ? 4 : family === "IPv6" ? 6 : typeof family === "number" ? family : 0;
+		const result = [...addresses.values()].filter((address) => familyNumber === 0 || address.family === familyNumber);
+		if (result.length < 1) throw new require_url.UrlError(`No validated address to connect to: ${hostname}`);
+		for (const address of result) verifyAddress(address);
+		return result;
+	}
+	const agent = new undici.Agent({ connect: { lookup } });
+	return {
+		supports(url) {
+			return url.protocol === "http:" || url.protocol === "https:";
+		},
+		async fetch(grant, request, signal) {
+			const record = redeemPinGrant(grant, new URL(request.url));
+			if ((0, node_net.isIP)(record.hostname) !== 0) for (const address of record.addresses) verifyAddress(address);
+			let registered = grants.get(record.hostname);
+			if (registered == null) {
+				registered = /* @__PURE__ */ new Map();
+				grants.set(record.hostname, registered);
+			}
+			registered.set(grant, record);
+			return await fetch(request, {
+				redirect: "manual",
+				signal: signal == null || signal === request.signal ? request.signal : AbortSignal.any([signal, request.signal]),
+				dispatcher: agent
+			});
+		},
+		release(grant) {
+			for (const [hostname, registered] of grants) {
+				if (!registered.delete(grant)) continue;
+				if (registered.size < 1) grants.delete(hostname);
+				break;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/pinners/mod.ts
+/**
+* Detects the current runtime.  Cloudflare Workers is checked first, since
+* `process` can exist there with `nodejs_compat`, and Deno and Bun before
+* Node.js, since both provide `process.versions.node`.
+* @returns The current runtime.
+*/
+function detectRuntime() {
+	const g = globalThis;
+	if (g.navigator?.userAgent === "Cloudflare-Workers") return "cfworkers";
+	if ("Deno" in globalThis) return "deno";
+	if ("Bun" in globalThis) return "bun";
+	if (g.process?.versions?.node != null) return "node";
+	return "other";
+}
+let runtimePinner;
+/**
+* Gets the production pinner of the current runtime, which rejects
+* non-public addresses right before connecting.  Deno and Cloudflare Workers
+* have no pinner.
+* @returns The pinner, or `null` if the runtime has none.
+*/
+function getRuntimePinner() {
+	runtimePinner ??= createRuntimePinner(detectRuntime());
+	return runtimePinner;
+}
+async function createRuntimePinner(runtime) {
+	switch (runtime) {
+		case "bun": return createBunPinner({ verifyAddress: require_url.assertPublicAddress });
+		case "node": return createNodePinner({
+			verifyAddress: require_url.assertPublicAddress,
+			undici: await import("undici")
+		});
+		default: return null;
+	}
+}
+//#endregion
+//#region src/public-fetch.ts
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"runtime",
+	"fetch"
+]);
+/**
+* Creates {@link PublicFetch.openPublicFetch} and
+* {@link PublicFetch.withPublicFetch} bound to the given pinner and lookup.
+* This is exported only for tests; it is not exported from any entry point.
+* @param dependencies The pinner and the default lookup function.
+* @returns The functions.
+*/
+function createPublicFetch(dependencies) {
+	async function openPublicFetch(url, options = {}) {
+		const { url: parsed, hostname, family } = require_url.parsePublicUrl(url);
+		if (parsed.username !== "" || parsed.password !== "") throw new require_url.UrlError("URLs with credentials are not allowed");
+		const lookup = options.lookup ?? dependencies.lookup;
+		let addresses;
+		if (family !== 0) addresses = [{
+			address: hostname,
+			family
+		}];
+		else if (lookup === require_url.lookupAllAddresses && !await canResolve()) return createSession(parsed, globalFetch);
+		else {
+			options.signal?.throwIfAborted();
+			addresses = await require_url.lookupPublicAddresses(hostname, lookup);
+			options.signal?.throwIfAborted();
+		}
+		const pinner = await dependencies.pinner();
+		if (pinner == null || !pinner.supports(parsed)) {
+			logUnpinned(parsed);
+			return createSession(parsed, globalFetch);
+		}
+		const grant = issuePinGrant(parsed, addresses);
+		return createSession(parsed, (input, init) => pinner.fetch(grant, new Request(input, init), init.signal ?? void 0), {
+			grant,
+			pinner
+		});
+	}
+	async function withPublicFetch(url, fn, options) {
+		const session = await openPublicFetch(url, options);
+		try {
+			const result = await fn(session.fetch);
+			if (result instanceof Response) throw new TypeError("withPublicFetch() callbacks must not return a Response, since its body is cancelled when the session is closed.");
+			return result;
+		} catch (error) {
+			logger.debug("Failed while fetching {url}; closing the session: {error}", {
+				url: session.url.href,
+				error
+			});
+			throw error;
+		} finally {
+			await session.close();
+		}
+	}
+	return {
+		openPublicFetch,
+		withPublicFetch
+	};
+}
+const runtimePublicFetch = createPublicFetch({
+	pinner: getRuntimePinner,
+	lookup: require_url.lookupAllAddresses
+});
+/**
+* Validates the URL, resolves its hostname, checks that every resolved
+* address is public, and opens a session that connects only to those
+* addresses.  Connections are pinned on Node.js and Bun.  On other runtimes,
+* the session uses the global `fetch()` after the check.
+* @param url The URL to open a session for.
+* @param options The options.
+* @returns The session.  It must be closed.
+* @throws {UrlError} If the URL is not allowed, or its hostname cannot be
+*                    resolved (with `reason: "dns"`).
+*/
+const openPublicFetch = runtimePublicFetch.openPublicFetch;
+/**
+* Opens a session with {@link openPublicFetch}, runs the given function with
+* its `fetch()`, and closes the session afterwards.
+* @param url The URL to open a session for.
+* @param fn The function to run.  It must not return a `Response`, since
+*           the response bodies are cancelled when the session is closed.
+* @param options The options.
+* @returns The value returned by `fn`.
+* @throws {UrlError} If the URL is not allowed.
+* @throws {TypeError} If `fn` returns a `Response`.
+*/
+const withPublicFetch = runtimePublicFetch.withPublicFetch;
+/**
+* Opens a session that neither validates nor pins addresses, for callers that
+* allow private addresses.  It has the same rules as {@link openPublicFetch}
+* sessions otherwise: requests are limited to the URL's origin, redirects are
+* never followed, and unconsumed response bodies are cancelled on close.
+* It grants nothing beyond calling the global `fetch()` directly.
+* @param url The URL to open a session for.
+* @returns The session.  It must be closed.
+*/
+function openDirectFetch(url) {
+	return Promise.resolve(createSession(new URL(url), globalFetch));
+}
+/**
+* Starts cancelling the body of a response without waiting for it to settle.
+* The cancellation of a branch of a tee (e.g., a body cloned by a fetch mock)
+* settles only after the other branch is cancelled too, per the Streams
+* standard, so awaiting it could block forever.  Failures are only logged.
+*/
+function cancelResponseBody(response, url) {
+	response.body?.cancel().catch((error) => {
+		logger.debug("Failed to cancel a response body from {url}: {error}", {
+			url: url.href,
+			error
+		});
+	});
+}
+function globalFetch(input, init) {
+	return fetch(input, init);
+}
+function createSession(url, send, pin) {
+	const origin = url.origin;
+	const tracked = [];
+	let closed = false;
+	async function sessionFetch(input, init) {
+		if (closed) throw new TypeError("The fetch session is closed.");
+		const target = new URL(input instanceof Request ? input.url : input);
+		if (target.origin !== origin) throw new TypeError(`A fetch session for ${origin} cannot fetch ${target.origin}.`);
+		const response = await send(input, {
+			...init,
+			redirect: "manual"
+		});
+		if (closed) {
+			cancelResponseBody(response, url);
+			throw new TypeError("The fetch session is closed.");
+		}
+		tracked.push(response);
+		return response;
+	}
+	async function close() {
+		if (closed) return;
+		closed = true;
+		for (const response of tracked) {
+			if (response.body == null || response.bodyUsed) continue;
+			if (response.body.locked) {
+				logger.debug("Cannot cancel a locked response body from {url}.", { url: url.href });
+				continue;
+			}
+			cancelResponseBody(response, url);
+		}
+		if (pin == null) return;
+		revokePinGrant(pin.grant);
+		await pin.pinner.release(pin.grant);
+	}
+	return {
+		get url() {
+			return new URL(url);
+		},
+		fetch: sessionFetch,
+		close
+	};
+}
+async function canResolve() {
+	if (!("Deno" in globalThis)) return true;
+	return (await Deno.permissions.query({ name: "net" })).state === "granted";
+}
+const loggedUnpinned = /* @__PURE__ */ new Set();
+function logUnpinned(url) {
+	const runtime = detectRuntime();
+	const key = `${runtime} ${url.protocol}`;
+	if (loggedUnpinned.has(key)) return;
+	loggedUnpinned.add(key);
+	logger.debug("Outbound {protocol} connections are not pinned to validated addresses on {runtime}; the hostname is resolved again when connecting.", {
+		runtime,
+		protocol: url.protocol
+	});
+}
+//#endregion
+Object.defineProperty(exports, "openDirectFetch", {
+	enumerable: true,
+	get: function() {
+		return openDirectFetch;
+	}
+});
+Object.defineProperty(exports, "openPublicFetch", {
+	enumerable: true,
+	get: function() {
+		return openPublicFetch;
+	}
+});
+Object.defineProperty(exports, "withPublicFetch", {
+	enumerable: true,
+	get: function() {
+		return withPublicFetch;
+	}
+});