unplugin-https-reverse-proxy 0.0.11 → 0.0.13

package/README.md

@@ -16,6 +16,7 @@ UHRP_AUTO_INSTALL_CADDY=true npm i unplugin-https-reverse-proxy --save-dev
 
 ```ts
 interface Options {
+  enable?: boolean // <- default: true
   target: string // <- https target hostname
   showCaddyLog?: boolean // <- default: false
 }
@@ -26,11 +27,11 @@ interface Options {
 
 ```ts
 // vite.config.ts
-import Starter from 'unplugin-https-reverse-proxy/vite'
+import HttpsReverseProxy from 'unplugin-https-reverse-proxy/vite'
 
 export default defineConfig({
   plugins: [
-    Starter({ /* options */ }),
+    HttpsReverseProxy({ /* options */ }),
   ],
 })
 ```
@@ -55,6 +56,7 @@ module.exports = {
         port: 443,
       },
     },
+    setupExitSignals: true,
   },
   plugins: [
     require('unplugin-https-reverse-proxy/webpack')({ /* options */ })
@@ -95,6 +97,7 @@ module.exports = {
         port: 443,
       },
     },
+    setupExitSignals: true,
   },
   configureWebpack: {
     plugins: [

package/dist/{chunk-UGVWTB7L.js → chunk-6KXUNICB.js}

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-5K6D2TTS.js";
+} from "./chunk-DH6VMKTP.js";
 
 // src/vite.ts
 import { createVitePlugin } from "unplugin";

package/dist/chunk-CQC5SSJR.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/utils.ts
+import { createConsola } from "consola";
+var consola = createConsola({
+  level: 3
+}).withTag("reverse-proxy");
+function once(fn) {
+  let called = false;
+  return (...args) => {
+    if (called)
+      return;
+    called = true;
+    return fn(...args);
+  };
+}
+
+export {
+  __spreadValues,
+  consola,
+  once
+};

package/dist/{chunk-5K6D2TTS.js → chunk-DH6VMKTP.js}

@@ -1,6 +1,8 @@
 import {
-  consola
-} from "./chunk-3HKPYCSE.js";
+  __spreadValues,
+  consola,
+  once
+} from "./chunk-CQC5SSJR.js";
 
 // src/index.ts
 import process3 from "process";
@@ -15,7 +17,7 @@ import { spawn } from "child_process";
 import { got } from "got-cjs";
 import { HttpProxyAgent } from "http-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
-import * as hostile from "hostile";
+import _Hosts from "hosts-so-easy";
 import kill from "kill-port";
 
 // src/caddy/constants.ts
@@ -137,6 +139,8 @@ var supportList = [
 
 // src/caddy/utils.ts
 import { createServer } from "net";
+import ora from "ora";
+var spinner;
 function tryPort(port) {
   return new Promise((resolve, reject) => {
     try {
@@ -155,8 +159,41 @@ function tryPort(port) {
     }
   });
 }
+function getNumber(number) {
+  if (number <= 0)
+    return "0%";
+  else if (number < 100)
+    return `${number.toFixed(2)}%`;
+  else
+    return "100%";
+}
+function logProgress(percent) {
+  if (!spinner) {
+    consola.log("");
+    spinner = ora({
+      text: "Start Download Caddy: 0%",
+      indent: 2
+    });
+    spinner.start();
+  } else {
+    spinner.text = `Download Caddy: ${getNumber(Number(percent) * 100)}`;
+  }
+}
+function logProgressOver() {
+  if (!spinner) {
+    spinner = ora({
+      text: "Start Download Caddy: 100%",
+      indent: 2
+    });
+    spinner.start();
+  } else {
+    spinner.succeed();
+    consola.log("");
+  }
+}
 
 // src/caddy/index.ts
+var Hosts = _Hosts.default || _Hosts;
 async function download() {
   if (await testCaddy())
     return caddyPath;
@@ -180,7 +217,10 @@ async function download() {
         http: httpAgent,
         https: httpsAgent
       }
+    }).on("downloadProgress", (progress) => {
+      logProgress(progress.percent);
     }).pipe(file).on("finish", () => {
+      logProgressOver();
       if (process2.platform === "win32")
         return resolve(caddyPath);
       chmodSync(caddyPath, 493);
@@ -195,7 +235,7 @@ function testCaddy() {
     if (!existsSync(caddyPath))
       return resolve(false);
     chmodSync(caddyPath, 493);
-    const child = process2.platform === "win32" ? spawn(caddyPath, []) : spawn("sudo", [caddyPath]);
+    const child = process2.platform === "win32" ? spawn(caddyPath, []) : spawn("sudo", ["-E", caddyPath]);
     child.on("close", () => {
       return resolve(false);
     });
@@ -210,6 +250,8 @@ function testCaddy() {
 var CaddyInstant = class {
   constructor() {
     this.inited = false;
+    this.stoped = false;
+    this.host = new Hosts();
     testCaddy().then(() => {
       this.inited = true;
     });
@@ -218,52 +260,46 @@ var CaddyInstant = class {
     await download();
     this.inited = true;
   }
-  async updateHost(ip, host) {
+  updateHost(ip, host) {
     ["localhost", "0.0.0.0"].includes(ip) && (ip = "127.0.0.1");
+    this.host.add(ip, host);
     return new Promise((resolve, reject) => {
-      hostile.set(ip, host, (err) => {
-        if (err) {
-          return reject(err);
-        } else {
-          if (process2.platform === "win32") {
-            spawn("ipconfig", ["/flushdns"]).on("error", (err2) => {
-              return reject(err2);
-            }).on("close", () => {
-              resolve(true);
-            });
-          } else {
-            spawn("sudo", ["killall", "-HUP", "mDNSResponder"]).on("error", (err2) => {
-              return reject(err2);
-            }).on("close", () => {
-              resolve(true);
-            });
-          }
-        }
-      });
+      if (process2.platform === "win32") {
+        spawn("ipconfig", ["/flushdns"]).on("error", (err) => {
+          consola.error(err);
+          return resolve(false);
+        }).on("close", () => {
+          resolve(true);
+        });
+      } else {
+        spawn("sudo", ["-E", "killall", "-HUP", "mDNSResponder"]).on("error", (err) => {
+          consola.error(err);
+          return resolve(false);
+        }).on("close", () => {
+          resolve(true);
+        });
+      }
     });
   }
-  async restoreHost(ip, host) {
+  restoreHost(ip, host) {
     ["localhost", "0.0.0.0"].includes(ip) && (ip = "127.0.0.1");
+    this.host.remove(ip, host);
     return new Promise((resolve, reject) => {
-      hostile.remove(ip, host, (err) => {
-        if (err) {
-          return reject(err);
-        } else {
-          if (process2.platform === "win32") {
-            spawn("ipconfig", ["/flushdns"]).on("error", (err2) => {
-              return reject(err2);
-            }).on("close", () => {
-              resolve(true);
-            });
-          } else {
-            spawn("sudo", ["killall", "-HUP", "mDNSResponder"]).on("error", (err2) => {
-              return reject(err2);
-            }).on("close", () => {
-              resolve(true);
-            });
-          }
-        }
-      });
+      if (process2.platform === "win32") {
+        spawn("ipconfig", ["/flushdns"]).on("error", (err) => {
+          consola.error(err);
+          return resolve(false);
+        }).on("close", () => {
+          resolve(true);
+        });
+      } else {
+        spawn("sudo", ["-E", "killall", "-HUP", "mDNSResponder"]).on("error", (err) => {
+          consola.error(err);
+          return resolve(false);
+        }).on("close", () => {
+          resolve(true);
+        });
+      }
     });
   }
   /**
@@ -280,14 +316,15 @@ var CaddyInstant = class {
     } = options || {};
     if (!this.inited)
       await this.init();
-    if (!await this.updateHost(source.split(":")[0], target.split(":")[0]))
-      throw new Error("update host failed");
     if (await tryPort(443))
       await kill(443, "tcp");
     if (process2.platform === "win32" && await tryPort(80))
       await kill(80, "tcp");
+    if (!await this.updateHost(source.split(":")[0], target.split(":")[0]))
+      throw new Error("update host failed");
+    consola.success("update host success\n");
     return new Promise((resolve, reject) => {
-      const child = process2.platform !== "win32" ? spawn("sudo", [caddyPath, "reverse-proxy", "--from", `${target.split(":")[0]}`, "--to", `${source}`, "--internal-certs"]) : spawn(caddyPath, ["reverse-proxy", "--from", `${target.split(":")[0]}`, "--to", `${source}`, "--internal-certs"]);
+      const child = process2.platform !== "win32" ? spawn("sudo", ["-E", caddyPath, "reverse-proxy", "--from", `${target.split(":")[0]}`, "--to", `${source}`, "--internal-certs"]) : spawn(caddyPath, ["reverse-proxy", "--from", `${target.split(":")[0]}`, "--to", `${source}`, "--internal-certs"]);
       child.on("error", (err) => {
         return reject(err);
       });
@@ -295,7 +332,7 @@ var CaddyInstant = class {
         const lines = data.toString().split("\n").map((line) => line.trim());
         for (const line of lines) {
           showCaddyLog && line && console.info(line);
-          if (line && JSON.parse(line).level === "error") {
+          if (line.includes("Error:") || line && JSON.parse(line).level === "error") {
             consola.error(line);
             return reject(line);
           }
@@ -303,14 +340,21 @@ var CaddyInstant = class {
       });
       child.stdout.on("data", (_data) => {
         consola.info(_data.toString());
-        resolve(async () => {
-          if (!restore)
+        resolve(async (callback) => {
+          if (!restore || this.stoped)
             return;
-          if (await this.restoreHost(source.split(":")[0], target.split(":")[0]))
-            consola.success("restore host success\n");
-          else
+          try {
+            if (await this.restoreHost(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");
+          }
+          this.stoped = true;
           child.kill();
+          callback && callback();
         });
       });
     });
@@ -320,21 +364,66 @@ var CaddyInstant = class {
 // src/index.ts
 var config;
 var caddy;
+var _stop;
+var _servce;
+function registerExit(clear) {
+  process3.on("beforeExit", async (_code) => {
+    await clear();
+  });
+  process3.on("uncaughtException", async (err) => {
+    console.error("An uncaught error occurred!", err.stack);
+    await clear();
+    process3.nextTick(() => {
+      process3.exit(1);
+    });
+  });
+  process3.on("unhandledRejection", async (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    await clear();
+    process3.nextTick(() => {
+      process3.exit(1);
+    });
+  });
+  process3.once("SIGINT", async () => {
+    await clear();
+    process3.emit("SIGINT");
+  });
+  process3.once("SIGTERM", async () => {
+    await clear();
+    process3.emit("SIGTERM");
+  });
+}
 var unpluginFactory = (options) => ({
   name: "unplugin-https-reverse-proxy",
-  enforce: "post",
+  enforce: "pre",
   vite: {
     configResolved(_config) {
       config = _config;
+      registerExit(async () => {
+        var _a;
+        try {
+          _servce && _servce.close();
+          (_a = _servce.httpServer) == null ? void 0 : _a.close(async () => {
+            _stop && await _stop();
+          });
+          _stop && await _stop();
+        } catch (e) {
+          consola.error(e);
+        }
+      });
     },
     configureServer(server) {
       const {
+        enable = true,
         target = ""
       } = options;
+      if (!enable)
+        return;
       if (!target) {
         consola.fail("please provide target");
         return;
       }
+      _servce = server;
       const _printUrls = server.printUrls;
       server.printUrls = () => {
         var _a;
@@ -347,51 +436,73 @@ var unpluginFactory = (options) => ({
         }
         const base = server.config.base || "/";
         try {
-          const caddy2 = new CaddyInstant();
-          caddy2.run(source, target, {
+          if (caddy)
+            return;
+          caddy = new CaddyInstant();
+          caddy.run(source, target, {
             base,
             showCaddyLog: options.showCaddyLog
           }).then((stop) => {
             const colorUrl = (url2) => c.green(url2.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
             consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`https://${target}${base}`)}`);
