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

package/dist/webpack.js

@@ -1,7 +1,7 @@
 import {
   unpluginFactory
-} from "./chunk-MMFIKYNA.js";
-import "./chunk-RUJE3YFB.js";
+} from "./chunk-GV7Y22GZ.js";
+import "./chunk-UGWFCSQS.js";
 
 // src/webpack.ts
 import { createWebpackPlugin } from "unplugin";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.15",
   "description": "",
   "license": "MIT",
   "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",
@@ -135,18 +135,20 @@
     "@rspack/core": "^0.5.4",
     "@types/kill-port": "^2.0.3",
     "@types/node": "^20.11.19",
+    "@types/proper-lockfile": "^4.1.4",
     "@vue/cli": "^5.0.8",
     "bumpp": "^9.3.0",
     "chalk": "^5.3.0",
     "eslint": "^8.56.0",
     "fast-glob": "^3.3.2",
     "nodemon": "^3.0.3",
+    "proper-lockfile": "^4.1.2",
     "rimraf": "^5.0.5",
     "rollup": "^3.29.4",
     "tsup": "^7.3.0",
     "typescript": "^5.3.3",
     "vite": "^4.5.2",
-    "vitest": "^0.34.6",
+    "vitest": "^2.0.5",
     "webpack": "^5.90.3"
   },
   "scripts": {
@@ -162,6 +164,6 @@
     "play:vuecli4": "npm -C examples/vuecli4 run serve",
     "release": "bumpp",
     "start": "tsx src/index.ts",
-    "test": "vitest"
+    "test": "UHRP_CADDY_PATH='./test/.uhrp' vitest"
   }
 }

package/scripts/postinstall.cjs

@@ -50,6 +50,7 @@ var import_node_os2 = require("os");
 var import_node_process4 = __toESM(require("process"), 1);
 var import_node_fs2 = require("fs");
 var import_node_child_process3 = require("child_process");
+var import_promises2 = require("fs/promises");
 var import_got_cjs = require("got-cjs");
 var import_http_proxy_agent = require("http-proxy-agent");
 var import_https_proxy_agent = require("https-proxy-agent");
@@ -85,6 +86,7 @@ function resolvePath(path2) {
 var TEMP_DIR = resolvePath(import_node_process3.default.env.UHRP_CADDY_PATH || import_node_process3.default.env.TEMP || import_node_process3.default.env.TMPDIR || "/tmp");
 var caddyPath = (0, import_node_path2.join)(TEMP_DIR, `caddy${import_node_process3.default.platform === "win32" ? ".exe" : ""}`);
 var caddyFilePath = (0, import_node_path2.join)(TEMP_DIR, "CADDYFILE");
+var caddyLockFilePath = (0, import_node_path2.join)(TEMP_DIR, "caddylock");
 var supportList = [
   {
     platform: "dragonfly",

package/src/caddy/constants.ts

@@ -16,6 +16,7 @@ function resolvePath(path: 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 caddyLockFilePath = join(TEMP_DIR, 'caddylock')
 
 export const supportList = [
   {

package/src/caddy/index.ts

@@ -1,14 +1,15 @@
 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 { chmodRecursive, consola, once } from '../utils'
 import { addHost, removeHost } from '../host'
-import { TEMP_DIR, caddyPath, supportList } from './constants'
+import { TEMP_DIR, caddyFilePath, caddyLockFilePath, caddyPath, supportList } from './constants'
 import { logProgress, logProgressOver, tryPort } from './utils'
 
 export async function download() {
@@ -103,10 +104,57 @@ export class CaddyInstant {
   private inited = false
   private stoped = false
 
+  /** has locked */
+  private locked = false
+  private caddyfile: string | undefined
+
+  private lockfile: typeof import('proper-lockfile')
+
   constructor() {
-    testCaddy().then(() => {
+    testCaddy().then(async () => {
+      await this.getCaddyfile()
+
       this.inited = true
     })
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    this.lockfile = require('proper-lockfile')
+
+    this.locked = this.checkLock()
+  }
+
+  checkLock() {
+    if (!existsSync(caddyLockFilePath))
+      writeFileSync(caddyLockFilePath, '')
+    return this.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() {
@@ -131,110 +179,162 @@ export class CaddyInstant {
     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')
 
+    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, 'tcp')
+      if ((process.platform === 'win32' || !https) && await tryPort(80))
+        await kill(80, 'tcp')
+    }
+
     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'])
-
-      child.on('error', (err) => {
-        return reject(err)
-      })
-
-      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)
+      const setupCleanup = () => {
+        process.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
+            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)
+
+          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
+            process.nextTick(() => {
+              originalExit(code)
+            })
           }
-          if (line.includes('caddy proxying'))
-            return resolve()
         }
-      })
+      }
+
+      if (!this.locked) {
+        const child = process.platform !== 'win32'
+          ? spawn('sudo', ['-E', caddyPath, 'run', '--config', caddyFilePath, '--watch'])
+          : spawn(caddyPath, ['run', '--config', caddyFilePath, '--watch'])
+
+        this.lockfile.lockSync(caddyLockFilePath)
+
+        child.on('error', (err) => {
+          return reject(err)
+        })
+
+        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}\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()
+          }
+        })
 
-      child.stdout.on('data', (_data) => {
-        consola.info(_data.toString())
-        resolve()
-      })
+        child.stdout.on('data', (_data) => {
+          consola.info(_data.toString())
+          resolve()
+        })
 
-      process.on('SIGINT', async () => {
-        if (!restore || this.stoped)
-          return
+        setupCleanup()
+      }
+      else {
+        consola.info('Caddy is running in another process.')
 
-        try {
-          if (await removeHost(source.split(':')[0], target.split(':')[0]))
-            consola.success('restore host success\n')
+        setupCleanup()
 
-          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 resolve()
       }
     })
   }
+
+  async baseCleanup() {
+    if (!this.locked) {
+      try {
+        await this.lockfile.unlock(caddyLockFilePath)
+        await unlink(caddyFilePath)
+        await unlink(caddyLockFilePath)
+      }
+      catch (e) {
+        // consola.error(e)
+      }
+    }
+  }
 }