unplugin-cloudflare-tunnel 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,1089 +1,2 @@
-import { a as number, c as string, i as nullish, l as unknown, n as array, o as object, r as boolean, s as optional, t as any } from "./schemas-Cpk3vGGi.mjs";
-import { createUnplugin } from "unplugin";
-import NodeFS from "node:fs/promises";
-import { bin, install } from "cloudflared";
-import * as NodeChildProcess from "node:child_process";
-import * as NodeUtil from "node:util";
-//#region src/index.ts
-/**
-* @fileoverview Cloudflare Tunnel Unplugin
-*
-* A cross-bundler plugin that automatically creates and manages
-* Cloudflare tunnels for local development, providing instant HTTPS access
-* to your local dev server from anywhere on the internet.
-*
-* @author Cloudflare Tunnel Plugin Contributors
-* @version 1.0.0
-* @license MIT
-*/
-const PLUGIN_NAME = "unplugin-cloudflare-tunnel";
-const INFO_LOG_REGEX = /^.*Z INF .*/;
-const LOG_LEVEL_RANK = {
-	debug: 10,
-	info: 20,
-	warn: 30,
-	error: 40,
-	fatal: 50
-};
-function shouldLog(threshold, level) {
-	return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[threshold];
-}
-function supportsColor() {
-	if (!process.stdout.isTTY) return false;
-	if (process.env.NO_COLOR !== void 0) return false;
-	if (process.env.TERM === "dumb") return false;
-	if (process.env.FORCE_COLOR === "0") return false;
-	return true;
-}
-const ANSI = {
-	reset: "\x1B[0m",
-	dim: "\x1B[2m",
-	bold: "\x1B[1m",
-	blue: "\x1B[34m",
-	yellow: "\x1B[33m"
-};
-const ANSI_STYLE_SEQUENCE_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
-function stripAnsi(text) {
-	return text.replace(ANSI_STYLE_SEQUENCE_REGEX, "");
-}
-function colorize(text, ansi) {
-	if (!supportsColor()) return text;
-	return `${ansi}${text}${ANSI.reset}`;
-}
-const CloudflareErrorSchema = object({
-	code: number(),
-	message: string()
-});
-const CloudflareApiResponseSchema = object({
-	success: boolean(),
-	errors: optional(array(CloudflareErrorSchema)),
-	messages: optional(array(string())),
-	result: unknown()
-});
-const AccountSchema = object({
-	id: string(),
-	name: string()
-});
-const ZoneSchema = object({
-	id: string(),
-	name: string(),
-	account: optional(object({ id: string() }))
-});
-const TunnelSchema = object({
-	id: string(),
-	name: string(),
-	account_tag: string(),
-	created_at: string(),
-	connections: optional(array(unknown()))
-});
-const DNSRecordSchema = object({
-	id: string(),
-	type: string(),
-	name: string(),
-	content: string(),
-	proxied: boolean(),
-	comment: nullish(string())
-});
-const unpluginFactory = (options = {}) => {
-	const { enabled = true } = options;
-	if (enabled === false) {
-		const VIRTUAL_MODULE_ID_STUB = "virtual:unplugin-cloudflare-tunnel";
-		return {
-			name: PLUGIN_NAME,
-			enforce: "pre",
-			resolveId(id) {
-				if (id === VIRTUAL_MODULE_ID_STUB) return id;
-			},
-			loadInclude(id) {
-				return id === VIRTUAL_MODULE_ID_STUB;
-			},
-			load(id) {
-				if (id === VIRTUAL_MODULE_ID_STUB) return "export function getTunnelUrl() { return \"\"; }";
-			}
-		};
-	}
-	const GLOBAL_STATE = Symbol.for("unplugin-cloudflare-tunnel.state");
-	const globalState = globalThis[GLOBAL_STATE] ?? {};
-	globalThis[GLOBAL_STATE] = globalState;
-	let child = globalState.child;
-	const VIRTUAL_MODULE_ID = "virtual:unplugin-cloudflare-tunnel";
-	const requestedMode = options.mode;
-	if (requestedMode && !["quick", "named"].includes(requestedMode)) throw new Error("[unplugin-cloudflare-tunnel] mode must be one of: 'quick', 'named'");
-	const hasHostname = "hostname" in options && typeof options.hostname === "string";
-	const isQuickMode = requestedMode ? requestedMode === "quick" : !hasHostname;
-	if (requestedMode === "named" && !hasHostname) throw new Error("[unplugin-cloudflare-tunnel] hostname is required when mode is set to named");
-	if (isQuickMode) {
-		const invalidOptions = [
-			"apiToken",
-			"accountId",
-			"zoneId",
-			"tunnelName",
-			"dns",
-			"ssl",
-			"cleanup"
-		].filter((opt) => opt in options);
-		if (invalidOptions.length > 0) throw new Error(`[unplugin-cloudflare-tunnel] The following options are only supported in named tunnel mode: ${invalidOptions.join(", ")}. Set mode to 'named' and provide a hostname, or remove these options for quick tunnel mode.`);
-	}
-	let providedApiToken;
-	let hostname;
-	let tunnelName;
-	let forcedAccount;
-	let forcedZone;
-	let dnsOption;
-	let sslOption;
-	let cleanupConfig;
-	if (isQuickMode) {
-		tunnelName = "quick-tunnel";
-		cleanupConfig = {};
-	} else {
-		const namedOptions = options;
-		providedApiToken = namedOptions.apiToken;
-		hostname = namedOptions.hostname;
-		forcedAccount = namedOptions.accountId;
-		forcedZone = namedOptions.zoneId;
-		tunnelName = namedOptions.tunnelName || "dev-tunnel";
-		dnsOption = namedOptions.dns;
-		sslOption = namedOptions.ssl;
-		cleanupConfig = namedOptions.cleanup || {};
-	}
-	const { port: userProvidedPort, logFile, logLevel, protocol = "http2", debug = false } = options;
-	const effectivePluginLogLevel = logLevel ?? (debug ? "debug" : "info");
-	const redactForDebug = (value) => {
-		if (typeof value === "string") {
-			if (value.startsWith("eyJ") && value.length > 40) return "[REDACTED_TOKEN]";
-			return value;
-		}
-		if (Array.isArray(value)) return value.map((item) => redactForDebug(item));
-		if (value && typeof value === "object") {
-			const entries = Object.entries(value).map(([key, nestedValue]) => {
-				if (/token|authorization|secret|password/i.test(key)) return [key, "[REDACTED]"];
-				return [key, redactForDebug(nestedValue)];
-			});
-			return Object.fromEntries(entries);
-		}
-		return value;
-	};
-	const formatDebugValue = (value) => {
-		const redactedValue = redactForDebug(value);
-		if (typeof redactedValue === "string") return redactedValue;
-		return NodeUtil.inspect(redactedValue, {
-			depth: null,
-			colors: supportsColor(),
-			compact: false,
-			breakLength: 120,
-			sorted: true
-		});
-	};
-	const pluginLog = {
-		debug: (...args) => {
-			if (debug || effectivePluginLogLevel === "debug") console.log("[cloudflare-tunnel:debug]", ...args.map((arg) => formatDebugValue(arg)));
-		},
-		info: (message) => {
-			if (shouldLog(effectivePluginLogLevel, "info")) console.log(`[unplugin-cloudflare-tunnel] ${message}`);
-		},
-		warn: (message) => {
-			if (shouldLog(effectivePluginLogLevel, "warn")) console.warn(`[unplugin-cloudflare-tunnel] ${message}`);
-		},
-		error: (message) => {
-			if (shouldLog(effectivePluginLogLevel, "error")) console.error(`[unplugin-cloudflare-tunnel] ${message}`);
-		}
-	};
-	const debugLog = pluginLog.debug;
-	const makeLocalDisplay = (localTarget) => {
-		if (!localTarget) return localTarget;
-		return localTarget.replace("http://[::1]:", "http://localhost:").replace("http://127.0.0.1:", "http://localhost:");
-	};
-	const announceConnecting = () => {
-		if (globalState.__tunnelConnectingAnnounced) return;
-		globalState.__tunnelConnectingAnnounced = true;
-		const message = isQuickMode ? "cf tunnel connecting…" : hostname ? `cf tunnel connecting… (${hostname})` : "cf tunnel connecting…";
-		console.log("");
-		console.log(colorize(message, ANSI.bold));
-	};
-	const announceTunnel = (params) => {
-		if (!params.url) return;
-		if (globalState.__lastAnnouncedTunnelKey === params.key) return;
-		globalState.__lastAnnouncedTunnelKey = params.key;
-		const cols = process.stdout.columns ?? 80;
-		const maxWidth = Math.max(10, cols - 2);
-		const header = `${colorize("[", ANSI.yellow)}unplugin-cloudflare-tunnel${colorize("]", ANSI.yellow)}`;
-		const urlLine = colorize(params.url, ANSI.blue + ANSI.bold);
-		const localLine = params.localTarget ? makeLocalDisplay(params.localTarget) : "";
-		const headerPlainLen = stripAnsi(header).length;
-		const contentPlainLen = Math.max(stripAnsi(urlLine).length, localLine.length, 10, 5);
-		const width = Math.min(90, maxWidth, Math.max(44, headerPlainLen, contentPlainLen + 4));
-		const rule = "─".repeat(width);
-		const center = (text) => {
-			const plainLen = stripAnsi(text).length;
-			const pad = Math.max(0, Math.floor((width - plainLen) / 2));
-			return `${" ".repeat(pad)}${text}`;
-		};
-		if (cols < 70) {
-			const out = [];
-			out.push("");
-			out.push(`${header} ${colorize("Tunnel URL", ANSI.bold)} ${urlLine}`);
-			if (localLine) out.push(`${header} ${colorize("Local", ANSI.dim + ANSI.bold)} ${localLine}`);
-			out.push("");
-			console.log(out.join("\n"));
-			return;
-		}
-		const out = [];
-		out.push("");
-		out.push(center(header));
-		out.push(rule);
-		out.push(center(colorize("Tunnel URL", ANSI.bold)));
-		out.push(center(urlLine));
-		if (localLine) {
-			out.push("");
-			out.push(center(colorize("Local", ANSI.dim + ANSI.bold)));
-			out.push(center(localLine));
-		}
-		out.push(rule);
-		out.push("");
-		console.log(out.join("\n"));
-	};
-	if (!isQuickMode && (!hostname || typeof hostname !== "string")) throw new Error("[unplugin-cloudflare-tunnel] hostname is required and must be a valid string in named tunnel mode");
-	let tunnelUrl = hostname ? `https://${hostname}` : "";
-	if (tunnelName && !/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(tunnelName)) throw new Error("[unplugin-cloudflare-tunnel] tunnelName must contain only letters, numbers, and hyphens. It cannot start or end with a hyphen.");
-	if (userProvidedPort && (typeof userProvidedPort !== "number" || userProvidedPort < 1 || userProvidedPort > 65535)) throw new Error("[unplugin-cloudflare-tunnel] port must be a valid number between 1 and 65535");
-	if (logLevel && ![
-		"debug",
-		"info",
-		"warn",
-		"error",
-		"fatal"
-	].includes(logLevel)) throw new Error("[unplugin-cloudflare-tunnel] logLevel must be one of: debug, info, warn, error, fatal");
-	const effectiveLogLevel = logLevel ?? (debug ? "info" : "warn");
-	const cloudflaredProcessLogLevel = effectiveLogLevel === "debug" ? "debug" : "info";
-	debugLog("Effective cloudflared log level filter:", effectiveLogLevel);
-	debugLog("Effective cloudflared process log level:", cloudflaredProcessLogLevel);
-	debugLog("Effective cloudflared protocol:", protocol);
-	if (dnsOption) {
-		if (!dnsOption.startsWith("*.") && dnsOption !== hostname) throw new Error("[unplugin-cloudflare-tunnel] dns option must either be a wildcard (e.g., '*.example.com') or exactly match the hostname");
-	}
-	if (sslOption) {
-		if (!sslOption.startsWith("*.") && sslOption !== hostname) throw new Error("[unplugin-cloudflare-tunnel] ssl option must either be a wildcard (e.g., '*.example.com') or exactly match the hostname");
-	}
-	if (!["http2", "quic"].includes(protocol)) throw new Error("[unplugin-cloudflare-tunnel] protocol must be one of: 'http2', 'quic'");
-	const trackSslCertificate = (certificateId, hosts, tunnelName, timestamp = (/* @__PURE__ */ new Date()).toISOString()) => {
-		const trackingKey = `ssl-cert-${certificateId}`;
-		globalState[trackingKey] = {
-			id: certificateId,
-			hosts,
-			tunnelName,
-			timestamp,
-			pluginVersion: "1.0.0"
-		};
-		debugLog(`Tracking SSL certificate: ${certificateId} for hosts: ${hosts.join(", ")}`);
-	};
-	const findMismatchedSslCertificates = async (apiToken, zoneId, currentTunnelName, currentHostname) => {
-		try {
-			const certPacks = await cf(apiToken, "GET", `/zones/${zoneId}/ssl/certificate_packs?status=all`, void 0, any());
-			const currentTunnelCerts = (Array.isArray(certPacks) ? certPacks : certPacks.result || []).filter((cert) => {
-				return (cert.hostnames || cert.hosts || []).some((host) => host.startsWith(`cf-tunnel-plugin-${currentTunnelName}--`));
-			});
-			debugLog(`Found ${currentTunnelCerts.length} SSL certificates for current tunnel: ${currentTunnelName}`);
-			const mismatchedCerts = currentTunnelCerts.filter((cert) => {
-				return !(cert.hostnames || cert.hosts || []).some((host) => {
-					if (host.startsWith("cf-tunnel-plugin-")) return false;
-					return host === currentHostname || host.startsWith("*.") && currentHostname.endsWith(host.slice(1));
-				});
-			});
-			debugLog(`Found ${mismatchedCerts.length} mismatched SSL certificates`, mismatchedCerts.map((c) => ({
-				id: c.id,
-				hosts: c.hostnames || c.hosts,
-				currentHostname
-			})));
-			return mismatchedCerts;
-		} catch (error) {
-			console.error(`[unplugin-cloudflare-tunnel] ❌ SSL certificate listing failed: ${error.message}`);
-			return [];
-		}
-	};
-	const cleanupMismatchedDnsRecords = async (apiToken, zoneId, dnsComment, currentHostname, tunnelId) => {
-		try {
-			const pluginDnsRecords = await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?comment=${dnsComment}&match=all`, void 0, array(DNSRecordSchema));
-			debugLog(`Found ${pluginDnsRecords.length} DNS records for current tunnel: ${dnsComment}`);
-			const expectedCnameContent = `${tunnelId}.cfargotunnel.com`;
-			const mismatchedRecords = pluginDnsRecords.filter((record) => {
-				if (record.name === currentHostname && record.content === expectedCnameContent) return false;
-				if (dnsOption && record.name === dnsOption && record.content === expectedCnameContent) return false;
-				return true;
-			});
-			debugLog(`Found ${mismatchedRecords.length} mismatched DNS records`, mismatchedRecords.map((r) => ({
-				name: r.name,
-				content: r.content,
-				expected: expectedCnameContent,
-				comment: r.comment
-			})));
-			const deletedRecords = [];
-			if (mismatchedRecords.length > 0) {
-				console.log(`[unplugin-cloudflare-tunnel] 🧹 Cleaning up ${mismatchedRecords.length} mismatched DNS records from tunnel '${dnsComment}'...`);
-				for (const record of mismatchedRecords) try {
-					await cf(apiToken, "DELETE", `/zones/${zoneId}/dns_records/${record.id}`);
-					deletedRecords.push(record);
-					console.log(`[unplugin-cloudflare-tunnel] ✅ Deleted mismatched DNS record: ${record.name} → ${record.content}`);
-				} catch (error) {
-					console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to delete DNS record ${record.name}: ${error.message}`);
-				}
-			}
-			return {
-				found: mismatchedRecords,
-				deleted: deletedRecords
-			};
-		} catch (error) {
-			console.error(`[unplugin-cloudflare-tunnel] ❌ DNS cleanup failed: ${error.message}`);
-			return {
-				found: [],
-				deleted: []
-			};
-		}
-	};
-	const cf = async (apiToken, method, url, body, resultSchema) => {
-		try {
-			debugLog("→ CF API", method, url, body ? { body } : "");
-			const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
-				method,
-				headers: {
-					Authorization: `Bearer ${apiToken}`,
-					"Content-Type": "application/json",
-					"User-Agent": "unplugin-cloudflare-tunnel/1.0.0"
-				},
-				...body ? { body: JSON.stringify(body) } : {}
-			});
-			if (!response.ok) {
-				const errorText = await response.text().catch(() => "Unknown error");
-				throw new Error(`[unplugin-cloudflare-tunnel] API request failed: ${response.status} ${response.statusText}. Response: ${errorText}`);
-			}
-			const rawData = await response.json();
-			debugLog("← CF API response", rawData);
-			const apiResponse = CloudflareApiResponseSchema.parse(rawData);
-			if (!apiResponse.success) {
-				const errorMsg = apiResponse.errors?.map((e) => e.message || `Error ${e.code}`).join(", ") || "Unknown API error";
-				throw new Error(`[unplugin-cloudflare-tunnel] Cloudflare API error: ${errorMsg}`);
-			}
-			if (resultSchema) {
-				const parsed = resultSchema.parse(apiResponse.result);
-				debugLog("← Parsed result", parsed);
-				return parsed;
-			}
-			debugLog("← Result (untyped)", apiResponse.result);
-			return apiResponse.result;
-		} catch (error) {
-			if (error instanceof Error) {
-				if (error.message.includes("[unplugin-cloudflare-tunnel]")) throw error;
-				throw new Error(`[unplugin-cloudflare-tunnel] API request failed: ${error.message}`);
-			}
-			throw new Error("[unplugin-cloudflare-tunnel] Unknown API error occurred");
-		}
-	};
-	const retryWithBackoff = async (fn, maxRetries = 5, initialDelayMs = 1e3) => {
-		let attempt = 0;
-		while (true) try {
-			return await fn();
-		} catch (error) {
-			attempt += 1;
-			const message = error instanceof Error ? error.message : String(error);
-			if (attempt > maxRetries) {
-				console.error(`[unplugin-cloudflare-tunnel] ❌ Edge certificate request failed after ${maxRetries} retries: ${message}`);
-				throw error;
-			}
-			const delay = initialDelayMs * 2 ** (attempt - 1);
-			console.error(`[unplugin-cloudflare-tunnel] ⚠️  Edge certificate request failed (attempt ${attempt}/${maxRetries}): ${message}`);
-			console.error(`[unplugin-cloudflare-tunnel] ⏳ Retrying in ${delay}ms...`);
-			await new Promise((resolve) => setTimeout(resolve, delay));
-		}
-	};
-	const spawnQuickTunnel = async (localTarget, protocol) => {
-		const cloudflaredArgs = ["tunnel"];
-		cloudflaredArgs.push("--loglevel", "info");
-		if (logFile) cloudflaredArgs.push("--logfile", logFile);
-		cloudflaredArgs.push("--protocol", protocol);
-		cloudflaredArgs.push("--url", localTarget);
-		debugLog("Spawning quick tunnel:", bin, cloudflaredArgs);
-		const child = NodeChildProcess.spawn(bin, cloudflaredArgs, {
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			detached: false,
-			windowsHide: true,
-			shell: process.platform === "win32"
-		});
-		debugLog(`[unplugin-cloudflare-tunnel] Quick tunnel process spawned with PID: ${child.pid}`);
-		return new Promise((resolve, reject) => {
-			let urlFound = false;
-			let settled = false;
-			const rejectOnce = (error) => {
-				if (settled) return;
-				settled = true;
-				reject(error);
-			};
-			const resolveOnce = (result) => {
-				if (settled) return;
-				settled = true;
-				resolve(result);
-			};
-			const timeout = setTimeout(() => {
-				if (!urlFound) {
-					try {
-						child.kill("SIGTERM");
-					} catch {}
-					rejectOnce(/* @__PURE__ */ new Error("Quick tunnel URL not found in output within 30 seconds"));
-				}
-			}, 3e4);
-			child.stdout?.on("data", (data) => {
-				const output = data.toString();
-				if (!globalState.shuttingDown || debug) {
-					if (effectiveLogLevel === "debug" || effectiveLogLevel === "info") console.log(`[cloudflared stdout] ${output.trim()}`);
-					else for (const line of output.split("\n")) if (!INFO_LOG_REGEX.test(line)) console.log(`[cloudflared stdout] ${line.trim()}`);
-				}
-			});
-			child.stderr?.on("data", (data) => {
-				const error = data.toString().trim();
-				const urlMatch = error.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
-				if (urlMatch && !urlFound) {
-					urlFound = true;
-					clearTimeout(timeout);
-					resolveOnce({
-						child,
-						url: urlMatch[0]
-					});
-				}
-				if (error.includes("Failed to parse ICMP reply") || error.includes("unknow ip version 0")) {
-					if (logLevel === "debug") console.log(`[cloudflared debug] ${error}`);
-					return;
-				}
-				if (!globalState.shuttingDown || debug) {
-					if (effectiveLogLevel === "debug" || effectiveLogLevel === "info") console.error(`[cloudflared stderr] ${error}`);
-					else for (const line of error.split("\n")) if (!INFO_LOG_REGEX.test(line)) console.error(`[cloudflared stderr] ${line.trim()}`);
-				}
-			});
-			child.on("error", (error) => {
-				clearTimeout(timeout);
-				rejectOnce(/* @__PURE__ */ new Error(`Failed to start quick tunnel process: ${error.message}`));
-			});
-			child.on("exit", (code, signal) => {
-				clearTimeout(timeout);
-				if (!urlFound) rejectOnce(/* @__PURE__ */ new Error(`Quick tunnel process exited before URL was found (code: ${code}, signal: ${signal})`));
-			});
-		});
-	};
-	const killCloudflared = (signal = "SIGTERM") => {
-		if (!child || child.killed) return;
-		globalState.shuttingDown = true;
-		globalState.tunnelUrl = void 0;
-		try {
-			debugLog(`[unplugin-cloudflare-tunnel] Terminating cloudflared process (PID: ${child.pid}) with ${signal}...`);
-			if (!child.kill(signal) && process.platform === "win32") NodeChildProcess.exec(`taskkill /pid ${child.pid} /T /F`, () => {});
-			if (signal === "SIGTERM") setTimeout(() => {
-				if (child && !child.killed) {
-					debugLog("[unplugin-cloudflare-tunnel] Force killing cloudflared process...");
-					if (process.platform === "win32") NodeChildProcess.exec(`taskkill /pid ${child.pid} /T /F`, () => {});
-					else child.kill("SIGKILL");
-				}
-			}, 2e3);
-		} catch (error) {
-			debugLog(`[unplugin-cloudflare-tunnel] Note: Error killing cloudflared: ${error}`);
-		}
-	};
-	let exitHandlersRegistered = globalState.exitHandlersRegistered ?? false;
-	const registerExitHandler = () => {
-		if (exitHandlersRegistered) return;
-		exitHandlersRegistered = true;
-		globalState.exitHandlersRegistered = true;
-		const cleanup = () => killCloudflared("SIGTERM");
-		process.once("exit", cleanup);
-		process.once("beforeExit", cleanup);
-		[
-			"SIGINT",
-			"SIGTERM",
-			"SIGQUIT",
-			"SIGHUP"
-		].forEach((signal) => {
-			process.once(signal, () => {
-				killCloudflared(signal);
-				try {
-					process.kill(process.pid, signal);
-				} catch {
-					process.exit(0);
-				}
-			});
-		});
-		process.once("uncaughtException", (error) => {
-			console.error("[unplugin-cloudflare-tunnel] Uncaught exception, cleaning up cloudflared...", error);
-			killCloudflared("SIGTERM");
-		});
-		process.once("unhandledRejection", (reason) => {
-			console.error("[unplugin-cloudflare-tunnel] Unhandled rejection, cleaning up cloudflared...", reason);
-			killCloudflared("SIGTERM");
-		});
-	};
-	const configureServer = async (server) => {
-		const generateDnsComment = () => {
-			return `unplugin-cloudflare-tunnel:${tunnelName}`;
-		};
-		const registerListeningHandler = (handler) => {
-			const httpServer = server.httpServer;
-			if (!httpServer) return;
-			const invokeHandler = () => {
-				try {
-					const maybePromise = handler();
-					if (maybePromise && typeof maybePromise.then === "function") maybePromise.catch((error) => {
-						console.error(`[unplugin-cloudflare-tunnel] ❌ Dev server listening hook failed: ${error.message}`);
-					});
-				} catch (error) {
-					console.error(`[unplugin-cloudflare-tunnel] ❌ Dev server listening hook failed: ${error.message}`);
-				}
-			};
-			httpServer.on("listening", invokeHandler);
-			if (httpServer.listening) invokeHandler();
-		};
-		try {
-			const { host: serverHost, port: detectedPort } = normalizeAddress(server.httpServer?.address());
-			const configPortValue = server.config?.server?.port;
-			const resolvedConfigPort = typeof configPortValue === "string" ? Number.parseInt(configPortValue, 10) : configPortValue;
-			const port = userProvidedPort || detectedPort || (typeof resolvedConfigPort === "number" && !Number.isNaN(resolvedConfigPort) ? resolvedConfigPort : void 0) || 5173;
-			const newConfigHash = JSON.stringify({
-				isQuickMode,
-				hostname,
-				port,
-				tunnelName,
-				dnsOption,
-				sslOption
-			});
-			if (globalState.child && !globalState.child.killed && globalState.configHash === newConfigHash) {
-				tunnelUrl = await globalState.tunnelUrl ?? "";
-				debugLog("[unplugin-cloudflare-tunnel] Config unchanged – re-using existing tunnel");
-				globalState.shuttingDown = false;
-				registerExitHandler();
-				return;
-			}
-			if (globalState.child && !globalState.child.killed) {
-				debugLog("[unplugin-cloudflare-tunnel] Config changed – terminating previous tunnel...");
-				try {
-					globalState.child.kill("SIGTERM");
-				} catch (_) {}
-			}
-			delete globalState.child;
-			delete globalState.configHash;
-			globalState.shuttingDown = false;
-			if (isQuickMode) {
-				debugLog("[unplugin-cloudflare-tunnel] Starting quick tunnel mode...");
-				debugLog("Quick tunnel mode - no API token or hostname required");
-				await ensureCloudflaredBinary(bin);
-				const localTarget = getLocalTarget(serverHost, port);
-				debugLog("← Quick tunnel connecting to local target", localTarget);
-				try {
-					const { child: quickChild, url } = await spawnQuickTunnel(localTarget, protocol);
-					tunnelUrl = url;
-					child = quickChild;
-					globalState.child = child;
-					globalState.configHash = newConfigHash;
-					globalState.tunnelUrl = Promise.resolve(url);
-					registerExitHandler();
-					registerListeningHandler(() => {
-						const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
-						const actualLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
-						announceTunnel({
-							key: `quick:${url}:${actualPort ?? port}`,
-							url,
-							localTarget: actualLocalTarget
-						});
-					});
-					registerListeningHandler(async () => {
-						try {
-							const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
-							if (actualPort !== port) {
-								pluginLog.warn(`Port conflict detected - server is using port ${actualPort} instead of ${port}`);
-								pluginLog.info("Restarting quick tunnel for the new port...");
-								killCloudflared("SIGTERM");
-								await new Promise((resolve) => setTimeout(resolve, 1e3));
-								const newLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
-								const { child: newChild, url: newUrl } = await spawnQuickTunnel(newLocalTarget, protocol);
-								tunnelUrl = newUrl;
-								child = newChild;
-								globalState.child = child;
-								globalState.tunnelUrl = Promise.resolve(newUrl);
-								announceTunnel({
-									key: `quick:${newUrl}:${actualPort ?? port}`,
-									url: newUrl,
-									localTarget: newLocalTarget
-								});
-								globalState.configHash = JSON.stringify({
-									isQuickMode,
-									hostname,
-									port: actualPort,
-									tunnelName,
-									dnsOption,
-									sslOption
-								});
-							}
-						} catch (error) {
-							console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to update quick tunnel for port change: ${error.message}`);
-						}
-					});
-					server.httpServer?.once("close", () => {
-						killCloudflared("SIGTERM");
-					});
-					return;
-				} catch (error) {
-					console.error(`[unplugin-cloudflare-tunnel] ❌ Quick tunnel setup failed: ${error.message}`);
-					throw error;
-				}
-			}
-			debugLog("[unplugin-cloudflare-tunnel] Starting named tunnel mode...");
-			const apiToken = providedApiToken || process.env.CLOUDFLARE_API_TOKEN;
-			if (!apiToken) throw new Error("[unplugin-cloudflare-tunnel] API token is required. Provide it via 'apiToken' option or set the CLOUDFLARE_API_TOKEN environment variable. Get your token at: https://dash.cloudflare.com/profile/api-tokens");
-			debugLog(`[unplugin-cloudflare-tunnel] Using port ${port}${userProvidedPort === port ? " (user-provided)" : " (from bundler config)"}`);
-			await ensureCloudflaredBinary(bin);
-			const apexDomain = hostname.split(".").slice(-2).join(".");
-			const parentDomain = hostname.split(".").slice(1).join(".");
-			debugLog("← Apex domain", apexDomain);
-			debugLog("← Parent domain", parentDomain);
-			let resolvedZone;
-			let zoneId = forcedZone;
-			if (!zoneId) {
-				let zones = [];
-				try {
-					zones = await cf(apiToken, "GET", `/zones?name=${parentDomain}`, void 0, array(ZoneSchema));
-				} catch (error) {
-					debugLog("← Error fetching zone for parent domain", error);
-				}
-				if (zones.length === 0) zones = await cf(apiToken, "GET", `/zones?name=${apexDomain}`, void 0, array(ZoneSchema));
-				resolvedZone = zones[0];
-				zoneId = resolvedZone?.id;
-			}
-			let accountId = forcedAccount || resolvedZone?.account?.id;
-			if (!accountId) accountId = (await cf(apiToken, "GET", "/accounts", void 0, array(AccountSchema)))[0]?.id;
-			if (!accountId) throw new Error("Unable to determine Cloudflare account ID");
-			if (!zoneId) throw new Error(`Zone ${apexDomain} not found in account ${accountId}`);
-			const { autoCleanup = true } = cleanupConfig;
-			let tunnel = (await cf(apiToken, "GET", `/accounts/${accountId}/cfd_tunnel?name=${tunnelName}`, void 0, array(TunnelSchema)))[0];
-			if (!tunnel) {
-				pluginLog.info(`Creating tunnel '${tunnelName}'...`);
-				tunnel = await cf(apiToken, "POST", `/accounts/${accountId}/cfd_tunnel`, {
-					name: tunnelName,
-					config_src: "cloudflare"
-				}, TunnelSchema);
-			}
-			const tunnelId = tunnel.id;
-			if (autoCleanup) {
-				debugLog(`[unplugin-cloudflare-tunnel] Running resource cleanup for tunnel '${tunnelName}'...`);
-				const dnsCleanup = await cleanupMismatchedDnsRecords(apiToken, zoneId, generateDnsComment(), hostname, tunnelId);
-				if (dnsCleanup.found.length > 0) pluginLog.warn(`DNS cleanup: ${dnsCleanup.found.length} mismatched, ${dnsCleanup.deleted.length} deleted`);
-				const mismatchedSslCerts = await findMismatchedSslCertificates(apiToken, zoneId, tunnelName, hostname);
-				if (mismatchedSslCerts.length > 0) {
-					for (const cert of mismatchedSslCerts) await cf(apiToken, "DELETE", `/zones/${zoneId}/ssl/certificate_packs/${cert.id}`);
-					pluginLog.warn(`SSL cleanup: ${mismatchedSslCerts.length} deleted`);
-				}
-			} else debugLog("← Cleanup skipped", cleanupConfig);
-			const localTarget = getLocalTarget(serverHost, port);
-			debugLog("← Connecting to local target", localTarget);
-			await cf(apiToken, "PUT", `/accounts/${accountId}/cfd_tunnel/${tunnelId}/configurations`, { config: { ingress: [{
-				hostname,
-				service: localTarget
-			}, { service: "http_status:404" }] } });
-			const generateSslTagHostname = () => {
-				return `cf-tunnel-plugin-${tunnelName}--${parentDomain}`;
-			};
-			if (dnsOption) {
-				const ensureDnsRecord = async (type, content) => {
-					if ((await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=${type}&name=${encodeURIComponent(dnsOption)}`, void 0, array(DNSRecordSchema))).length === 0) {
-						console.log(`[unplugin-cloudflare-tunnel] Creating ${type} record for ${dnsOption}...`);
-						await cf(apiToken, "POST", `/zones/${zoneId}/dns_records`, {
-							type,
-							name: dnsOption,
-							content,
-							proxied: true,
-							comment: generateDnsComment()
-						}, DNSRecordSchema);
-					}
-				};
-				await ensureDnsRecord("CNAME", `${tunnelId}.cfargotunnel.com`);
-			} else {
-				const wildcardDns = `*.${parentDomain}`;
-				if ((await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=CNAME&name=${wildcardDns}`, void 0, array(DNSRecordSchema))).length === 0) {
-					const existingRecord = (await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=CNAME&name=${hostname}`, void 0, array(DNSRecordSchema)))[0];
-					const expectedContent = `${tunnelId}.cfargotunnel.com`;
-					if (!existingRecord) {
-						console.log(`[unplugin-cloudflare-tunnel] Creating DNS record for ${hostname}...`);
-						await cf(apiToken, "POST", `/zones/${zoneId}/dns_records`, {
-							type: "CNAME",
-							name: hostname,
-							content: expectedContent,
-							proxied: true,
-							comment: generateDnsComment()
-						}, DNSRecordSchema);
-					} else if (existingRecord.content !== expectedContent) {
-						debugLog(`← DNS record for ${hostname} points to different tunnel, updating...`);
-						pluginLog.info(`Updating DNS record for ${hostname} to point to tunnel '${tunnelName}'...`);
-						await cf(apiToken, "PUT", `/zones/${zoneId}/dns_records/${existingRecord.id}`, {
-							type: "CNAME",
-							name: hostname,
-							content: expectedContent,
-							proxied: true,
-							comment: generateDnsComment()
-						}, DNSRecordSchema);
-					}
-				}
-			}
-			const token = await cf(apiToken, "GET", `/accounts/${accountId}/cfd_tunnel/${tunnelId}/token`, void 0, string());
-			try {
-				const certListRaw = await cf(apiToken, "GET", `/zones/${zoneId}/ssl/certificate_packs?status=all`, void 0, any());
-				const certPacks = Array.isArray(certListRaw) ? certListRaw : certListRaw.result || [];
-				const certContainingHost = (host) => certPacks.filter((c) => (c.hostnames || c.hosts || []).includes(host))?.[0];
-				if (sslOption) {
-					const isWildcard = sslOption.startsWith("*.");
-					const certNeededHost = sslOption;
-					const matchingCert = certContainingHost(certNeededHost);
-					if (!matchingCert) {
-						console.log(`[unplugin-cloudflare-tunnel] Requesting ${isWildcard ? "wildcard " : ""}certificate for ${certNeededHost}...`);
-						const tagHostname = generateSslTagHostname();
-						const certificateHosts = [certNeededHost, tagHostname];
-						debugLog(`Adding tag hostname to certificate: ${tagHostname}`);
-						const newCert = await retryWithBackoff(() => cf(apiToken, "POST", `/zones/${zoneId}/ssl/certificate_packs/order`, {
-							hosts: certificateHosts,
-							certificate_authority: "lets_encrypt",
-							type: "advanced",
-							validation_method: isWildcard ? "txt" : "http",
-							validity_days: 90,
-							cloudflare_branding: false
-						}));
-						if (newCert?.id) trackSslCertificate(newCert.id, certificateHosts, tunnelName);
-					} else debugLog("← Edge certificate already exists", matchingCert);
-				} else {
-					const wildcardDomain = `*.${parentDomain}`;
-					const wildcardExists = certContainingHost(wildcardDomain);
-					if (!wildcardExists) {
-						const totalTls = await cf(apiToken, "GET", `/zones/${zoneId}/acm/total_tls`, void 0, object({ status: string() }));
-						debugLog("← Total TLS", totalTls);
-						const existingHostnameCert = certContainingHost(hostname);
-						if (totalTls.status !== "on" && !existingHostnameCert) {
-							pluginLog.info(`Requesting edge certificate for ${hostname}...`);
-							const tagHostname = generateSslTagHostname();
-							const certificateHosts = [hostname, tagHostname];
-							debugLog(`Adding tag hostname to certificate: ${tagHostname}`);
-							const newCert = await retryWithBackoff(() => cf(apiToken, "POST", `/zones/${zoneId}/ssl/certificate_packs/order`, {
-								hosts: certificateHosts,
-								certificate_authority: "lets_encrypt",
-								type: "advanced",
-								validation_method: "txt",
-								validity_days: 90,
-								cloudflare_branding: false
-							}));
-							if (newCert?.id) trackSslCertificate(newCert.id, certificateHosts, tunnelName);
-						} else debugLog("← Edge certificate already exists", existingHostnameCert);
-					} else debugLog("← Edge certificate (wildcard) already exists", wildcardExists, wildcardDomain);
-				}
-			} catch (sslError) {
-				console.error(`[unplugin-cloudflare-tunnel] ⚠️  SSL management error: ${sslError.message}`);
-				throw sslError;
-			}
-			let tunnelReady = false;
-			let localTargetForAnnouncement = localTarget;
-			let activeTunnelProtocol;
-			const announceNamedTunnelIfReady = () => {
-				if (!tunnelReady) return;
-				announceTunnel({
-					key: `named:${hostname}:${localTargetForAnnouncement}`,
-					url: `https://${hostname}`,
-					localTarget: localTargetForAnnouncement
-				});
-			};
-			const logCloudflaredLines = (kind, text) => {
-				if (globalState.shuttingDown && !debug) return;
-				const isVerbose = effectiveLogLevel === "debug" || effectiveLogLevel === "info";
-				const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
-				if (isVerbose) {
-					for (const line of lines) {
-						const prefix = kind === "stdout" ? "[cloudflared stdout]" : "[cloudflared stderr]";
-						if (kind === "stdout") console.log(`${prefix} ${line}`);
-						else console.error(`${prefix} ${line}`);
-					}
-					return;
-				}
-				for (const line of lines) {
-					if (INFO_LOG_REGEX.test(line)) continue;
-					const prefix = kind === "stdout" ? "[cloudflared stdout]" : "[cloudflared stderr]";
-					if (kind === "stdout") console.log(`${prefix} ${line}`);
-					else console.error(`${prefix} ${line}`);
-				}
-			};
-			const spawnNamedTunnelProcess = (protocol) => {
-				const cloudflaredArgs = ["tunnel"];
-				cloudflaredArgs.push("--loglevel", cloudflaredProcessLogLevel);
-				if (logFile) cloudflaredArgs.push("--logfile", logFile);
-				cloudflaredArgs.push("--protocol", protocol);
-				debugLog("Spawning cloudflared", bin, cloudflaredArgs);
-				const spawnedChild = NodeChildProcess.spawn(bin, [
-					...cloudflaredArgs,
-					"run",
-					"--token",
-					token
-				], {
-					stdio: [
-						"ignore",
-						"pipe",
-						"pipe"
-					],
-					detached: false,
-					windowsHide: true,
-					shell: process.platform === "win32"
-				});
-				child = spawnedChild;
-				globalState.child = spawnedChild;
-				globalState.configHash = newConfigHash;
-				debugLog(`[unplugin-cloudflare-tunnel] Process spawned with PID: ${spawnedChild.pid}`);
-				const handleCloudflaredOutput = (kind, text) => {
-					if (text.includes("Failed to parse ICMP reply") || text.includes("unknow ip version 0")) {
-						if (logLevel === "debug") console.log(`[cloudflared debug] ${text.trim()}`);
-						return;
-					}
-					logCloudflaredLines(kind, text);
-					if (/registered tunnel connection|connection.*registered/i.test(text)) {
-						activeTunnelProtocol = protocol;
-						if (!tunnelReady) {
-							tunnelReady = true;
-							pluginLog.info(`Tunnel connected for https://${hostname} via ${protocol.toUpperCase()}`);
-						}
-						announceNamedTunnelIfReady();
-					}
-				};
-				spawnedChild.stdout?.on("data", (data) => {
-					handleCloudflaredOutput("stdout", data.toString());
-				});
-				spawnedChild.stderr?.on("data", (data) => {
-					handleCloudflaredOutput("stderr", data.toString());
-				});
-				spawnedChild.on("error", (error) => {
-					console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to start tunnel process: ${error.message}`);
-					if (error.message.includes("ENOENT")) console.error(`[unplugin-cloudflare-tunnel] Hint: cloudflared binary may not be installed correctly`);
-				});
-				spawnedChild.on("exit", (code, signal) => {
-					if (globalState.child !== spawnedChild) return;
-					if (code !== 0 && code !== null) {
-						console.error(`[unplugin-cloudflare-tunnel] ❌ Tunnel process exited with code ${code}`);
-						if (signal) console.error(`[unplugin-cloudflare-tunnel] Process terminated by signal: ${signal}`);
-					} else if (code === 0) console.log(`[unplugin-cloudflare-tunnel] ✅ Tunnel process exited cleanly`);
-				});
-			};
-			spawnNamedTunnelProcess(protocol);
-			registerExitHandler();
-			registerListeningHandler(() => {
-				const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
-				localTargetForAnnouncement = getLocalTarget(actualServerHost, actualPort ?? port);
-				announceNamedTunnelIfReady();
-			});
-			server.httpServer?.once("close", () => {
-				killCloudflared("SIGTERM");
-			});
-			registerListeningHandler(async () => {
-				try {
-					const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
-					if (actualPort !== port) {
-						pluginLog.warn(`Port conflict detected - server is using port ${actualPort} instead of ${port}`);
-						pluginLog.info("Updating tunnel configuration...");
-						const newLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
-						localTargetForAnnouncement = newLocalTarget;
-						debugLog("← Updating local target to", newLocalTarget);
-						await cf(apiToken, "PUT", `/accounts/${accountId}/cfd_tunnel/${tunnelId}/configurations`, { config: { ingress: [{
-							hostname,
-							service: newLocalTarget
-						}, { service: "http_status:404" }] } });
-						pluginLog.info(`Tunnel configuration updated to use port ${actualPort}`);
-						globalState.configHash = JSON.stringify({
-							hostname,
-							port: actualPort,
-							tunnelName,
-							dnsOption,
-							sslOption
-						});
-						if (tunnelReady && activeTunnelProtocol) pluginLog.info(`Tunnel remains connected via ${activeTunnelProtocol.toUpperCase()} after port update`);
-						announceNamedTunnelIfReady();
-					}
-				} catch (error) {
-					console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to update tunnel for port change: ${error.message}`);
-				}
-			});
-		} catch (error) {
-			if (error instanceof Error) {
-				console.error(`[unplugin-cloudflare-tunnel] ❌ Setup failed: ${error.message}`);
-				if (error.message.includes("API token")) {
-					console.error(`[unplugin-cloudflare-tunnel] 💡 Check your API token at: https://dash.cloudflare.com/profile/api-tokens`);
-					console.error(`[unplugin-cloudflare-tunnel] 💡 Required permissions: Zone:Zone:Read, Zone:DNS:Edit, Account:Cloudflare Tunnel:Edit`);
-				} else if (error.message.includes("Zone") && error.message.includes("not found")) console.error(`[unplugin-cloudflare-tunnel] 💡 Make sure '${hostname}' domain is added to your Cloudflare account`);
-				else if (error.message.includes("cloudflared")) console.error(`[unplugin-cloudflare-tunnel] 💡 Try deleting node_modules and reinstalling to get a fresh cloudflared binary`);
-			}
-			throw error;
-		}
-	};
-	const ensureWebpackAllowedHosts = (devServerOptions, bundler) => {
-		if (!devServerOptions) return;
-		const hostToAllow = isQuickMode ? ".trycloudflare.com" : hostname;
-		if (!hostToAllow) return;
-		const label = bundler === "webpack" ? "Webpack" : "Rspack";
-		const normalizeArray = (values) => {
-			const unique = Array.from(new Set(values.filter(Boolean)));
-			devServerOptions.allowedHosts = unique;
-			return unique;
-		};
-		let modified = false;
-		const current = devServerOptions.allowedHosts;
-		if (current === "all") return;
-		if (typeof current === "undefined" || current === "auto") {
-			normalizeArray(["localhost", hostToAllow]);
-			modified = true;
-		} else if (typeof current === "string") {
-			if (current !== hostToAllow) {
-				normalizeArray([current, hostToAllow]);
-				modified = true;
-			}
-		} else if (Array.isArray(current)) {
-			if (!current.includes(hostToAllow)) {
-				current.push(hostToAllow);
-				modified = true;
-			}
-		}
-		if (modified) debugLog(`[unplugin-cloudflare-tunnel] Configured ${label} devServer.allowedHosts to include ${hostToAllow}`);
-	};
-	const ensureViteAllowedHosts = (serverConfig) => {
-		const hostToAllow = isQuickMode ? ".trycloudflare.com" : hostname;
-		if (!hostToAllow) return;
-		const current = serverConfig.allowedHosts;
-		if (current === true) return;
-		if (typeof current === "undefined") serverConfig.allowedHosts = [hostToAllow];
-		else if (typeof current === "string") {
-			if (current !== hostToAllow) serverConfig.allowedHosts = [current, hostToAllow];
-		} else if (Array.isArray(current)) {
-			if (!current.includes(hostToAllow)) current.push(hostToAllow);
-		}
-	};
-	const setupWebpackLikeDevServerIntegration = (compiler, bundler) => {
-		if ((compiler?.options?.mode ?? process.env.NODE_ENV) === "production") return;
-		const optionsContainer = compiler.options;
-		if (!optionsContainer.devServer) optionsContainer.devServer = {};
-		const devServerOptions = optionsContainer.devServer;
-		ensureWebpackAllowedHosts(devServerOptions, bundler);
-		let lastHttpServer;
-		let missingServerWarned = false;
-		const runConfiguration = (devServerInstance) => {
-			if (!devServerInstance) {
-				if (!missingServerWarned) {
-					console.warn(`[unplugin-cloudflare-tunnel] ${bundler} dev server instance unavailable; skipping tunnel setup`);
-					missingServerWarned = true;
-				}
-				return;
-			}
-			const httpServer = [
-				devServerInstance.server,
-				devServerInstance.httpServer,
-				devServerInstance.listeningApp,
-				devServerInstance.server?.server
-			].find((candidate) => candidate);
-			if (!httpServer) {
-				if (!missingServerWarned) {
-					console.warn(`[unplugin-cloudflare-tunnel] Unable to locate HTTP server from ${bundler} dev server; tunnel will not start`);
-					missingServerWarned = true;
-				}
-				return;
-			}
-			if (lastHttpServer === httpServer) return;
-			lastHttpServer = httpServer;
-			httpServer.once("close", () => {
-				if (lastHttpServer === httpServer) lastHttpServer = void 0;
-			});
-			const configuredPromise = configureServer({
-				httpServer,
-				config: { server: { port: devServerInstance.options?.port ?? devServerOptions?.port } }
-			});
-			globalState.tunnelUrl = configuredPromise.then(() => tunnelUrl).catch(() => "");
-			configuredPromise.catch(() => {});
-		};
-		const scheduleConfiguration = (devServerInstance) => {
-			const httpServer = devServerInstance?.server || devServerInstance?.httpServer || devServerInstance?.listeningApp;
-			if (httpServer && typeof httpServer.once === "function") if (httpServer.listening) runConfiguration(devServerInstance);
-			else httpServer.once("listening", () => runConfiguration(devServerInstance));
-			else runConfiguration(devServerInstance);
-		};
-		const originalSetupMiddlewares = devServerOptions.setupMiddlewares;
-		devServerOptions.setupMiddlewares = function(middlewares, devServer) {
-			scheduleConfiguration(devServer);
-			if (typeof originalSetupMiddlewares === "function") return originalSetupMiddlewares.call(this, middlewares, devServer);
-			return middlewares;
-		};
-		const originalOnListening = devServerOptions.onListening;
-		devServerOptions.onListening = function(devServer) {
-			scheduleConfiguration(devServer);
-			if (typeof originalOnListening === "function") return originalOnListening.call(this, devServer);
-		};
-	};
-	return {
-		name: PLUGIN_NAME,
-		enforce: "pre",
-		resolveId(id) {
-			if (id === VIRTUAL_MODULE_ID) {
-				debugLog("resolveId called for", id);
-				return id;
-			}
-		},
-		loadInclude(id) {
-			return id === VIRTUAL_MODULE_ID;
-		},
-		async load(id) {
-			if (id === VIRTUAL_MODULE_ID) {
-				const url = await globalState.tunnelUrl;
-				return `export function getTunnelUrl() { return ${JSON.stringify(url || "")}; }`;
-			}
-		},
-		vite: {
-			config: (config) => {
-				announceConnecting();
-				if (!config.server) config.server = {};
-				ensureViteAllowedHosts(config.server);
-				if (!isQuickMode) debugLog(`[unplugin-cloudflare-tunnel] Configured Vite to allow requests from ${hostname}`);
-			},
-			configureServer: (server) => {
-				const configuredPromise = configureServer(server);
-				globalState.tunnelUrl = configuredPromise.then(() => tunnelUrl).catch(() => "");
-				return async () => {
-					await configuredPromise;
-				};
-			}
-		},
-		rspack: (compiler) => {
-			setupWebpackLikeDevServerIntegration(compiler, "rspack");
-		},
-		webpack: (compiler) => {
-			setupWebpackLikeDevServerIntegration(compiler, "webpack");
-		},
-		closeBundle() {
-			killCloudflared("SIGTERM");
-			delete globalState.child;
-			delete globalState.configHash;
-			delete globalState.shuttingDown;
-		}
-	};
-};
-function normalizeAddress(address) {
-	if (address && typeof address === "object") return {
-		host: "address" in address && address.address ? address.address : "localhost",
-		port: "port" in address && typeof address.port === "number" ? address.port : void 0
-	};
-	return { host: "localhost" };
-}
-async function ensureCloudflaredBinary(binPath) {
-	try {
-		await NodeFS.access(binPath);
-	} catch {
-		console.log("[unplugin-cloudflare-tunnel] Installing cloudflared binary...");
-		await install(binPath);
-	}
-}
-function getLocalTarget(host, port) {
-	return `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
-}
-const CloudflareTunnel = createUnplugin(unpluginFactory);
-//#endregion
+import { t as CloudflareTunnel } from "./src-D0eR3kCb.mjs";
 export { CloudflareTunnel, CloudflareTunnel as default };