vite-plugin-caddy-multiple-tls 1.1.0 → 1.2.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

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, "");
 }
@@ -353,7 +368,8 @@ function viteCaddyTlsPlugin({
 } = {}) {
   return {
     name: "vite:caddy-tls",
-    configureServer({ httpServer, config }) {
+    configureServer(server) {
+      const { httpServer, config } = server;
       const fallbackPort = config.server.port || 5173;
       const resolvedDomain = resolveDomain({
         domain,
@@ -367,6 +383,9 @@ function viteCaddyTlsPlugin({
       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."
@@ -374,13 +393,60 @@ function viteCaddyTlsPlugin({
         return;
       }
       let tlsPolicyAdded = false;
-      function getServerPort() {
-        if (!httpServer) return fallbackPort;
-        const address = httpServer.address();
+      function getPortFromAddress(address) {
         if (address && typeof address === "object" && "port" in address) {
-          return address.port;
+          const port = address.port;
+          if (typeof port === "number") {
+            return 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) {
+          }
+        }
+        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;
+              }
+            }
+          }
+        }
+        if (resolvedPort === null && typeof config.server.port === "number") {
+          resolvedPort = config.server.port;
+        }
+        if (resolvedHost === null) {
+          resolvedHost = resolveUpstreamHost(config.server.host);
         }
-        return fallbackPort;
+      }
+      function getServerPort() {
+        updateResolvedTarget();
+        return resolvedPort ?? fallbackPort;
+      }
+      function getUpstreamHost() {
+        updateResolvedTarget();
+        return resolvedHost ?? "127.0.0.1";
       }
       async function cleanupRoute() {
         if (cleanupStarted) return;
@@ -429,6 +495,7 @@ function viteCaddyTlsPlugin({
           return;
         }
         const port = getServerPort();
+        const upstreamHost = getUpstreamHost();
         if (tlsPolicyId) {
           try {
             await addTlsPolicy(tlsPolicyId, domainArray);
@@ -439,7 +506,7 @@ function viteCaddyTlsPlugin({
           }
         }
         try {
-          await addRoute(routeId, domainArray, port, cors, serverName);
+          await addRoute(routeId, domainArray, port, cors, serverName, upstreamHost);
         } catch (e) {
           if (tlsPolicyAdded && tlsPolicyId) {
             await removeTlsPolicy(tlsPolicyId);
@@ -451,7 +518,7 @@ function viteCaddyTlsPlugin({
         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"} `
+          `\u{1F517} Access your local ${domainArray.length > 1 ? "servers" : "server"}!`
         );
         domainArray.forEach((domain2) => {
           console.log(`\u{1F30D} https://${domain2}`);
@@ -467,15 +534,37 @@ function viteCaddyTlsPlugin({
         registerProcessCleanup();
         httpServer?.once("close", onServerClose);
       }
-      function onListening() {
+      function runSetupOnce() {
+        if (setupStarted) return;
+        setupStarted = true;
         void setupRoute();
       }
+      function wrapServerListen() {
+        if (typeof server.listen !== "function") 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) {
-        void setupRoute();
+        runSetupOnce();
       } else if (httpServer) {
         httpServer.once("listening", onListening);
-      } else {
-        void setupRoute();
+      } else if (!listenWrapped) {
+        runSetupOnce();
       }
     }
   };

package/package.json

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