@stacksjs/rpx 0.1.1 → 0.3.0

package/dist/index.js

@@ -77,14 +77,15 @@ var config = await loadConfig({
       validityDays: 180,
       verbose: false
     },
+    etcHostsCleanup: false,
     verbose: true
   }
 });
-// src/start.ts
-import * as fs3 from "fs";
-import * as http from "http";
-import * as https from "https";
-import * as net from "net";
+// src/hosts.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import os3 from "os";
+import path2 from "path";
 import process3 from "process";
 
 // node_modules/@stacksjs/cli/dist/index.js
@@ -20395,8 +20396,167 @@ var quotes = collect([
   "Security is mostly a superstition. Life is either a daring adventure or nothing."
 ]);
 var export_prompts = import_prompts.default;
-// package.json
-var version = "0.1.1";
+
+// src/utils.ts
+function debugLog(category, message, verbose) {
+  if (verbose || config.verbose) {
+    console.debug(`[rpx:${category}] ${message}`);
+  }
+}
+
+// src/hosts.ts
+var hostsFilePath = process3.platform === "win32" ? path2.join(process3.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
+async function sudoWrite(operation, content) {
+  return new Promise((resolve3, reject) => {
+    if (process3.platform === "win32") {
+      reject(new Error("Administrator privileges required on Windows"));
+      return;
+    }
+    const tmpFile = path2.join(os3.tmpdir(), "hosts.tmp");
+    try {
+      if (operation === "append") {
+        const currentContent = fs.readFileSync(hostsFilePath, "utf8");
+        fs.writeFileSync(tmpFile, currentContent + content, "utf8");
+      } else {
+        fs.writeFileSync(tmpFile, content, "utf8");
+      }
+      const sudo = spawn("sudo", ["cp", tmpFile, hostsFilePath]);
+      sudo.on("close", (code) => {
+        try {
+          fs.unlinkSync(tmpFile);
+          if (code === 0)
+            resolve3();
+          else
+            reject(new Error(`sudo process exited with code ${code}`));
+        } catch (err2) {
+          reject(err2);
+        }
+      });
+      sudo.on("error", (err2) => {
+        try {
+          fs.unlinkSync(tmpFile);
+        } catch {
+        }
+        reject(err2);
+      });
+    } catch (err2) {
+      reject(err2);
+    }
+  });
+}
+async function addHosts(hosts) {
+  debugLog("hosts", `Adding hosts: ${hosts.join(", ")}`, config.verbose);
+  debugLog("hosts", `Using hosts file at: ${hostsFilePath}`, config.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", config.verbose);
+      log.info("All hosts are already in the hosts file");
+      return;
+    }
+    const hostEntries = newEntries.map((host) => `\n# Added by rpx\n127.0.0.1 ${host}\n::1 ${host}`).join("\n");
+    try {
+      await fs.promises.appendFile(hostsFilePath, hostEntries, { flag: "a" });
+      log.success(`Added new hosts: ${newEntries.join(", ")}`);
+    } catch (writeErr) {
+      if (writeErr.code === "EACCES") {
+        debugLog("hosts", "Permission denied, attempting with sudo", config.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("\n").forEach((entry) => log.warn(entry));
+          if (process3.platform === "win32") {
+            log.warn("\nOn Windows:");
+            log.warn("1. Run notepad as administrator");
+            log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
+          } else {
+            log.warn("\nOn Unix systems:");
+            log.warn(`sudo nano ${hostsFilePath}`);
+          }
+          throw new Error("Failed to modify hosts file: manual intervention required");
+        }
+      } else {
+        throw writeErr;
+      }
+    }
+  } catch (err2) {
+    const error = err2;
+    log.error(`Failed to manage hosts file: ${error.message}`);
+    throw error;
+  }
+}
+async function removeHosts(hosts) {
+  debugLog("hosts", `Removing hosts: ${hosts.join(", ")}`, config.verbose);
+  try {
+    const content = await fs.promises.readFile(hostsFilePath, "utf-8");
+    const lines = content.split("\n");
+    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("\n")}\n`;
+    try {
+      await fs.promises.writeFile(hostsFilePath, newContent);
+      log.success("Hosts removed successfully");
+    } catch (writeErr) {
+      if (writeErr.code === "EACCES") {
+        debugLog("hosts", "Permission denied, attempting with sudo", config.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("\nOn Windows:");
+            log.warn("1. Run notepad as administrator");
+            log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
+          } else {
+            log.warn("\nOn Unix systems:");
+            log.warn(`sudo nano ${hostsFilePath}`);
+          }
+          throw new Error("Failed to modify hosts file: manual intervention required");
+        }
+      } else {
+        throw writeErr;
+      }
+    }
+  } catch (err2) {
+    const error = err2;
+    log.error(`Failed to remove hosts: ${error.message}`);
+    throw error;
+  }
+}
+async function checkHosts(hosts) {
+  debugLog("hosts", `Checking hosts: ${hosts}`, config.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 os7 from "os";
+import path6 from "path";
 
 // node_modules/@stacksjs/tlsx/dist/index.js
 import fs2 from "fs";
@@ -20435,7 +20595,7 @@ import process8 from "process";
 import process102 from "process";
 import process182 from "process";
 import process112 from "process";
-import os3 from "os";
+import os5 from "os";
 import tty32 from "tty";
 import process142 from "process";
 import process132 from "process";
@@ -20444,10 +20604,10 @@ import process162 from "process";
 import process172 from "process";
 import process192 from "process";
 import os22 from "os";
-import path2 from "path";
+import path4 from "path";
 import { resolve as resolve3 } from "path";
 import process22 from "process";
-import fs from "fs";
+import fs3 from "fs";
 import path22 from "path";
 var __create3 = Object.create;
 var __getProtoOf3 = Object.getPrototypeOf;
@@ -32497,14 +32657,14 @@ var require_tls = __commonJS2((exports, module) => {
       c2.version = c2.session.version = session.version;
       c2.session.sp = session.sp;
     } else {
-      var version2;
+      var version;
       for (var i = 1;i < tls.SupportedVersions.length; ++i) {
-        version2 = tls.SupportedVersions[i];
-        if (version2.minor <= msg.version.minor) {
+        version = tls.SupportedVersions[i];
+        if (version.minor <= msg.version.minor) {
           break;
         }
       }
-      c2.version = { major: version2.major, minor: version2.minor };
+      c2.version = { major: version.major, minor: version.minor };
       c2.session.version = c2.version;
     }
     if (session !== null) {
@@ -32675,8 +32835,8 @@ var require_tls = __commonJS2((exports, module) => {
     try {
       var sp = c2.session.sp;
       sp.pre_master_secret = privateKey.decrypt(msg.enc_pre_master_secret);
-      var version2 = c2.session.clientHelloVersion;
-      if (version2.major !== sp.pre_master_secret.charCodeAt(0) || version2.minor !== sp.pre_master_secret.charCodeAt(1)) {
+      var version = c2.session.clientHelloVersion;
+      if (version.major !== sp.pre_master_secret.charCodeAt(0) || version.minor !== sp.pre_master_secret.charCodeAt(1)) {
         throw new Error("TLS version rollback attack detected.");
       }
     } catch (ex) {
@@ -38619,16 +38779,16 @@ var require_isIP2 = __commonJS22((exports, module) => {
   var IPv6SegmentFormat = "(?:[0-9a-fA-F]{1,4})";
   var IPv6AddressRegExp = new RegExp("^(" + "(?:".concat(IPv6SegmentFormat, ":){7}(?:").concat(IPv6SegmentFormat, "|:)|") + "(?:".concat(IPv6SegmentFormat, ":){6}(?:").concat(IPv4AddressFormat, "|:").concat(IPv6SegmentFormat, "|:)|") + "(?:".concat(IPv6SegmentFormat, ":){5}(?::").concat(IPv4AddressFormat, "|(:").concat(IPv6SegmentFormat, "){1,2}|:)|") + "(?:".concat(IPv6SegmentFormat, ":){4}(?:(:").concat(IPv6SegmentFormat, "){0,1}:").concat(IPv4AddressFormat, "|(:").concat(IPv6SegmentFormat, "){1,3}|:)|") + "(?:".concat(IPv6SegmentFormat, ":){3}(?:(:").concat(IPv6SegmentFormat, "){0,2}:").concat(IPv4AddressFormat, "|(:").concat(IPv6SegmentFormat, "){1,4}|:)|") + "(?:".concat(IPv6SegmentFormat, ":){2}(?:(:").concat(IPv6SegmentFormat, "){0,3}:").concat(IPv4AddressFormat, "|(:").concat(IPv6SegmentFormat, "){1,5}|:)|") + "(?:".concat(IPv6SegmentFormat, ":){1}(?:(:").concat(IPv6SegmentFormat, "){0,4}:").concat(IPv4AddressFormat, "|(:").concat(IPv6SegmentFormat, "){1,6}|:)|") + "(?::((?::".concat(IPv6SegmentFormat, "){0,5}:").concat(IPv4AddressFormat, "|(?::").concat(IPv6SegmentFormat, "){1,7}|:))") + ")(%[0-9a-zA-Z-.:]{1,})?$");
   function isIP(str) {
-    var version2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    var version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
     (0, _assertString.default)(str);
-    version2 = String(version2);
-    if (!version2) {
+    version = String(version);
+    if (!version) {
       return isIP(str, 4) || isIP(str, 6);
     }
-    if (version2 === "4") {
+    if (version === "4") {
       return IPv4AddressRegExp.test(str);
     }
-    if (version2 === "6") {
+    if (version === "6") {
       return IPv6AddressRegExp.test(str);
     }
     return false;
@@ -39150,9 +39310,9 @@ var require_isUUID2 = __commonJS22((exports, module) => {
     7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
     all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
   };
-  function isUUID(str, version2) {
+  function isUUID(str, version) {
     (0, _assertString.default)(str);
-    var pattern = uuid[![undefined, null].includes(version2) ? version2 : "all"];
+    var pattern = uuid[![undefined, null].includes(version) ? version : "all"];
     return !!pattern && pattern.test(str);
   }
   module.exports = exports.default;
@@ -51329,7 +51489,7 @@ var uuidRule2 = createRule2((value, options2, field) => {
       field.report(messages2.uuid, "uuid", field);
     }
   } else {
-    const matchesAnyVersion = options2.version.find((version2) => helpers32.isUUID(value, version2));
+    const matchesAnyVersion = options2.version.find((version) => helpers32.isUUID(value, version));
     if (!matchesAnyVersion) {
       field.report(messages2.uuid, "uuid", field, options2);
     }
@@ -51424,8 +51584,8 @@ var VineString2 = class _VineString2 extends BaseLiteralType2 {
   mobile(...args) {
     return this.use(mobileRule2(...args));
   }
-  ipAddress(version2) {
-    return this.use(ipAddressRule2(version2 ? { version: version2 } : undefined));
+  ipAddress(version) {
+    return this.use(ipAddressRule2(version ? { version } : undefined));
   }
   hexCode() {
     return this.use(hexCodeRule2());
@@ -53938,7 +54098,7 @@ function _supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process112.platform === "win32") {
-    const osRelease = os3.release().split(".");
+    const osRelease = os5.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -56505,18 +56665,18 @@ var config42 = await loadConfig2({
   defaultConfig: {
     altNameIPs: ["127.0.0.1"],
     altNameURIs: ["localhost"],
-    organizationName: "stacksjs.org",
+    organizationName: "Local Development",
     countryName: "US",
     stateName: "California",
     localityName: "Playa Vista",
     commonName: "stacks.localhost",
     validityDays: 180,
     hostCertCN: "stacks.localhost",
-    domain: "localhost",
+    domain: "stacks.localhost",
     rootCAObject: { certificate: "", privateKey: "" },
-    caCertPath: path2.join(os22.homedir(), ".stacks", "ssl", `tlsx.localhost.ca.crt`),
-    certPath: path2.join(os22.homedir(), ".stacks", "ssl", `tlsx.localhost.crt`),
-    keyPath: path2.join(os22.homedir(), ".stacks", "ssl", `tlsx.localhost.crt.key`),
+    caCertPath: path4.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.ca.crt`),
+    certPath: path4.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.crt`),
+    keyPath: path4.join(os22.homedir(), ".stacks", "ssl", `stacks.localhost.crt.key`),
     verbose: false
   }
 });
@@ -56532,10 +56692,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 = path22.join(dir, file);
-        const stats = fs.lstatSync(filePath);
+        const stats = fs3.lstatSync(filePath);
         if (stats.isDirectory()) {
           search(filePath);
         } else if (file === fileName) {
@@ -56549,29 +56709,29 @@ 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 randomSerialNumber(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 getCertNotBefore(verbose) {
-  debugLog("cert", "Calculating certificate not-before date", verbose);
+  debugLog2("cert", "Calculating certificate not-before date", verbose);
   const twoDaysAgo = new Date(Date.now() - 172800000);
   const year = twoDaysAgo.getFullYear();
   const month = (twoDaysAgo.getMonth() + 1).toString().padStart(2, "0");
   const day = twoDaysAgo.getDate().toString().padStart(2, "0");
   const date = new Date(`${year}-${month}-${day}T23:59:59Z`);
-  debugLog("cert", `Certificate not-before date: ${date.toISOString()}`, verbose);
+  debugLog2("cert", `Certificate not-before date: ${date.toISOString()}`, verbose);
   return date;
 }
 function getCertNotAfter(notBefore, verbose) {
-  debugLog("cert", "Calculating certificate not-after date", verbose);
+  debugLog2("cert", "Calculating certificate not-after date", verbose);
   const validityDays = config42.validityDays;
   const daysInMillis = validityDays * 60 * 60 * 24 * 1000;
   const notAfterDate = new Date(notBefore.getTime() + daysInMillis);
@@ -56579,27 +56739,27 @@ function getCertNotAfter(notBefore, verbose) {
   const month = (notAfterDate.getMonth() + 1).toString().padStart(2, "0");
   const day = notAfterDate.getDate().toString().padStart(2, "0");
   const date = new Date(`${year}-${month}-${day}T23:59:59Z`);
-  debugLog("cert", `Certificate not-after date: ${date.toISOString()} (${validityDays} days validity)`, verbose);
+  debugLog2("cert", `Certificate not-after date: ${date.toISOString()} (${validityDays} days validity)`, verbose);
   return date;
 }
 function getCANotAfter(notBefore, verbose) {
-  debugLog("cert", "Calculating CA not-after date", verbose);
+  debugLog2("cert", "Calculating CA not-after date", verbose);
   const year = notBefore.getFullYear() + 100;
   const month = (notBefore.getMonth() + 1).toString().padStart(2, "0");
   const day = notBefore.getDate().toString().padStart(2, "0");
   const date = new Date(`${year}-${month}-${day}T23:59:59Z`);
-  debugLog("cert", `CA not-after date: ${date.toISOString()} (100 years validity)`, verbose);
+  debugLog2("cert", `CA not-after date: ${date.toISOString()} (100 years validity)`, verbose);
   return date;
 }
 async function createRootCA(options22) {
-  debugLog("ca", "Creating new Root CA Certificate", options22?.verbose);
-  debugLog("ca", "Generating 2048-bit RSA key pair", options22?.verbose);
+  debugLog2("ca", "Creating new Root CA Certificate", options22?.verbose);
+  debugLog2("ca", "Generating 2048-bit RSA key pair", options22?.verbose);
   const { privateKey, publicKey } = import_node_forge2.pki.rsa.generateKeyPair(2048);
   const mergedOptions = {
     ...config42,
     ...options22 || {}
   };
-  debugLog("ca", "Setting certificate attributes", options22?.verbose);
+  debugLog2("ca", "Setting certificate attributes", options22?.verbose);
   const attributes = [
     { shortName: "C", value: mergedOptions.countryName },
     { shortName: "ST", value: mergedOptions.stateName },
@@ -56607,7 +56767,7 @@ async function createRootCA(options22) {
     { shortName: "O", value: "Local Development CA" },
     { shortName: "CN", value: "Local Development Root CA" }
   ];
-  debugLog("ca", "Setting certificate extensions", options22?.verbose);
+  debugLog2("ca", "Setting certificate extensions", options22?.verbose);
   const extensions = [
     {
       name: "basicConstraints",
@@ -56624,7 +56784,7 @@ async function createRootCA(options22) {
       name: "subjectKeyIdentifier"
     }
   ];
-  debugLog("ca", "Creating CA certificate", options22?.verbose);
+  debugLog2("ca", "Creating CA certificate", options22?.verbose);
   const caCert = import_node_forge2.pki.createCertificate();
   caCert.publicKey = publicKey;
   caCert.serialNumber = randomSerialNumber(options22?.verbose);
@@ -56633,11 +56793,11 @@ async function createRootCA(options22) {
   caCert.setSubject(attributes);
   caCert.setIssuer(attributes);
   caCert.setExtensions(extensions);
-  debugLog("ca", "Signing certificate with SHA-256", options22?.verbose);
+  debugLog2("ca", "Signing certificate with SHA-256", options22?.verbose);
   caCert.sign(privateKey, import_node_forge2.default.md.sha256.create());
   const pemCert = import_node_forge2.pki.certificateToPem(caCert);
   const pemKey = import_node_forge2.pki.privateKeyToPem(privateKey);
-  debugLog("ca", "Root CA Certificate created successfully", options22?.verbose);
+  debugLog2("ca", "Root CA Certificate created successfully", options22?.verbose);
   return {
     certificate: pemCert,
     privateKey: pemKey,
@@ -56646,34 +56806,41 @@ async function createRootCA(options22) {
   };
 }
 async function generateCert(options22) {
-  debugLog("cert", "Generating new host certificate", options22?.verbose);
-  debugLog("cert", `Options: ${JSON.stringify(options22)}`, options22?.verbose);
+  debugLog2("cert", "Generating new host certificate", options22?.verbose);
+  debugLog2("cert", `Options: ${JSON.stringify(options22)}`, options22?.verbose);
   if (!options22?.hostCertCN?.trim()) {
-    debugLog("cert", "Error: hostCertCN is required", options22?.verbose);
+    debugLog2("cert", "Error: hostCertCN is required", options22?.verbose);
     throw new Error('"hostCertCN" must be a String');
   }
   if (!options22.domain?.trim()) {
-    debugLog("cert", "Error: domain is required", options22?.verbose);
+    debugLog2("cert", "Error: domain is required", options22?.verbose);
     throw new Error('"domain" must be a String');
   }
   if (!options22.rootCAObject || !options22.rootCAObject.certificate || !options22.rootCAObject.privateKey) {
-    debugLog("cert", "Error: rootCAObject is invalid or missing", options22?.verbose);
+    debugLog2("cert", "Error: rootCAObject is invalid or missing", options22?.verbose);
     throw new Error('"rootCAObject" must be an Object with the properties "certificate" & "privateKey"');
   }
-  debugLog("cert", "Converting Root CA PEM to forge objects", options22?.verbose);
+  debugLog2("cert", "Converting Root CA PEM to forge objects", options22?.verbose);
   const caCert = import_node_forge2.pki.certificateFromPem(options22.rootCAObject.certificate);
   const caKey = import_node_forge2.pki.privateKeyFromPem(options22.rootCAObject.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 hostKeys = import_node_forge2.pki.rsa.generateKeyPair(2048);
-  debugLog("cert", "Setting certificate attributes", options22?.verbose);
+  debugLog2("cert", "Setting certificate attributes", options22?.verbose);
   const attributes = [
-    { shortName: "C", value: config42.countryName },
-    { shortName: "ST", value: config42.stateName },
-    { shortName: "L", value: config42.localityName },
-    { shortName: "O", value: "Local Development" },
-    { shortName: "CN", value: "*.localhost" }
+    { shortName: "C", value: options22.countryName || config42.countryName },
+    { shortName: "ST", value: options22.stateName || config42.stateName },
+    { shortName: "L", value: options22.localityName || config42.localityName },
+    { shortName: "O", value: options22.organizationName || config42.organizationName },
+    { shortName: "CN", value: options22.commonName || config42.commonName }
+  ];
+  const domain = options22.domain || config42.domain;
+  const wildcardDomain = `*.${domain.includes(".") ? domain.split(".").slice(1).join(".") : domain}`;
+  const altNames = [
+    { type: 2, value: wildcardDomain },
+    { type: 2, value: "localhost" },
+    { type: 2, value: domain }
   ];
-  debugLog("cert", "Setting certificate extensions", options22?.verbose);
+  debugLog2("cert", "Setting certificate extensions", options22?.verbose);
   const extensions = [
     {
       name: "basicConstraints",
@@ -56693,30 +56860,25 @@ async function generateCert(options22) {
     },
     {
       name: "subjectAltName",
-      altNames: [
-        { type: 2, value: "*.localhost" },
-        { type: 2, value: "localhost" },
-        { type: 2, value: "stacks.localhost" },
-        { type: 2, value: options22.domain }
-      ]
+      altNames
     }
   ];
-  debugLog("cert", "Creating new host certificate", options22?.verbose);
+  debugLog2("cert", "Creating new host certificate", options22?.verbose);
   const newHostCert = import_node_forge2.pki.createCertificate();
   newHostCert.publicKey = hostKeys.publicKey;
-  debugLog("cert", "Setting certificate properties", options22?.verbose);
+  debugLog2("cert", "Setting certificate properties", options22?.verbose);
   newHostCert.serialNumber = randomSerialNumber(options22?.verbose);
   newHostCert.validity.notBefore = getCertNotBefore(options22?.verbose);
   newHostCert.validity.notAfter = getCertNotAfter(newHostCert.validity.notBefore, options22?.verbose);
   newHostCert.setSubject(attributes);
   newHostCert.setIssuer(caCert.subject.attributes);
   newHostCert.setExtensions(extensions);
-  debugLog("cert", "Signing certificate with SHA-256", options22?.verbose);
+  debugLog2("cert", "Signing certificate with SHA-256", options22?.verbose);
   newHostCert.sign(caKey, import_node_forge2.default.md.sha256.create());
-  debugLog("cert", "Converting certificate to PEM format", options22?.verbose);
+  debugLog2("cert", "Converting certificate to PEM format", options22?.verbose);
   const pemHostCert = import_node_forge2.pki.certificateToPem(newHostCert);
   const pemHostKey = import_node_forge2.pki.privateKeyToPem(hostKeys.privateKey);
-  debugLog("cert", "Host certificate generated successfully", options22?.verbose);
+  debugLog2("cert", "Host certificate generated successfully", options22?.verbose);
   return {
     certificate: pemHostCert,
     privateKey: pemHostKey,
@@ -56725,81 +56887,81 @@ async function generateCert(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 = storeCert(cert, options22);
-  debugLog("trust", "Storing CA certificate", options22?.verbose);
+  debugLog2("trust", "Storing CA certificate", options22?.verbose);
   const caCertPath = storeCACert(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 storeCert(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 = options22?.certPath || config42.certPath;
   const certKeyPath = 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 storeCACert(caCert, options22) {
-  debugLog("storage", "Storing CA certificate", options22?.verbose);
+  debugLog2("storage", "Storing CA certificate", options22?.verbose);
   const caCertPath = 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;
@@ -56807,8 +56969,37 @@ var export_pki = import_node_forge2.pki;
 var export_forge = import_node_forge2.default;
 
 // src/https.ts
+function httpsConfig() {
+  const domain = config.to || "stacks.localhost";
+  const defaultConfig = {
+    domain,
+    hostCertCN: domain,
+    caCertPath: path6.join(os7.homedir(), ".stacks", "ssl", `${domain}.ca.crt`),
+    certPath: path6.join(os7.homedir(), ".stacks", "ssl", `${domain}.crt`),
+    keyPath: path6.join(os7.homedir(), ".stacks", "ssl", `${domain}.crt.key`),
+    altNameIPs: ["127.0.0.1"],
+    altNameURIs: ["localhost"],
+    organizationName: "stacksjs.org",
+    countryName: "US",
+    stateName: "California",
+    localityName: "Playa Vista",
+    commonName: domain,
+    validityDays: 180,
+    verbose: false
+  };
+  if (config.https === true)
+    return defaultConfig;
+  return {
+    ...defaultConfig,
+    ...config.https
+  };
+}
 async function generateCertificate(domain) {
-  domain = domain ?? config.https.altNameURIs[0];
+  if (config.https === true)
+    config.https = httpsConfig();
+  else if (config.https === false)
+    return;
+  domain = domain ?? config.https.domain;
   log.info(`Generating a self-signed SSL certificate for: ${domain}`);
   const caCert = await createRootCA(config.https);
   const hostCert = await generateCert({
@@ -56830,71 +57021,100 @@ async function generateCertificate(domain) {
   await addCertToSystemTrustStoreAndSaveCert(hostCert, caCert.certificate, config.https);
   log.success("Certificate generated");
 }
-
-// src/utils.ts
-function debugLog2(category, message, verbose) {
-  if (verbose || config.verbose) {
-    console.debug(`[rpx:${category}] ${message}`);
-  }
-}
+// src/start.ts
+import * as fs5 from "fs";
+import * as http from "http";
+import * as https from "https";
+import * as net from "net";
+import os8 from "os";
+import path7 from "path";
+import process9 from "process";
+// package.json
+var version = "0.3.0";
 
 // src/start.ts
 var activeServers = new Set;
-function cleanup() {
-  debugLog2("cleanup", "Starting cleanup process", config.verbose);
+async function cleanup() {
+  debugLog("cleanup", "Starting cleanup process", config.verbose);
   console.log(`\n`);
   log.info("Shutting down proxy servers...");
-  const closePromises = Array.from(activeServers).map((server) => new Promise((resolve4) => {
+  const cleanupPromises = [];
+  const serverClosePromises = Array.from(activeServers).map((server) => new Promise((resolve4) => {
     server.close(() => {
-      debugLog2("cleanup", "Server closed successfully", config.verbose);
+      debugLog("cleanup", "Server closed successfully", config.verbose);
       resolve4();
     });
   }));
-  Promise.all(closePromises).then(() => {
-    debugLog2("cleanup", "All servers closed successfully", config.verbose);
-    log.success("All proxy servers shut down successfully");
-    process3.exit(0);
-  }).catch((err3) => {
-    debugLog2("cleanup", `Error during shutdown: ${err3}`, config.verbose);
-    log.error("Error during shutdown:", err3);
-    process3.exit(1);
-  });
+  cleanupPromises.push(...serverClosePromises);
+  if (config.etcHostsCleanup) {
+    debugLog("cleanup", "Cleaning up hosts file entries", config.verbose);
+    try {
+      const toUrl = new URL(config.to.startsWith("http") ? config.to : `http://${config.to}`);
+      const hostname = toUrl.hostname;
+      if (!hostname.includes("localhost") && !hostname.includes("127.0.0.1")) {
+        log.info("Cleaning up hosts file entries...");
+        cleanupPromises.push(removeHosts([hostname]).then(() => {
+          debugLog("cleanup", `Removed hosts entry for ${hostname}`, config.verbose);
+        }).catch((err3) => {
+          debugLog("cleanup", `Failed to remove hosts entry: ${err3}`, config.verbose);
+          log.warn(`Failed to clean up hosts file entry for ${hostname}:`, err3);
+        }));
+      }
+    } catch (err3) {
+      debugLog("cleanup", `Error parsing URL during hosts cleanup: ${err3}`, config.verbose);
+      log.warn("Failed to parse URL for hosts cleanup:", err3);
+    }
+  }
+  try {
+    await Promise.all(cleanupPromises);
+    debugLog("cleanup", "All cleanup tasks completed successfully", config.verbose);
+    log.success("All cleanup tasks completed successfully");
+    process9.exit(0);
+  } catch (err3) {
+    debugLog("cleanup", `Error during cleanup: ${err3}`, config.verbose);
+    log.error("Error during cleanup:", err3);
+    process9.exit(1);
+  }
 }
