local.tsx

import assert from "node:assert";
import { fork } from "node:child_process";
import { realpathSync } from "node:fs";
import { readFile } from "node:fs/promises";
import path from "node:path";
import chalk from "chalk";
import getPort from "get-port";
import { npxImport } from "npx-import";
import { useState, useEffect, useRef } from "react";
import onExit from "signal-exit";
import { fetch } from "undici";
import { performApiFetch } from "../cfetch/internal";
import { registerWorker } from "../dev-registry";
import useInspector from "../inspect";
import { logger } from "../logger";
import {
	DEFAULT_MODULE_RULES,
	ModuleTypeToRuleType,
} from "../module-collection";
import { getBasePath } from "../paths";
import { waitForPortToBeAvailable } from "../proxy";
import { requireAuth } from "../user";
import type { Config } from "../config";
import type { WorkerRegistry } from "../dev-registry";
import type { LoggerLevel } from "../logger";
import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli/types";
import type { AssetPaths } from "../sites";
import type {
	CfWorkerInit,
	CfScriptFormat,
	CfWasmModuleBindings,
	CfTextBlobBindings,
	CfDataBlobBindings,
	CfDurableObject,
	CfKvNamespace,
	CfR2Bucket,
	CfVars,
	CfQueue,
	CfD1Database,
} from "../worker";
import type { EsbuildBundle } from "./use-esbuild";
import type {
	Miniflare as Miniflare3Type,
	MiniflareOptions as Miniflare3Options,
	Log as Miniflare3LogType,
	CloudflareFetch,
} from "@miniflare/tre";
import type { MiniflareOptions } from "miniflare";
import type { ChildProcess } from "node:child_process";

export interface LocalProps {
	name: string | undefined;
	bundle: EsbuildBundle | undefined;
	format: CfScriptFormat | undefined;
	compatibilityDate: string;
	compatibilityFlags: string[] | undefined;
	usageModel: "bundled" | "unbound" | undefined;
	bindings: CfWorkerInit["bindings"];
	workerDefinitions: WorkerRegistry | undefined;
	assetPaths: AssetPaths | undefined;
	initialPort: number;
	initialIp: string;
	rules: Config["rules"];
	inspectorPort: number;
	localPersistencePath: string | null;
	liveReload: boolean;
	crons: Config["triggers"]["crons"];
	queueConsumers: Config["queues"]["consumers"];
	localProtocol: "http" | "https";
	localUpstream: string | undefined;
	inspect: boolean;
	onReady: ((ip: string, port: number) => void) | undefined;
	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
	testScheduled?: boolean;
	experimentalLocal: boolean | undefined;
	accountId: string | undefined; // Account ID? In local mode??? :exploding_head:
	experimentalLocalRemoteKv: boolean | undefined;
}

type InspectorJSON = {
	id: string;
	title: string;
	type: "node";
	description: string;
	webSocketDebuggerUrl: string;
	devtoolsFrontendUrl: string;
	devtoolsFrontendUrlCompat: string;
	faviconUrl: string;
	url: string;
}[];

export function Local(props: LocalProps) {
	const { inspectorUrl } = useLocalWorker(props);
	useInspector({
		inspectorUrl,
		port: props.inspectorPort,
		logToTerminal: props.experimentalLocal ?? false,
	});
	return null;
}

