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

package/dist/webpack.js

@@ -1,6 +1,6 @@
 import {
   unpluginFactory
-} from "./chunk-E6C23MZG.js";
+} from "./chunk-XGTVAT6M.js";
 import "./chunk-2P7SUCQ3.js";
 
 // src/webpack.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "2.0.2",
+  "version": "2.0.3-beta.2",
   "description": "",
   "license": "MIT",
   "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",
@@ -75,7 +75,6 @@
   },
   "files": [
     "dist",
-    "scripts/postinstall.cjs",
     "src"
   ],
   "peerDependencies": {
@@ -140,11 +139,14 @@
     "@types/proper-lockfile": "^4.1.4",
     "@types/qrcode-terminal": "^0.12.2",
     "@vue/cli": "^5.0.8",
+    "alien-signals": "^2.0.7",
+    "arktype": "^2.1.20",
     "bumpp": "^9.11.1",
     "chalk": "^5.4.1",
     "cross-env": "^7.0.3",
     "eslint": "^9.20.0",
     "fast-glob": "^3.3.3",
+    "liquidjs": "^10.21.1",
     "nodemon": "^3.1.9",
     "proper-lockfile": "^4.1.2",
     "rimraf": "^5.0.10",
@@ -157,7 +159,6 @@
     "webpack": "^5.90.3"
   },
   "scripts": {
-    "postinstall": "node scripts/postinstall.cjs",
     "build": "tsup",
     "dev": "tsup --watch src",
     "build:fix": "tsx scripts/postbuild.ts",

package/src/caddy/caddyfile.ts

@@ -0,0 +1,78 @@
+import { type } from 'arktype'
+import { Liquid } from 'liquidjs'
+
+export const ProxyType = type({
+  target: 'string',
+  port_suffix: 'string',
+  tls: 'string',
+  source: 'string',
+  base: 'string',
+  health_check: 'boolean',
+})
+
+const CaddyContext = type({
+  caddy_root: 'string',
+  proxies: ProxyType.array(),
+})
+
+export function validateTemplateContext(ctx: unknown): typeof CaddyContext.infer {
+  const out = CaddyContext(ctx as any)
+  if (out instanceof type.errors)
+    throw new Error(out.summary)
+
+  return ctx as typeof CaddyContext.infer
+}
+
+export const caddyTemplate = `{
+  debug
+  auto_https disable_redirects
+}
+
+:7601 {
+  root * "{{ caddy_root }}"
+  file_server browse
+}
+
+# 正向代理配置
+:7600 {
+  bind 0.0.0.0
+  
+  forward_proxy {
+    hide_ip
+    hide_via
+    acl {
+      allow all
+    }
+  }
+}
+
+{% for p in proxies %}
+{{ p.target }}{{ p.port_suffix }} {
+  {{ p.tls }}
+  reverse_proxy http://{{ p.source }} {% if p.health_check %} {
+    health_uri {{ p.base }}
+    health_interval 2s
+    health_timeout 5s
+    fail_duration 2s
+    unhealthy_status 502 503 504 404
+    lb_try_duration 3s
+    lb_try_interval 300ms
+
+    @error status 502 503 504 404
+    handle_response @error {
+      respond * 503 {
+        body "Service Unavailable"
+        close
+      }
+    }
+  }
+  {% endif %}
+}
+{% endfor %}
+`
+
+const liquid = new Liquid()
+
+export async function genCaddyfile(ctx: typeof CaddyContext.infer): Promise<string> {
+  return await liquid.parseAndRender(caddyTemplate, ctx)
+}

package/src/caddy/config.ts

@@ -0,0 +1,67 @@
+import type { ProxyType } from './caddyfile'
+import { existsSync, readFileSync, watch, writeFileSync } from 'node:fs'
+import { unlink } from 'node:fs/promises'
+import { computed, signal } from 'alien-signals'
+import { caddyConfigPath } from './constants'
+
+export function useCaddyConfig(): {
+  configJsonRef: () => (Record<string, typeof ProxyType.infer> | undefined)
+  writeCaddyConfig: (proxies: Array<typeof ProxyType.infer>) => void
+  cleanUp: () => Promise<void>
+} {
+  const configContentRef = signal('{}')
+
+  const configJsonRef = computed(() => {
+    try {
+      return JSON.parse(configContentRef()) as Record<string, typeof ProxyType.infer>
+    }
+    catch {
+      return undefined
+    }
+  })
+
+  function setConfigContent(): void {
+    if (!existsSync(caddyConfigPath)) {
+      writeFileSync(caddyConfigPath, '{}')
+    }
+    try {
+      configContentRef(readFileSync(caddyConfigPath, 'utf-8'))
+    }
+    catch {
+      configContentRef('')
+    }
+  }
+
+  if (!existsSync(caddyConfigPath)) {
+    writeFileSync(caddyConfigPath, '{}')
+  }
+
+  const watchCaddyConfig = watch(caddyConfigPath, () => {
+    setConfigContent()
+  })
+
+  function writeCaddyConfig(_proxies: Array<typeof ProxyType.infer>): void {
+    const proxies = configJsonRef() || {}
+
+    _proxies.forEach((p) => {
+      const index = `${p.target}${p.port_suffix}`
+      proxies[index] = p
+    })
+
+    const content = JSON.stringify(proxies, null, 2)
+    configContentRef(content)
+    return writeFileSync(caddyConfigPath, content)
+  }
+
+  async function cleanUp(): Promise<void> {
+    await unlink(caddyConfigPath).catch(() => { })
+    configContentRef('{}')
+    watchCaddyConfig.close()
+  }
+
+  return {
+    configJsonRef,
+    writeCaddyConfig,
+    cleanUp,
+  }
+}

package/src/caddy/constants.ts

@@ -16,6 +16,8 @@ function resolvePath(path: string): string {
 export const TEMP_DIR = resolvePath(process.env.UHRP_CADDY_PATH || process.env.TEMP || process.env.TMPDIR || '/tmp')
 export const caddyPath = join(TEMP_DIR, `caddy${process.platform === 'win32' ? '.exe' : ''}`)
 export const caddyFilePath = join(TEMP_DIR, 'CADDYFILE')
+
+export const caddyConfigPath = join(TEMP_DIR, '.CADDYFILE.config.json')
 export const caddyLockFilePath = join(TEMP_DIR, 'caddylock')
 
 export const supportList = [

package/src/caddy/index.ts

@@ -4,12 +4,15 @@ import { readFile, unlink, writeFile } from 'node:fs/promises'
 import { platform } from 'node:os'
 import { join } from 'node:path'
 import process from 'node:process'
+import { effect } from 'alien-signals'
 import { got } from 'got-cjs'
 import { HttpProxyAgent } from 'http-proxy-agent'
 import { HttpsProxyAgent } from 'https-proxy-agent'
 import * as lockfile from 'proper-lockfile'
 import { addHost, removeHost } from '../host'
 import { chmodRecursive, consola, once } from '../utils'
+import { genCaddyfile, validateTemplateContext } from './caddyfile'
+import { useCaddyConfig } from './config'
 import { caddyFilePath, caddyLockFilePath, caddyPath, supportList, TEMP_DIR } from './constants'
 import { kill, logProgress, logProgressOver, tryPort } from './utils'
 
@@ -99,13 +102,16 @@ interface RunOptions {
   base: string
   showCaddyLog: boolean
   https: boolean
+  health_check?: boolean
 }
 
+const { cleanUp, configJsonRef, writeCaddyConfig } = useCaddyConfig()
+
 export class CaddyInstant {
   private inited = false
   private stoped = false
 
-  /** has locked */
+  /** has locked when start */
   private locked = false
   private caddyfile: string | undefined
 
@@ -113,11 +119,10 @@ export class CaddyInstant {
 
   private _source: string | undefined
   private _target: string | undefined
+  private _stopEffects: Array< (() => void)> = []
 
   constructor() {
     testCaddy().then(async () => {
-      await this.getCaddyfile()
-
       this.inited = true
     })
 
@@ -131,45 +136,22 @@ export class CaddyInstant {
   }
 
   async getCaddyfile(): Promise<string> {
-    if (!existsSync(caddyFilePath))
-      await this.initCaddyfile()
+    if (!existsSync(caddyFilePath)) {
+      this.caddyfile = ''
+      return ''
+    }
 
     this.caddyfile = await readFile(caddyFilePath, 'utf-8')
     return this.caddyfile
   }
 
-  async initCaddyfile(): Promise<void> {
-    const contet = `
-{
-  debug
-  auto_https disable_redirects
-}
-
-:7601 {
-  root * "${join(
-    process.platform === 'win32'
-      ? `${process.env.AppData!}/Caddy`
-      : `${process.env.HOME!}/Library/Application Support/Caddy`,
-    './pki/authorities/local',
-  )}"
-  file_server browse
-}
-
-# 正向代理配置
-:7600 {
-  bind 0.0.0.0
-  
-  forward_proxy {
-    hide_ip
-    hide_via
-    acl {
-      allow all
-    }
-  }
-}
-`
-    await writeFile(caddyFilePath, contet)
-    this.caddyfile = contet
+  get caddyRoot(): string {
+    return join(
+      process.platform === 'win32'
+        ? `${process.env.AppData!}/Caddy`
+        : `${process.env.HOME!}/Library/Application Support/Caddy`,
+      './pki/authorities/local',
+    )
   }
 
   async writeCaddyfile(): Promise<void> {
@@ -196,6 +178,7 @@ export class CaddyInstant {
       base = '/',
       showCaddyLog = false,
       https = false,
+      health_check = true,
     } = options || {}
 
     this._source = source
@@ -208,38 +191,36 @@ export class CaddyInstant {
       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
-    }
+    const targetHost = target.split(':')[0]
 
-    @error status 502 503 504 404
-    handle_response @error {
-      respond * 503 {
-        body "Service Unavailable"
-        close
-      }
-    }
-  }
-}
-`
+    const proxies = [
+      {
+        target: targetHost,
+        port_suffix: https ? '' : ':80',
+        tls: https ? 'tls internal' : '',
+        source,
+        base,
+        health_check,
+      },
+    ]
+
+    writeCaddyConfig(proxies)
+
+    this._stopEffects.push(
+      effect(async () => {
+        const proxies = Object.values(configJsonRef() || {})
+        if (!(this.caddyfile || '').includes(`${target.split(':')[0]}${https ? '' : ':80'}`)) {
+          const ctx = validateTemplateContext({
+            caddy_root: this.caddyRoot,
+            proxies,
+          })
+
+          this.caddyfile = await genCaddyfile(ctx)
+          await this.writeCaddyfile()
+        }
+      }),
+    )
 
-      await this.writeCaddyfile()
-    }
     if (!existsSync(caddyLockFilePath))
       writeFileSync(caddyLockFilePath, '')
 
@@ -366,6 +347,8 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
   }
 
   async baseCleanup(restore: boolean = true): Promise<void> {
+    this._stopEffects.forEach(fn => fn())
+
     try {
       if (restore && this._source && this._target) {
         if (await removeHost(this._source.split(':')[0], this._target.split(':')[0]))
@@ -385,6 +368,7 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
         await lockfile.unlock(caddyLockFilePath).catch(() => { })
         await unlink(caddyFilePath).catch(() => { })
         await unlink(caddyLockFilePath).catch(() => { })
+        await cleanUp()
       }
       catch (e) {
         consola.error(e)

package/src/types.ts

@@ -5,4 +5,5 @@ export interface Options {
   showCaddyLog?: boolean
   /** default `false` */
   https?: boolean
+  health_check?: boolean
 }