-process3.on("SIGINT", cleanup);
-process3.on("SIGTERM", cleanup);
-process3.on("uncaughtException", (err3) => {
-  debugLog2("process", `Uncaught exception: ${err3}`, config.verbose);
+process9.on("SIGINT", cleanup);
+process9.on("SIGTERM", cleanup);
+process9.on("uncaughtException", (err3) => {
+  debugLog("process", `Uncaught exception: ${err3}`, config.verbose);
   log.error("Uncaught exception:", err3);
   cleanup();
 });
 async function loadSSLConfig(options3) {
-  debugLog2("ssl", "Loading SSL configuration", options3.verbose);
+  debugLog("ssl", "Loading SSL configuration", options3.verbose);
+  if (options3.https === true)
+    options3.https = httpsConfig();
+  else if (options3.https === false)
+    return null;
   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.promises.readFile(options3.https?.keyPath, "utf8");
-      const cert = await fs3.promises.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.promises.readFile(options3.https?.keyPath, "utf8");
+      const cert = await fs5.promises.readFile(options3.https?.certPath, "utf8");
+      debugLog("ssl", "SSL configuration loaded successfully", options3.verbose);
       return { key, cert };
     } catch (error) {
       if (error.code === "ENOENT") {
-        debugLog2("ssl", "Certificates not found, generating new ones", options3.verbose);
-        await generateCertificate();
-        debugLog2("ssl", "Reading newly generated certificates", options3.verbose);
-        const key = await fs3.promises.readFile(options3.https?.keyPath, "utf8");
-        const cert = await fs3.promises.readFile(options3.https?.certPath, "utf8");
-        debugLog2("ssl", "New SSL certificates loaded successfully", options3.verbose);
+        debugLog("ssl", "Certificates not found, generating new ones", options3.verbose);
+        await generateCertificate(options3.to);
+        debugLog("ssl", "Reading newly generated certificates", options3.verbose);
+        const key = await fs5.promises.readFile(options3.https?.keyPath, "utf8");
+        const cert = await fs5.promises.readFile(options3.https?.certPath, "utf8");
+        debugLog("ssl", "New SSL certificates loaded successfully", options3.verbose);
         return { key, cert };
       }
       throw error;
@@ -56902,22 +57122,22 @@ async function loadSSLConfig(options3) {
   } catch (err3) {
     const error = err3;
     const detail = error.code === "ENOENT" ? `File not found: ${error.path}` : error.message;
-    debugLog2("ssl", `SSL configuration error: ${error}`, options3.verbose);
+    debugLog("ssl", `SSL configuration error: ${error}`, options3.verbose);
     throw new Error(`SSL Configuration Error: ${detail}`);
   }
 }
 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);
     });
