wrangler 0.0.0-e043479 → 0.0.0-e09abbc

package/src/environment-variables.ts

@@ -1,3 +1,5 @@
+import { logger } from "./logger";
+
 /**
  * Create a function used to access an environment variable.
  *
@@ -5,29 +7,29 @@
  * A warning is shown if the client is using a deprecated version - but only once.
  */
 export function getEnvironmentVariableFactory({
-  variableName,
-  deprecatedName,
-  defaultValue,
+	variableName,
+	deprecatedName,
+	defaultValue,
 }: {
-  variableName: string;
-  deprecatedName?: string;
-  defaultValue?: string;
+	variableName: string;
+	deprecatedName?: string;
+	defaultValue?: string;
 }) {
-  let hasWarned = false;
-  return () => {
-    if (process.env[variableName]) {
-      return process.env[variableName];
-    } else if (deprecatedName && process.env[deprecatedName]) {
-      if (!hasWarned) {
-        // Only show the warning once.
-        hasWarned = true;
-        console.warn(
-          `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
-        );
-      }
-      return process.env[deprecatedName];
-    } else {
-      return defaultValue;
-    }
-  };
+	let hasWarned = false;
+	return () => {
+		if (process.env[variableName]) {
+			return process.env[variableName];
+		} else if (deprecatedName && process.env[deprecatedName]) {
+			if (!hasWarned) {
+				// Only show the warning once.
+				hasWarned = true;
+				logger.warn(
+					`Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
+				);
+			}
+			return process.env[deprecatedName];
+		} else {
+			return defaultValue;
+		}
+	};
 }

package/src/errors.ts

@@ -0,0 +1,11 @@
+export class DeprecationError extends Error {
+	constructor(message: string) {
+		super(`Deprecation:\n${message}`);
+	}
+}
+
+export class FatalError extends Error {
+	constructor(message?: string, readonly code?: number) {
+		super(message);
+	}
+}

package/src/faye-websocket.d.ts

@@ -0,0 +1,6 @@
+module "faye-websocket" {
+	/**
+	 * Standards-compliant WebSocket client and server.
+	 */
+	export default WebSocket;
+}

package/src/generate.ts

@@ -0,0 +1,33 @@
+import { DeprecationError } from "./errors";
+import type { Argv, ArgumentsCamelCase } from "yargs";
+
+interface GenerateArgs {
+	name: string;
+	template: string;
+}
+
+export function generateOptions(yargs: Argv) {
+	return yargs
+		.positional("name", {
+			describe: "Name of the Workers project",
+			default: "worker",
+		})
+		.positional("template", {
+			describe: "The URL of a GitHub template",
+			default: "https://github.com/cloudflare/worker-template",
+		});
+}
+
+export function generateHandler(
+	generateArgs: ArgumentsCamelCase<GenerateArgs>
+) {
+	// "👯 [DEPRECATED]. Scaffold a Cloudflare Workers project from a public GitHub repository.",
+	throw new DeprecationError(
+		"`wrangler generate` has been deprecated.\n" +
+			"Try running `wrangler init` to generate a basic Worker, or cloning the template repository instead:\n\n" +
+			"```\n" +
+			`git clone ${generateArgs.template}\n` +
+			"```\n\n" +
+			"Please refer to https://developers.cloudflare.com/workers/wrangler/deprecations/#generate for more information."
+	);
+}

package/src/git-client.ts

@@ -0,0 +1,42 @@
+import { execa } from "execa";
+import { findUp } from "find-up";
+
+/**
+ * Check whether the given current working directory is within a git repository
+ * by looking for a `.git` directory in this or an ancestor directory.
+ */
+export async function isInsideGitRepo(cwd: string) {
+	const res = await findUp(".git", { cwd, type: "directory" });
+	return res !== undefined;
+}
+
+/**
+ * Check whether git is installed by trying to run it.
+ */
+export async function isGitInstalled() {
+	try {
+		return (await execa("git", ["--version"])).exitCode === 0;
+	} catch (err) {
+		return false;
+	}
+}
+
+/**
+ * Initialize a new Worker project with a git repository.
+ *
+ * We want the branch to be called `main` but earlier versions of git do not support `--initial-branch`.
+ * If that is the case then we just fallback to the default initial branch name.
+ */
+export async function initializeGit(cwd: string) {
+	try {
+		// Try to create the repository with the HEAD branch of `main`.
+		await execa("git", ["init", "--initial-branch", "main"], {
+			cwd,
+		});
+	} catch {
+		// Unable to create the repo with a HEAD branch name, so just fall back to the default.
+		await execa("git", ["init"], {
+			cwd,
+		});
+	}
+}

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