function useLocalWorker({
	name: workerName,
	bundle,
	format,
	compatibilityDate,
	compatibilityFlags,
	usageModel,
	bindings,
	workerDefinitions,
	assetPaths,
	initialPort,
	rules,
	localPersistencePath,
	liveReload,
	initialIp,
	crons,
	queueConsumers,
	localProtocol,
	localUpstream,
	inspect,
	onReady,
	enablePagesAssetsServiceBinding,
	experimentalLocal,
	accountId,
	experimentalLocalRemoteKv,
}: LocalProps) {
	// TODO: pass vars via command line
	const local = useRef<ChildProcess>();
	const experimentalLocalRef = useRef<Miniflare3Type>();
	const removeSignalExitListener = useRef<() => void>();
	const removeExperimentalLocalSignalExitListener = useRef<() => void>();
	const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();

	// Our inspector proxy server will be binding to `LocalProps`'s `inspectorPort`.
	// If we attempted to bind Node.js/workerd to the same inspector port, we'd get a port already in use error.
	// Therefore, generate a new random port for our runtime's to bind their inspector service to.
	const runtimeInspectorPortRef = useRef<number>();

	useEffect(() => {
		if (bindings.services && bindings.services.length > 0) {
			logger.warn(
				"⎔ Support for service bindings in local mode is experimental and may change."
			);
		}
	}, [bindings.services]);

	useEffect(() => {
		const externalDurableObjects = (
			bindings.durable_objects?.bindings || []
		).filter((binding) => binding.script_name);

		if (externalDurableObjects.length > 0) {
			logger.warn(
				"⎔ Support for external Durable Objects in local mode is experimental and may change."
			);
		}
	}, [bindings.durable_objects?.bindings]);

	useEffect(() => {
		const abortController = new AbortController();
		async function startLocalWorker() {
			if (!bundle || !format) return;

			const scriptPath = realpathSync(bundle.path);

			const upstream =
				typeof localUpstream === "string"
					? `${localProtocol}://${localUpstream}`
					: undefined;

			const {
				externalDurableObjects,
				internalDurableObjects,
				wasmBindings,
				textBlobBindings,
				dataBlobBindings,
			} = setupBindings({
				wasm_modules: bindings.wasm_modules,
				text_blobs: bindings.text_blobs,
				data_blobs: bindings.data_blobs,
				durable_objects: bindings.durable_objects,
				format,
				bundle,
			});

			runtimeInspectorPortRef.current ??= await getPort();
			const runtimeInspectorPort = runtimeInspectorPortRef.current;

			const { forkOptions, miniflareCLIPath, options } = setupMiniflareOptions({
				workerName,
				port: initialPort,
				scriptPath,
				localProtocol,
				ip: initialIp,
				format,
				rules,
				compatibilityDate,
				compatibilityFlags,
				usageModel,
				kv_namespaces: bindings?.kv_namespaces,
				r2_buckets: bindings?.r2_buckets,
				queueBindings: bindings?.queues,
				queueConsumers: queueConsumers,
				d1_databases: bindings?.d1_databases,
				internalDurableObjects,
				externalDurableObjects,
				localPersistencePath,
				liveReload,
				assetPaths,
				vars: bindings?.vars,
				wasmBindings,
				textBlobBindings,
				dataBlobBindings,
				crons,
				upstream,
				workerDefinitions,
				enablePagesAssetsServiceBinding,
			});

			if (experimentalLocal) {
				const log = await buildMiniflare3Logger();
				const mf3Options = await transformMf2OptionsToMf3Options({
					miniflare2Options: options,
					format,
					bundle,
					log,
					enablePagesAssetsServiceBinding,
					kvNamespaces: bindings?.kv_namespaces,
					r2Buckets: bindings?.r2_buckets,
					d1Databases: bindings?.d1_databases,
					authenticatedAccountId: accountId,
					kvRemote: experimentalLocalRemoteKv,
					inspectorPort: runtimeInspectorPort,
				});

				const current = experimentalLocalRef.current;

				if (current === undefined) {
					// If we don't have an active Miniflare instance, create a new one
					const { Miniflare } = await getMiniflare3();
					if (abortController.signal.aborted) return;
					const mf = new Miniflare(mf3Options);
					experimentalLocalRef.current = mf;
					removeExperimentalLocalSignalExitListener.current = onExit(() => {
						logger.log("⎔ Shutting down experimental local server.");
						void mf.dispose();
						experimentalLocalRef.current = undefined;
					});
					await mf.ready;
				} else {
					// Otherwise, reuse the existing instance with its loopback server
					// and just update the options
					if (abortController.signal.aborted) return;
					logger.log("⎔ Reloading experimental local server.");
					await current.setOptions(mf3Options);
				}

				try {
					// fetch the inspector JSON response from the DevTools Inspector protocol
					const inspectorJSONArr = (await (
						await fetch(`http://127.0.0.1:${runtimeInspectorPort}/json`)
					).json()) as InspectorJSON;

					const foundInspectorURL = inspectorJSONArr?.find((inspectorJSON) =>
						inspectorJSON.id.startsWith("core:user")
					)?.webSocketDebuggerUrl;
					if (foundInspectorURL === undefined) {
						setInspectorUrl(undefined);
					} else {
						const url = new URL(foundInspectorURL);
						// Force inspector URL to be different on each reload so `useEffect`
						// in `useInspector` is re-run to connect to newly restarted
						// `workerd` server when updating options. Can't use a query param
						// here as that seems to cause an infinite connection loop, can't
						// use a hash as those are forbidden by `ws`, so username it is.
						url.username = `${Date.now()}-${Math.floor(
							Math.random() * Number.MAX_SAFE_INTEGER
						)}`;
						setInspectorUrl(url.toString());
					}
				} catch (error: unknown) {
					logger.error("Error attempting to retrieve Debugger URL:", error);
				}

				return;
			}

			// Wait for the Worker port to be available. We don't want to do this in experimental local
			// mode, as we only `dispose()` the Miniflare 3 instance, and shutdown the server when
			// unmounting the component, not when props change. If we did, we'd just timeout every time.
			await waitForPortToBeAvailable(initialPort, {
				retryPeriod: 200,
				timeout: 2000,
				abortSignal: abortController.signal,
			});

			const nodeOptions = setupNodeOptions({
				inspect,
				inspectorPort: runtimeInspectorPort,
			});
			logger.log("⎔ Starting a local server...");

			const hasColourSupport =
				chalk.supportsColor.hasBasic && process.env.FORCE_COLOR !== "0";
			const child = (local.current = fork(miniflareCLIPath, forkOptions, {
				cwd: path.dirname(scriptPath),
				execArgv: nodeOptions,
				stdio: "pipe",
				env: {
					...process.env,
					FORCE_COLOR: hasColourSupport ? "1" : undefined,
				},
			}));

			child.on("message", async (messageString) => {
				const message = JSON.parse(messageString as string);
				if (message.ready) {
					// Let's register our presence in the dev registry
					if (workerName) {
						await registerWorker(workerName, {
							protocol: localProtocol,
							mode: "local",
							port: message.port,
							host: initialIp,
							durableObjects: internalDurableObjects.map((binding) => ({
								name: binding.name,
								className: binding.class_name,
							})),
							...(message.durableObjectsPort
								? {
										durableObjectsHost: initialIp,
										durableObjectsPort: message.durableObjectsPort,
								  }
								: {}),
						});
					}
					onReady?.(initialIp, message.port);
				}
			});

			child.on("close", (code) => {
				if (code) {
					logger.log(`Miniflare process exited with code ${code}`);
				}
			});

			child.stdout?.on("data", (data: Buffer) => {
				process.stdout.write(data);
			});

			// parse the node inspector url (which may be received in chunks) from stderr
			let stderrData = "";
			let inspectorUrlFound = false;
			child.stderr?.on("data", (data: Buffer) => {
				if (!inspectorUrlFound) {
					stderrData += data.toString();
					const matches =
						/Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[A-Za-z0-9-]+)[\r|\n]/.exec(
							stderrData
						);
					if (matches) {
						inspectorUrlFound = true;
						setInspectorUrl(matches[1]);
					}
				}

				process.stderr.write(data);
			});

			child.on("exit", (code) => {
				if (code) {
					logger.error(`Miniflare process exited with code ${code}`);
				}
			});

			child.on("error", (error: Error) => {
				logger.error(`Miniflare process failed to spawn`);
				logger.error(error);
			});

			removeSignalExitListener.current = onExit((_code, _signal) => {
				logger.log("⎔ Shutting down local server.");
				child.kill();
				local.current = undefined;
			});
		}

		startLocalWorker().catch((err) => {
			if (err.code === "ERR_RUNTIME_FAILURE") {
				// Don't log a full verbose stack-trace when Miniflare 3's workerd instance fails to start.
				// workerd will log its own errors, and our stack trace won't have any useful information.
				logger.error(err.message);
			} else {
				logger.error("local worker:", err);
			}
		});

		return () => {
			abortController.abort();
			if (local.current) {
				logger.log("⎔ Shutting down local server.");
				local.current?.kill();
				local.current = undefined;
			}
			removeSignalExitListener.current?.();
			removeSignalExitListener.current = undefined;
		};
	}, [
		bundle,
		workerName,
		format,
		initialPort,
		initialIp,
		queueConsumers,
		bindings.queues,
		bindings.durable_objects,
		bindings.kv_namespaces,
		bindings.r2_buckets,
		bindings.d1_databases,
		bindings.vars,
		bindings.services,
		workerDefinitions,
		compatibilityDate,
		compatibilityFlags,
		usageModel,
		localPersistencePath,
		liveReload,
		assetPaths,
		rules,
		bindings.wasm_modules,
		bindings.text_blobs,
		bindings.data_blobs,
		crons,
		localProtocol,
		localUpstream,
		inspect,
		onReady,
		enablePagesAssetsServiceBinding,
		experimentalLocal,
		accountId,
		experimentalLocalRemoteKv,
	]);

	// Rather than disposing the Miniflare instance on every reload, only dispose
	// it if local mode is disabled and the `Local` component is unmounted. This
	// allows us to use the more efficient `Miniflare#setOptions` on reload which
	// retains internal state (e.g. the Miniflare loopback server).
	useEffect(
		() => () => {
			if (experimentalLocalRef.current) {
				logger.log("⎔ Shutting down experimental local server.");
				// Initialisation errors are also thrown asynchronously by dispose().
				// The catch() above should've caught them though.
				experimentalLocalRef.current?.dispose().catch(() => {});
				experimentalLocalRef.current = undefined;
			}
			removeExperimentalLocalSignalExitListener.current?.();
			removeExperimentalLocalSignalExitListener.current = undefined;
		},
		[]
	);

	return { inspectorUrl };
}

