@stacksjs/rpx 0.5.0 → 0.6.0

package/dist/cli.js

@@ -20461,7 +20461,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";
@@ -20520,6 +20520,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`),
@@ -57099,9 +57100,15 @@ function extractHostname(options3) {
 function isValidRootCA(value) {
   return typeof value === "object" && value !== null && "certificate" in value && "privateKey" in value && typeof value.certificate === "string" && typeof value.privateKey === "string";
 }
-
-// src/https.ts
-var cachedSSLConfig = null;
+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 isMultiProxyConfig(options3) {
   return "proxies" in options3 && Array.isArray(options3.proxies);
 }
@@ -57111,6 +57118,9 @@ function isMultiProxyOptions(options3) {
 function isSingleProxyOptions(options3) {
   return "to" in options3 && typeof options3.to === "string";
 }
+
+// src/https.ts
+var cachedSSLConfig = null;
 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") {
@@ -57154,15 +57164,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 = "";
@@ -57244,7 +57245,6 @@ async function generateCertificate2(options3) {
   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,
@@ -57348,49 +57348,22 @@ import * as net from "net";
 import process9 from "process";
 
 // src/hosts.ts
-import { spawn } from "child_process";
+import { exec as exec2 } from "child_process";
 import fs5 from "fs";
 import os3 from "os";
 import path4 from "path";
 import process3 from "process";
+import { promisify } from "util";
+var execAsync = promisify(exec2);
 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 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) {
   debugLog2("hosts", `Adding hosts: ${hosts.join(", ")}`, verbose);
@@ -57412,35 +57385,29 @@ async function addHosts(hosts, verbose) {
 127.0.0.1 ${host}
 ::1 ${host}`).join(`
 `);
+    const tmpFile = path4.join(os3.tmpdir(), "hosts.tmp");
+    await fs5.promises.writeFile(tmpFile, existingContent + hostEntries, "utf8");
     try {
-      await fs5.promises.appendFile(hostsFilePath, hostEntries, { flag: "a" });
+      await execSudo(`cp "${tmpFile}" "${hostsFilePath}"`);
       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(`
+    } 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(`
+      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");
-        }
+        log.warn("1. Run notepad as administrator");
+        log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
       } else {
-        throw writeErr;
+        log.warn(`
+On Unix systems:`);
+        log.warn(`sudo nano ${hostsFilePath}`);
       }
