wrangler 2.4.3 → 2.5.0

package/src/dev/start-server.ts

@@ -112,8 +112,8 @@ export async function startDevServer(
 				compatibilityFlags: props.compatibilityFlags,
 				bindings: props.bindings,
 				assetPaths: props.assetPaths,
-				port: props.port,
-				ip: props.ip,
+				initialPort: props.initialPort,
+				initialIp: props.initialIp,
 				rules: props.rules,
 				inspectorPort: props.inspectorPort,
 				localPersistencePath: props.localPersistencePath,
@@ -149,8 +149,8 @@ export async function startDevServer(
 				bindings: props.bindings,
 				assetPaths: props.assetPaths,
 				isWorkersSite: props.isWorkersSite,
-				port: props.port,
-				ip: props.ip,
+				port: props.initialPort,
+				ip: props.initialIp,
 				localProtocol: props.localProtocol,
 				inspectorPort: props.inspectorPort,
 				inspect: props.inspect,
@@ -294,12 +294,12 @@ export async function startLocalServer({
 	bindings,
 	workerDefinitions,
 	assetPaths,
-	port,
+	initialPort,
 	inspectorPort,
 	rules,
 	localPersistencePath,
 	liveReload,
-	ip,
+	initialIp,
 	crons,
 	queueConsumers,
 	localProtocol,
@@ -325,14 +325,11 @@ export async function startLocalServer({
 		if (!bundle || !format) return;
 
 		// port for the worker
-
-		if (port !== 0) {
-			await waitForPortToBeAvailable(port, {
-				retryPeriod: 200,
-				timeout: 2000,
-				abortSignal: abortController.signal,
-			});
-		}
+		await waitForPortToBeAvailable(initialPort, {
+			retryPeriod: 200,
+			timeout: 2000,
+			abortSignal: abortController.signal,
+		});
 
 		if (bindings.services && bindings.services.length > 0) {
 			logger.warn(
@@ -373,10 +370,10 @@ export async function startLocalServer({
 
 		const { forkOptions, miniflareCLIPath, options } = setupMiniflareOptions({
 			workerName,
-			port,
+			port: initialPort,
 			scriptPath,
 			localProtocol,
-			ip,
+			ip: initialIp,
 			format,
 			rules,
 			compatibilityDate,
@@ -429,7 +426,11 @@ export async function startLocalServer({
 			return;
 		}
 
-		const nodeOptions = setupNodeOptions({ inspect, ip, inspectorPort });
+		const nodeOptions = setupNodeOptions({
+			inspect,
+			ip: initialIp,
+			inspectorPort,
+		});
 		logger.log("⎔ Starting a local server...");
 
 		const child = (local = fork(miniflareCLIPath, forkOptions, {
@@ -446,21 +447,21 @@ export async function startLocalServer({
 					await registerWorker(workerName, {
 						protocol: localProtocol,
 						mode: "local",
-						port: message.mfPort,
-						host: ip,
+						port: message.port,
+						host: initialIp,
 						durableObjects: internalDurableObjects.map((binding) => ({
 							name: binding.name,
 							className: binding.class_name,
 						})),
 						...(message.durableObjectsPort
 							? {
-									durableObjectsHost: ip,
+									durableObjectsHost: initialIp,
 									durableObjectsPort: message.durableObjectsPort,
 							  }
 							: {}),
 					});
 				}
-				onReady?.(ip, message.mfPort);
+				onReady?.(initialIp, message.port);
 			}
 		});
 

package/src/dev.tsx

@@ -467,11 +467,13 @@ export async function startDev(args: StartDevOptions) {
 					accountId={configParam.account_id || getAccountFromCache()?.id}
 					assetPaths={assetPaths}
 					assetsConfig={configParam.assets}
-					port={args.port || configParam.dev.port || (await getLocalPort())}
-					ip={args.ip || configParam.dev.ip}
+					initialPort={
+						args.port ?? configParam.dev.port ?? (await getLocalPort())
+					}
+					initialIp={args.ip || configParam.dev.ip}
 					inspectorPort={
-						args.inspectorPort ||
-						configParam.dev.inspector_port ||
+						args.inspectorPort ??
+						configParam.dev.inspector_port ??
 						(await getInspectorPort())
 					}
 					isWorkersSite={Boolean(args.site || configParam.site)}
@@ -584,14 +586,11 @@ export async function startApiDev(args: StartDevOptions) {
 			assetPaths: assetPaths,
 			assetsConfig: configParam.assets,
 			//port can be 0, which means to use a random port
-			port:
-				args.port === 0
-					? args.port
-					: args.port || configParam.dev.port || (await getLocalPort()),
-			ip: args.ip || configParam.dev.ip,
+			initialPort: args.port ?? configParam.dev.port ?? (await getLocalPort()),
+			initialIp: args.ip || configParam.dev.ip,
 			inspectorPort:
-				args["inspector-port"] ||
-				configParam.dev.inspector_port ||
+				args["inspector-port"] ??
+				configParam.dev.inspector_port ??
 				(await getInspectorPort()),
 			isWorkersSite: Boolean(args.site || configParam.site),
 			compatibilityDate: getDevCompatibilityDate(

package/src/miniflare-cli/assets.ts

@@ -3,11 +3,11 @@ import { join } from "node:path";
 import { createMetadataObject } from "@cloudflare/pages-shared/metadata-generator/createMetadataObject";
 import { parseHeaders } from "@cloudflare/pages-shared/metadata-generator/parseHeaders";
 import { parseRedirects } from "@cloudflare/pages-shared/metadata-generator/parseRedirects";
-import { fetch as miniflareFetch } from "@miniflare/core";
 import {
 	Response as MiniflareResponse,
 	Request as MiniflareRequest,
 } from "@miniflare/core";
+import { upgradingFetch as miniflareFetch } from "@miniflare/web-sockets";
 import { watch } from "chokidar";
 import { getType } from "mime";
 import { hashFile } from "../pages/hash";
@@ -40,7 +40,12 @@ export default async function generateASSETSBinding(options: Options) {
 			try {
 				const url = new URL(miniflareRequest.url);
 				url.host = `localhost:${options.proxyPort}`;
-				return await miniflareFetch(url, miniflareRequest);
+				const proxyRequest = new MiniflareRequest(url, miniflareRequest);
+				if (proxyRequest.headers.get("Upgrade") === "websocket") {
+					proxyRequest.headers.delete("Sec-WebSocket-Accept");
+					proxyRequest.headers.delete("Sec-WebSocket-Key");
+				}
+				return await miniflareFetch(proxyRequest);
 			} catch (thrown) {
 				options.log.error(new Error(`Could not proxy request: ${thrown}`));
 

package/src/miniflare-cli/index.ts

@@ -196,7 +196,7 @@ async function main() {
 		process.send &&
 			process.send(
 				JSON.stringify({
-					mfPort: mfPort,
+					port: mfPort,
 					ready: true,
 					durableObjectsPort: durableObjectsMfPort,
 				})

package/src/pages/dev.tsx

@@ -293,7 +293,6 @@ export const Handler = async ({
 				buildOutputDirectory: directory,
 				nodeCompat,
 				local: true,
-				d1Databases: d1s.map((binding) => binding.toString()),
 			});
 			await metrics.sendMetricsEvent("build pages functions");
 
@@ -312,7 +311,6 @@ export const Handler = async ({
 						buildOutputDirectory: directory,
 						nodeCompat,
 						local: true,
-						d1Databases: d1s.map((binding) => binding.toString()),
 					});
 					await metrics.sendMetricsEvent("build pages functions");
 				} catch (e) {

package/src/proxy.ts

@@ -651,6 +651,11 @@ export async function waitForPortToBeAvailable(
 		}
 
 		function checkPort() {
+			if (port === 0) {
+				doResolve();
+				return;
+			}
+
 			// Testing whether a port is 'available' involves simply
 			// trying to make a server listen on that port, and retrying
 			// until it succeeds.