wrangler 2.0.23 → 2.0.26

package/src/init.ts

@@ -5,12 +5,16 @@ import TOML from "@iarna/toml";
 import { findUp } from "find-up";
 import { version as wranglerVersion } from "../package.json";
 
+import { fetchDashboardScript } from "./cfetch/internal";
+import { readConfig } from "./config";
 import { confirm, select } from "./dialogs";
 import { initializeGit, isGitInstalled, isInsideGitRepo } from "./git-client";
 import { logger } from "./logger";
 import { getPackageManager } from "./package-manager";
 import { parsePackageJSON, parseTOML, readFileSync } from "./parse";
+import { requireAuth } from "./user";
 import { CommandLineArgsError, printWranglerBanner } from "./index";
+import type { ConfigPath } from "./index";
 
 import type { Argv, ArgumentsCamelCase } from "yargs";
 
@@ -36,6 +40,12 @@ export async function initOptions(yargs: Argv) {
 			describe: 'Answer "yes" to any prompts for new projects',
 			type: "boolean",
 			alias: "y",
+		})
+		.option("from-dash", {
+			describe: "Download script from the dashboard for local development",
+			type: "string",
+			requiresArg: true,
+			hidden: true,
 		});
 }
 
@@ -61,7 +71,11 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	const devDepsToInstall: string[] = [];
 	const instructions: string[] = [];
 	let shouldRunPackageManagerInstall = false;
