unplugin-https-reverse-proxy 4.1.0-beta.2 → 4.1.0-beta.4

package/dist/webpack.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(webpack_exports);
 var import_unplugin2 = require("unplugin");
 
 // src/index.ts
-var import_node_process8 = __toESM(require("process"), 1);
+var import_node_process9 = __toESM(require("process"), 1);
 var import_console_table_printer = require("console-table-printer");
 var import_picocolors2 = __toESM(require("picocolors"), 1);
 var import_unplugin = require("unplugin");
@@ -44,450 +44,13 @@ var import_unplugin = require("unplugin");
 // src/caddy/index.ts
 var import_node_child_process3 = require("child_process");
 var import_node_fs4 = require("fs");
-var import_promises3 = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_os5 = require("os");
 var import_node_path5 = require("path");
-var import_node_process7 = __toESM(require("process"), 1);
-
-// node_modules/.pnpm/alien-signals@2.0.7/node_modules/alien-signals/esm/system.mjs
-var ReactiveFlags;
-(function(ReactiveFlags2) {
-  ReactiveFlags2[ReactiveFlags2["None"] = 0] = "None";
-  ReactiveFlags2[ReactiveFlags2["Mutable"] = 1] = "Mutable";
-  ReactiveFlags2[ReactiveFlags2["Watching"] = 2] = "Watching";
-  ReactiveFlags2[ReactiveFlags2["RecursedCheck"] = 4] = "RecursedCheck";
-  ReactiveFlags2[ReactiveFlags2["Recursed"] = 8] = "Recursed";
-  ReactiveFlags2[ReactiveFlags2["Dirty"] = 16] = "Dirty";
-  ReactiveFlags2[ReactiveFlags2["Pending"] = 32] = "Pending";
-})(ReactiveFlags || (ReactiveFlags = {}));
-function createReactiveSystem({ update, notify: notify2, unwatched }) {
-  let currentVersion = 0;
-  return {
-    link: link2,
-    unlink: unlink4,
-    propagate: propagate2,
-    checkDirty: checkDirty2,
-    endTracking: endTracking2,
-    startTracking: startTracking2,
-    shallowPropagate: shallowPropagate2
-  };
-  function link2(dep, sub) {
-    const prevDep = sub.depsTail;
-    if (prevDep !== void 0 && prevDep.dep === dep) {
-      return;
-    }
-    const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
-    if (nextDep !== void 0 && nextDep.dep === dep) {
-      nextDep.version = currentVersion;
-      sub.depsTail = nextDep;
-      return;
-    }
-    const prevSub = dep.subsTail;
-    if (prevSub !== void 0 && prevSub.version === currentVersion && prevSub.sub === sub) {
-      return;
-    }
-    const newLink = sub.depsTail = dep.subsTail = {
-      version: currentVersion,
-      dep,
-      sub,
-      prevDep,
-      nextDep,
-      prevSub,
-      nextSub: void 0
-    };
-    if (nextDep !== void 0) {
-      nextDep.prevDep = newLink;
-    }
-    if (prevDep !== void 0) {
-      prevDep.nextDep = newLink;
-    } else {
-      sub.deps = newLink;
-    }
-    if (prevSub !== void 0) {
-      prevSub.nextSub = newLink;
-    } else {
-      dep.subs = newLink;
-    }
-  }
-  function unlink4(link3, sub = link3.sub) {
-    const dep = link3.dep;
-    const prevDep = link3.prevDep;
-    const nextDep = link3.nextDep;
-    const nextSub = link3.nextSub;
-    const prevSub = link3.prevSub;
-    if (nextDep !== void 0) {
-      nextDep.prevDep = prevDep;
-    } else {
-      sub.depsTail = prevDep;
-    }
-    if (prevDep !== void 0) {
-      prevDep.nextDep = nextDep;
-    } else {
-      sub.deps = nextDep;
-    }
-    if (nextSub !== void 0) {
-      nextSub.prevSub = prevSub;
-    } else {
-      dep.subsTail = prevSub;
-    }
-    if (prevSub !== void 0) {
-      prevSub.nextSub = nextSub;
-    } else if ((dep.subs = nextSub) === void 0) {
-      unwatched(dep);
-    }
-    return nextDep;
-  }
-  function propagate2(link3) {
-    let next2 = link3.nextSub;
-    let stack;
-    top:
-      do {
-        const sub = link3.sub;
-        let flags = sub.flags;
-        if (!(flags & 60)) {
-          sub.flags = flags | 32;
-        } else if (!(flags & 12)) {
-          flags = 0;
-        } else if (!(flags & 4)) {
-          sub.flags = flags & ~8 | 32;
-        } else if (!(flags & 48) && isValidLink(link3, sub)) {
-          sub.flags = flags | 40;
-          flags &= 1;
-        } else {
-          flags = 0;
-        }
-        if (flags & 2) {
-          notify2(sub);
-        }
-        if (flags & 1) {
-          const subSubs = sub.subs;
-          if (subSubs !== void 0) {
-            const nextSub = (link3 = subSubs).nextSub;
-            if (nextSub !== void 0) {
-              stack = { value: next2, prev: stack };
-              next2 = nextSub;
-            }
-            continue;
-          }
-        }
-        if ((link3 = next2) !== void 0) {
-          next2 = link3.nextSub;
-          continue;
-        }
-        while (stack !== void 0) {
-          link3 = stack.value;
-          stack = stack.prev;
-          if (link3 !== void 0) {
-            next2 = link3.nextSub;
-            continue top;
-          }
-        }
-        break;
-      } while (true);
-  }
-  function startTracking2(sub) {
-    ++currentVersion;
-    sub.depsTail = void 0;
-    sub.flags = sub.flags & ~56 | 4;
-  }
-  function endTracking2(sub) {
-    const depsTail = sub.depsTail;
-    let toRemove = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
-    while (toRemove !== void 0) {
-      toRemove = unlink4(toRemove, sub);
-    }
-    sub.flags &= ~4;
-  }
-  function checkDirty2(link3, sub) {
-    let stack;
-    let checkDepth = 0;
-    top:
-      do {
-        const dep = link3.dep;
-        const flags = dep.flags;
-        let dirty = false;
-        if (sub.flags & 16) {
-          dirty = true;
-        } else if ((flags & 17) === 17) {
-          if (update(dep)) {
-            const subs = dep.subs;
-            if (subs.nextSub !== void 0) {
-              shallowPropagate2(subs);
-            }
-            dirty = true;
-          }
-        } else if ((flags & 33) === 33) {
-          if (link3.nextSub !== void 0 || link3.prevSub !== void 0) {
-            stack = { value: link3, prev: stack };
-          }
-          link3 = dep.deps;
-          sub = dep;
-          ++checkDepth;
-          continue;
-        }
-        if (!dirty) {
-          const nextDep = link3.nextDep;
-          if (nextDep !== void 0) {
-            link3 = nextDep;
-            continue;
-          }
-        }
-        while (checkDepth--) {
-          const firstSub = sub.subs;
-          const hasMultipleSubs = firstSub.nextSub !== void 0;
-          if (hasMultipleSubs) {
-            link3 = stack.value;
-            stack = stack.prev;
-          } else {
-            link3 = firstSub;
-          }
-          if (dirty) {
-            if (update(sub)) {
-              if (hasMultipleSubs) {
-                shallowPropagate2(firstSub);
-              }
-              sub = link3.sub;
-              continue;
-            }
-          } else {
-            sub.flags &= ~32;
-          }
-          sub = link3.sub;
-          const nextDep = link3.nextDep;
-          if (nextDep !== void 0) {
-            link3 = nextDep;
-            continue top;
-          }
-          dirty = false;
-        }
-        return dirty;
-      } while (true);
-  }
-  function shallowPropagate2(link3) {
-    do {
-      const sub = link3.sub;
-      const flags = sub.flags;
-      if ((flags & 48) === 32) {
-        sub.flags = flags | 16;
-        if (flags & 2) {
-          notify2(sub);
-        }
-      }
-    } while ((link3 = link3.nextSub) !== void 0);
-  }
-  function isValidLink(checkLink, sub) {
-    let link3 = sub.depsTail;
-    while (link3 !== void 0) {
-      if (link3 === checkLink) {
-        return true;
-      }
-      link3 = link3.prevDep;
-    }
-    return false;
-  }
-}
-
-// node_modules/.pnpm/alien-signals@2.0.7/node_modules/alien-signals/esm/index.mjs
-var queuedEffects = [];
-var { link, unlink, propagate, checkDirty, endTracking, startTracking, shallowPropagate } = createReactiveSystem({
-  update(signal2) {
-    if ("getter" in signal2) {
-      return updateComputed(signal2);
-    } else {
-      return updateSignal(signal2, signal2.value);
-    }
-  },
-  notify,
-  unwatched(node2) {
-    if ("getter" in node2) {
-      let toRemove = node2.deps;
-      if (toRemove !== void 0) {
-        node2.flags = 17;
-        do {
-          toRemove = unlink(toRemove, node2);
-        } while (toRemove !== void 0);
-      }
-    } else if (!("previousValue" in node2)) {
-      effectOper.call(node2);
-    }
-  }
-});
-var batchDepth = 0;
-var notifyIndex = 0;
-var queuedEffectsLength = 0;
-var activeSub;
-var activeScope;
-function setCurrentSub(sub) {
-  const prevSub = activeSub;
-  activeSub = sub;
-  return prevSub;
-}
-function signal(initialValue) {
-  return signalOper.bind({
-    previousValue: initialValue,
-    value: initialValue,
-    subs: void 0,
-    subsTail: void 0,
-    flags: 1
-  });
-}
-function computed(getter) {
-  return computedOper.bind({
-    value: void 0,
-    subs: void 0,
-    subsTail: void 0,
-    deps: void 0,
-    depsTail: void 0,
-    flags: 17,
-    getter
-  });
-}
-function effect(fn) {
-  const e = {
-    fn,
-    subs: void 0,
-    subsTail: void 0,
-    deps: void 0,
-    depsTail: void 0,
-    flags: 2
-  };
-  if (activeSub !== void 0) {
-    link(e, activeSub);
-  } else if (activeScope !== void 0) {
-    link(e, activeScope);
-  }
-  const prev = setCurrentSub(e);
-  try {
-    e.fn();
-  } finally {
-    setCurrentSub(prev);
-  }
-  return effectOper.bind(e);
-}
-function updateComputed(c3) {
-  const prevSub = setCurrentSub(c3);
-  startTracking(c3);
-  try {
-    const oldValue = c3.value;
-    return oldValue !== (c3.value = c3.getter(oldValue));
-  } finally {
-    setCurrentSub(prevSub);
-    endTracking(c3);
-  }
-}
-function updateSignal(s, value2) {
-  s.flags = 1;
-  return s.previousValue !== (s.previousValue = value2);
-}
-function notify(e) {
-  const flags = e.flags;
-  if (!(flags & 64)) {
-    e.flags = flags | 64;
-    const subs = e.subs;
-    if (subs !== void 0) {
-      notify(subs.sub);
-    } else {
-      queuedEffects[queuedEffectsLength++] = e;
-    }
-  }
-}
-function run(e, flags) {
-  if (flags & 16 || flags & 32 && checkDirty(e.deps, e)) {
-    const prev = setCurrentSub(e);
-    startTracking(e);
-    try {
-      e.fn();
-    } finally {
-      setCurrentSub(prev);
-      endTracking(e);
-    }
-    return;
-  } else if (flags & 32) {
-    e.flags = flags & ~32;
-  }
-  let link2 = e.deps;
-  while (link2 !== void 0) {
-    const dep = link2.dep;
-    const depFlags = dep.flags;
-    if (depFlags & 64) {
-      run(dep, dep.flags = depFlags & ~64);
-    }
-    link2 = link2.nextDep;
-  }
-}
-function flush() {
-  while (notifyIndex < queuedEffectsLength) {
-    const effect2 = queuedEffects[notifyIndex];
-    queuedEffects[notifyIndex++] = void 0;
-    run(effect2, effect2.flags &= ~64);
-  }
-  notifyIndex = 0;
-  queuedEffectsLength = 0;
-}
-function computedOper() {
-  const flags = this.flags;
-  if (flags & 16 || flags & 32 && checkDirty(this.deps, this)) {
-    if (updateComputed(this)) {
-      const subs = this.subs;
-      if (subs !== void 0) {
-        shallowPropagate(subs);
-      }
-    }
-  } else if (flags & 32) {
-    this.flags = flags & ~32;
-  }
-  if (activeSub !== void 0) {
-    link(this, activeSub);
-  } else if (activeScope !== void 0) {
-    link(this, activeScope);
-  }
-  return this.value;
-}
-function signalOper(...value2) {
-  if (value2.length) {
-    if (this.value !== (this.value = value2[0])) {
-      this.flags = 17;
-      const subs = this.subs;
-      if (subs !== void 0) {
-        propagate(subs);
-        if (!batchDepth) {
-          flush();
-        }
-      }
-    }
-  } else {
-    const value3 = this.value;
-    if (this.flags & 16) {
-      if (updateSignal(this, value3)) {
-        const subs = this.subs;
-        if (subs !== void 0) {
-          shallowPropagate(subs);
-        }
-      }
-    }
-    if (activeSub !== void 0) {
-      link(this, activeSub);
-    }
-    return value3;
-  }
-}
-function effectOper() {
-  let dep = this.deps;
-  while (dep !== void 0) {
-    dep = unlink(dep, this);
-  }
-  const sub = this.subs;
-  if (sub !== void 0) {
-    unlink(sub);
-  }
-  this.flags = 0;
-}
-
-// src/caddy/index.ts
+var import_node_process8 = __toESM(require("process"), 1);
 var import_got_cjs = require("got-cjs");
 var import_http_proxy_agent = require("http-proxy-agent");
 var import_https_proxy_agent = require("https-proxy-agent");
