vite-plugin-caddy-multiple-tls 1.4.2 → 1.5.0

package/README.md

@@ -20,6 +20,8 @@ export default config;
 ```
 
 Will give this in the terminal, allow you to connect to your app on HTTPS with a self-signed and trusted cert.
+
+The plugin defaults `server.host = true` and `server.allowedHosts = true` (plus preview equivalents) so custom hostnames work without extra config. When a domain is resolved, it also defaults `server.hmr` to use `wss` on port `443` and the resolved host, isolating multiple Vite instances without extra config. Override these in your Vite config if you need different values.
 ```
 > vite
 
@@ -52,6 +54,24 @@ const config = defineConfig({
 export default config;
 ```
 
+You can also pass multiple explicit domains:
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import caddyTls from 'vite-plugin-caddy-multiple-tls';
+
+const config = defineConfig({
+  plugins: [
+    caddyTls({
+      domain: ['app.localhost', 'api.localhost'],
+    })
+  ]
+});
+
+export default config;
+```
+
 To derive a domain like `<repo>.<branch>.<baseDomain>` automatically from git (repo name first, then branch):
 
 ```js
@@ -78,6 +98,24 @@ For a zero-config experience, use `baseDomain: 'localhost'` (the default) so the
 
 For non-`.localhost` domains (like `local.example.test`), keep `internalTls: true` to force Caddy to use its internal CA for certificates.
 
+If your Caddy Admin API is not on the default `http://localhost:2019`, set `caddyApiUrl`. Empty or whitespace values fall back to the default.
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import caddyTls from 'vite-plugin-caddy-multiple-tls';
+
+const config = defineConfig({
+  plugins: [
+    caddyTls({
+      caddyApiUrl: 'http://localhost:2020',
+    })
+  ]
+});
+
+export default config;
+```
+
 > [!IMPORTANT]  
 > **Hosts file limitation:** If you use a custom domain, you must **manually** add each generated subdomain to your `/etc/hosts` file (e.g., `127.0.0.1 repo.branch.local.example.test`). System hosts files **do not support wildcards** (e.g., `*.local.example.test`), so you lose the benefit of automatic domain resolution that `localhost` provides.
 
@@ -127,6 +165,8 @@ api.app.localhost
 ## Development
 This repo uses npm workspaces. Install from the root with `npm install`, then run workspace scripts like `npm run build --workspace packages/plugin` or `npm run dev --workspace playground`.
 
+The published package README is synced from the root `README.md` via `packages/plugin/scripts/sync-readme.sh`.
+
 ## Contributing
 See [CONTRIBUTING.md](./CONTRIBUTING.md) to see how to get started.
  

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { PluginOption } from 'vite';
 
 interface ViteCaddyTlsPluginOptions {
     /** Explicit domain to proxy without repo/branch derivation */
-    domain?: string;
+    domain?: string | string[];
     /** Base domain to build <repo>.<branch>.<baseDomain> (defaults to localhost) */
     baseDomain?: string;
     /** Optional loopback domain to avoid /etc/hosts edits */
@@ -14,6 +14,8 @@ interface ViteCaddyTlsPluginOptions {
     cors?: string;
     /** Override the default Caddy server name (srv0) */
     serverName?: string;
+    /** Override the Caddy Admin API base URL (default: http://localhost:2019) */
+    caddyApiUrl?: string;
     /** Use Caddy's internal CA for the provided domains (defaults to true when baseDomain or domain is set) */
     internalTls?: boolean;
     /**
@@ -35,6 +37,6 @@ type LoopbackDomain = 'localtest.me' | 'lvh.me' | 'nip.io';
  * ```
  * @returns {Plugin} - a Vite plugin
  */
-declare function viteCaddyTlsPlugin({ domain, baseDomain, loopbackDomain, repo, branch, cors, serverName, internalTls, upstreamHostHeader, }?: ViteCaddyTlsPluginOptions): PluginOption;
+declare function viteCaddyTlsPlugin({ domain, baseDomain, loopbackDomain, repo, branch, cors, serverName, caddyApiUrl, internalTls, upstreamHostHeader, }?: ViteCaddyTlsPluginOptions): PluginOption;
 
 export { type ViteCaddyTlsPluginOptions, viteCaddyTlsPlugin as default };

package/dist/index.js

@@ -4,8 +4,15 @@ import path from "path";
 
 // src/utils.ts
 import { execSync } from "child_process";
-var CADDY_API = "http://localhost:2019";
 var DEFAULT_SERVER_NAME = "srv0";
+var DEFAULT_CADDY_API_URL = "http://localhost:2019";
+var caddyApiUrl = DEFAULT_CADDY_API_URL;
+function setCaddyApiUrl(url) {
+  caddyApiUrl = url;
+}
+function getCaddyApiUrl() {
+  return caddyApiUrl;
+}
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -31,7 +38,7 @@ function validateCaddyIsInstalled() {
 }
 async function isCaddyRunning() {
   try {
-    const res = await fetch(`${CADDY_API}/config/`);
+    const res = await fetch(`${caddyApiUrl}/config/`);
     return res.ok;
   } catch (e) {
     return false;
@@ -51,7 +58,7 @@ async function startCaddy() {
   }
 }
 async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
-  const serverUrl = `${CADDY_API}/config/apps/http/servers/${serverName}`;
+  const serverUrl = `${caddyApiUrl}/config/apps/http/servers/${serverName}`;
   const res = await fetch(serverUrl);
   if (res.ok) return;
   const baseConfig = {
@@ -63,7 +70,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
       [serverName]: baseConfig
     }
   };
-  const configRes = await fetch(`${CADDY_API}/config/`);
+  const configRes = await fetch(`${caddyApiUrl}/config/`);
   if (!configRes.ok) {
     const text = await configRes.text();
     throw new Error(`Failed to read Caddy config: ${text}`);
@@ -75,7 +82,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
   }
   const isEmptyConfig = configText.trim() === "" || config === null || isRecord(config) && Object.keys(config).length === 0;
   if (isEmptyConfig) {
-    const loadRes = await fetch(`${CADDY_API}/load`, {
+    const loadRes = await fetch(`${caddyApiUrl}/load`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -97,7 +104,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
   let hasHttp = isRecord(http);
   let hasServers = isRecord(servers);
   if (!hasApps) {
-    const createAppsRes = await fetch(`${CADDY_API}/config/apps`, {
+    const createAppsRes = await fetch(`${caddyApiUrl}/config/apps`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({})
@@ -109,7 +116,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
     hasApps = true;
   }
   if (!hasHttp) {
-    const createHttpRes = await fetch(`${CADDY_API}/config/apps/http`, {
+    const createHttpRes = await fetch(`${caddyApiUrl}/config/apps/http`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ servers: {} })
@@ -122,7 +129,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
     hasServers = true;
   }
   if (!hasServers) {
-    const createServersRes = await fetch(`${CADDY_API}/config/apps/http/servers`, {
+    const createServersRes = await fetch(`${caddyApiUrl}/config/apps/http/servers`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({})
@@ -143,7 +150,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
   }
 }
 async function ensureTlsAutomation() {
-  const policiesUrl = `${CADDY_API}/config/apps/tls/automation/policies`;
+  const policiesUrl = `${caddyApiUrl}/config/apps/tls/automation/policies`;
   const policiesRes = await fetch(policiesUrl);
   if (policiesRes.ok) return;
   const policiesText = await policiesRes.text();
@@ -152,7 +159,7 @@ async function ensureTlsAutomation() {
       `Failed to initialize Caddy TLS automation: ${policiesText}`
     );
   }
-  const automationRes = await fetch(`${CADDY_API}/config/apps/tls/automation`, {
+  const automationRes = await fetch(`${caddyApiUrl}/config/apps/tls/automation`, {
     method: "PUT",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ policies: [] })
@@ -164,7 +171,7 @@ async function ensureTlsAutomation() {
       `Failed to initialize Caddy TLS automation: ${automationText}`
     );
   }
-  const tlsRes = await fetch(`${CADDY_API}/config/apps/tls`, {
+  const tlsRes = await fetch(`${caddyApiUrl}/config/apps/tls`, {
     method: "PUT",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ automation: { policies: [] } })
@@ -231,7 +238,7 @@ async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAM
     terminal: true
   };
   const res = await fetch(
-    `${CADDY_API}/config/apps/http/servers/${serverName}/routes`,
+    `${caddyApiUrl}/config/apps/http/servers/${serverName}/routes`,
     {
       method: "POST",
       // Append to routes list
@@ -255,7 +262,7 @@ async function addTlsPolicy(id, domains) {
       }
     ]
   };
-  const res = await fetch(`${CADDY_API}/config/apps/tls/automation/policies`, {
+  const res = await fetch(`${caddyApiUrl}/config/apps/tls/automation/policies`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(policy)
@@ -269,20 +276,24 @@ async function addTlsPolicy(id, domains) {
   }
 }
 async function removeRoute(id) {
-  const res = await fetch(`${CADDY_API}/id/${id}`, {
+  const res = await fetch(`${caddyApiUrl}/id/${id}`, {
     method: "DELETE"
   });
   if (!res.ok && res.status !== 404) {
     console.error(`Failed to remove route ${id}`);
+    return false;
   }
+  return true;
 }
 async function removeTlsPolicy(id) {
-  const res = await fetch(`${CADDY_API}/id/${id}`, {
+  const res = await fetch(`${caddyApiUrl}/id/${id}`, {
     method: "DELETE"
   });
   if (!res.ok && res.status !== 404) {
     console.error(`Failed to remove TLS policy ${id}`);
+    return false;
   }
+  return true;
 }
 
 // src/index.ts
@@ -360,11 +371,24 @@ function normalizeDomain(domain) {
   if (!trimmed) return null;
   return trimmed;
 }
-function resolveDomain(options) {
+function normalizeDomains(domains) {
+  const domainList = Array.isArray(domains) ? domains : [domains];
+  const normalized = domainList.map((domain) => normalizeDomain(domain)).filter((domain) => Boolean(domain));
+  if (normalized.length === 0) return null;
+  return Array.from(new Set(normalized));
+}
+function normalizeCaddyApiUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/\/+$/g, "");
+}
+function resolveDomains(options) {
   if (options.domain) {
-    return normalizeDomain(options.domain);
+    return normalizeDomains(options.domain);
   }
-  return buildDerivedDomain(options);
+  const derivedDomain = buildDerivedDomain(options);
+  if (!derivedDomain) return null;
+  return [derivedDomain];
 }
 function viteCaddyTlsPlugin({
   domain,
@@ -374,9 +398,21 @@ function viteCaddyTlsPlugin({
   branch,
   cors,
   serverName,
+  caddyApiUrl: caddyApiUrl2,
   internalTls,
   upstreamHostHeader
 } = {}) {
+  if (caddyApiUrl2 !== void 0) {
+    const normalizedApiUrl = normalizeCaddyApiUrl(caddyApiUrl2);
+    if (normalizedApiUrl) {
+      setCaddyApiUrl(normalizedApiUrl);
+    } else {
+      setCaddyApiUrl(DEFAULT_CADDY_API_URL);
+      console.warn(
+        `caddyApiUrl is empty after trimming. Falling back to ${DEFAULT_CADDY_API_URL}.`
+      );
+    }
+  }
   function isPreviewServer(server) {
     return server.config.isProduction;
   }
@@ -399,14 +435,14 @@ function viteCaddyTlsPlugin({
     const { httpServer, config } = server;
     const previewMode = isPreviewServer(server);
     const fallbackPort = previewMode ? getPreviewPort(config) ?? 4173 : config.server.port || 5173;
-    const resolvedDomain = resolveDomain({
+    const resolvedDomains = resolveDomains({
       domain,
       baseDomain,
       loopbackDomain,
       repo,
       branch
     });
-    const domainArray = resolvedDomain ? [resolvedDomain] : [];
+    const domainArray = resolvedDomains ?? [];
     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;
@@ -414,10 +450,30 @@ function viteCaddyTlsPlugin({
     let resolvedPort = null;
     let resolvedHost = null;
     let setupStarted = false;
+    function buildDomainResolutionMessage() {
+      const issues = [];
+      if (domain !== void 0 && !normalizeDomains(domain)) {
+        issues.push("`domain` is empty after trimming");
+      }
+      if (baseDomain !== void 0 && !normalizeBaseDomain(baseDomain)) {
+        issues.push("`baseDomain` is empty after trimming");
+      }
+      const info = getGitRepoInfo();
+      const resolvedRepo = repo ?? info.repo;
+      const resolvedBranch = branch ?? info.branch;
+      if (!resolvedRepo) {
+        issues.push("repo name not found (not a git repo?)");
+      }
+      if (!resolvedBranch) {
+        issues.push("branch name not found (detached HEAD?)");
+      }
+      if (issues.length === 0) {
+        return "No domain resolved. Provide `domain`, or `repo` and `branch`, or ensure git metadata is available.";
+      }
+      return `No domain resolved. Issues: ${issues.join("; ")}. Provide \`domain\`, or \`repo\` and \`branch\`, or ensure git metadata is available.`;
+    }
     if (domainArray.length === 0) {
-      console.error(
-        "No domain resolved. Provide domain, or run inside a git repo, or pass repo/branch."
-      );
+      console.error(buildDomainResolutionMessage());
       return;
     }
     let tlsPolicyAdded = false;
@@ -487,13 +543,19 @@ function viteCaddyTlsPlugin({
       updateResolvedTarget();
       return resolvedHost ?? "127.0.0.1";
     }
+    function formatUpstreamTarget(host, port) {
+      if (host.includes(":") && !host.startsWith("[")) {
+        return `[${host}]:${port}`;
+      }
+      return `${host}:${port}`;
+    }
     async function cleanupRoute() {
       if (cleanupStarted) return;
       cleanupStarted = true;
       if (tlsPolicyId) {
-        await removeTlsPolicy(tlsPolicyId);
+        await removeWithRetry(() => removeTlsPolicy(tlsPolicyId), "TLS policy");
       }
-      await removeRoute(routeId);
+      await removeWithRetry(() => removeRoute(routeId), "route");
     }
     function onServerClose() {
       void cleanupRoute();
@@ -515,6 +577,24 @@ function viteCaddyTlsPlugin({
       process.once("SIGINT", onSigint);
       process.once("SIGTERM", onSigterm);
     }
+    function wait(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async function removeWithRetry(remover, label, maxAttempts = 3) {
+      let attempt = 0;
+      let delayMs = 100;
+      while (attempt < maxAttempts) {
+        const ok = await remover();
+        if (ok) return true;
+        attempt += 1;
+        if (attempt < maxAttempts) {
+          await wait(delayMs);
+          delayMs *= 2;
+        }
+      }
+      console.error(`Failed to remove ${label} after ${maxAttempts} attempts.`);
+      return false;
+    }
     async function setupRoute() {
       if (!validateCaddyIsInstalled()) {
         return;
@@ -530,7 +610,10 @@ function viteCaddyTlsPlugin({
       try {
         await ensureBaseConfig(serverName);
       } catch (e) {
-        console.error("Failed to configure Caddy base settings.", e);
+        console.error(
+          `Failed to configure Caddy base settings. Is the Caddy Admin API reachable at ${getCaddyApiUrl()}?`,
+          e
+        );
         return;
       }
       const port = getServerPort();
@@ -540,7 +623,10 @@ function viteCaddyTlsPlugin({
           await addTlsPolicy(tlsPolicyId, domainArray);
           tlsPolicyAdded = true;
         } catch (e) {
-          console.error("Failed to add TLS policy to Caddy.", e);
+          console.error(
+            `Failed to add TLS policy to Caddy. Is the Caddy Admin API reachable at ${getCaddyApiUrl()}?`,
+            e
+          );
           return;
         }
       }
@@ -558,10 +644,15 @@ function viteCaddyTlsPlugin({
         if (tlsPolicyAdded && tlsPolicyId) {
           await removeTlsPolicy(tlsPolicyId);
         }
-        console.error("Failed to add route to Caddy.", e);
+        console.error(
+          `Failed to add route to Caddy. Is the Caddy Admin API reachable at ${getCaddyApiUrl()}?`,
+          e
+        );
         return;
       }
       console.log("\n\u{1F512} Caddy is proxying your traffic on https");
+      console.log(`
+\u27A1\uFE0F Upstream target: http://${formatUpstreamTarget(upstreamHost, port)}`);
       console.log(
         `
 \u{1F517} Access your local ${domainArray.length > 1 ? "servers" : "server"}!`
@@ -615,10 +706,24 @@ function viteCaddyTlsPlugin({
   return {
     name: "vite:caddy-tls",
     config(userConfig) {
+      const resolvedDomains = resolveDomains({
+        domain,
+        baseDomain,
+        loopbackDomain,
+        repo,
+        branch
+      });
+      const defaultHmrDomain = resolvedDomains?.[0];
+      const hmrConfig = userConfig.server?.hmr === void 0 && defaultHmrDomain ? {
+        protocol: "wss",
+        host: defaultHmrDomain,
+        clientPort: 443
+      } : userConfig.server?.hmr;
       return {
         server: {
           host: userConfig.server?.host === void 0 ? true : userConfig.server.host,
-          allowedHosts: userConfig.server?.allowedHosts === void 0 ? true : userConfig.server.allowedHosts
+          allowedHosts: userConfig.server?.allowedHosts === void 0 ? true : userConfig.server.allowedHosts,
+          ...hmrConfig !== void 0 ? { hmr: hmrConfig } : {}
         },
         preview: {
           host: userConfig.preview?.host === void 0 ? true : userConfig.preview.host,

package/package.json

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