unplugin-https-reverse-proxy 1.0.0-beta.16 → 1.0.0-beta.18

package/src/caddy/index.ts

@@ -6,12 +6,11 @@ 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, caddyFilePath, caddyLockFilePath, caddyPath, supportList } from './constants'
-import { logProgress, logProgressOver, tryPort } from './utils'
+import { kill, logProgress, logProgressOver, tryPort } from './utils'
 
 export async function download() {
   if (await testCaddy())
@@ -109,6 +108,11 @@ export class CaddyInstant {
   private locked = false
   private caddyfile: string | undefined
 
+  private _caddyChild: ReturnType<typeof spawn> | undefined
+
+  private _source: string | undefined
+  private _target: string | undefined
+
   constructor() {
     testCaddy().then(async () => {
       await this.getCaddyfile()
@@ -172,6 +176,9 @@ export class CaddyInstant {
       https = false,
     } = options || {}
 
+    this._source = source
+    this._target = target
+
     if (!this.inited)
       await this.init()
 
@@ -197,29 +204,21 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
 
     if (!this.locked) {
       if (await tryPort(443))
-        await kill(443, 'tcp')
+        await kill(443)
       if ((process.platform === 'win32' || !https) && await tryPort(80))
-        await kill(80, 'tcp')
+        await kill(80)
     }
 
     return new Promise<void>((resolve, reject) => {
       const setupCleanup = () => {
         process.on('SIGINT', async () => {
-          if (!restore || this.stoped)
+          if (this.stoped)
             return
 
-          await this.baseCleanup()
+          process.stdin.resume()
 
           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')
+            await this.baseCleanup(restore)
           }
           finally {
             this.stoped = true
@@ -235,36 +234,29 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
         process.exit = async (code?: number) => {
           const port = Number(source.split(':')[1])
           if (!Number.isNaN(port) && await tryPort(port))
-            await kill(port, 'tcp')
+            await kill(port)
 
           // fix `Error: EPERM: operation not permitted`
           const pwd = process.cwd()
           const viteCacheDir = `${pwd}/node_modules/.vite`
           if (existsSync(viteCacheDir))
-            chmodRecursive(viteCacheDir, 0o777)
+            await chmodRecursive(viteCacheDir, 0o777).catch(() => { })
           const nuxtCacheDir = `${pwd}/.nuxt`
           if (existsSync(nuxtCacheDir))
-            await chmodRecursive(nuxtCacheDir, 0o777)
+            await chmodRecursive(nuxtCacheDir, 0o777).catch(() => { })
           const webpackCacheDir = `${pwd}/node_modules/.cache`
           if (existsSync(webpackCacheDir))
-            chmodRecursive(webpackCacheDir, 0o777)
+            await chmodRecursive(webpackCacheDir, 0o777).catch(() => { })
 
-          if (!restore || this.stoped)
+          if (this.stoped)
             return originalExit(code)
 
-          await this.baseCleanup()
+          process.stdin.resume()
 
           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')
+            await this.baseCleanup()
           }
+
           finally {
             this.stoped = true
             process.nextTick(() => {
@@ -275,17 +267,17 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
       }
 
       if (!this.locked) {
-        const child = process.platform !== 'win32'
+        this._caddyChild = process.platform !== 'win32'
           ? spawn('sudo', ['-E', caddyPath, 'run', '--config', caddyFilePath, '--watch'])
           : spawn(caddyPath, ['run', '--config', caddyFilePath, '--watch'])
 
         lockfile.lockSync(caddyLockFilePath)
 
-        child.on('error', (err) => {
+        this._caddyChild!.on('error', (err) => {
           return reject(err)
         })
 
-        child.stderr.on('data', (data) => {
+        this._caddyChild!.stderr?.on('data', (data) => {
           const lines = (data.toString() as string).split('\n').map(line => line.trim())
           for (const line of lines) {
             // caddy log
@@ -304,7 +296,7 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
           }
         })
 
-        child.stdout.on('data', (_data) => {
+        this._caddyChild!.stdout?.on('data', (_data) => {
           consola.info(_data.toString())
           resolve()
         })
@@ -321,15 +313,29 @@ ${target.split(':')[0]}${https ? '' : ':80'} {
     })
   }
 
-  async baseCleanup() {
-    if (!this.locked) {
+  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)
-        await unlink(caddyFilePath)
-        await unlink(caddyLockFilePath)
+        await lockfile.unlock(caddyLockFilePath).catch(() => { })
+        await unlink(caddyFilePath).catch(() => { })
+        await unlink(caddyLockFilePath).catch(() => { })
       }
       catch (e) {
-        // consola.error(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()
 }