vite-plugin-rpx 0.11.0 → 0.11.1

package/dist/index.d.ts

@@ -7,5 +7,7 @@ export type { SimplifiedPluginOptions } from './simplified-plugin';
  * @deprecated Use SimplifiedVitePlugin instead to avoid WebSocket port allocation issues
  */
 export declare function VitePluginRpx(options: VitePluginRpxOptions): Plugin;
+// Export the simplified plugin types and implementation
 export { SimplifiedVitePlugin } from './simplified-plugin';
-export default SimplifiedVitePlugin;
+// Set the default export to be the simplified plugin
+export default SimplifiedVitePlugin;

package/dist/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -3319,13 +3337,14 @@ function getSudoPassword() {
 }
 function execSudoSync(command) {
   const sudoPassword = getSudoPassword();
+  const escaped = command.replace(/'/g, `'\\''`);
   if (sudoPassword) {
-    return execSync(`echo '${sudoPassword}' | sudo -S ${command}`, {
+    return execSync(`echo '${sudoPassword}' | sudo -S sh -c '${escaped}' 2>/dev/null`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
   }
-  return execSync(`sudo ${command}`, { encoding: "utf-8" });
+  return execSync(`sudo sh -c '${escaped}'`, { encoding: "utf-8" });
 }
 function debugLog(category, message, verbose) {
   if (verbose)
@@ -4796,15 +4815,21 @@ import * as net2 from "node:net";
 import * as process18 from "node:process";
 
 // ../rpx/src/logger.ts
-import { createRequire as createRequire2 } from "node:module";
-var require2 = createRequire2(import.meta.url);
-var consolaMod = require2("consola");
-var log = consolaMod.consola;
+var log = {
+  info: (...args) => console.log("[info]", ...args),
+  success: (...args) => console.log("[success]", ...args),
+  warn: (...args) => console.warn("[warn]", ...args),
+  error: (...args) => console.error("[error]", ...args),
+  debug: (...args) => console.debug("[debug]", ...args),
+  log: (...args) => console.log(...args),
+  start: (...args) => console.log("[start]", ...args),
+  box: (...args) => console.log("[box]", ...args)
+};
 
 // ../rpx/src/start.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
 // ../rpx/package.json
-var version = "0.11.0";
+var version = "0.11.1";
 
 // ../rpx/src/config.ts
 import { homedir as homedir3 } from "node:os";
@@ -9847,13 +9872,13 @@ var defaultConfig3 = {
 };
 
 // ../rpx/src/hosts.ts
+await init_utils();
 import { exec } from "node:child_process";
 import fs2 from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import * as process15 from "node:process";
 import { promisify } from "node:util";
-await init_utils();
 var execAsync = promisify(exec);
 var hostsFilePath = process15.platform === "win32" ? path.join(process15.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
 var sudoPrivilegesAcquired = false;
@@ -9861,21 +9886,22 @@ async function execSudo(command) {
   if (process15.platform === "win32")
     throw new Error("Administrator privileges required on Windows");
   const sudoPassword = getSudoPassword();
+  const escaped = command.replace(/'/g, `'\\''`);
   try {
     if (sudoPassword) {
-      const { stdout: stdout2 } = await execAsync(`echo '${sudoPassword}' | sudo -S ${command}`);
+      const { stdout: stdout2 } = await execAsync(`echo '${sudoPassword}' | sudo -S sh -c '${escaped}' 2>/dev/null`);
       sudoPrivilegesAcquired = true;
       return stdout2;
     }
     if (sudoPrivilegesAcquired) {
       try {
-        const { stdout: stdout2 } = await execAsync(`sudo -n true && sudo -n ${command}`);
+        const { stdout: stdout2 } = await execAsync(`sudo -n sh -c '${escaped}'`);
         return stdout2;
       } catch (error) {
         debugLog("hosts", "Cached sudo privileges expired, requesting again", true);
       }
     }
-    const { stdout } = await execAsync(`sudo ${command}`);
+    const { stdout } = await execAsync(`sudo sh -c '${escaped}'`);
     sudoPrivilegesAcquired = true;
     return stdout;
   } catch (error) {
@@ -9889,13 +9915,13 @@ async function addHosts(hosts, verbose) {
     let existingContent;
     try {
       existingContent = await fs2.promises.readFile(hostsFilePath, "utf-8");
-    } catch (readErr) {
-      debugLog("hosts", `Error reading hosts file: ${readErr}`, verbose);
-      log.error(`Failed to read hosts file: ${readErr}`);
+    } catch {
+      debugLog("hosts", "Reading hosts file requires elevated permissions, using sudo", verbose);
       try {
         existingContent = await execSudo(`cat "${hostsFilePath}"`);
       } catch (sudoErr) {
-        log.error(`Failed to read hosts file with sudo: ${sudoErr}`);
+        console.log("  Could not read hosts file — skipping hosts setup");
+        debugLog("hosts", `sudo read also failed: ${sudoErr}`, verbose);
         throw new Error(`Cannot read hosts file: ${sudoErr}`);
       }
     }
@@ -9906,7 +9932,6 @@ async function addHosts(hosts, verbose) {
     });
     if (newEntries.length === 0) {
       debugLog("hosts", "All hosts already exist in hosts file", verbose);
-      log.info("All hosts are already in the hosts file");
       return;
     }
     const hostEntries = newEntries.map((host) => `
@@ -9918,32 +9943,19 @@ async function addHosts(hosts, verbose) {
     try {
       await fs2.promises.writeFile(tmpFile, existingContent + hostEntries, "utf8");
       await execSudo(`cat "${tmpFile}" | tee "${hostsFilePath}" > /dev/null`);
-      log.success(`Added new hosts: ${newEntries.join(", ")}`);
+      console.log(`  Hosts updated: ${newEntries.join(", ")}`);
     } catch (error) {
-      log.warn("Could not modify hosts file automatically");
-      log.info("Please add these entries to your hosts file:");
+      console.log("  Could not update hosts file automatically");
+      console.log("  Add these entries to /etc/hosts:");
       newEntries.forEach((host) => {
-        log.info(`  127.0.0.1 ${host}`);
-        log.info(`  ::1 ${host}`);
+        console.log(`    127.0.0.1 ${host}`);
+        console.log(`    ::1 ${host}`);
       });
-      if (process15.platform === "win32") {
-        log.info(`
-On Windows:`);
-        log.info("1. Run notepad as administrator");
-        log.info("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
-      } else {
-        log.info(`
-On Unix systems:`);
-        log.info(`  sudo nano ${hostsFilePath}`);
-      }
-      log.info(`
-Or run: buddy setup:ssl`);
+      console.log(`  Or run: sudo nano ${hostsFilePath}`);
     } finally {
       try {
         await fs2.promises.unlink(tmpFile);
-      } catch (unlinkErr) {
-        debugLog("hosts", `Failed to remove temporary file: ${unlinkErr}`, verbose);
-      }
+      } catch {}
     }
   } catch (err) {
     const error = err;
@@ -9956,12 +9968,12 @@ async function removeHosts(hosts, verbose) {
     let content;
     try {
       content = await fs2.promises.readFile(hostsFilePath, "utf-8");
-    } catch (readErr) {
-      debugLog("hosts", `Error reading hosts file: ${readErr}`, verbose);
+    } catch {
+      debugLog("hosts", "Reading hosts file requires elevated permissions, using sudo", verbose);
       try {
         content = await execSudo(`cat "${hostsFilePath}"`);
       } catch (sudoErr) {
-        log.error(`Failed to read hosts file with sudo: ${sudoErr}`);
+        debugLog("hosts", `sudo read also failed: ${sudoErr}`, verbose);
         throw new Error(`Cannot read hosts file: ${sudoErr}`);
       }
     }
@@ -9993,14 +10005,9 @@ async function removeHosts(hosts, verbose) {
     try {
       await fs2.promises.writeFile(tmpFile, newContent, "utf8");
       await execSudo(`cat "${tmpFile}" | tee "${hostsFilePath}" > /dev/null`);
-      log.success("Hosts removed successfully");
+      debugLog("hosts", "Hosts removed successfully", verbose);
     } catch (error) {
-      log.warn("Could not modify hosts file automatically");
-      log.info("You may want to remove these entries from your hosts file:");
-      hosts.forEach((host) => {
-        log.info(`  127.0.0.1 ${host}`);
-        log.info(`  ::1 ${host}`);
-      });
+      debugLog("hosts", "Could not clean up hosts file automatically", verbose);
     } finally {
       try {
         await fs2.promises.unlink(tmpFile);
@@ -19079,10 +19086,12 @@ async function generateCertificate(options) {
   const domains = isMultiProxyOptions(options) ? options.proxies.map((proxy) => proxy.to) : [options.to];
   debugLog("ssl", `Generating certificate for domains: ${domains.join(", ")}`, options.verbose);
   const rootCAConfig = httpsConfig(options, options.verbose);
-  log.info("Generating Root CA certificate...");
+  if (options.verbose)
+    log.info("Generating Root CA certificate...");
   const caCert = await QO(rootCAConfig);
   const hostConfig = httpsConfig(options, options.verbose);
-  log.info(`Generating host certificate for: ${domains.join(", ")}`);
+  if (options.verbose)
+    log.info(`Generating host certificate for: ${domains.join(", ")}`);
   const hostCert = await YO({
     ...hostConfig,
     rootCA: {
@@ -19106,22 +19115,26 @@ async function generateCertificate(options) {
   const alreadyTrusted = await isCertTrusted(hostConfig.certPath, { verbose: options.verbose, regenerateUntrustedCerts: true });
   if (alreadyTrusted) {
     debugLog("ssl", "Certificate is already trusted, skipping trust store update", options.verbose);
-    log.success("Certificate is already trusted in system trust store");
+    if (options.verbose)
+      log.success("Certificate is already trusted in system trust store");
     cachedSSLConfig = {
       key: hostCert.privateKey,
       cert: hostCert.certificate,
       ca: caCert.certificate
     };
-    log.success(`Certificate generated successfully for ${domains.length} domain${domains.length > 1 ? "s" : ""}`);
+    if (options.verbose)
+      log.success(`Certificate generated successfully for ${domains.length} domain${domains.length > 1 ? "s" : ""}`);
     return;
   }
-  log.info("Adding certificate to system trust store (may require sudo permission)...");
+  if (options.verbose)
+    log.info("Adding certificate to system trust store (may require sudo permission)...");
   let isTrusted = false;
   if (process16.platform === "darwin") {
     try {
       const combinedCmd = `security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${hostConfig.caCertPath}" && security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${hostConfig.certPath}"`;
       execSudoSync(combinedCmd);
-      log.success("Successfully added CA and host certificates to system trust store");
+      if (options.verbose)
+        log.success("Successfully added CA and host certificates to system trust store");
       try {
         execSync2(`security add-trusted-cert -d -r trustRoot -k ~/Library/Keychains/login.keychain-db "${hostConfig.certPath}"`, { stdio: "pipe" });
       } catch {}
@@ -19137,7 +19150,8 @@ echo "If you still see certificate warnings, type 'thisisunsafe' on the warning
 `;
       await fs3.writeFile(scriptPath, scriptContent, { mode: 493 });
     } catch (err) {
-      log.warn(`Could not add certificate to trust store automatically: ${err}`);
+      if (options.verbose)
+        log.warn(`Could not add certificate to trust store automatically: ${err}`);
       const sslScriptDir = hostConfig.basePath || join7(homedir6(), ".stacks", "ssl");
       const scriptPath = join7(sslScriptDir, "trust-rpx-cert.sh");
       const scriptContent = `#!/bin/bash
@@ -19148,8 +19162,10 @@ echo "Certificates trusted! Please restart your browser."
 echo "If you still see certificate warnings, type 'thisisunsafe' on the warning page in Chrome/Arc browsers."
 `;
       await fs3.writeFile(scriptPath, scriptContent, { mode: 493 });
-      log.info(`Created a trust helper script at: ${scriptPath}`);
-      log.info(`If you're still having certificate issues, run: sh ${scriptPath}`);
+      if (options.verbose) {
+        log.info(`Created a trust helper script at: ${scriptPath}`);
+        log.info(`If you're still having certificate issues, run: sh ${scriptPath}`);
+      }
     }
   } else if (process16.platform === "linux") {
     try {
@@ -19167,10 +19183,12 @@ echo "RPX certificates installed. Please restart your browser."
       await new Promise((resolve9) => {
         exec2(`sudo bash "${tmpScript}"`, (error) => {
           if (error) {
-            log.warn(`Could not trust certificates: ${error}`);
+            if (options.verbose)
+              log.warn(`Could not trust certificates: ${error}`);
             resolve9(false);
           } else {
-            log.success("Successfully added certificates to system trust store");
+            if (options.verbose)
+              log.success("Successfully added certificates to system trust store");
             resolve9(true);
           }
         });
@@ -19178,7 +19196,8 @@ echo "RPX certificates installed. Please restart your browser."
       await fs3.unlink(tmpScript).catch(() => {});
       isTrusted = true;
     } catch (error) {
-      log.warn(`Failed to trust certificates: ${error}`);
+      if (options.verbose)
+        log.warn(`Failed to trust certificates: ${error}`);
     }
   } else if (process16.platform === "win32") {
     try {
@@ -19193,17 +19212,20 @@ Write-Host "Certificate trusted successfully!"
       const psPath = join7(os2.tmpdir(), "rpx-trust.ps1");
       await fs3.writeFile(psPath, winScript);
       execSync2(`powershell -ExecutionPolicy Bypass -File "${psPath}"`);
-      log.success("Successfully added certificate to Windows trust store");
+      if (options.verbose)
+        log.success("Successfully added certificate to Windows trust store");
       isTrusted = true;
     } catch (error) {
-      log.warn(`Could not trust certificate: ${error}`);
+      if (options.verbose)
+        log.warn(`Could not trust certificate: ${error}`);
     }
   } else {
     try {
       await UO(hostCert, caCert.certificate, hostConfig);
       isTrusted = true;
     } catch (err) {
-      log.warn(`Could not add certificate to trust store: ${err}`);
+      if (options.verbose)
+        log.warn(`Could not add certificate to trust store: ${err}`);
     }
   }
   cachedSSLConfig = {
@@ -19211,8 +19233,9 @@ Write-Host "Certificate trusted successfully!"
     cert: hostCert.certificate,
     ca: caCert.certificate
   };
-  log.success(`Certificate generated successfully for ${domains.length} domain${domains.length > 1 ? "s" : ""}`);
-  if (!isTrusted) {
+  if (options.verbose)
+    log.success(`Certificate generated successfully for ${domains.length} domain${domains.length > 1 ? "s" : ""}`);
+  if (!isTrusted && options.verbose) {
     log.warn('If you see certificate warnings in Chrome/Arc, type "thisisunsafe" on the warning page');
     log.warn("This will bypass the warning and you should only need to do it once");
   }
@@ -19230,10 +19253,13 @@ async function checkExistingCertificates(options) {
       sslConfig.caCertPath ? fs3.access(sslConfig.caCertPath).then(() => true).catch(() => false) : Promise.resolve(false)
     ]);
     if (!keyExists || !certExists) {
-      debugLog("ssl", `Certificate files don't exist: key=${keyExists}, cert=${certExists}`, options.verbose);
+      debugLog("ssl", `Certificate files don't exist: key=${keyExists}, cert=${certExists}, paths: ${sslConfig.keyPath}, ${sslConfig.certPath}`, options.verbose);
       return null;
     }
-    const shouldCheckTrust = "regenerateUntrustedCerts" in options ? options.regenerateUntrustedCerts !== false : true;
+    const hasFlag = "regenerateUntrustedCerts" in options;
+    const flagValue = options.regenerateUntrustedCerts;
+    const shouldCheckTrust = hasFlag ? flagValue !== false : true;
+    debugLog("ssl", `Trust check: hasFlag=${hasFlag}, flagValue=${flagValue}, shouldCheckTrust=${shouldCheckTrust}`, options.verbose);
     const certIsTrusted = shouldCheckTrust ? await isCertTrusted(sslConfig.certPath, options) : true;
     if (!certIsTrusted) {
       debugLog("ssl", "Certificate exists but is not trusted, will regenerate", options.verbose);
@@ -19244,10 +19270,25 @@ async function checkExistingCertificates(options) {
       fs3.readFile(sslConfig.certPath, "utf8"),
       caExists && sslConfig.caCertPath ? fs3.readFile(sslConfig.caCertPath, "utf8") : Promise.resolve(undefined)
     ]);
-    if (ca && !isValidRootCA(ca)) {
-      debugLog("ssl", "Invalid root CA certificate, will regenerate", options.verbose);
+    if (ca && !ca.includes("-----BEGIN CERTIFICATE-----")) {
+      debugLog("ssl", "Invalid root CA certificate content, will regenerate", options.verbose);
       return null;
     }
+    if (isMultiProxyOptions(options)) {
+      try {
+        const { X509Certificate } = await import("node:crypto");
+        const x509 = new X509Certificate(cert);
+        const san = x509.subjectAltName || "";
+        const requiredDomains = options.proxies.map((p3) => p3.to);
+        const missingDomains = requiredDomains.filter((d3) => !san.includes(`DNS:${d3}`));
+        if (missingDomains.length > 0) {
+          debugLog("ssl", `Certificate missing SANs for: ${missingDomains.join(", ")}, will regenerate`, options.verbose);
+          return null;
+        }
+      } catch (err) {
+        debugLog("ssl", `Could not verify cert SANs: ${err}`, options.verbose);
+      }
+    }
     debugLog("ssl", "Successfully loaded existing certificates", options.verbose);
     cachedSSLConfig = { key, cert, ca };
     return cachedSSLConfig;
@@ -20079,7 +20120,8 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
           vitePluginUsage,
           listenPort,
           ssl: true,
-          cleanUrls
+          cleanUrls,
+          verbose
         });
         resolve9();
       } catch (err) {
@@ -20099,7 +20141,8 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
           vitePluginUsage,
           listenPort,
           ssl: !!ssl,
-          cleanUrls
+          cleanUrls,
+          verbose
         });
         resolve9();
       });