interface SetupBindingsProps {
	wasm_modules: CfWasmModuleBindings | undefined;
	text_blobs: CfTextBlobBindings | undefined;
	data_blobs: CfDataBlobBindings | undefined;
	durable_objects: { bindings: CfDurableObject[] } | undefined;
	bundle: EsbuildBundle;
	format: CfScriptFormat;
}

export function setupBindings({
	wasm_modules,
	text_blobs,
	data_blobs,
	durable_objects,
	format,
	bundle,
}: SetupBindingsProps) {
	// the wasm_modules/text_blobs/data_blobs bindings are
	// relative to process.cwd(), but the actual worker bundle
	// is in the temp output directory; so we rewrite the paths to be absolute,
	// letting miniflare resolve them correctly

	// wasm
	const wasmBindings: Record<string, string> = {};
	for (const [name, filePath] of Object.entries(wasm_modules || {})) {
		wasmBindings[name] = path.join(process.cwd(), filePath);
	}

	// text
	const textBlobBindings: Record<string, string> = {};
	for (const [name, filePath] of Object.entries(text_blobs || {})) {
		textBlobBindings[name] = path.join(process.cwd(), filePath);
	}

	// data
	const dataBlobBindings: Record<string, string> = {};
	for (const [name, filePath] of Object.entries(data_blobs || {})) {
		dataBlobBindings[name] = path.join(process.cwd(), filePath);
	}

	if (format === "service-worker") {
		for (const { type, name } of bundle.modules) {
			if (type === "compiled-wasm") {
				// In service-worker format, .wasm modules are referenced by global identifiers,
				// so we convert it here.
				// This identifier has to be a valid JS identifier, so we replace all non alphanumeric
				// characters with an underscore.
				const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
				wasmBindings[identifier] = name;
			} else if (type === "text") {
				// In service-worker format, text modules are referenced by global identifiers,
				// so we convert it here.
				// This identifier has to be a valid JS identifier, so we replace all non alphanumeric
				// characters with an underscore.
				const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
				textBlobBindings[identifier] = name;
			} else if (type === "buffer") {
				// In service-worker format, data blobs are referenced by global identifiers,
				// so we convert it here.
				// This identifier has to be a valid JS identifier, so we replace all non alphanumeric
				// characters with an underscore.
				const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
				dataBlobBindings[identifier] = name;
			}
		}
	}

	const internalDurableObjects = (durable_objects?.bindings || []).filter(
		(binding) => !binding.script_name
	);
	const externalDurableObjects = (durable_objects?.bindings || []).filter(
		(binding) => binding.script_name
	);
	return {
		internalDurableObjects,
		externalDurableObjects,
		wasmBindings,
		textBlobBindings,
		dataBlobBindings,
	};
}

