wrangler 2.0.23 → 2.0.24

package/src/index.tsx

@@ -1,4 +1,6 @@
+import * as fs from "node:fs";
 import path from "node:path";
+import * as stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import { setTimeout } from "node:timers/promises";
 import TOML from "@iarna/toml";
@@ -45,7 +47,14 @@ import {
 import { previewHandler, previewOptions } from "./preview";
 import publish from "./publish";
 import { pubSubCommands } from "./pubsub/pubsub-commands";
-import { createR2Bucket, deleteR2Bucket, listR2Buckets } from "./r2";
+import {
+	bucketAndKeyFromObjectPath,
+	createR2Bucket,
+	deleteR2Bucket,
+	getR2Object,
+	listR2Buckets,
+	putR2Object,
+} from "./r2";
 import { getAssetPaths, getSiteAssetPaths } from "./sites";
 import {
 	createTail,
@@ -67,6 +76,7 @@ import { workerNamespaceCommands } from "./worker-namespace";
 import type { Config } from "./config";
 import type { KeyValue } from "./kv";
 import type { TailCLIFilters } from "./tail";
+import type { Readable } from "node:stream";
 import type { RawData } from "ws";
 import type { CommandModule } from "yargs";
 import type Yargs from "yargs";
@@ -513,10 +523,16 @@ function createCLIParser(argv: string[]) {
 				(args.config as ConfigPath) ||
 				(args.script && findWranglerToml(path.dirname(args.script)));
 			const config = readConfig(configPath, args);
-			await metrics.sendMetricsEvent("deploy worker script", {
-				sendMetrics: config.send_metrics,
-			});
 			const entry = await getEntry(args, config, "publish");
+			await metrics.sendMetricsEvent(
+				"deploy worker script",
+				{
+					usesTypeScript: /\.tsx?$/.test(entry.file),
+				},
+				{
+					sendMetrics: config.send_metrics,
+				}
+			);
 
 			if (args.public) {
 				throw new Error("The --public field has been renamed to --assets");
@@ -950,6 +966,7 @@ function createCLIParser(argv: string[]) {
 											text_blobs: {},
 											data_blobs: {},
 											worker_namespaces: [],
+											logfwdr: { schema: undefined, bindings: [] },
 											unsafe: [],
 										},
 										modules: [],
@@ -1746,6 +1763,167 @@ function createCLIParser(argv: string[]) {
 	wrangler.command("r2", "📦 Interact with an R2 store", (r2Yargs) => {
 		return r2Yargs
 			.command(subHelp)
+			.command("object", "Manage R2 objects", (r2ObjectYargs) => {
+				return r2ObjectYargs
+					.command(
+						"get <objectPath>",
+						"Fetch an object from an R2 bucket",
+						(yargs) => {
+							return yargs
+								.positional("objectPath", {
+									describe:
+										"The source object path in the form of {bucket}/{key}",
+									type: "string",
+								})
+								.option("file", {
+									describe: "The destination file to create",
+									alias: "f",
+									conflicts: "pipe",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("pipe", {
+									describe:
+										"Enables the file to be piped to a destination, rather than specified with the --file option",
+									alias: "p",
+									conflicts: "file",
+									type: "boolean",
+								});
+						},
+						async (args) => {
+							const config = readConfig(args.config as ConfigPath, args);
+							const accountId = await requireAuth(config);
+							const { objectPath, pipe } = args;
+							const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+
+							let file = args.file;
+							if (!file && !pipe) {
+								file = key;
+							}
+							if (!pipe) {
+								await printWranglerBanner();
+								logger.log(`Downloading "${key}" from "${bucket}".`);
+							}
+							const input = await getR2Object(accountId, bucket, key);
+							const output = file ? fs.createWriteStream(file) : process.stdout;
+							await new Promise<void>((resolve, reject) => {
+								stream.pipeline(input, output, (err: unknown) => {
+									err ? reject(err) : resolve();
+								});
+							});
+							if (!pipe) logger.log("Download complete.");
+						}
+					)
+					.command(
+						"put <objectPath>",
+						"Create an object in an R2 bucket",
+						(yargs) => {
+							return yargs
+								.positional("objectPath", {
+									describe:
+										"The destination object path in the form of {bucket}/{key}",
+									type: "string",
+								})
+								.option("file", {
+									describe: "The path of the file to upload",
+									alias: "f",
+									conflicts: "pipe",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("pipe", {
+									describe:
+										"Enables the file to be piped in, rather than specified with the --file option",
+									alias: "p",
+									conflicts: "file",
+									type: "boolean",
+								})
+								.option("content-type", {
+									describe:
+										"A standard MIME type describing the format of the object data",
+									alias: "ct",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("content-disposition", {
+									describe:
+										"Specifies presentational information for the object",
+									alias: "cd",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("content-encoding", {
+									describe:
+										"Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field",
+									alias: "ce",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("content-language", {
+									describe: "The language the content is in",
+									alias: "cl",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("cache-control", {
+									describe:
+										"Specifies caching behavior along the request/reply chain",
+									alias: "cc",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("expires", {
+									describe:
+										"The date and time at which the object is no longer cacheable",
+									alias: "e",
+									requiresArg: true,
+									type: "string",
+								});
+						},
+						async (args) => {
+							await printWranglerBanner();
+
+							const config = readConfig(args.config as ConfigPath, args);
+							const accountId = await requireAuth(config);
+							const { objectPath, file, pipe, ...options } = args;
+							const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+							if (!file && !pipe) {
+								throw new CommandLineArgsError(
+									"Either the --file or --pipe options are required."
+								);
+							}
+							let object: Readable | Buffer;
+							let objectSize: number;
+							if (file) {
+								object = fs.createReadStream(file);
+								const stats = fs.statSync(file);
+								objectSize = stats.size;
+							} else {
+								object = await new Promise<Buffer>((resolve, reject) => {
+									const stdin = process.stdin;
+									const chunks = Array<Buffer>();
+									stdin.on("data", (chunk) => chunks.push(chunk));
+									stdin.on("end", () => resolve(Buffer.concat(chunks)));
+									stdin.on("error", (err) =>
+										reject(
+											new CommandLineArgsError(
+												`Could not pipe. Reason: "${err.message}"`
+											)
+										)
+									);
+								});
+								objectSize = object.byteLength;
+							}
+
+							logger.log(`Creating object "${key}" in bucket "${bucket}".`);
+							await putR2Object(accountId, bucket, key, object, {
+								...options,
+								"content-length": `${objectSize}`,
+							});
+							logger.log("Upload complete.");
+						}
+					);
+			})
 			.command("bucket", "Manage R2 buckets", (r2BucketYargs) => {
 				r2BucketYargs.command(
 					"create <name>",

package/src/inspect.ts

@@ -1,3 +1,4 @@
+import { readFile } from "fs/promises";
 import assert from "node:assert";
 import { createServer } from "node:http";
 import os from "node:os";
@@ -5,6 +6,7 @@ import { URL } from "node:url";
 
 import open from "open";
 import { useEffect, useRef, useState } from "react";
+import { SourceMapConsumer } from "source-map";
 import WebSocket, { WebSocketServer } from "ws";
 import { version } from "../package.json";
 import { logger } from "./logger";
@@ -52,6 +54,10 @@ interface InspectorProps {
 	 * logged to the terminal by nature of them actually running in node locally.)
 	 */
 	logToTerminal: boolean;
+	/**
+	 * Sourcemap path, so that stacktraces can be interpretted
+	 */
+	sourceMapPath?: string | undefined;
 }
 
 export default function useInspector(props: InspectorProps) {
@@ -252,15 +258,96 @@ export default function useInspector(props: InspectorProps) {
 		 * without having to open the devtools).
 		 */
 		if (props.logToTerminal) {
-			ws.addEventListener("message", (event: MessageEvent) => {
+			ws.addEventListener("message", async (event: MessageEvent) => {
 				if (typeof event.data === "string") {
 					const evt = JSON.parse(event.data);
 					if (evt.method === "Runtime.exceptionThrown") {
 						const params = evt.params as Protocol.Runtime.ExceptionThrownEvent;
-						logger.error(
-							params.exceptionDetails.text,
-							params.exceptionDetails.exception?.description ?? ""
-						);
+
+						// Parse stack trace with source map.
+						if (props.sourceMapPath) {
+							// Parse in the sourcemap
+							const mapContent = JSON.parse(
+								await readFile(props.sourceMapPath, "utf-8")
+							);
+
+							// Create the lines for the exception details log
+							const exceptionLines = [
+								params.exceptionDetails.exception?.description?.split("\n")[0],
+							];
+
+							await SourceMapConsumer.with(
+								mapContent,
+								null,
+								async (consumer) => {
+									// Pass each of the callframes into the consumer, and format the error
+									const stack = params.exceptionDetails.stackTrace?.callFrames;
+
+									stack?.forEach(
+										({ functionName, lineNumber, columnNumber }, i) => {
+											try {
+												if (lineNumber) {
+													// The line and column numbers in the stackTrace are zero indexed,
+													// whereas the sourcemap consumer indexes from one.
+													const pos = consumer.originalPositionFor({
+														line: lineNumber + 1,
+														column: columnNumber + 1,
+													});
+
+													// Print out line which caused error:
+													if (i === 0 && pos.source && pos.line) {
+														const fileSource = consumer.sourceContentFor(
+															pos.source
+														);
+														const fileSourceLine =
+															fileSource?.split("\n")[pos.line - 1] || "";
+														exceptionLines.push(fileSourceLine.trim());
+
+														// If we have a column, we can mark the position underneath
+														if (pos.column) {
+															exceptionLines.push(
+																`${" ".repeat(
+																	pos.column - fileSourceLine.search(/\S/)
+																)}^`
+															);
+														}
+													}
+
+													// From the way esbuild implements the "names" field:
+													// > To save space, the original name is only recorded when it's different from the final name.
+													// however, source-map consumer does not handle this
+													if (pos && pos.line != null) {
+														const convertedFnName =
+															pos.name || functionName || "";
+														exceptionLines.push(
+															`    at ${convertedFnName} (${pos.source?.replace(
+																`${mapContent.sourceRoot}/`,
+																""
+															)}:${pos.line}:${pos.column})`
+														);
+													}
+												}
+											} catch {
+												// Line failed to parse through the sourcemap consumer
+												// We should handle this better
+											}
+										}
+									);
+								}
+							);
+
+							// Log the parsed stacktrace
+							logger.error(
+								params.exceptionDetails.text,
+								exceptionLines.join("\n")
+							);
+						} else {
+							// We log the stacktrace to the terminal
+							logger.error(
+								params.exceptionDetails.text,
+								params.exceptionDetails.exception?.description ?? ""
+							);
+						}
 					}
 					if (evt.method === "Runtime.consoleAPICalled") {
 						logConsoleMessage(
@@ -333,6 +420,7 @@ export default function useInspector(props: InspectorProps) {
 	}, [
 		props.inspectorUrl,
 		props.logToTerminal,
+		props.sourceMapPath,
 		wsServer,
 		// We use a state value as a sigil to trigger a retry of the
 		// remote websocket connection. It's not used inside the effect,

package/src/metrics/index.ts

@@ -2,3 +2,4 @@ export { getMetricsDispatcher } from "./metrics-dispatcher";
 export type { Properties } from "./metrics-dispatcher";
 export { getMetricsConfig } from "./metrics-config";
 export * from "./send-event";
+export { getMetricsUsageHeaders } from "./metrics-usage-headers";

package/src/metrics/metrics-dispatcher.ts

@@ -67,6 +67,7 @@ export async function getMetricsDispatcher(options: MetricsConfigOptions) {
 			properties: {
 				category: "Workers",
 				wranglerVersion,
+				os: process.platform + ":" + process.arch,
 				...event.properties,
 			},
 		});

package/src/metrics/metrics-usage-headers.ts

@@ -0,0 +1,24 @@
+import { getMetricsConfig } from "./metrics-config";
+
+/**
+ * Add an additional header to publish requests if the user has opted into sending usage metrics.
+ *
+ * This allows us to estimate the number of instances of Wrangler that have opted-in
+ * without breaking our agreement not to send stuff if you have not opted-in.
+ */
+export async function getMetricsUsageHeaders(
+	sendMetrics: boolean | undefined
+): Promise<Record<string, string> | undefined> {
+	const metricsEnabled = (
+		await getMetricsConfig({
+			sendMetrics,
+		})
+	).enabled;
+	if (metricsEnabled) {
+		return {
+			metricsEnabled: "true",
+		};
+	} else {
+		return undefined;
+	}
+}

package/src/metrics/send-event.ts

@@ -47,8 +47,8 @@ export type EventNames =
 	| "rename worker namespace"
 	| "create pages project"
 	| "list pages projects"
-	| "deploy pages project"
-	| "list pages projects deployments"
+	| "create pages deployment"
+	| "list pages deployments"
 	| "build pages functions"
 	| "run dev"
 	| "run pages dev";

package/src/module-collection.ts

@@ -123,9 +123,9 @@ export default function createModuleCollector(props: {
 						{
 							filter: new RegExp(
 								"^(" +
-									[...props.wrangler1xlegacyModuleReferences.fileNames].join(
-										"|"
-									) +
+									[...props.wrangler1xlegacyModuleReferences.fileNames]
+										.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+										.join("|") +
 									")$"
 							),
 						},

package/src/pages/constants.ts

@@ -3,5 +3,6 @@ export const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
 export const MAX_BUCKET_FILE_COUNT = 5000;
 export const BULK_UPLOAD_CONCURRENCY = 3;
 export const MAX_UPLOAD_ATTEMPTS = 5;
+export const MAX_CHECK_MISSING_ATTEMPTS = 5;
 export const SECONDS_TO_WAIT_FOR_PROXY = 5;
 export const isInPagesCI = !!process.env.CF_PAGES;

package/src/pages/deployments.tsx

@@ -102,5 +102,5 @@ export async function ListHandler({
 		patchConsole: false,
 	});
 	unmount();
-	await metrics.sendMetricsEvent("list pages projects deployments");
+	await metrics.sendMetricsEvent("list pages deployments");
 }

package/src/pages/dev.tsx

@@ -139,7 +139,12 @@ export const Handler = async ({
 
 	let proxyPort: number | undefined;
 
-	if (directory === undefined) {
+	if (directory !== undefined && command.length > 0) {
+		throw new FatalError(
+			"Specify either a directory OR a proxy command, not both.",
+			1
+		);
+	} else if (directory === undefined) {
 		proxyPort = await spawnProxyProcess({
 			port: requestedProxyPort,
 			command,

package/src/pages/publish.tsx

@@ -334,5 +334,5 @@ export const Handler = async ({
 	logger.log(
 		`✨ Deployment complete! Take a peek over at ${deploymentResponse.url}`
 	);
-	await metrics.sendMetricsEvent("deploy pages project");
+	await metrics.sendMetricsEvent("create pages deployment");
 };

package/src/pages/upload.tsx

@@ -22,6 +22,7 @@ import {
 	BULK_UPLOAD_CONCURRENCY,
 	MAX_BUCKET_FILE_COUNT,
 	MAX_BUCKET_SIZE,
+	MAX_CHECK_MISSING_ATTEMPTS,
 	MAX_UPLOAD_ATTEMPTS,
 } from "./constants";
 import { pagesBetaWarning } from "./utils";
@@ -190,19 +191,37 @@ export const upload = async (
 
 	const start = Date.now();
 
-	const missingHashes = await fetchResult<string[]>(
-		`/pages/assets/check-missing`,
-		{
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${jwt}`,
-			},
-			body: JSON.stringify({
-				hashes: files.map(({ hash }) => hash),
-			}),
+	let attempts = 0;
+	const getMissingHashes = async (): Promise<string[]> => {
+		try {
+			return await fetchResult<string[]>(`/pages/assets/check-missing`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${jwt}`,
+				},
+				body: JSON.stringify({
+					hashes: files.map(({ hash }) => hash),
+				}),
+			});
+		} catch (e) {
+			if (attempts < MAX_CHECK_MISSING_ATTEMPTS) {
+				// Exponential backoff, 1 second first time, then 2 second, then 4 second etc.
+				await new Promise((resolvePromise) =>
+					setTimeout(resolvePromise, Math.pow(2, attempts++) * 1000)
+				);
+
+				if ((e as { code: number }).code === 8000013) {
+					// Looks like the JWT expired, fetch another one
+					jwt = await fetchJwt();
+				}
+				return getMissingHashes();
+			} else {
+				throw e;
+			}
 		}
-	);
+	};
+	const missingHashes = await getMissingHashes();
 
 	const sortedFiles = files
 		.filter((file) => missingHashes.includes(file.hash))
@@ -256,7 +275,7 @@ export const upload = async (
 		// Don't upload empty buckets (can happen for tiny projects)
 		if (bucket.files.length === 0) continue;
 
-		let attempts = 0;
+		attempts = 0;
 		const doUpload = async (): Promise<void> => {
 			// Populate the payload only when actually uploading (this is limited to 3 concurrent uploads at 50 MiB per bucket meaning we'd only load in a max of ~150 MiB)
 			// This is so we don't run out of memory trying to upload the files.