@cloudflare/vitest-pool-workers 0.15.0 → 0.15.2

package/dist/pool/index.mjs

@@ -1,11 +1,13 @@
 import { createRequire } from "node:module";
 import assert from "node:assert";
-import crypto from "node:crypto";
-import fs, { existsSync, readFileSync, statSync } from "node:fs";
+import crypto, { createHash } from "node:crypto";
+import fs, { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import path, { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import util from "node:util";
-import os from "node:os";
+import os, { arch } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+import { fetch } from "undici";
 import net from "node:net";
 import { Log, LogLevel, Miniflare, ModuleRuleTypeSchema, PLUGINS, Response, compileModuleRules, formatZodError, getNodeCompat, getRootPath, kCurrentWorker, kUnsafeEphemeralUniqueKey, maybeApply, mergeWorkerOptions, parseWithRootPath, structuredSerializableReducers, structuredSerializableRevivers, testRegExps } from "miniflare";
 import { experimental_readRawConfig } from "wrangler";
@@ -459,7 +461,7 @@ var MetricsRegistry = class {
 };
 
 //#endregion
-//#region ../workers-utils/dist/chunk-A4F3D336.mjs
+//#region ../workers-utils/dist/chunk-XXCQEG76.mjs
 var UserError = class extends Error {
 	static {
 		__name(this, "UserError");
@@ -468,7 +470,7 @@ var UserError = class extends Error {
 	constructor(message, options) {
 		super(message, options);
 		Object.setPrototypeOf(this, new.target.prototype);
-		this.telemetryMessage = options?.telemetryMessage === true ? message : options?.telemetryMessage;
+		this.telemetryMessage = typeof options?.telemetryMessage === "string" ? options.telemetryMessage : options?.telemetryMessage ? message : void 0;
 	}
 };
 var DeprecationError = class extends UserError {
@@ -481,13 +483,14 @@ ${message}`, options);
 	}
 };
 var FatalError = class extends UserError {
-	constructor(message, code, options) {
-		super(message, options);
-		this.code = code;
-	}
 	static {
 		__name(this, "FatalError");
 	}
+	code;
+	constructor(message, options) {
+		super(message, options);
+		this.code = options.code;
+	}
 };
 var CommandLineArgsError = class extends UserError {
 	static {
@@ -495,10 +498,6 @@ var CommandLineArgsError = class extends UserError {
 	}
 };
 var JsonFriendlyFatalError = class extends FatalError {
-	constructor(message, code, options) {
-		super(message, code, options);
-		this.code = code;
-	}
 	static {
 		__name(this, "JsonFriendlyFatalError");
 	}
@@ -513,9 +512,9 @@ var MissingConfigError = class extends Error {
 		this.telemetryMessage = `Missing config value for ${key}`;
 	}
 };
-function createFatalError(message, isJson, code, telemetryMessage) {
-	if (isJson) return new JsonFriendlyFatalError(JSON.stringify(message), code, telemetryMessage);
-	else return new FatalError(`${message}`, code, telemetryMessage);
+function createFatalError(message, isJson, options) {
+	if (isJson) return new JsonFriendlyFatalError(JSON.stringify(message), options);
+	return new FatalError(`${message}`, options);
 }
 __name(createFatalError, "createFatalError");
 function createScanner(text, ignoreTrivia = false) {
@@ -2535,7 +2534,8 @@ function readFileSyncToBuffer(file2) {
 		const { message } = err;
 		throw new ParseError({
 			text: `Could not read file: ${file2}`,
-			notes: [{ text: message.replace(file2, resolve(file2)) }]
+			notes: [{ text: message.replace(file2, resolve(file2)) }],
+			telemetryMessage: false
 		});
 	}
 }
@@ -2827,7 +2827,10 @@ function findRedirectedWranglerConfig(cwd, userConfigPath) {
 		const deployConfig = parseJSONC(deployConfigFile, deployConfigPath);
 		redirectedConfigPath = deployConfig.configPath && path.resolve(path.dirname(deployConfigPath), deployConfig.configPath);
 	} catch (e) {
-		throw new UserError(`Failed to parse the deploy configuration file at ${path.relative(".", deployConfigPath)}`, { cause: e });
+		throw new UserError(`Failed to parse the deploy configuration file at ${path.relative(".", deployConfigPath)}`, {
+			cause: e,
+			telemetryMessage: false
+		});
 	}
 	if (!redirectedConfigPath) throw new UserError(esm_default`
 			A deploy configuration file was found at "${path.relative(".", deployConfigPath)}".
@@ -2836,17 +2839,17 @@ function findRedirectedWranglerConfig(cwd, userConfigPath) {
 			\`\`\`
 			${deployConfigFile}
 			\`\`\`
-		`);
+		`, { telemetryMessage: false });
 	if (!existsSync(redirectedConfigPath)) throw new UserError(esm_default`
 				There is a deploy configuration at "${path.relative(".", deployConfigPath)}".
 				But the redirected configuration path it points to, "${path.relative(".", redirectedConfigPath)}", does not exist.
-			`);
+			`, { telemetryMessage: false });
 	if (userConfigPath) {
 		if (path.join(path.dirname(userConfigPath), PATH_TO_DEPLOY_CONFIG) !== deployConfigPath) throw new UserError(esm_default`
 					Found both a user configuration file at "${path.relative(".", userConfigPath)}"
 					and a deploy configuration file at "${path.relative(".", deployConfigPath)}".
 					But these do not share the same base path so it is not clear which should be used.
-				`);
+				`, { telemetryMessage: false });
 	}
 	return {
 		configPath: redirectedConfigPath,
@@ -3412,6 +3415,113 @@ var require_mod_cjs3 = __commonJS({ "../../node_modules/.pnpm/xdg-app-paths@8.3.
 	var node_js_1 = require_node3();
 	module$1.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
 } });
+var require_command_exists = __commonJS({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports$1, module$1) {
+	var exec = __require("child_process").exec;
+	var execSync = __require("child_process").execSync;
+	var fs2 = __require("fs");
+	var path4 = __require("path");
+	var access = fs2.access;
+	var accessSync2 = fs2.accessSync;
+	var constants2 = fs2.constants || fs2;
+	var isUsingWindows = process.platform == "win32";
+	var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
+		access(commandName, constants2.F_OK, function(err) {
+			callback(!err);
+		});
+	}, "fileNotExists");
+	var fileNotExistsSync = /* @__PURE__ */ __name(function(commandName) {
+		try {
+			accessSync2(commandName, constants2.F_OK);
+			return false;
+		} catch (e2) {
+			return true;
+		}
+	}, "fileNotExistsSync");
+	var localExecutable = /* @__PURE__ */ __name(function(commandName, callback) {
+		access(commandName, constants2.F_OK | constants2.X_OK, function(err) {
+			callback(null, !err);
+		});
+	}, "localExecutable");
+	var localExecutableSync = /* @__PURE__ */ __name(function(commandName) {
+		try {
+			accessSync2(commandName, constants2.F_OK | constants2.X_OK);
+			return true;
+		} catch (e2) {
+			return false;
+		}
+	}, "localExecutableSync");
+	var commandExistsUnix = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+		fileNotExists(commandName, function(isFile$1) {
+			if (!isFile$1) {
+				exec("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }", function(error, stdout, stderr) {
+					callback(null, !!stdout);
+				});
+				return;
+			}
+			localExecutable(commandName, callback);
+		});
+	}, "commandExistsUnix");
+	var commandExistsWindows = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+		if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) {
+			callback(null, false);
+			return;
+		}
+		exec("where " + cleanedCommandName, function(error) {
+			if (error !== null) callback(null, false);
+			else callback(null, true);
+		});
+	}, "commandExistsWindows");
+	var commandExistsUnixSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName) {
+		if (fileNotExistsSync(commandName)) try {
+			return !!execSync("command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }");
+		} catch (error) {
+			return false;
+		}
+		return localExecutableSync(commandName);
+	}, "commandExistsUnixSync");
+	var commandExistsWindowsSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+		if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) return false;
+		try {
+			return !!execSync("where " + cleanedCommandName, { stdio: [] });
+		} catch (error) {
+			return false;
+		}
+	}, "commandExistsWindowsSync");
+	var cleanInput = /* @__PURE__ */ __name(function(s) {
+		if (/[^A-Za-z0-9_\/:=-]/.test(s)) {
+			s = "'" + s.replace(/'/g, "'\\''") + "'";
+			s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
+		}
+		return s;
+	}, "cleanInput");
+	if (isUsingWindows) cleanInput = /* @__PURE__ */ __name(function(s) {
+		if (/[\\]/.test(s)) {
+			var dirname2 = "\"" + path4.dirname(s) + "\"";
+			var basename = "\"" + path4.basename(s) + "\"";
+			return dirname2 + ":" + basename;
+		}
+		return "\"" + s + "\"";
+	}, "cleanInput");
+	module$1.exports = /* @__PURE__ */ __name(function commandExists(commandName, callback) {
+		var cleanedCommandName = cleanInput(commandName);
+		if (!callback && typeof Promise !== "undefined") return new Promise(function(resolve$2, reject) {
+			commandExists(commandName, function(error, output) {
+				if (output) resolve$2(commandName);
+				else reject(error);
+			});
+		});
+		if (isUsingWindows) commandExistsWindows(commandName, cleanedCommandName, callback);
+		else commandExistsUnix(commandName, cleanedCommandName, callback);
+	}, "commandExists");
+	module$1.exports.sync = function(commandName) {
+		var cleanedCommandName = cleanInput(commandName);
+		if (isUsingWindows) return commandExistsWindowsSync(commandName, cleanedCommandName);
+		else return commandExistsUnixSync(commandName, cleanedCommandName);
+	};
+} });
+var require_command_exists2 = __commonJS({ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/index.js"(exports$1, module$1) {
+	module$1.exports = require_command_exists();
+} });
 var defaultWranglerConfig = {
 	configPath: void 0,
 	userConfigPath: void 0,
@@ -7090,7 +7200,7 @@ function getBooleanEnvironmentVariableFactory(options) {
 		switch (process.env[options.variableName]?.toLowerCase()) {
 			case "true": return true;
 			case "false": return false;
-			default: throw new UserError(`Expected ${options.variableName} to be "true" or "false", but got ${JSON.stringify(process.env[options.variableName])}`);
+			default: throw new UserError(`Expected ${options.variableName} to be "true" or "false", but got ${JSON.stringify(process.env[options.variableName])}`, { telemetryMessage: false });
 		}
 	};
 }
@@ -7116,7 +7226,7 @@ function getProcessEnv(variableName, choices) {
 }
 __name(getProcessEnv, "getProcessEnv");
 function assertOneOf(choices, value) {
-	if (Array.isArray(choices) && !choices.includes(value)) throw new UserError(`Expected ${JSON.stringify(value)} to be one of ${JSON.stringify(choices)}`);
+	if (Array.isArray(choices) && !choices.includes(value)) throw new UserError(`Expected ${JSON.stringify(value)} to be one of ${JSON.stringify(choices)}`, { telemetryMessage: false });
 }
 __name(assertOneOf, "assertOneOf");
 var getC3CommandFromEnv = getEnvironmentVariableFactory({
@@ -7140,7 +7250,7 @@ var getCloudflareComplianceRegion = /* @__PURE__ */ __name((complianceConfig) =>
 			The compliance region has been set to different values in two places:
 			 - \`CLOUDFLARE_COMPLIANCE_REGION\` environment variable: \`${complianceRegionFromEnv}\`
 			 - \`compliance_region\` configuration property: \`${complianceConfig.compliance_region}\`
-			`);
+			`, { telemetryMessage: false });
 	return complianceRegionFromEnv || complianceConfig?.compliance_region || "public";
 }, "getCloudflareComplianceRegion");
 var getCloudflareApiBaseUrlFromEnv = getEnvironmentVariableFactory({
@@ -7678,7 +7788,7 @@ function applyPythonConfig(config, args) {
 			type: "PythonModule",
 			globs: ["**/*.py"]
 		});
-		if (!config.compatibility_flags.includes("python_workers")) throw new UserError("The `python_workers` compatibility flag is required to use Python.");
+		if (!config.compatibility_flags.includes("python_workers")) throw new UserError("The `python_workers` compatibility flag is required to use Python.", { telemetryMessage: false });
 	}
 }
 __name(applyPythonConfig, "applyPythonConfig");
@@ -9677,7 +9787,7 @@ function isDockerfile(imagePath, configPath) {
 	const baseDir = configPath ? path.dirname(configPath) : process.cwd();
 	const maybeDockerfile = path.resolve(baseDir, imagePath);
 	if (fs.existsSync(maybeDockerfile)) {
-		if (isDirectory$1(maybeDockerfile)) throw new UserError(`${imagePath} is a directory, you should specify a path to the Dockerfile`);
+		if (isDirectory$1(maybeDockerfile)) throw new UserError(`${imagePath} is a directory, you should specify a path to the Dockerfile`, { telemetryMessage: false });
 		return true;
 	}
 	const errorPrefix = `The image "${imagePath}" does not appear to be a valid path to a Dockerfile, or a valid image registry path:
@@ -9685,12 +9795,12 @@ function isDockerfile(imagePath, configPath) {
 	try {
 		new URL(`https://${imagePath}`);
 	} catch (e2) {
-		if (e2 instanceof Error) throw new UserError(errorPrefix + e2.message);
+		if (e2 instanceof Error) throw new UserError(errorPrefix + e2.message, { telemetryMessage: false });
 		throw e2;
 	}
 	const imageParts = imagePath.split("/");
-	if (!imageParts[imageParts.length - 1]?.includes(":")) throw new UserError(errorPrefix + `If this is an image registry path, it needs to include at least a tag ':' (e.g: docker.io/httpd:1)`);
-	if (imagePath.includes("://")) throw new UserError(errorPrefix + `Image reference should not include the protocol part (e.g: docker.io/httpd:1, not https://docker.io/httpd:1)`);
+	if (!imageParts[imageParts.length - 1]?.includes(":")) throw new UserError(errorPrefix + `If this is an image registry path, it needs to include at least a tag ':' (e.g: docker.io/httpd:1)`, { telemetryMessage: false });
+	if (imagePath.includes("://")) throw new UserError(errorPrefix + `Image reference should not include the protocol part (e.g: docker.io/httpd:1, not https://docker.io/httpd:1)`, { telemetryMessage: false });
 	return false;
 }
 __name(isDockerfile, "isDockerfile");
@@ -9727,7 +9837,7 @@ var supportedPagesConfigFields = [
 ];
 function validatePagesConfig(config, envNames, projectName) {
 	if (!config.pages_build_output_dir) throw new FatalError(`Attempting to validate Pages configuration file, but "pages_build_output_dir" field was not found.
-		"pages_build_output_dir" is required for Pages projects.`);
+		"pages_build_output_dir" is required for Pages projects.`, { telemetryMessage: false });
 	const diagnostics = new Diagnostics(`Running configuration file validation for Pages:`);
 	validateMainField(config, diagnostics);
 	validateProjectName(projectName, diagnostics);
@@ -9775,6 +9885,569 @@ Pages requires Durable Object bindings to specify the name of the Worker where t
 	}
 }
 __name(validateDurableObjectBinding2, "validateDurableObjectBinding");
+var import_command_exists = __toESM(require_command_exists2());
+var UPDATE_SERVICE_URL = "https://update.argotunnel.com";
+var CLOUDFLARED_VERSION_PATTERN = /^\d{4}\.\d+\.\d+$/;
+function sha256Hex(buffer) {
+	return createHash("sha256").update(buffer).digest("hex");
+}
+__name(sha256Hex, "sha256Hex");
+function getGoArch() {
+	const nodeArch = arch();
+	switch (nodeArch) {
+		case "x64": return "amd64";
+		case "arm64": return "arm64";
+		case "arm": return "arm";
+		default: throw new UserError(`Unsupported architecture for cloudflared: ${nodeArch}
+
+cloudflared supports: x64 (amd64), arm64, arm
+
+You can manually install cloudflared and set the CLOUDFLARED_PATH environment variable.
+Download instructions: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`, { telemetryMessage: "tunnel cloudflared unsupported architecture" });
+	}
+}
+__name(getGoArch, "getGoArch");
+function getGoOS() {
+	switch (process.platform) {
+		case "darwin": return "darwin";
+		case "linux": return "linux";
+		case "win32": return "windows";
+		default: throw new UserError(`Unsupported platform for cloudflared: ${process.platform}
+
+cloudflared supports: darwin (macOS), linux, win32 (Windows)
+
+You can manually install cloudflared and set the CLOUDFLARED_PATH environment variable.
+Download instructions: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`, { telemetryMessage: "tunnel cloudflared unsupported platform" });
+	}
+}
+__name(getGoOS, "getGoOS");
+var GITHUB_RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/download";
+function getAssetFilename(goOS, goArch) {
+	if (goOS === "windows") return `cloudflared-${goOS}-${goArch}.exe`;
+	if (goOS === "darwin") return `cloudflared-${goOS}-${goArch}.tgz`;
+	return `cloudflared-${goOS}-${goArch}`;
+}
+__name(getAssetFilename, "getAssetFilename");
+async function queryUpdateService(goOS, goArch, options) {
+	const { logger } = options ?? {};
+	const url = new URL(UPDATE_SERVICE_URL);
+	url.searchParams.set("os", goOS);
+	url.searchParams.set("arch", goArch);
+	logger?.debug(`Checking for latest cloudflared: ${url.toString()}`);
+	let response;
+	try {
+		response = await fetch(url.toString(), { headers: { "User-Agent": "wrangler" } });
+	} catch (e2) {
+		logger?.debug(`Failed to reach update service: ${e2 instanceof Error ? e2.message : String(e2)}`);
+		return null;
+	}
+	if (!response.ok) {
+		logger?.debug(`Update service returned ${response.status} for ${goOS}/${goArch}`);
+		return null;
+	}
+	let data;
+	try {
+		data = await response.json();
+	} catch (e2) {
+		logger?.debug(`Update service returned non-JSON response: ${e2 instanceof Error ? e2.message : String(e2)}`);
+		return null;
+	}
+	if (typeof data.version === "string" && !CLOUDFLARED_VERSION_PATTERN.test(data.version)) throw new Error(`[cloudflared] Invalid cloudflared version returned by update service: ${data.version}`);
+	if (data.error || !data.url || !data.version) return data.version ? data : null;
+	return data;
+}
+__name(queryUpdateService, "queryUpdateService");
+async function getLatestVersionInfo(options) {
+	const { logger } = options ?? {};
+	const goOS = getGoOS();
+	const goArch = getGoArch();
+	const primary = await queryUpdateService(goOS, goArch, { logger });
+	if (primary && primary.url && primary.version) return primary;
+	logger?.debug(`Update worker had no result for ${goOS}/${goArch}, falling back to GitHub release URL`);
+	const fallback = await queryUpdateService("linux", "amd64", { logger });
+	if (!fallback?.version) throw new UserError(`[cloudflared] Failed to determine the latest cloudflared version.
+
+The update service did not return results for ${goOS}/${goArch},
+and the fallback query also failed.
+
+You can manually install cloudflared from:
+https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`, { telemetryMessage: "tunnel cloudflared version lookup failed" });
+	const version = fallback.version;
+	const filename = getAssetFilename(goOS, goArch);
+	return {
+		url: `${GITHUB_RELEASE_BASE}/${version}/${filename}`,
+		version,
+		checksum: "",
+		compressed: filename.endsWith(".tgz"),
+		shouldUpdate: true,
+		userMessage: "",
+		error: ""
+	};
+}
+__name(getLatestVersionInfo, "getLatestVersionInfo");
+function getCacheDir(version) {
+	return join(getGlobalWranglerConfigPath(), "cloudflared", version);
+}
+__name(getCacheDir, "getCacheDir");
+function getCloudflaredBinPath(version) {
+	const binName = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
+	return join(getCacheDir(version), binName);
+}
+__name(getCloudflaredBinPath, "getCloudflaredBinPath");
+function isBinaryExecutable(binPath) {
+	try {
+		accessSync(binPath, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+__name(isBinaryExecutable, "isBinaryExecutable");
+function validateBinary(binPath, options) {
+	const { logger } = options ?? {};
+	try {
+		const output = execFileSync(binPath, ["--version"], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: 1e4,
+			encoding: "utf8"
+		}).trim();
+		logger?.debug(`cloudflared version: ${output}`);
+	} catch {
+		let errorMessage = `[cloudflared] Failed to validate cloudflared binary at ${binPath}
+
+`;
+		errorMessage += `This usually means:
+`;
+		errorMessage += `  - The binary is corrupted or incomplete
+`;
+		errorMessage += `  - You're missing required system libraries
+`;
+		if (process.platform === "linux") {
+			errorMessage += `
+On Linux, make sure you have the required dependencies:
+`;
+			errorMessage += `  - glibc (GNU C Library)
+`;
+			errorMessage += `  - For Debian/Ubuntu: sudo apt-get install libc6
+`;
+		}
+		const cacheDir = join(getGlobalWranglerConfigPath(), "cloudflared");
+		errorMessage += `
+You can try:
+`;
+		errorMessage += `  1. Deleting the cache directory: rm -rf ${cacheDir}
+`;
+		errorMessage += `  2. Running the command again to re-download
+`;
+		errorMessage += `  3. Manually installing cloudflared: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/
+`;
+		errorMessage += `  4. Setting CLOUDFLARED_PATH to point to your cloudflared binary`;
+		throw new UserError(errorMessage, { telemetryMessage: "tunnel cloudflared validation failed" });
+	}
+}
+__name(validateBinary, "validateBinary");
+function redactCloudflaredArgsForLogging(args) {
+	const redacted = [...args];
+	for (let i = 0; i < redacted.length; i++) {
+		const arg = redacted[i];
+		if (arg === "--token" && i + 1 < redacted.length) redacted[i + 1] = "[REDACTED]";
+		if (arg.startsWith("--token=")) redacted[i] = "--token=[REDACTED]";
+	}
+	return redacted;
+}
+__name(redactCloudflaredArgsForLogging, "redactCloudflaredArgsForLogging");
+function tryGetCloudflaredFromPath(options) {
+	const { logger } = options ?? {};
+	if (!(0, import_command_exists.sync)("cloudflared")) return null;
+	try {
+		validateBinary("cloudflared", { logger });
+		return "cloudflared";
+	} catch (e2) {
+		logger?.debug("cloudflared found in PATH but failed validation", e2);
+		return null;
+	}
+}
+__name(tryGetCloudflaredFromPath, "tryGetCloudflaredFromPath");
+function getInstalledVersion(binPath) {
+	try {
+		const match = execFileSync(binPath, ["--version"], {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			timeout: 1e4,
+			encoding: "utf8"
+		}).match(/(\d+\.\d+\.\d+)/);
+		return match ? match[1] : null;
+	} catch {
+		return null;
+	}
+}
+__name(getInstalledVersion, "getInstalledVersion");
+function isVersionOutdated(installed, latest) {
+	const parse$2 = /* @__PURE__ */ __name((v) => v.split(".").map(Number), "parse");
+	const [iYear, iMonth, iPatch] = parse$2(installed);
+	const [lYear, lMonth, lPatch] = parse$2(latest);
+	if (iYear !== lYear) return iYear < lYear;
+	if (iMonth !== lMonth) return iMonth < lMonth;
+	return iPatch < lPatch;
+}
+__name(isVersionOutdated, "isVersionOutdated");
+async function warnIfOutdated(binPath, options) {
+	const { logger } = options ?? {};
+	try {
+		const installed = getInstalledVersion(binPath);
+		if (!installed) return;
+		const latestVersion = (await queryUpdateService(getGoOS(), getGoArch(), { logger }) ?? await queryUpdateService("linux", "amd64", { logger }))?.version;
+		if (!latestVersion) return;
+		if (isVersionOutdated(installed, latestVersion)) logger?.warn(`Your cloudflared (${installed}) is outdated. Latest version is ${latestVersion}.
+Update: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`);
+	} catch (e2) {
+		logger?.debug("Failed to check cloudflared version", e2);
+	}
+}
+__name(warnIfOutdated, "warnIfOutdated");
+function writeFileAtomic(filePath, contents) {
+	const tmpPath = join(dirname(filePath), `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+	try {
+		writeFileSync(tmpPath, contents);
+		renameSync(tmpPath, filePath);
+	} finally {
+		try {
+			if (existsSync(tmpPath)) unlinkSync(tmpPath);
+		} catch {}
+	}
+}
+__name(writeFileAtomic, "writeFileAtomic");
+async function downloadCloudflared(versionInfo, binPath, options) {
+	const { logger } = options ?? {};
+	const { url, version, checksum, compressed } = versionInfo;
+	logger?.log(`Downloading cloudflared ${version}...`);
+	logger?.debug(`Download URL: ${url}`);
+	const cacheDir = dirname(binPath);
+	mkdirSync(cacheDir, { recursive: true });
+	let response;
+	try {
+		response = await fetch(url, { headers: { "User-Agent": "wrangler" } });
+	} catch (e2) {
+		throw new UserError(`[cloudflared] Failed to download cloudflared from ${url}
+
+Network error: ${e2 instanceof Error ? e2.message : String(e2)}
+
+Please check your internet connection and try again.
+If you're behind a proxy, make sure it's configured correctly.`, { telemetryMessage: "tunnel cloudflared download network failed" });
+	}
+	if (!response.ok) throw new UserError(`[cloudflared] Failed to download cloudflared from ${url}
+
+HTTP ${response.status}: ${response.statusText}
+
+You can manually download cloudflared from:
+https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/`, { telemetryMessage: "tunnel cloudflared download response failed" });
+	try {
+		if (compressed) await downloadAndExtractTarball(response, checksum, binPath, cacheDir);
+		else await downloadBinary(response, checksum, binPath);
+	} catch (e2) {
+		try {
+			if (existsSync(binPath)) unlinkSync(binPath);
+		} catch {}
+		if (e2 instanceof UserError) throw e2;
+		throw new UserError(`[cloudflared] Failed to save cloudflared binary
+
+Error: ${e2 instanceof Error ? e2.message : String(e2)}
+
+Please ensure you have write permissions to: ${cacheDir}`, { telemetryMessage: "tunnel cloudflared save failed" });
+	}
+	if (process.platform !== "win32") chmodSync(binPath, 493);
+	logger?.log(`cloudflared ${version} installed`);
+	logger?.debug(`Binary location: ${binPath}`);
+}
+__name(downloadCloudflared, "downloadCloudflared");
+async function downloadAndExtractTarball(response, expectedChecksum, binPath, cacheDir) {
+	const tempTarPath = join(cacheDir, "cloudflared.tgz");
+	const buffer = Buffer.from(await response.arrayBuffer());
+	if (expectedChecksum) {
+		const actualSha256 = sha256Hex(buffer);
+		if (actualSha256 !== expectedChecksum) throw new UserError(`[cloudflared] SHA256 mismatch for downloaded cloudflared tarball.
+
+Expected: ${expectedChecksum}
+Actual:   ${actualSha256}`, { telemetryMessage: "tunnel cloudflared tarball checksum mismatch" });
+	}
+	writeFileSync(tempTarPath, buffer);
+	try {
+		execFileSync("tar", [
+			"-xzf",
+			tempTarPath,
+			"-C",
+			cacheDir
+		], { stdio: "ignore" });
+		const extractedPath = join(cacheDir, "cloudflared");
+		if (extractedPath !== binPath && existsSync(extractedPath)) renameSync(extractedPath, binPath);
+	} finally {
+		try {
+			if (existsSync(tempTarPath)) unlinkSync(tempTarPath);
+		} catch {}
+	}
+}
+__name(downloadAndExtractTarball, "downloadAndExtractTarball");
+async function downloadBinary(response, expectedChecksum, binPath) {
+	const buffer = Buffer.from(await response.arrayBuffer());
+	if (expectedChecksum) {
+		const actualSha256 = sha256Hex(buffer);
+		if (actualSha256 !== expectedChecksum) throw new UserError(`[cloudflared] SHA256 mismatch for downloaded cloudflared binary.
+
+Expected: ${expectedChecksum}
+Actual:   ${actualSha256}`, { telemetryMessage: "tunnel cloudflared binary checksum mismatch" });
+	}
+	writeFileAtomic(binPath, buffer);
+}
+__name(downloadBinary, "downloadBinary");
+async function getCloudflaredPath(options) {
+	const logger = options?.logger;
+	const envPath = getCloudflaredPathFromEnv();
+	if (envPath) {
+		if (!existsSync(envPath)) throw new UserError(`CLOUDFLARED_PATH is set to "${envPath}" but the file does not exist.
+
+Please ensure the path points to a valid cloudflared binary.`, { telemetryMessage: "tunnel cloudflared env path missing" });
+		logger?.debug(`Using cloudflared from CLOUDFLARED_PATH: ${envPath}`);
+		return envPath;
+	}
+	const pathBin = tryGetCloudflaredFromPath({ logger });
+	if (pathBin) {
+		logger?.debug("Using cloudflared from PATH");
+		if (!options?.skipVersionCheck) await warnIfOutdated(pathBin, { logger });
+		return pathBin;
+	}
+	const versionInfo = await getLatestVersionInfo({ logger });
+	const binPath = getCloudflaredBinPath(versionInfo.version);
+	let needsDownload = !isBinaryExecutable(binPath);
+	if (!needsDownload) try {
+		validateBinary(binPath, { logger });
+		logger?.debug(`Using cached cloudflared ${versionInfo.version}: ${binPath}`);
+		return binPath;
+	} catch (e2) {
+		logger?.debug("Cached cloudflared failed validation; re-downloading", e2);
+		needsDownload = true;
+	}
+	if (!(await options?.confirmDownload?.(`cloudflared (${versionInfo.version}) is needed but not installed. Download to ${binPath}?`) ?? true)) throw new UserError(`cloudflared is required to run this command.
+
+You can install it manually from:
+https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/
+
+Then either add it to your PATH or set CLOUDFLARED_PATH.`, { telemetryMessage: "tunnel cloudflared download declined" });
+	if (existsSync(binPath)) {
+		const cacheDir = removeCloudflaredCache(versionInfo.version);
+		if (cacheDir) logger?.log(`Removed cloudflared cache: ${cacheDir}`);
+	}
+	await downloadCloudflared(versionInfo, binPath, { logger });
+	validateBinary(binPath, { logger });
+	return binPath;
+}
+__name(getCloudflaredPath, "getCloudflaredPath");
+async function spawnCloudflared(args, options) {
+	const logger = options?.logger;
+	const binPath = await getCloudflaredPath({
+		skipVersionCheck: options?.skipVersionCheck,
+		confirmDownload: options?.confirmDownload,
+		logger
+	});
+	logger?.debug(`Spawning cloudflared: ${binPath} ${redactCloudflaredArgsForLogging(args).join(" ")}`);
+	return spawn(binPath, args, {
+		stdio: options?.stdio ?? "inherit",
+		env: options?.env ? {
+			...process.env,
+			...options.env
+		} : void 0
+	});
+}
+__name(spawnCloudflared, "spawnCloudflared");
+function removeCloudflaredCache(version) {
+	const cacheDir = version ? getCacheDir(version) : join(getGlobalWranglerConfigPath(), "cloudflared");
+	if (existsSync(cacheDir)) {
+		removeDirSync(cacheDir);
+		return cacheDir;
+	}
+	return null;
+}
+__name(removeCloudflaredCache, "removeCloudflaredCache");
+var TUNNEL_STARTUP_TIMEOUT_MS = 3e4;
+var TUNNEL_FORCE_KILL_TIMEOUT_MS = 5e3;
+var DEFAULT_TUNNEL_EXPIRY_MS = 3600 * 1e3;
+var DEFAULT_TUNNEL_EXTENSION_MS = 3600 * 1e3;
+var DEFAULT_TUNNEL_MAX_REMAINING_MS = 10800 * 1e3;
+var DEFAULT_TUNNEL_REMINDER_INTERVAL_MS = 600 * 1e3;
+var QUICK_TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+function startTunnel(options) {
+	let disposed = false;
+	let reminderInterval;
+	let expiryTimeout;
+	let expiresAt = 0;
+	let cloudflaredProcess;
+	const logger = options.logger;
+	const timeoutMs = options.timeoutMs ?? TUNNEL_STARTUP_TIMEOUT_MS;
+	const reminderIntervalMs = options.reminderIntervalMs ?? DEFAULT_TUNNEL_REMINDER_INTERVAL_MS;
+	const defaultExpiryMs = options.expiryMs ?? DEFAULT_TUNNEL_EXPIRY_MS;
+	const timeFormatter = new Intl.DateTimeFormat(void 0, { timeStyle: "short" });
+	const readyPromise = spawnCloudflared([
+		"tunnel",
+		"--no-autoupdate",
+		"--url",
+		options.origin.href
+	], {
+		stdio: "pipe",
+		skipVersionCheck: true,
+		logger
+	}).then((process2) => {
+		cloudflaredProcess = process2;
+		if (disposed) terminateCloudflared(process2);
+		return process2;
+	}).then((process2) => waitForQuickTunnelReady(process2, timeoutMs, {
+		logger,
+		origin: options.origin
+	})).then((result) => {
+		expiresAt = Date.now() + defaultExpiryMs;
+		scheduleExpiryTimeout();
+		scheduleReminder(result.publicUrl.origin);
+		return result;
+	});
+	function disposeTunnel() {
+		disposed = true;
+		clearTunnelTimers();
+		if (cloudflaredProcess) terminateCloudflared(cloudflaredProcess);
+	}
+	__name(disposeTunnel, "disposeTunnel");
+	function clearTunnelTimers() {
+		if (expiryTimeout) {
+			clearTimeout(expiryTimeout);
+			expiryTimeout = void 0;
+		}
+		if (reminderInterval) {
+			clearInterval(reminderInterval);
+			reminderInterval = void 0;
+		}
+	}
+	__name(clearTunnelTimers, "clearTunnelTimers");
+	function scheduleReminder(publicURL) {
+		if (reminderIntervalMs > 0) {
+			reminderInterval = setInterval(() => {
+				if (disposed) return;
+				const remainingMs = expiresAt - Date.now();
+				if (remainingMs <= 0) return;
+				logger?.log(`The tunnel is still open at ${publicURL}. It expires in ${formatTunnelDuration(remainingMs)}. ${options.extendHint ?? ""}`);
+			}, reminderIntervalMs);
+			reminderInterval.unref?.();
+		}
+	}
+	__name(scheduleReminder, "scheduleReminder");
+	function scheduleExpiryTimeout() {
+		if (disposed) return;
+		if (expiryTimeout) clearTimeout(expiryTimeout);
+		expiryTimeout = setTimeout(() => {
+			if (disposed) return;
+			logger?.log("Tunnel expired. Closing tunnel.");
+			disposeTunnel();
+		}, Math.max(0, expiresAt - Date.now()));
+		expiryTimeout.unref();
+	}
+	__name(scheduleExpiryTimeout, "scheduleExpiryTimeout");
+	function extendExpiry(ms = DEFAULT_TUNNEL_EXTENSION_MS) {
+		if (disposed || !expiryTimeout || ms <= 0) return;
+		const now = Date.now();
+		const previousExpiresAt = expiresAt;
+		expiresAt = Math.min(now + DEFAULT_TUNNEL_MAX_REMAINING_MS, Math.max(expiresAt, now) + ms);
+		const extendedByMs = expiresAt - previousExpiresAt;
+		if (extendedByMs < ms) {
+			logger?.log(`Tunnel expiry extended to the ${formatTunnelDuration(DEFAULT_TUNNEL_MAX_REMAINING_MS)} limit. It now expires at ${timeFormatter.format(new Date(expiresAt))}.`);
+			scheduleExpiryTimeout();
+			return;
+		}
+		logger?.log(`Tunnel expiry extended by ${formatTunnelDuration(extendedByMs)}. It now expires at ${timeFormatter.format(new Date(expiresAt))}.`);
+		scheduleExpiryTimeout();
+	}
+	__name(extendExpiry, "extendExpiry");
+	return {
+		ready: /* @__PURE__ */ __name(() => readyPromise, "ready"),
+		dispose: disposeTunnel,
+		extendExpiry
+	};
+}
+__name(startTunnel, "startTunnel");
+function formatTunnelDuration(durationMs) {
+	const totalMinutes = Math.max(1, Math.ceil(durationMs / 6e4));
+	const hours = Math.floor(totalMinutes / 60);
+	const minutes = totalMinutes % 60;
+	if (hours === 0) return `${minutes}m`;
+	if (minutes === 0) return `${hours}h`;
+	return `${hours}h ${minutes}m`;
+}
+__name(formatTunnelDuration, "formatTunnelDuration");
+function terminateCloudflared(cloudflared) {
+	if (cloudflared.killed) return;
+	cloudflared.unref();
+	cloudflared.kill("SIGTERM");
+	setTimeout(() => {
+		if (!cloudflared.killed) cloudflared.kill("SIGKILL");
+	}, TUNNEL_FORCE_KILL_TIMEOUT_MS).unref();
+}
+__name(terminateCloudflared, "terminateCloudflared");
+function waitForQuickTunnelReady(cloudflared, timeoutMs, options) {
+	return new Promise((resolve$2, reject) => {
+		let resolved = false;
+		let stderrOutput = "";
+		const logger = options?.logger;
+		const origin = options?.origin;
+		const timeoutId = setTimeout(() => {
+			if (!resolved) {
+				resolved = true;
+				terminateCloudflared(cloudflared);
+				reject(createTunnelStartupError(`Timed out waiting for cloudflared to start (${timeoutMs / 1e3}s).`, stderrOutput, origin));
+			}
+		}, timeoutMs);
+		timeoutId.unref();
+		if (cloudflared.stderr) cloudflared.stderr.on("data", (data) => {
+			const chunk = data.toString();
+			stderrOutput += chunk;
+			logger?.debug("[cloudflared]", chunk.trimEnd());
+			const match = QUICK_TUNNEL_URL_REGEX.exec(stderrOutput);
+			if (match && !resolved) {
+				resolved = true;
+				clearTimeout(timeoutId);
+				resolve$2({ publicUrl: new URL(match[0]) });
+			}
+		});
+		cloudflared.on("error", (error) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeoutId);
+				reject(/* @__PURE__ */ new Error(`Failed to start cloudflared: ${error.message}`));
+			}
+		});
+		cloudflared.on("exit", (code, signal) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeoutId);
+				reject(createTunnelStartupError(`cloudflared ${signal ? `terminated by signal ${signal}` : `exited with code ${code}`} before the tunnel was ready.`, stderrOutput, origin));
+			}
+		});
+	});
+}
+__name(waitForQuickTunnelReady, "waitForQuickTunnelReady");
+function createTunnelStartupError(message, stderrOutput, origin) {
+	const isQuickTunnelRateLimited = stderrOutput.includes("429 Too Many Requests");
+	const errorMessage = `${message}
+cloudflared output:
+${stderrOutput || "(no output)"}
+
+The local dev server started at ${origin.href}.
+` + (isQuickTunnelRateLimited ? "Cloudflare Quick Tunnel creation was rate limited. Try again in a few minutes, or use a named tunnel if you need more reliable access." : `Check the cloudflared output above for more details, and verify that ${origin.href} is reachable from this machine if this keeps happening.`);
+	if (isQuickTunnelRateLimited) return new UserError(errorMessage, { telemetryMessage: false });
+	return new Error(errorMessage);
+}
+__name(createTunnelStartupError, "createTunnelStartupError");
 
 //#endregion
 //#region ../../node_modules/.pnpm/devalue@5.6.3/node_modules/devalue/src/utils.js