-            process3.on("SIGINT", async () => {
-              await stop();
-              server.close();
-              process3.exit();
-            });
+            !_stop && (_stop = once(stop));
+          }).catch((e) => {
+            throw e;
           });
         } catch (e) {
           consola.error(e);
         }
       };
+    },
+    async buildEnd() {
+      _stop && await _stop();
     }
   },
   webpack(compiler) {
     const {
+      enable = true,
       target = ""
     } = options;
+    if (!enable)
+      return;
     if (!target) {
       consola.fail("please provide target");
       return;
     }
     try {
-      const devServer = compiler.options.devServer || process3.VUE_CLI_SERVICE.projectOptions.devServer;
-      const source = `${(devServer == null ? void 0 : devServer.host) || "127.0.0.1"}:${(devServer == null ? void 0 : devServer.port) || "8080"}`;
+      registerExit(async () => {
+        try {
+          _stop && await _stop();
+        } catch (e) {
+          consola.error(e);
+        }
+      });
+      const devServer = __spreadValues(__spreadValues({
+        host: "127.0.0.1",
+        port: 8080
+      }, compiler.options.devServer), process3.VUE_CLI_SERVICE.projectOptions.devServer);
+      const source = `${devServer.host}:${devServer.port}`;
       if (caddy)
         return;
+      const _close = compiler.close.bind(compiler);
+      compiler.close = async (callback) => {
+        try {
+          _stop && await _stop(() => {
+            _close && _close(callback);
+          });
+        } catch (e) {
+          consola.error(e);
+          process3.exit(1);
+        }
+      };
       caddy = new CaddyInstant();
       caddy.run(source, target, {
         showCaddyLog: options.showCaddyLog
       }).then((stop) => {
         const colorUrl = (url) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
-        compiler.hooks.done.tap("unplugin-https-reverse-proxy", (stats) => {
-          if (stats.hasErrors())
-            return;
+        compiler.hooks.done.tap("unplugin-https-reverse-proxy", () => {
           consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`https://${target}`)}`);
-        });
-        process3.on("SIGINT", async () => {
-          await stop();
-          process3.exit();
+          !_stop && (_stop = once(stop));
         });
       }).catch((e) => {
         throw e;

package/dist/{chunk-BFAT7WWW.js → chunk-RTEXFW4L.js}

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-5K6D2TTS.js";
+} from "./chunk-DH6VMKTP.js";
 
 // src/webpack.ts
 import { createWebpackPlugin } from "unplugin";