unplugin-https-reverse-proxy 1.0.0-beta.8 → 1.0.0

package/src/caddy/index.ts

@@ -1,15 +1,16 @@
 import { platform } from 'node:os'
 import process from 'node:process'
-import { chmodSync, createWriteStream, existsSync, mkdirSync, unlinkSync } from 'node:fs'
+import { chmodSync, 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 kill from 'kill-port'
+import * as lockfile from 'proper-lockfile'
 import { chmodRecursive, consola, once } from '../utils'
 import { addHost, removeHost } from '../host'
-import { TEMP_DIR, caddyPath, supportList } from './constants'
-import { logProgress, logProgressOver, tryPort } from './utils'
+import { TEMP_DIR, caddyFilePath, caddyLockFilePath, caddyPath, supportList } from './constants'
+import { kill, logProgress, logProgressOver, tryPort } from './utils'
 
 export async function download() {
   if (await testCaddy())
@@ -103,10 +104,57 @@ export class CaddyInstant {
   private inited = false
   private stoped = false
 
+  /** has locked */
+  private locked = false
+  private caddyfile: string | undefined
+
+  private _caddyChild: ReturnType<typeof spawn> | undefined
+
+  private _source: string | undefined
+  private _target: string | undefined
+
   constructor() {
-    testCaddy().then(() => {
+    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() {
@@ -128,111 +176,194 @@ export class CaddyInstant {
       https = false,
     } = options || {}
 
+    this._source = source
+    this._target = target
+
     if (!this.inited)
       await this.init()
 
-    if (https && await tryPort(443))
-      await kill(443, 'tcp')
-    if ((process.platform === 'win32' || !https) && await tryPort(80))
-      await kill(80, 'tcp')
-
     if (!await addHost(source.split(':')[0], target.split(':')[0]))
       throw new Error('update host failed')
     consola.success('update host success\n')
 
-    return new Promise<void>((resolve, reject) => {
-      // caddy reverse-proxy --from target --to source --internal-certs
-      const child = process.platform !== 'win32'
-        ? spawn('sudo', ['-E', caddyPath, 'reverse-proxy', '--from', `${target.split(':')[0]}${https ? '' : ':80'}`, '--to', `${source}`, '--internal-certs', '--insecure', '--disable-redirects'])
-        : spawn(caddyPath, ['reverse-proxy', '--from', `${target.split(':')[0]}`, '--to', `${source}`, '--internal-certs'])
+    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
+    }
 
-      child.on('error', (err) => {
-        return reject(err)
-      })
+    @error status 502 503 504 404
+    handle_response @error {
+      respond * 503 {
+        body "Service Unavailable"
+        close
+      }
+    }
+  }
+}
 
-      process.on('SIGINT', async () => {
-        if (!restore || this.stoped)
-          return
+`
 
-        try {
-          if (await removeHost(source.split(':')[0], target.split(':')[0]))
-            consola.success('restore host success\n')
+      await this.writeCaddyfile()
+    }
+    if (!existsSync(caddyLockFilePath))
+      writeFileSync(caddyLockFilePath, '')
+
+    if (!this.locked) {
+      if (await tryPort(443))
+        await kill(443)
+      if ((process.platform === 'win32' || !https) && await tryPort(80))
+        await kill(80)
+    }
 
-          else
-            consola.fail('restore host failed\n')
-        }
-        catch (e) {
-          consola.error(e)
-          consola.fail('restore host failed\n')
-        }
-        finally {
-          this.stoped = true
-          process.nextTick(() => {
-            process.exit()
-          })
-        }
-      })
-
-      const originalExit = process.exit.bind(process)
-
-      // @ts-expect-error override
-      process.exit = async (code?: number) => {
-        const port = Number(source.split(':')[1])
-        if (!Number.isNaN(port) && await tryPort(port))
-          await kill(port, 'tcp')
-
-        // fix `Error: EPERM: operation not permitted`
-        const pwd = process.cwd()
-        const viteCacheDir = `${pwd}/node_modules/.vite`
-        if (existsSync(viteCacheDir))
-          chmodRecursive(viteCacheDir, 0o777)
-        const nuxtCacheDir = `${pwd}/.nuxt`
-        if (existsSync(nuxtCacheDir))
-          await chmodRecursive(nuxtCacheDir, 0o777)
-        const webpackCacheDir = `${pwd}/node_modules/.cache`
-        if (existsSync(webpackCacheDir))
-          chmodRecursive(webpackCacheDir, 0o777)
-
-        if (!restore || this.stoped)
-          return originalExit(code)
-
-        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
-          process.nextTick(() => {
-            originalExit(code)
-          })
+    return new Promise<void>((resolve, reject) => {
+      const setupCleanup = () => {
+        process.on('SIGINT', async () => {
+          if (this.stoped)
+            return
+
+          process.stdin.resume()
+
+          try {
+            await this.baseCleanup(restore)
+          }
+          finally {
+            this.stoped = true
+            process.nextTick(() => {
+              process.exit()
+            })
+          }
+        })
+
+        const originalExit = process.exit.bind(process)
+
+        // @ts-expect-error override
+        process.exit = async (code?: number) => {
+          const port = Number(source.split(':')[1])
+          if (!Number.isNaN(port) && await tryPort(port))
+            await kill(port)
+
+          // fix `Error: EPERM: operation not permitted`
+          const pwd = process.cwd()
+          const viteCacheDir = `${pwd}/node_modules/.vite`
+          if (existsSync(viteCacheDir))
+            await chmodRecursive(viteCacheDir, 0o777).catch(() => { })
+          const nuxtCacheDir = `${pwd}/.nuxt`
+          if (existsSync(nuxtCacheDir))
+            await chmodRecursive(nuxtCacheDir, 0o777).catch(() => { })
+          const webpackCacheDir = `${pwd}/node_modules/.cache`
+          if (existsSync(webpackCacheDir))
+            await chmodRecursive(webpackCacheDir, 0o777).catch(() => { })
+
+          if (this.stoped)
+            return originalExit(code)
+
+          process.stdin.resume()
+
+          try {
+            await this.baseCleanup()
+          }
+
+          finally {
+            this.stoped = true
+            process.nextTick(() => {
+              originalExit(code)
+            })
+          }
         }
       }
 
-      child.stderr.on('data', (data) => {
-        const lines = (data.toString() as string).split('\n').map(line => line.trim())
-        for (const line of lines) {
-          // caddy log
-          // eslint-disable-next-line no-console
-          showCaddyLog && line && console.info(line)
-          if (line.includes('Error:') || (line && JSON.parse(line).level === 'error')) {
-            consola.error(line)
-            // child.kill()
-            return reject(line)
+      if (!this.locked) {
+        this._caddyChild = process.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)
+        })
+
+        this._caddyChild!.stderr?.on('data', async (data) => {
+          const lines = (data.toString() as string).split('\n').map(line => line.trim())
+          for (const line of lines) {
+            // caddy log
+            // eslint-disable-next-line no-console
+            showCaddyLog && line && console.info(line)
+            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}\n\n${line}\n`)
+                await this.baseCleanup()
+                process.exit()
+              }
+              else {
+                consola.error(`${line}\n`)
+                // child.kill()
+                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()
           }
-        }
-      })
+        })
+
+        this._caddyChild!.stdout?.on('data', (_data) => {
+          consola.info(_data.toString())
+          resolve()
+        })
 
-      child.stdout.on('data', (_data) => {
-        consola.info(_data.toString())
-        resolve()
-      })
+        setupCleanup()
+      }
+      else {
+        consola.info('Caddy is running in another process.')
+
+        setupCleanup()
+
+        return resolve()
+      }
     })
   }