interface SetupMiniflareOptionsProps {
	workerName: string | undefined;
	port: number;
	scriptPath: string;
	localProtocol: "http" | "https";
	ip: string;
	format: CfScriptFormat;
	rules: Config["rules"];
	compatibilityDate: string;
	compatibilityFlags: string[] | undefined;
	usageModel: "bundled" | "unbound" | undefined;
	kv_namespaces: CfKvNamespace[] | undefined;
	queueBindings: CfQueue[] | undefined;
	queueConsumers: Config["queues"]["consumers"];
	r2_buckets: CfR2Bucket[] | undefined;
	d1_databases: CfD1Database[] | undefined;
	internalDurableObjects: CfDurableObject[];
	externalDurableObjects: CfDurableObject[];
	localPersistencePath: string | null;
	liveReload: boolean;
	assetPaths: AssetPaths | undefined;
	vars: CfVars | undefined;
	wasmBindings: Record<string, string>;
	textBlobBindings: Record<string, string>;
	dataBlobBindings: Record<string, string>;
	crons: Config["triggers"]["crons"];
	upstream: string | undefined;
	workerDefinitions: WorkerRegistry | undefined;
	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
}

export function setupMiniflareOptions({
	workerName,
	port,
	scriptPath,
	localProtocol,
	ip,
	format,
	rules,
	compatibilityDate,
	compatibilityFlags,
	usageModel,
	kv_namespaces,
	queueBindings,
	queueConsumers,
	r2_buckets,
	d1_databases,
	internalDurableObjects,
	externalDurableObjects,
	localPersistencePath,
	liveReload,
	assetPaths,
	vars,
	wasmBindings,
	textBlobBindings,
	dataBlobBindings,
	crons,
	upstream,
	workerDefinitions,
	enablePagesAssetsServiceBinding,
}: SetupMiniflareOptionsProps): {
	miniflareCLIPath: string;
	forkOptions: string[];
	options: MiniflareOptions;
} {
	// It's now getting _really_ messy now with Pages ASSETS binding outside and the external Durable Objects inside.
	const options: MiniflareOptions = {
		name: workerName,
		port,
		scriptPath,
		https: localProtocol === "https",
		host: ip,
		modules: format === "modules",
		modulesRules: (rules || [])
			.concat(DEFAULT_MODULE_RULES)
			.map(({ type, globs: include, fallthrough }) => ({
				type,
				include,
				fallthrough,
			})),
		compatibilityDate,
		compatibilityFlags,
		usageModel,
		kvNamespaces: kv_namespaces?.map((kv) => kv.binding),
		queueBindings: queueBindings?.map((queue) => {
			return { name: queue.binding, queueName: queue.queue_name };
		}),
		queueConsumers: queueConsumers?.map((consumer) => {
			const waitMs = consumer.max_batch_timeout
				? 1000 * consumer.max_batch_timeout
				: undefined;
			return {
				queueName: consumer.queue,
				maxBatchSize: consumer.max_batch_size,
				maxWaitMs: waitMs,
				maxRetries: consumer.max_retries,
				deadLetterQueue: consumer.dead_letter_queue,
			};
		}),
		r2Buckets: r2_buckets?.map((r2) => r2.binding),
		durableObjects: Object.fromEntries(
			internalDurableObjects.map((binding) => [
				binding.name,
				binding.class_name,
			])
		),
		externalDurableObjects: Object.fromEntries(
			externalDurableObjects
				.map((binding) => {
					const service =
						workerDefinitions &&
						workerDefinitions[binding.script_name as string];
					if (!service) return [binding.name, undefined];

					const name = service.durableObjects.find(
						(durableObject) => durableObject.className === binding.class_name
					)?.name;
					if (!name) return [binding.name, undefined];

					return [
						binding.name,
						{
							name,
							host: service.durableObjectsHost,
							port: service.durableObjectsPort,
						},
					];
				})
				.filter(([_, details]) => !!details)
		),
		d1Databases: d1_databases?.map((db) => db.binding),
		...(localPersistencePath
			? {
					cachePersist: path.join(localPersistencePath, "cache"),
					durableObjectsPersist: path.join(localPersistencePath, "do"),
					kvPersist: path.join(localPersistencePath, "kv"),
					r2Persist: path.join(localPersistencePath, "r2"),
					d1Persist: path.join(localPersistencePath, "d1"),
			  }
			: {
					// We mark these as true, so that they'll
					// persist in the temp directory.
					// This means they'll persist across a dev session,
					// even if we change source and reload,
					// and be deleted when the dev session ends
					cachePersist: true,
					durableObjectsPersist: true,
					kvPersist: true,
					r2Persist: true,
			  }),

		liveReload,
		sitePath: assetPaths?.assetDirectory
			? path.join(assetPaths.baseDirectory, assetPaths.assetDirectory)
			: undefined,
		siteInclude: assetPaths?.includePatterns.length
			? assetPaths?.includePatterns
			: undefined,
		siteExclude: assetPaths?.excludePatterns.length
			? assetPaths.excludePatterns
			: undefined,
		bindings: vars,
		wasmBindings,
		textBlobBindings,
		dataBlobBindings,
		sourceMap: true,
		logUnhandledRejections: true,
		crons,
		upstream,
		logLevel: logger.loggerLevel,
		enablePagesAssetsServiceBinding,
	};
	// The path to the Miniflare CLI assumes that this file is being run from
	// `wrangler-dist` and that the CLI is found in `miniflare-dist`.
	// If either of those paths change this line needs updating.
	const miniflareCLIPath = path.resolve(
		getBasePath(),
		"miniflare-dist/index.mjs"
	);
	const miniflareOptions = JSON.stringify(options, null);
	const forkOptions = [miniflareOptions];
	if (enablePagesAssetsServiceBinding) {
		forkOptions.push(JSON.stringify(enablePagesAssetsServiceBinding));
	}
	return { miniflareCLIPath, forkOptions, options };
}

