@stacksjs/rpx 0.5.0 → 0.6.0

package/dist/index.js

@@ -20467,7 +20467,7 @@ var quotes = collect([
 ]);
 var export_prompts = import_prompts.default;
 // package.json
-var version = "0.5.0";
+var version = "0.6.0";
 
 // src/config.ts
 import { homedir } from "os";
@@ -20526,6 +20526,7 @@ async function loadConfig({ name, cwd, defaultConfig }) {
 var defaultConfig = {
   from: "localhost:5173",
   to: "stacks.localhost",
+  cleanUrls: false,
   https: {
     basePath: "",
     caCertPath: join2(homedir(), ".stacks", "ssl", `stacks.localhost.ca.crt`),
@@ -20541,14 +20542,179 @@ var config4 = await loadConfig({
 });
 
 // src/hosts.ts
-import { spawn } from "child_process";
-import fs5 from "fs";
-import os3 from "os";
-import path4 from "path";
+import { exec } from "child_process";
+import fs from "fs";
+import os2 from "os";
+import path from "path";
 import process3 from "process";
+import { promisify } from "util";
+
+// src/utils.ts
+function debugLog(category, message, verbose) {
+  if (verbose) {
+    console.debug(`[rpx:${category}] ${message}`);
+  }
+}
+function extractHostname(options2) {
+  if (isMultiProxyOptions(options2)) {
+    return options2.proxies.map((proxy) => {
+      const domain = proxy.to || "stacks.localhost";
+      return domain.startsWith("http") ? new URL(domain).hostname : domain;
+    });
+  }
+  if (isSingleProxyOptions(options2)) {
+    const domain = options2.to || "stacks.localhost";
+    return [domain.startsWith("http") ? new URL(domain).hostname : domain];
+  }
+  return ["stacks.localhost"];
+}
+function isValidRootCA(value) {
+  return typeof value === "object" && value !== null && "certificate" in value && "privateKey" in value && typeof value.certificate === "string" && typeof value.privateKey === "string";
+}
+function getPrimaryDomain(options2) {
+  if (!options2)
+    return "stacks.localhost";
+  if (isMultiProxyOptions(options2) && options2.proxies.length > 0)
+    return options2.proxies[0].to || "stacks.localhost";
+  if (isSingleProxyOptions(options2))
+    return options2.to || "stacks.localhost";
+  return "stacks.localhost";
+}
+function isMultiProxyConfig(options2) {
+  return "proxies" in options2 && Array.isArray(options2.proxies);
+}
+function isMultiProxyOptions(options2) {
+  return "proxies" in options2 && Array.isArray(options2.proxies);
+}
+function isSingleProxyOptions(options2) {
+  return "to" in options2 && typeof options2.to === "string";
+}
+
+// src/hosts.ts
+var execAsync = promisify(exec);
+var hostsFilePath = process3.platform === "win32" ? path.join(process3.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
+async function execSudo(command) {
+  if (process3.platform === "win32")
+    throw new Error("Administrator privileges required on Windows");
+  try {
+    await execAsync(`sudo ${command}`);
+  } catch (error) {
+    throw new Error(`Failed to execute sudo command: ${error.message}`);
+  }
+}
+async function addHosts(hosts, verbose) {
+  debugLog("hosts", `Adding hosts: ${hosts.join(", ")}`, verbose);
+  debugLog("hosts", `Using hosts file at: ${hostsFilePath}`, verbose);
+  try {
+    const existingContent = await fs.promises.readFile(hostsFilePath, "utf-8");
+    const newEntries = hosts.filter((host) => {
+      const ipv4Entry = `127.0.0.1 ${host}`;
+      const ipv6Entry = `::1 ${host}`;
+      return !existingContent.includes(ipv4Entry) && !existingContent.includes(ipv6Entry);
+    });
+    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) => `
+# Added by rpx
+127.0.0.1 ${host}
+::1 ${host}`).join(`
+`);
+    const tmpFile = path.join(os2.tmpdir(), "hosts.tmp");
+    await fs.promises.writeFile(tmpFile, existingContent + hostEntries, "utf8");
+    try {
+      await execSudo(`cp "${tmpFile}" "${hostsFilePath}"`);
+      log.success(`Added new hosts: ${newEntries.join(", ")}`);
+    } catch (error) {
+      log.error("Failed to modify hosts file automatically");
+      log.warn("Please add these entries to your hosts file manually:");
+      hostEntries.split(`
+`).forEach((entry) => log.warn(entry));
+      if (process3.platform === "win32") {
+        log.warn(`
+On Windows:`);
+        log.warn("1. Run notepad as administrator");
+        log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
+      } else {
+        log.warn(`
+On Unix systems:`);
+        log.warn(`sudo nano ${hostsFilePath}`);
+      }
+      throw new Error("Failed to modify hosts file: manual intervention required");
+    } finally {
+      fs.unlinkSync(tmpFile);
+    }
+  } catch (err2) {
+    const error = err2;
+    log.error(`Failed to manage hosts file: ${error.message}`);
+    throw error;
+  }
+}
+async function removeHosts(hosts, verbose) {
+  debugLog("hosts", `Removing hosts: ${hosts.join(", ")}`, verbose);
+  try {
+    const content = await fs.promises.readFile(hostsFilePath, "utf-8");
+    const lines = content.split(`
+`);
+    const filteredLines = lines.filter((line, index) => {
+      if (line.trim() === "# Added by rpx") {
+        lines.splice(index + 1, 2);
+        return false;
+      }
+      return true;
+    });
+    while (filteredLines[filteredLines.length - 1]?.trim() === "")
+      filteredLines.pop();
+    const newContent = `${filteredLines.join(`
+`)}
+`;
+    const tmpFile = path.join(os2.tmpdir(), "hosts.tmp");
+    await fs.promises.writeFile(tmpFile, newContent, "utf8");
+    try {
+      await execSudo(`cp "${tmpFile}" "${hostsFilePath}"`);
+      log.success("Hosts removed successfully");
+    } catch (error) {
+      log.error("Failed to modify hosts file automatically");
+      log.warn("Please remove these entries from your hosts file manually:");
+      hosts.forEach((host) => {
+        log.warn("# Added by rpx");
+        log.warn(`127.0.0.1 ${host}`);
+        log.warn(`::1 ${host}`);
+      });
+      if (process3.platform === "win32") {
+        log.warn(`
+On Windows:`);
+        log.warn("1. Run notepad as administrator");
+        log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
+      } else {
+        log.warn(`
+On Unix systems:`);
+        log.warn(`sudo nano ${hostsFilePath}`);
+      }
+      throw new Error("Failed to modify hosts file: manual intervention required");
+    } finally {
+      fs.unlinkSync(tmpFile);
+    }
+  } catch (err2) {
+    const error = err2;
+    log.error(`Failed to remove hosts: ${error.message}`);
+    throw error;
+  }
+}
+async function checkHosts(hosts, verbose) {
+  debugLog("hosts", `Checking hosts: ${hosts}`, verbose);
+  const content = await fs.promises.readFile(hostsFilePath, "utf-8");
+  return hosts.map((host) => {
+    const ipv4Entry = `127.0.0.1 ${host}`;
+    const ipv6Entry = `::1 ${host}`;
+    return content.includes(ipv4Entry) || content.includes(ipv6Entry);
+  });
+}
 
 // src/https.ts
-import fs3 from "fs/promises";
+import fs5 from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
 
@@ -20589,7 +20755,7 @@ import process8 from "process";
 import process102 from "process";
 import process182 from "process";
 import process112 from "process";
-import os2 from "os";
+import os3 from "os";
 import tty32 from "tty";
 import process142 from "process";
 import process132 from "process";
@@ -20598,11 +20764,11 @@ import process162 from "process";
 import process172 from "process";
 import process192 from "process";
 import os22 from "os";
-import path from "path";
+import path2 from "path";
 import { resolve as resolve3 } from "path";
 import process22 from "process";
-import fs from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path22 from "path";
 var __create3 = Object.create;
 var __getProtoOf3 = Object.getPrototypeOf;
 var __defProp3 = Object.defineProperty;
@@ -48126,29 +48292,29 @@ var log2 = {
   },
   echo: (...args) => console.log(...args)
 };
-function userDatabasePath2(path22) {
-  return projectPath2(`database/${path22 || ""}`);
+function userDatabasePath2(path23) {
+  return projectPath2(`database/${path23 || ""}`);
 }
-function appPath2(path22) {
-  return projectPath2(`app/${path22 || ""}`);
+function appPath2(path23) {
+  return projectPath2(`app/${path23 || ""}`);
 }
-function commandsPath2(path22) {
-  return appPath2(`Commands/${path22 || ""}`);
+function commandsPath2(path23) {
+  return appPath2(`Commands/${path23 || ""}`);
 }
-function logsPath2(path22) {
-  return storagePath2(`logs/${path22 || ""}`);
+function logsPath2(path23) {
+  return storagePath2(`logs/${path23 || ""}`);
 }
 function projectPath2(filePath = "", options2) {
-  let path22 = process52.cwd();
-  while (path22.includes("storage"))
-    path22 = resolve22(path22, "..");
-  const finalPath = resolve22(path22, filePath);
+  let path23 = process52.cwd();
+  while (path23.includes("storage"))
+    path23 = resolve22(path23, "..");
+  const finalPath = resolve22(path23, filePath);
   if (options2?.relative)
     return relative2(process52.cwd(), finalPath);
   return finalPath;
 }
-function storagePath2(path22) {
-  return projectPath2(`storage/${path22 || ""}`);
+function storagePath2(path23) {
+  return projectPath2(`storage/${path23 || ""}`);
 }
 var config6 = {
   ai: {
@@ -53763,7 +53929,7 @@ class Err2 {
 }
 var fromThrowable2 = Result2.fromThrowable;
 var import_prompts2 = __toESM22(require_prompts32(), 1);
-async function exec(command, options2) {
+async function exec2(command, options2) {
   const cmd = Array.isArray(command) ? command : command.match(/(?:[^\s"]|"[^"]*")+/g);
   log2.debug("exec:", Array.isArray(command) ? command.join(" ") : command, options2);
   log2.debug("cmd:", cmd);
@@ -53809,7 +53975,7 @@ async function runCommand(command, options2) {
     stdio: options2?.stdio ?? [options2?.stdin ?? "inherit", "pipe", "pipe"],
     verbose: options2?.verbose ?? false
   };
-  return await exec(command, opts);
+  return await exec2(command, opts);
 }
 var exports_esm2 = {};
 __export3(exports_esm2, {
@@ -54235,7 +54401,7 @@ function _supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process112.platform === "win32") {
-    const osRelease = os2.release().split(".");
+    const osRelease = os3.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -56832,9 +56998,9 @@ var defaultConfig2 = {
   domain: "stacks.localhost",
   rootCA: { certificate: "", privateKey: "" },
   basePath: "",
-  caCertPath: path.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.ca.crt`),
-  certPath: path.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.crt`),
-  keyPath: path.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.crt.key`),
+  caCertPath: path2.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.ca.crt`),
+  certPath: path2.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.crt`),
+  keyPath: path2.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.crt.key`),
   verbose: false
 };
 var config42 = await loadConfig2({
@@ -56853,10 +57019,10 @@ function findFoldersWithFile(rootDir, fileName) {
   const result = [];
   function search(dir) {
     try {
-      const files = fs.readdirSync(dir);
+      const files = fs3.readdirSync(dir);
       for (const file of files) {
-        const filePath = path2.join(dir, file);
-        const stats = fs.lstatSync(filePath);
+        const filePath = path22.join(dir, file);
+        const stats = fs3.lstatSync(filePath);
         if (stats.isDirectory()) {
           search(filePath);
         } else if (file === fileName) {
@@ -56870,26 +57036,26 @@ function findFoldersWithFile(rootDir, fileName) {
   search(rootDir);
   return result;
 }
-function debugLog(category, message, verbose) {
+function debugLog2(category, message, verbose) {
   if (verbose || config42.verbose) {
     console.debug(`[tlsx:${category}] ${message}`);
   }
 }
 function generateRandomSerial(verbose) {
-  debugLog("cert", "Generating random serial number", verbose);
+  debugLog2("cert", "Generating random serial number", verbose);
   const serialNumber = makeNumberPositive(import_node_forge2.default.util.bytesToHex(import_node_forge2.default.random.getBytesSync(20)));
-  debugLog("cert", `Generated serial number: ${serialNumber}`, verbose);
+  debugLog2("cert", `Generated serial number: ${serialNumber}`, verbose);
   return serialNumber;
 }
 function calculateValidityDates(options22) {
   const notBeforeDays = options22.notBeforeDays ?? 2;
   const validityDays = options22.validityDays ?? (options22.validityYears ? options22.validityYears * 365 : 180);
-  debugLog("cert", "Calculating certificate validity dates", options22.verbose);
+  debugLog2("cert", "Calculating certificate validity dates", options22.verbose);
   const notBefore = new Date(Date.now() - 86400 * notBeforeDays * 1000);
   const notAfter = new Date(notBefore.getTime() + validityDays * 24 * 60 * 60 * 1000);
   notBefore.setUTCHours(0, 0, 0, 0);
   notAfter.setUTCHours(23, 59, 59, 999);
-  debugLog("cert", `Validity period: ${notBefore.toISOString()} to ${notAfter.toISOString()}`, options22.verbose);
+  debugLog2("cert", `Validity period: ${notBefore.toISOString()} to ${notAfter.toISOString()}`, options22.verbose);
   return { notBefore, notAfter };
 }
 function generateCertificateExtensions(options22) {
@@ -56922,9 +57088,9 @@ function generateCertificateExtensions(options22) {
   return extensions;
 }
 async function createRootCA(options22 = {}) {
-  debugLog("ca", "Creating new Root CA Certificate", options22.verbose);
+  debugLog2("ca", "Creating new Root CA Certificate", options22.verbose);
   const keySize = options22.keySize || 2048;
-  debugLog("ca", `Generating ${keySize}-bit RSA key pair`, options22.verbose);
+  debugLog2("ca", `Generating ${keySize}-bit RSA key pair`, options22.verbose);
   const { privateKey, publicKey } = import_node_forge2.pki.rsa.generateKeyPair(keySize);
   const attributes = [
     { shortName: "C", value: options22.countryName || config42.countryName },
@@ -56971,14 +57137,14 @@ async function createRootCA(options22 = {}) {
   };
 }
 async function generateCertificate(options22) {
-  debugLog("cert", "Generating new certificate", options22.verbose);
-  debugLog("cert", `Options: ${JSON.stringify(options22)}`, options22.verbose);
+  debugLog2("cert", "Generating new certificate", options22.verbose);
+  debugLog2("cert", `Options: ${JSON.stringify(options22)}`, options22.verbose);
   if (!options22.rootCA?.certificate || !options22.rootCA?.privateKey) {
     throw new Error("Root CA certificate and private key are required");
   }
   const caCert = import_node_forge2.pki.certificateFromPem(options22.rootCA.certificate);
   const caKey = import_node_forge2.pki.privateKeyFromPem(options22.rootCA.privateKey);
-  debugLog("cert", "Generating 2048-bit RSA key pair for host certificate", options22.verbose);
+  debugLog2("cert", "Generating 2048-bit RSA key pair for host certificate", options22.verbose);
   const keySize = 2048;
   const { privateKey, publicKey } = import_node_forge2.pki.rsa.generateKeyPair(keySize);
   const attributes = options22.certificateAttributes || [
@@ -57009,81 +57175,81 @@ async function generateCertificate(options22) {
   };
 }
 async function addCertToSystemTrustStoreAndSaveCert(cert, caCert, options22) {
-  debugLog("trust", `Adding certificate to system trust store with options: ${JSON.stringify(options22)}`, options22?.verbose);
-  debugLog("trust", "Storing certificate and private key", options22?.verbose);
+  debugLog2("trust", `Adding certificate to system trust store with options: ${JSON.stringify(options22)}`, options22?.verbose);
+  debugLog2("trust", "Storing certificate and private key", options22?.verbose);
   const certPath = storeCertificate(cert, options22);
-  debugLog("trust", "Storing CA certificate", options22?.verbose);
+  debugLog2("trust", "Storing CA certificate", options22?.verbose);
   const caCertPath = storeCACertificate(caCert, options22);
   const platform22 = os4.platform();
-  debugLog("trust", `Detected platform: ${platform22}`, options22?.verbose);
+  debugLog2("trust", `Detected platform: ${platform22}`, options22?.verbose);
   const args = "TC, C, C";
   if (platform22 === "darwin") {
-    debugLog("trust", "Adding certificate to macOS keychain", options22?.verbose);
+    debugLog2("trust", "Adding certificate to macOS keychain", options22?.verbose);
     await runCommand(`sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain ${caCertPath}`);
   } else if (platform22 === "win32") {
-    debugLog("trust", "Adding certificate to Windows certificate store", options22?.verbose);
+    debugLog2("trust", "Adding certificate to Windows certificate store", options22?.verbose);
     await runCommand(`certutil -f -v -addstore -enterprise Root ${caCertPath}`);
   } else if (platform22 === "linux") {
-    debugLog("trust", "Adding certificate to Linux certificate store", options22?.verbose);
+    debugLog2("trust", "Adding certificate to Linux certificate store", options22?.verbose);
     const rootDirectory = os4.homedir();
     const targetFileName = "cert9.db";
-    debugLog("trust", `Searching for certificate databases in ${rootDirectory}`, options22?.verbose);
+    debugLog2("trust", `Searching for certificate databases in ${rootDirectory}`, options22?.verbose);
     const foldersWithFile = findFoldersWithFile(rootDirectory, targetFileName);
     for (const folder of foldersWithFile) {
-      debugLog("trust", `Processing certificate database in ${folder}`, options22?.verbose);
+      debugLog2("trust", `Processing certificate database in ${folder}`, options22?.verbose);
       try {
-        debugLog("trust", `Attempting to delete existing cert for ${config42.commonName}`, options22?.verbose);
+        debugLog2("trust", `Attempting to delete existing cert for ${config42.commonName}`, options22?.verbose);
         await runCommand(`certutil -d sql:${folder} -D -n ${config42.commonName}`);
       } catch (error) {
-        debugLog("trust", `Warning: Error deleting existing cert: ${error}`, options22?.verbose);
+        debugLog2("trust", `Warning: Error deleting existing cert: ${error}`, options22?.verbose);
         console.warn(`Error deleting existing cert: ${error}`);
       }
-      debugLog("trust", `Adding new certificate to ${folder}`, options22?.verbose);
+      debugLog2("trust", `Adding new certificate to ${folder}`, options22?.verbose);
       await runCommand(`certutil -d sql:${folder} -A -t ${args} -n ${config42.commonName} -i ${caCertPath}`);
       log2.info(`Cert added to ${folder}`);
     }
   } else {
-    debugLog("trust", `Error: Unsupported platform ${platform22}`, options22?.verbose);
+    debugLog2("trust", `Error: Unsupported platform ${platform22}`, options22?.verbose);
     throw new Error(`Unsupported platform: ${platform22}`);
   }
-  debugLog("trust", "Certificate successfully added to system trust store", options22?.verbose);
+  debugLog2("trust", "Certificate successfully added to system trust store", options22?.verbose);
   return certPath;
 }
 function storeCertificate(cert, options22) {
-  debugLog("storage", `Storing certificate and private key with options: ${JSON.stringify(options22)}`, options22?.verbose);
+  debugLog2("storage", `Storing certificate and private key with options: ${JSON.stringify(options22)}`, options22?.verbose);
   const certPath = path3.join(options22?.basePath || config42.basePath, options22?.certPath || config42.certPath);
   const certKeyPath = path3.join(options22?.basePath || config42.basePath, options22?.keyPath || config42.keyPath);
-  debugLog("storage", `Certificate path: ${certPath}`, options22?.verbose);
-  debugLog("storage", `Private key path: ${certKeyPath}`, options22?.verbose);
+  debugLog2("storage", `Certificate path: ${certPath}`, options22?.verbose);
+  debugLog2("storage", `Private key path: ${certKeyPath}`, options22?.verbose);
   const certDir = path3.dirname(certPath);
   if (!fs2.existsSync(certDir)) {
-    debugLog("storage", `Creating certificate directory: ${certDir}`, options22?.verbose);
+    debugLog2("storage", `Creating certificate directory: ${certDir}`, options22?.verbose);
     fs2.mkdirSync(certDir, { recursive: true });
   }
-  debugLog("storage", "Writing certificate file", options22?.verbose);
+  debugLog2("storage", "Writing certificate file", options22?.verbose);
   fs2.writeFileSync(certPath, cert.certificate);
   const certKeyDir = path3.dirname(certKeyPath);
   if (!fs2.existsSync(certKeyDir)) {
-    debugLog("storage", `Creating private key directory: ${certKeyDir}`, options22?.verbose);
+    debugLog2("storage", `Creating private key directory: ${certKeyDir}`, options22?.verbose);
     fs2.mkdirSync(certKeyDir, { recursive: true });
   }
-  debugLog("storage", "Writing private key file", options22?.verbose);
+  debugLog2("storage", "Writing private key file", options22?.verbose);
   fs2.writeFileSync(certKeyPath, cert.privateKey);
-  debugLog("storage", "Certificate and private key stored successfully", options22?.verbose);
+  debugLog2("storage", "Certificate and private key stored successfully", options22?.verbose);
   return certPath;
 }
 function storeCACertificate(caCert, options22) {
-  debugLog("storage", "Storing CA certificate", options22?.verbose);
+  debugLog2("storage", "Storing CA certificate", options22?.verbose);
   const caCertPath = path3.join(options22?.basePath || config42.basePath, options22?.caCertPath || config42.caCertPath);
-  debugLog("storage", `CA certificate path: ${caCertPath}`, options22?.verbose);
+  debugLog2("storage", `CA certificate path: ${caCertPath}`, options22?.verbose);
   const caCertDir = path3.dirname(caCertPath);
   if (!fs2.existsSync(caCertDir)) {
-    debugLog("storage", `Creating CA certificate directory: ${caCertDir}`, options22?.verbose);
+    debugLog2("storage", `Creating CA certificate directory: ${caCertDir}`, options22?.verbose);
     fs2.mkdirSync(caCertDir, { recursive: true });
   }
-  debugLog("storage", "Writing CA certificate file", options22?.verbose);
+  debugLog2("storage", "Writing CA certificate file", options22?.verbose);
   fs2.writeFileSync(caCertPath, caCert);
-  debugLog("storage", "CA certificate stored successfully", options22?.verbose);
+  debugLog2("storage", "CA certificate stored successfully", options22?.verbose);
   return caCertPath;
 }
 var export_tls = import_node_forge2.tls;
@@ -57092,15 +57258,6 @@ var export_forge = import_node_forge2.default;
 
 // src/https.ts
 var cachedSSLConfig = null;
-function isMultiProxyConfig(options3) {
-  return "proxies" in options3 && Array.isArray(options3.proxies);
-}
-function isMultiProxyOptions(options3) {
-  return "proxies" in options3 && Array.isArray(options3.proxies);
-}
-function isSingleProxyOptions(options3) {
-  return "to" in options3 && typeof options3.to === "string";
-}
 function resolveSSLPaths(options3, defaultConfig3) {
   const domain = isMultiProxyConfig(options3) ? options3.proxies[0].to || "stacks.localhost" : options3.to || "stacks.localhost";
   if (typeof options3.https === "object" && typeof defaultConfig3.https === "object") {
@@ -57144,15 +57301,6 @@ function generateWildcardPatterns(domain) {
     patterns.add(`*.${parts.slice(1).join(".")}`);
   return Array.from(patterns);
 }
-function getPrimaryDomain(options3) {
-  if (!options3)
-    return "stacks.localhost";
-  if (isMultiProxyOptions(options3) && options3.proxies.length > 0)
-    return options3.proxies[0].to || "stacks.localhost";
-  if (isSingleProxyOptions(options3))
-    return options3.to || "stacks.localhost";
-  return "stacks.localhost";
-}
 function generateSSLPaths(options3) {
   const domain = getPrimaryDomain(options3);
   let basePath = "";
@@ -57190,51 +57338,50 @@ function getAllDomains(options3) {
   return domains;
 }
 async function loadSSLConfig(options3) {
-  debugLog2("ssl", `Loading SSL configuration`, options3.verbose);
+  debugLog("ssl", `Loading SSL configuration`, options3.verbose);
   const mergedOptions = {
     ...config4,
     ...options3
   };
   options3.https = httpsConfig(mergedOptions);
   if (!options3.https?.keyPath && !options3.https?.certPath) {
-    debugLog2("ssl", "No SSL configuration provided", options3.verbose);
+    debugLog("ssl", "No SSL configuration provided", options3.verbose);
     return null;
   }
   if (options3.https?.keyPath && !options3.https?.certPath || !options3.https?.keyPath && options3.https?.certPath) {
     const missing = !options3.https?.keyPath ? "keyPath" : "certPath";
-    debugLog2("ssl", `Invalid SSL configuration - missing ${missing}`, options3.verbose);
+    debugLog("ssl", `Invalid SSL configuration - missing ${missing}`, options3.verbose);
     throw new Error(`SSL Configuration requires both keyPath and certPath. Missing: ${missing}`);
   }
   try {
     if (!options3.https?.keyPath || !options3.https?.certPath)
       return null;
     try {
-      debugLog2("ssl", "Reading SSL certificate files", options3.verbose);
-      const key = await fs3.readFile(options3.https?.keyPath, "utf8");
-      const cert = await fs3.readFile(options3.https?.certPath, "utf8");
-      debugLog2("ssl", "SSL configuration loaded successfully", options3.verbose);
+      debugLog("ssl", "Reading SSL certificate files", options3.verbose);
+      const key = await fs5.readFile(options3.https?.keyPath, "utf8");
+      const cert = await fs5.readFile(options3.https?.certPath, "utf8");
+      debugLog("ssl", "SSL configuration loaded successfully", options3.verbose);
       return { key, cert };
     } catch (error) {
-      debugLog2("ssl", `Failed to read certificates: ${error}`, options3.verbose);
+      debugLog("ssl", `Failed to read certificates: ${error}`, options3.verbose);
       return null;
     }
   } catch (err3) {
-    debugLog2("ssl", `SSL configuration error: ${err3}`, options3.verbose);
+    debugLog("ssl", `SSL configuration error: ${err3}`, options3.verbose);
     throw err3;
   }
 }
 async function generateCertificate2(options3) {
   if (cachedSSLConfig) {
-    debugLog2("ssl", "Using cached SSL configuration", options3.verbose);
+    debugLog("ssl", "Using cached SSL configuration", options3.verbose);
     return;
   }
   const domains = isMultiProxyOptions(options3) ? options3.proxies.map((proxy) => proxy.to) : [options3.to];
-  debugLog2("ssl", `Generating certificate for domains: ${domains.join(", ")}`, options3.verbose);
+  debugLog("ssl", `Generating certificate for domains: ${domains.join(", ")}`, options3.verbose);
   const rootCAConfig = httpsConfig(options3, options3.verbose);
   log.info("Generating Root CA certificate...");
   const caCert = await createRootCA(rootCAConfig);
   const hostConfig = httpsConfig(options3, options3.verbose);
-  console.log("hostConfig", hostConfig);
   log.info(`Generating host certificate for: ${domains.join(", ")}`);
   const hostCert = await generateCertificate({
     ...hostConfig,
@@ -57250,7 +57397,7 @@ async function generateCertificate2(options3) {
     ca: caCert.certificate
   };
   log.success(`Certificate generated successfully for ${domains.length} domain${domains.length > 1 ? "s" : ""}`);
-  debugLog2("ssl", `Certificate includes domains: ${domains.join(", ")}`, options3.verbose);
+  debugLog("ssl", `Certificate includes domains: ${domains.join(", ")}`, options3.verbose);
 }
 function getSSLConfig() {
   return cachedSSLConfig;
@@ -57259,29 +57406,29 @@ async function checkExistingCertificates(options3) {
   const name = getPrimaryDomain(options3);
   const paths = generateSSLPaths(options3);
   try {
-    debugLog2("ssl", `Checking certificates for ${name} at paths:`, options3?.verbose);
-    debugLog2("ssl", `CA: ${paths.caCertPath}`, options3?.verbose);
-    debugLog2("ssl", `Cert: ${paths.certPath}`, options3?.verbose);
-    debugLog2("ssl", `Key: ${paths.keyPath}`, options3?.verbose);
-    const key = await fs3.readFile(paths.keyPath, "utf8");
-    const cert = await fs3.readFile(paths.certPath, "utf8");
+    debugLog("ssl", `Checking certificates for ${name} at paths:`, options3?.verbose);
+    debugLog("ssl", `CA: ${paths.caCertPath}`, options3?.verbose);
+    debugLog("ssl", `Cert: ${paths.certPath}`, options3?.verbose);
+    debugLog("ssl", `Key: ${paths.keyPath}`, options3?.verbose);
+    const key = await fs5.readFile(paths.keyPath, "utf8");
+    const cert = await fs5.readFile(paths.certPath, "utf8");
     let ca;
     if (paths.caCertPath) {
       try {
-        ca = await fs3.readFile(paths.caCertPath, "utf8");
+        ca = await fs5.readFile(paths.caCertPath, "utf8");
       } catch (err3) {
-        debugLog2("ssl", `Failed to read CA cert: ${err3}`, options3?.verbose);
+        debugLog("ssl", `Failed to read CA cert: ${err3}`, options3?.verbose);
       }
     }
     return { key, cert, ca };
   } catch (err3) {
-    debugLog2("ssl", `Failed to read certificates: ${err3}`, options3?.verbose);
+    debugLog("ssl", `Failed to read certificates: ${err3}`, options3?.verbose);
     return null;
   }
 }
 function httpsConfig(options3, verbose) {
   const primaryDomain = getPrimaryDomain(options3);
-  debugLog2("ssl", `Primary domain: ${primaryDomain}`, verbose);
+  debugLog("ssl", `Primary domain: ${primaryDomain}`, verbose);
   const defaultPaths = generateSSLPaths(options3);
   if (typeof options3.https === "object") {
     const config5 = {
@@ -57331,227 +57478,41 @@ function httpsConfig(options3, verbose) {
   };
 }
 
-// src/utils.ts
-function debugLog2(category, message, verbose) {
-  if (verbose) {
-    console.debug(`[rpx:${category}] ${message}`);
-  }
-}
-function extractHostname(options3) {
-  if (isMultiProxyOptions(options3)) {
-    return options3.proxies.map((proxy) => {
-      const domain = proxy.to || "stacks.localhost";
-      return domain.startsWith("http") ? new URL(domain).hostname : domain;
-    });
-  }
-  if (isSingleProxyOptions(options3)) {
-    const domain = options3.to || "stacks.localhost";
-    return [domain.startsWith("http") ? new URL(domain).hostname : domain];
-  }
-  return ["stacks.localhost"];
-}
-function isValidRootCA(value) {
-  return typeof value === "object" && value !== null && "certificate" in value && "privateKey" in value && typeof value.certificate === "string" && typeof value.privateKey === "string";
-}
-
-// src/hosts.ts
-var hostsFilePath = process3.platform === "win32" ? path4.join(process3.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
-async function sudoWrite(operation, content) {
-  return new Promise((resolve4, reject) => {
-    if (process3.platform === "win32") {
-      reject(new Error("Administrator privileges required on Windows"));
-      return;
-    }
-    const tmpFile = path4.join(os3.tmpdir(), "hosts.tmp");
-    try {
-      if (operation === "append") {
-        const currentContent = fs5.readFileSync(hostsFilePath, "utf8");
-        fs5.writeFileSync(tmpFile, currentContent + content, "utf8");
-      } else {
-        fs5.writeFileSync(tmpFile, content, "utf8");
-      }
-      const sudo = spawn("sudo", ["cp", tmpFile, hostsFilePath]);
-      sudo.on("close", (code) => {
-        try {
-          fs5.unlinkSync(tmpFile);
-          if (code === 0)
-            resolve4();
-          else
-            reject(new Error(`sudo process exited with code ${code}`));
-        } catch (err3) {
-          reject(err3);
-        }
-      });
-      sudo.on("error", (err3) => {
-        try {
-          fs5.unlinkSync(tmpFile);
-        } catch {
-        }
-        reject(err3);
-      });
-    } catch (err3) {
-      reject(err3);
-    }
-  });
-}
-async function addHosts(hosts, verbose) {
-  debugLog2("hosts", `Adding hosts: ${hosts.join(", ")}`, verbose);
-  debugLog2("hosts", `Using hosts file at: ${hostsFilePath}`, verbose);
-  try {
-    const existingContent = await fs5.promises.readFile(hostsFilePath, "utf-8");
-    const newEntries = hosts.filter((host) => {
-      const ipv4Entry = `127.0.0.1 ${host}`;
-      const ipv6Entry = `::1 ${host}`;
-      return !existingContent.includes(ipv4Entry) && !existingContent.includes(ipv6Entry);
-    });
-    if (newEntries.length === 0) {
-      debugLog2("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) => `
-# Added by rpx
-127.0.0.1 ${host}
-::1 ${host}`).join(`
-`);
-    try {
-      await fs5.promises.appendFile(hostsFilePath, hostEntries, { flag: "a" });
-      log.success(`Added new hosts: ${newEntries.join(", ")}`);
-    } catch (writeErr) {
-      if (writeErr.code === "EACCES") {
-        debugLog2("hosts", "Permission denied, attempting with sudo", verbose);
-        try {
-          await sudoWrite("append", hostEntries);
-          log.success(`Added new hosts with sudo: ${newEntries.join(", ")}`);
-        } catch (sudoErr) {
-          log.error("Failed to modify hosts file automatically");
-          log.warn("Please add these entries to your hosts file manually:");
-          hostEntries.split(`
-`).forEach((entry) => log.warn(entry));
-          if (process3.platform === "win32") {
-            log.warn(`
-On Windows:`);
-            log.warn("1. Run notepad as administrator");
-            log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
-          } else {
-            log.warn(`
-On Unix systems:`);
-            log.warn(`sudo nano ${hostsFilePath}`);
-          }
-          throw new Error("Failed to modify hosts file: manual intervention required");
-        }
-      } else {
-        throw writeErr;
-      }
-    }
-  } catch (err3) {
-    const error = err3;
-    log.error(`Failed to manage hosts file: ${error.message}`);
-    throw error;
-  }
-}
-async function removeHosts(hosts, verbose) {
-  debugLog2("hosts", `Removing hosts: ${hosts.join(", ")}`, verbose);
-  try {
-    const content = await fs5.promises.readFile(hostsFilePath, "utf-8");
-    const lines = content.split(`
-`);
-    const filteredLines = lines.filter((line, index) => {
-      if (line.trim() === "# Added by rpx") {
-        lines.splice(index + 1, 2);
-        return false;
-      }
-      return true;
-    });
-    while (filteredLines[filteredLines.length - 1]?.trim() === "")
-      filteredLines.pop();
-    const newContent = `${filteredLines.join(`
-`)}
-`;
-    try {
-      await fs5.promises.writeFile(hostsFilePath, newContent);
-      log.success("Hosts removed successfully");
-    } catch (writeErr) {
-      if (writeErr.code === "EACCES") {
-        debugLog2("hosts", "Permission denied, attempting with sudo", verbose);
-        try {
-          await sudoWrite("write", newContent);
-          log.success("Hosts removed successfully with sudo");
-        } catch (sudoErr) {
-          log.error("Failed to modify hosts file automatically");
-          log.warn("Please remove these entries from your hosts file manually:");
-          hosts.forEach((host) => {
-            log.warn("# Added by rpx");
-            log.warn(`127.0.0.1 ${host}`);
-            log.warn(`::1 ${host}`);
-          });
-          if (process3.platform === "win32") {
-            log.warn(`
-On Windows:`);
-            log.warn("1. Run notepad as administrator");
-            log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
-          } else {
-            log.warn(`
-On Unix systems:`);
-            log.warn(`sudo nano ${hostsFilePath}`);
-          }
-          throw new Error("Failed to modify hosts file: manual intervention required");
-        }
-      } else {
-        throw writeErr;
-      }
-    }
-  } catch (err3) {
-    const error = err3;
-    log.error(`Failed to remove hosts: ${error.message}`);
-    throw error;
-  }
-}
-async function checkHosts(hosts, verbose) {
-  debugLog2("hosts", `Checking hosts: ${hosts}`, verbose);
-  const content = await fs5.promises.readFile(hostsFilePath, "utf-8");
-  return hosts.map((host) => {
-    const ipv4Entry = `127.0.0.1 ${host}`;
-    const ipv6Entry = `::1 ${host}`;
-    return content.includes(ipv4Entry) || content.includes(ipv6Entry);
-  });
-}
-
 // src/start.ts
 var activeServers = new Set;
 async function cleanup(options3) {
-  debugLog2("cleanup", "Starting cleanup process", options3?.verbose);
+  debugLog("cleanup", "Starting cleanup process", options3?.verbose);
   console.log(`
 `);
   log.info("Shutting down proxy servers...");
   const cleanupPromises = [];
   const serverClosePromises = Array.from(activeServers).map((server) => new Promise((resolve4) => {
     server.close(() => {
-      debugLog2("cleanup", "Server closed successfully", options3?.verbose);
+      debugLog("cleanup", "Server closed successfully", options3?.verbose);
       resolve4();
     });
   }));
   cleanupPromises.push(...serverClosePromises);
   if (options3?.etcHostsCleanup && options3.domains?.length) {
-    debugLog2("cleanup", "Cleaning up hosts file entries", options3?.verbose);
+    debugLog("cleanup", "Cleaning up hosts file entries", options3?.verbose);
     const domainsToClean = options3.domains.filter((domain) => !domain.includes("localhost"));
     if (domainsToClean.length > 0) {
       log.info("Cleaning up hosts file entries...");
       cleanupPromises.push(removeHosts(domainsToClean, options3?.verbose).then(() => {
-        debugLog2("cleanup", `Removed hosts entries for ${domainsToClean.join(", ")}`, options3?.verbose);
+        debugLog("cleanup", `Removed hosts entries for ${domainsToClean.join(", ")}`, options3?.verbose);
       }).catch((err3) => {
-        debugLog2("cleanup", `Failed to remove hosts entries: ${err3}`, options3?.verbose);
+        debugLog("cleanup", `Failed to remove hosts entries: ${err3}`, options3?.verbose);
         log.warn(`Failed to clean up hosts file entries for ${domainsToClean.join(", ")}:`, err3);
       }));
     }
   }
   try {
     await Promise.all(cleanupPromises);
-    debugLog2("cleanup", "All cleanup tasks completed successfully", options3?.verbose);
+    debugLog("cleanup", "All cleanup tasks completed successfully", options3?.verbose);
     log.success("All cleanup tasks completed successfully");
     process9.exit(0);
   } catch (err3) {
-    debugLog2("cleanup", `Error during cleanup: ${err3}`, options3?.verbose);
+    debugLog("cleanup", `Error during cleanup: ${err3}`, options3?.verbose);
     log.error("Error during cleanup:", err3);
     process9.exit(1);
   }
@@ -57559,22 +57520,22 @@ async function cleanup(options3) {
 process9.on("SIGINT", cleanup);
 process9.on("SIGTERM", cleanup);
 process9.on("uncaughtException", (err3) => {
-  debugLog2("process", `Uncaught exception: ${err3}`, true);
+  debugLog("process", `Uncaught exception: ${err3}`, true);
   log.error("Uncaught exception:", err3);
   cleanup();
 });
 function isPortInUse(port, hostname, verbose) {
-  debugLog2("port", `Checking if port ${port} is in use on ${hostname}`, verbose);
+  debugLog("port", `Checking if port ${port} is in use on ${hostname}`, verbose);
   return new Promise((resolve4) => {
     const server = net.createServer();
     server.once("error", (err3) => {
       if (err3.code === "EADDRINUSE") {
-        debugLog2("port", `Port ${port} is in use`, verbose);
+        debugLog("port", `Port ${port} is in use`, verbose);
         resolve4(true);
       }
     });
     server.once("listening", () => {
-      debugLog2("port", `Port ${port} is available`, verbose);
+      debugLog("port", `Port ${port} is available`, verbose);
       server.close();
       resolve4(false);
     });
@@ -57582,17 +57543,17 @@ function isPortInUse(port, hostname, verbose) {
   });
 }
 async function findAvailablePort(startPort, hostname, verbose) {
-  debugLog2("port", `Finding available port starting from ${startPort}`, verbose);
+  debugLog("port", `Finding available port starting from ${startPort}`, verbose);
   let port = startPort;
   while (await isPortInUse(port, hostname, verbose)) {
-    debugLog2("port", `Port ${port} is in use, trying ${port + 1}`, verbose);
+    debugLog("port", `Port ${port} is in use, trying ${port + 1}`, verbose);
     port++;
   }
-  debugLog2("port", `Found available port: ${port}`, verbose);
+  debugLog("port", `Found available port: ${port}`, verbose);
   return port;
 }
 async function testConnection(hostname, port, verbose) {
-  debugLog2("connection", `Testing connection to ${hostname}:${port}`, verbose);
+  debugLog("connection", `Testing connection to ${hostname}:${port}`, verbose);
   return new Promise((resolve4, reject) => {
     const socket = net.connect({
       host: hostname,
@@ -57600,30 +57561,30 @@ async function testConnection(hostname, port, verbose) {
       timeout: 5000
     });
     socket.once("connect", () => {
-      debugLog2("connection", `Successfully connected to ${hostname}:${port}`, verbose);
+      debugLog("connection", `Successfully connected to ${hostname}:${port}`, verbose);
       socket.end();
       resolve4();
     });
     socket.once("timeout", () => {
-      debugLog2("connection", `Connection to ${hostname}:${port} timed out`, verbose);
+      debugLog("connection", `Connection to ${hostname}:${port} timed out`, verbose);
       socket.destroy();
       reject(new Error(`Connection to ${hostname}:${port} timed out`));
     });
     socket.once("error", (err3) => {
-      debugLog2("connection", `Failed to connect to ${hostname}:${port}: ${err3}`, verbose);
+      debugLog("connection", `Failed to connect to ${hostname}:${port}: ${err3}`, verbose);
       socket.destroy();
       reject(new Error(`Failed to connect to ${hostname}:${port}: ${err3.message}`));
     });
   });
 }
 async function startServer(options3) {
-  debugLog2("server", `Starting server with options: ${JSON.stringify(options3)}`, options3.verbose);
+  debugLog("server", `Starting server with options: ${JSON.stringify(options3)}`, options3.verbose);
   const fromUrl = new URL((options3.from?.startsWith("http") ? options3.from : `http://${options3.from}`) || "localhost:5173");
   const toUrl = new URL((options3.to?.startsWith("http") ? options3.to : `http://${options3.to}`) || "stacks.localhost");
   const fromPort = Number.parseInt(fromUrl.port) || (fromUrl.protocol.includes("https:") ? 443 : 80);
   const hostsToCheck = [toUrl.hostname];
   if (!toUrl.hostname.includes("localhost") && !toUrl.hostname.includes("127.0.0.1")) {
-    debugLog2("hosts", `Checking if hosts file entry exists for: ${toUrl.hostname}`, options3?.verbose);
+    debugLog("hosts", `Checking if hosts file entry exists for: ${toUrl.hostname}`, options3?.verbose);
     try {
       const hostsExist = await checkHosts(hostsToCheck, options3.verbose);
       if (!hostsExist[0]) {
@@ -57646,7 +57607,7 @@ async function startServer(options3) {
           }
         }
       } else {
-        debugLog2("hosts", `Host entry already exists for ${toUrl.hostname}`, options3.verbose);
+        debugLog("hosts", `Host entry already exists for ${toUrl.hostname}`, options3.verbose);
       }
     } catch (checkError) {
       log.error("Failed to check hosts file:", checkError.message);
@@ -57655,7 +57616,7 @@ async function startServer(options3) {
   try {
     await testConnection(fromUrl.hostname, fromPort, options3.verbose);
   } catch (err3) {
-    debugLog2("server", `Connection test failed: ${err3}`, options3.verbose);
+    debugLog("server", `Connection test failed: ${err3}`, options3.verbose);
     log.error(err3.message);
     process9.exit(1);
   }
@@ -57669,17 +57630,17 @@ async function startServer(options3) {
         });
       }
       try {
-        debugLog2("ssl", `Attempting to load SSL configuration for ${toUrl.hostname}`, options3.verbose);
+        debugLog("ssl", `Attempting to load SSL configuration for ${toUrl.hostname}`, options3.verbose);
         sslConfig = await loadSSLConfig({
           ...options3,
           to: toUrl.hostname,
           https: options3.https
         });
       } catch (loadError) {
-        debugLog2("ssl", `Failed to load certificates, will generate new ones: ${loadError}`, options3.verbose);
+        debugLog("ssl", `Failed to load certificates, will generate new ones: ${loadError}`, options3.verbose);
       }
       if (!sslConfig) {
-        debugLog2("ssl", `Generating new certificates for ${toUrl.hostname}`, options3.verbose);
+        debugLog("ssl", `Generating new certificates for ${toUrl.hostname}`, options3.verbose);
         await generateCertificate2({
           ...options3,
           from: fromUrl.toString(),
@@ -57696,11 +57657,11 @@ async function startServer(options3) {
         }
       }
     } catch (err3) {
-      debugLog2("server", `SSL setup failed: ${err3}`, options3.verbose);
+      debugLog("server", `SSL setup failed: ${err3}`, options3.verbose);
       throw err3;
     }
   }
-  debugLog2("server", `Setting up reverse proxy with SSL config for ${toUrl.hostname}`, options3.verbose);
+  debugLog("server", `Setting up reverse proxy with SSL config for ${toUrl.hostname}`, options3.verbose);
   await setupReverseProxy({
     ...options3,
     from: options3.from || "localhost:5173",
@@ -57713,23 +57674,69 @@ async function startServer(options3) {
     ssl: sslConfig
   });
 }
-async function createProxyServer(from, to, fromPort, listenPort, hostname, sourceUrl, ssl, verbose) {
-  debugLog2("proxy", `Creating proxy server ${from} -> ${to}`, verbose);
+async function createProxyServer(from, to, fromPort, listenPort, hostname, sourceUrl, ssl, verbose, cleanUrls) {
+  debugLog("proxy", `Creating proxy server ${from} -> ${to} with cleanUrls: ${cleanUrls}`, verbose);
   const requestHandler = (req, res) => {
-    debugLog2("request", `Incoming request: ${req.method} ${req.url}`, verbose);
+    debugLog("request", `Incoming request: ${req.method} ${req.url}`, verbose);
+    let path4 = req.url || "/";
+    if (cleanUrls) {
+      if (!path4.match(/\.[a-z0-9]+$/i)) {
+        if (path4.endsWith("/")) {
+          path4 = `${path4}index.html`;
+        } else {
+          path4 = `${path4}.html`;
+        }
+      }
+    }
     const proxyOptions = {
       hostname: sourceUrl.hostname,
       port: fromPort,
-      path: req.url,
+      path: path4,
       method: req.method,
       headers: {
         ...req.headers,
         host: sourceUrl.host
       }
     };
-    debugLog2("request", `Proxy request options: ${JSON.stringify(proxyOptions)}`, verbose);
+    debugLog("request", `Proxy request options: ${JSON.stringify(proxyOptions)}`, verbose);
     const proxyReq = http.request(proxyOptions, (proxyRes) => {
-      debugLog2("response", `Proxy response received with status ${proxyRes.statusCode}`, verbose);
+      debugLog("response", `Proxy response received with status ${proxyRes.statusCode}`, verbose);
+      if (cleanUrls && proxyRes.statusCode === 404) {
+        const alternativePaths = [];
+        if (path4.endsWith(".html")) {
+          alternativePaths.push(path4.slice(0, -5));
+        } else if (!path4.match(/\.[a-z0-9]+$/i)) {
+          alternativePaths.push(`${path4}.html`);
+        }
+        if (!path4.endsWith("/")) {
+          alternativePaths.push(`${path4}/index.html`);
+        }
+        if (alternativePaths.length > 0) {
+          debugLog("cleanUrls", `Trying alternative paths: ${alternativePaths.join(", ")}`, verbose);
+          const tryNextPath = (paths) => {
+            if (paths.length === 0) {
+              res.writeHead(proxyRes.statusCode || 404, proxyRes.headers);
+              proxyRes.pipe(res);
+              return;
+            }
+            const altPath = paths[0];
+            const altOptions = { ...proxyOptions, path: altPath };
+            const altReq = http.request(altOptions, (altRes) => {
+              if (altRes.statusCode === 200) {
+                debugLog("cleanUrls", `Found matching path: ${altPath}`, verbose);
+                res.writeHead(altRes.statusCode, altRes.headers);
+                altRes.pipe(res);
+              } else {
+                tryNextPath(paths.slice(1));
+              }
+            });
+            altReq.on("error", () => tryNextPath(paths.slice(1)));
+            altReq.end();
+          };
+          tryNextPath(alternativePaths);
+          return;
+        }
+      }
       const headers = {
         ...proxyRes.headers,
         "Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
@@ -57739,7 +57746,7 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
       proxyRes.pipe(res);
     });
     proxyReq.on("error", (err3) => {
-      debugLog2("request", `Proxy request failed: ${err3}`, verbose);
+      debugLog("request", `Proxy request failed: ${err3}`, verbose);
       log.error("Proxy request failed:", err3);
       res.writeHead(502);
       res.end(`Proxy Error: ${err3.message}`);
@@ -57766,11 +57773,11 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
     allowHTTP1: true,
     ALPNProtocols: ["h2", "http/1.1"]
   } : undefined;
-  debugLog2("server", `Creating server with SSL config: ${!!ssl}`, verbose);
+  debugLog("server", `Creating server with SSL config: ${!!ssl}`, verbose);
   const server = ssl && serverOptions ? https.createServer(serverOptions, requestHandler) : http.createServer(requestHandler);
   if (ssl) {
     server.on("secureConnection", (tlsSocket) => {
-      debugLog2("tls", `TLS Connection established: ${JSON.stringify({
+      debugLog("tls", `TLS Connection established: ${JSON.stringify({
         protocol: tlsSocket.getProtocol?.(),
         cipher: tlsSocket.getCipher?.(),
         authorized: tlsSocket.authorized,
@@ -57781,7 +57788,7 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
   activeServers.add(server);
   return new Promise((resolve4, reject) => {
     server.listen(listenPort, hostname, () => {
-      debugLog2("server", `Server listening on port ${listenPort}`, verbose);
+      debugLog("server", `Server listening on port ${listenPort}`, verbose);
       console.log("");
       console.log(`  ${green(bold("reverse-proxy"))} ${green(`v${version}`)}`);
       console.log("");
@@ -57795,16 +57802,19 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
         console.log(`     - HTTP/2 enabled`);
         console.log(`     - HSTS enabled`);
       }
+      if (cleanUrls) {
+        console.log(`  ${green("\u279C")}  Clean URLs enabled`);
+      }
       resolve4();
     });
     server.on("error", (err3) => {
-      debugLog2("server", `Server error: ${err3}`, verbose);
+      debugLog("server", `Server error: ${err3}`, verbose);
       reject(err3);
     });
   });
 }
 async function setupReverseProxy(options3) {
-  debugLog2("setup", `Setting up reverse proxy: ${JSON.stringify(options3)}`, options3.verbose);
+  debugLog("setup", `Setting up reverse proxy: ${JSON.stringify(options3)}`, options3.verbose);
   const { from, to, fromPort, sourceUrl, ssl, verbose, etcHostsCleanup, portManager } = options3;
   const httpPort = 80;
   const httpsPort = 443;
@@ -57813,11 +57823,11 @@ async function setupReverseProxy(options3) {
     if (ssl && !portManager?.usedPorts.has(httpPort)) {
       const isHttpPortBusy = await isPortInUse(httpPort, hostname, verbose);
       if (!isHttpPortBusy) {
-        debugLog2("setup", "Starting HTTP redirect server", verbose);
+        debugLog("setup", "Starting HTTP redirect server", verbose);
         startHttpRedirectServer(verbose);
         portManager?.usedPorts.add(httpPort);
       } else {
-        debugLog2("setup", "Port 80 is in use, skipping HTTP redirect", verbose);
+        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");
       }
     }
@@ -57835,7 +57845,7 @@ async function setupReverseProxy(options3) {
     }
     await createProxyServer(from, to, fromPort, finalPort, hostname, sourceUrl, ssl, verbose);
   } catch (err3) {
-    debugLog2("setup", `Setup failed: ${err3}`, verbose);
+    debugLog("setup", `Setup failed: ${err3}`, verbose);
     log.error(`Failed to setup reverse proxy: ${err3.message}`);
     cleanup({
       domains: [to],
@@ -57845,34 +57855,35 @@ async function setupReverseProxy(options3) {
   }
 }
 function startHttpRedirectServer(verbose) {
-  debugLog2("redirect", "Starting HTTP redirect server", verbose);
+  debugLog("redirect", "Starting HTTP redirect server", verbose);
   const server = http.createServer((req, res) => {
     const host = req.headers.host || "";
-    debugLog2("redirect", `Redirecting request from ${host}${req.url} to HTTPS`, verbose);
+    debugLog("redirect", `Redirecting request from ${host}${req.url} to HTTPS`, verbose);
     res.writeHead(301, {
       Location: `https://${host}${req.url}`
     });
     res.end();
   }).listen(80);
   activeServers.add(server);
-  debugLog2("redirect", "HTTP redirect server started", verbose);
+  debugLog("redirect", "HTTP redirect server started", verbose);
 }
 function startProxy(options3) {
   const mergedOptions = {
     ...config4,
     ...options3
   };
-  debugLog2("proxy", `Starting proxy with options: ${JSON.stringify(mergedOptions)}`, mergedOptions?.verbose);
+  debugLog("proxy", `Starting proxy with options: ${JSON.stringify(mergedOptions)}`, mergedOptions?.verbose);
   const serverOptions = {
     from: mergedOptions.from,
     to: mergedOptions.to,
+    cleanUrls: mergedOptions.cleanUrls,
     https: httpsConfig(mergedOptions),
     etcHostsCleanup: mergedOptions.etcHostsCleanup,
     verbose: mergedOptions.verbose
   };
   console.log("serverOptions", serverOptions);
   startServer(serverOptions).catch((err3) => {
-    debugLog2("proxy", `Failed to start proxy: ${err3}`, mergedOptions.verbose);
+    debugLog("proxy", `Failed to start proxy: ${err3}`, mergedOptions.verbose);
     log.error(`Failed to start proxy: ${err3.message}`);
     cleanup({
       domains: [mergedOptions.to],
@@ -57882,7 +57893,7 @@ function startProxy(options3) {
   });
 }
 async function startProxies(options3) {
-  debugLog2("proxies", "Starting proxy setup", options3?.verbose);
+  debugLog("proxies", "Starting proxy setup", options3?.verbose);
   const mergedOptions = {
     ...config4,
     ...options3
@@ -57891,10 +57902,10 @@ async function startProxies(options3) {
   if (mergedOptions.https) {
     const existingSSLConfig = await checkExistingCertificates(mergedOptions);
     if (existingSSLConfig) {
-      debugLog2("ssl", `Using existing certificates for ${primaryDomain}`, mergedOptions.verbose);
+      debugLog("ssl", `Using existing certificates for ${primaryDomain}`, mergedOptions.verbose);
       mergedOptions._cachedSSLConfig = existingSSLConfig;
     } else {
-      debugLog2("ssl", `No valid certificates found for ${primaryDomain}, generating new ones`, mergedOptions.verbose);
+      debugLog("ssl", `No valid certificates found for ${primaryDomain}, generating new ones`, mergedOptions.verbose);
       await generateCertificate2(mergedOptions);
       const sslConfig2 = await checkExistingCertificates(mergedOptions);
       if (!sslConfig2) {
@@ -57907,11 +57918,13 @@ async function startProxies(options3) {
     ...proxy,
     https: mergedOptions.https,
     etcHostsCleanup: mergedOptions.etcHostsCleanup,
+    cleanUrls: mergedOptions.cleanUrls,
     verbose: mergedOptions.verbose,
     _cachedSSLConfig: mergedOptions._cachedSSLConfig
   })) : [{
     from: mergedOptions.from || "localhost:5173",
     to: mergedOptions.to || "stacks.localhost",
+    cleanUrls: mergedOptions.cleanUrls || false,
     https: mergedOptions.https,
     etcHostsCleanup: mergedOptions.etcHostsCleanup,
     verbose: mergedOptions.verbose,
@@ -57927,24 +57940,25 @@ async function startProxies(options3) {
   process9.on("SIGINT", cleanupHandler);
   process9.on("SIGTERM", cleanupHandler);
   process9.on("uncaughtException", (err3) => {
-    debugLog2("process", `Uncaught exception: ${err3}`, true);
+    debugLog("process", `Uncaught exception: ${err3}`, true);
     console.error("Uncaught exception:", err3);
     cleanupHandler();
   });
   for (const option of proxyOptions) {
     try {
       const domain = option.to || "stacks.localhost";
-      debugLog2("proxy", `Starting proxy for ${domain} with SSL config: ${!!sslConfig}`, option.verbose);
+      debugLog("proxy", `Starting proxy for ${domain} with SSL config: ${!!sslConfig}`, option.verbose);
       await startServer({
         from: option.from || "localhost:5173",
         to: domain,
-        https: option.https ?? false,
+        cleanUrls: option.cleanUrls || false,
+        https: option.https || false,
         etcHostsCleanup: option.etcHostsCleanup || false,
         verbose: option.verbose || false,
         _cachedSSLConfig: sslConfig
       });
     } catch (err3) {
-      debugLog2("proxies", `Failed to start proxy for ${option.to}: ${err3}`, option.verbose);
+      debugLog("proxies", `Failed to start proxy for ${option.to}: ${err3}`, option.verbose);
       console.error(`Failed to start proxy for ${option.to}:`, err3);
       cleanupHandler();
     }
@@ -57976,7 +57990,7 @@ export {
   generateCertificate2 as generateCertificate,
   extractHostname,
   src_default as default,
-  debugLog2 as debugLog,
+  debugLog,
   config4 as config,
   cleanup,
   checkHosts,