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

package/README.md

@@ -92,6 +92,26 @@ export default config;
 
 You can override auto-detection with `repo` or `branch` if needed.
 
+If you run different projects that derive the same `<repo>.<branch>` host, add `instanceLabel` to keep domains unique:
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import caddyTls from 'vite-plugin-caddy-multiple-tls';
+
+const config = defineConfig({
+  plugins: [
+    caddyTls({
+      instanceLabel: 'web-1',
+    })
+  ]
+});
+
+export default config;
+```
+
+This derives a host like `<repo>.<branch>.web-1.localhost`.
+
 For a zero-config experience, use `baseDomain: 'localhost'` (the default) so the derived domain works without editing `/etc/hosts`.
 
 `internalTls` defaults to `true` when you pass `baseDomain` or `domain`. You can override it if needed.

package/dist/index.d.ts

@@ -11,6 +11,8 @@ interface ViteCaddyTlsPluginOptions {
     repo?: string;
     /** Override branch name used in derived domains */
     branch?: string;
+    /** Extra unique label appended after branch in derived domains */
+    instanceLabel?: string;
     cors?: string;
     /** Override the default Caddy server name (srv0) */
     serverName?: string;
@@ -37,6 +39,6 @@ type LoopbackDomain = 'localtest.me' | 'lvh.me' | 'nip.io';
  * ```
  * @returns {Plugin} - a Vite plugin
  */
-declare function viteCaddyTlsPlugin({ domain, baseDomain, loopbackDomain, repo, branch, cors, serverName, caddyApiUrl, internalTls, upstreamHostHeader, }?: ViteCaddyTlsPluginOptions): PluginOption;
+declare function viteCaddyTlsPlugin({ domain, baseDomain, loopbackDomain, repo, branch, instanceLabel, cors, serverName, caddyApiUrl, internalTls, upstreamHostHeader, }?: ViteCaddyTlsPluginOptions): PluginOption;
 
 export { type ViteCaddyTlsPluginOptions, viteCaddyTlsPlugin as default };

package/dist/index.js

@@ -1,18 +1,16 @@
 // src/index.ts
 import { execSync as execSync2 } from "child_process";
-import path from "path";
+import { createHash as createHash2 } from "crypto";
+import path2 from "path";
 
 // src/utils.ts
 import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { open, unlink } from "fs/promises";
+import os from "os";
+import path from "path";
 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);
 }
