vite-plugin-caddy-multiple-tls 1.1.0 → 1.3.0

package/README.md

@@ -1,5 +1,8 @@
 # vite-plugin-caddy-multiple-tls
 
+## What it does
+Runs Caddy alongside Vite to give you HTTPS locally with automatic, per-branch domains like `<repo>.<branch>.localhost`, so you can use real hostnames, cookies, and secure APIs without manual proxy setup.
+
 ## Usage
 
 ```js
@@ -112,7 +115,7 @@ api.app.localhost
 > - `nip.io`: dynamic parsing of the IP in the hostname (e.g. `app.192.168.1.50.nip.io`) so you can target LAN devices.
 > Why use them: subdomains behave like real domains, no `/etc/hosts` edits, and closer parity for cookies/CORS rules.
 >
-> When using loopback domains, ensure your Vite config allows the Host header, e.g. `server: { allowedHosts: true }`.
+> When using loopback domains, ensure your Vite config allows the Host header and binds to all interfaces, e.g. `server: { allowedHosts: true, host: true }`.
 >
 > For a permanent fix that handles all `*.localhost` domains automatically, install dnsmasq:
 > ```bash

package/dist/index.js

@@ -174,7 +174,13 @@ async function ensureTlsAutomation() {
     throw new Error(`Failed to initialize Caddy TLS automation: ${text}`);
   }
 }
