unplugin-https-reverse-proxy 4.1.0-beta.8 → 4.1.0-beta.9

package/dist/{chunk-ICH7VY4H.js → chunk-3NHJSYFO.js}

@@ -13149,29 +13149,31 @@ function writeConfig(proxies) {
   writeFileSync(temp, content);
   renameSync(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => existsSync2(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: process3.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14020,10 +14022,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return join6(
+    process8.platform === "win32" ? `${process8.env.AppData}/Caddy` : `${process8.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await writeFile2(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14079,10 +14094,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return join6(
-      process8.platform === "win32" ? `${process8.env.AppData}/Caddy` : `${process8.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await writeFile2(caddyFilePath, this.caddyfile || "");

package/dist/esbuild.cjs

@@ -13197,29 +13197,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14120,10 +14122,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14179,10 +14194,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/esbuild.js

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
 import "./chunk-WOMR3ZLM.js";

package/dist/index.cjs

@@ -13197,29 +13197,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14120,10 +14122,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14179,10 +14194,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   unplugin,
   unpluginFactory,
   vitePrintUrls
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
 import "./chunk-WOMR3ZLM.js";

package/dist/nuxt.cjs

@@ -13198,29 +13198,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14121,10 +14123,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14180,10 +14195,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/nuxt.js

@@ -1,6 +1,6 @@
 import {
   vitePrintUrls
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import {
   consola
 } from "./chunk-EY3HXBJ4.js";

package/dist/privileged-helper.cjs

@@ -381,7 +381,8 @@ function createHelperRuntime(deps) {
         await dispose();
     },
     dispose,
-    sweepStaleEntries
+    sweepStaleEntries,
+    clientCount: () => clients.size
   };
 }
 async function reclaimTree(target, uid, gid) {
@@ -432,6 +433,14 @@ function createNodeHelperDeps(options) {
   const log = options.log ?? ((message) => import_node_process.default.stdout.write(`${message}
 `));
   let caddy;
+  import_node_process.default.on("exit", () => {
+    if ((caddy == null ? void 0 : caddy.pid) === void 0)
+      return;
+    try {
+      import_node_process.default.kill(caddy.pid, "SIGTERM");
+    } catch {
+    }
+  });
   return {
     readHosts: () => (0, import_node_fs.readFileSync)(hostsPath, "utf8"),
     writeHosts: (content) => {
@@ -476,7 +485,8 @@ function createNodeHelperDeps(options) {
       const child = (0, import_node_child_process.spawn)(options.caddyBin, ["run", "--adapter", "caddyfile", "--config", options.caddyConfigPath, "--watch"], {
         cwd: options.caddyCwd ?? import_node_process.default.cwd(),
         env: { ...import_node_process.default.env, ...options.caddyEnv },
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: (0, import_node_os.platform)() !== "win32"
       });
       const handle = {
         pid: child.pid,
@@ -750,13 +760,14 @@ async function main() {
       XDG_DATA_HOME: import_node_process3.default.env.XDG_DATA_HOME ?? ""
     }
   });
-  import_node_process3.default.on("SIGINT", () => {
-  });
-  const shutdown = () => {
+  for (const signal of ["SIGINT", "SIGQUIT", "SIGTSTP", "SIGHUP"])
+    import_node_process3.default.on(signal, () => {
+    });
+  import_node_process3.default.on("SIGTERM", () => {
+    if (helper.runtime.clientCount() > 0)
+      return;
     void helper.runtime.dispose().finally(() => import_node_process3.default.exit(0));
-  };
-  import_node_process3.default.on("SIGTERM", shutdown);
-  import_node_process3.default.on("SIGHUP", shutdown);
+  });
   import_node_process3.default.stdout.on("error", () => {
   });
   import_node_process3.default.stderr.on("error", () => {

package/dist/privileged-helper.js

@@ -355,7 +355,8 @@ function createHelperRuntime(deps) {
         await dispose();
     },
     dispose,
-    sweepStaleEntries
+    sweepStaleEntries,
+    clientCount: () => clients.size
   };
 }
 async function reclaimTree(target, uid, gid) {
@@ -406,6 +407,14 @@ function createNodeHelperDeps(options) {
   const log = options.log ?? ((message) => process.stdout.write(`${message}
 `));
   let caddy;
+  process.on("exit", () => {
+    if ((caddy == null ? void 0 : caddy.pid) === void 0)
+      return;
+    try {
+      process.kill(caddy.pid, "SIGTERM");
+    } catch {
+    }
+  });
   return {
     readHosts: () => readFileSync(hostsPath, "utf8"),
     writeHosts: (content) => {
@@ -450,7 +459,8 @@ function createNodeHelperDeps(options) {
       const child = spawn(options.caddyBin, ["run", "--adapter", "caddyfile", "--config", options.caddyConfigPath, "--watch"], {
         cwd: options.caddyCwd ?? process.cwd(),
         env: { ...process.env, ...options.caddyEnv },
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: platform() !== "win32"
       });
       const handle = {
         pid: child.pid,
@@ -724,13 +734,14 @@ async function main() {
       XDG_DATA_HOME: process3.env.XDG_DATA_HOME ?? ""
     }
   });
-  process3.on("SIGINT", () => {
-  });
-  const shutdown = () => {
+  for (const signal of ["SIGINT", "SIGQUIT", "SIGTSTP", "SIGHUP"])
+    process3.on(signal, () => {
+    });
+  process3.on("SIGTERM", () => {
+    if (helper.runtime.clientCount() > 0)
+      return;
     void helper.runtime.dispose().finally(() => process3.exit(0));
-  };
-  process3.on("SIGTERM", shutdown);
-  process3.on("SIGHUP", shutdown);
+  });
   process3.stdout.on("error", () => {
   });
   process3.stderr.on("error", () => {

package/dist/rollup.cjs

@@ -13197,29 +13197,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14120,10 +14122,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14179,10 +14194,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/rollup.js

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
 import "./chunk-WOMR3ZLM.js";

package/dist/rspack.cjs

@@ -13196,29 +13196,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14119,10 +14121,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14178,10 +14193,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/rspack.js

@@ -1,6 +1,6 @@
 import {
   src_default
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
 import "./chunk-WOMR3ZLM.js";

package/dist/vite.cjs

@@ -13197,29 +13197,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14120,10 +14122,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14179,10 +14194,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/vite.js

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
 import "./chunk-WOMR3ZLM.js";

package/dist/webpack.cjs

@@ -13197,29 +13197,31 @@ function writeConfig(proxies) {
   (0, import_node_fs.writeFileSync)(temp, content);
   (0, import_node_fs.renameSync)(temp, caddyConfigPath);
 }
-async function mutateConfig(lock3, mutate) {
-  const release = await lock3.acquire();
-  try {
-    const proxies = readConfig();
-    mutate(proxies);
-    writeConfig(proxies);
-    return proxies;
-  } finally {
-    release();
-  }
-}
 function useCaddyConfig(options = {}) {
   const lock3 = options.lock ?? createFileLock();
+  async function mutate(apply) {
+    var _a4;
+    const release = await lock3.acquire();
+    try {
+      const proxies = readConfig();
+      apply(proxies);
+      writeConfig(proxies);
+      await ((_a4 = options.renderCaddyfile) == null ? void 0 : _a4.call(options, proxies));
+      return proxies;
+    } finally {
+      release();
+    }
+  }
   return {
     configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock3, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: import_node_process2.default.pid };
       });
     },
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock3, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route];
@@ -14120,10 +14122,23 @@ function testCaddy() {
     });
   });
 }
+function caddyRootPath() {
+  return (0, import_node_path5.join)(
+    import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
+    "./pki/authorities/local"
+  );
+}
+async function renderCaddyfile(proxies) {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies)
+  });
+  await (0, import_promises2.writeFile)(caddyFilePath, await genCaddyfile(ctx));
+}
 var caddyConfig;
 function getCaddyConfig() {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig();
+    caddyConfig = useCaddyConfig({ renderCaddyfile });
   }
   return caddyConfig;
 }
@@ -14179,10 +14194,7 @@ var CaddyInstant = class {
     return this.caddyfile;
   }
   get caddyRoot() {
-    return (0, import_node_path5.join)(
-      import_node_process8.default.platform === "win32" ? `${import_node_process8.default.env.AppData}/Caddy` : `${import_node_process8.default.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    );
+    return caddyRootPath();
   }
   async writeCaddyfile() {
     return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");

package/dist/webpack.js

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-ICH7VY4H.js";
+} from "./chunk-3NHJSYFO.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
 import "./chunk-WOMR3ZLM.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "4.1.0-beta.8",
+  "version": "4.1.0-beta.9",
   "description": "",
   "license": "MIT",
   "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",

package/src/caddy/config.ts

@@ -84,43 +84,58 @@ function writeConfig(proxies: ProxyMap): void {
   renameSync(temp, caddyConfigPath)
 }
 
-/** Applies `mutate` under the file lock, re-reading the latest state first. */
-async function mutateConfig(
-  lock: ConfigLock,
-  mutate: (proxies: ProxyMap) => void,
-): Promise<ProxyMap> {
-  const release = await lock.acquire()
-  try {
-    const proxies = readConfig()
-    mutate(proxies)
-    writeConfig(proxies)
-    return proxies
-  }
-  finally {
-    release()
-  }
-}
-
 export interface CaddyConfigOptions {
   /** Injected in tests so they do not need the real lock. */
   lock?: ConfigLock
+  /**
+   * Renders the Caddyfile from the routes, called inside the config lock.
+   *
+   * Rendering here rather than in the caller is what keeps the file in step
+   * with the JSON: two projects writing concurrently would otherwise render
+   * from their own stale view and the later write would win.
+   */
+  renderCaddyfile?: (proxies: ProxyMap) => Promise<void>
 }
 
 export function useCaddyConfig(options: CaddyConfigOptions = {}): CaddyConfigApi {
   const lock = options.lock ?? createFileLock()
 
+  /**
+   * Applies the change, then re-renders while still holding the lock.
+   *
+   * The Caddyfile has to follow every change: leaving a stopped project's site
+   * in it would keep proxying to an upstream that is gone. Doing it inside the
+   * lock also picks up routes whose owner process died, since `readConfig`
+   * drops those.
+   */
+  async function mutate(
+    apply: (proxies: ProxyMap) => void,
+  ): Promise<ProxyMap> {
+    const release = await lock.acquire()
+    try {
+      const proxies = readConfig()
+      apply(proxies)
+      writeConfig(proxies)
+      await options.renderCaddyfile?.(proxies)
+      return proxies
+    }
+    finally {
+      release()
+    }
+  }
+
   return {
     configJsonRef: () => (existsSync(caddyConfigPath) ? readConfig() : undefined),
 
     async writeCaddyConfig(_proxies, key) {
-      await mutateConfig(lock, (proxies) => {
+      await mutate((proxies) => {
         for (const p of _proxies)
           proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: process.pid }
       })
     },
 
     async removeProxy(key) {
-      const proxies = await mutateConfig(lock, (current) => {
+      const proxies = await mutate((current) => {
         for (const route of Object.keys(current)) {
           if (route.endsWith(`#${key}`))
             delete current[route]

package/src/caddy/index.ts

@@ -106,11 +106,35 @@ interface RunOptions {
   healthCheck?: boolean
 }
 
+/** Where Caddy keeps the local CA; the template serves it for device installs. */
+function caddyRootPath(): string {
+  return join(
+    process.platform === 'win32'
+      ? `${process.env.AppData!}/Caddy`
+      : `${process.env.HOME!}/Library/Application Support/Caddy`,
+    './pki/authorities/local',
+  )
+}
+
+/**
+ * Renders the Caddyfile from the routes currently on disk and writes it.
+ *
+ * Called from inside the config lock, so two projects writing at once cannot
+ * render from their own stale view of the routes.
+ */
+async function renderCaddyfile(proxies: Record<string, unknown>): Promise<void> {
+  const ctx = validateTemplateContext({
+    caddy_root: caddyRootPath(),
+    proxies: Object.values(proxies) as never,
+  })
+  await writeFile(caddyFilePath, await genCaddyfile(ctx))
+}
+
 let caddyConfig: ReturnType<typeof useCaddyConfig> | undefined
 
 function getCaddyConfig(): ReturnType<typeof useCaddyConfig> {
   if (!caddyConfig) {
-    caddyConfig = useCaddyConfig()
+    caddyConfig = useCaddyConfig({ renderCaddyfile: renderCaddyfile as never })
   }
   return caddyConfig
 }
@@ -194,12 +218,7 @@ export class CaddyInstant {
   }
 
   get caddyRoot(): string {
-    return join(
-      process.platform === 'win32'
-        ? `${process.env.AppData!}/Caddy`
-        : `${process.env.HOME!}/Library/Application Support/Caddy`,
-      './pki/authorities/local',
-    )
+    return caddyRootPath()
   }
 
   async writeCaddyfile(): Promise<void> {

package/src/privileged/server.ts

@@ -104,6 +104,8 @@ export interface HelperRuntime {
   dispose: () => Promise<void>
   /** Removes hosts entries a previous crashed session left behind. */
   sweepStaleEntries: () => Promise<boolean>
+  /** Number of attached dev servers; a signal must not tear down a live one. */
+  clientCount: () => number
 }
 
 /**
@@ -332,6 +334,7 @@ export function createHelperRuntime(deps: HelperDeps): HelperRuntime {
     },
     dispose,
     sweepStaleEntries,
+    clientCount: () => clients.size,
   }
 }
 
@@ -413,6 +416,19 @@ export function createNodeHelperDeps(options: NodeHelperDepsOptions): HelperDeps
   const log = options.log ?? ((message: string) => process.stdout.write(`${message}\n`))
   let caddy: CaddyChild | undefined
 
+  // Caddy runs in its own session, so it no longer dies with this process. The
+  // `exit` hook is the last chance to take it down; it must stay synchronous,
+  // which `kill` is. Nothing runs after SIGKILL, and that case is covered by
+  // the next start freeing the port.
+  process.on('exit', () => {
+    if (caddy?.pid === undefined)
+      return
+    try {
+      process.kill(caddy.pid, 'SIGTERM')
+    }
+    catch {}
+  })
+
   return {
     readHosts: () => readFileSync(hostsPath, 'utf8'),
     writeHosts: (content) => {
@@ -465,10 +481,18 @@ export function createNodeHelperDeps(options: NodeHelperDepsOptions): HelperDeps
     startCaddy: (emit) => {
       // `--watch` makes Caddy reload when another project rewrites the shared
       // Caddyfile. Without it the second project's route never takes effect.
+      //
+      // `detached` puts Caddy in its own session. It shares one Caddy between
+      // projects, so the Ctrl+C that stops one dev server must not reach it:
+      // the whole foreground process group gets SIGINT, and Caddy exits on
+      // SIGINT. `kill()` still targets the pid, and the exit event still fires.
+      // Windows has no process groups to escape and `detached` would open a
+      // console window there, so it stays off.
       const child = spawn(options.caddyBin, ['run', '--adapter', 'caddyfile', '--config', options.caddyConfigPath, '--watch'], {
         cwd: options.caddyCwd ?? process.cwd(),
         env: { ...process.env, ...options.caddyEnv },
         stdio: ['ignore', 'pipe', 'pipe'],
+        detached: platform() !== 'win32',
       })
       const handle: CaddyChild & { running?: boolean } = {
         pid: child.pid,

package/src/privileged-helper.ts

@@ -86,17 +86,25 @@ async function main(): Promise<void> {
     },
   })
 
-  // Ctrl+C is delivered to the whole foreground process group. The plugin also
-  // receives it and will drop the socket, which is the signal this helper acts
-  // on; exiting here would race that cleanup.
-  process.on('SIGINT', () => {})
+  // Terminal signals reach the whole foreground process group, so they also hit
+  // this helper when one of several dev servers stops. Acting on them would tear
+  // down the shared Caddy and hosts entries the remaining projects still use.
+  // The socket closing is the only signal this helper acts on.
+  //
+  // Ctrl+C, Ctrl+\, Ctrl+Z and a terminal closing all arrive this way: SIGINT,
+  // SIGQUIT, SIGTSTP and SIGHUP. Ignoring SIGTSTP also keeps the helper from
+  // being suspended, which would stall every attached project's RPC.
+  for (const signal of ['SIGINT', 'SIGQUIT', 'SIGTSTP', 'SIGHUP'] as const)
+    process.on(signal, () => {})
 
-  const shutdown = (): void => {
+  // SIGTERM is different: IDE and process-tree runners send it to shut the tool
+  // down for real. It still must not drop a live session, so it only tears down
+  // when no dev server is attached.
+  process.on('SIGTERM', () => {
+    if (helper.runtime.clientCount() > 0)
+      return
     void helper.runtime.dispose().finally(() => process.exit(0))
-  }
-
-  process.on('SIGTERM', shutdown)
-  process.on('SIGHUP', shutdown)
+  })
 
   // A closed stdout (the parent died) must not interrupt the cleanup path.
   process.stdout.on('error', () => {})