@@ -20132,16 +20175,14 @@ async function setupProxy(options) {
         }
       }
     } else {
-      if (to && to.includes("localhost") && !to.match(/^(localhost|127\.0\.0\.1)$/)) {
+      if (process18.platform !== "darwin" && to && to.includes("localhost") && !to.match(/^(localhost|127\.0\.0\.1)$/)) {
         const hostsExist = await checkHosts([to], verbose);
         if (!hostsExist[0]) {
-          log.warn(`The hostname ${to} isn't in your hosts file. Adding it now...`);
+          debugLog("hosts", `${to} not found in hosts file, adding...`, verbose);
           try {
             await addHosts([to], verbose);
-            log.success(`Added ${to} to your hosts file.`);
           } catch (error) {
-            log.error(`Failed to add ${to} to your hosts file: ${error}`);
-            log.info(`You may need to manually add '127.0.0.1 ${to}' to your /etc/hosts file.`);
+            debugLog("hosts", `Failed to add ${to} to hosts file: ${error}`, verbose);
           }
         }
       }
@@ -20154,30 +20195,32 @@ async function setupProxy(options) {
         portManager2.usedPorts.add(httpPort);
       } else {
         debugLog("setup", "Port 80 is in use, skipping HTTP redirect", verbose);
-        log.warn("Port 80 is in use, HTTP to HTTPS redirect will not be available");
+        if (verbose)
+          log.warn("Port 80 is in use, HTTP to HTTPS redirect will not be available");
       }
     }
     const targetPort = ssl ? httpsPort : httpPort;
     const isTargetPortBusy = await isPortInUse(targetPort, hostname, verbose);
     let finalPort;
     if (isTargetPortBusy) {
-      log.warn(`Port ${targetPort} is already in use. This may be another instance of rpx or another service.`);
+      debugLog("setup", `Port ${targetPort} is already in use`, verbose);
+      if (verbose)
+        log.warn(`Port ${targetPort} is already in use. This may be another instance of rpx or another service.`);
       if (targetPort === 443) {
-        log.info("HTTPS requires port 443 for standard operation. Using an alternative port instead.");
         finalPort = await portManager2.getNextAvailablePort(3443, true);
-        log.info(`Using port ${finalPort} instead. Access your site at https://${to}:${finalPort}`);
+        debugLog("setup", `Using port ${finalPort} instead of ${targetPort}`, verbose);
+        if (verbose)
+          log.info(`Using port ${finalPort} instead. Access your site at https://${to}:${finalPort}`);
       } else {
         finalPort = await portManager2.getNextAvailablePort(targetPort + 1000, true);
-        log.info(`Using port ${finalPort} instead. Access your site at http://${to}:${finalPort}`);
+        debugLog("setup", `Using port ${finalPort} instead of ${targetPort}`, verbose);
+        if (verbose)
+          log.info(`Using port ${finalPort} instead. Access your site at http://${to}:${finalPort}`);
       }
     } else {
       finalPort = targetPort;
       portManager2.usedPorts.add(finalPort);
-      if (targetPort === 443) {
-        log.info(`Using standard HTTPS port 443. Access your site at https://${to}`);
-      } else {
-        log.info(`Using standard HTTP port 80. Access your site at http://${to}`);
-      }
+      debugLog("setup", `Using standard ${targetPort === 443 ? "HTTPS" : "HTTP"} port ${targetPort} for ${to}`, verbose);
     }
     await createProxyServer(from, to, fromPort, finalPort, hostname, sourceUrl, ssl, vitePluginUsage, verbose, cleanUrls, changeOrigin);
   } catch (err) {
@@ -20326,8 +20369,8 @@ async function startProxies(options) {
   const problematicTlds = ["dev", "app", "page", "new", "day", "foo"];
   const reservedTlds = ["test", "localhost", "local", "example", "invalid"];
   const uniqueTlds = [...new Set(customDomains.map((d3) => d3.split(".").pop()?.toLowerCase()))];
-  const problematicFound = uniqueTlds.filter((t2) => typeof t2 === "string" && problematicTlds.includes(t2));
-  if (problematicFound.length > 0) {
+  const problematicFound = uniqueTlds.filter((t2) => !!t2 && problematicTlds.includes(t2));
+  if (problematicFound.length > 0 && verbose) {
     log.warn(`The following TLDs may not work reliably for local development: ${problematicFound.map((t2) => `.${t2}`).join(", ")}`);
     log.info(`  These TLDs have HSTS preloading which can bypass local DNS`);
     log.info(`  Consider using reserved TLDs: .test, .localhost, or .local`);
@@ -20337,14 +20380,16 @@ async function startProxies(options) {
     const dnsStarted = await startDnsServer2(customDomains, verbose);
     if (dnsStarted) {
       await setupResolver2(verbose, customDomains);
-      const hasReservedOnly = uniqueTlds.every((t2) => typeof t2 === "string" && reservedTlds.includes(t2));
-      if (hasReservedOnly) {
-        log.success(`DNS server started for ${uniqueTlds.map((t2) => `.${t2}`).join(", ")} domains`);
-      } else {
-        log.success(`DNS server started for ${uniqueTlds.map((t2) => `.${t2}`).join(", ")} domains (hosts file entries also added)`);
+      if (verbose) {
+        const hasReservedOnly = uniqueTlds.every((t2) => !!t2 && reservedTlds.includes(t2));
+        if (hasReservedOnly) {
+          log.success(`DNS server started for ${uniqueTlds.map((t2) => `.${t2}`).join(", ")} domains`);
+        } else {
+          log.success(`DNS server started for ${uniqueTlds.map((t2) => `.${t2}`).join(", ")} domains (hosts file entries also added)`);
+        }
       }
     } else {
-      log.warn("Could not start DNS server - custom domains may not resolve");
+      debugLog("dns", "Could not start DNS server - custom domains may not resolve", verbose);
     }
   }
   const cleanupHandler = async () => {
@@ -20375,47 +20420,143 @@ async function startProxies(options) {
     console.error("Uncaught exception:", err);
     cleanupHandler();
   });
-  for (const option of proxyOptions) {
-    try {
+  if (sslConfig && proxyOptions.length > 1) {
+    debugLog("proxies", `Creating shared HTTPS server for ${proxyOptions.length} domains`, verbose);
+    const routingTable = new Map;
+    for (const option of proxyOptions) {
       const domain = option.to || "rpx.localhost";
-      debugLog("proxy", `Starting proxy for ${domain} with SSL config: ${!!sslConfig}`, option.verbose);
-      await startServer({
-        from: option.from || "localhost:5173",
-        to: domain,
+      const fromUrl = new URL(option.from?.startsWith("http") ? option.from : `http://${option.from}`);
+      const fromPort = Number.parseInt(fromUrl.port) || 80;
+      routingTable.set(domain, {
+        fromPort,
+        sourceHost: fromUrl.host,
         cleanUrls: option.cleanUrls || false,
-        https: option.https || false,
-        cleanup: option.cleanup || false,
-        vitePluginUsage: option.vitePluginUsage || false,
-        verbose: option.verbose || false,
-        _cachedSSLConfig: sslConfig,
         changeOrigin: option.changeOrigin || false
       });
+      debugLog("proxies", `Route: ${domain} → ${fromUrl.host}`, verbose);
+      if (!domain.includes("localhost") && !domain.includes("127.0.0.1")) {
+        try {
+          const hostsExist = await checkHosts([domain], verbose);
+          if (!hostsExist[0]) {
+            await addHosts([domain], verbose);
+          }
+        } catch {
+          debugLog("hosts", `Could not add hosts entry for ${domain}`, verbose);
+        }
+      }
+    }
+    const isHttpPortBusy = await isPortInUse(80, "0.0.0.0", verbose);
+    if (!isHttpPortBusy) {
+      startHttpRedirectServer(verbose);
+    }
+    const listenPort = 443;
+    const isPortBusy = await isPortInUse(listenPort, "0.0.0.0", verbose);
+    if (isPortBusy) {
+      debugLog("proxies", `Port ${listenPort} is already in use, cannot start shared proxy`, verbose);
+      if (verbose)
+        log.warn(`Port ${listenPort} is in use. Shared HTTPS proxy cannot start.`);
+      return;
+    }
+    try {
+      const bunServer = Bun.serve({
+        port: listenPort,
+        hostname: "0.0.0.0",
+        tls: {
+          key: sslConfig.key,
+          cert: sslConfig.cert,
+          ca: sslConfig.ca,
+          requestCert: false,
+          rejectUnauthorized: false
+        },
+        async fetch(req) {
+          const url = new URL(req.url);
+          const hostHeader = req.headers.get("host") || "";
+          const hostname = hostHeader.split(":")[0];
+          const route = routingTable.get(hostname);
+          if (!route) {
+            debugLog("request", `No route found for host: ${hostname}`, verbose);
+            return new Response(`No proxy configured for ${hostname}`, { status: 404 });
+          }
+          const targetUrl = `http://${route.sourceHost}${url.pathname}${url.search}`;
+          try {
+            const headers = new Headers(req.headers);
+            headers.set("host", route.sourceHost);
+            if (route.changeOrigin) {
+              headers.set("origin", `http://${route.sourceHost}`);
+            }
+            headers.set("x-forwarded-for", "127.0.0.1");
+            headers.set("x-forwarded-proto", "https");
+            headers.set("x-forwarded-host", hostname);
+            const response = await fetch(targetUrl, {
+              method: req.method,
+              headers,
+              body: req.body,
+              redirect: "manual"
+            });
+            const responseHeaders = new Headers(response.headers);
+            if (route.cleanUrls && url.pathname.endsWith(".html")) {
+              const cleanPath = url.pathname.replace(/\.html$/, "");
+              return new Response(null, {
+                status: 301,
+                headers: { Location: cleanPath }
+              });
+            }
+            return new Response(response.body, {
+              status: response.status,
+              statusText: response.statusText,
+              headers: responseHeaders
+            });
+          } catch (err) {
+            debugLog("request", `Proxy error for ${hostname}: ${err}`, verbose);
+            return new Response(`Proxy Error: ${err}`, { status: 502 });
+          }
+        },
+        error(err) {
+          debugLog("server", `Shared proxy server error: ${err}`, verbose);
+          return new Response(`Server Error: ${err.message}`, { status: 500 });
+        }
+      });
+      activeServers.add(bunServer);
+      debugLog("proxies", `Shared HTTPS proxy listening on port ${listenPort} for ${routingTable.size} domains`, verbose);
     } catch (err) {
-      debugLog("proxies", `Failed to start proxy for ${option.to}: ${err}`, option.verbose);
-      console.error(`Failed to start proxy for ${option.to}:`, err);
+      debugLog("proxies", `Failed to start shared proxy: ${err}`, verbose);
+      console.error("Failed to start shared HTTPS proxy:", err);
       cleanupHandler();
     }
+  } else {
+    for (const option of proxyOptions) {
+      try {
+        const domain = option.to || "rpx.localhost";
+        debugLog("proxy", `Starting proxy for ${domain} with SSL config: ${!!sslConfig}`, option.verbose);
+        await startServer({
+          from: option.from || "localhost:5173",
+          to: domain,
+          cleanUrls: option.cleanUrls || false,
+          https: option.https || false,
+          cleanup: option.cleanup || false,
+          vitePluginUsage: option.vitePluginUsage || false,
+          verbose: option.verbose || false,
+          _cachedSSLConfig: sslConfig,
+          changeOrigin: option.changeOrigin || false
+        });
+      } catch (err) {
+        debugLog("proxies", `Failed to start proxy for ${option.to}: ${err}`, option.verbose);
+        console.error(`Failed to start proxy for ${option.to}:`, err);
+        cleanupHandler();
+      }
+    }
   }
 }
 function logToConsole(options) {
-  if (!options?.vitePluginUsage) {
-    console.log("");
-    console.log(`  ${import_picocolors.default.green(import_picocolors.default.bold("rpx"))} ${import_picocolors.default.green(`v${version}`)}`);
-    console.log("");
-    console.log(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.dim(options?.from ?? "")} ${import_picocolors.default.dim("➜")} ${import_picocolors.default.cyan(options?.ssl ? ` https://${options?.to}` : ` http://${options?.to}`)}`);
-    if (options?.listenPort !== (options?.ssl ? 443 : 80))
-      console.log(`  ${import_picocolors.default.green("➜")}  Listening on port ${options?.listenPort}`);
-    if (options?.ssl) {
-      console.log(`  ${import_picocolors.default.green("➜")}  SSL enabled with:`);
-      console.log(`     - TLS 1.2/1.3`);
-      console.log(`     - Modern cipher suite`);
-      console.log(`     - HTTP/2 enabled`);
-      console.log(`     - HSTS enabled`);
-    }
-    if (options?.cleanUrls) {
-      console.log(`  ${import_picocolors.default.green("➜")}  Clean URLs enabled`);
-    }
-  }
+  if (options?.vitePluginUsage || !options?.verbose)
+    return;
+  console.log("");
+  console.log(`  ${import_picocolors.default.green(import_picocolors.default.bold("rpx"))} ${import_picocolors.default.green(`v${version}`)}`);
+  console.log(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.dim(options?.from ?? "")} ${import_picocolors.default.dim("➜")} ${import_picocolors.default.cyan(options?.ssl ? `https://${options?.to}` : `http://${options?.to}`)}`);
+  if (options?.listenPort !== (options?.ssl ? 443 : 80))
+    console.log(`  ${import_picocolors.default.green("➜")}  Listening on port ${options?.listenPort}`);
+  if (options?.cleanUrls)
+    console.log(`  ${import_picocolors.default.green("➜")}  Clean URLs enabled`);
 }
 
 // ../rpx/src/index.ts

package/dist/simplified-plugin.d.ts

@@ -1,6 +1,4 @@
 import type { Plugin } from 'vite';
 import type { VitePluginRpxOptions } from './types';
 export declare function SimplifiedVitePlugin(options?: SimplifiedPluginOptions): Plugin;
-export declare interface SimplifiedPluginOptions extends VitePluginRpxOptions {
-
-}
+export declare interface SimplifiedPluginOptions extends VitePluginRpxOptions {}

package/dist/types.d.ts

@@ -6,19 +6,11 @@ export declare interface VitePluginRpxOptions {
   https?: boolean | TlsConfig
   cleanUrls?: boolean
   cleanup?: boolean | {
-    /**
-     * Whether to clean up hosts file entries
-     * @default true
-     */
     hosts?: boolean
-    /**
-     * Whether to clean up SSL certificates
-     * @default false
-     */
     certs?: boolean
   }
   changeOrigin?: boolean
   verbose?: boolean
   regenerateUntrustedCerts?: boolean
   enableHmr?: boolean
-}
+}

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
 import type { SingleReverseProxyConfig } from '@stacksjs/rpx';
 import type { VitePluginRpxOptions } from './types';
 export declare function getDefaultSSLConfig(): { caCertPath: string, certPath: string, keyPath: string };
-export declare function buildConfig(options: VitePluginRpxOptions, serverUrl?: string): SingleReverseProxyConfig;
+export declare function buildConfig(options: VitePluginRpxOptions, serverUrl?: string): SingleReverseProxyConfig;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-plugin-rpx",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "A modern and smart reverse proxy. Vite plugin.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "typecheck": "bunx tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/rpx": "0.11.0",
+    "@stacksjs/rpx": "0.11.1",
     "@stacksjs/tlsx": "^0.10.0"
   },
   "devDependencies": {