@@ -56925,17 +57145,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,
@@ -56943,54 +57163,89 @@ 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);
   if (!options3)
     options3 = config;
   if (!options3.from)
     options3.from = config.from;
   if (!options3.to)
     options3.to = config.to;
-  if (config.https) {
-    const domain = config.https.altNameURIs?.[0] || new URL(options3.to).hostname;
-    options3.keyPath = config.https.keyPath || `/Users/${process3.env.USER}/.stacks/ssl/${domain}.crt.key`;
-    options3.certPath = config.https.certPath || `/Users/${process3.env.USER}/.stacks/ssl/${domain}.crt`;
-    debugLog2("server", `HTTPS enabled, using cert paths: ${options3.keyPath}, ${options3.certPath}`, options3.verbose);
-  }
   const fromUrl = new URL(options3.from.startsWith("http") ? options3.from : `http://${options3.from}`);
   const toUrl = new URL(options3.to.startsWith("http") ? options3.to : `http://${options3.to}`);
   const fromPort = Number.parseInt(fromUrl.port) || (fromUrl.protocol.includes("https:") ? 443 : 80);
-  debugLog2("server", `Parsed URLs - from: ${fromUrl}, to: ${toUrl}`, options3.verbose);
+  const hostsToCheck = [toUrl.hostname];
+  if (!toUrl.hostname.includes("localhost") && !toUrl.hostname.includes("127.0.0.1")) {
+    debugLog("hosts", `Checking if hosts file entry exists for: ${toUrl.hostname}`, options3.verbose);
+    try {
+      const hostsExist = await checkHosts(hostsToCheck);
+      if (!hostsExist[0]) {
+        log.info(`Adding ${toUrl.hostname} to hosts file...`);
+        log.info("This may require sudo/administrator privileges");
+        try {
+          await addHosts(hostsToCheck);
+        } catch (addError) {
+          log.error("Failed to add hosts entry:", addError.message);
+          log.warn("You can manually add this entry to your hosts file:");
+          log.warn(`127.0.0.1 ${toUrl.hostname}`);
+          log.warn(`::1 ${toUrl.hostname}`);
+          if (process9.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 /etc/hosts");
+          }
+        }
+      } else {
+        debugLog("hosts", `Host entry already exists for ${toUrl.hostname}`, options3.verbose);
+      }
+    } catch (checkError) {
+      log.error("Failed to check hosts file:", checkError.message);
+    }
+  }
+  if (config.https) {
+    if (config.https === true)
+      config.https = httpsConfig();
+    const domain = toUrl.hostname;
+    if (typeof options3.https !== "boolean" && options3.https) {
+      options3.https.keyPath = config.https.keyPath || path7.join(os8.homedir(), ".stacks", "ssl", `${domain}.crt.key`);
+      options3.https.certPath = config.https.certPath || path7.join(os8.homedir(), ".stacks", "ssl", `${domain}.crt`);
+      debugLog("server", `HTTPS enabled, using cert paths: ${options3.https.keyPath}, ${options3.https.certPath}`, options3.verbose);
+    }
+  }
+  debugLog("server", `Parsed URLs - from: ${fromUrl}, to: ${toUrl}`, options3.verbose);
   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);