export function setupNodeOptions({
	inspect,
	inspectorPort,
}: {
	inspect: boolean;
	inspectorPort: number;
}) {
	const nodeOptions = [
		"--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
		"--no-warnings", // hide annoying Node warnings
		// "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
	];
	if (inspect) {
		nodeOptions.push("--inspect=" + `127.0.0.1:${inspectorPort}`); // start Miniflare listening for a debugger to attach
	}
	return nodeOptions;
}

export interface SetupMiniflare3Options {
	// Regular Miniflare 2 options to transform
	miniflare2Options: MiniflareOptions;
	// Miniflare 3 requires all modules to be manually specified
	format: CfScriptFormat;
	bundle: EsbuildBundle;

	// Miniflare's logger
	log: Miniflare3LogType;

	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;

	// Miniflare 3 accepts namespace/bucket names in addition to binding names.
	// This means multiple workers persisting to the same location can have
	// different binding names for the same namespace/bucket. Therefore, we need
	// the full KV/R2 arrays. This is also required for remote KV storage, as
	// we need actual namespace IDs to connect to.
	kvNamespaces: CfKvNamespace[] | undefined;
	r2Buckets: CfR2Bucket[] | undefined;
	d1Databases: CfD1Database[] | undefined;

	// Account ID to use for authenticated Cloudflare fetch. If true, prompt
	// user for ID if multiple available.
	authenticatedAccountId: string | true | undefined;
	// Whether to read/write from/to real KV namespaces
	kvRemote: boolean | undefined;

