wrangler 2.0.25 → 2.0.28

package/src/cfetch/internal.ts

@@ -1,7 +1,9 @@
 import assert from "node:assert";
-import { fetch, Headers } from "undici";
+import Busboy from "busboy";
+import { fetch, File, FormData, Headers } from "undici";
 import { version as wranglerVersion } from "../../package.json";
 import { getEnvironmentVariableFactory } from "../environment-variables";
+import { logger } from "../logger";
 import { ParseError, parseJSON } from "../parse";
 import { loginOrRefreshIfRequired, requireApiToken } from "../user";
 import type { ApiCredentials } from "../user";
@@ -44,6 +46,13 @@ export async function fetchInternal<ResponseType>(
 
 	const queryString = queryParams ? `?${queryParams.toString()}` : "";
 	const method = init.method ?? "GET";
+
+	logger.debug(
+		`-- START CF API REQUEST: ${method} ${getCloudflareAPIBaseURL()}${resource}${queryString}`
+	);
+	logger.debug("HEADERS:", JSON.stringify(headers, null, 2));
+	logger.debug("INIT:", JSON.stringify(init, null, 2));
+	logger.debug("-- END CF API REQUEST");
 	const response = await fetch(
 		`${getCloudflareAPIBaseURL()}${resource}${queryString}`,
 		{
@@ -54,6 +63,15 @@ export async function fetchInternal<ResponseType>(
 		}
 	);
 	const jsonText = await response.text();
+	logger.debug(
+		"-- START CF API RESPONSE:",
+		response.statusText,
+		response.status
+	);
+	logger.debug("HEADERS:", JSON.stringify(response.headers, null, 2));
+	logger.debug("RESPONSE:", jsonText);
+	logger.debug("-- END CF API RESPONSE");
+
 	try {
 		return parseJSON<ResponseType>(jsonText);
 	} catch (err) {
@@ -179,3 +197,102 @@ export async function fetchR2Objects(
 		);
 	}
 }
+
+/**
+ * This is a wrapper STOPGAP for getting the script which returns a raw text response.
+ */
+export async function fetchDashboardScript(
+	resource: string,
+	bodyInit: RequestInit = {}
+): Promise<string> {
+	await requireLoggedIn();
+	const auth = requireApiToken();
+	const headers = cloneHeaders(bodyInit.headers);
+	addAuthorizationHeaderIfUnspecified(headers, auth);
+	addUserAgent(headers);
+
+	const response = await fetch(`${getCloudflareAPIBaseURL()}${resource}`, {
+		...bodyInit,
+		headers,
+	});
+
+	if (!response.ok || !response.body) {
+		throw new Error(
+			`Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+		);
+	}
+
+	const usesModules = response.headers
+		.get("content-type")
+		?.startsWith("multipart");
+
+	if (usesModules) {
+		// Response from edge contains generic "name = worker.js" for dashboard created scripts
+		const form = await formData(response);
+		const entries = Array.from(form.entries());
+		if (entries.length > 1)
+			throw new RangeError("Expected only one entry in multipart response");
+		const [_, file] = entries[0];
+
+		if (file instanceof File) {
+			return await file.text();
+		}
+
+		return file ?? "";
+
+		// Follow up on issue in Undici about multipart/form-data support & replace the workaround: https://github.com/nodejs/undici/issues/974
+		// This should be using a builtin formData() parser pattern.
+	} else {
+		return response.text();
+	}
+}
+
+async function formData({ headers, body }: Response): Promise<FormData> {
+	// undici doesn't include a multipart/form-data parser yet, so we parse
+	// form data with busboy instead
+	const contentType = headers.get("Content-Type") ?? "";
+	if (!/multipart\/form-data/.test(contentType))
+		throw Error("Need Content-Type for multipart/form-data");
+
+	const responseFormData = new FormData();
+
+	let busboy: Busboy.Busboy;
+
+	const parsedHeaders = Object.fromEntries(
+		Array.from(headers).map(([header, value]) => [header.toLowerCase(), value])
+	);
+	try {
+		busboy = Busboy({ headers: parsedHeaders });
+	} catch (err) {
+		// Error due to headers:
+		throw Object.assign(new TypeError(), { cause: err });
+	}
+
+	busboy.on("field", (name, value) => {
+		responseFormData.append(name, value);
+	});
+	busboy.on("file", (name, value, info) => {
+		const { filename, encoding, mimeType } = info;
+		const base64 = encoding.toLowerCase() === "base64";
+		const chunks: Buffer[] = [];
+		value.on("data", (chunk) => {
+			if (base64) chunk = Buffer.from(chunk.toString(), "base64");
+			chunks.push(chunk);
+		});
+		value.on("end", () => {
+			const file = new File(chunks, filename, { type: mimeType });
+			responseFormData.append(name, file);
+		});
+	});
+
+	const busboyResolve = new Promise((resolve, reject) => {
+		busboy.on("finish", resolve);
+		busboy.on("error", (err) => reject(err));
+	});
+
+	if (body !== null) for await (const chunk of body) busboy.write(chunk);
+	busboy.end();
+	await busboyResolve;
+
+	return responseFormData;
+}

package/src/config/environment.ts

@@ -210,7 +210,7 @@ interface EnvironmentInheritable {
 	 * @default `[]`
 	 * @nonInheritable
 	 */
-	worker_namespaces: {
+	dispatch_namespaces: {
 		/** The binding name used to refer to the bound service. */
 		binding: string;
 		/** The namespace to bind to. */

package/src/config/index.ts

@@ -91,7 +91,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		unsafe,
 		vars,
 		wasm_modules,
-		worker_namespaces,
+		dispatch_namespaces,
 	} = bindings;
 
 	if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
@@ -219,10 +219,10 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
-	if (worker_namespaces !== undefined && worker_namespaces.length > 0) {
+	if (dispatch_namespaces !== undefined && dispatch_namespaces.length > 0) {
 		output.push({
-			type: "Worker Namespaces",
-			entries: worker_namespaces.map(({ binding, namespace }) => {
+			type: "dispatch namespaces",
+			entries: dispatch_namespaces.map(({ binding, namespace }) => {
 				return {
 					key: binding,
 					value: namespace,

package/src/config/validation-helpers.ts

@@ -383,7 +383,7 @@ export const validateRequiredProperty = (
 	container: string,
 	key: string,
 	value: unknown,
-	type: string,
+	type: TypeofType,
 	choices?: unknown[]
 ): boolean => {
 	if (container) {
@@ -417,7 +417,7 @@ export const validateOptionalProperty = (
 	container: string,
 	key: string,
 	value: unknown,
-	type: string,
+	type: TypeofType,
 	choices?: unknown[]
 ): boolean => {
 	if (value !== undefined) {
@@ -440,7 +440,7 @@ export const validateTypedArray = (
 	diagnostics: Diagnostics,
 	container: string,
 	value: unknown,
-	type: string
+	type: TypeofType
 ): boolean => {
 	let isValid = true;
 	if (!Array.isArray(value)) {
@@ -472,7 +472,7 @@ export const validateOptionalTypedArray = (
 	diagnostics: Diagnostics,
 	container: string,
 	value: unknown,
-	type: string
+	type: TypeofType
 ) => {
 	if (value !== undefined) {
 		return validateTypedArray(diagnostics, container, value, type);
@@ -486,7 +486,7 @@ export const validateOptionalTypedArray = (
 export const isRequiredProperty = <T extends object>(
 	obj: object,
 	prop: keyof T,
-	type: string,
+	type: TypeofType,
 	choices?: unknown[]
 ): obj is T =>
 	hasProperty<T>(obj, prop) &&
@@ -499,7 +499,7 @@ export const isRequiredProperty = <T extends object>(
 export const isOptionalProperty = <T extends object>(
 	obj: object,
 	prop: keyof T,
-	type: string
+	type: TypeofType
 ): obj is T => !hasProperty<T>(obj, prop) || typeof obj[prop] === type;
 
 /**
@@ -582,3 +582,16 @@ const isRecord = (
 	value: unknown
 ): value is Record<string | number | symbol, unknown> =>
 	typeof value === "object" && value !== null && !Array.isArray(value);
+
+/**
+ * JavaScript `typeof` operator return values.
+ */
+type TypeofType =
+	| "string"
+	| "number"
+	| "bigint"
+	| "boolean"
+	| "symbol"
+	| "undefined"
+	| "object"
+	| "function";

package/src/config/validation.ts

@@ -899,7 +899,7 @@ function normalizeAndValidateEnvironment(
 
 	experimental(diagnostics, rawEnv, "unsafe");
 	experimental(diagnostics, rawEnv, "services");
-	experimental(diagnostics, rawEnv, "worker_namespaces");
+	experimental(diagnostics, rawEnv, "dispatch_namespaces");
 
 	const route = normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv);
 
@@ -1085,13 +1085,13 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateServiceBinding),
 			[]
 		),
-		worker_namespaces: notInheritable(
+		dispatch_namespaces: notInheritable(
 			diagnostics,
 			topLevelEnv,
 			rawConfig,
 			rawEnv,
 			envName,
-			"worker_namespaces",
+			"dispatch_namespaces",
 			validateBindingArray(envName, validateWorkerNamespaceBinding),
 			[]
 		),
@@ -1630,7 +1630,10 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 		);
 		isValid = false;
 	}
-	if (!isRequiredProperty(value, "id", "string")) {
+	if (
+		!isRequiredProperty(value, "id", "string") ||
+		(value as { id: string }).id.length === 0
+	) {
 		diagnostics.errors.push(
 			`"${field}" bindings should have a string "id" field but got ${JSON.stringify(
 				value
@@ -1668,7 +1671,10 @@ const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
 		);
 		isValid = false;
 	}
-	if (!isRequiredProperty(value, "bucket_name", "string")) {
+	if (
+		!isRequiredProperty(value, "bucket_name", "string") ||
+		(value as { bucket_name: string }).bucket_name.length === 0
+	) {
 		diagnostics.errors.push(
 			`"${field}" bindings should have a string "bucket_name" field but got ${JSON.stringify(
 				value

package/src/config-cache.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import * as path from "path";
 import { findUpSync } from "find-up";
+import { CI } from "./is-ci";
 import isInteractive from "./is-interactive";
 import { logger } from "./logger";
 
@@ -29,7 +30,7 @@ const arrayFormatter = new Intl.ListFormat("en", {
 });
 
 function showCacheMessage(fields: string[], folder: string) {
-	if (!cacheMessageShown && isInteractive()) {
+	if (!cacheMessageShown && isInteractive() && !CI.isCI()) {
 		if (fields.length > 0) {
 			logger.log(
 				`Retrieving cached values for ${arrayFormatter.format(

package/src/create-worker-upload-form.ts

@@ -23,6 +23,31 @@ export function toMimeType(type: CfModuleType): string {
 	}
 }
 
+type WorkerMetadataBinding =
+	// If you add any new binding types here, also add it to safeBindings
+	// under validateUnsafeBinding in config/validation.ts
+	| { type: "plain_text"; name: string; text: string }
+	| { type: "json"; name: string; json: unknown }
+	| { type: "wasm_module"; name: string; part: string }
+	| { type: "text_blob"; name: string; part: string }
+	| { type: "data_blob"; name: string; part: string }
+	| { type: "kv_namespace"; name: string; namespace_id: string }
+	| {
+			type: "durable_object_namespace";
+			name: string;
+			class_name: string;
+			script_name?: string;
+			environment?: string;
+	  }
+	| { type: "r2_bucket"; name: string; bucket_name: string }
+	| { type: "service"; name: string; service: string; environment?: string }
+	| { type: "namespace"; name: string; namespace: string }
+	| {
+			type: "logfwdr";
+			name: string;
+			destination: string;
+	  };
+
 export interface WorkerMetadata {
 	/** The name of the entry point module. Only exists when the worker is in the ES module format */
 	main_module?: string;
@@ -33,31 +58,8 @@ export interface WorkerMetadata {
 	usage_model?: "bundled" | "unbound";
 	migrations?: CfDurableObjectMigrations;
 	capnp_schema?: string;
-	// If you add any new binding types here, also add it to safeBindings
-	// under validateUnsafeBinding in config/validation.ts
-	bindings: (
-		| { type: "plain_text"; name: string; text: string }
-		| { type: "json"; name: string; json: unknown }
-		| { type: "wasm_module"; name: string; part: string }
-		| { type: "text_blob"; name: string; part: string }
-		| { type: "data_blob"; name: string; part: string }
-		| { type: "kv_namespace"; name: string; namespace_id: string }
-		| {
-				type: "durable_object_namespace";
-				name: string;
-				class_name: string;
-				script_name?: string;
-				environment?: string;
-		  }
-		| { type: "r2_bucket"; name: string; bucket_name: string }
-		| { type: "service"; name: string; service: string; environment?: string }
-		| { type: "namespace"; name: string; namespace: string }
-		| {
-				type: "logfwdr";
-				name: string;
-				destination: string;
-		  }
-	)[];
+	bindings: WorkerMetadataBinding[];
+	keep_bindings: WorkerMetadataBinding["type"][];
 }
 
 /**
@@ -123,7 +125,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
-	bindings.worker_namespaces?.forEach(({ binding, namespace }) => {
+	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
 		metadataBindings.push({
 			name: binding,
 			type: "namespace",
@@ -255,6 +257,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		...(usage_model && { usage_model }),
 		...(migrations && { migrations }),
 		capnp_schema: bindings.logfwdr?.schema,
+		keep_bindings: ["plain_text", "json"],
 	};
 
 	formData.set("metadata", JSON.stringify(metadata));

package/src/dev/dev.tsx

@@ -493,6 +493,10 @@ function useHotkeys(props: {
 					break;
 				// open browser
 				case "b": {
+					if (ip === "0.0.0.0") {
+						await openInBrowser(`${localProtocol}://127.0.0.1:${port}`);
+						return;
+					}
 					await openInBrowser(`${localProtocol}://${ip}:${port}`);
 					break;
 				}

package/src/dev/remote.tsx

@@ -182,7 +182,7 @@ export function useWorker(props: {
 	} = props;
 	const [session, setSession] = useState<CfPreviewSession | undefined>();
 	const [token, setToken] = useState<CfPreviewToken | undefined>();
-
+	const [restartCounter, setRestartCounter] = useState<number>(0);
 	// This is the most reliable way to detect whether
 	// something's "happened" in our system; We make a ref and
 	// mark it once we log our initial message. Refs are vars!
@@ -237,6 +237,7 @@ export function useWorker(props: {
 		props.routes,
 		props.zone,
 		props.sendMetrics,
+		restartCounter,
 	]);
 
 	// This effect uses the session to upload the worker and create a preview
@@ -314,6 +315,7 @@ export function useWorker(props: {
 				compatibility_date: compatibilityDate,
 				compatibility_flags: compatibilityFlags,
 				usage_model: usageModel,
+				keep_bindings: true,
 			};
 
 			const workerAccount: CfAccount = {
@@ -379,6 +381,13 @@ export function useWorker(props: {
 					logger.error(
 						`${errorMessage}\n${solutionMessage}\n${onboardingLink}`
 					);
+				} else if (err.code === 10049) {
+					logger.log("Preview token expired, fetching a new one");
+					// code 10049 happens when the preview token expires
+					// since we want a new preview token when this happens,
+					// lets increment the counter, and trigger a rerun of
+					// the useEffect above
+					setRestartCounter((prevCount) => prevCount + 1);
 				} else {
 					logger.error("Error on remote worker:", err);
 				}

package/src/dev.tsx

@@ -63,6 +63,8 @@ interface DevArgs {
 	tsconfig?: string;
 	local?: boolean;
 	minify?: boolean;
+	var?: string[];
+	define?: string[];
 	"node-compat"?: boolean;
 	"experimental-enable-local-persistence"?: boolean;
 	"live-reload"?: boolean;
@@ -129,7 +131,6 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 			.option("ip", {
 				describe: "IP address to listen on",
 				type: "string",
-				default: "0.0.0.0",
 			})
 			.option("port", {
 				describe: "Port to listen on",
@@ -196,6 +197,19 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 				describe: "Protocol to forward requests to host on, defaults to https.",
 				choices: ["http", "https"] as const,
 			})
+			.option("var", {
+				describe:
+					"A key-value pair to be injected into the script as a variable",
+				type: "string",
+				requiresArg: true,
+				array: true,
+			})
+			.option("define", {
+				describe: "A key-value pair to be substituted in the script",
+				type: "string",
+				requiresArg: true,
+				array: true,
+			})
 			.option("jsx-factory", {
 				describe: "The function that is called for each JSX element",
 				type: "string",
@@ -427,22 +441,36 @@ export async function startDev(args: StartDevOptions) {
 		const getLocalPort = memoizeGetPort(DEFAULT_LOCAL_PORT);
 		const getInspectorPort = memoizeGetPort(DEFAULT_INSPECTOR_PORT);
 
+		const cliVars =
+			args.var?.reduce<Record<string, string>>((collectVars, v) => {
+				const [key, ...value] = v.split(":");
+				collectVars[key] = value.join("");
+				return collectVars;
+			}, {}) || {};
+
+		const cliDefines =
+			args.define?.reduce<Record<string, string>>((collectDefines, d) => {
+				const [key, ...value] = d.split(":");
+				collectDefines[key] = value.join("");
+				return collectDefines;
+			}, {}) || {};
+
 		// eslint-disable-next-line no-inner-declarations
 		async function getDevReactElement(configParam: Config) {
 			// now log all available bindings into the terminal
 			const bindings = await getBindings(configParam, {
 				kv: args.kv,
-				vars: args.vars,
+				vars: { ...args.vars, ...cliVars },
 				durableObjects: args.durableObjects,
 				r2: args.r2,
 			});
 
-			// mask anything that was overridden in .dev.vars
+			// mask anything that was overridden in .dev.vars or cli args
 			// so that we don't log potential secrets into the terminal
 			const maskedVars = { ...bindings.vars };
 			for (const key of Object.keys(maskedVars)) {
 				if (maskedVars[key] !== configParam.vars[key]) {
-					// This means it was overridden in .dev.vars
+					// This means it was overridden in .dev.vars or cli args
 					// so let's mask it
 					maskedVars[key] = "(hidden)";
 				}
@@ -477,7 +505,7 @@ export async function startDev(args: StartDevOptions) {
 					minify={args.minify ?? config.minify}
 					nodeCompat={nodeCompat}
 					build={config.build || {}}
-					define={config.define}
+					define={{ ...config.define, ...cliDefines }}
 					initialMode={args.local ? "local" : "remote"}
 					jsxFactory={args["jsx-factory"] || config.jsx_factory}
 					jsxFragment={args["jsx-fragment"] || config.jsx_fragment}
@@ -502,10 +530,10 @@ export async function startDev(args: StartDevOptions) {
 					isWorkersSite={Boolean(args.site || config.site)}
 					compatibilityDate={getDevCompatibilityDate(
 						config,
-						args["compatibility-date"]
+						args.compatibilityDate
 					)}
 					compatibilityFlags={
-						args["compatibility-flags"] || config.compatibility_flags
+						args.compatibilityFlags || config.compatibility_flags
 					}
 					usageModel={config.usage_model}
 					bindings={bindings}
@@ -615,7 +643,7 @@ async function getBindings(
 			) || []),
 			...(args.r2 || []),
 		],
-		worker_namespaces: configParam.worker_namespaces,
+		dispatch_namespaces: configParam.dispatch_namespaces,
 		services: configParam.services,
 		unsafe: configParam.unsafe?.bindings,
 		logfwdr: configParam.logfwdr,

package/src/{worker-namespace.ts → dispatch-namespace.ts}

@@ -34,7 +34,7 @@ async function createWorkerNamespace(accountId: string, name: string) {
 		}
 	);
 	logger.log(
-		`Created Worker namespace "${name}" with ID "${namespace.namespace_id}"`
+		`Created dispatch namespace "${name}" with ID "${namespace.namespace_id}"`
 	);
 }
 
@@ -46,7 +46,7 @@ async function deleteWorkerNamespace(accountId: string, name: string) {
 		`/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
 		{ method: "DELETE" }
 	);
-	logger.log(`Deleted Worker namespace "${name}"`);
+	logger.log(`Deleted dispatch namespace "${name}"`);
 }
 
 /**
@@ -101,7 +101,7 @@ async function renameWorkerNamespace(
 			body: JSON.stringify({ name: newName }),
 		}
 	);
-	logger.log(`Renamed Worker namespace "${oldName}" to "${newName}"`);
+	logger.log(`Renamed dispatch namespace "${oldName}" to "${newName}"`);
 }
 
 export function workerNamespaceCommands(
@@ -110,20 +110,20 @@ export function workerNamespaceCommands(
 ): Argv {
 	return workerNamespaceYargs
 		.command(subHelp)
-		.command("list", "List all Worker namespaces", {}, async (args) => {
+		.command("list", "List all dispatch namespaces", {}, async (args) => {
 			const config = readConfig(args.config as ConfigPath, args);
 			const accountId = await requireAuth(config);
 			await listWorkerNamespaces(accountId);
-			await metrics.sendMetricsEvent("list worker namespaces", {
+			await metrics.sendMetricsEvent("list dispatch namespaces", {
 				sendMetrics: config.send_metrics,
 			});
 		})
 		.command(
 			"get <name>",
-			"Get information about a Worker namespace",
+			"Get information about a dispatch namespace",
 			(yargs) => {
 				return yargs.positional("name", {
-					describe: "Name of the Worker namespace",
+					describe: "Name of the dispatch namespace",
 					type: "string",
 					demandOption: true,
 				});
@@ -132,17 +132,17 @@ export function workerNamespaceCommands(
 				const config = readConfig(args.config as ConfigPath, args);
 				const accountId = await requireAuth(config);
 				await getWorkerNamespaceInfo(accountId, args.name);
-				await metrics.sendMetricsEvent("view worker namespace", {
+				await metrics.sendMetricsEvent("view dispatch namespace", {
 					sendMetrics: config.send_metrics,
 				});
 			}
 		)
 		.command(
 			"create <name>",
-			"Create a Worker namespace",
+			"Create a dispatch namespace",
 			(yargs) => {
 				return yargs.positional("name", {
-					describe: "Name of the Worker namespace",
+					describe: "Name of the dispatch namespace",
 					type: "string",
 					demandOption: true,
 				});
@@ -152,17 +152,17 @@ export function workerNamespaceCommands(
 				const config = readConfig(args.config as ConfigPath, args);
 				const accountId = await requireAuth(config);
 				await createWorkerNamespace(accountId, args.name);
-				await metrics.sendMetricsEvent("create worker namespace", {
+				await metrics.sendMetricsEvent("create dispatch namespace", {
 					sendMetrics: config.send_metrics,
 				});
 			}
 		)
 		.command(
 			"delete <name>",
-			"Delete a Worker namespace",
+			"Delete a dispatch namespace",
 			(yargs) => {
 				return yargs.positional("name", {
-					describe: "Name of the Worker namespace",
+					describe: "Name of the dispatch namespace",
 					type: "string",
 					demandOption: true,
 				});
@@ -172,23 +172,23 @@ export function workerNamespaceCommands(
 				const config = readConfig(args.config as ConfigPath, args);
 				const accountId = await requireAuth(config);
 				await deleteWorkerNamespace(accountId, args.name);
-				await metrics.sendMetricsEvent("delete worker namespace", {
+				await metrics.sendMetricsEvent("delete dispatch namespace", {
 					sendMetrics: config.send_metrics,
 				});
 			}
 		)
 		.command(
 			"rename <old-name> <new-name>",
-			"Rename a Worker namespace",
+			"Rename a dispatch namespace",
 			(yargs) => {
 				return yargs
 					.positional("old-name", {
-						describe: "Name of the Worker namespace",
+						describe: "Name of the dispatch namespace",
 						type: "string",
 						demandOption: true,
 					})
 					.positional("new-name", {
-						describe: "New name of the Worker namespace",
+						describe: "New name of the dispatch namespace",
 						type: "string",
 						demandOption: true,
 					});
@@ -198,7 +198,7 @@ export function workerNamespaceCommands(
 				const config = readConfig(args.config as ConfigPath, args);
 				const accountId = await requireAuth(config);
 				await renameWorkerNamespace(accountId, args.oldName, args.newName);
-				await metrics.sendMetricsEvent("rename worker namespace", {
+				await metrics.sendMetricsEvent("rename dispatch namespace", {
 					sendMetrics: config.send_metrics,
 				});
 			}