-    process3.exit(1);
+    process9.exit(1);
   }
   let sslConfig = null;
   if (config.https) {
     try {
       sslConfig = await loadSSLConfig(options3);
     } catch (err3) {
-      debugLog2("server", `SSL config failed, attempting to generate certificates: ${err3}`, options3.verbose);
-      await generateCertificate();
+      debugLog("server", `SSL config failed, attempting to generate certificates: ${err3}`, options3.verbose);
+      await generateCertificate(options3.to);
       sslConfig = await loadSSLConfig(options3);
     }
   }
@@ -57007,9 +57262,9 @@ async function startServer(options3) {
   });
 }
 async function createProxyServer(from, to, fromPort, listenPort, hostname, sourceUrl, ssl, verbose) {
-  debugLog2("proxy", `Creating proxy server ${from} -> ${to}`, verbose);
+  debugLog("proxy", `Creating proxy server ${from} -> ${to}`, verbose);
   const requestHandler = (req, res) => {
-    debugLog2("request", `Incoming request: ${req.method} ${req.url}`, verbose);
+    debugLog("request", `Incoming request: ${req.method} ${req.url}`, verbose);
     const proxyOptions = {
       hostname: sourceUrl.hostname,
       port: fromPort,
@@ -57020,9 +57275,9 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
         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);
       const headers = {
         ...proxyRes.headers,
         "Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
@@ -57032,7 +57287,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}`);
@@ -57059,11 +57314,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,
@@ -57074,7 +57329,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("");
@@ -57091,13 +57346,13 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
       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 } = options3;
   const httpPort = 80;
   const httpsPort = 443;
@@ -57106,73 +57361,72 @@ async function setupReverseProxy(options3) {
     if (ssl) {
       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);
       } 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");
       }
     }
     const targetPort = ssl ? httpsPort : httpPort;
     const isTargetPortBusy = await isPortInUse(targetPort, hostname, verbose);
     if (isTargetPortBusy) {
-      debugLog2("setup", `Port ${targetPort} is busy, finding alternative`, verbose);
+      debugLog("setup", `Port ${targetPort} is busy, finding alternative`, verbose);
       const availablePort = await findAvailablePort(ssl ? 8443 : 8080, hostname, verbose);
       log.warn(`Port ${targetPort} is in use. Using port ${availablePort} instead.`);
       log.info(`You can use 'sudo lsof -i :${targetPort}' (Unix) or 'netstat -ano | findstr :${targetPort}' (Windows) to check what's using the port.`);
       await createProxyServer(from, to, fromPort, availablePort, hostname, sourceUrl, ssl, verbose);
     } else {
-      debugLog2("setup", `Using default port ${targetPort}`, verbose);
+      debugLog("setup", `Using default port ${targetPort}`, verbose);
       await createProxyServer(from, to, fromPort, targetPort, 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();
   }
 }
 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 finalOptions = {
     ...config,
     ...options3
   };
-  debugLog2("proxy", `Starting proxy with options: ${JSON.stringify({
+  debugLog("proxy", `Starting proxy with options: ${JSON.stringify({
     from: finalOptions.from,
     to: finalOptions.to,
-    keyPath: finalOptions.https.keyPath,
-    certPath: finalOptions.https.certPath
+    https: finalOptions.https
   })}`, finalOptions.verbose);
   startServer(finalOptions).catch((err3) => {
-    debugLog2("proxy", `Failed to start proxy: ${err3}`, finalOptions.verbose);
+    debugLog("proxy", `Failed to start proxy: ${err3}`, finalOptions.verbose);
     log.error(`Failed to start proxy: ${err3.message}`);
     cleanup();
   });
 }
 function startProxies(options3) {
   if (Array.isArray(options3)) {
-    debugLog2("proxies", `Starting multiple proxies: ${options3.length}`, options3[0]?.verbose);
+    debugLog("proxies", `Starting multiple proxies: ${options3.length}`, options3[0]?.verbose);
     Promise.all(options3.map((option) => startServer(option))).catch((err3) => {
-      debugLog2("proxies", `Failed to start proxies: ${err3}`, options3[0]?.verbose);
+      debugLog("proxies", `Failed to start proxies: ${err3}`, options3[0]?.verbose);
       log.error("Failed to start proxies:", err3);
       cleanup();
     });
   } else if (options3) {
-    debugLog2("proxies", "Starting single proxy", options3.verbose);
+    debugLog("proxies", "Starting single proxy", options3.verbose);
     startServer(options3).catch((err3) => {
-      debugLog2("proxies", `Failed to start proxy: ${err3}`, options3.verbose);
+      debugLog("proxies", `Failed to start proxy: ${err3}`, options3.verbose);
       log.error("Failed to start proxy:", err3);
       cleanup();
     });
@@ -57184,5 +57438,12 @@ export {
   startProxies,
   startHttpRedirectServer,
   setupReverseProxy,
-  config
+  removeHosts,
+  httpsConfig,
+  hostsFilePath,
+  generateCertificate,
+  config,
+  cleanup,
+  checkHosts,
+  addHosts
 };