	// Port to start DevTools inspector server on
	inspectorPort: number;
}

export async function buildMiniflare3Logger(): Promise<Miniflare3LogType> {
	const { Log, NoOpLog, LogLevel } = await getMiniflare3();

	let level = logger.loggerLevel.toUpperCase() as Uppercase<LoggerLevel>;
	if (level === "LOG") level = "INFO";
	const logLevel = LogLevel[level];

	return logLevel === LogLevel.NONE ? new NoOpLog() : new Log(logLevel);
}

export async function transformMf2OptionsToMf3Options({
	miniflare2Options,
	format,
	bundle,
	log,
	enablePagesAssetsServiceBinding,
	kvNamespaces,
	r2Buckets,
	d1Databases,
	authenticatedAccountId,
	kvRemote,
	inspectorPort,
}: SetupMiniflare3Options): Promise<Miniflare3Options> {
	// Build authenticated Cloudflare API fetch function if required
	let cloudflareFetch: CloudflareFetch | undefined;
	if (kvRemote && authenticatedAccountId !== undefined) {
		const { Response: Miniflare3Response } = await getMiniflare3();
		const preferredAccountId =
			authenticatedAccountId === true ? undefined : authenticatedAccountId;
		const accountId = await requireAuth({ account_id: preferredAccountId });
		cloudflareFetch = async (resource, searchParams, init) => {
			resource = `/accounts/${accountId}/${resource}`;
			const response = await performApiFetch(resource, init, searchParams);
			return new Miniflare3Response(response.body, response);
		};
	}

	const options: Miniflare3Options = {
		...miniflare2Options,
		// Miniflare 3 distinguishes between binding name and namespace/bucket IDs.
		kvNamespaces: Object.fromEntries(
			kvNamespaces?.map(({ binding, id }) => [binding, id]) ?? []
		),
		r2Buckets: Object.fromEntries(
			r2Buckets?.map(({ binding, bucket_name }) => [binding, bucket_name]) ?? []
		),
		d1Databases: Object.fromEntries(
			d1Databases?.map(({ binding, database_id, preview_database_id }) => [
				binding,
				preview_database_id ?? database_id,
			]) ?? []
		),
		inspectorPort,
		verbose: true,
		cloudflareFetch,
		log,
	};

	if (enablePagesAssetsServiceBinding !== undefined) {
		// `../miniflare-cli/assets` dynamically imports`@cloudflare/pages-shared/environment-polyfills`.
		// `@cloudflare/pages-shared/environment-polyfills/types.ts` defines `global`
		// augmentations that pollute the `import`-site's typing environment.
		//
		// We `require` instead of `import`ing here to avoid polluting the main
		// `wrangler` TypeScript project with the `global` augmentations. This
		// relies on the fact that `require` is untyped.
		//
		// eslint-disable-next-line @typescript-eslint/no-var-requires
		const generateASSETSBinding = require("../miniflare-cli/assets").default;
		options.serviceBindings = {
			...options.serviceBindings,
			ASSETS: (await generateASSETSBinding({
				log,
				...enablePagesAssetsServiceBinding,
				tre: true,
				// We can get rid of this `any` easily once we do experimental-local/tre by default
				// eslint-disable-next-line @typescript-eslint/no-explicit-any
			})) as any,
		};
	}

	if (format === "modules") {
		// Manually specify all modules from the bundle. If we didn't do this,
		// Miniflare 3 would try collect them automatically again itself.

		// Resolve entrypoint relative to the temporary directory, ensuring
		// path doesn't start with `..`, which causes issues in `workerd`.
		// Also ensures other modules with relative names can be resolved.
		const root = path.dirname(bundle.path);

		assert.strictEqual(bundle.type, "esm");
		// Required for source mapped paths to resolve correctly
		options.modulesRoot = root;
		options.modules = [
			// Entrypoint
			{
				type: "ESModule",
				path: bundle.path,
				contents: await readFile(bundle.path, "utf-8"),
			},
			// Misc (WebAssembly, etc, ...)
			...bundle.modules.map((module) => ({
				type: ModuleTypeToRuleType[module.type ?? "esm"],
				path: path.resolve(root, module.name),
				contents: module.content,
			})),
		];
	}

	if (kvRemote) {
		// `kvPersist` is always assigned a truthy value in `setupMiniflareOptions`
		assert(options.kvPersist);
		const kvRemoteCache =
			options.kvPersist === true
				? // If storing in temporary directory, find this path from the bundle
				  // output path
				  path.join(path.dirname(bundle.path), ".mf", "kv-remote")
				: // Otherwise, `kvPersist` looks like `.../kv`, so rewrite it to
				  // `kv-remote` since the expected metadata format for remote storage
				  // is different to local
				  path.join(path.dirname(options.kvPersist), "kv-remote");
		options.kvPersist = `remote:?cache=${encodeURIComponent(kvRemoteCache)}`;
	}

	return options;
}

// Caching of the `npx-import`ed `@miniflare/tre` package
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
let miniflare3Module: typeof import("@miniflare/tre");
export async function getMiniflare3(): Promise<
	// eslint-disable-next-line @typescript-eslint/consistent-type-imports
	typeof import("@miniflare/tre")
> {
	return (miniflare3Module ??= await npxImport("@miniflare/tre@3.0.0-next.12"));
}