wrangler 4.131.2 → 4.132.0

package/templates/startDevWorker/ProxyWorker.ts

@@ -1,478 +0,0 @@
-import {
-	createDeferred,
-	type DeferredPromise,
-	isSameUserWorkerOrigin,
-	rewriteUrlInHeaderValue,
-	urlFromParts,
-} from "../../src/api/startDevWorker/utils";
-import type {
-	ProxyData,
-	ProxyWorkerIncomingRequestBody,
-	ProxyWorkerOutgoingRequestBody,
-} from "../../src/api/startDevWorker/events";
-
-interface Env {
-	PROXY_CONTROLLER: Fetcher;
-	PROXY_CONTROLLER_AUTH_SECRET: string;
-	DURABLE_OBJECT: DurableObjectNamespace;
-}
-
-// request.cf.hostMetadata is verbose to type using the workers-types Request -- this allows us to have Request correctly typed in this scope
-type Request = Parameters<
-	NonNullable<
-		ExportedHandler<Env, unknown, ProxyWorkerIncomingRequestBody>["fetch"]
-	>
->[0];
-
-const LIVE_RELOAD_PROTOCOL = "WRANGLER_PROXYWORKER_LIVE_RELOAD_PROTOCOL";
-const LIVE_RELOAD_PATHNAME = "/cdn-cgi/live-reload";
-export default {
-	fetch(req, env) {
-		const singleton = env.DURABLE_OBJECT.idFromName("");
-		const inspectorProxy = env.DURABLE_OBJECT.get(singleton);
-
-		return inspectorProxy.fetch(req);
-	},
-} as ExportedHandler<Env, unknown, ProxyWorkerIncomingRequestBody>;
-
-export class ProxyWorker implements DurableObject {
-	constructor(
-		readonly state: DurableObjectState,
-		readonly env: Env
-	) {}
-
-	proxyData?: ProxyData;
-	requestQueue = new Map<Request, DeferredPromise<Response>>();
-	requestRetryQueue = new Map<Request, DeferredPromise<Response>>();
-
-	fetch(request: Request) {
-		if (isRequestForLiveReloadWebsocket(request)) {
-			// requests for live-reload websocket
-
-			return this.handleLiveReloadWebSocket(request);
-		}
-
-		if (isRequestFromProxyController(request, this.env)) {
-			// requests from ProxyController
-
-			return this.processProxyControllerRequest(request);
-		}
-
-		// regular requests to be proxied
-		const deferred = createDeferred<Response>();
-
-		this.requestQueue.set(request, deferred);
-		this.processQueue();
-
-		return deferred.promise;
-	}
-
-	handleLiveReloadWebSocket(request: Request) {
-		const { 0: response, 1: liveReload } = new WebSocketPair();
-		const websocketProtocol =
-			request.headers.get("Sec-WebSocket-Protocol") ?? "";
-
-		this.state.acceptWebSocket(liveReload, ["live-reload"]);
-
-		return new Response(null, {
-			status: 101,
-			webSocket: response,
-			headers: { "Sec-WebSocket-Protocol": websocketProtocol },
-		});
-	}
-
-	processProxyControllerRequest(request: Request) {
-		const event = request.cf?.hostMetadata;
-		switch (event?.type) {
-			case "pause":
-				this.proxyData = undefined;
-				break;
-
-			case "play":
-				this.proxyData = event.proxyData;
-				this.processQueue();
-				this.state
-					.getWebSockets("live-reload")
-					.forEach((ws) => ws.send("reload"));
-
-				break;
-		}
-
-		return new Response(null, { status: 204 });
-	}
-
-	/**
-	 * Process requests that are being retried first, then process newer requests.
-	 * Requests that are being retried are, by definition, older than requests which haven't been processed yet.
-	 * We don't need to be more accurate than this re ordering, since the requests are being fired off synchronously.
-	 */
-	*getOrderedQueue() {
-		yield* this.requestRetryQueue;
-		yield* this.requestQueue;
-	}
-
-	processQueue() {
-		const { proxyData } = this; // store proxyData at the moment this function was called
-		if (proxyData === undefined) return;
-
-		for (const [request, deferredResponse] of this.getOrderedQueue()) {
-			this.requestRetryQueue.delete(request);
-			this.requestQueue.delete(request);
-
-			const outerUrl = new URL(request.url);
-			const headers = new Headers(request.headers);
-
-			// override url parts for proxying
-			const userWorkerUrl = new URL(request.url);
-			Object.assign(userWorkerUrl, proxyData.userWorkerUrl);
-
-			// set request.url in the UserWorker
-			const innerUrl = urlFromParts(
-				proxyData.userWorkerInnerUrlOverrides ?? {},
-				request.url
-			);
-
-			// rewrite requests to old miniflare paths
-			// because wrangler cannot have a breaking change
-			userWorkerUrl.pathname = rewriteLegacyMiniflarePath(
-				userWorkerUrl.pathname
-			);
-			innerUrl.pathname = rewriteLegacyMiniflarePath(innerUrl.pathname);
-
-			// Preserve client `Accept-Encoding`, rather than using Worker's default
-			// of `Accept-Encoding: br, gzip`
-			const encoding = request.cf?.clientAcceptEncoding;
-			if (encoding !== undefined) headers.set("Accept-Encoding", encoding);
-
-			rewriteUrlRelatedHeaders(headers, outerUrl, innerUrl);
-
-			// Set after `rewriteUrlRelatedHeaders` so that any occurrences of the
-			// outer host inside the URL's query string (e.g. `?redirect_uri=`)
-			// are preserved in `request.url` inside the user worker.
-			headers.set("MF-Original-URL", innerUrl.href);
-
-			// merge proxyData headers with the request headers
-			for (const [key, value] of Object.entries(proxyData.headers ?? {})) {
-				if (value === undefined) continue;
-
-				if (key.toLowerCase() === "cookie") {
-					const existing = request.headers.get("cookie") ?? "";
-					headers.set("cookie", `${existing};${value}`);
-				} else {
-					headers.set(key, value);
-				}
-			}
-
-			/**
-			 * Sends the request to the UserWorker and settles `deferredResponse`
-			 * with the outcome — or requeues the request if the UserWorker is
-			 * mid-reload. The promise chain is deliberately not awaited (`void`):
-			 * we are in a loop and want to process the whole queue quickly +
-			 * synchronously.
-			 *
-			 * A connection-level failure (the `fetch` itself rejects, so no
-			 * response was received) on a same-origin GET/HEAD request is retried
-			 * before being reported — see the rejection handler.
-			 *
-			 * Kept as a `const` arrow function: the handlers re-read
-			 * `this.proxyData` across async boundaries to detect UserWorker
-			 * reloads, so they need the ProxyWorker's lexical `this`.
-			 *
-			 * @param attempt the number of attempts that have already failed
-			 * (`0` on the first try)
-			 */
-			const attemptUserWorkerFetch = (attempt = 0) =>
-				void fetch(userWorkerUrl, new Request(request, { headers }))
-					.then(
-						async (res) => {
-							if (attempt > 0) {
-								console.warn(
-									`ProxyWorker: ${request.method} ${request.url} recovered on attempt ${attempt + 1} after a dropped connection to the UserWorker`
-								);
-							}
-
-							res = new Response(res.body, res);
-							rewriteUrlRelatedHeaders(res.headers, innerUrl, outerUrl);
-
-							await checkForPreviewTokenError(res, this.env, proxyData);
-
-							if (isHtmlResponse(res)) {
-								res = insertLiveReloadScript(request, res, this.env, proxyData);
-							}
-
-							if (isSseResponse(res)) {
-								void sendMessageToProxyController(this.env, {
-									type: "sseResponseDetected",
-								});
-							}
-
-							deferredResponse.resolve(res);
-						},
-						(error: Error) => {
-							// the fetch itself rejected: a connection-level failure, and no
-							// response was received. Errors thrown while post-processing a
-							// received response skip this handler and land in the .catch
-							// below, so they are reported rather than retried and can never
-							// re-run the UserWorker's handler.
-							//
-							// When the UserWorker origin is unchanged (i.e. this is not a
-							// reload — see the same check in the .catch below), the failure
-							// is most commonly the UserWorker's HTTP server closing a reused
-							// keep-alive connection at the same moment this request was
-							// written to it (kj's client pool idleTimeout and server
-							// pipelineTimeout both default to 5s, so a connection idling ~5s
-							// races the close). Retrying bodyless requests draws a fresh
-							// connection and absorbs the race, mirroring the requeue in the
-							// .catch for reloads: retry immediately, then once more after
-							// 250ms (3 attempts in total).
-							if (
-								isSameUserWorkerOrigin(
-									userWorkerUrl,
-									this.proxyData?.userWorkerUrl
-								) &&
-								(request.method === "GET" || request.method === "HEAD") &&
-								attempt < 2
-							) {
-								setTimeout(
-									() => {
-										// the UserWorker may have started reloading while this
-										// retry was queued (even at 0ms — setTimeout defers to a
-										// later task). `proxyData` carries the destination AND the
-										// headers, so retrying with the captured one could reach
-										// the pre-reload Worker or send a stale preview token.
-										// Requeue instead and let the current proxyData rebuild it.
-										if (this.proxyData !== proxyData) {
-											this.requestRetryQueue.set(request, deferredResponse);
-											this.processQueue();
-											return;
-										}
-
-										attemptUserWorkerFetch(attempt + 1);
-									},
-									attempt === 0 ? 0 : 250
-								);
-								return;
-							}
-
-							throw error;
-						}
-					)
-					.catch((error: Error) => {
-						// errors here are from response post-processing, or connection-
-						// level failures rethrown by the rejection handler above (a
-						// non-retriable method, or the retry budget was exhausted)
-
-						// we have crossed an async boundary, so proxyData may have changed
-						// if proxyData.userWorkerUrl has changed, it means there is a new downstream UserWorker
-						// and that this error is stale since it was for a request to the old UserWorker
-						// only report the error if the request still targets the current
-						// UserWorker. isSameUserWorkerOrigin compares origin (not href) so a
-						// genuine error on a non-root path isn't misread as a reload — see
-						// its docs.
-						if (
-							isSameUserWorkerOrigin(
-								userWorkerUrl,
-								this.proxyData?.userWorkerUrl
-							)
-						) {
-							const attemptsNote = ` (failed after ${attempt + 1} ${
-								attempt === 0 ? "attempt" : "attempts"
-							})`;
-							void sendMessageToProxyController(this.env, {
-								type: "error",
-								error: {
-									name: error.name,
-									message: `${request.method} ${request.url}${attemptsNote}: ${error.message}`,
-									stack: error.stack,
-									cause: error.cause,
-								},
-							});
-
-							deferredResponse.reject(error);
-						}
-
-						// if the request can be retried (subset of idempotent requests which have no body), requeue it
-						else if (request.method === "GET" || request.method === "HEAD") {
-							this.requestRetryQueue.set(request, deferredResponse);
-							// we would only end up here if the downstream UserWorker is chang*ing*
-							// i.e. we are in a `pause`d state and expecting a `play` message soon
-							// this request will be processed (retried) when the `play` message arrives
-							// for that reason, we do not need to call `this.processQueue` here
-							// (but, also, it can't hurt to call it since it bails when
-							// in a `pause`d state i.e. `this.proxyData` is undefined)
-						}
-
-						// if the request cannot be retried, respond with 503 Service Unavailable
-						// important to note, this is not an (unexpected) error -- it is an acceptable flow of local development
-						// it would be incorrect to retry non-idempotent requests
-						// and would require cloning all body streams to avoid stream reuse (which is inefficient but not out of the question in the future)
-						// this is a good enough UX for now since it solves the most common GET use-case
-						else {
-							deferredResponse.resolve(
-								new Response(
-									"Your worker restarted mid-request. Please try sending the request again. Only GET or HEAD requests are retried automatically.",
-									{
-										status: 503,
-										headers: { "Retry-After": "0" },
-									}
-								)
-							);
-						}
-					});
-
-			attemptUserWorkerFetch();
-		}
-	}
-}
-
-function isRequestFromProxyController(req: Request, env: Env): boolean {
-	return req.headers.get("Authorization") === env.PROXY_CONTROLLER_AUTH_SECRET;
-}
-
-// Miniflare v5 moved its internal endpoints under `/cdn-cgi/local/` (and
-// `/__cf_local/` for endpoints that must remain reachable over tunnels). These
-// map the pre-v5 paths onto their current equivalents.
-const LEGACY_PATH_REWRITES: readonly [string, string][] = [
-	["/cdn-cgi/handler", "/cdn-cgi/local"],
-	["/cdn-cgi/mf/scheduled", "/cdn-cgi/local/scheduled"],
-	["/cdn-cgi/mf/stream", "/__cf_local/stream"],
-	["/cdn-cgi/mf/imagedelivery", "/__cf_local/imagedelivery"],
-	["/cdn-cgi/explorer", "/cdn-cgi/local/explorer"],
-];
-
-function rewriteLegacyMiniflarePath(pathname: string): string {
-	for (const [oldPrefix, newPrefix] of LEGACY_PATH_REWRITES) {
-		if (pathname === oldPrefix || pathname.startsWith(`${oldPrefix}/`)) {
-			return newPrefix + pathname.slice(oldPrefix.length);
-		}
-	}
-	return pathname;
-}
-function isHtmlResponse(res: Response): boolean {
-	return res.headers.get("content-type")?.startsWith("text/html") ?? false;
-}
-function isSseResponse(res: Response): boolean {
-	return (
-		res.headers.get("content-type")?.startsWith("text/event-stream") ?? false
-	);
-}
-function isRequestForLiveReloadWebsocket(req: Request): boolean {
-	if (new URL(req.url).pathname !== LIVE_RELOAD_PATHNAME) {
-		return false;
-	}
-
-	const websocketProtocol = req.headers.get("Sec-WebSocket-Protocol");
-	const isWebSocketUpgrade = req.headers.get("Upgrade") === "websocket";
-
-	return isWebSocketUpgrade && websocketProtocol === LIVE_RELOAD_PROTOCOL;
-}
-
-function sendMessageToProxyController(
-	env: Env,
-	message: ProxyWorkerOutgoingRequestBody
-) {
-	return env.PROXY_CONTROLLER.fetch("http://dummy", {
-		method: "POST",
-		body: JSON.stringify(message),
-	});
-}
-
-async function checkForPreviewTokenError(
-	response: Response,
-	env: Env,
-	proxyData: ProxyData
-) {
-	if (response.status !== 400) {
-		return;
-	}
-
-	// At this point HTMLRewriter tries to parse the compressed stream,
-	// so we clone and read the text instead.
-	const clone = response.clone();
-	const text = await clone.text();
-	// Naive string match should be good enough when combined with status code check.
-	// "Invalid Workers Preview configuration" is the HTML error returned when the
-	// preview token has expired. "error code: 1031" is a text/plain error returned
-	// by remote bindings (e.g. Workers AI) when their underlying session has timed out.
-	// Both indicate the preview session needs to be refreshed.
-	if (
-		text.includes("Invalid Workers Preview configuration") ||
-		text.includes("error code: 1031")
-	) {
-		void sendMessageToProxyController(env, {
-			type: "previewTokenExpired",
-			proxyData,
-		});
-	}
-}
-
-function insertLiveReloadScript(
-	request: Request,
-	response: Response,
-	env: Env,
-	proxyData: ProxyData
-) {
-	const htmlRewriter = new HTMLRewriter();
-
-	htmlRewriter.onDocument({
-		end(end) {
-			// if liveReload enabled, append a script tag
-			// TODO: compare to existing nodejs implementation
-			if (proxyData.liveReload) {
-				const websocketUrl = new URL(request.url);
-				websocketUrl.protocol =
-					websocketUrl.protocol === "http:" ? "ws:" : "wss:";
-
-				end.append(liveReloadScript, { html: true });
-			}
-		},
-	});
-
-	return htmlRewriter.transform(response);
-}
-
-const liveReloadScript = `
-<script defer type="application/javascript">
-	(function() {
-		var ws;
-		function recover() {
-			ws = null;
-			setTimeout(initLiveReload, 100);
-		}
-		function initLiveReload() {
-			if (ws) return;
-			var origin = (location.protocol === "http:" ? "ws://" : "wss://") + location.host;
-			ws = new WebSocket(origin + "${LIVE_RELOAD_PATHNAME}", "${LIVE_RELOAD_PROTOCOL}");
-			ws.onclose = recover;
-			ws.onerror = recover;
-			ws.onmessage = location.reload.bind(location);
-		}
-		initLiveReload();
-	})();
-</script>
-`;
-
-/**
- * Rewrite references to URLs in request/response headers.
- *
- * This function is used to map the URLs in headers like Origin and Access-Control-Allow-Origin
- * so that this proxy is transparent to the Client Browser and User Worker.
- */
-function rewriteUrlRelatedHeaders(headers: Headers, from: URL, to: URL) {
-	const setCookie = headers.getAll("Set-Cookie");
-	headers.delete("Set-Cookie");
-	headers.forEach((value, key) => {
-		if (typeof value === "string" && value.includes(from.host)) {
-			headers.set(key, rewriteUrlInHeaderValue(value, from, to));
-		}
-	});
-	for (const cookie of setCookie) {
-		headers.append(
-			"Set-Cookie",
-			cookie.replace(
-				new RegExp(`Domain=${from.hostname}($|;|,)`),
-				`Domain=${to.hostname}$1`
-			)
-		);
-	}
-}

