unplugin-https-reverse-proxy 1.0.0-beta.8 → 1.0.0

package/dist/{chunk-AYUGOY4B.js → chunk-KVE7AVSI.js}

@@ -1,36 +1,34 @@
 import {
-  __spreadValues,
   chmodRecursive,
   consola,
   isAdmin,
   once
-} from "./chunk-RUJE3YFB.js";
+} from "./chunk-2VGRJ3QS.js";
 
 // src/index.ts
-import process4 from "process";
+import process4 from "node:process";
 import { createUnplugin } from "unplugin";
 import c from "picocolors";
 
 // src/caddy/index.ts
-import { platform } from "os";
-import process3 from "process";
-import { chmodSync as chmodSync2, createWriteStream, existsSync, mkdirSync, unlinkSync } from "fs";
-import { spawn } from "child_process";
+import { platform } from "node:os";
+import process3 from "node:process";
+import { chmodSync as chmodSync2, createWriteStream, existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { readFile, unlink, writeFile } from "node:fs/promises";
 import { got } from "got-cjs";
 import { HttpProxyAgent } from "http-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
-import kill from "kill-port";
+import * as lockfile from "proper-lockfile";
 
 // src/host/index.ts
-import process from "process";
-import { exec } from "child_process";
-import { chmodSync } from "fs";
-import _Hosts from "hosts-so-easy";
-var Hosts = _Hosts.default || _Hosts;
-var hostInstance = new Hosts({
-  debounceTime: 50,
-  hostsFile: getPathOfSystemHostsPath()
-});
+import process from "node:process";
+import { exec } from "node:child_process";
+import { chmodSync } from "node:fs";
+import { promisify } from "node:util";
+import hostile from "hostile";
+var _setHost = promisify(hostile.set);
+var _removeHost = promisify(hostile.remove);
 function getPathOfSystemHostsPath() {
   return process.platform === "win32" ? `${process.env.windir || "C:\\WINDOWS"}\\system32\\drivers\\etc\\hosts` : "/etc/hosts";
 }
@@ -51,27 +49,25 @@ async function syncHost() {
 async function addHost(ip, host) {
   if (process.platform !== "win32")
     chmodSync(getPathOfSystemHostsPath(), 511);
-  hostInstance.add("127.0.0.1", "localhost");
-  hostInstance.add(ip, host);
+  await _setHost("127.0.0.1", "localhost");
+  await _setHost(ip, host);
   if (ip === "localhost")
-    hostInstance.add("127.0.0.1", host);
-  await hostInstance.updateFinish();
+    await _setHost("127.0.0.1", host);
   return await syncHost();
 }
 async function removeHost(ip, host) {
   if (process.platform !== "win32")
     chmodSync(getPathOfSystemHostsPath(), 511);
-  hostInstance.remove(ip, host);
+  await _removeHost(ip, host);
   if (ip === "localhost")
-    hostInstance.remove("127.0.0.1", host);
-  await hostInstance.updateFinish();
+    await _removeHost("127.0.0.1", host);
   return await syncHost();
 }
 
 // src/caddy/constants.ts
-import { join } from "path";
-import os from "os";
-import process2 from "process";
+import { join } from "node:path";
+import os from "node:os";
+import process2 from "node:process";
 import dotenvFlow from "dotenv-flow";
 dotenvFlow.config({
   silent: true
@@ -84,6 +80,7 @@ function resolvePath(path) {
 var TEMP_DIR = resolvePath(process2.env.UHRP_CADDY_PATH || process2.env.TEMP || process2.env.TMPDIR || "/tmp");
 var caddyPath = join(TEMP_DIR, `caddy${process2.platform === "win32" ? ".exe" : ""}`);
 var caddyFilePath = join(TEMP_DIR, "CADDYFILE");
+var caddyLockFilePath = join(TEMP_DIR, "caddylock");
 var supportList = [
   {
     platform: "dragonfly",
@@ -196,7 +193,8 @@ var supportList = [
 ];
 
 // src/caddy/utils.ts
-import { createServer } from "net";
+import { createServer } from "node:net";
+import { exec as exec2 } from "node:child_process";
 import ora from "ora";
 var spinner;
 function tryPort(port) {
@@ -217,6 +215,18 @@ function tryPort(port) {
     }
   });
 }
+async function kill(port) {
+  return new Promise((resolve, reject) => {
+    exec2(`npx @maxbo/free-port ${port} -s`, (err, stdout, stderr) => {
+      if (err) {
+        reject(err);
+      } else {
+        consola.log(stdout);
+        resolve();
+      }
+    });
+  });
+}
 function getNumber(number) {
   if (number <= 0)
     return "0%";
@@ -316,9 +326,41 @@ var CaddyInstant = class {
   constructor() {
     this.inited = false;
     this.stoped = false;
-    testCaddy().then(() => {
+    /** has locked */
+    this.locked = false;
+    testCaddy().then(async () => {
+      await this.getCaddyfile();
       this.inited = true;
     });
+    this.locked = this.checkLock();
+  }
+  checkLock() {
+    if (!existsSync(caddyLockFilePath))
+      writeFileSync(caddyLockFilePath, "");
+    return lockfile.checkSync(caddyLockFilePath);
+  }
+  async getCaddyfile() {
+    if (!existsSync(caddyFilePath))
+      await this.initCaddyfile();
+    this.caddyfile = await readFile(caddyFilePath, "utf-8");
+    return this.caddyfile;
+  }
+  async initCaddyfile() {
+    const contet = `
+{
+  debug
+  auto_https disable_redirects
+}
+    
+`;
+    await writeFile(caddyFilePath, contet);
+    this.caddyfile = contet;
+  }
+  async writeCaddyfile() {
+    return await writeFile(caddyFilePath, this.caddyfile || "");
+  }
+  async deleteCaddyfile() {
+    return await unlink(caddyFilePath);
   }
   async init() {
     await download();
@@ -337,100 +379,184 @@ var CaddyInstant = class {
       showCaddyLog = false,
       https = false
     } = options || {};
+    this._source = source;
+    this._target = target;
     if (!this.inited)
       await this.init();
-    if (https && await tryPort(443))
-      await kill(443, "tcp");
-    if ((process3.platform === "win32" || !https) && await tryPort(80))
-      await kill(80, "tcp");
     if (!await addHost(source.split(":")[0], target.split(":")[0]))
       throw new Error("update host failed");
     consola.success("update host success\n");
+    await this.getCaddyfile();
+    if (!(this.caddyfile || "").includes(`${target.split(":")[0]}${https ? "" : ":80"}`)) {
+      this.caddyfile = `${this.caddyfile}
+${target.split(":")[0]}${https ? "" : ":80"} {
+  ${https ? "tls internal" : ""}
+  reverse_proxy http://${source} {
+    health_uri ${base}
+    health_interval 2s
+    health_timeout 5s
+    fail_duration 2s
+    unhealthy_status 502 503 504 404
+    lb_try_duration 3s
+    lb_try_interval 300ms
+    health_headers {
+      Accept text/html
+      Accept-Encoding gzip, deflate, br
+      User-Agent Caddy-Health-Check
+    }
+
+    @error status 502 503 504 404
+    handle_response @error {
+      respond * 503 {
+        body "Service Unavailable"
+        close
+      }
+    }
+  }
+}
+
+`;
+      await this.writeCaddyfile();
+    }
+    if (!existsSync(caddyLockFilePath))
+      writeFileSync(caddyLockFilePath, "");
+    if (!this.locked) {
+      if (await tryPort(443))
+        await kill(443);
+      if ((process3.platform === "win32" || !https) && await tryPort(80))
+        await kill(80);
+    }
     return new Promise((resolve, reject) => {
-      const child = process3.platform !== "win32" ? spawn("sudo", ["-E", caddyPath, "reverse-proxy", "--from", `${target.split(":")[0]}${https ? "" : ":80"}`, "--to", `${source}`, "--internal-certs", "--insecure", "--disable-redirects"]) : spawn(caddyPath, ["reverse-proxy", "--from", `${target.split(":")[0]}`, "--to", `${source}`, "--internal-certs"]);
-      child.on("error", (err) => {
-        return reject(err);
-      });
-      process3.on("SIGINT", async () => {
-        if (!restore || this.stoped)
-          return;
-        try {
-          if (await removeHost(source.split(":")[0], target.split(":")[0]))
-            consola.success("restore host success\n");
-          else
-            consola.fail("restore host failed\n");
-        } catch (e) {
-          consola.error(e);
-          consola.fail("restore host failed\n");
-        } finally {
-          this.stoped = true;
-          process3.nextTick(() => {
-            process3.exit();
-          });
-        }
-      });
-      const originalExit = process3.exit.bind(process3);
-      process3.exit = async (code) => {
-        const port = Number(source.split(":")[1]);
-        if (!Number.isNaN(port) && await tryPort(port))
-          await kill(port, "tcp");
-        const pwd2 = process3.cwd();
-        const viteCacheDir = `${pwd2}/node_modules/.vite`;
-        if (existsSync(viteCacheDir))
-          chmodRecursive(viteCacheDir, 511);
-        const nuxtCacheDir = `${pwd2}/.nuxt`;
-        if (existsSync(nuxtCacheDir))
-          await chmodRecursive(nuxtCacheDir, 511);
-        const webpackCacheDir = `${pwd2}/node_modules/.cache`;
-        if (existsSync(webpackCacheDir))
-          chmodRecursive(webpackCacheDir, 511);
-        if (!restore || this.stoped)
-          return originalExit(code);
-        try {
-          if (await removeHost(source.split(":")[0], target.split(":")[0]))
-            consola.success("restore host success\n");
-          else
-            consola.fail("restore host failed\n");
-        } catch (e) {
-          consola.error(e);
-          consola.fail("restore host failed\n");
-        } finally {
-          this.stoped = true;
-          process3.nextTick(() => {
-            originalExit(code);
-          });
-        }
+      var _a, _b;
+      const setupCleanup = () => {
+        process3.on("SIGINT", async () => {
+          if (this.stoped)
+            return;
+          process3.stdin.resume();
+          try {
+            await this.baseCleanup(restore);
+          } finally {
+            this.stoped = true;
+            process3.nextTick(() => {
+              process3.exit();
+            });
+          }
+        });
+        const originalExit = process3.exit.bind(process3);
+        process3.exit = async (code) => {
+          const port = Number(source.split(":")[1]);
+          if (!Number.isNaN(port) && await tryPort(port))
+            await kill(port);
+          const pwd = process3.cwd();
+          const viteCacheDir = `${pwd}/node_modules/.vite`;
+          if (existsSync(viteCacheDir))
+            await chmodRecursive(viteCacheDir, 511).catch(() => {
+            });
+          const nuxtCacheDir = `${pwd}/.nuxt`;
+          if (existsSync(nuxtCacheDir))
+            await chmodRecursive(nuxtCacheDir, 511).catch(() => {
+            });
+          const webpackCacheDir = `${pwd}/node_modules/.cache`;
+          if (existsSync(webpackCacheDir))
+            await chmodRecursive(webpackCacheDir, 511).catch(() => {
+            });
+          if (this.stoped)
+            return originalExit(code);
+          process3.stdin.resume();
+          try {
+            await this.baseCleanup();
+          } finally {
+            this.stoped = true;
+            process3.nextTick(() => {
+              originalExit(code);
+            });
+          }
+        };
       };
-      child.stderr.on("data", (data) => {
-        const lines = data.toString().split("\n").map((line) => line.trim());
-        for (const line of lines) {
-          showCaddyLog && line && console.info(line);
-          if (line.includes("Error:") || line && JSON.parse(line).level === "error") {
-            consola.error(line);
-            return reject(line);
+      if (!this.locked) {
+        this._caddyChild = process3.platform !== "win32" ? spawn("sudo", ["-E", caddyPath, "run", "--config", caddyFilePath, "--watch"]) : spawn(caddyPath, ["run", "--config", caddyFilePath, "--watch"]);
+        lockfile.lockSync(caddyLockFilePath);
+        this._caddyChild.on("error", (err) => {
+          return reject(err);
+        });
+        (_a = this._caddyChild.stderr) == null ? void 0 : _a.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 (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();
+                process3.exit();
+              } else {
+                consola.error(`${line}
+`);
+                return reject(line);
+              }
+            }
+            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"))
+              return resolve();
           }
-        }
-      });
-      child.stdout.on("data", (_data) => {
-        consola.info(_data.toString());
-        resolve();
-      });
+        });
+        (_b = this._caddyChild.stdout) == null ? void 0 : _b.on("data", (_data) => {
+          consola.info(_data.toString());
+          resolve();
+        });
+        setupCleanup();
+      } else {
+        consola.info("Caddy is running in another process.");
+        setupCleanup();
+        return resolve();
+      }
     });
   }
+  async baseCleanup(restore = true) {
+    var _a;
+    try {
+      if (restore && this._source && this._target) {
+        if (await removeHost(this._source.split(":")[0], this._target.split(":")[0]))
+          consola.success("Restore host success.\n");
+        else
+          consola.fail("Restore host failed.\n");
+      }
+    } catch (e) {
+      consola.error(e);
+      consola.fail("Restore host failed.\n");
+    }
+    if (!this.locked && !this.stoped) {
+      (_a = this._caddyChild) == null ? void 0 : _a.kill();
+      try {
+        await lockfile.unlock(caddyLockFilePath).catch(() => {
+        });
+        await unlink(caddyFilePath).catch(() => {
+        });
+        await unlink(caddyLockFilePath).catch(() => {
+        });
+      } catch (e) {
+        consola.error(e);
+      }
+    }
+  }
 };
 
 // src/index.ts
 var config;
 var caddy;
-var pwd = process4.cwd();
+var cwd = process4.cwd();
 var vitePrintUrls = once((options, source, target, base = "/", _printUrls) => {
   _printUrls == null ? void 0 : _printUrls();
   if (caddy)
     return;
   caddy = new CaddyInstant();
-  caddy.run(source, target, __spreadValues({
-    base
-  }, options)).then(() => {
+  caddy.run(source, target, {
+    base,
+    ...options
+  }).then(() => {
     const colorUrl = (url) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
     consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}${base}`)}`);
   }).catch((e) => {
@@ -448,16 +574,16 @@ var unpluginFactory = (options) => ({
       var _a;
       if (config.command !== "serve")
         return;
-      if (!isAdmin()) {
-        consola.warn("please run as administrator");
-        return;
-      }
       const {
         enable = true,
         target = ""
       } = options;
       if (!enable)
         return;
+      if (!isAdmin()) {
+        consola.warn("please run as administrator");
+        return;
+      }
       if (!target) {
         consola.fail("please provide target");
         return;
@@ -474,31 +600,34 @@ var unpluginFactory = (options) => ({
     }
   },
   webpack(compiler) {
-    var _a;
+    var _a, _b;
     if (process4.env.NODE_ENV !== "development")
       return;
-    if (!isAdmin()) {
-      consola.warn("please run as administrator");
-      return;
-    }
     const {
       enable = true,
       target = ""
     } = options;
     if (!enable)
       return;
+    if (!isAdmin()) {
+      consola.warn("please run as administrator");
+      return;
+    }
     if (!target) {
       consola.fail("please provide target");
       return;
     }
-    const devServer = __spreadValues(__spreadValues({
+    const devServer = {
       host: "localhost",
-      port: 8080
-    }, compiler.options.devServer), process4.VUE_CLI_SERVICE.projectOptions.devServer);
+      port: 8080,
+      ...compiler.options.devServer,
+      // @ts-expect-error vuecli
+      ...(_a = process4.VUE_CLI_SERVICE) == null ? void 0 : _a.projectOptions.devServer
+    };
     const source = `${devServer.host}:${devServer.port}`;
     if (caddy)
       return;
-    const _close = (_a = compiler.close) == null ? void 0 : _a.bind(compiler);
+    const _close = (_b = compiler.close) == null ? void 0 : _b.bind(compiler);
     if (_close) {
       compiler.close = async (callback) => {
         process4.on("exit", () => {
@@ -509,7 +638,9 @@ var unpluginFactory = (options) => ({
       options.https = false;
     }
     caddy = new CaddyInstant();
-    caddy.run(source, target, __spreadValues({}, options)).then(() => {
+    caddy.run(source, target, {
+      ...options
+    }).then(() => {
       const colorUrl = (url) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
       compiler.hooks.done.tap("unplugin-https-reverse-proxy", () => {
         consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}`)}`);
@@ -517,6 +648,45 @@ var unpluginFactory = (options) => ({
     }).catch((e) => {
       throw e;
     });
+  },
+  async rspack(compiler) {
+    var _a, _b, _c;
+    if (process4.env.NODE_ENV !== "development")
+      return;
+    const {
+      enable = true,
+      target = ""
+    } = options;
+    if (!enable)
+      return;
+    if (!isAdmin()) {
+      consola.warn("please run as administrator");
+      return;
+    }
+    if (!target) {
+      consola.fail("please provide target");
+      return;
+    }
+    const devServer = {
+      host: "localhost",
+      port: 8080,
+      ...compiler.options.devServer,
+      ...(_c = (_b = await ((_a = await import("@rsbuild/core")) == null ? void 0 : _a.loadConfig({
+        cwd
+      }))) == null ? void 0 : _b.content) == null ? void 0 : _c.server
+    };
+    const source = `${devServer.host}:${devServer.port}`;
+    if (caddy)
+      return;
+    caddy = new CaddyInstant();
+    caddy.run(source, target, {
+      ...options
+    }).then(() => {
+      const colorUrl = (url) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
+      consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}`)}`);
+    }).catch((e) => {
+      throw e;
+    });
   }
 });
 var unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);