+      throw new Error("Failed to modify hosts file: manual intervention required");
+    } finally {
+      fs5.unlinkSync(tmpFile);
     }
   } catch (err3) {
     const error = err3;
@@ -57466,38 +57433,32 @@ async function removeHosts(hosts, verbose) {
     const newContent = `${filteredLines.join(`
 `)}
 `;
+    const tmpFile = path4.join(os3.tmpdir(), "hosts.tmp");
+    await fs5.promises.writeFile(tmpFile, newContent, "utf8");
     try {
-      await fs5.promises.writeFile(hostsFilePath, newContent);
+      await execSudo(`cp "${tmpFile}" "${hostsFilePath}"`);
       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(`
+    } 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");
-        }
+        log.warn("1. Run notepad as administrator");
+        log.warn("2. Open C:\\Windows\\System32\\drivers\\etc\\hosts");
       } else {
-        throw writeErr;
+        log.warn(`
+On Unix systems:`);
+        log.warn(`sudo nano ${hostsFilePath}`);
       }
+      throw new Error("Failed to modify hosts file: manual intervention required");
+    } finally {
+      fs5.unlinkSync(tmpFile);
     }
   } catch (err3) {
     const error = err3;
@@ -57711,14 +57672,24 @@ 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) {
+  debugLog2("proxy", `Creating proxy server ${from} -> ${to} with cleanUrls: ${cleanUrls}`, verbose);
   const requestHandler = (req, res) => {
     debugLog2("request", `Incoming request: ${req.method} ${req.url}`, verbose);
+    let path5 = req.url || "/";
+    if (cleanUrls) {
+      if (!path5.match(/\.[a-z0-9]+$/i)) {
+        if (path5.endsWith("/")) {
+          path5 = `${path5}index.html`;
+        } else {
+          path5 = `${path5}.html`;
+        }
+      }
+    }
     const proxyOptions = {
       hostname: sourceUrl.hostname,
       port: fromPort,
-      path: req.url,
+      path: path5,
       method: req.method,
       headers: {
         ...req.headers,
@@ -57728,6 +57699,42 @@ async function createProxyServer(from, to, fromPort, listenPort, hostname, sourc
     debugLog2("request", `Proxy request options: ${JSON.stringify(proxyOptions)}`, verbose);
     const proxyReq = http.request(proxyOptions, (proxyRes) => {
       debugLog2("response", `Proxy response received with status ${proxyRes.statusCode}`, verbose);
+      if (cleanUrls && proxyRes.statusCode === 404) {
+        const alternativePaths = [];
+        if (path5.endsWith(".html")) {
+          alternativePaths.push(path5.slice(0, -5));
+        } else if (!path5.match(/\.[a-z0-9]+$/i)) {
+          alternativePaths.push(`${path5}.html`);
+        }
+        if (!path5.endsWith("/")) {
+          alternativePaths.push(`${path5}/index.html`);
+        }
+        if (alternativePaths.length > 0) {
+          debugLog2("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) {
+                debugLog2("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",
@@ -57793,6 +57800,9 @@ 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) => {
@@ -57864,6 +57874,7 @@ function startProxy(options3) {
   const serverOptions = {
     from: mergedOptions.from,
     to: mergedOptions.to,
+    cleanUrls: mergedOptions.cleanUrls,
     https: httpsConfig(mergedOptions),
     etcHostsCleanup: mergedOptions.etcHostsCleanup,
     verbose: mergedOptions.verbose
@@ -57905,11 +57916,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,
@@ -57936,7 +57949,8 @@ async function startProxies(options3) {
       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
@@ -57953,7 +57967,6 @@ async function startProxies(options3) {
 var cli = new CAC("reverse-proxy");
 cli.command("start", "Start the Reverse Proxy Server").option("--from <from>", "The URL to proxy from").option("--to <to>", "The URL to proxy to").option("--key-path <path>", "Absolute path to the SSL key").option("--cert-path <path>", "Absolute path to the SSL certificate").option("--ca-cert-path <path>", "Absolute path to the SSL CA certificate").option("--etc-hosts-cleanup", "Cleanup /etc/hosts on exit").option("--verbose", "Enable verbose logging").example("reverse-proxy start --from localhost:5173 --to my-project.localhost").example("reverse-proxy start --from localhost:3000 --to my-project.localhost/api").example("reverse-proxy start --from localhost:3000 --to localhost:3001").example("reverse-proxy start --from localhost:5173 --to my-project.test --key-path /absolute/path/to/key --cert-path /absolute/path/to/cert").action(async (options3) => {
   if (!options3?.from || !options3.to) {
-    console.log("in here", config4);
     return startProxies(config4);
   }
   return startProxy({

package/dist/hosts.d.ts

@@ -1,5 +1,6 @@
+declare const execAsync: unknown;
 export declare const hostsFilePath: string;
-declare function sudoWrite(operation: 'append' | 'write', content: string): Promise<void>;
+declare function execSudo(command: string): Promise<void>;
 export declare function addHosts(hosts: string[], verbose?: boolean): Promise<void>;
 export declare function removeHosts(hosts: string[], verbose?: boolean): Promise<void>;
 export declare function checkHosts(hosts: string[], verbose?: boolean): Promise<boolean[]>;

package/dist/https.d.ts

@@ -1,11 +1,7 @@
 import type { ReverseProxyConfigs, ReverseProxyOption, ReverseProxyOptions, TlsConfig } from './types';
 
-export declare function isMultiProxyConfig(options: ReverseProxyConfigs): options is MultiReverseProxyConfig;
-export declare function isMultiProxyOptions(options: ReverseProxyOption | ReverseProxyOptions): options is MultiReverseProxyConfig;
-export declare function isSingleProxyOptions(options: ReverseProxyOption | ReverseProxyOptions): options is SingleReverseProxyConfig;
 export declare function resolveSSLPaths(options: ReverseProxyConfigs, defaultConfig: typeof config): TlsConfig;
 export declare function generateWildcardPatterns(domain: string): string[];
-export declare function getPrimaryDomain(options?: ReverseProxyOption | ReverseProxyOptions): string;
 export declare function generateSSLPaths(options?: ReverseProxyOptions): void;
 export declare function getAllDomains(options: ReverseProxyOption | ReverseProxyOptions): Set<string>;
 export declare function loadSSLConfig(options: ReverseProxyOption): Promise<SSLConfig | null>;