unplugin-https-reverse-proxy 0.0.1

package/dist/webpack.cjs

@@ -0,0 +1,381 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/webpack.ts
+var webpack_exports = {};
+__export(webpack_exports, {
+  default: () => webpack_default
+});
+module.exports = __toCommonJS(webpack_exports);
+var import_unplugin2 = require("unplugin");
+
+// src/index.ts
+var import_node_process3 = __toESM(require("process"), 1);
+var import_unplugin = require("unplugin");
+var import_picocolors = __toESM(require("picocolors"), 1);
+
+// src/caddy/index.ts
+var import_node_os = require("os");
+var import_node_process2 = __toESM(require("process"), 1);
+var import_node_fs = require("fs");
+var import_node_child_process = require("child_process");
+var import_got = __toESM(require("got"), 1);
+var hostile = __toESM(require("hostile"), 1);
+var import_kill_port = __toESM(require("kill-port"), 1);
+
+// src/caddy/constants.ts
+var import_node_path = require("path");
+var import_node_process = __toESM(require("process"), 1);
+var TEMP_DIR = import_node_process.default.env.TEMP || import_node_process.default.env.TMPDIR || "/tmp";
+var caddyPath = (0, import_node_path.join)(TEMP_DIR, "caddy");
+var caddyFilePath = (0, import_node_path.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 = (0, import_node_fs.createWriteStream)(caddyPath);
+    let _platform = (0, import_node_os.platform)().toString();
+    _platform === "win32" && (_platform = "windows");
+    let _arch = import_node_process2.default.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}`;
+    (0, import_node_fs.existsSync)(caddyPath) && (0, import_node_fs.unlinkSync)(caddyPath);
+    import_got.default.stream(dowmloadLink).pipe(file).on("finish", () => {
+      if (import_node_process2.default.platform === "win32")
+        return resolve(caddyPath);
+      (0, import_node_fs.chmodSync)(caddyPath, 493);
+      resolve(caddyPath);
+    }).on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function testCaddy() {
+  return new Promise((resolve, reject) => {
+    if (!(0, import_node_fs.existsSync)(caddyPath))
+      return resolve(false);
+    (0, import_node_fs.chmodSync)(caddyPath, 493);
+    const child = (0, import_node_child_process.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 (import_node_process2.default.platform === "win32") {
+            (0, import_node_child_process.spawn)("ipconfig", ["/flushdns"]).on("error", (err2) => {
+              return reject(err2);
+            }).on("close", () => {
+              resolve(true);
+            });
+          } else {
+            (0, import_node_child_process.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 (import_node_process2.default.platform === "win32") {
+            (0, import_node_child_process.spawn)("ipconfig", ["/flushdns"]).on("error", (err2) => {
+              return reject(err2);
+            }).on("close", () => {
+              resolve(true);
+            });
+          } else {
+            (0, import_node_child_process.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 (0, import_kill_port.default)(443, "tcp");
+    return new Promise((resolve, reject) => {
+      const child = (0, import_node_child_process.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) => import_picocolors.default.green(url2.replace(/:(\d+)\//, (_, port) => `:${import_picocolors.default.bold(port)}/`));
+            console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold("run caddy reverse proxy success")}: ${colorUrl(`https://${target}${base}`)}`);
+            import_node_process3.default.on("SIGINT", async () => {
+              await stop();
+              server.close();
+              import_node_process3.default.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) => import_picocolors.default.green(url.replace(/:(\d+)\//, (_, port) => `:${import_picocolors.default.bold(port)}/`));
+        console.log(`  ${import_picocolors.default.green("\u279C")}  ${import_picocolors.default.bold("run caddy reverse proxy success")}: ${colorUrl(`https://${target}`)}`);
+        import_node_process3.default.on("SIGINT", async () => {
+          await stop();
+          import_node_process3.default.exit();
+        });
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+});
+
+// src/webpack.ts
+var webpack_default = (0, import_unplugin2.createWebpackPlugin)(unpluginFactory);
+exports.default = module.exports;

package/dist/webpack.d.cts

@@ -0,0 +1,6 @@
+import * as webpack from 'webpack';
+import { Options } from './types.cjs';
+
+declare const _default: (options: Options) => webpack.WebpackPluginInstance;
+
+export { _default as default };

package/dist/webpack.d.ts

@@ -0,0 +1,6 @@
+import * as webpack from 'webpack';
+import { Options } from './types.js';
+
+declare const _default: (options: Options) => webpack.WebpackPluginInstance;
+
+export { _default as default };

package/dist/webpack.js

@@ -0,0 +1,7 @@
+import {
+  webpack_default
+} from "./chunk-TIR4PYKX.js";
+import "./chunk-QYHKWM3K.js";
+export {
+  webpack_default as default
+};

package/package.json

@@ -0,0 +1,143 @@
+{
+  "name": "unplugin-https-reverse-proxy",
+  "type": "module",
+  "version": "0.0.1",
+  "packageManager": "pnpm@8.6.12",
+  "description": "",
+  "license": "MIT",
+  "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zcf0508/unplugin-https-reverse-proxy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zcf0508/unplugin-https-reverse-proxy/issues"
+  },
+  "keywords": [
+    "unplugin",
+    "vite",
+    "webpack",
+    "rollup",
+    "transform"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js",
+      "require": "./dist/vite.cjs"
+    },
+    "./webpack": {
+      "types": "./dist/webpack.d.ts",
+      "import": "./dist/webpack.js",
+      "require": "./dist/webpack.cjs"
+    },
+    "./rollup": {
+      "types": "./dist/rollup.d.ts",
+      "import": "./dist/rollup.js",
+      "require": "./dist/rollup.cjs"
+    },
+    "./esbuild": {
+      "types": "./dist/esbuild.d.ts",
+      "import": "./dist/esbuild.js",
+      "require": "./dist/esbuild.cjs"
+    },
+    "./nuxt": {
+      "types": "./dist/nuxt.d.ts",
+      "import": "./dist/nuxt.js",
+      "require": "./dist/nuxt.cjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
+    },
+    "./*": "./*"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@nuxt/kit": "^3",
+    "@nuxt/schema": "^3",
+    "esbuild": "*",
+    "rollup": "^3",
+    "vite": ">=3",
+    "webpack": "^4 || ^5"
+  },
+  "peerDependenciesMeta": {
+    "webpack": {
+      "optional": true
+    },
+    "rollup": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@nuxt/schema": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "got": "^13.0.0",
+    "hostile": "^1.3.3",
+    "kill-port": "^2.0.1",
+    "picocolors": "^1.0.0",
+    "unplugin": "^1.4.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^0.40.2",
+    "@nuxt/kit": "^3.6.5",
+    "@nuxt/schema": "^3.6.5",
+    "@types/got": "^9.6.12",
+    "@types/hostile": "^1.3.3",
+    "@types/kill-port": "^2.0.3",
+    "@types/node": "^20.5.2",
+    "bumpp": "^9.2.0",
+    "chalk": "^5.3.0",
+    "eslint": "^8.47.0",
+    "esno": "^0.17.0",
+    "fast-glob": "^3.3.1",
+    "nodemon": "^3.0.1",
+    "rimraf": "^5.0.1",
+    "rollup": "^3.28.1",
+    "tsup": "^7.2.0",
+    "typescript": "^5.1.6",
+    "vite": "^4.4.9",
+    "vitest": "^0.34.2",
+    "webpack": "^5.88.2"
+  },
+  "scripts": {
+    "postinstall": "esno scripts/postinstall.ts",
+    "build": "tsup",
+    "dev": "tsup --watch src",
+    "build:fix": "esno scripts/postbuild.ts",
+    "lint": "eslint .",
+    "play": "npm -C playground run dev",
+    "release": "bumpp",
+    "start": "esno src/index.ts",
+    "test": "vitest"
+  }
+}