unplugin-cloudflare-tunnel 0.0.0-alpha-1 → 0.0.2

package/dist/{src-BC4MyCER.js → index.mjs}

@@ -1,56 +1,104 @@
-import { bin, install } from "cloudflared";
-import fs from "node:fs/promises";
-import { exec, spawn } from "node:child_process";
-import { z } from "zod";
+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-CwcXCIyR.mjs";
 import { createUnplugin } from "unplugin";
+import NodeFS from "node:fs/promises";
+import { bin, install } from "cloudflared";
+import * as NodeChildProcess from "node:child_process";
 
 //#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 CloudflareErrorSchema = z.object({
-	code: z.number(),
-	message: z.string()
+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_ESCAPE = String.fromCharCode(27);
+const ANSI_STYLE_SEQUENCE_REGEX = new RegExp(`${ANSI_ESCAPE}\\[[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 = z.object({
-	success: z.boolean(),
-	errors: z.array(CloudflareErrorSchema).optional(),
-	messages: z.array(z.string()).optional(),
-	result: z.unknown()
+const CloudflareApiResponseSchema = object({
+	success: boolean(),
+	errors: optional(array(CloudflareErrorSchema)),
+	messages: optional(array(string())),
+	result: unknown()
 });
-const AccountSchema = z.object({
-	id: z.string(),
-	name: z.string()
+const AccountSchema = object({
+	id: string(),
+	name: string()
 });
-const ZoneSchema = z.object({
-	id: z.string(),
-	name: z.string()
+const ZoneSchema = object({
+	id: string(),
+	name: string()
 });
-const TunnelSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	account_tag: z.string(),
-	created_at: z.string(),
-	connections: z.array(z.unknown()).optional()
+const TunnelSchema = object({
+	id: string(),
+	name: string(),
+	account_tag: string(),
+	created_at: string(),
+	connections: optional(array(unknown()))
 });
-const DNSRecordSchema = z.object({
-	id: z.string(),
-	type: z.string(),
-	name: z.string(),
-	content: z.string(),
-	proxied: z.boolean(),
-	comment: z.string().nullish()
+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: "unplugin-cloudflare-tunnel",
+			name: PLUGIN_NAME,
 			enforce: "pre",
 			resolveId(id) {
-				if (id === VIRTUAL_MODULE_ID_STUB) return "\0" + VIRTUAL_MODULE_ID_STUB;
+				if (id === VIRTUAL_MODULE_ID_STUB) return id;
+			},
+			loadInclude(id) {
+				return id === VIRTUAL_MODULE_ID_STUB;
 			},
 			load(id) {
-				if (id === "\0" + VIRTUAL_MODULE_ID_STUB) return "export function getTunnelUrl() { return \"\"; }";
+				if (id === VIRTUAL_MODULE_ID_STUB) return "export function getTunnelUrl() { return \"\"; }";
 			}
 		};
 	}
@@ -95,8 +143,79 @@ const unpluginFactory = (options = {}) => {
 		cleanupConfig = namedOptions.cleanup || {};
 	}
 	const { port: userProvidedPort, logFile, logLevel, debug = false } = options;
-	const debugLog = (...args) => {
-		if (debug) console.log("[cloudflare-tunnel:debug]", ...args);
+	const effectivePluginLogLevel = logLevel ?? (debug ? "debug" : "info");
+	const pluginLog = {
+		debug: (...args) => {
+			if (debug || effectivePluginLogLevel === "debug") console.log("[cloudflare-tunnel:debug]", ...args);
+		},
+		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 headerText = "unplugin-cloudflare-tunnel";
+		const header = (() => {
+			return `${colorize("[", ANSI.yellow)}${headerText}${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$1 = [];
+			out$1.push("");
+			out$1.push(`${header} ${colorize("Tunnel URL", ANSI.bold)} ${urlLine}`);
+			if (localLine) out$1.push(`${header} ${colorize("Local", ANSI.dim + ANSI.bold)} ${localLine}`);
+			out$1.push("");
+			console.log(out$1.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));
+		out.push(center(urlLine));
+		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}` : "";
@@ -130,7 +249,7 @@ const unpluginFactory = (options = {}) => {
 	};
 	const findMismatchedSslCertificates = async (apiToken, zoneId, currentTunnelName, currentHostname) => {
 		try {
-			const certPacks = await cf(apiToken, "GET", `/zones/${zoneId}/ssl/certificate_packs?status=all`, void 0, z.any());
+			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}--`));
 			});
