wrangler 2.0.17 → 2.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.0.17",
+	"version": "2.0.18",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -149,6 +149,7 @@
 		"undici": "^5.5.1",
 		"update-check": "^1.5.4",
 		"ws": "^8.5.0",
+		"xdg-app-paths": "^7.3.0",
 		"yargs": "^17.4.1"
 	},
 	"optionalDependencies": {

package/src/__tests__/helpers/run-in-tmp.ts

@@ -5,42 +5,34 @@ import { reinitialiseAuthTokens } from "../../user";
 
 const originalCwd = process.cwd();
 
-export function runInTempDir(
-	{ homedir }: { homedir?: string } = { homedir: "./home" }
-) {
-	let tmpDir: string;
-
-	beforeAll(() => {
-		if (tmpDir !== undefined) {
-			process.chdir(originalCwd);
-			fs.rmSync(tmpDir, { recursive: true });
-		}
-	});
+export function runInTempDir({ homedir } = { homedir: "./home" }) {
+	let tmpDir: string | undefined;
 
 	beforeEach(() => {
 		// Use realpath because the temporary path can point to a symlink rather than the actual path.
 		tmpDir = fs.realpathSync(
 			fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"))
 		);
+
 		process.chdir(tmpDir);
-		if (homedir !== undefined) {
-			// The path that is returned from `homedir()` should be absolute.
-			const absHomedir = path.resolve(tmpDir, homedir);
-			// Override where the home directory is so that we can write our own user config,
-			// without destroying the real thing.
-			fs.mkdirSync(absHomedir, { recursive: true });
-			// Note it is very important that we use the "default" value from "node:os" (e.g. `import os from "node:os";`)
-			// rather than an alias to the module (e.g. `import * as os from "node:os";`).
-			// This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
-			// getter that is not configurable (and so cannot be spied upon).
-			jest.spyOn(os, "homedir").mockReturnValue(absHomedir);
-			// Now that we have changed the home directory location, we must reinitialize the user auth state
-			reinitialiseAuthTokens();
-		}
+		// The path that is returned from `homedir()` should be absolute.
+		const absHomedir = path.resolve(tmpDir, homedir);
+		// Override where the home directory is so that we can write our own user config,
+		// without destroying the real thing.
+		fs.mkdirSync(absHomedir, { recursive: true });
+		// Note it is very important that we use the "default" value from "node:os" (e.g. `import os from "node:os";`)
+		// rather than an alias to the module (e.g. `import * as os from "node:os";`).
+		// This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
+		// getter that is not configurable (and so cannot be spied upon).
+		jest.spyOn(os, "homedir")?.mockReturnValue(absHomedir);
+		// Now that we have changed the home directory location, we must reinitialize the user auth state
+		reinitialiseAuthTokens();
 	});
 
 	afterEach(() => {
-		process.chdir(originalCwd);
-		fs.rmSync(tmpDir, { recursive: true });
+		if (tmpDir && fs.existsSync(tmpDir)) {
+			process.chdir(originalCwd);
+			fs.rmSync(tmpDir, { recursive: true });
+		}
 	});
 }

package/src/__tests__/https-options.test.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
-import { resolve } from "node:path";
+import path from "node:path";
+import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
 import { getHttpsOptions } from "../https-options";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
@@ -10,15 +11,15 @@ describe("getHttpsOptions()", () => {
 	const std = mockConsoleMethods();
 
 	it("should use cached values if they have not expired", async () => {
-		fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+		fs.mkdirSync(path.resolve(getGlobalWranglerConfigPath(), "local-cert"), {
 			recursive: true,
 		});
 		fs.writeFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
 			"PRIVATE KEY"
 		);
 		fs.writeFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
 			"PUBLIC KEY"
 		);
 		const result = await getHttpsOptions();
@@ -32,11 +33,11 @@ describe("getHttpsOptions()", () => {
 	it("should generate and cache new keys if none are cached", async () => {
 		const result = await getHttpsOptions();
 		const key = fs.readFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
 			"utf8"
 		);
 		const cert = fs.readFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
 			"utf8"
 		);
 		expect(result.key).toEqual(key);
@@ -49,28 +50,28 @@ describe("getHttpsOptions()", () => {
 	});
 
 	it("should generate and cache new keys if cached files have expired", async () => {
-		fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+		fs.mkdirSync(path.resolve(getGlobalWranglerConfigPath(), "local-cert"), {
 			recursive: true,
 		});
 		const ORIGINAL_KEY = "EXPIRED PRIVATE KEY";
 		const ORIGINAL_CERT = "EXPIRED PUBLIC KEY";
 		fs.writeFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
 			ORIGINAL_KEY
 		);
 		fs.writeFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
 			ORIGINAL_CERT
 		);
 		mockStatSync(/\.pem$/, { mtimeMs: new Date(2000).valueOf() });
 
 		const result = await getHttpsOptions();
 		const key = fs.readFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
 			"utf8"
 		);
 		const cert = fs.readFileSync(
-			resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
 			"utf8"
 		);
 		expect(key).not.toEqual(ORIGINAL_KEY);
@@ -84,25 +85,57 @@ describe("getHttpsOptions()", () => {
 		expect(std.err).toMatchInlineSnapshot(`""`);
 	});
 
+	it("should warn if not able to write to the cache (legacy config path)", async () => {
+		fs.mkdirSync(path.join(os.homedir(), ".wrangler"));
+		mockWriteFileSyncThrow(/\.pem$/);
+		await getHttpsOptions();
+		expect(
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem")
+			)
+		).toBe(false);
+		expect(
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem")
+			)
+		).toBe(false);
+		expect(std.out).toMatchInlineSnapshot(
+			`"Generating new self-signed certificate..."`
+		);
+		expect(std.warn).toMatchInlineSnapshot(`
+		      "▲ [WARNING] Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+
+		        ERROR: Cannot write file
+
+		      "
+	    `);
+		expect(std.err).toMatchInlineSnapshot(`""`);
+		fs.rmSync(path.join(os.homedir(), ".wrangler"), { recursive: true });
+	});
+
 	it("should warn if not able to write to the cache", async () => {
 		mockWriteFileSyncThrow(/\.pem$/);
 		await getHttpsOptions();
 		expect(
-			fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/key.pem"))
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem")
+			)
 		).toBe(false);
 		expect(
-			fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/cert.pem"))
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem")
+			)
 		).toBe(false);
 		expect(std.out).toMatchInlineSnapshot(
 			`"Generating new self-signed certificate..."`
 		);
 		expect(std.warn).toMatchInlineSnapshot(`
-      "▲ [WARNING] Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+		"▲ [WARNING] Unable to cache generated self-signed certificate in test-xdg-config/local-cert.
 
-        ERROR: Cannot write file
+		  ERROR: Cannot write file
 
-      "
-    `);
+		"
+	`);
 		expect(std.err).toMatchInlineSnapshot(`""`);
 	});
 });

package/src/__tests__/jest.setup.ts

@@ -105,3 +105,16 @@ jest.mock("../user/generate-random-state", () => {
 		generateRandomState: jest.fn().mockImplementation(() => "MOCK_STATE_PARAM"),
 	};
 });
+
+jest.mock("xdg-app-paths", () => {
+	return {
+		__esModule: true,
+		default: jest.fn().mockImplementation(() => {
+			return {
+				config() {
+					return jest.requireActual("node:path").resolve("test-xdg-config");
+				},
+			};
+		}),
+	};
+});

package/src/__tests__/pages.test.ts

@@ -45,6 +45,13 @@ describe("pages", () => {
 		outOfBandTests.forEach((fn) => fn());
 	});
 
+	beforeEach(() => {
+		// @ts-expect-error we're using a very simple setTimeout mock here
+		jest.spyOn(global, "setTimeout").mockImplementation((fn, _period) => {
+			setImmediate(fn);
+		});
+	});
+
 	it("should should display a list of available subcommands, for pages with no subcommand", async () => {
 		await runWrangler("pages");
 		await endEventLoop();
@@ -645,8 +652,8 @@ describe("pages", () => {
 				});
 				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
 			}
-			// First bucket should end up with 2 files
-			expect(bodies.map((b) => b.length)).toEqual([2, 1, 1]);
+			// One bucket should end up with 2 files
+			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
 			expect(bodies.flatMap((b) => b)).toEqual(
 				expect.arrayContaining([
@@ -759,8 +766,8 @@ describe("pages", () => {
 				});
 				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
 			}
-			// First bucket should end up with 2 files
-			expect(bodies.map((b) => b.length)).toEqual([2, 1, 1]);
+			// One bucket should end up with 2 files
+			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
 			expect(bodies.flatMap((b) => b)).toEqual(
 				expect.arrayContaining([
@@ -874,8 +881,8 @@ describe("pages", () => {
 				});
 				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
 			}
-			// First bucket should end up with 2 files
-			expect(bodies.map((b) => b.length)).toEqual([2, 1, 1]);
+			// One bucket should end up with 2 files
+			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
 			expect(bodies.flatMap((b) => b)).toEqual(
 				expect.arrayContaining([
@@ -1163,8 +1170,8 @@ describe("pages", () => {
 				});
 				bodies.push(JSON.parse(init.body as string) as UploadPayloadFile[]);
 			}
-			// First bucket should end up with 2 files
-			expect(bodies.map((b) => b.length)).toEqual([2, 1, 1]);
+			// One bucket should end up with 2 files
+			expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
 			// But we don't know the order, so flatten and test without ordering
 			expect(bodies.flatMap((b) => b)).toEqual(
 				expect.arrayContaining([

package/src/__tests__/publish.test.ts

@@ -51,6 +51,31 @@ describe("publish", () => {
 		unsetMockFetchKVGetValues();
 	});
 
+	describe("output additional script information", () => {
+		mockApiToken();
+
+		it("should print worker information at log level", async () => {
+			setIsTTY(false);
+			writeWranglerToml();
+			writeWorkerSource();
+			mockSubDomainRequest();
+			mockUploadWorkerRequest({ expectedType: "esm", sendScriptIds: true });
+			mockOAuthServerCallback();
+
+			await runWrangler("publish ./index");
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"Total Upload: 0xx KiB / gzip: 0xx KiB
+			Worker ID:  abc12345
+			Worker ETag:  etag98765
+			Worker PipelineHash:  hash9999
+			Uploaded test-name (TIMINGS)
+			Published test-name (TIMINGS)
+			  test-name.test-sub-domain.workers.dev"
+		`);
+		});
+	});
+
 	describe("authentication", () => {
 		mockApiToken({ apiToken: null });
 		beforeEach(() => {
@@ -6113,6 +6138,7 @@ function mockUploadWorkerRequest(
 		expectedMigrations?: CfWorkerInit["migrations"];
 		env?: string;
 		legacyEnv?: boolean;
+		sendScriptIds?: boolean;
 	} = {}
 ) {
 	const {
@@ -6127,6 +6153,7 @@ function mockUploadWorkerRequest(
 		env = undefined,
 		legacyEnv = false,
 		expectedMigrations,
+		sendScriptIds,
 	} = options;
 	setMockResponse(
 		env && !legacyEnv
@@ -6175,7 +6202,16 @@ function mockUploadWorkerRequest(
 				expect(await (formBody.get(name) as File).text()).toEqual(content);
 			}
 
-			return { available_on_subdomain };
+			return {
+				available_on_subdomain,
+				...(sendScriptIds
+					? {
+							id: "abc12345",
+							etag: "etag98765",
+							pipeline_hash: "hash9999",
+					  }
+					: {}),
+			};
 		}
 	);
 }

package/src/__tests__/user.test.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import fetchMock from "jest-fetch-mock";
+import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
 import {
 	loginOrRefreshIfRequired,
 	readAuthConfigFile,
@@ -86,7 +86,10 @@ describe("User", () => {
 			expect(fetchMock).toHaveBeenCalledTimes(1);
 
 			// Make sure that logout removed the config file containing the auth tokens.
-			const config = path.join(os.homedir(), USER_AUTH_CONFIG_FILE);
+			const config = path.join(
+				getGlobalWranglerConfigPath(),
+				USER_AUTH_CONFIG_FILE
+			);
 			expect(fs.existsSync(config)).toBeFalsy();
 		});
 	});

package/src/global-wrangler-config-path.ts

@@ -0,0 +1,26 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import xdgAppPaths from "xdg-app-paths";
+
+function isDirectory(configPath: string) {
+	try {
+		return fs.statSync(configPath).isDirectory();
+	} catch (error) {
+		// ignore error
+		return false;
+	}
+}
+
+export function getGlobalWranglerConfigPath() {
+	//TODO: We should implement a custom path --global-config and/or the WRANGLER_HOME type environment variable
+	const configDir = xdgAppPaths(".wrangler").config(); // New XDG compliant config path
+	const legacyConfigDir = path.join(os.homedir(), ".wrangler"); // Legacy config in user's home directory
+
+	// Check for the .wrangler directory in root if it is not there then use the XDG compliant path.
+	if (isDirectory(legacyConfigDir)) {
+		return legacyConfigDir;
+	} else {
+		return configDir;
+	}
+}

package/src/https-options.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { getGlobalWranglerConfigPath } from "./global-wrangler-config-path";
 import { logger } from "./logger";
 import type { Attributes, Options } from "selfsigned";
 
@@ -17,7 +18,7 @@ const ONE_DAY_IN_MS = 86400000;
  * The certificates are self-signed and generated locally, and cached in the `CERT_ROOT` directory.
  */
 export async function getHttpsOptions() {
-	const certDirectory = path.join(os.homedir(), ".wrangler/local-cert");
+	const certDirectory = path.join(getGlobalWranglerConfigPath(), "local-cert");
 	const keyPath = path.join(certDirectory, "key.pem");
 	const certPath = path.join(certDirectory, "cert.pem");
 

package/src/pages/upload.tsx

@@ -95,7 +95,7 @@ export const upload = async (
 	}
 
 	type FileContainer = {
-		content: string;
+		path: string;
 		contentType: string;
 		sizeInBytes: number;
 		hash: string;
@@ -112,6 +112,14 @@ export const upload = async (
 
 	const directory = resolve(args.directory);
 
+	// TODO(future): Use this to more efficiently load files in and speed up uploading
+	// Limit memory to 1 GB unless more is specified
+	// let maxMemory = 1_000_000_000;
+	// if (process.env.NODE_OPTIONS && (process.env.NODE_OPTIONS.includes('--max-old-space-size=') || process.env.NODE_OPTIONS.includes('--max_old_space_size='))) {
+	// 	const parsed = parser(process.env.NODE_OPTIONS);
+	// 	maxMemory = (parsed['max-old-space-size'] ? parsed['max-old-space-size'] : parsed['max_old_space_size']) * 1000 * 1000; // Turn MB into bytes
+	// }
+
 	const walk = async (
 		dir: string,
 		fileMap: Map<string, FileContainer> = new Map(),
@@ -137,7 +145,6 @@ export const upload = async (
 				} else {
 					const name = relative(startingDir, filepath).split(sep).join("/");
 
-					// TODO: Move this to later so we don't hold as much in memory
 					const fileContent = await readFile(filepath);
 
 					const base64Content = fileContent.toString("base64");
@@ -152,8 +159,9 @@ export const upload = async (
 						);
 					}
 
+					// We don't want to hold the content in memory. We instead only want to read it when it's needed
 					fileMap.set(name, {
-						content: base64Content,
+						path: filepath,
 						contentType: getType(name) || "application/octet-stream",
 						sizeInBytes: filestat.size,
 						hash: blake3hash(base64Content + extension)
@@ -248,17 +256,21 @@ export const upload = async (
 		// Don't upload empty buckets (can happen for tiny projects)
 		if (bucket.files.length === 0) continue;
 
-		const payload: UploadPayloadFile[] = bucket.files.map((file) => ({
-			key: file.hash,
-			value: file.content,
-			metadata: {
-				contentType: file.contentType,
-			},
-			base64: true,
-		}));
-
 		let 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.
+			const payload: UploadPayloadFile[] = await Promise.all(
+				bucket.files.map(async (file) => ({
+					key: file.hash,
+					value: (await readFile(file.path)).toString("base64"),
+					metadata: {
+						contentType: file.contentType,
+					},
+					base64: true,
+				}))
+			);
+
 			try {
 				return await fetchResult(`/pages/assets/upload`, {
 					method: "POST",

package/src/publish.ts

@@ -469,21 +469,34 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 		if (!props.dryRun) {
 			// Upload the script so it has time to propagate.
 			// We can also now tell whether available_on_subdomain is set
-			available_on_subdomain = (
-				await fetchResult<{ available_on_subdomain: boolean }>(
-					workerUrl,
-					{
-						method: "PUT",
-						body: createWorkerUploadForm(worker),
-					},
-					new URLSearchParams({
-						include_subdomain_availability: "true",
-						// pass excludeScript so the whole body of the
-						// script doesn't get included in the response
-						excludeScript: "true",
-					})
-				)
-			).available_on_subdomain;
+			const result = await fetchResult<{
+				available_on_subdomain: boolean;
+				id: string | null;
+				etag: string | null;
+				pipeline_hash: string | null;
+			}>(
+				workerUrl,
+				{
+					method: "PUT",
+					body: createWorkerUploadForm(worker),
+				},
+				new URLSearchParams({
+					include_subdomain_availability: "true",
+					// pass excludeScript so the whole body of the
+					// script doesn't get included in the response
+					excludeScript: "true",
+				})
+			);
+
+			available_on_subdomain = result.available_on_subdomain;
+
+			// Print some useful information returned after publishing
+			// Not all fields will be populated for every worker
+			// These fields are likely to be scraped by tools, so do not rename
+			if (result.id) logger.log("Worker ID: ", result.id);
+			if (result.etag) logger.log("Worker ETag: ", result.etag);
+			if (result.pipeline_hash)
+				logger.log("Worker PipelineHash: ", result.pipeline_hash);
 		}
 	} finally {
 		if (typeof destination !== "string") {

package/src/user/user.tsx

@@ -209,7 +209,6 @@ import assert from "node:assert";
 import { webcrypto as crypto } from "node:crypto";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import http from "node:http";
-import os from "node:os";
 import path from "node:path";
 import url from "node:url";
 import { TextEncoder } from "node:util";
@@ -224,6 +223,7 @@ import {
 	purgeConfigCaches,
 	saveToConfigCache,
 } from "../config-cache";
+import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
 import isInteractive from "../is-interactive";
 import { logger } from "../logger";
 import openInBrowser from "../open-in-browser";
@@ -270,7 +270,7 @@ interface AuthTokens {
  * The path to the config file that holds user authentication data,
  * relative to the user's home directory.
  */
-export const USER_AUTH_CONFIG_FILE = ".wrangler/config/default.toml";
+export const USER_AUTH_CONFIG_FILE = "config/default.toml";
 
 /**
  * The data that may be read from the `USER_CONFIG_FILE`.
@@ -843,7 +843,10 @@ async function generatePKCECodes(): Promise<PKCECodes> {
  * and updates the user auth state with the new credentials.
  */
 export function writeAuthConfigFile(config: UserAuthConfig) {
-	const authConfigFilePath = path.join(os.homedir(), USER_AUTH_CONFIG_FILE);
+	const authConfigFilePath = path.join(
+		getGlobalWranglerConfigPath(),
+		USER_AUTH_CONFIG_FILE
+	);
 	mkdirSync(path.dirname(authConfigFilePath), {
 		recursive: true,
 	});
@@ -857,7 +860,10 @@ export function writeAuthConfigFile(config: UserAuthConfig) {
 }
 
 export function readAuthConfigFile(): UserAuthConfig {
-	const authConfigFilePath = path.join(os.homedir(), USER_AUTH_CONFIG_FILE);
+	const authConfigFilePath = path.join(
+		getGlobalWranglerConfigPath(),
+		USER_AUTH_CONFIG_FILE
+	);
 	const toml = parseTOML(readFileSync(authConfigFilePath));
 	return toml;
 }
@@ -1042,7 +1048,7 @@ export async function logout(): Promise<void> {
 		},
 	});
 	await response.text(); // blank text? would be nice if it was something meaningful
-	rmSync(path.join(os.homedir(), USER_AUTH_CONFIG_FILE));
+	rmSync(path.join(getGlobalWranglerConfigPath(), USER_AUTH_CONFIG_FILE));
 	logger.log(`Successfully logged out.`);
 }