unplugin-https-reverse-proxy 0.0.4 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "packageManager": "pnpm@8.6.12",
   "description": "",
   "license": "MIT",
@@ -70,7 +70,9 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "scripts/postinstall.ts",
+    "src"
   ],
   "peerDependencies": {
     "@nuxt/kit": "^3",

package/scripts/postinstall.ts

@@ -0,0 +1,15 @@
+import { existsSync, unlinkSync } from 'node:fs'
+import { download } from '../src/caddy'
+import { caddyPath } from '../src/caddy/constants'
+
+async function run() {
+  try {
+    existsSync(caddyPath) && unlinkSync(caddyPath)
+    await download()
+  }
+  catch (e: any) {
+    console.log(e.code)
+  }
+}
+
+run()

package/src/caddy/constants.ts

@@ -0,0 +1,117 @@
+import { join } from 'node:path'
+import process from 'node:process'
+
+const TEMP_DIR = 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 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',
+  },
+]

package/src/caddy/index.ts

@@ -0,0 +1,212 @@
+import { platform } from 'node:os'
+import process from 'node:process'
+import { chmodSync, createWriteStream, existsSync, unlinkSync } from 'node:fs'
+import { spawn } from 'node:child_process'
+import { got } from 'got-cjs'
+import { HttpProxyAgent } from 'http-proxy-agent'
+import { HttpsProxyAgent } from 'https-proxy-agent'
+import * as hostile from 'hostile'
+import kill from 'kill-port'
+import { caddyPath, supportList } from './constants'
+import { tryPort } from './utils'
+
+export async function download() {
+  if (await testCaddy())
+    return caddyPath
+
+  return new Promise<string>((resolve, reject) => {
+    // https://caddyserver.com/api/download?os=darwin&arch=amd64
+
+    const file = createWriteStream(caddyPath)
+
+    let _platform = platform().toString()
+    // win32 -> windows
+    _platform === 'win32' && (_platform = 'windows')
+    let _arch = process.arch.toString()
+    // x64 -> amd64
+    _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 = process.env.HTTP_PROXY || process.env.http_proxy
+    const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy
+
+    const httpAgent = httpProxy ? new HttpProxyAgent(httpProxy) : undefined
+    const httpsAgent = httpsProxy ? new HttpsProxyAgent(httpsProxy) : undefined
+
+    got.stream(dowmloadLink, {
+      agent: {
+        http: httpAgent,
+        https: httpsAgent,
+      },
+    }).pipe(file).on('finish', () => {
+      if (process.platform === 'win32')
+        return resolve(caddyPath)
+      // chmod +x
+      chmodSync(caddyPath, 0o755)
+      resolve(caddyPath)
+    }).on('error', (err) => {
+      // console.log(err)
+      reject(err)
+    })
+  })
+}
+
+function testCaddy() {
+  return new Promise((resolve, reject) => {
+    if (!existsSync(caddyPath))
+      return resolve(false)
+    chmodSync(caddyPath, 0o755)
+    const child = process.platform === 'win32' ? spawn(caddyPath, []) : spawn('sudo', [caddyPath])
+    child.on('close', () => {
+      return resolve(true)
+    })
+    child.on('error', (err) => {
+      return reject(err)
+    })
+    child.stdout.on('data', (_data) => {
+      return resolve(true)
+    })
+  })
+}
+
+interface RunOptions {
+  restore: boolean
+  base: string
+}
+
+export class CaddyInstant {
+  private inited = false
+
+  constructor() {
+    testCaddy().then(() => {
+      this.inited = true
+    })
+  }
+
+  async init() {
+    await download()
+    this.inited = true
+  }
+
+  private async updateHost(ip: string, host: string) {
+    ['localhost', '0.0.0.0'].includes(ip) && (ip = '127.0.0.1')
+    return new Promise<boolean>((resolve, reject) => {
+      hostile.set(ip, host, (err) => {
+        if (err) {
+          return reject(err)
+        }
+        else {
+          if (process.platform === 'win32') {
+            spawn('ipconfig', ['/flushdns']).on('error', (err) => {
+              return reject(err)
+            }).on('close', () => {
+              resolve(true)
+            })
+          }
+          else {
+            spawn('sudo', ['killall', '-HUP', 'mDNSResponder']).on('error', (err) => {
+              return reject(err)
+            }).on('close', () => {
+              resolve(true)
+            })
+          }
+        }
+      })
+    })
+  }
+
+  private async restoreHost(ip: string, host: string) {
+    ['localhost', '0.0.0.0'].includes(ip) && (ip = '127.0.0.1')
+    return new Promise<boolean>((resolve, reject) => {
+      hostile.remove(ip, host, (err) => {
+        if (err) {
+          return reject(err)
+        }
+        else {
+          if (process.platform === 'win32') {
+            spawn('ipconfig', ['/flushdns']).on('error', (err) => {
+              return reject(err)
+            }).on('close', () => {
+              resolve(true)
+            })
+          }
+          else {
+            spawn('sudo', ['killall', '-HUP', 'mDNSResponder']).on('error', (err) => {
+              return reject(err)
+            }).on('close', () => {
+              resolve(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: string, target: string, options?: Partial<RunOptions>) {
+    source = source.replace('0.0.0.0', '127.0.0.1').replace('localhost', '127.0.0.1')
+    const {
+      restore = true,
+      base = '/',
+    } = options || {}
+
+    if (!this.inited)
+      await this.init()
+
+    if (!await this.updateHost(source.split(':')[0], target.split(':')[0]))
+      throw new Error('update host failed')
+
+    if (await tryPort(443))
+      await kill(443, 'tcp')
+    if (process.platform === 'win32' && await tryPort(80))
+      await kill(80, 'tcp')
+
+    return new Promise<() => Promise<void>>((resolve, reject) => {
+      // caddy reverse-proxy --from target --to source --internal-certs
+      const child = process.platform !== 'win32'
+        ? spawn('sudo', [caddyPath, 'reverse-proxy', '--from', `${target.split(':')[0]}`, '--to', `${source}`, '--internal-certs'])
+        : spawn(caddyPath, ['reverse-proxy', '--from', `${target.split(':')[0]}`, '--to', `${source}`, '--internal-certs'])
+
+      child.on('error', (err) => {
+        return reject(err)
+      })
+
+      child.stderr.on('data', (data) => {
+        if ((data.toString() as string).includes('Error')) {
+          child.kill()
+          return reject(data.toString())
+        }
+      })
+
+      child.stdout.on('data', (_data) => {
+        // eslint-disable-next-line no-console
+        console.log(_data.toString())
+        resolve(async () => {
+          if (!restore)
+            return
+
+          if (await this.restoreHost(source.split(':')[0], target.split(':')[0])) {
+            // eslint-disable-next-line no-console
+            console.log('restore host success\n')
+          }
+          else {
+            console.error('restore host failed\n')
+          }
+          child.kill()
+        })
+      })
+    })
+  }
+}

package/src/caddy/utils.ts

@@ -0,0 +1,26 @@
+import { createServer } from 'node:net'
+
+/**
+ * @returns whether the port is in use
+ */
+export function tryPort(port: number) {
+  return new Promise<boolean>((resolve, reject) => {
+    try {
+      const server = createServer().listen(port)
+      server.on('listening', () => {
+        server.close()
+        resolve(false)
+      })
+      server.on('error', (err) => {
+        // @ts-expect-error err.code
+        if (err.code === 'EADDRINUSE')
+          resolve(true)
+        server.close()
+      })
+    }
+    catch (e) {
+      // console.log(e)
+      resolve(true)
+    }
+  })
+}

package/src/esbuild.ts

@@ -0,0 +1,4 @@
+import { createEsbuildPlugin } from 'unplugin'
+import { unpluginFactory } from '.'
+
+export default createEsbuildPlugin(unpluginFactory)

package/src/index.ts

@@ -0,0 +1,105 @@
+import process from 'node:process'
+import type { UnpluginFactory } from 'unplugin'
+import { createUnplugin } from 'unplugin'
+import type { ResolvedConfig } from 'vite'
+import c from 'picocolors'
+import type { Options } from './types'
+import { CaddyInstant } from './caddy'
+
+let config: ResolvedConfig
+
+let caddy: CaddyInstant
+
+export const unpluginFactory: UnpluginFactory<Options> = options => ({
+  name: 'unplugin-https-reverse-proxy',
+  enforce: 'post',
+  vite: {
+    configResolved(_config) {
+      config = _config
+    },
+    configureServer(server) {
+      const {
+        target = '',
+      } = options
+      if (!target) {
+        // eslint-disable-next-line no-console
+        console.log('please provide target')
+        return
+      }
+      server.printUrls = () => {
+        let source = `localhost:${config.server.port}`
+        const url = server.resolvedUrls?.local[0]
+        if (url) {
+          const u = new URL(url)
+          source = u.host
+        }
+        const base = server.config.base || '/'
+        try {
+          const caddy = new CaddyInstant()
+          caddy.run(source, target, {
+            base,
+          }).then((stop) => {
+            const colorUrl = (url: string) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`))
+            // eslint-disable-next-line no-console
+            console.log(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`https://${target}${base}`)}`)
+
+            process.on('SIGINT', async () => {
+              await stop()
+              server.close()
+              process.exit()
+            })
+          })
+        }
+        catch (e) {
+          console.error(e)
+        }
+      }
+    },
+  },
+  webpack(compiler) {
+    const {
+      target = '',
+    } = options
+    if (!target) {
+      // eslint-disable-next-line no-console
+      console.log('please provide target')
+      return
+    }
+    try {
+      // @ts-expect-error vuecli
+      const devServer = compiler.options.devServer || process.VUE_CLI_SERVICE.projectOptions.devServer
+      const source = `${devServer?.host || '127.0.0.1'}:${devServer?.port || '8080'}`
+
+      if (caddy)
+        return
+
+      caddy = new CaddyInstant()
+
+      caddy.run(source, target).then((stop) => {
+        const colorUrl = (url: string) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`))
+
+        compiler.hooks.done.tap('unplugin-https-reverse-proxy', (stats) => {
+          if (stats.hasErrors())
+            return
+
+          // eslint-disable-next-line no-console
+          console.log(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`https://${target}`)}`)
+        })
+
+        process.on('SIGINT', async () => {
+          await stop()
+          process.exit()
+        })
+      }).catch((e) => {
+        throw e
+      })
+    }
+    catch (e) {
+      console.error(e)
+    }
+  },
+})
+
+export const unplugin = /* #__PURE__ */ createUnplugin(unpluginFactory)
+
+export default unplugin

package/src/nuxt.ts

@@ -0,0 +1,22 @@
+import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from '@nuxt/kit'
+import vite from './vite'
+import webpack from './webpack'
+import type { Options } from './types'
+import '@nuxt/schema'
+
+export interface ModuleOptions extends Options {
+
+}
+
+export default defineNuxtModule<ModuleOptions>({
+  meta: {
+    name: 'nuxt-unplugin-https-reverse-proxy',
+    configKey: 'unpluginHttpsReverseProxy',
+  },
+  setup(options, _nuxt) {
+    addVitePlugin(() => vite(options))
+    addWebpackPlugin(() => webpack(options))
+
+    // ...
+  },
+})

package/src/rollup.ts

@@ -0,0 +1,4 @@
+import { createRollupPlugin } from 'unplugin'
+import { unpluginFactory } from '.'
+
+export default createRollupPlugin(unpluginFactory)

package/src/types.ts

@@ -0,0 +1,4 @@
+export interface Options {
+  // define your plugin options here
+  target: string
+}

package/src/vite.ts

@@ -0,0 +1,4 @@
+import { createVitePlugin } from 'unplugin'
+import { unpluginFactory } from '.'
+
+export default createVitePlugin(unpluginFactory)

package/src/webpack.ts

@@ -0,0 +1,4 @@
+import { createWebpackPlugin } from 'unplugin'
+import { unpluginFactory } from '.'
+
+export default createWebpackPlugin(unpluginFactory)