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

package/dist/rollup.js

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-FNF6HQJB.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];
@@ -13673,19 +13675,22 @@ function takeBackTerminal() {
     return () => {
     };
   const wasRaw = stdin.isRaw === true;
+  stdin.pause();
   try {
     stdin.setRawMode(false);
   } catch {
+    stdin.resume();
     return () => {
     };
   }
   return () => {
-    if (!wasRaw)
-      return;
-    try {
-      stdin.setRawMode(true);
-    } catch {
+    if (wasRaw) {
+      try {
+        stdin.setRawMode(true);
+      } catch {
+      }
     }
+    stdin.resume();
   };
 }
 var PrivilegeDeniedError = class extends Error {
@@ -14116,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;
 }
@@ -14175,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-FNF6HQJB.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];
@@ -13674,19 +13676,22 @@ function takeBackTerminal() {
     return () => {
     };
   const wasRaw = stdin.isRaw === true;
+  stdin.pause();
   try {
     stdin.setRawMode(false);
   } catch {
+    stdin.resume();
     return () => {
     };
   }
   return () => {
-    if (!wasRaw)
-      return;
-    try {
-      stdin.setRawMode(true);
-    } catch {
+    if (wasRaw) {
+      try {
+        stdin.setRawMode(true);
+      } catch {
+      }
     }
+    stdin.resume();
   };
 }
 var PrivilegeDeniedError = class extends Error {
@@ -14117,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;
 }
@@ -14176,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-FNF6HQJB.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];
@@ -13674,19 +13676,22 @@ function takeBackTerminal() {
     return () => {
     };
   const wasRaw = stdin.isRaw === true;
+  stdin.pause();
   try {
     stdin.setRawMode(false);
   } catch {
+    stdin.resume();
     return () => {
     };
   }
   return () => {
-    if (!wasRaw)
-      return;
-    try {
-      stdin.setRawMode(true);
-    } catch {
+    if (wasRaw) {
+      try {
+        stdin.setRawMode(true);
+      } catch {
+      }
     }
+    stdin.resume();
   };
 }
 var PrivilegeDeniedError = class extends Error {
@@ -14117,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;
 }
@@ -14176,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-FNF6HQJB.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.7",
+  "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/launch.ts

@@ -146,13 +146,18 @@ function runPrompt(sudoCommand: string): Promise<{ status: number | null, signal
 }
 
 /**
- * Returns the terminal to cooked mode for the duration of the prompt.
+ * Gives the terminal to `sudo` for the duration of the prompt.
  *
- * Vite leaves stdin in raw mode while it listens for its own shortcuts. In raw
- * mode the tty does no line editing, so the Enter that should submit the
- * password only reaches sudo as a bare carriage return and the read does not
- * complete. The returned function puts the previous state back, so Vite's
- * shortcuts keep working afterwards.
+ * Vite keeps stdin in raw mode with a `data` listener attached, so that every
+ * keystroke reaches its shortcut handler. Two things break the password read:
+ *
+ * 1. Raw mode does no line editing, so Enter never terminates the line sudo is
+ *    waiting for.
+ * 2. The `data` listener is resumed, so it consumes the characters before sudo
+ *    can see them. sudo then reads nothing and reports a wrong password.
+ *
+ * Both are undone here and restored afterwards, so Vite's shortcuts keep
+ * working once the prompt is over.
  */
 function takeBackTerminal(): () => void {
   const stdin = process.stdin
@@ -160,20 +165,28 @@ function takeBackTerminal(): () => void {
     return () => {}
 
   const wasRaw = stdin.isRaw === true
+
+  // `pause` detaches the stream from the tty without removing Vite's listener,
+  // so the same handler still works when the stream is resumed later.
+  stdin.pause()
+
   try {
     stdin.setRawMode(false)
   }
   catch {
+    stdin.resume()
     return () => {}
   }
 
   return () => {
-    if (!wasRaw)
-      return
-    try {
-      stdin.setRawMode(true)
+    if (wasRaw) {
+      try {
+        stdin.setRawMode(true)
+      }
+      catch {}
     }
-    catch {}
+    // Resume last: Vite's listener is still attached and expects a live stream.
+    stdin.resume()
   }
 }
 

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', () => {})