-async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAME) {
+function formatDialAddress(host, port) {
+  if (host.includes(":") && !host.startsWith("[")) {
+    return `[${host}]:${port}`;
+  }
+  return `${host}:${port}`;
+}
+async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAME, upstreamHost = "127.0.0.1") {
   const handlers = [];
   if (cors) {
     handlers.push({
@@ -197,7 +203,7 @@ async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAM
   }
   handlers.push({
     handler: "reverse_proxy",
-    upstreams: [{ dial: `localhost:${port}` }]
+    upstreams: [{ dial: formatDialAddress(upstreamHost, port) }]
   });
   const route = {
     "@id": id,
@@ -311,6 +317,15 @@ function resolveBaseDomain(options) {
   }
   return "localhost";
 }
+function resolveUpstreamHost(host) {
+  if (typeof host === "string") {
+    const trimmed = host.trim();
+    if (trimmed && trimmed !== "0.0.0.0" && trimmed !== "::") {
+      return trimmed;
+    }
+  }
+  return "127.0.0.1";
+}
 function sanitizeDomainLabel(value) {
   return value.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -351,132 +366,240 @@ function viteCaddyTlsPlugin({
   serverName,
   internalTls
 } = {}) {
-  return {
-    name: "vite:caddy-tls",
-    configureServer({ httpServer, config }) {
-      const fallbackPort = config.server.port || 5173;
-      const resolvedDomain = resolveDomain({
-        domain,
-        baseDomain,
-        loopbackDomain,
-        repo,
-        branch
-      });
-      const domainArray = resolvedDomain ? [resolvedDomain] : [];
-      const routeId = `vite-proxy-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
-      const shouldUseInternalTls = internalTls ?? (baseDomain !== void 0 || loopbackDomain !== void 0 || domain !== void 0);
-      const tlsPolicyId = shouldUseInternalTls ? `${routeId}-tls` : null;
-      let cleanupStarted = false;
-      if (domainArray.length === 0) {
-        console.error(
-          "No domain resolved. Provide domain, or run inside a git repo, or pass repo/branch."
-        );
-        return;
+  function isPreviewServer(server) {
+    return server.config.isProduction;
+  }
+  function getPreviewPort(config) {
+    if (typeof config.preview?.port === "number") {
+      return config.preview.port;
+    }
+    return null;
+  }
+  function getPreviewHost(config) {
+    if (config.preview && "host" in config.preview) {
+      return resolveUpstreamHost(config.preview.host);
+    }
+    return null;
+  }
+  function hasListen(server) {
+    return !!server && typeof server === "object" && "listen" in server && typeof server.listen === "function";
+  }
+  function setupServer(server) {
+    const { httpServer, config } = server;
+    const previewMode = isPreviewServer(server);
+    const fallbackPort = previewMode ? getPreviewPort(config) ?? 4173 : config.server.port || 5173;
+    const resolvedDomain = resolveDomain({
+      domain,
+      baseDomain,
+      loopbackDomain,
+      repo,
+      branch
+    });
+    const domainArray = resolvedDomain ? [resolvedDomain] : [];
+    const routeId = `vite-proxy-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
+    const shouldUseInternalTls = internalTls ?? (baseDomain !== void 0 || loopbackDomain !== void 0 || domain !== void 0);
+    const tlsPolicyId = shouldUseInternalTls ? `${routeId}-tls` : null;
+    let cleanupStarted = false;
+    let resolvedPort = null;
+    let resolvedHost = null;
+    let setupStarted = false;
+    if (domainArray.length === 0) {
+      console.error(
+        "No domain resolved. Provide domain, or run inside a git repo, or pass repo/branch."
+      );
+      return;
+    }
+    let tlsPolicyAdded = false;
+    function getPortFromAddress(address) {
+      if (address && typeof address === "object" && "port" in address) {
+        const port = address.port;
+        if (typeof port === "number") {
+          return port;
+        }
       }
-      let tlsPolicyAdded = false;
-      function getServerPort() {
-        if (!httpServer) return fallbackPort;
-        const address = httpServer.address();
-        if (address && typeof address === "object" && "port" in address) {
-          return address.port;
+      return null;
+    }
+    function updateResolvedTarget() {
+      if (resolvedPort !== null && resolvedHost !== null) return;
+      const resolvedUrl = server.resolvedUrls?.local?.[0];
+      if (resolvedUrl) {
+        try {
+          const url = new URL(resolvedUrl);
+          if (resolvedHost === null && url.hostname) {
+            resolvedHost = url.hostname === "localhost" ? "127.0.0.1" : url.hostname;
+          }
+          const port = Number(url.port);
+          if (resolvedPort === null && !Number.isNaN(port)) {
+            resolvedPort = port;
+          }
+        } catch (e) {
         }
-        return fallbackPort;
       }
-      async function cleanupRoute() {
-        if (cleanupStarted) return;
-        cleanupStarted = true;
-        if (tlsPolicyId) {
-          await removeTlsPolicy(tlsPolicyId);
+      if (httpServer) {
+        const address = httpServer.address();
+        if (address && typeof address === "object") {
+          const port = getPortFromAddress(address);
+          if (resolvedPort === null && port !== null) {
+            resolvedPort = port;
+          }
+          if (resolvedHost === null && "address" in address) {
+            const host = address.address;
+            if (typeof host === "string" && host !== "0.0.0.0" && host !== "::") {
+              resolvedHost = host;
+            }
+          }
         }
-        await removeRoute(routeId);
       }
-      function onServerClose() {
-        void cleanupRoute();
+      if (resolvedPort === null && typeof config.server.port === "number") {
+        resolvedPort = config.server.port;
       }
-      function handleSignal(signal) {
-        process.off("SIGINT", onSigint);
-        process.off("SIGTERM", onSigterm);
-        void cleanupRoute().finally(() => {
-          process.kill(process.pid, signal);
-        });
+      if (previewMode && resolvedPort === null) {
+        const previewPort = getPreviewPort(config);
+        if (previewPort !== null) {
+          resolvedPort = previewPort;
+        }
       }
-      function onSigint() {
-        handleSignal("SIGINT");
+      if (resolvedHost === null) {
+        if (previewMode) {
+          resolvedHost = getPreviewHost(config);
+        }
+        if (resolvedHost === null) {
+          resolvedHost = resolveUpstreamHost(config.server.host);
+        }
       }
-      function onSigterm() {
-        handleSignal("SIGTERM");
+    }
+    function getServerPort() {
+      updateResolvedTarget();
+      return resolvedPort ?? fallbackPort;
+    }
+    function getUpstreamHost() {
+      updateResolvedTarget();
+      return resolvedHost ?? "127.0.0.1";
+    }
+    async function cleanupRoute() {
+      if (cleanupStarted) return;
+      cleanupStarted = true;
+      if (tlsPolicyId) {
+        await removeTlsPolicy(tlsPolicyId);
       }
-      function registerProcessCleanup() {
-        process.once("SIGINT", onSigint);
-        process.once("SIGTERM", onSigterm);
+      await removeRoute(routeId);
+    }
+    function onServerClose() {
+      void cleanupRoute();
+    }
+    function handleSignal(signal) {
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      void cleanupRoute().finally(() => {
+        process.kill(process.pid, signal);
+      });
+    }
+    function onSigint() {
+      handleSignal("SIGINT");
+    }
+    function onSigterm() {
+      handleSignal("SIGTERM");
+    }
+    function registerProcessCleanup() {
+      process.once("SIGINT", onSigint);
+      process.once("SIGTERM", onSigterm);
+    }
+    async function setupRoute() {
+      if (!validateCaddyIsInstalled()) {
+        return;
       }
-      async function setupRoute() {
-        if (!validateCaddyIsInstalled()) {
-          return;
-        }
-        let running = await isCaddyRunning();
+      let running = await isCaddyRunning();
+      if (!running) {
+        running = await startCaddy();
         if (!running) {
-          running = await startCaddy();
-          if (!running) {
-            console.error("Failed to start Caddy server.");
-            return;
-          }
-        }
-        try {
-          await ensureBaseConfig(serverName);
-        } catch (e) {
-          console.error("Failed to configure Caddy base settings.", e);
+          console.error("Failed to start Caddy server.");
           return;
         }
-        const port = getServerPort();
-        if (tlsPolicyId) {
-          try {
-            await addTlsPolicy(tlsPolicyId, domainArray);
-            tlsPolicyAdded = true;
-          } catch (e) {
-            console.error("Failed to add TLS policy to Caddy.", e);
-            return;
-          }
-        }
+      }
+      try {
+        await ensureBaseConfig(serverName);
+      } catch (e) {
+        console.error("Failed to configure Caddy base settings.", e);
+        return;
+      }
+      const port = getServerPort();
+      const upstreamHost = getUpstreamHost();
+      if (tlsPolicyId) {
         try {
-          await addRoute(routeId, domainArray, port, cors, serverName);
+          await addTlsPolicy(tlsPolicyId, domainArray);
+          tlsPolicyAdded = true;
         } catch (e) {
-          if (tlsPolicyAdded && tlsPolicyId) {
-            await removeTlsPolicy(tlsPolicyId);
-          }
-          console.error("Failed to add route to Caddy.", e);
+          console.error("Failed to add TLS policy to Caddy.", e);
           return;
         }
-        console.log();
-        console.log("\u{1F512} Caddy is proxying your traffic on https");
-        console.log();
-        console.log(
-          `\u{1F517} Access your local ${domainArray.length > 1 ? "servers" : "server"} `
-        );
-        domainArray.forEach((domain2) => {
-          console.log(`\u{1F30D} https://${domain2}`);
-        });
-        if (process.platform === "linux" && !loopbackDomain) {
-          console.log();
-          console.log("\u{1F427} Linux users: if the domain doesn't resolve, run:");
-          domainArray.forEach((domain2) => {
-            console.log(`   echo "127.0.0.1 ${domain2}" | sudo tee -a /etc/hosts`);
-          });
-        }
-        console.log();
-        registerProcessCleanup();
-        httpServer?.once("close", onServerClose);
       }
-      function onListening() {
-        void setupRoute();
+      try {
+        await addRoute(routeId, domainArray, port, cors, serverName, upstreamHost);
+      } catch (e) {
+        if (tlsPolicyAdded && tlsPolicyId) {
+          await removeTlsPolicy(tlsPolicyId);
+        }
+        console.error("Failed to add route to Caddy.", e);
+        return;
       }
-      if (httpServer?.listening) {
-        void setupRoute();
-      } else if (httpServer) {
-        httpServer.once("listening", onListening);
-      } else {
-        void setupRoute();
+      console.log("\n\u{1F512} Caddy is proxying your traffic on https");
+      console.log(
+        `
+\u{1F517} Access your local ${domainArray.length > 1 ? "servers" : "server"}!`
+      );
+      domainArray.forEach((domain2) => {
+        console.log(`\u{1F30D} https://${domain2}`);
+      });
+      if (process.platform === "linux" && !loopbackDomain) {
+        console.log("\n\u{1F427} Linux users: if the domain doesn't resolve, run:");
+        domainArray.forEach((domain2) => {
+          console.log(`   echo "127.0.0.1 ${domain2}" | sudo tee -a /etc/hosts`);
+        });
       }
+      console.log();
+      registerProcessCleanup();
+      httpServer?.once("close", onServerClose);
+    }
+    function runSetupOnce() {
+      if (setupStarted) return;
+      setupStarted = true;
+      void setupRoute();
+    }
+    function wrapServerListen() {
+      if (!hasListen(server)) return false;
+      const originalListen = server.listen.bind(server);
+      server.listen = async function(port, isRestart) {
+        const result = await originalListen(port, isRestart);
+        if (typeof port === "number") {
+          resolvedPort = port;
+        } else {
+          updateResolvedTarget();
+        }
+        runSetupOnce();
+        return result;
+      };
+      return true;
+    }
+    function onListening() {
+      updateResolvedTarget();
+      runSetupOnce();
+    }
+    const listenWrapped = wrapServerListen();
+    if (httpServer?.listening) {
+      runSetupOnce();
+    } else if (httpServer) {
+      httpServer.once("listening", onListening);
+    } else if (!listenWrapped) {
+      runSetupOnce();
+    }
+  }
+  return {
+    name: "vite:caddy-tls",
+    configureServer(server) {
+      setupServer(server);
+    },
+    configurePreviewServer(server) {
+      setupServer(server);
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-caddy-multiple-tls",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Vite plugin that uses Caddy to provide local HTTPS with derived domains.",
   "keywords": [
     "vite",