package/templates/tsconfig-sanity.ts

@@ -1,11 +0,0 @@
-// @ts-nocheck `@types/node` should NOT be included
-Buffer.from("test");
-
-// @ts-expect-error `@types/jest` should NOT be included
-test("test");
-
-// `@cloudflare/workers-types` should be included
-const _handler: ExportedHandler = {};
-new HTMLRewriter();
-
-export {};

package/templates/tsconfig.init.json

@@ -1,22 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "es2021" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-		"lib": [
-			"es2021"
-		] /* Specify a set of bundled library declaration files that describe the target runtime environment. */,
-		"jsx": "react-jsx" /* Specify what JSX code is generated. */,
-		"module": "ESNext" /* Specify what module code is generated. */,
-		"moduleResolution": "Bundler" /* Specify how TypeScript looks up a file from a given module specifier. */,
-		"types": [
-			"@cloudflare/workers-types"
-		] /* Specify type package names to be included without being referenced in a source file. */,
-		"resolveJsonModule": true /* Enable importing .json files */,
-		"allowJs": true /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */,
-		"noEmit": true /* Disable emitting files from a compilation. */,
-		"isolatedModules": true /* Ensure that each file can be safely transpiled without relying on other imports. */,
-		"allowSyntheticDefaultImports": true /* Allow 'import x from y' when a module doesn't have a default export. */,
-		"strict": true /* Enable all strict type-checking options. */,
-		"noUncheckedIndexedAccess": true,
-		"skipLibCheck": true /* Skip type checking all .d.ts files. */
-	}
-}

package/templates/tsconfig.json

@@ -1,14 +0,0 @@
-{
-	"extends": "@cloudflare/workers-tsconfig/tsconfig.json",
-	"compilerOptions": {
-		"types": ["@cloudflare/workers-types"]
-	},
-	"include": ["**/*.ts"],
-	"exclude": [
-		"__tests__",
-		// Note: `startDevWorker` and `middleware` should also be included but some work is needed
-		//       for that first (see: https://github.com/cloudflare/workers-sdk/issues/8303)
-		"startDevWorker",
-		"middleware"
-	]
-}