unplugin-https-reverse-proxy 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/chunk-2VGRJ3QS.js

@@ -0,0 +1,45 @@
+// src/utils.ts
+import process from "node:process";
+import path from "node:path";
+import { chmod, readdir, stat } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { createConsola } from "consola";
+var consola = createConsola({
+  level: 3
+}).withTag("reverse-proxy");
+async function chmodRecursive(_path, mode) {
+  await chmod(_path, mode);
+  if ((await stat(_path)).isDirectory()) {
+    const children = await readdir(_path);
+    for (const child of children)
+      await chmodRecursive(path.join(_path, child), mode);
+  }
+}
+function once(fn) {
+  let called = false;
+  return (...args) => {
+    if (called)
+      return;
+    called = true;
+    return fn(...args);
+  };
+}
+function isAdmin() {
+  if (process.platform === "win32") {
+    try {
+      execSync("net session", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  } else {
+    return process.getuid && process.getuid() === 0;
+  }
+}
+
+export {
+  consola,
+  chmodRecursive,
+  once,
+  isAdmin
+};

package/dist/chunk-WCFY7NJQ.js

@@ -0,0 +1,662 @@
+import {
+  chmodRecursive,
+  consola,
+  isAdmin,
+  once
+} from "./chunk-2VGRJ3QS.js";
+
+// src/index.ts
+import process4 from "node:process";
+import { createUnplugin } from "unplugin";
+import c from "picocolors";
+
+// src/caddy/index.ts
+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 * as lockfile from "proper-lockfile";
+
+// src/host/index.ts
+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";
+}
+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 { join } from "node:path";
+import os from "node:os";
+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 { createServer } from "node:net";
+import { exec as exec2 } from "node:child_process";
+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 (e) {
+      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}`;
+    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
+}
+    
+`;
+    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.
+   * @returns
+   */
+  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 || {};
+    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}
+}
+
+`;
+      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 (!restore || this.stoped)
+            return;
+          await this.baseCleanup();
+          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);
+          const pwd = process3.cwd();
+          const viteCacheDir = `${pwd}/node_modules/.vite`;
+          if (existsSync(viteCacheDir))
+            chmodRecursive(viteCacheDir, 511);
+          const nuxtCacheDir = `${pwd}/.nuxt`;
+          if (existsSync(nuxtCacheDir))
+            await chmodRecursive(nuxtCacheDir, 511);
+          const webpackCacheDir = `${pwd}/node_modules/.cache`;
+          if (existsSync(webpackCacheDir))
+            chmodRecursive(webpackCacheDir, 511);
+          if (!restore || this.stoped)
+            return originalExit(code);
+          await this.baseCleanup();
+          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);
+            });
+          }
+        };
+      };
+      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", (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 (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() {
+    var _a;
+    if (!this.locked) {
+      (_a = this.caddyChild) == null ? void 0 : _a.kill();
+      try {
+        await lockfile.unlock(caddyLockFilePath);
+        await unlink(caddyFilePath);
+        await unlink(caddyLockFilePath);
+      } catch (e) {
+      }
+    }
+  }
+};
+
+// src/index.ts
+var config;
+var caddy;
+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, {
+    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) => {
+    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;
+      }
+      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;
+    }
+    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(() => {
+      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}`)}`);
+      });
+    }).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);
+var src_default = unplugin;
+
+export {
+  vitePrintUrls,
+  unpluginFactory,
+  unplugin,
+  src_default
+};