-	const creationDirectory = path.resolve(process.cwd(), args.name ?? "");
+	const fromDashScriptName = args["from-dash"] as string;
+	const creationDirectory = path.resolve(
+		process.cwd(),
+		(args.name ? args.name : fromDashScriptName) ?? ""
+	);
 
 	if (args.site) {
 		const gitDirectory =
@@ -90,6 +104,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 
 	// TODO: ask which directory to make the worker in (defaults to args.name)
 	// TODO: if args.name isn't provided, ask what to name the worker
+	// Note: `--from-dash` will be a fallback creationDir/Worker name if none is provided.
 
 	const wranglerTomlDestination = path.join(
 		creationDirectory,
@@ -98,12 +113,15 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	let justCreatedWranglerToml = false;
 
 	if (fs.existsSync(wranglerTomlDestination)) {
+		let shouldContinue = false;
 		logger.warn(
 			`${path.relative(process.cwd(), wranglerTomlDestination)} already exists!`
 		);
-		const shouldContinue = await confirm(
-			"Do you want to continue initializing this project?"
-		);
+		if (!fromDashScriptName) {
+			shouldContinue = await confirm(
+				"Do you want to continue initializing this project?"
+			);
+		}
 		if (!shouldContinue) {
 			return;
 		}
@@ -438,27 +456,23 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 				process.cwd(),
 				path.join(creationDirectory, "./src/index.ts")
 			);
-
-			const newWorkerType = yesFlag
-				? "fetch"
-				: await getNewWorkerType(newWorkerFilename);
-
-			if (newWorkerType !== "none") {
-				const template = getNewWorkerTemplate("ts", newWorkerType);
-
+			if (fromDashScriptName) {
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
 				await mkdir(path.join(creationDirectory, "./src"), {
 					recursive: true,
 				});
-				await writeFile(
-					path.join(creationDirectory, "./src/index.ts"),
-					readFileSync(path.join(__dirname, `../templates/${template}`))
+
+				const dashScript = await fetchDashboardScript(
+					`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
+					{
+						method: "GET",
+					}
 				);
 
-				logger.log(
-					`✨ Created ${path.relative(
-						process.cwd(),
-						path.join(creationDirectory, "./src/index.ts")
-					)}`
+				await writeFile(
+					path.join(creationDirectory, "./src/index.ts"),
+					dashScript
 				);
 
 				await writePackageJsonScriptsAndUpdateWranglerToml(
@@ -466,8 +480,39 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					justCreatedWranglerToml,
 					pathToPackageJson,
 					"src/index.ts",
-					getNewWorkerToml(newWorkerType)
+					{}
 				);
+			} else {
+				const newWorkerType = yesFlag
+					? "fetch"
+					: await getNewWorkerType(newWorkerFilename);
+
+				if (newWorkerType !== "none") {
+					const template = getNewWorkerTemplate("ts", newWorkerType);
+
+					await mkdir(path.join(creationDirectory, "./src"), {
+						recursive: true,
+					});
+					await writeFile(
+						path.join(creationDirectory, "./src/index.ts"),
+						readFileSync(path.join(__dirname, `../templates/${template}`))
+					);
+
+					logger.log(
+						`✨ Created ${path.relative(
+							process.cwd(),
+							path.join(creationDirectory, "./src/index.ts")
+						)}`
+					);
+
+					await writePackageJsonScriptsAndUpdateWranglerToml(
+						shouldWritePackageJsonScripts,
+						justCreatedWranglerToml,
+						pathToPackageJson,
+						"src/index.ts",
+						getNewWorkerToml(newWorkerType)
+					);
+				}
 			}
 		}
 	} else {
@@ -477,35 +522,63 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 				path.join(creationDirectory, "./src/index.js")
 			);
 
-			const newWorkerType = yesFlag
-				? "fetch"
-				: await getNewWorkerType(newWorkerFilename);
-
-			if (newWorkerType !== "none") {
-				const template = getNewWorkerTemplate("js", newWorkerType);
-
+			if (fromDashScriptName) {
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
 				await mkdir(path.join(creationDirectory, "./src"), {
 					recursive: true,
 				});
-				await writeFile(
-					path.join(creationDirectory, "./src/index.js"),
-					readFileSync(path.join(__dirname, `../templates/${template}`))
+
+				const dashScript = await fetchDashboardScript(
+					`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
+					{
+						method: "GET",
+					}
 				);
 
-				logger.log(
-					`✨ Created ${path.relative(
-						process.cwd(),
-						path.join(creationDirectory, "./src/index.js")
-					)}`
+				await writeFile(
+					path.join(creationDirectory, "./src/index.js"),
+					dashScript
 				);
 
 				await writePackageJsonScriptsAndUpdateWranglerToml(
 					shouldWritePackageJsonScripts,
 					justCreatedWranglerToml,
 					pathToPackageJson,
-					"src/index.js",
-					getNewWorkerToml(newWorkerType)
+					"src/index.ts",
+					{}
 				);
+			} else {
+				const newWorkerType = yesFlag
+					? "fetch"
+					: await getNewWorkerType(newWorkerFilename);
+
+				if (newWorkerType !== "none") {
+					const template = getNewWorkerTemplate("js", newWorkerType);
+
+					await mkdir(path.join(creationDirectory, "./src"), {
+						recursive: true,
+					});
+					await writeFile(
+						path.join(creationDirectory, "./src/index.js"),
+						readFileSync(path.join(__dirname, `../templates/${template}`))
+					);
+
+					logger.log(
+						`✨ Created ${path.relative(
+							process.cwd(),
+							path.join(creationDirectory, "./src/index.js")
+						)}`
+					);
+
+					await writePackageJsonScriptsAndUpdateWranglerToml(
+						shouldWritePackageJsonScripts,
+						justCreatedWranglerToml,
+						pathToPackageJson,
+						"src/index.js",
+						getNewWorkerToml(newWorkerType)
+					);
+				}
 			}
 		}
 	}

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,93 @@ 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}:${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 +417,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/miniflare-cli/assets.ts

@@ -335,6 +335,11 @@ async function generateAssetsFetch(
 
 	const generateResponse = (request: MiniflareRequest) => {
 		const url = new URL(request.url);
+		let assetName = url.pathname;
+		try {
+			//it's possible for someone to send a URL like http://fakehost/abc%2 which would fail to decode
+			assetName = decodeURIComponent(url.pathname);
+		} catch {}
 
 		const deconstructedResponse: {
 			status: number;
@@ -377,7 +382,7 @@ async function generateAssetsFetch(
 		}
 
 		const notFound = () => {
-			let cwd = url.pathname;
+			let cwd = assetName;
 			while (cwd) {
 				cwd = cwd.slice(0, cwd.lastIndexOf("/"));
 
@@ -407,38 +412,36 @@ async function generateAssetsFetch(
 
 		let asset;
 
-		if (url.pathname.endsWith("/")) {
-			if ((asset = getAsset(`${url.pathname}/index.html`))) {
+		if (assetName.endsWith("/")) {
+			if ((asset = getAsset(`${assetName}/index.html`))) {
 				deconstructedResponse.body = serveAsset(asset);
 				deconstructedResponse.headers.set(
 					"Content-Type",
 					getType(asset) || "application/octet-stream"
 				);
 				return deconstructedResponse;
-			} else if (
-				(asset = getAsset(`${url.pathname.replace(/\/$/, ".html")}`))
-			) {
+			} else if ((asset = getAsset(`${assetName.replace(/\/$/, ".html")}`))) {
 				deconstructedResponse.status = 301;
 				deconstructedResponse.headers.set(
 					"Location",
-					`${url.pathname.slice(0, -1)}${url.search}`
+					`${assetName.slice(0, -1)}${url.search}`
 				);
 				return deconstructedResponse;
 			}
 		}
 
-		if (url.pathname.endsWith("/index")) {
+		if (assetName.endsWith("/index")) {
 			deconstructedResponse.status = 301;
 			deconstructedResponse.headers.set(
 				"Location",
-				`${url.pathname.slice(0, -"index".length)}${url.search}`
+				`${assetName.slice(0, -"index".length)}${url.search}`
 			);
 			return deconstructedResponse;
 		}
 
-		if ((asset = getAsset(url.pathname))) {
-			if (url.pathname.endsWith(".html")) {
-				const extensionlessPath = url.pathname.slice(0, -".html".length);
+		if ((asset = getAsset(assetName))) {
+			if (assetName.endsWith(".html")) {
+				const extensionlessPath = assetName.slice(0, -".html".length);
 				if (getAsset(extensionlessPath) || extensionlessPath === "/") {
 					deconstructedResponse.body = serveAsset(asset);
 					deconstructedResponse.headers.set(
@@ -462,12 +465,20 @@ async function generateAssetsFetch(
 				);
 				return deconstructedResponse;
 			}
-		} else if (hasFileExtension(url.pathname)) {
+		} else if (hasFileExtension(assetName)) {
+			if ((asset = getAsset(assetName + ".html"))) {
+				deconstructedResponse.body = serveAsset(asset);
+				deconstructedResponse.headers.set(
+					"Content-Type",
+					getType(asset) || "application/octet-stream"
+				);
+				return deconstructedResponse;
+			}
 			notFound();
 			return deconstructedResponse;
 		}
 
-		if ((asset = getAsset(`${url.pathname}.html`))) {
+		if ((asset = getAsset(`${assetName}.html`))) {
 			deconstructedResponse.body = serveAsset(asset);
 			deconstructedResponse.headers.set(
 				"Content-Type",
@@ -476,11 +487,11 @@ async function generateAssetsFetch(
 			return deconstructedResponse;
 		}
 
-		if ((asset = getAsset(`${url.pathname}/index.html`))) {
+		if ((asset = getAsset(`${assetName}/index.html`))) {
 			deconstructedResponse.status = 301;
 			deconstructedResponse.headers.set(
 				"Location",
-				`${url.pathname}/${url.search}`
+				`${assetName}/${url.search}`
 			);
 			return deconstructedResponse;
 		} else {

package/src/miniflare-cli/index.ts

@@ -1,10 +1,23 @@
-import { Log, LogLevel, Miniflare } from "miniflare";
+import { fetch } from "@miniflare/core";
+import {
+	DurableObjectNamespace,
+	DurableObjectStub,
+} from "@miniflare/durable-objects";
+import {
+	Log,
+	LogLevel,
+	Miniflare,
+	Response as MiniflareResponse,
+	Request as MiniflareRequest,
+} from "miniflare";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { FatalError } from "../errors";
 import generateASSETSBinding from "./assets";
 import { enumKeys } from "./enum-keys";
 import { getRequestContextCheckOptions } from "./request-context";
 import type { Options } from "./assets";
+import type { AddressInfo } from "net";
 
 export interface EnablePagesAssetsServiceBindingOptions {
 	proxyPort?: number;
@@ -44,7 +57,48 @@ async function main() {
 		console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
 	}
 
+	config.bindings = {
+		...config.bindings,
+		...Object.fromEntries(
+			Object.entries(
+				config.externalDurableObjects as Record<
+					string,
+					{ name: string; host: string; port: number }
+				>
+			).map(([binding, { name, host, port }]) => {
+				const factory = () => {
+					throw new FatalError(
+						"An external Durable Object instance's state has somehow been attempted to be accessed.",
+						1
+					);
+				};
+				const namespace = new DurableObjectNamespace(name as string, factory);
+				namespace.get = (id) => {
+					const stub = new DurableObjectStub(factory, id);
+					stub.fetch = (...reqArgs) => {
+						const requestFromArgs = new MiniflareRequest(...reqArgs);
+						const url = new URL(requestFromArgs.url);
+						url.host = host;
+						if (port !== undefined) url.port = port.toString();
+						const request = new MiniflareRequest(
+							url.toString(),
+							requestFromArgs
+						);
+						request.headers.set("x-miniflare-durable-object-name", name);
+						request.headers.set("x-miniflare-durable-object-id", id.toString());
+
+						return fetch(request);
+					};
+					return stub;
+				};
+				return [binding, namespace];
+			})
+		),
+	};
+
 	let mf: Miniflare | undefined;
+	let durableObjectsMf: Miniflare | undefined = undefined;
+	let durableObjectsMfPort: number | undefined = undefined;
 
 	try {
 		if (args._[1]) {
@@ -73,12 +127,80 @@ async function main() {
 		// Start Miniflare development server
 		await mf.startServer();
 		await mf.startScheduler();
-		process.send && process.send("ready");
+
+		const internalDurableObjectClassNames = Object.values(
+			config.durableObjects as Record<string, string>
+		);
+
+		if (internalDurableObjectClassNames.length > 0) {
+			durableObjectsMf = new Miniflare({
+				host: config.host,
+				port: 0,
+				script: `
+				export default {
+					fetch(request, env) {
+						return env.DO.fetch(request)
+					}
+				}`,
+				serviceBindings: {
+					DO: async (request: MiniflareRequest) => {
+						request = new MiniflareRequest(request);
+
+						const name = request.headers.get("x-miniflare-durable-object-name");
+						const idString = request.headers.get(
+							"x-miniflare-durable-object-id"
+						);
+						request.headers.delete("x-miniflare-durable-object-name");
+						request.headers.delete("x-miniflare-durable-object-id");
+
+						if (!name || !idString) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
+								{ status: 400 }
+							);
+						}
+
+						const namespace = await mf?.getDurableObjectNamespace(name);
+						const id = namespace?.idFromString(idString);
+
+						if (!id) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate an ID. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						const stub = namespace?.get(id);
+
+						if (!stub) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						return stub.fetch(request);
+					},
+				},
+				modules: true,
+			});
+			const server = await durableObjectsMf.startServer();
+			durableObjectsMfPort = (server.address() as AddressInfo).port;
+		}
+
+		process.send &&
+			process.send(
+				JSON.stringify({
+					ready: true,
+					durableObjectsPort: durableObjectsMfPort,
+				})
+			);
 	} catch (e) {
 		mf?.log.error(e as Error);
 		process.exitCode = 1;
 		// Unmount any mounted workers
 		await mf?.dispose();
+		await durableObjectsMf?.dispose();
 	}
 }
 

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("|") +
 									")$"
 							),
 						},