wrangler 0.0.0-e3e3243 → 0.0.0-e41c7e41

package/src/git-client.ts

@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execa } from "execa";
+import { findUp } from "find-up";
+import semiver from "semiver";
+
+/**
+ * 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.
+ *
+ * @returns a `string` containing the version of git that's installed, or `null` if git isn't installed
+ */
+export async function getGitVersioon(): Promise<string | null> {
+	try {
+		const gitVersionExecutionResult = await execa("git", ["--version"]);
+		if (gitVersionExecutionResult.exitCode !== 0) {
+			return null;
+		}
+
+		const [gitVersion] =
+			/\d+.\d+.\d+/.exec(gitVersionExecutionResult.stdout) || [];
+		return gitVersion;
+	} catch (err) {
+		return null;
+	}
+}
+
+/**
+ * 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,
+		});
+	}
+}
+
+/**
+ * Clone a repository into a given directory, optionally applying a given filter for a sparse checkout.
+ * Note: this does NOT initialize a git repository, that must be done separately.
+ *
+ * @param remote the remote repository to clone
+ * @param targetDirectory the directory to clone into
+ * @param subdirectory optional, clone a subdirectory instead of the whole repo
+ */
+export async function cloneIntoDirectory(
+	remote: string,
+	targetDirectory: string,
+	subdirectory?: string
+) {
+	const args = ["clone", "--depth", "1"];
+
+	const gitVersion = await getGitVersioon();
+	if (!gitVersion) {
+		throw new Error("Failed to find git installation");
+	}
+
+	// sparse checkouts were added in git 2.26.0, and allow for...sparse...checkouts...
+	// basically it means you can checkout only certain files/folders/etc. instead of
+	// the whole repo. useful for monorepos that may, for example,
+	// contain multiple wrangler templates
+	const useSparseCheckout = subdirectory && semiver(gitVersion, "2.26.0") > -1;
+	if (useSparseCheckout) {
+		args.push("--filter=blob:none", "--sparse");
+	}
+
+	const tagIndex = remote.lastIndexOf("#");
+	if (tagIndex === -1) {
+		args.push(remote);
+	} else {
+		args.push("-b", remote.substring(tagIndex + 1));
+		args.push(remote.substring(0, tagIndex));
+	}
+
+	// we first clone into a temporary directory so that if something goes wrong,
+	// the user's filesystem isn't left in a messed-up state
+	const tempDir = fs.mkdtempSync(
+		path.join(os.tmpdir(), `wrangler-generate-repo-`)
+	);
+	args.push(tempDir);
+
+	await execa("git", args);
+
+	// if we can use sparse checkout, run it now.
+	// otherwise, the entire repo was cloned anyway, so skip this step
+	if (useSparseCheckout) {
+		await execa("git", [`sparse-checkout`, `set`, subdirectory], {
+			cwd: tempDir,
+		});
+	}
+
+	const templatePath =
+		subdirectory !== undefined ? path.join(tempDir, subdirectory) : tempDir;
+
+	// cleanup: move the template to the target directory and delete `.git`
+	try {
+		fs.renameSync(templatePath, targetDirectory);
+	} catch {
+		throw new Error(`Failed to find "${subdirectory}" in ${remote}`);
+	}
+	fs.rmSync(path.join(targetDirectory, ".git"), {
+		recursive: true,
+		force: true,
+	});
+}

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

@@ -1,7 +1,9 @@
 import * as fs from "node:fs";
-import { homedir, networkInterfaces } from "node:os";
+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.
@@ -16,36 +18,39 @@ 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(homedir(), ".wrangler/local-cert");
-  const keyPath = path.join(certDirectory, "key.pem");
-  const certPath = path.join(certDirectory, "cert.pem");
+	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);
+	const regenerate =
+		!fs.existsSync(keyPath) ||
+		!fs.existsSync(certPath) ||
+		hasCertificateExpired(keyPath, certPath);
 
-  if (regenerate) {
-    console.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}`;
-      console.warn(
-        `Unable to cache generated self-signed certificate in ${certDirectory}.\n${message}`
-      );
-    }
-    return { key, cert };
-  } else {
-    return {
-      key: fs.readFileSync(keyPath, "utf8"),
-      cert: fs.readFileSync(certPath, "utf8"),
-    };
-  }
+	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"),
+		};
+	}
 }
 
 /**
@@ -53,70 +58,70 @@ export async function getHttpsOptions() {
  * 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;
+	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
-  );
+	// `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 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 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 };
+	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(networkInterfaces()).forEach((net) =>
-    net?.forEach(({ family, address }) => {
-      if (!ipv4 || family === "IPv4") hosts.push(address);
-    })
-  );
-  return hosts;
+	const hosts: string[] = [];
+	Object.values(os.networkInterfaces()).forEach((net) =>
+		net?.forEach(({ family, address }) => {
+			if (!ipv4 || family === "IPv4") hosts.push(address);
+		})
+	);
+	return hosts;
 }