-var lockfile = __toESM(require("proper-lockfile"), 1);
 
 // src/utils.ts
 var import_node_os = require("os");
@@ -13469,7 +13032,8 @@ async function genCaddyfile(ctx) {
 
 // src/caddy/config.ts
 var import_node_fs = require("fs");
-var import_promises = require("fs/promises");
+var import_node_process2 = __toESM(require("process"), 1);
+var lockfile = __toESM(require("proper-lockfile"), 1);
 
 // src/caddy/constants.ts
 var import_node_os2 = __toESM(require("os"), 1);
@@ -13601,56 +13165,108 @@ var supportList = [
 ];
 
 // src/caddy/config.ts
-function useCaddyConfig() {
-  const configContentRef = signal("{}");
-  const configJsonRef = computed(() => {
-    try {
-      return JSON.parse(configContentRef());
-    } catch {
-      return void 0;
-    }
-  });
-  function setConfigContent() {
-    if (!(0, import_node_fs.existsSync)(caddyConfigPath)) {
-      (0, import_node_fs.writeFileSync)(caddyConfigPath, "{}");
-    }
-    try {
-      configContentRef((0, import_node_fs.readFileSync)(caddyConfigPath, "utf-8"));
-    } catch {
-      configContentRef("");
-    }
+function isAlive(pid) {
+  if (pid === void 0)
+    return true;
+  try {
+    import_node_process2.default.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
-  if (!(0, import_node_fs.existsSync)(caddyConfigPath)) {
-    (0, import_node_fs.writeFileSync)(caddyConfigPath, "{}");
+}
+function readConfig() {
+  if (!(0, import_node_fs.existsSync)(caddyConfigPath))
+    return {};
+  let parsed2;
+  try {
+    parsed2 = JSON.parse((0, import_node_fs.readFileSync)(caddyConfigPath, "utf-8"));
+  } catch {
+    return {};
   }
-  const watchCaddyConfig = (0, import_node_fs.watch)(caddyConfigPath, () => {
-    setConfigContent();
-  });
-  function writeCaddyConfig(_proxies) {
-    const proxies = configJsonRef() || {};
-    _proxies.forEach((p) => {
-      let base = p.base || "/";
-      if (!base.startsWith("/"))
-        base = `/${base}`;
-      if (base !== "/" && !base.endsWith("/"))
-        base = `${base}/`;
-      const index = `${p.target}${p.portSuffix}${base}`;
-      proxies[index] = { ...p, base };
-    });
-    const content = JSON.stringify(proxies, null, 2);
-    configContentRef(content);
-    return (0, import_node_fs.writeFileSync)(caddyConfigPath, content);
+  const alive = {};
+  for (const [key, entry] of Object.entries(parsed2)) {
+    if (isAlive(entry == null ? void 0 : entry.ownerPid))
+      alive[key] = entry;
   }
-  async function cleanUp() {
-    await (0, import_promises.unlink)(caddyConfigPath).catch(() => {
-    });
-    configContentRef("{}");
-    watchCaddyConfig.close();
+  return alive;
+}
+function writeConfig(proxies) {
+  const content = JSON.stringify(proxies, null, 2);
+  const temp = `${caddyConfigPath}.${import_node_process2.default.pid}.tmp`;
+  (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();
+  return {
+    configJsonRef: () => (0, import_node_fs.existsSync)(caddyConfigPath) ? readConfig() : void 0,
+    async writeCaddyConfig(_proxies, key) {
+      await mutateConfig(lock3, (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) => {
+        for (const route of Object.keys(current)) {
+          if (route.endsWith(`#${key}`))
+            delete current[route];
+        }
+      });
+      if (Object.keys(proxies).length === 0)
+        removeConfigFile();
+    },
+    readProxies: () => readConfig(),
+    async cleanUp() {
+      removeConfigFile();
+    }
+  };
+}
+function removeConfigFile() {
+  try {
+    if ((0, import_node_fs.existsSync)(caddyConfigPath))
+      (0, import_node_fs.unlinkSync)(caddyConfigPath);
+  } catch {
   }
+}
+function normalizeBase(base) {
+  let out = base || "/";
+  if (!out.startsWith("/"))
+    out = `/${out}`;
+  if (out !== "/" && !out.endsWith("/"))
+    out = `${out}/`;
+  return out;
+}
+function routeKey(proxy, ownerKey) {
+  return `${proxy.target}${proxy.portSuffix}${normalizeBase(proxy.base)}#${ownerKey}`;
+}
+function createFileLock() {
   return {
-    configJsonRef,
-    writeCaddyConfig,
-    cleanUp
+    async acquire() {
+      if (!(0, import_node_fs.existsSync)(caddyConfigPath))
+        (0, import_node_fs.writeFileSync)(caddyConfigPath, "{}");
+      const release = await lockfile.lock(caddyConfigPath, {
+        realpath: false,
+        stale: 1e4,
+        retries: { retries: 20, minTimeout: 10, maxTimeout: 100 }
+      });
+      return () => {
+        void release().catch(() => {
+        });
+      };
+    }
   };
 }
 
@@ -13668,43 +13284,56 @@ function isCaddyReloadCancellation(line) {
 var import_node_buffer2 = require("buffer");
 var import_node_events = require("events");
 var import_node_path4 = require("path");
-var import_node_process6 = __toESM(require("process"), 1);
+var import_node_process7 = __toESM(require("process"), 1);
 var import_node_url = require("url");
 
 // src/privileged/entry.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
-var import_node_process2 = __toESM(require("process"), 1);
+var import_node_process3 = __toESM(require("process"), 1);
 function resolveHelperEntry(options) {
-  const { moduleDir, nodeBin = import_node_process2.default.execPath, exists: exists2 = import_node_fs2.existsSync } = options;
+  const { moduleDir, nodeBin = import_node_process3.default.execPath, exists: exists2 = import_node_fs2.existsSync } = options;
   for (const name of ["privileged-helper.js", "privileged-helper.cjs", "privileged-helper.mjs"]) {
-    const candidate = (0, import_node_path2.join)(moduleDir, name);
-    if (exists2(candidate))
+    const candidate = findUp(moduleDir, name, exists2);
+    if (candidate)
       return { entry: nodeBin, args: [candidate] };
   }
-  const source = (0, import_node_path2.join)(moduleDir, "privileged-helper.ts");
-  const tsxCli = (0, import_node_path2.join)(moduleDir, "../node_modules/tsx/dist/cli.mjs");
-  if (exists2(source) && exists2(tsxCli))
+  const source = findUp(moduleDir, "privileged-helper.ts", exists2);
+  const tsxCli = findUp(moduleDir, "node_modules/tsx/dist/cli.mjs", exists2);
+  if (source && tsxCli)
     return { entry: nodeBin, args: [tsxCli, source] };
   throw new Error(`privileged helper entry not found in ${moduleDir}. Build the package first.`);
 }
+function findUp(from, relative, exists2) {
+  let current = from;
+  while (true) {
+    const candidate = (0, import_node_path2.join)(current, relative);
+    if (exists2(candidate))
+      return candidate;
+    const parent = (0, import_node_path2.dirname)(current);
+    if (parent === current)
+      return void 0;
+    current = parent;
+  }
+}
 
 // src/privileged/session.ts
 var import_node_buffer = require("buffer");
 var import_node_fs3 = require("fs");
-var import_promises2 = require("fs/promises");
+var import_promises = require("fs/promises");
 var import_node_os4 = require("os");
 var import_node_path3 = require("path");
+var lockfile2 = __toESM(require("proper-lockfile"), 1);
 
 // src/privileged/launch.ts
 var import_node_child_process2 = require("child_process");
 var import_node_crypto = require("crypto");
 var import_node_os3 = require("os");
-var import_node_process5 = __toESM(require("process"), 1);
+var import_node_process6 = __toESM(require("process"), 1);
 
 // src/privileged/client.ts
 var import_node_net = require("net");
-var import_node_process3 = __toESM(require("process"), 1);
+var import_node_process4 = __toESM(require("process"), 1);
 
 // src/privileged/protocol.ts
 function serializeMessage(message) {
@@ -13767,7 +13396,7 @@ var FORWARDED_ENV_KEYS = [
   "NO_PROXY",
   "no_proxy"
 ];
-function collectForwardedEnv(source = import_node_process3.default.env) {
+function collectForwardedEnv(source = import_node_process4.default.env) {
   const result = {};
   for (const key of FORWARDED_ENV_KEYS) {
     const value2 = source[key];
@@ -13944,7 +13573,7 @@ function createClient(socket, initialBuffer, callTimeoutMs) {
 
 // src/privileged/windows-elevation.ts
 var import_node_child_process = require("child_process");
-var import_node_process4 = __toESM(require("process"), 1);
+var import_node_process5 = __toESM(require("process"), 1);
 function quotePowerShell(value2) {
   return `'${value2.replace(/'/g, "''")}'`;
 }
@@ -13986,18 +13615,42 @@ function spawnElevatedOnWindows(options) {
 function createHelperToken() {
   return (0, import_node_crypto.randomBytes)(24).toString("hex");
 }
-function authenticateSudo(sudoCommand = "sudo") {
+function describePasswordReason(target, https) {
+  const port = https ? "443" : "80";
+  return [
+    `reverse proxy needs administrator permission for ${target}`,
+    `  \xB7 bind port ${port}${https ? ` for https://${target}` : ""}`,
+    `  \xB7 add ${target} to the hosts file`,
+    "",
+    "This is the only prompt; the rest of the dev server keeps running as you.",
+    "Press Ctrl+C at the prompt to skip the proxy and keep the dev server."
+  ];
+}
+function authenticateSudo(sudoCommand = "sudo", options = {}) {
   if ((0, import_node_os3.platform)() === "win32")
     return { ok: true };
   if ((0, import_node_child_process2.spawnSync)(sudoCommand, ["-n", "true"], { stdio: "ignore" }).status === 0)
     return { ok: true };
+  if (options.target) {
+    for (const line of describePasswordReason(options.target, options.https ?? false))
+      import_node_process6.default.stderr.write(`${line}
+`);
+    import_node_process6.default.stderr.write("\n");
+  }
   if ((0, import_node_child_process2.spawnSync)(sudoCommand, ["-v"], { stdio: "inherit" }).status === 0)
     return { ok: true };
   return {
     ok: false,
+    denied: true,
     message: "administrator permission is required to edit the hosts file and bind ports 80/443"
   };
 }
+var PrivilegeDeniedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrivilegeDeniedError";
+  }
+};
 async function startPrivilegedHelper(options) {
   var _a4, _b3;
   const {
@@ -14008,14 +13661,16 @@ async function startPrivilegedHelper(options) {
     sudoCommand = "sudo",
     skipAuth = false,
     direct = false,
-    env: env2 = import_node_process5.default.env,
+    env: env2 = import_node_process6.default.env,
     log,
     connectTimeoutMs = 12e4
   } = options;
   if (!skipAuth && !direct) {
-    const auth = authenticateSudo(sudoCommand);
-    if (!auth.ok)
-      throw new Error(auth.message);
+    const auth = authenticateSudo(sudoCommand, options.reason);
+    if (!auth.ok) {
+      const message = auth.message ?? "administrator permission is required";
+      throw auth.denied ? new PrivilegeDeniedError(message) : new Error(message);
+    }
   }
   const forwarded = collectForwardedEnv(env2);
   const forwardedArgs = Object.entries(forwarded).map(([key, value2]) => `${key}=${value2}`);
@@ -14025,8 +13680,8 @@ async function startPrivilegedHelper(options) {
     socketPath,
     "--token",
     token,
-    ...typeof import_node_process5.default.getuid === "function" ? ["--owner-uid", String(import_node_process5.default.getuid())] : [],
-    ...typeof import_node_process5.default.getgid === "function" ? ["--owner-gid", String(import_node_process5.default.getgid())] : [],
+    ...typeof import_node_process6.default.getuid === "function" ? ["--owner-uid", String(import_node_process6.default.getuid())] : [],
+    ...typeof import_node_process6.default.getgid === "function" ? ["--owner-gid", String(import_node_process6.default.getgid())] : [],
     ...options.caddyStoragePath ? ["--caddy-storage", options.caddyStoragePath] : [],
     "--caddy",
     options.caddyBin,
@@ -14035,7 +13690,7 @@ async function startPrivilegedHelper(options) {
   ];
   let child;
   if (!direct && (0, import_node_os3.platform)() === "win32") {
-    await spawnElevatedOnWindows({ file: helperEntry, args: childArgv, cwd: import_node_process5.default.cwd() });
+    await spawnElevatedOnWindows({ file: helperEntry, args: childArgv, cwd: import_node_process6.default.cwd() });
   } else {
     const command = direct ? helperEntry : sudoCommand;
     const spawnArgs = direct ? childArgv : ["-n", "env", ...forwardedArgs, helperEntry, ...childArgv];
@@ -14092,21 +13747,34 @@ function sessionSocketPath(runtimeDir) {
 }
 async function openHelperSession(scope2) {
   const socketPath = sessionSocketPath(scope2.runtimeDir);
-  if ((0, import_node_fs3.existsSync)(socketPath) || (0, import_node_os4.platform)() === "win32") {
-    const token2 = await readToken(scope2.runtimeDir);
-    if (token2) {
-      const reused = await connectExistingHelper(socketPath, token2);
-      if (reused) {
-        return {
-          client: reused,
-          reused: true,
-          close: async () => {
-            await reused.close();
-          }
-        };
-      }
-    }
+  const release = await acquireStartLock(scope2.runtimeDir);
+  try {
+    const reused = await tryReuse(socketPath, scope2);
+    if (reused)
+      return reused;
+    return await startNew(socketPath, scope2);
+  } finally {
+    release();
   }
+}
+async function tryReuse(socketPath, scope2) {
+  if (!(0, import_node_fs3.existsSync)(socketPath) && (0, import_node_os4.platform)() !== "win32")
+    return void 0;
+  const token = await readToken(scope2.runtimeDir);
+  if (!token)
+    return void 0;
+  const reused = await connectExistingHelper(socketPath, token);
+  if (!reused)
+    return void 0;
+  return {
+    client: reused,
+    reused: true,
+    close: async () => {
+      await reused.close();
+    }
+  };
+}
+async function startNew(socketPath, scope2) {
   const token = createHelperToken();
   const started = await startPrivilegedHelper({
     socketPath,
@@ -14120,6 +13788,7 @@ async function openHelperSession(scope2) {
     caddyStoragePath: scope2.caddyStoragePath,
     caddyBin: scope2.caddyBin,
     caddyConfigPath: scope2.caddyConfigPath,
+    reason: scope2.reason,
     log: scope2.log
   });
   await writeToken(scope2.runtimeDir, token);
@@ -14131,9 +13800,25 @@ async function openHelperSession(scope2) {
     }
   };
 }
+async function acquireStartLock(runtimeDir) {
+  const lockPath = (0, import_node_path3.join)(runtimeDir, "helper.start.lock");
+  try {
+    await (0, import_promises.writeFile)(lockPath, "", { flag: "a" });
+  } catch {
+  }
+  const release = await lockfile2.lock(lockPath, {
+    realpath: false,
+    stale: 3e4,
+    retries: { retries: 100, minTimeout: 50, maxTimeout: 200 }
+  });
+  return () => {
+    void release().catch(() => {
+    });
+  };
+}
 async function readToken(runtimeDir) {
   try {
-    const content = await (0, import_promises2.readFile)(tokenPath(runtimeDir), "utf8");
+    const content = await (0, import_promises.readFile)(tokenPath(runtimeDir), "utf8");
     const token = content.trim();
     return token === "" ? void 0 : token;
   } catch {
@@ -14142,7 +13827,7 @@ async function readToken(runtimeDir) {
 }
 async function writeToken(runtimeDir, token) {
   try {
-    await (0, import_promises2.writeFile)(tokenPath(runtimeDir), token, { mode: 384 });
+    await (0, import_promises.writeFile)(tokenPath(runtimeDir), token, { mode: 384 });
   } catch {
   }
 }
@@ -14190,7 +13875,7 @@ var HelperCaddyProcess = class extends import_node_events.EventEmitter {
   }
 };
 function caddyStoragePath() {
-  return import_node_process6.default.platform === "win32" ? (0, import_node_path4.join)(import_node_process6.default.env.AppData ?? "", "Caddy") : (0, import_node_path4.join)(import_node_process6.default.env.HOME ?? "", "Library/Application Support/Caddy");
+  return import_node_process7.default.platform === "win32" ? (0, import_node_path4.join)(import_node_process7.default.env.AppData ?? "", "Caddy") : (0, import_node_path4.join)(import_node_process7.default.env.HOME ?? "", "Library/Application Support/Caddy");
 }
 function openPrivilegedSession(runtimeDir, options) {
   const env2 = resolvePrivilegedEnv();
@@ -14206,6 +13891,7 @@ function openPrivilegedSession(runtimeDir, options) {
     // execute a path supplied over the socket.
     caddyBin: options.caddyBin,
     caddyConfigPath: options.caddyConfigPath,
+    reason: options.reason,
     log: options.log
   });
 }
@@ -14339,15 +14025,15 @@ async function download() {
     const file = (0, import_node_fs4.createWriteStream)(caddyPath);
     let _platform = (0, import_node_os5.platform)().toString();
     _platform === "win32" && (_platform = "windows");
-    let _arch = import_node_process7.default.arch.toString();
+    let _arch = import_node_process8.default.arch.toString();
     _arch === "x64" && (_arch = "amd64");
     const support = supportList.find((item) => item.platform === _platform && item.arch === _arch);
     if (!support)
       return reject2(new Error("not support"));
     const dowmloadLink = `https://caddyserver.com/api/download?os=${support.platform}&arch=${support.arch}&p=github.com%2Fcaddyserver%2Fforwardproxy`;
     (0, import_node_fs4.existsSync)(caddyPath) && (0, import_node_fs4.unlinkSync)(caddyPath);
-    const httpProxy = import_node_process7.default.env.HTTP_PROXY || import_node_process7.default.env.http_proxy;
-    const httpsProxy = import_node_process7.default.env.HTTPS_PROXY || import_node_process7.default.env.https_proxy;
+    const httpProxy = import_node_process8.default.env.HTTP_PROXY || import_node_process8.default.env.http_proxy;
+    const httpsProxy = import_node_process8.default.env.HTTPS_PROXY || import_node_process8.default.env.https_proxy;
     const httpAgent = httpProxy ? new import_http_proxy_agent.HttpProxyAgent(httpProxy) : void 0;
     const httpsAgent = httpsProxy ? new import_https_proxy_agent.HttpsProxyAgent(httpsProxy) : void 0;
     const chmodCaddyOnce = once(() => {
@@ -14363,7 +14049,7 @@ async function download() {
       chmodCaddyOnce();
     }).pipe(file).on("finish", () => {
       logProgressOver();
-      if (import_node_process7.default.platform === "win32")
+      if (import_node_process8.default.platform === "win32")
         return resolve2(caddyPath);
       (0, import_node_fs4.chmodSync)(caddyPath, 493);
       resolve2(caddyPath);
@@ -14406,43 +14092,35 @@ function splitHostPort(addr) {
   return { host: addr.slice(0, lastColon), port: addr.slice(lastColon + 1) };
 }
 var defaultDependencies = {
-  openSession: (runtimeDir) => openPrivilegedSession(runtimeDir, {
+  openSession: (runtimeDir, reason) => openPrivilegedSession(runtimeDir, {
     log: (message) => consola.debug(message),
     // Both paths are fixed here, before any socket traffic: the privileged
     // helper must never execute something named in a request.
     caddyBin: caddyPath,
-    caddyConfigPath: caddyFilePath
-  })
+    caddyConfigPath: caddyFilePath,
+    reason
+  }),
+  config: () => getCaddyConfig()
 };
 var CaddyInstant = class {
   constructor(deps = {}) {
     this.inited = false;
     this.stoped = false;
-    /** has locked when start */
-    this.locked = false;
     this._stopEffects = [];
+    /** Identifies this instance's routes in the shared config. */
+    this.proxyKey = `${import_node_process8.default.pid}-${Math.random().toString(36).slice(2, 8)}`;
     this.deps = { ...defaultDependencies, ...deps };
-    this.locked = this.checkLock();
-  }
-  checkLock() {
-    if (!(0, import_node_fs4.existsSync)(caddyLockFilePath))
-      (0, import_node_fs4.writeFileSync)(caddyLockFilePath, "");
-    try {
-      return lockfile.checkSync(caddyLockFilePath);
-    } catch {
-      return false;
-    }
   }
   /**
    * Connects to the privileged helper, starting it once if needed. It is
    * reused across instances so a second dev server does not ask for a
    * password again.
    */
-  async session() {
+  async session(reason) {
     if (this._session && !this._session.client.connected)
       this._session = void 0;
     if (!this._session)
-      this._session = await this.deps.openSession(TEMP_DIR);
+      this._session = await this.deps.openSession(TEMP_DIR, reason);
     return this._session;
   }
   async getCaddyfile() {
@@ -14450,20 +14128,20 @@ var CaddyInstant = class {
       this.caddyfile = "";
       return "";
     }
-    this.caddyfile = await (0, import_promises3.readFile)(caddyFilePath, "utf-8");
+    this.caddyfile = await (0, import_promises2.readFile)(caddyFilePath, "utf-8");
     return this.caddyfile;
   }
   get caddyRoot() {
     return (0, import_node_path5.join)(
-      import_node_process7.default.platform === "win32" ? `${import_node_process7.default.env.AppData}/Caddy` : `${import_node_process7.default.env.HOME}/Library/Application Support/Caddy`,
+      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 writeCaddyfile() {
-    return await (0, import_promises3.writeFile)(caddyFilePath, this.caddyfile || "");
+    return await (0, import_promises2.writeFile)(caddyFilePath, this.caddyfile || "");
   }
   async deleteCaddyfile() {
-    return await (0, import_promises3.unlink)(caddyFilePath);
+    return await (0, import_promises2.unlink)(caddyFilePath);
   }
   async init() {
     await download();
@@ -14501,9 +14179,15 @@ Run \`${caddyPath} trust\` manually if the browser warns about the certificate.`
     if (!health.healthy)
       throw new Error(formatTlsHealthFailure(targetHost, health));
   }
+  /**
+   * Regenerates the Caddyfile from the config on disk.
+   *
+   * Reading the file rather than a cached view matters here: another project
+   * may have added its route since this instance last looked.
+   */
   async updateCaddyfile() {
-    const { configJsonRef } = getCaddyConfig();
-    const proxies = Object.values(configJsonRef() || {});
+    const { readProxies } = this.deps.config();
+    const proxies = Object.values(readProxies());
     const ctx = validateTemplateContext({
       caddy_root: this.caddyRoot,
       proxies
@@ -14547,12 +14231,12 @@ Run \`${caddyPath} trust\` manually if the browser warns about the certificate.`
     this._target = target;
     if (!this.inited)
       await this.init();
-    const session = await this.session();
     const sourceHost = splitHostPort(source).host;
     const targetHost = splitHostPort(target).host;
+    const session = await this.session({ target: targetHost, https });
     await session.client.call("hosts.add", { ip: sourceHost, host: targetHost });
     consola.success("update host success\n");
-    const normalizeBase = (b) => {
+    const normalizeBase2 = (b) => {
       let out = b || "/";
       if (!out.startsWith("/"))
         out = `/${out}`;
@@ -14560,7 +14244,7 @@ Run \`${caddyPath} trust\` manually if the browser warns about the certificate.`
         out = `${out}/`;
       return out;
     };
-    const baseNormalized = normalizeBase(base);
+    const baseNormalized = normalizeBase2(base);
     const proxies = [
       {
         target: targetHost,
@@ -14571,27 +14255,12 @@ Run \`${caddyPath} trust\` manually if the browser warns about the certificate.`
         healthCheck
       }
     ];
-    const { writeCaddyConfig } = getCaddyConfig();
-    writeCaddyConfig(proxies);
+    const { writeCaddyConfig } = this.deps.config();
+    await writeCaddyConfig(proxies, this.proxyKey);
     await this.updateCaddyfile();
-    let skipInitialCaddyfileEffect = true;
-    this._stopEffects.push(
-      effect(() => {
-        getCaddyConfig().configJsonRef();
-        if (skipInitialCaddyfileEffect) {
-          skipInitialCaddyfileEffect = false;
-          return;
-        }
-        void this.updateCaddyfile();
-      })
-    );
-    if (!(0, import_node_fs4.existsSync)(caddyLockFilePath))
-      (0, import_node_fs4.writeFileSync)(caddyLockFilePath, "");
-    if (!this.locked) {
-      await session.client.call("port.free", { port: 443 });
-      if (import_node_process7.default.platform === "win32" || !https)
-        await session.client.call("port.free", { port: 80 });
-    }
+    await session.client.call("port.free", { port: 443 });
+    if (import_node_process8.default.platform === "win32" || !https)
+      await session.client.call("port.free", { port: 80 });
     return new Promise((resolve2, reject2) => {
       let startupCheckStarted = false;
       const resolveWhenReady = async () => {
@@ -14605,106 +14274,89 @@ Run \`${caddyPath} trust\` manually if the browser warns about the certificate.`
           }
           resolve2();
         } catch (error) {
-          if (!this.locked)
-            await this.baseCleanup(restore);
+          await this.baseCleanup(restore);
           reject2(error);
         }
       };
       const setupCleanup = () => {
-        import_node_process7.default.on("SIGINT", async () => {
+        import_node_process8.default.on("SIGINT", async () => {
           if (this.stoped)
             return;
-          import_node_process7.default.stdin.resume();
+          import_node_process8.default.stdin.resume();
           try {
             await this.baseCleanup(restore);
           } finally {
             this.stoped = true;
-            import_node_process7.default.nextTick(() => {
-              import_node_process7.default.exit();
+            import_node_process8.default.nextTick(() => {
+              import_node_process8.default.exit();
             });
           }
         });
-        const originalExit = import_node_process7.default.exit.bind(import_node_process7.default);
-        import_node_process7.default.exit = async (code) => {
+        const originalExit = import_node_process8.default.exit.bind(import_node_process8.default);
+        import_node_process8.default.exit = async (code) => {
           if (this.stoped)
             return originalExit(code);
-          import_node_process7.default.stdin.resume();
+          import_node_process8.default.stdin.resume();
           try {
             await this.baseCleanup();
           } finally {
             this.stoped = true;
-            import_node_process7.default.nextTick(() => {
+            import_node_process8.default.nextTick(() => {
               originalExit(code);
             });
           }
         };
       };
-      if (!this.locked) {
-        lockfile.lockSync(caddyLockFilePath);
-        setupCleanup();
-        void (async () => {
-          try {
-            const child = new HelperCaddyProcess(session.client);
-            this._caddyChild = child;
-            await session.client.call("caddy.start");
-            child.on("exit", (code) => {
-              if (code !== null && code !== 0)
-                reject2(new Error(`Caddy exited with code ${code}`));
-            });
-            child.stderr.on("data", async (data) => {
-              const lines = data.toString().split("\n").map((line) => line.trim());
-              for (const line of lines) {
-                showCaddyLog && line && console.info(line);
-                if (isCaddyReloadCancellation(line)) {
-                  consola.info("Caddy restarted before TLS issuance completed; retrying.\n");
-                  continue;
-                }
-                try {
-                  if (line.includes("Error:") || line && JSON.parse(line).level === "error") {
-                    if (line.includes("parsing caddyfile tokens")) {
-                      consola.error("Caddyfile syntax error, please contact the author:\n", `${this.caddyfile}
+      setupCleanup();
+      void (async () => {
+        try {
+          const child = new HelperCaddyProcess(session.client);
+          this._caddyChild = child;
+          await session.client.call("caddy.start");
+          child.on("exit", (code) => {
+            if (code !== null && code !== 0)
+              reject2(new Error(`Caddy exited with code ${code}`));
+          });
+          child.stderr.on("data", async (data) => {
+            const lines = data.toString().split("\n").map((line) => line.trim());
+            for (const line of lines) {
+              showCaddyLog && line && console.info(line);
+              if (isCaddyReloadCancellation(line)) {
+                consola.info("Caddy restarted before TLS issuance completed; retrying.\n");
+                continue;
+              }
+              try {
+                if (line.includes("Error:") || line && JSON.parse(line).level === "error") {
+                  if (line.includes("parsing caddyfile tokens")) {
+                    consola.error("Caddyfile syntax error, please contact the author:\n", `${this.caddyfile}
 
 ${line}
 `);
-                      await this.baseCleanup();
-                      import_node_process7.default.exit();
-                    } else {
-                      consola.error(`${line}
+                    await this.baseCleanup();
+                    import_node_process8.default.exit();
+                  } else {
+                    consola.error(`${line}
 `);
-                      return reject2(line);
-                    }
+                    return reject2(line);
                   }
-                } catch {
                 }
-                if (line.includes("config file changed"))
-                  consola.success("Detect added a new reverse proxy config, restarted.\n");
-                if (line.includes("caddy proxying") || line.includes("serving initial"))
-                  void resolveWhenReady();
+              } catch {
               }
-            });
-            child.stdout.on("data", (data) => {
-              consola.info(data.toString());
-              void resolveWhenReady();
-            });
-          } catch (error) {
-            if (!this.locked)
-              await this.baseCleanup(restore);
-            reject2(error);
-          }
-        })();
-      } else {
-        consola.info("Caddy is running in another process.");
-        void (async () => {
-          try {
-            if (https)
-              await this.ensureTlsReady(targetHost);
-            setupCleanup();
-            resolve2();
-          } catch (error) {
-            reject2(error);
-          }
-        })();
-      }
+              if (line.includes("config file changed"))
+                consola.success("Detect added a new reverse proxy config, restarted.\n");
+              if (line.includes("caddy proxying") || line.includes("serving initial"))
+                void resolveWhenReady();
+            }
+          });
+          child.stdout.on("data", (data) => {
+            consola.info(data.toString());
+            void resolveWhenReady();
+          });
+        } catch (error) {
+          await this.baseCleanup(restore);
+          reject2(error);
+        }
+      })();
     });
   }
   async baseCleanup(restore = true) {
@@ -14728,18 +14380,9 @@ ${line}
         consola.fail("Restore host failed.\n");
       }
     }
-    if (!this.locked && !this.stoped) {
-      await this.stopCaddy();
+    if (!this.stoped) {
       try {
-        await lockfile.unlock(caddyLockFilePath).catch(() => {
-        });
-        await (0, import_promises3.unlink)(caddyFilePath).catch(() => {
-        });
-        await (0, import_promises3.unlink)(caddyLockFilePath).catch(() => {
-        });
-        if (caddyConfig) {
-          await caddyConfig.cleanUp();
-        }
+        await this.deps.config().removeProxy(this.proxyKey);
       } catch (e) {
         consola.error(e);
       }
@@ -14981,11 +14624,20 @@ var hmrSseBridgeClientScript = `
 })();
 `;
 
+// src/privilege-state.ts
+var denied = false;
+function markPrivilegeDenied() {
+  denied = true;
+}
+function isPrivilegeDenied() {
+  return denied;
+}
+
 // src/index.ts
 var config;
 var caddy;
 var hmrSseBridgeActive = false;
-var cwd = import_node_process8.default.cwd();
+var cwd = import_node_process9.default.cwd();
 function colorUrl(url2) {
   return import_picocolors2.default.green(url2.replace(/:(\d+)\//, (_, port) => `:${import_picocolors2.default.bold(port)}/`));
 }
@@ -15020,16 +14672,27 @@ async function printForwardProxy() {
 }
 var vitePrintUrls = once((options, source, target, base = "/", _printUrls) => {
   _printUrls == null ? void 0 : _printUrls();
+  if (isPrivilegeDenied())
+    return;
   if (caddy)
     return;
-  caddy = new CaddyInstant();
-  caddy.run(source, target, {
+  const instance = new CaddyInstant();
+  caddy = instance;
+  instance.run(source, target, {
     base,
     ...options
   }).then(async () => {
     await printForwardProxy();
     consola.success(`  ${import_picocolors2.default.green("\u279C")}  ${import_picocolors2.default.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}${base}`)}`);
   }).catch((e) => {
+    if (caddy === instance)
+      caddy = void 0;
+    if (e instanceof PrivilegeDeniedError) {
+      markPrivilegeDenied();
+      consola.warn("reverse proxy skipped: administrator permission was not granted.");
+      consola.info("Restart the dev server to enable it again.");
+      return;
+    }
     throw e;
   });
 });
@@ -15085,7 +14748,7 @@ var unpluginFactory = (options) => ({
   },
   webpack(compiler) {
     var _a4, _b3, _c2;
-    if (import_node_process8.default.env.NODE_ENV !== "development")
+    if (import_node_process9.default.env.NODE_ENV !== "development")
       return;
     const {
       enable = true,
@@ -15106,9 +14769,11 @@ var unpluginFactory = (options) => ({
       port: 8080,
       ...compiler.options.devServer,
       // @ts-expect-error vuecli
-      ...(_a4 = import_node_process8.default.VUE_CLI_SERVICE) == null ? void 0 : _a4.projectOptions.devServer
+      ...(_a4 = import_node_process9.default.VUE_CLI_SERVICE) == null ? void 0 : _a4.projectOptions.devServer
     };
     const source = `${devServer.host}:${devServer.port}`;
+    if (isPrivilegeDenied())
+      return;
     if (caddy)
       return;
     let base = "/";
@@ -15123,15 +14788,16 @@ var unpluginFactory = (options) => ({
     const _close = (_c2 = compiler.close) == null ? void 0 : _c2.bind(compiler);
     if (_close) {
       compiler.close = async (callback) => {
-        import_node_process8.default.on("exit", () => {
+        import_node_process9.default.on("exit", () => {
           _close && _close(callback);
         });
       };
     } else {
       options.https = false;
     }
-    caddy = new CaddyInstant();
-    caddy.run(source, target, {
+    const instance = new CaddyInstant();
+    caddy = instance;
+    instance.run(source, target, {
       base,
       ...options
     }).then(() => {
@@ -15140,12 +14806,20 @@ var unpluginFactory = (options) => ({
         consola.success(`  ${import_picocolors2.default.green("\u279C")}  ${import_picocolors2.default.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}${base}`)}`);
       });
     }).catch((e) => {
+      if (caddy === instance)
+        caddy = void 0;
+      if (e instanceof PrivilegeDeniedError) {
+        markPrivilegeDenied();
+        consola.warn("reverse proxy skipped: administrator permission was not granted.");
+        consola.info("Restart the dev server to enable it again.");
+        return;
+      }
       throw e;
     });
   },
   async rspack(compiler) {
     var _a4, _b3, _c2, _d2;
-    if (import_node_process8.default.env.NODE_ENV !== "development")
+    if (import_node_process9.default.env.NODE_ENV !== "development")
       return;
     const {
       enable = true,
@@ -15170,9 +14844,10 @@ var unpluginFactory = (options) => ({
       }))) == null ? void 0 : _b3.content) == null ? void 0 : _c2.server
     };
     const source = `${devServer.host}:${devServer.port}`;
+    if (isPrivilegeDenied())
+      return;
     if (caddy)
       return;
-    caddy = new CaddyInstant();
     let base = "/";
     const publicPath = (_d2 = compiler.options.output) == null ? void 0 : _d2.publicPath;
     if (typeof publicPath === "string" && publicPath) {
@@ -15182,13 +14857,23 @@ var unpluginFactory = (options) => ({
       base = `/${base}`;
     if (base !== "/" && !base.endsWith("/"))
       base = `${base}/`;
-    caddy.run(source, target, {
+    const instance = new CaddyInstant();
+    caddy = instance;
+    instance.run(source, target, {
       base,
       ...options
     }).then(async () => {
       await printForwardProxy();
       consola.success(`  ${import_picocolors2.default.green("\u279C")}  ${import_picocolors2.default.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}${base}`)}`);
     }).catch((e) => {
+      if (caddy === instance)
+        caddy = void 0;
+      if (e instanceof PrivilegeDeniedError) {
+        markPrivilegeDenied();
+        consola.warn("reverse proxy skipped: administrator permission was not granted.");
+        consola.info("Restart the dev server to enable it again.");
+        return;
+      }
       throw e;
     });
   }