@@ -0,0 +1,127 @@
+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";
+
+// Most of this file has been borrowed from the implementation in Miniflare.
+// See https://github.com/cloudflare/miniflare/blob/870b401ef5/packages/http-server/src/plugin.ts#L313-L397
+// Thanks @mrbbot.
+const CERT_EXPIRY_DAYS = 30;
+const ONE_DAY_IN_MS = 86400000;
+
+/**
+ * Get the options (i.e. SSL certificates) for running an HTTPS server.
+ *
+ * The certificates are self-signed and generated locally, and cached in the `CERT_ROOT` directory.
+ */
+export async function getHttpsOptions() {
+	const certDirectory = path.join(getGlobalWranglerConfigPath(), "local-cert");
+	const keyPath = path.join(certDirectory, "key.pem");
+	const certPath = path.join(certDirectory, "cert.pem");
+
+	const regenerate =
+		!fs.existsSync(keyPath) ||
+		!fs.existsSync(certPath) ||
+		hasCertificateExpired(keyPath, certPath);
+
+	if (regenerate) {
+		logger.log("Generating new self-signed certificate...");
+		const { key, cert } = await generateCertificate();
+		try {
+			// Write certificate files so we can reuse them later.
+			fs.mkdirSync(certDirectory, { recursive: true });
+			fs.writeFileSync(keyPath, key, "utf8");
+			fs.writeFileSync(certPath, cert, "utf8");
+		} catch (e) {
+			const message = e instanceof Error ? e.message : `${e}`;
+			logger.warn(
+				`Unable to cache generated self-signed certificate in ${path.relative(
+					process.cwd(),
+					certDirectory
+				)}.\n${message}`
+			);
+		}
+		return { key, cert };
+	} else {
+		return {
+			key: fs.readFileSync(keyPath, "utf8"),
+			cert: fs.readFileSync(certPath, "utf8"),
+		};
+	}
+}
+
+/**
+ * Determine if the certificate defined in `keyPath` and `certPath` files
+ * have expired based on the date when they were last modified.
+ */
+function hasCertificateExpired(keyPath: string, certPath: string): boolean {
+	const keyStat = fs.statSync(keyPath);
+	const certStat = fs.statSync(certPath);
+	const created = Math.max(keyStat.mtimeMs, certStat.mtimeMs);
+	return Date.now() - created > (CERT_EXPIRY_DAYS - 2) * ONE_DAY_IN_MS;
+}
+
+/**
+ * Generate a new self-signed certificate and cache it in `CERT_ROOT` directory.
+ */
+async function generateCertificate() {
+	// `selfsigned` imports `node-forge`, which is a pretty big library.
+	// To reduce startup time, only load this dynamically when needed.
+	// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+	const generate: typeof import("selfsigned").generate = promisify(
+		// eslint-disable-next-line @typescript-eslint/no-var-requires
+		require("selfsigned").generate
+	);
+
+	const certAttrs: Attributes = [{ name: "commonName", value: "localhost" }];
+
+	const certOptions: Options = {
+		algorithm: "sha256",
+		days: CERT_EXPIRY_DAYS,
+		keySize: 2048,
+		extensions: [
+			{ name: "basicConstraints", cA: true },
+			{
+				name: "keyUsage",
+				keyCertSign: true,
+				digitalSignature: true,
+				nonRepudiation: true,
+				keyEncipherment: true,
+				dataEncipherment: true,
+			},
+			{
+				name: "extKeyUsage",
+				serverAuth: true,
+				clientAuth: true,
+				codeSigning: true,
+				timeStamping: true,
+			},
+			{
+				name: "subjectAltName",
+				altNames: [
+					{ type: 2, value: "localhost" },
+					...getAccessibleHosts().map((ip) => ({ type: 7, ip })),
+				],
+			},
+		],
+	};
+
+	const { private: key, cert } = await generate(certAttrs, certOptions);
+	return { key, cert };
+}
+
+/**
+ * Ask the OS for the addresses of locally accessible hosts.
+ */
+function getAccessibleHosts(ipv4 = false): string[] {
+	const hosts: string[] = [];
+	Object.values(os.networkInterfaces()).forEach((net) =>
+		net?.forEach(({ family, address }) => {
+			if (!ipv4 || family === "IPv4") hosts.push(address);
+		})
+	);
+	return hosts;
+}