@@ -154,7 +273,7 @@ const unpluginFactory = (options = {}) => {
 	};
 	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, z.array(DNSRecordSchema));
+			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) => {
@@ -252,7 +371,7 @@ const unpluginFactory = (options = {}) => {
 		if (logFile) cloudflaredArgs.push("--logfile", logFile);
 		cloudflaredArgs.push("--url", localTarget);
 		debugLog("Spawning quick tunnel:", bin, cloudflaredArgs);
-		const child$1 = spawn(bin, cloudflaredArgs, {
+		const child$1 = NodeChildProcess.spawn(bin, cloudflaredArgs, {
 			stdio: [
 				"ignore",
 				"pipe",
@@ -262,7 +381,7 @@ const unpluginFactory = (options = {}) => {
 			windowsHide: true,
 			shell: process.platform === "win32"
 		});
-		console.log(`[unplugin-cloudflare-tunnel] Quick tunnel process spawned with PID: ${child$1.pid}`);
+		debugLog(`[unplugin-cloudflare-tunnel] Quick tunnel process spawned with PID: ${child$1.pid}`);
 		return new Promise((resolve, reject) => {
 			let urlFound = false;
 			const timeout = setTimeout(() => {
@@ -310,17 +429,17 @@ const unpluginFactory = (options = {}) => {
 		globalState.shuttingDown = true;
 		globalState.tunnelUrl = void 0;
 		try {
-			console.log(`[unplugin-cloudflare-tunnel] 🛑 Terminating cloudflared process (PID: ${child.pid}) with ${signal}...`);
-			if (!child.kill(signal) && process.platform === "win32") exec(`taskkill /pid ${child.pid} /T /F`, () => {});
+			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) {
-					console.log("[unplugin-cloudflare-tunnel] 🛑 Force killing cloudflared process...");
-					if (process.platform === "win32") exec(`taskkill /pid ${child.pid} /T /F`, () => {});
+					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) {
-			console.log(`[unplugin-cloudflare-tunnel] Note: Error killing cloudflared: ${error}`);
+			debugLog(`[unplugin-cloudflare-tunnel] Note: Error killing cloudflared: ${error}`);
 		}
 	};
 	let exitHandlersRegistered = globalState.exitHandlersRegistered ?? false;
@@ -359,9 +478,27 @@ const unpluginFactory = (options = {}) => {
 		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 port = userProvidedPort || detectedPort || server.config.server.port || 5173;
+			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,
@@ -372,13 +509,13 @@ const unpluginFactory = (options = {}) => {
 			});
 			if (globalState.child && !globalState.child.killed && globalState.configHash === newConfigHash) {
 				tunnelUrl = await globalState.tunnelUrl ?? "";
-				console.log("[unplugin-cloudflare-tunnel] Config unchanged – re-using existing tunnel");
+				debugLog("[unplugin-cloudflare-tunnel] Config unchanged – re-using existing tunnel");
 				globalState.shuttingDown = false;
 				registerExitHandler();
 				return;
 			}
 			if (globalState.child && !globalState.child.killed) {
-				console.log("[unplugin-cloudflare-tunnel] Config changed – terminating previous tunnel...");
+				debugLog("[unplugin-cloudflare-tunnel] Config changed – terminating previous tunnel...");
 				try {
 					globalState.child.kill("SIGTERM");
 				} catch (_) {}
@@ -387,7 +524,7 @@ const unpluginFactory = (options = {}) => {
 			delete globalState.configHash;
 			globalState.shuttingDown = false;
 			if (isQuickMode) {
-				console.log("[unplugin-cloudflare-tunnel] Starting quick tunnel mode...");
+				debugLog("[unplugin-cloudflare-tunnel] Starting quick tunnel mode...");
 				debugLog("Quick tunnel mode - no API token or hostname required");
 				await ensureCloudflaredBinary(bin);
 				const localTarget$1 = getLocalTarget(serverHost, port);
@@ -399,20 +536,33 @@ const unpluginFactory = (options = {}) => {
 					globalState.child = child;
 					globalState.configHash = newConfigHash;
 					registerExitHandler();
-					console.log(`🌐  Quick tunnel ready at: ${url}`);
-					server.httpServer?.on("listening", async () => {
+					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) {
-								console.log(`[unplugin-cloudflare-tunnel] ⚠️  Port conflict detected - server is using port ${actualPort} instead of ${port}`);
-								console.log(`[unplugin-cloudflare-tunnel] 🔄 Quick tunnel needs to be restarted for new 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 { child: newChild, url: newUrl } = await spawnQuickTunnel(getLocalTarget(actualServerHost, actualPort ?? port));
+								const newLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
+								const { child: newChild, url: newUrl } = await spawnQuickTunnel(newLocalTarget);
 								tunnelUrl = newUrl;
 								child = newChild;
 								globalState.child = child;
-								console.log(`🌐  Quick tunnel updated for port ${actualPort}: ${newUrl}`);
+								announceTunnel({
+									key: `quick:${newUrl}:${actualPort ?? port}`,
+									url: newUrl,
+									localTarget: newLocalTarget
+								});
 								globalState.configHash = JSON.stringify({
 									isQuickMode,
 									hostname,
@@ -435,12 +585,12 @@ const unpluginFactory = (options = {}) => {
 					throw error;
 				}
 			}
-			console.log("[unplugin-cloudflare-tunnel] Starting named tunnel mode...");
+			debugLog("[unplugin-cloudflare-tunnel] Starting named tunnel mode...");
 			const apiToken = providedApiToken || process.env.CLOUDFLARE_API_KEY;
 			if (!apiToken) throw new Error("[unplugin-cloudflare-tunnel] API token is required. Provide it via 'apiToken' option or set the CLOUDFLARE_API_KEY environment variable. Get your token at: https://dash.cloudflare.com/profile/api-tokens");
-			console.log(`[unplugin-cloudflare-tunnel] Using port ${port}${userProvidedPort === port ? " (user-provided)" : " (from bundler config)"}`);
+			debugLog(`[unplugin-cloudflare-tunnel] Using port ${port}${userProvidedPort === port ? " (user-provided)" : " (from bundler config)"}`);
 			await ensureCloudflaredBinary(bin);
-			const accounts = await cf(apiToken, "GET", "/accounts", void 0, z.array(AccountSchema));
+			const accounts = await cf(apiToken, "GET", "/accounts", void 0, array(AccountSchema));
 			const accountId = forcedAccount || accounts[0]?.id;
 			if (!accountId) throw new Error("Unable to determine Cloudflare account ID");
 			const apexDomain = hostname.split(".").slice(-2).join(".");
@@ -451,18 +601,18 @@ const unpluginFactory = (options = {}) => {
 			if (!zoneId) {
 				let zones = [];
 				try {
-					zones = await cf(apiToken, "GET", `/zones?name=${parentDomain}`, void 0, z.array(ZoneSchema));
+					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, z.array(ZoneSchema));
+				if (zones.length === 0) zones = await cf(apiToken, "GET", `/zones?name=${apexDomain}`, void 0, array(ZoneSchema));
 				zoneId = zones[0]?.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, z.array(TunnelSchema)))[0];
+			let tunnel = (await cf(apiToken, "GET", `/accounts/${accountId}/cfd_tunnel?name=${tunnelName}`, void 0, array(TunnelSchema)))[0];
 			if (!tunnel) {
-				console.log(`[unplugin-cloudflare-tunnel] Creating tunnel '${tunnelName}'...`);
+				pluginLog.info(`Creating tunnel '${tunnelName}'...`);
 				tunnel = await cf(apiToken, "POST", `/accounts/${accountId}/cfd_tunnel`, {
 					name: tunnelName,
 					config_src: "cloudflare"
@@ -470,13 +620,13 @@ const unpluginFactory = (options = {}) => {
 			}
 			const tunnelId = tunnel.id;
 			if (autoCleanup) {
-				console.log(`[unplugin-cloudflare-tunnel] 🧹 Running resource cleanup for tunnel '${tunnelName}'...`);
+				debugLog(`[unplugin-cloudflare-tunnel] Running resource cleanup for tunnel '${tunnelName}'...`);
 				const dnsCleanup = await cleanupMismatchedDnsRecords(apiToken, zoneId, generateDnsComment(), hostname, tunnelId);
-				if (dnsCleanup.found.length > 0) console.log(`[unplugin-cloudflare-tunnel] 📊 DNS cleanup: ${dnsCleanup.found.length} mismatched, ${dnsCleanup.deleted.length} deleted`);
+				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}`);
-					console.log(`[unplugin-cloudflare-tunnel] 📊 SSL cleanup: ${mismatchedSslCerts.length} deleted`);
+					pluginLog.warn(`SSL cleanup: ${mismatchedSslCerts.length} deleted`);
 				}
 			} else debugLog("← Cleanup skipped", cleanupConfig);
 			const localTarget = getLocalTarget(serverHost, port);
@@ -490,7 +640,7 @@ const unpluginFactory = (options = {}) => {
 			};
 			if (dnsOption) {
 				const ensureDnsRecord = async (type, content) => {
-					if ((await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=${type}&name=${encodeURIComponent(dnsOption)}`, void 0, z.array(DNSRecordSchema))).length === 0) {
+					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,
@@ -504,22 +654,34 @@ const unpluginFactory = (options = {}) => {
 				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, z.array(DNSRecordSchema))).length === 0) {
-					if (!((await cf(apiToken, "GET", `/zones/${zoneId}/dns_records?type=CNAME&name=${hostname}`, void 0, z.array(DNSRecordSchema))).length > 0)) {
+				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: `${tunnelId}.cfargotunnel.com`,
+							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, z.string());
+			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, z.any());
+				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) {
@@ -545,11 +707,11 @@ const unpluginFactory = (options = {}) => {
 					const wildcardDomain = `*.${parentDomain}`;
 					const wildcardExists = certContainingHost(wildcardDomain);
 					if (!wildcardExists) {
-						const totalTls = await cf(apiToken, "GET", `/zones/${zoneId}/acm/total_tls`, void 0, z.object({ status: z.string() }));
+						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) {
-							console.log(`[unplugin-cloudflare-tunnel] Requesting edge certificate for ${hostname}...`);
+							pluginLog.info(`Requesting edge certificate for ${hostname}...`);
 							const tagHostname = generateSslTagHostname();
 							const certificateHosts = [hostname, tagHostname];
 							debugLog(`Adding tag hostname to certificate: ${tagHostname}`);
@@ -574,7 +736,7 @@ const unpluginFactory = (options = {}) => {
 			if (logFile) cloudflaredArgs.push("--logfile", logFile);
 			debugLog("Spawning cloudflared", bin, cloudflaredArgs);
 			cloudflaredArgs.push("run", "--token", token);
-			child = spawn(bin, cloudflaredArgs, {
+			child = NodeChildProcess.spawn(bin, cloudflaredArgs, {
 				stdio: [
 					"ignore",
 					"pipe",
@@ -584,18 +746,37 @@ const unpluginFactory = (options = {}) => {
 				windowsHide: true,
 				shell: process.platform === "win32"
 			});
-			console.log(`[unplugin-cloudflare-tunnel] Process spawned with PID: ${child.pid}`);
+			debugLog(`[unplugin-cloudflare-tunnel] Process spawned with PID: ${child.pid}`);
 			globalState.child = child;
 			globalState.configHash = newConfigHash;
 			registerExitHandler();
 			let tunnelReady = false;
+			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}`);
+				}
+			};
 			child.stdout?.on("data", (data) => {
 				const output = data.toString();
-				if (!globalState.shuttingDown || debug) console.log(`[cloudflared stdout] ${output.trim()}`);
+				logCloudflaredLines("stdout", output);
 				if (output.includes("Connection") && output.includes("registered")) {
 					if (!tunnelReady) {
 						tunnelReady = true;
-						console.log(`🌐  Cloudflare tunnel started for https://${hostname}`);
+						pluginLog.info(`Tunnel connected for https://${hostname}`);
 					}
 				}
 			});
@@ -605,10 +786,7 @@ const unpluginFactory = (options = {}) => {
 					if (logLevel === "debug") console.log(`[cloudflared debug] ${error}`);
 					return;
 				}
-				if (!globalState.shuttingDown || debug) console.error(`[cloudflared stderr] ${error}`);
-				if (error.toLowerCase().includes("error") || error.toLowerCase().includes("failed") || error.toLowerCase().includes("fatal")) {
-					if (!globalState.shuttingDown || debug) console.error(`[unplugin-cloudflare-tunnel] ⚠️  ${error}`);
-				}
+				logCloudflaredLines("stderr", error);
 			});
 			child.on("error", (error) => {
 				console.error(`[unplugin-cloudflare-tunnel] ❌ Failed to start tunnel process: ${error.message}`);
@@ -620,25 +798,31 @@ const unpluginFactory = (options = {}) => {
 					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`);
 			});
-			setTimeout(() => {
-				if (!tunnelReady) console.log(`🌐  Cloudflare tunnel starting for https://${hostname}`);
-			}, 3e3);
+			registerListeningHandler(() => {
+				const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
+				const actualLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
+				announceTunnel({
+					key: `named:${hostname}:${actualPort ?? port}`,
+					url: `https://${hostname}`,
+					localTarget: actualLocalTarget
+				});
+			});
 			server.httpServer?.once("close", () => {
 				killCloudflared("SIGTERM");
 			});
-			server.httpServer?.on("listening", async () => {
+			registerListeningHandler(async () => {
 				try {
 					const { host: actualServerHost, port: actualPort } = normalizeAddress(server.httpServer?.address());
 					if (actualPort !== port) {
-						console.log(`[unplugin-cloudflare-tunnel] ⚠️  Port conflict detected - server is using port ${actualPort} instead of ${port}`);
-						console.log(`[unplugin-cloudflare-tunnel] 🔄 Updating tunnel configuration...`);
+						pluginLog.warn(`Port conflict detected - server is using port ${actualPort} instead of ${port}`);
+						pluginLog.info("Updating tunnel configuration...");
 						const newLocalTarget = getLocalTarget(actualServerHost, actualPort ?? port);
 						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" }] } });
-						console.log(`[unplugin-cloudflare-tunnel] ✅ Tunnel configuration updated to use port ${actualPort}`);
+						pluginLog.info(`Tunnel configuration updated to use port ${actualPort}`);
 						globalState.configHash = JSON.stringify({
 							hostname,
 							port: actualPort,
@@ -652,27 +836,126 @@ const unpluginFactory = (options = {}) => {
 				}
 			});
 		} catch (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`);
+			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 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: "unplugin-cloudflare-tunnel",
+		name: PLUGIN_NAME,
 		enforce: "pre",
 		resolveId(id) {
-			if (id === VIRTUAL_MODULE_ID) return "\0" + VIRTUAL_MODULE_ID;
+			if (id === VIRTUAL_MODULE_ID) {
+				debugLog("resolveId called for", id);
+				return id;
+			}
+		},
+		loadInclude(id) {
+			return id === VIRTUAL_MODULE_ID;
 		},
 		async load(id) {
-			const url = await globalState.tunnelUrl;
-			if (id === "\0" + VIRTUAL_MODULE_ID) return `export function getTunnelUrl() { return ${JSON.stringify(url || "")}; }`;
+			if (id === VIRTUAL_MODULE_ID) {
+				const url = await globalState.tunnelUrl;
+				return `export function getTunnelUrl() { return ${JSON.stringify(url || "")}; }`;
+			}
 		},
 		vite: {
-			config(config) {
+			config: (config) => {
+				announceConnecting();
 				if (!config.server) config.server = {};
 				if (isQuickMode) {
 					config.server.allowedHosts = [".trycloudflare.com"];
@@ -680,15 +963,15 @@ const unpluginFactory = (options = {}) => {
 				}
 				if (!config.server.allowedHosts) {
 					config.server.allowedHosts = [hostname];
-					console.log(`[unplugin-cloudflare-tunnel] Configured Vite to allow requests from ${hostname}`);
+					debugLog(`[unplugin-cloudflare-tunnel] Configured Vite to allow requests from ${hostname}`);
 				} else if (Array.isArray(config.server.allowedHosts)) {
 					if (!config.server.allowedHosts.includes(hostname)) {
 						config.server.allowedHosts.push(hostname);
-						console.log(`[unplugin-cloudflare-tunnel] Added ${hostname} to allowed hosts`);
+						debugLog(`[unplugin-cloudflare-tunnel] Added ${hostname} to allowed hosts`);
 					}
 				}
 			},
-			configureServer(server) {
+			configureServer: (server) => {
 				const configuredPromise = configureServer(server);
 				globalState.tunnelUrl = configuredPromise.then(() => tunnelUrl).catch(() => "");
 				return async () => {
@@ -696,6 +979,12 @@ const unpluginFactory = (options = {}) => {
 				};
 			}
 		},
+		rspack: (compiler) => {
+			setupWebpackLikeDevServerIntegration(compiler, "rspack");
+		},
+		webpack: (compiler) => {
+			setupWebpackLikeDevServerIntegration(compiler, "webpack");
+		},
 		closeBundle() {
 			killCloudflared("SIGTERM");
 			delete globalState.child;
@@ -713,7 +1002,7 @@ function normalizeAddress(address) {
 }
 async function ensureCloudflaredBinary(binPath) {
 	try {
-		await fs.access(binPath);
+		await NodeFS.access(binPath);
 	} catch {
 		console.log("[unplugin-cloudflare-tunnel] Installing cloudflared binary...");
 		await install(binPath);
@@ -726,4 +1015,4 @@ const CloudflareTunnel = createUnplugin(unpluginFactory);
 var src_default = CloudflareTunnel;
 
 //#endregion
-export { src_default as n, CloudflareTunnel as t };
+export { CloudflareTunnel, src_default as default };