+
+  async baseCleanup(restore: boolean = true) {
+    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) {
+      this._caddyChild?.kill()
+      try {
+        await lockfile.unlock(caddyLockFilePath).catch(() => { })
+        await unlink(caddyFilePath).catch(() => { })
+        await unlink(caddyLockFilePath).catch(() => { })
+      }
+      catch (e) {
+        consola.error(e)
+      }
+    }
+  }
 }

package/src/caddy/utils.ts

@@ -1,4 +1,5 @@
 import { createServer } from 'node:net'
+import { exec } from 'node:child_process'
 import ora from 'ora'
 import { consola } from '../utils'
 
@@ -28,6 +29,23 @@ export function tryPort(port: number) {
   })
 }
 
+/**
+ * npx free-port :port
+ */
+export async function kill(port: number) {
+  return new Promise<void>((resolve, reject) => {
+    exec(`npx @maxbo/free-port ${port} -s`, (err, stdout, stderr) => {
+      if (err) {
+        reject(err)
+      }
+      else {
+        consola.log(stdout)
+        resolve()
+      }
+    })
+  })
+}
+
 function getNumber(number: number) {
   if (number <= 0)
     return '0%'

package/src/host/index.ts

@@ -1,17 +1,13 @@
 import process from 'node:process'
 import { exec } from 'node:child_process'
 import { chmodSync } from 'node:fs'
+import { promisify } from 'node:util'
 
-// @ts-expect-error no type
-import _Hosts from 'hosts-so-easy'
+import hostile from 'hostile'
 import { consola } from '../utils'
 
-const Hosts = _Hosts.default || _Hosts
-
-const hostInstance = new Hosts({
-  debounceTime: 50,
-  hostsFile: getPathOfSystemHostsPath(),
-})
+const _setHost = promisify(hostile.set)
+const _removeHost = promisify(hostile.remove)
 
 function getPathOfSystemHostsPath() {
   return process.platform === 'win32'
@@ -38,20 +34,18 @@ async function syncHost() {
 export async function addHost(ip: string, host: string) {
   if (process.platform !== 'win32')
     chmodSync(getPathOfSystemHostsPath(), 0o777)
-  hostInstance.add('127.0.0.1', 'localhost')
-  hostInstance.add(ip, host)
+  await _setHost('127.0.0.1', 'localhost')
+  await _setHost(ip, host)
   if (ip === 'localhost')
-    hostInstance.add('127.0.0.1', host)
-  await hostInstance.updateFinish()
+    await _setHost('127.0.0.1', host)
   return await syncHost()
 }
 
 export async function removeHost(ip: string, host: string) {
   if (process.platform !== 'win32')
     chmodSync(getPathOfSystemHostsPath(), 0o777)
-  hostInstance.remove(ip, host)
+  await _removeHost(ip, host)
   if (ip === 'localhost')
-    hostInstance.remove('127.0.0.1', host)
-  await hostInstance.updateFinish()
+    await _removeHost('127.0.0.1', host)
   return await syncHost()
 }

package/src/index.ts

@@ -11,7 +11,7 @@ let config: ResolvedConfig
 
 let caddy: CaddyInstant
 
-const pwd = process.cwd()
+const cwd = process.cwd()
 
 export const vitePrintUrls = once((
   options: Options,
@@ -47,17 +47,18 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
       if (config.command !== 'serve')
         return
 
-      if (!isAdmin()) {
-        consola.warn('please run as administrator')
-        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
@@ -81,17 +82,19 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
     if (process.env.NODE_ENV !== 'development')
       return
 
-    if (!isAdmin()) {
-      consola.warn('please run as administrator')
-      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
@@ -102,7 +105,7 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
       port: 8080,
       ...compiler.options.devServer,
       // @ts-expect-error vuecli
-      ...process.VUE_CLI_SERVICE.projectOptions.devServer,
+      ...(process.VUE_CLI_SERVICE?.projectOptions.devServer),
     }
     const source = `${devServer.host}:${devServer.port}`
 
@@ -137,6 +140,54 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
       throw e
     })
   },
+  async rspack(compiler) {
+    if (process.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,
+      ...(await (await import('@rsbuild/core'))?.loadConfig({
+        cwd,
+      }))?.content?.server,
+    }
+
+    const source = `${devServer.host}:${devServer.port}`
+
+    if (caddy)
+      return
+
+    caddy = new CaddyInstant()
+
+    caddy.run(source, target, {
+      ...options,
+    }).then(() => {
+      const colorUrl = (url: string) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`))
+
+      consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}`)}`)
+    }).catch((e) => {
+      throw e
+    })
+  },
 })
 
 export const unplugin = /* #__PURE__ */ createUnplugin(unpluginFactory)

package/src/nuxt.ts

@@ -18,17 +18,19 @@ export default defineNuxtModule<ModuleOptions>({
     if (process.env.NODE_ENV !== 'development')
       return
 
-    if (!isAdmin()) {
-      consola.warn('please run as administrator')
-      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

package/src/rspack.ts

@@ -0,0 +1,5 @@
+import type { Options } from './types'
+import unplugin from '.'
+
+// TODO: some upstream lib failed generate invalid dts, remove the any in the future
+export default unplugin.rspack as (options?: Options) => any

package/dist/chunk-RUJE3YFB.js

@@ -1,63 +0,0 @@
-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 process from "process";
-import path from "path";
-import { chmod, readdir, stat } from "fs/promises";
-import { execSync } from "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 (e) {
-      return false;
-    }
-  } else {
-    return process.getuid && process.getuid() === 0;
-  }
-}
-
-export {
-  __spreadValues,
-  consola,
-  chmodRecursive,
-  once,
-  isAdmin
-};

package/scripts/postinstall.ts

@@ -1,19 +0,0 @@
-import { existsSync, unlinkSync } from 'node:fs'
-import process from 'node:process'
-import { consola } from '../src/utils'
-import { download } from '../src/caddy'
-import { caddyPath } from '../src/caddy/constants'
-
-async function run() {
-  try {
-    if (process.env.UHRP_AUTO_INSTALL_CADDY) {
-      existsSync(caddyPath) && unlinkSync(caddyPath)
-      await download()
-    }
-  }
-  catch (e: any) {
-    consola.error(e.code)
-  }
-}
-
-run()