wrangler 2.0.21 → 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";
@@ -76,6 +86,7 @@ export type ConfigPath = string | undefined;
 const resetColor = "\x1b[0m";
 const fgGreenColor = "\x1b[32m";
 export const DEFAULT_LOCAL_PORT = 8787;
+export const DEFAULT_INSPECTOR_PORT = 9229;
 
 const proxy =
 	process.env.https_proxy ||
@@ -258,11 +269,22 @@ function createCLIParser(argv: string[]) {
 		["*"],
 		false,
 		() => {},
-		(args) => {
+		async (args) => {
 			if (args._.length > 0) {
 				throw new CommandLineArgsError(`Unknown command: ${args._}.`);
 			} else {
-				wrangler.showHelp("log");
+				// args.v will exist and be true in the case that no command is called, and the -v
+				// option is present. This is to allow for running asynchronous printWranglerBanner
+				// in the version command.
+				if (args.v) {
+					if (process.stdout.isTTY) {
+						await printWranglerBanner();
+					} else {
+						logger.log(wranglerVersion);
+					}
+				} else {
+					wrangler.showHelp("log");
+				}
 			}
 		}
 	);
@@ -501,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");
@@ -938,6 +966,7 @@ function createCLIParser(argv: string[]) {
 											text_blobs: {},
 											data_blobs: {},
 											worker_namespaces: [],
+											logfwdr: { schema: undefined, bindings: [] },
 											unsafe: [],
 										},
 										modules: [],
@@ -1220,7 +1249,9 @@ function createCLIParser(argv: string[]) {
 
 						const accountId = await requireAuth(config);
 
+						logger.log(`Deleting KV namespace ${id}.`);
 						await deleteKVNamespace(accountId, id);
+						logger.log(`Deleted KV namespace ${id}.`);
 						await metrics.sendMetricsEvent("delete kv namespace", {
 							sendMetrics: config.send_metrics,
 						});
@@ -1732,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>",
@@ -1903,6 +2095,29 @@ function createCLIParser(argv: string[]) {
 		}
 	);
 
+	// This set to false to allow overwrite of default behaviour
+	wrangler.version(false);
+
+	// version
+	wrangler.command(
+		"version",
+		false,
+		() => {},
+		async () => {
+			if (process.stdout.isTTY) {
+				await printWranglerBanner();
+			} else {
+				logger.log(wranglerVersion);
+			}
+		}
+	);
+
+	wrangler.option("v", {
+		describe: "Show version number",
+		alias: "version",
+		type: "boolean",
+	});
+
 	wrangler.option("config", {
 		alias: "c",
 		describe: "Path to .toml configuration file",
@@ -1912,7 +2127,7 @@ function createCLIParser(argv: string[]) {
 
 	wrangler.group(["config", "help", "version"], "Flags:");
 	wrangler.help().alias("h", "help");
-	wrangler.version(wranglerVersion).alias("v", "version");
+
 	wrangler.exitProcess(false);
 
 	return wrangler;

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/is-ci.ts

@@ -0,0 +1,14 @@
+import isCI from "is-ci";
+
+/**
+ * Use this object to find out if we are currently running in a continuous integration environment.
+ *
+ * The isCI constant imported above cannot be easily mocked for testing.
+ * By wrapping this up in a method on an object, it results in clean and testable code.
+ */
+export const CI = {
+	/** Is Wrangler currently running in a CI? */
+	isCI() {
+		return isCI;
+	},
+};

package/src/metrics/metrics-config.ts

@@ -5,9 +5,11 @@ import path from "node:path";
 import { fetchResult } from "../cfetch";
 import { getConfigCache, saveToConfigCache } from "../config-cache";
 import { confirm } from "../dialogs";
+import { getEnvironmentVariableFactory } from "../environment-variables";
 import isInteractive from "../is-interactive";
 import { logger } from "../logger";
 import { getAPIToken } from "../user";
+import { CI } from "./is-ci";
 
 /**
  * The date that the metrics being gathered was last updated in a way that would require
@@ -21,6 +23,10 @@ import { getAPIToken } from "../user";
 export const CURRENT_METRICS_DATE = new Date(2022, 6, 4);
 export const USER_ID_CACHE_PATH = "user-id.json";
 
+export const getWranglerSendMetricsFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_SEND_METRICS",
+});
+
 export interface MetricsConfigOptions {
 	/**
 	 * Defines whether to send metrics to Cloudflare:
@@ -70,6 +76,17 @@ export async function getMetricsConfig({
 	const deviceId = getDeviceId(config);
 	const userId = await getUserId(offline);
 
+	// If the WRANGLER_SEND_METRICS environment variable has been set use that
+	// and ignore everything else.
+	const sendMetricsEnv = getWranglerSendMetricsFromEnv();
+	if (sendMetricsEnv !== undefined) {
+		return {
+			enabled: sendMetricsEnv.toLowerCase() === "true",
+			deviceId,
+			userId,
+		};
+	}
+
 	// If the project is explicitly set the `send_metrics` options in `wrangler.toml`
 	// then use that and ignore any user preference.
 	if (sendMetrics !== undefined) {
@@ -89,8 +106,8 @@ export async function getMetricsConfig({
 	}
 
 	// We couldn't get the metrics permission from the project-level nor the user-level config.
-	// If we are not interactive then just bail out.
-	if (!isInteractive()) {
+	// If we are not interactive or in a CI build then just bail out.
+	if (!isInteractive() || CI.isCI()) {
 		return { enabled: false, deviceId, userId };
 	}
 

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";