unplugin-https-reverse-proxy 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 huali <https://github.com/zcf0508>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# unplugin-https-reverse-proxy
+
+[![NPM version](https://img.shields.io/npm/v/unplugin-https-reverse-proxy?color=a1b858&label=)](https://www.npmjs.com/package/unplugin-https-reverse-proxy)
+
+A plugin for https reverse proxy, support `vite` and `webpack`.
+
+## Install
+
+```bash
+npm i unplugin-https-reverse-proxy
+```
+
+<details>
+<summary>Vite</summary><br>
+
+```ts
+// vite.config.ts
+import Starter from 'unplugin-https-reverse-proxy/vite'
+
+export default defineConfig({
+  plugins: [
+    Starter({ /* options */ }),
+  ],
+})
+```
+
+Example: [`playground/`](./playground/)
+
+<br></details>
+
+<details>
+<summary>Webpack</summary><br>
+
+```ts
+// webpack.config.js
+module.exports = {
+  /* ... */
+  plugins: [
+    require('unplugin-https-reverse-proxy/webpack')({ /* options */ })
+  ]
+}
+```
+
+<br></details>
+
+<details>
+<summary>Nuxt</summary><br>
+
+```ts
+// nuxt.config.js
+export default defineNuxtConfig({
+  modules: [
+    ['unplugin-https-reverse-proxy/nuxt', { /* options */ }],
+  ],
+})
+```
+
+> This module works for both Nuxt 2 and [Nuxt Vite](https://github.com/nuxt/vite)
+
+<br></details>
+
+<details>
+<summary>Vue CLI</summary><br>
+
+```ts
+// vue.config.js
+module.exports = {
+  configureWebpack: {
+    plugins: [
+      require('unplugin-https-reverse-proxy/webpack')({ /* options */ }),
+    ],
+  },
+}
+```
+
+<br>

package/dist/chunk-QYHKWM3K.js

@@ -0,0 +1,348 @@
+// src/index.ts
+import process3 from "process";
+import { createUnplugin } from "unplugin";
+import c from "picocolors";
+
+// src/caddy/index.ts
+import { platform } from "os";
+import process2 from "process";
+import { chmodSync, createWriteStream, existsSync, unlinkSync } from "fs";
+import { spawn } from "child_process";
+import got from "got";
+import * as hostile from "hostile";
+import kill from "kill-port";
+
+// src/caddy/constants.ts
+import { join } from "path";
+import process from "process";
+var TEMP_DIR = process.env.TEMP || process.env.TMPDIR || "/tmp";
+var caddyPath = join(TEMP_DIR, "caddy");
+var caddyFilePath = join(TEMP_DIR, "CADDYFILE");
+var supportList = [
+  {
+    platform: "dragonfly",
+    arch: "amd64"
+  },
+  {
+    platform: "freebsd",
+    arch: "amd64"
+  },
+  {
+    platform: "freebsd",
+    arch: "arm-6"
+  },
+  {
+    platform: "freebsd",
+    arch: "arm-7"
+  },
+  {
+    platform: "freebsd",
+    arch: "arm64"
+  },
+  {
+    platform: "linux",
+    arch: "amd64"
+  },
+  {
+    platform: "linux",
+    arch: "arm-5"
+  },
+  {
+    platform: "linux",
+    arch: "arm-6"
+  },
+  {
+    platform: "linux",
+    arch: "arm-7"
+  },
+  {
+    platform: "linux",
+    arch: "arm64"
+  },
+  {
+    platform: "linux",
+    arch: "mips"
+  },
+  {
+    platform: "linux",
+    arch: "mips64"
+  },
+  {
+    platform: "linux",
+    arch: "mips64le"
+  },
+  {
+    platform: "linux",
+    arch: "mipsle"
+  },
+  {
+    platform: "linux",
+    arch: "ppc64"
+  },
+  {
+    platform: "linux",
+    arch: "ppc64le"
+  },
+  {
+    platform: "linux",
+    arch: "s390x"
+  },
+  {
+    platform: "darwin",
+    arch: "amd64"
+  },
+  {
+    platform: "darwin",
+    arch: "arm64"
+  },
+  {
+    platform: "openbsd",
+    arch: "amd64"
+  },
+  {
+    platform: "openbsd",
+    arch: "arm-6"
+  },
+  {
+    platform: "openbsd",
+    arch: "arm-7"
+  },
+  {
+    platform: "openbsd",
+    arch: "arm64"
+  },
+  {
+    platform: "windows",
+    arch: "amd64"
+  },
+  {
+    platform: "windows",
+    arch: "arm-6"
+  },
+  {
+    platform: "windows",
+    arch: "arm-7"
+  },
+  {
+    platform: "windows",
+    arch: "arm64"
+  }
+];
+
+// src/caddy/index.ts
+async function download() {
+  if (await testCaddy())
+    return caddyPath;
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(caddyPath);
+    let _platform = platform().toString();
+    _platform === "win32" && (_platform = "windows");
+    let _arch = process2.arch.toString();
+    _arch === "x64" && (_arch = "amd64");
+    const support = supportList.find((item) => item.platform === _platform && item.arch === _arch);
+    if (!support)
+      return reject(new Error("not support"));
+    const dowmloadLink = `https://caddyserver.com/api/download?os=${support.platform}&arch=${support.arch}`;
+    existsSync(caddyPath) && unlinkSync(caddyPath);
+    got.stream(dowmloadLink).pipe(file).on("finish", () => {
+      if (process2.platform === "win32")
+        return resolve(caddyPath);
+      chmodSync(caddyPath, 493);
+      resolve(caddyPath);
+    }).on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function testCaddy() {
+  return new Promise((resolve, reject) => {
+    if (!existsSync(caddyPath))
+      return resolve(false);
+    chmodSync(caddyPath, 493);
+    const child = spawn("sudo", [caddyPath]);
+    child.on("error", (err) => {
+      reject(err);
+    });
+    child.stdout.on("data", (_data) => {
+      resolve(true);
+    });
+  });
+}
+var CaddyInstant = class {
+  constructor() {
+    this.inited = false;
+    testCaddy().then(() => {
+      this.inited = true;
+    });
+  }
+  async init() {
+    await download();
+    this.inited = true;
+  }
+  async updateHost(ip, host) {
+    ["localhost", "0.0.0.0"].includes(ip) && (ip = "127.0.0.1");
+    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);
+            });
+          }
+        }
+      });
+    });
+  }
+  async restoreHost(ip, host) {
+    ["localhost", "0.0.0.0"].includes(ip) && (ip = "127.0.0.1");
+    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);
+            });
+          }
+        }
+      });
+    });
+  }
+  /**
+   * @param source like `127.0.0.1:8080`
+   * @param target like `test.abc.com`. And if you provide a port ,it will be ignore.
+   * @returns
+   */
+  async run(source, target, options) {
+    const {
+      restore = false,
+      base = "/"
+    } = options || {};
+    if (!this.inited)
+      await this.init();
+    if (!await this.updateHost(source.split(":")[0], target.split(":")[0]))
+      throw new Error("update host failed");
+    await kill(443, "tcp");
+    return new Promise((resolve, reject) => {
+      const child = spawn("sudo", [caddyPath, "reverse-proxy", "--from", `${target.split(":")[0]}`, "--to", `${source}`, "--internal-certs"]);
+      child.on("error", (err) => {
+        return reject(err);
+      });
+      child.stderr.on("data", (data) => {
+        if (data.toString().includes("Error")) {
+          child.kill();
+          return reject(data.toString());
+        }
+      });
+      child.stdout.on("data", (_data) => {
+        resolve(async () => {
+          if (!restore)
+            return;
+          if (await this.restoreHost(source.split(":")[0], target.split(":")[0])) {
+            console.log("restore host success\n");
+          } else {
+            console.error("restore host failed\n");
+          }
+          child.kill();
+        });
+      });
+    });
+  }
+};
+
+// src/index.ts
+var config;
+var unpluginFactory = (options) => ({
+  name: "unplugin-https-reverse-proxy",
+  vite: {
+    configResolved(_config) {
+      config = _config;
+    },
+    configureServer(server) {
+      const {
+        target = ""
+      } = options;
+      if (!target) {
+        console.log("please provide target");
+        return;
+      }
+      server.printUrls = () => {
+        var _a;
+        let source = `localhost:${config.server.port}`;
+        const url = (_a = server.resolvedUrls) == null ? void 0 : _a.local[0];
+        if (url) {
+          const u = new URL(url);
+          source = u.host;
+        }
+        const base = server.config.base || "/";
+        try {
+          const caddy = new CaddyInstant();
+          caddy.run(source, target, {
+            base
+          }).then((stop) => {
+            const colorUrl = (url2) => c.green(url2.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
+            console.log(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`https://${target}${base}`)}`);
+            process3.on("SIGINT", async () => {
+              await stop();
+              server.close();
+              process3.exit();
+            });
+          });
+        } catch (e) {
+          console.error(e);
+        }
+      };
+    }
+  },
+  webpack(compiler) {
+    var _a, _b;
+    const {
+      target = ""
+    } = options;
+    if (!target) {
+      console.log("please provide target");
+      return;
+    }
+    const source = `${((_a = compiler.options.devServer) == null ? void 0 : _a.host) || "127.0.0.1"}:${((_b = compiler.options.devServer) == null ? void 0 : _b.port) || "8080"}`;
+    try {
+      const caddy = new CaddyInstant();
+      caddy.run(source, target).then((stop) => {
+        const colorUrl = (url) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
+        console.log(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`https://${target}`)}`);
+        process3.on("SIGINT", async () => {
+          await stop();
+          process3.exit();
+        });
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+});
+var unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
+var src_default = unplugin;
+
+export {
+  unpluginFactory,
+  unplugin,
+  src_default
+};

package/dist/chunk-TIR4PYKX.js

@@ -0,0 +1,11 @@
+import {
+  unpluginFactory
+} from "./chunk-QYHKWM3K.js";
+
+// src/webpack.ts
+import { createWebpackPlugin } from "unplugin";
+var webpack_default = createWebpackPlugin(unpluginFactory);
+
+export {
+  webpack_default
+};

package/dist/chunk-XWZYGFLS.js

@@ -0,0 +1,11 @@
+import {
+  unpluginFactory
+} from "./chunk-QYHKWM3K.js";
+
+// src/vite.ts
+import { createVitePlugin } from "unplugin";
+var vite_default = createVitePlugin(unpluginFactory);
+
+export {
+  vite_default
+};