unplugin-https-reverse-proxy 2.0.2 → 2.0.3-beta.1

package/dist/chunk-E6C23MZG.js

@@ -1,769 +0,0 @@
-import {
-  chmodRecursive,
-  consola,
-  generateQrcode,
-  getIpv4List,
-  isAdmin,
-  once
-} from "./chunk-2P7SUCQ3.js";
-
-// src/index.ts
-import process4 from "node:process";
-import { Table } from "console-table-printer";
-import c from "picocolors";
-import { createUnplugin } from "unplugin";
-
-// src/caddy/index.ts
-import { spawn } from "node:child_process";
-import { chmodSync as chmodSync2, createWriteStream, existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { readFile, unlink, writeFile } from "node:fs/promises";
-import { platform } from "node:os";
-import { join as join2 } from "node:path";
-import process3 from "node:process";
-import { got } from "got-cjs";
-import { HttpProxyAgent } from "http-proxy-agent";
-import { HttpsProxyAgent } from "https-proxy-agent";
-import * as lockfile from "proper-lockfile";
-
-// src/host/index.ts
-import { exec } from "node:child_process";
-import { chmodSync } from "node:fs";
-import process from "node:process";
-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";
-}
-async function syncHost() {
-  return new Promise((resolve, _reject) => {
-    exec(
-      process.platform === "win32" ? "ipconfig /flushdns" : "sudo -E killall -HUP mDNSResponder",
-      (error, _stdout, _stderr) => {
-        if (error) {
-          consola.error(`exec error: ${error}`);
-          return resolve(false);
-        }
-        return resolve(true);
-      }
-    );
-  });
-}
-async function addHost(ip, host) {
-  if (process.platform !== "win32")
-    chmodSync(getPathOfSystemHostsPath(), 511);
-  await _setHost("127.0.0.1", "localhost");
-  await _setHost(ip, host);
-  if (ip === "localhost")
-    await _setHost("127.0.0.1", host);
-  return await syncHost();
-}
-async function removeHost(ip, host) {
-  if (process.platform !== "win32")
-    chmodSync(getPathOfSystemHostsPath(), 511);
-  await _removeHost(ip, host);
-  if (ip === "localhost")
-    await _removeHost("127.0.0.1", host);
-  return await syncHost();
-}
-
-// src/caddy/constants.ts
-import os from "node:os";
-import { join } from "node:path";
-import process2 from "node:process";
-import dotenvFlow from "dotenv-flow";
-dotenvFlow.config({
-  silent: true
-});
-function resolvePath(path) {
-  if (path.startsWith("~"))
-    return join(os.homedir() || "", path.slice(1));
-  return 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",
-    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/utils.ts
-import { exec as exec2 } from "node:child_process";
-import { createServer } from "node:net";
-import ora from "ora";
-var spinner;
-function tryPort(port) {
-  return new Promise((resolve, _reject) => {
-    try {
-      const server = createServer().listen(port);
-      server.on("listening", () => {
-        server.close();
-        resolve(false);
-      });
-      server.on("error", (err) => {
-        if (err.code === "EADDRINUSE")
-          resolve(true);
-        server.close();
-      });
-    } catch {
-      resolve(true);
-    }
-  });
-}
-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%";
-  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
-async function download() {
-  if (await testCaddy())
-    return caddyPath;
-  return new Promise((resolve, reject) => {
-    if (!existsSync(TEMP_DIR)) {
-      mkdirSync(TEMP_DIR, { recursive: true });
-      chmodSync2(TEMP_DIR, 511);
-    }
-    const file = createWriteStream(caddyPath);
-    let _platform = platform().toString();
-    _platform === "win32" && (_platform = "windows");
-    let _arch = process3.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}&p=github.com%2Fcaddyserver%2Fforwardproxy`;
-    existsSync(caddyPath) && unlinkSync(caddyPath);
-    const httpProxy = process3.env.HTTP_PROXY || process3.env.http_proxy;
-    const httpsProxy = process3.env.HTTPS_PROXY || process3.env.https_proxy;
-    const httpAgent = httpProxy ? new HttpProxyAgent(httpProxy) : void 0;
-    const httpsAgent = httpsProxy ? new HttpsProxyAgent(httpsProxy) : void 0;
-    const chmodCaddyOnce = once(() => {
-      chmodSync2(caddyPath, 511);
-    });
-    got.stream(dowmloadLink, {
-      agent: {
-        http: httpAgent,
-        https: httpsAgent
-      }
-    }).on("downloadProgress", (progress) => {
-      logProgress(progress.percent);
-      chmodCaddyOnce();
-    }).pipe(file).on("finish", () => {
-      logProgressOver();
-      if (process3.platform === "win32")
-        return resolve(caddyPath);
-      chmodSync2(caddyPath, 511);
-      resolve(caddyPath);
-    }).on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-function testCaddy() {
-  return new Promise((resolve, reject) => {
-    if (!existsSync(caddyPath))
-      return resolve(false);
-    chmodSync2(caddyPath, 511);
-    const child = process3.platform === "win32" ? spawn(caddyPath, []) : spawn("sudo", ["-E", caddyPath]);
-    child.on("close", () => {
-      return resolve(false);
-    });
-    child.on("error", (err) => {
-      return reject(err);
-    });
-    child.stdout.on("data", (_data) => {
-      return resolve(true);
-    });
-  });
-}
-var CaddyInstant = class {
-  constructor() {
-    this.inited = false;
-    this.stoped = false;
-    /** 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
-}
-
-:7601 {
-  root * "${join2(
-      process3.platform === "win32" ? `${process3.env.AppData}/Caddy` : `${process3.env.HOME}/Library/Application Support/Caddy`,
-      "./pki/authorities/local"
-    )}"
-  file_server browse
-}
-
-# \u6B63\u5411\u4EE3\u7406\u914D\u7F6E
-:7600 {
-  bind 0.0.0.0
-  
-  forward_proxy {
-    hide_ip
-    hide_via
-    acl {
-      allow all
-    }
-  }
-}
-`;
-    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();
-    this.inited = 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.
-   */
-  async run(source, target, options) {
-    source = source.replace("0.0.0.0", "127.0.0.1");
-    const {
-      restore = true,
-      base = "/",
-      showCaddyLog = false,
-      https = false
-    } = options || {};
-    this._source = source;
-    this._target = target;
-    if (!this.inited)
-      await this.init();
-    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) => {
-      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);
-            });
-          }
-        };
-      };
-      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);
-            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();
-                  process3.exit();
-                } else {
-                  consola.error(`${line}
-`);
-                  return reject(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"))
-              return 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 cwd = process4.cwd();
-function colorUrl(url) {
-  return c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`));
-}
-async function printForwardProxy() {
-  const ipv4List = getIpv4List();
-  if (ipv4List.length) {
-    const ips = ipv4List.map((ip) => c.cyan(ip)).join(", ");
-    consola.info(`${c.bold("Mobile device proxy access")}:
-`);
-    consola.info("1. Install certificate: scan the QR code and download the `root.crt` file,");
-    consola.info("   then install it on your mobile device");
-    const ipTable = await Promise.all(
-      ipv4List.map(async (ip) => ({
-        target: `http://${ip}:7601`,
-        certificate: await generateQrcode(`http://${ip}:7601`)
-      }))
-    );
-    const table = new Table({
-      columns: [
-        { name: "target", alignment: "left" },
-        { name: "certificate", alignment: "center", minLen: 28 }
-      ]
-    });
-    ipTable.forEach((ip) => {
-      table.addRow(ip);
-    });
-    table.printTable();
-    consola.info(`2. Set proxy on mobile device (Available IPs: ${ips}):${c.bold(7600)}
-
-`);
-  }
-}
-var vitePrintUrls = once((options, source, target, base = "/", _printUrls) => {
-  _printUrls == null ? void 0 : _printUrls();
-  if (caddy)
-    return;
-  caddy = new CaddyInstant();
-  caddy.run(source, target, {
-    base,
-    ...options
-  }).then(async () => {
-    await printForwardProxy();
-    consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}${base}`)}`);
-  }).catch((e) => {
-    throw e;
-  });
-});
-var unpluginFactory = (options) => ({
-  name: "unplugin-https-reverse-proxy",
-  enforce: "pre",
-  vite: {
-    configResolved(_config) {
-      config = _config;
-    },
-    configureServer(server) {
-      var _a;
-      if (config.command !== "serve")
-        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;
-      }
-      if (target.match(/^(?:https?)?:\/\//)) {
-        consola.fail("target must be a domain");
-        return;
-      }
-      const _printUrls = server.printUrls.bind(server);
-      let source = `localhost:${config.server.port || 5173}`;
-      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 || "/";
-      server.printUrls = () => vitePrintUrls(options, source, target, base, _printUrls);
-    }
-  },
-  webpack(compiler) {
-    var _a, _b;
-    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;
-    }
-    if (target.match(/^(?:https?)?:\/\//)) {
-      consola.fail("target must be a domain");
-      return;
-    }
-    const devServer = {
-      host: "localhost",
-      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 = (_b = compiler.close) == null ? void 0 : _b.bind(compiler);
-    if (_close) {
-      compiler.close = async (callback) => {
-        process4.on("exit", () => {
-          _close && _close(callback);
-        });
-      };
-    } else {
-      options.https = false;
-    }
-    caddy = new CaddyInstant();
-    caddy.run(source, target, {
-      ...options
-    }).then(() => {
-      compiler.hooks.done.tap("unplugin-https-reverse-proxy", async () => {
-        await printForwardProxy();
-        consola.success(`  ${c.green("\u279C")}  ${c.bold("run caddy reverse proxy success")}: ${colorUrl(`${options.https ? "https" : "http"}://${target}`)}`);
-      });
-    }).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;
-    }
-    if (target.match(/^(?:https?)?:\/\//)) {
-      consola.fail("target must be a domain");
-      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(async () => {
-      await printForwardProxy();
-      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);
-var src_default = unplugin;
-
-export {
-  vitePrintUrls,
-  unpluginFactory,
-  unplugin,
-  src_default
-};