@@ -27,6 +25,42 @@ function parseConfig(text) {
 function isTlsPolicyOverlapError(text) {
   return text.includes("cannot apply more than one automation policy to host");
 }
+function getApiUrl(apiUrl) {
+  return apiUrl ?? DEFAULT_CADDY_API_URL;
+}
+function getLockPath(apiUrl) {
+  const key = createHash("sha1").update(getApiUrl(apiUrl)).digest("hex").slice(0, 12);
+  return path.join(os.tmpdir(), `vite-plugin-caddy-multiple-tls-${key}.lock`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withApiLock(apiUrl, fn) {
+  const lockPath = getLockPath(apiUrl);
+  const startedAt = Date.now();
+  const timeoutMs = 5e3;
+  while (true) {
+    try {
+      const handle = await open(lockPath, "wx");
+      try {
+        await fn();
+      } finally {
+        await handle.close();
+        await unlink(lockPath).catch(() => void 0);
+      }
+      return;
+    } catch (e) {
+      if (e.code !== "EEXIST") {
+        throw e;
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        await fn();
+        return;
+      }
+      await sleep(50);
+    }
+  }
+}
 function validateCaddyIsInstalled() {
   try {
     execSync("caddy version");
@@ -36,29 +70,28 @@ function validateCaddyIsInstalled() {
     return false;
   }
 }
-async function isCaddyRunning() {
+async function isCaddyRunning(apiUrl) {
   try {
-    const res = await fetch(`${caddyApiUrl}/config/`);
+    const res = await fetch(`${getApiUrl(apiUrl)}/config/`);
     return res.ok;
   } catch (e) {
     return false;
   }
 }
-async function startCaddy() {
+async function startCaddy(apiUrl) {
   try {
     execSync("caddy start", { stdio: "ignore" });
-    for (let i = 0; i < 10; i++) {
-      if (await isCaddyRunning()) return true;
-      await new Promise((r) => setTimeout(r, 500));
-    }
-    return false;
   } catch (e) {
-    console.error("Failed to start Caddy:", e);
-    return false;
   }
+  for (let i = 0; i < 10; i++) {
+    if (await isCaddyRunning(apiUrl)) return true;
+    await sleep(500);
+  }
+  return false;
 }
-async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
-  const serverUrl = `${caddyApiUrl}/config/apps/http/servers/${serverName}`;
+async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME, apiUrl) {
+  const resolvedApiUrl = getApiUrl(apiUrl);
+  const serverUrl = `${resolvedApiUrl}/config/apps/http/servers/${serverName}`;
   const res = await fetch(serverUrl);
   if (res.ok) return;
   const baseConfig = {
@@ -70,7 +103,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
       [serverName]: baseConfig
     }
   };
-  const configRes = await fetch(`${caddyApiUrl}/config/`);
+  const configRes = await fetch(`${resolvedApiUrl}/config/`);
   if (!configRes.ok) {
     const text = await configRes.text();
     throw new Error(`Failed to read Caddy config: ${text}`);
@@ -82,7 +115,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(`${caddyApiUrl}/load`, {
+    const loadRes = await fetch(`${resolvedApiUrl}/load`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -104,7 +137,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
   let hasHttp = isRecord(http);
   let hasServers = isRecord(servers);
   if (!hasApps) {
-    const createAppsRes = await fetch(`${caddyApiUrl}/config/apps`, {
+    const createAppsRes = await fetch(`${resolvedApiUrl}/config/apps`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({})
@@ -116,7 +149,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
     hasApps = true;
   }
   if (!hasHttp) {
-    const createHttpRes = await fetch(`${caddyApiUrl}/config/apps/http`, {
+    const createHttpRes = await fetch(`${resolvedApiUrl}/config/apps/http`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ servers: {} })
@@ -129,7 +162,7 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
     hasServers = true;
   }
   if (!hasServers) {
-    const createServersRes = await fetch(`${caddyApiUrl}/config/apps/http/servers`, {
+    const createServersRes = await fetch(`${resolvedApiUrl}/config/apps/http/servers`, {
       method: "PUT",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({})
@@ -149,8 +182,9 @@ async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
     throw new Error(`Failed to initialize Caddy base configuration: ${text}`);
   }
 }
-async function ensureTlsAutomation() {
-  const policiesUrl = `${caddyApiUrl}/config/apps/tls/automation/policies`;
+async function ensureTlsAutomation(apiUrl) {
+  const resolvedApiUrl = getApiUrl(apiUrl);
+  const policiesUrl = `${resolvedApiUrl}/config/apps/tls/automation/policies`;
   const policiesRes = await fetch(policiesUrl);
   if (policiesRes.ok) return;
   const policiesText = await policiesRes.text();
@@ -159,7 +193,7 @@ async function ensureTlsAutomation() {
       `Failed to initialize Caddy TLS automation: ${policiesText}`
     );
   }
-  const automationRes = await fetch(`${caddyApiUrl}/config/apps/tls/automation`, {
+  const automationRes = await fetch(`${resolvedApiUrl}/config/apps/tls/automation`, {
     method: "PUT",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ policies: [] })
@@ -171,7 +205,7 @@ async function ensureTlsAutomation() {
       `Failed to initialize Caddy TLS automation: ${automationText}`
     );
   }
-  const tlsRes = await fetch(`${caddyApiUrl}/config/apps/tls`, {
+  const tlsRes = await fetch(`${resolvedApiUrl}/config/apps/tls`, {
     method: "PUT",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ automation: { policies: [] } })
@@ -187,7 +221,47 @@ function formatDialAddress(host, port) {
   }
   return `${host}:${port}`;
 }
-async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAME, upstreamHost = "127.0.0.1", upstreamHostHeader) {
+function extractMatchedHosts(route) {
+  if (!isRecord(route)) return [];
+  const match = route.match;
+  if (!Array.isArray(match)) return [];
+  const hosts = [];
+  for (const item of match) {
+    if (!isRecord(item) || !Array.isArray(item.host)) continue;
+    for (const host of item.host) {
+      if (typeof host === "string") {
+        hosts.push(host);
+      }
+    }
+  }
+  return hosts;
+}
+function intersectsDomains(targetDomains, routeDomains) {
+  if (targetDomains.length === 0 || routeDomains.length === 0) return false;
+  const targetSet = new Set(targetDomains);
+  return routeDomains.some((domain) => targetSet.has(domain));
+}
+async function cleanupStaleRoutesForDomains(domains, currentRouteId, serverName = DEFAULT_SERVER_NAME, apiUrl) {
+  if (domains.length === 0) return;
+  const res = await fetch(
+    `${getApiUrl(apiUrl)}/config/apps/http/servers/${serverName}/routes`
+  );
+  if (!res.ok) return;
+  const text = await res.text();
+  const parsed = parseConfig(text);
+  if (!Array.isArray(parsed)) return;
+  for (const route of parsed) {
+    if (!isRecord(route)) continue;
+    const id = route["@id"];
+    if (typeof id !== "string") continue;
+    if (!id.startsWith("vite-proxy-")) continue;
+    if (id === currentRouteId) continue;
+    const routeDomains = extractMatchedHosts(route);
+    if (!intersectsDomains(domains, routeDomains)) continue;
+    await removeRoute(id, apiUrl);
+  }
+}
+async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAME, upstreamHost = "127.0.0.1", upstreamHostHeader, apiUrl) {
   const handlers = [];
   if (cors) {
     handlers.push({
@@ -238,7 +312,7 @@ async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAM
     terminal: true
   };
   const res = await fetch(
-    `${caddyApiUrl}/config/apps/http/servers/${serverName}/routes`,
+    `${getApiUrl(apiUrl)}/config/apps/http/servers/${serverName}/routes`,
     {
       method: "POST",
       // Append to routes list
@@ -251,8 +325,8 @@ async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAM
     throw new Error(`Failed to add route: ${text}`);
   }
 }
-async function addTlsPolicy(id, domains) {
-  await ensureTlsAutomation();
+async function addTlsPolicy(id, domains, apiUrl) {
+  await ensureTlsAutomation(apiUrl);
   const policy = {
     "@id": id,
     subjects: domains,
@@ -262,7 +336,7 @@ async function addTlsPolicy(id, domains) {
       }
     ]
   };
-  const res = await fetch(`${caddyApiUrl}/config/apps/tls/automation/policies`, {
+  const res = await fetch(`${getApiUrl(apiUrl)}/config/apps/tls/automation/policies`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(policy)
@@ -275,8 +349,8 @@ async function addTlsPolicy(id, domains) {
     throw new Error(`Failed to add TLS policy: ${text}`);
   }
 }
-async function removeRoute(id) {
-  const res = await fetch(`${caddyApiUrl}/id/${id}`, {
+async function removeRoute(id, apiUrl) {
+  const res = await fetch(`${getApiUrl(apiUrl)}/id/${id}`, {
     method: "DELETE"
   });
   if (!res.ok && res.status !== 404) {
@@ -285,8 +359,8 @@ async function removeRoute(id) {
   }
   return true;
 }
-async function removeTlsPolicy(id) {
-  const res = await fetch(`${caddyApiUrl}/id/${id}`, {
+async function removeTlsPolicy(id, apiUrl) {
+  const res = await fetch(`${getApiUrl(apiUrl)}/id/${id}`, {
     method: "DELETE"
   });
   if (!res.ok && res.status !== 404) {
@@ -295,6 +369,18 @@ async function removeTlsPolicy(id) {
   }
   return true;
 }
+async function ensureCaddyReady(serverName = DEFAULT_SERVER_NAME, apiUrl) {
+  await withApiLock(apiUrl, async () => {
+    let running = await isCaddyRunning(apiUrl);
+    if (!running) {
+      running = await startCaddy(apiUrl);
+    }
+    if (!running) {
+      throw new Error("Failed to start Caddy server.");
+    }
+    await ensureBaseConfig(serverName, apiUrl);
+  });
+}
 
 // src/index.ts
 var LOOPBACK_DOMAINS = {
@@ -310,7 +396,7 @@ function getGitRepoInfo() {
   try {
     const repoRoot = execGit("git rev-parse --show-toplevel");
     if (repoRoot) {
-      info.repo = path.basename(repoRoot);
+      info.repo = path2.basename(repoRoot);
     }
   } catch (e) {
   }
@@ -364,7 +450,13 @@ function buildDerivedDomain(options) {
   const repoLabel = sanitizeDomainLabel(repo);
   const branchLabel = sanitizeDomainLabel(branch);
   if (!repoLabel || !branchLabel) return null;
-  return `${repoLabel}.${branchLabel}.${baseDomain}`;
+  const labels = [repoLabel, branchLabel];
+  if (options.instanceLabel !== void 0) {
+    const instanceLabel = sanitizeDomainLabel(options.instanceLabel);
+    if (!instanceLabel) return null;
+    labels.push(instanceLabel);
+  }
+  return `${labels.join(".")}.${baseDomain}`;
 }
 function normalizeDomain(domain) {
   const trimmed = domain.trim().toLowerCase();
@@ -396,22 +488,27 @@ function viteCaddyTlsPlugin({
   loopbackDomain,
   repo,
   branch,
+  instanceLabel,
   cors,
   serverName,
-  caddyApiUrl: caddyApiUrl2,
+  caddyApiUrl,
   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}.`
-      );
-    }
+  const normalizedApiUrl = caddyApiUrl ? normalizeCaddyApiUrl(caddyApiUrl) : null;
+  const pluginCaddyApiUrl = normalizedApiUrl ?? DEFAULT_CADDY_API_URL;
+  if (caddyApiUrl !== void 0 && !normalizedApiUrl) {
+    console.warn(
+      `caddyApiUrl is empty after trimming. Falling back to ${DEFAULT_CADDY_API_URL}.`
+    );
+  }
+  function getInstanceKey(domains, configRoot) {
+    const keyMaterial = JSON.stringify({
+      domains: [...domains].sort(),
+      cwd: process.cwd(),
+      root: configRoot ?? null
+    });
+    return createHash2("sha1").update(keyMaterial).digest("hex").slice(0, 12);
   }
   function isPreviewServer(server) {
     return server.config.isProduction;
@@ -440,10 +537,11 @@ function viteCaddyTlsPlugin({
       baseDomain,
       loopbackDomain,
       repo,
-      branch
+      branch,
+      instanceLabel
     });
     const domainArray = resolvedDomains ?? [];
-    const routeId = `vite-proxy-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
+    const routeId = `vite-proxy-${getInstanceKey(domainArray, config.root)}`;
     const shouldUseInternalTls = internalTls ?? (baseDomain !== void 0 || loopbackDomain !== void 0 || domain !== void 0);
     const tlsPolicyId = shouldUseInternalTls ? `${routeId}-tls` : null;
     let cleanupStarted = false;
@@ -458,6 +556,9 @@ function viteCaddyTlsPlugin({
       if (baseDomain !== void 0 && !normalizeBaseDomain(baseDomain)) {
         issues.push("`baseDomain` is empty after trimming");
       }
+      if (instanceLabel !== void 0 && !sanitizeDomainLabel(instanceLabel)) {
+        issues.push("`instanceLabel` is empty after sanitization");
+      }
       const info = getGitRepoInfo();
       const resolvedRepo = repo ?? info.repo;
       const resolvedBranch = branch ?? info.branch;
@@ -553,9 +654,12 @@ function viteCaddyTlsPlugin({
       if (cleanupStarted) return;
       cleanupStarted = true;
       if (tlsPolicyId) {
-        await removeWithRetry(() => removeTlsPolicy(tlsPolicyId), "TLS policy");
+        await removeWithRetry(
+          () => removeTlsPolicy(tlsPolicyId, pluginCaddyApiUrl),
+          "TLS policy"
+        );
       }
-      await removeWithRetry(() => removeRoute(routeId), "route");
+      await removeWithRetry(() => removeRoute(routeId, pluginCaddyApiUrl), "route");
     }
     function onServerClose() {
       void cleanupRoute();
@@ -599,32 +703,32 @@ function viteCaddyTlsPlugin({
       if (!validateCaddyIsInstalled()) {
         return;
       }
-      let running = await isCaddyRunning();
-      if (!running) {
-        running = await startCaddy();
-        if (!running) {
-          console.error("Failed to start Caddy server.");
-          return;
-        }
-      }
       try {
-        await ensureBaseConfig(serverName);
+        await ensureCaddyReady(serverName, pluginCaddyApiUrl);
       } catch (e) {
         console.error(
-          `Failed to configure Caddy base settings. Is the Caddy Admin API reachable at ${getCaddyApiUrl()}?`,
+          `Failed to configure Caddy base settings. Is the Caddy Admin API reachable at ${pluginCaddyApiUrl}?`,
           e
         );
         return;
       }
       const port = getServerPort();
       const upstreamHost = getUpstreamHost();
+      await cleanupStaleRoutesForDomains(
+        domainArray,
+        routeId,
+        serverName,
+        pluginCaddyApiUrl
+      );
+      await removeRoute(routeId, pluginCaddyApiUrl);
       if (tlsPolicyId) {
+        await removeTlsPolicy(tlsPolicyId, pluginCaddyApiUrl);
         try {
-          await addTlsPolicy(tlsPolicyId, domainArray);
+          await addTlsPolicy(tlsPolicyId, domainArray, pluginCaddyApiUrl);
           tlsPolicyAdded = true;
         } catch (e) {
           console.error(
-            `Failed to add TLS policy to Caddy. Is the Caddy Admin API reachable at ${getCaddyApiUrl()}?`,
+            `Failed to add TLS policy to Caddy. Is the Caddy Admin API reachable at ${pluginCaddyApiUrl}?`,
             e
           );
           return;
@@ -638,14 +742,15 @@ function viteCaddyTlsPlugin({
           cors,
           serverName,
           upstreamHost,
-          upstreamHostHeader
+          upstreamHostHeader,
+          pluginCaddyApiUrl
         );
       } catch (e) {
         if (tlsPolicyAdded && tlsPolicyId) {
-          await removeTlsPolicy(tlsPolicyId);
+          await removeTlsPolicy(tlsPolicyId, pluginCaddyApiUrl);
         }
         console.error(
-          `Failed to add route to Caddy. Is the Caddy Admin API reachable at ${getCaddyApiUrl()}?`,
+          `Failed to add route to Caddy. Is the Caddy Admin API reachable at ${pluginCaddyApiUrl}?`,
           e
         );
         return;
@@ -680,11 +785,8 @@ function viteCaddyTlsPlugin({
       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();
-        }
+        resolvedPort = null;
+        updateResolvedTarget();
         runSetupOnce();
         return result;
       };
@@ -711,7 +813,8 @@ function viteCaddyTlsPlugin({
         baseDomain,
         loopbackDomain,
         repo,
-        branch
+        branch,
+        instanceLabel
       });
       const defaultHmrDomain = resolvedDomains?.[0];
       const hmrConfig = userConfig.server?.hmr === void 0 && defaultHmrDomain ? {

package/package.json

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