wrangler 0.0.0-b2c2c2b → 0.0.0-b36ef43

package/bin/wrangler.js

@@ -52,9 +52,6 @@ Consider using a Node.js version manager such as https://volta.sh/ or https://gi
 	return spawn(
 		process.execPath,
 		[
-			...(semiver(process.versions.node, "18.0.0") >= 0
-				? ["--no-experimental-fetch"] // TODO: remove this when https://github.com/cloudflare/wrangler2/issues/834 is properly fixed
-				: []),
 			"--no-warnings",
 			"--experimental-vm-modules",
 			...process.execArgv,

package/miniflare-dist/index.mjs

@@ -4846,6 +4846,13 @@ var getRequestContextCheckOptions = async () => {
 };
 
 // src/miniflare-cli/index.ts
+var NoOpLog = class extends Log {
+  log() {
+  }
+  error(message) {
+    throw message;
+  }
+};
 async function main() {
   const args = await yargs_default(hideBin(process.argv)).help(false).version(false).option("log", {
     choices: enumKeys(LogLevel)
@@ -4854,9 +4861,9 @@ async function main() {
   const requestContextCheckOptions = await getRequestContextCheckOptions();
   const config = {
     ...JSON.parse(args._[0] ?? "{}"),
-    ...requestContextCheckOptions,
-    log: new Log(logLevel)
+    ...requestContextCheckOptions
   };
+  config.log = config.disableLogs ? new NoOpLog() : new Log(logLevel);
   if (logLevel > LogLevel.INFO) {
     console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
   }

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "wrangler",
-	"version": "0.0.0-b2c2c2b",
+	"version": "0.0.0-b36ef43",
 	"author": "wrangler@cloudflare.com",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"bin": {
 		"wrangler": "./bin/wrangler.js",
 		"wrangler2": "./bin/wrangler.js"
 	},
+	"main": "wrangler-dist/cli.js",
 	"license": "MIT OR Apache-2.0",
 	"bugs": {
 		"url": "https://github.com/cloudflare/wrangler2/issues"
@@ -40,7 +41,7 @@
 		"@esbuild-plugins/node-globals-polyfill": "^0.1.1",
 		"@esbuild-plugins/node-modules-polyfill": "^0.1.4",
 		"blake3-wasm": "^2.1.5",
-		"esbuild": "0.14.34",
+		"esbuild": "0.14.47",
 		"miniflare": "^2.5.1",
 		"nanoid": "^3.3.3",
 		"path-to-regexp": "^6.2.0",

package/src/__tests__/publish.test.ts

@@ -2480,13 +2480,16 @@ addEventListener('fetch', event => {});`
 
 			await runWrangler("publish");
 
-			// We expect this to be uploaded in 3 batches
-			// The first batch has 11 files (88mb)
+			// We expect this to be uploaded in 4 batches
+
+			// The first batch has 11 files
 			expect(requests[0].uploads.length).toEqual(11);
-			// The next batch has 5 files (93mb)
+			// The next batch has 5 files
 			expect(requests[1].uploads.length).toEqual(5);
-			// And the last one has 4 files (98mb)
-			expect(requests[2].uploads.length).toEqual(4);
+			// And the next one has 3 files
+			expect(requests[2].uploads.length).toEqual(3);
+			// And just 1 in the last batch
+			expect(requests[3].uploads.length).toEqual(1);
 
 			let assetIndex = 0;
 			for (const request of requests) {

package/src/api/dev.ts

@@ -0,0 +1,39 @@
+import { startDev } from "../dev";
+import { logger } from "../logger";
+interface DevOptions {
+	env?: string;
+	ip?: string;
+	port?: number;
+	localProtocol?: "http" | "https";
+	assets?: string;
+	site?: string;
+	siteInclude?: string[];
+	siteExclude?: string[];
+	nodeCompat?: boolean;
+	experimentalEnableLocalPersistence?: boolean;
+	_: (string | number)[]; //yargs wants this
+	$0: string; //yargs wants this
+}
+
+export async function unstable_dev(script: string, options: DevOptions) {
+	logger.warn(
+		`unstable_dev() is experimental\nunstable_dev()'s behaviour will likely change in future releases`
+	);
+
+	return new Promise<{ stop: () => void }>((resolve) => {
+		//lmao
+		return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
+			const devServer = startDev({
+				script: script,
+				...options,
+				local: true,
+				onReady: () => ready(devServer),
+				inspect: false,
+				logLevel: "none",
+				showInteractiveDevSession: false,
+			});
+		}).then((devServer) => {
+			resolve({ stop: devServer.stop });
+		});
+	});
+}

package/src/api/index.ts

@@ -0,0 +1 @@
+export { unstable_dev } from "./dev";

package/src/cli.ts

@@ -1,13 +1,27 @@
 import "dotenv/config"; // Grab locally specified env params from a `.env` file.
 import process from "process";
 import { hideBin } from "yargs/helpers";
+import { unstable_dev } from "./api";
 import { FatalError } from "./errors";
 import { main } from ".";
 
-main(hideBin(process.argv)).catch((e) => {
-	// The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
-	// Here we just want to ensure that the process exits with a non-zero code.
-	// We don't want to do this inside the `main()` function, since that would kill the process when running our tests.
-	const exitCode = (e instanceof FatalError && e.code) || 1;
-	process.exit(exitCode);
-});
+/**
+ * The main entrypoint for the CLI.
+ * main only gets called when the script is run directly, not when it's imported as a module.
+ */
+if (require.main) {
+	main(hideBin(process.argv)).catch((e) => {
+		// The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
+		// Here we just want to ensure that the process exits with a non-zero code.
+		// We don't want to do this inside the `main()` function, since that would kill the process when running our tests.
+		const exitCode = (e instanceof FatalError && e.code) || 1;
+		process.exit(exitCode);
+	});
+}
+
+/**
+ * This is how we're exporting the API.
+ * It makes it possible to import wrangler from 'wrangler',
+ * and call wrangler.unstable_dev().
+ */
+module.exports = { unstable_dev };

package/src/dev/dev.tsx

@@ -55,6 +55,10 @@ export type DevProps = {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
+	inspect: boolean | undefined;
+	logLevel: "none" | "error" | "log" | "warn" | "debug" | undefined;
+	onReady: (() => void) | undefined;
+	showInteractiveDevSession: boolean | undefined;
 };
 
 export function DevImplementation(props: DevProps): JSX.Element {
@@ -88,7 +92,8 @@ export function DevImplementation(props: DevProps): JSX.Element {
 
 	// only load the UI if we're running in a supported environment
 	const { isRawModeSupported } = useStdin();
-	return isRawModeSupported ? (
+
+	return props.showInteractiveDevSession ?? isRawModeSupported ? (
 		<InteractiveDevSession {...props} />
 	) : (
 		<DevSession {...props} local={props.initialMode === "local"} />
@@ -171,6 +176,9 @@ function DevSession(props: DevSessionProps) {
 			crons={props.crons}
 			localProtocol={props.localProtocol}
 			localUpstream={props.localUpstream}
+			logLevel={props.logLevel}
+			inspect={props.inspect}
+			onReady={props.onReady}
 		/>
 	) : (
 		<Remote
@@ -193,6 +201,7 @@ function DevSession(props: DevSessionProps) {
 			zone={props.zone}
 			host={props.host}
 			routes={props.routes}
+			onReady={props.onReady}
 		/>
 	);
 }

package/src/dev/local.tsx

@@ -31,6 +31,9 @@ interface LocalProps {
 	crons: Config["triggers"]["crons"];
 	localProtocol: "http" | "https";
 	localUpstream: string | undefined;
+	inspect: boolean | undefined;
+	onReady: (() => void) | undefined;
+	logLevel: "none" | "error" | "log" | "warn" | "debug" | undefined;
 }
 
 export function Local(props: LocalProps) {
@@ -59,6 +62,9 @@ function useLocalWorker({
 	crons,
 	localProtocol,
 	localUpstream,
+	inspect,
+	onReady,
+	logLevel,
 }: LocalProps) {
 	// TODO: pass vars via command line
 	const local = useRef<ReturnType<typeof spawn>>();
@@ -220,6 +226,7 @@ function useLocalWorker({
 				logUnhandledRejections: true,
 				crons,
 				upstream,
+				disableLogs: logLevel === "none",
 			};
 
 			// The path to the Miniflare CLI assumes that this file is being run from
@@ -232,20 +239,25 @@ function useLocalWorker({
 			const optionsArg = JSON.stringify(options, null);
 
 			logger.log("⎔ Starting a local server...");
-			local.current = spawn(
-				"node",
-				[
-					"--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
-					"--no-warnings", // hide annoying Node warnings
-					"--inspect", // start Miniflare listening for a debugger to attach
-					miniflareCLIPath,
-					optionsArg,
-					// "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
-				],
-				{
-					cwd: path.dirname(scriptPath),
-				}
-			);
+			const localServerOptions = [
+				"--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
+				"--no-warnings", // hide annoying Node warnings
+				miniflareCLIPath,
+				optionsArg,
+				// "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
+			];
+			if (inspect) {
+				localServerOptions.push("--inspect"); // start Miniflare listening for a debugger to attach
+			}
+			// spawn isn't technically synchronous here
+			local.current = spawn("node", localServerOptions, {
+				cwd: path.dirname(scriptPath),
+			});
+			//TODO: instead of being lucky with spawn's timing, have miniflare-cli notify wrangler that it's ready in packages/wrangler/src/miniflare-cli/index.ts, after the mf.startScheduler promise resolves
+			if (onReady) {
+				await new Promise((resolve) => setTimeout(resolve, 200));
+				onReady();
+			}
 
 			local.current.on("close", (code) => {
 				if (code) {
@@ -330,6 +342,9 @@ function useLocalWorker({
 		crons,
 		localProtocol,
 		localUpstream,
+		inspect,
+		logLevel,
+		onReady,
 	]);
 	return { inspectorUrl };
 }

package/src/dev/remote.tsx

@@ -36,6 +36,7 @@ export function Remote(props: {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
+	onReady?: () => void;
 }) {
 	const [accountId, setAccountId] = useState(props.accountId);
 	const accountChoicesRef = useRef<Promise<ChooseAccountItem[]>>();
@@ -59,6 +60,7 @@ export function Remote(props: {
 		zone: props.zone,
 		host: props.host,
 		routes: props.routes,
+		onReady: props.onReady,
 	});
 
 	usePreviewServer({
@@ -129,6 +131,7 @@ export function useWorker(props: {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
+	onReady?: () => void;
 }): CfPreviewToken | undefined {
 	const {
 		name,
@@ -142,6 +145,7 @@ export function useWorker(props: {
 		compatibilityFlags,
 		usageModel,
 		port,
+		onReady,
 	} = props;
 	const [token, setToken] = useState<CfPreviewToken | undefined>();
 
@@ -239,6 +243,7 @@ export function useWorker(props: {
 					abortController.signal
 				)
 			);
+			onReady?.();
 		}
 		start().catch((err) => {
 			// we want to log the error, but not end the process
@@ -283,6 +288,7 @@ export function useWorker(props: {
 		props.zone,
 		props.host,
 		props.routes,
+		onReady,
 	]);
 	return token;
 }

package/src/dev.tsx

@@ -57,6 +57,9 @@ interface DevArgs {
 	minify?: boolean;
 	"node-compat"?: boolean;
 	"experimental-enable-local-persistence"?: boolean;
+	onReady?: () => void;
+	logLevel?: "none" | "error" | "log" | "warn" | "debug";
+	showInteractiveDevSession?: boolean;
 }
 
 export function devOptions(yargs: Argv): Argv<DevArgs> {
@@ -231,9 +234,27 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 }
 
 export async function devHandler(args: ArgumentsCamelCase<DevArgs>) {
+	let watcher;
+	try {
+		const devInstance = await startDev(args);
+		watcher = devInstance.watcher;
+		const { waitUntilExit } = devInstance.devReactElement;
+		await waitUntilExit();
+	} finally {
+		await watcher?.close();
+	}
+}
+
+export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 	let watcher: ReturnType<typeof watch> | undefined;
+	let rerender: (node: React.ReactNode) => void | undefined;
 	try {
+		if (args.logLevel) {
+			// we don't define a "none" logLevel, so "error" will do for now.
+			logger.loggerLevel = args.logLevel === "none" ? "error" : args.logLevel;
+		}
 		await printWranglerBanner();
+
 		const configPath =
 			(args.config as ConfigPath) ||
 			((args.script &&
@@ -274,6 +295,7 @@ export async function devHandler(args: ArgumentsCamelCase<DevArgs>) {
 		}
 
 		if (args.inspect) {
+			//devtools are enabled by default, but we still need to disable them if the caller doesn't want them
 			logger.warn(
 				"Passing --inspect is unnecessary, now you can always connect to devtools."
 			);
@@ -469,13 +491,25 @@ export async function devHandler(args: ArgumentsCamelCase<DevArgs>) {
 					usageModel={config.usage_model}
 					bindings={bindings}
 					crons={config.triggers.crons}
+					logLevel={args.logLevel}
+					onReady={args.onReady}
+					inspect={args.inspect}
+					showInteractiveDevSession={args.showInteractiveDevSession}
 				/>
 			);
 		}
-		const { waitUntilExit, rerender } = render(
-			await getDevReactElement(config)
-		);
-		await waitUntilExit();
+		const devReactElement = render(await getDevReactElement(config));
+		rerender = devReactElement.rerender;
+		return {
+			devReactElement,
+			watcher,
+			stop: async () => {
+				devReactElement.unmount();
+				await devReactElement.waitUntilExit();
+				await watcher?.close();
+				process.exit(0);
+			},
+		};
 	} finally {
 		await watcher?.close();
 	}

package/src/miniflare-cli/index.ts

@@ -4,6 +4,16 @@ import { hideBin } from "yargs/helpers";
 import { enumKeys } from "./enum-keys";
 import { getRequestContextCheckOptions } from "./request-context";
 
+// miniflare defines this but importing it throws:
+// Dynamic require of "path" is not supported
+class NoOpLog extends Log {
+	log(): void {}
+
+	error(message: Error): void {
+		throw message;
+	}
+}
+
 async function main() {
 	const args = await yargs(hideBin(process.argv))
 		.help(false)
@@ -17,8 +27,9 @@ async function main() {
 	const config = {
 		...JSON.parse((args._[0] as string) ?? "{}"),
 		...requestContextCheckOptions,
-		log: new Log(logLevel),
 	};
+	//miniflare's logLevel 0 still logs routes, so lets override the logger
+	config.log = config.disableLogs ? new NoOpLog() : new Log(logLevel);
 
 	if (logLevel > LogLevel.INFO) {
 		console.log("OPTIONS:\n", JSON.stringify(config, null, 2));

package/src/preview.ts

@@ -0,0 +1,31 @@
+import { DeprecationError } from "./errors";
+import type { Argv } from "yargs";
+
+export function previewOptions(yargs: Argv) {
+	return yargs
+		.positional("method", {
+			type: "string",
+			describe: "Type of request to preview your worker",
+		})
+		.positional("body", {
+			type: "string",
+			describe: "Body string to post to your preview worker request.",
+		})
+		.option("env", {
+			type: "string",
+			requiresArg: true,
+			describe: "Perform on a specific environment",
+		})
+		.option("watch", {
+			default: true,
+			describe: "Enable live preview",
+			type: "boolean",
+		});
+}
+
+export function previewHandler() {
+	throw new DeprecationError(
+		"The `wrangler preview` command has been deprecated.\n" +
+			"Try using `wrangler dev` to to try out a worker during development.\n"
+	);
+}

package/src/sites.tsx

@@ -138,9 +138,9 @@ export async function syncAssets(
 
 	const manifest: Record<string, string> = {};
 
-	// A batch of uploads where each bucket has to be less than 100mb
+	// A batch of uploads where each bucket has to be less than 98mb
 	const uploadBuckets: KeyValue[][] = [];
-	// The "live" bucket that we'll keep filling until it's just below 100mb
+	// The "live" bucket that we'll keep filling until it's just below 98mb
 	let uploadBucket: KeyValue[] = [];
 	// A size counter for the live bucket
 	let uploadBucketSize = 0;
@@ -166,7 +166,7 @@ export async function syncAssets(
 		const content = await readFile(absAssetFile, "base64");
 		await validateAssetSize(absAssetFile, assetFile);
 		// while KV accepts files that are 25 MiB **before** b64 encoding
-		// the overall bucket size must be below 100 MiB **after** b64 encoding
+		// the overall bucket size must be below 100 MB **after** b64 encoding
 		const assetSize = Buffer.from(content).length;
 		const assetKey = hashAsset(hasher, assetFile, content);
 		validateAssetKey(assetKey);
@@ -176,8 +176,8 @@ export async function syncAssets(
 			logger.log(`Uploading as ${assetKey}...`);
 
 			// Check if adding this asset to the bucket would
-			// push it over the 100 MiB limit KV bulk API limit
-			if (uploadBucketSize + assetSize > 100 * 1024 * 1024) {
+			// push it over the 98 MiB limit KV bulk API limit
+			if (uploadBucketSize + assetSize > 98 * 1000 * 1000) {
 				// If so, move the current bucket into the batch,
 				// and reset the counter/bucket
 				uploadBuckets.push(uploadBucket);