unplugin-https-reverse-proxy 4.1.0-beta.2 → 4.1.0-beta.4

package/dist/webpack.js

@@ -1,8 +1,9 @@
 import {
   unpluginFactory
-} from "./chunk-7CA3EIIX.js";
+} from "./chunk-H7LIW3S4.js";
 import "./chunk-EY3HXBJ4.js";
 import "./chunk-C5A7XLKL.js";
+import "./chunk-WOMR3ZLM.js";
 import "./chunk-RKHJN6KY.js";
 
 // src/webpack.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "4.1.0-beta.2",
+  "version": "4.1.0-beta.4",
   "description": "",
   "license": "MIT",
   "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",

package/src/caddy/config.ts

@@ -1,72 +1,191 @@
 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 { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+import process from 'node:process'
+import * as lockfile from 'proper-lockfile'
 import { caddyConfigPath } from './constants'
 
-export function useCaddyConfig(): {
-  configJsonRef: () => (Record<string, typeof ProxyType.infer> | undefined)
-  writeCaddyConfig: (proxies: Array<typeof ProxyType.infer>) => void
+/** One project's route, plus the pid that owns it. */
+type ProxyEntry = typeof ProxyType.infer & { ownerPid?: number }
+
+type ProxyMap = Record<string, ProxyEntry>
+
+/**
+ * A file lock held around every read-modify-write of the shared config.
+ *
+ * Several dev servers run as independent processes, so a read-then-write from
+ * two of them can interleave and drop an entry. Synchronous calls are only
+ * atomic within one event loop, which is why the lock has to be a real file
+ * lock rather than an in-process queue.
+ */
+interface ConfigLock {
+  acquire: () => Promise<() => void>
+}
+
+export interface CaddyConfigApi {
+  configJsonRef: () => ProxyMap | undefined
+  /** Adds or replaces this project's routes, keeping everyone else's. */
+  writeCaddyConfig: (proxies: Array<typeof ProxyType.infer>, key: string) => Promise<void>
+  /** Drops one project's routes; the file goes away when nothing is left. */
+  removeProxy: (key: string) => Promise<void>
+  /** Reads the routes currently on disk, for regenerating the Caddyfile. */
+  readProxies: () => ProxyMap
   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('')
-    }
+}
+
+/** Owner pids that have exited can never clean up after themselves. */
+function isAlive(pid: number | undefined): boolean {
+  if (pid === undefined)
+    return true
+  try {
+    process.kill(pid, 0)
+    return true
+  }
+  catch {
+    return false
   }
+}
+
+/**
+ * Reads the shared config, dropping entries whose owner process is gone.
+ *
+ * A SIGKILLed dev server cannot remove its own route, so without this sweep its
+ * domain would keep resolving to a proxy with no upstream behind it.
+ */
+function readConfig(): ProxyMap {
+  if (!existsSync(caddyConfigPath))
+    return {}
 
-  if (!existsSync(caddyConfigPath)) {
-    writeFileSync(caddyConfigPath, '{}')
+  let parsed: ProxyMap
+  try {
+    parsed = JSON.parse(readFileSync(caddyConfigPath, 'utf-8')) as ProxyMap
+  }
+  catch {
+    // A half-written file is not worth preserving: it has no usable routes.
+    return {}
   }
 
-  const watchCaddyConfig = watch(caddyConfigPath, () => {
-    setConfigContent()
-  })
-
-  function writeCaddyConfig(_proxies: Array<typeof ProxyType.infer>): void {
-    const proxies = configJsonRef() || {}
-
-    _proxies.forEach((p) => {
-      let base = p.base || '/'
-      if (!base.startsWith('/'))
-        base = `/${base}`
-      if (base !== '/' && !base.endsWith('/'))
-        base = `${base}/`
-      const index = `${p.target}${p.portSuffix}${base}`
-      proxies[index] = { ...p, base }
-    })
-
-    const content = JSON.stringify(proxies, null, 2)
-    configContentRef(content)
-    return writeFileSync(caddyConfigPath, content)
+  const alive: ProxyMap = {}
+  for (const [key, entry] of Object.entries(parsed)) {
+    if (isAlive(entry?.ownerPid))
+      alive[key] = entry
   }
+  return alive
+}
 
-  async function cleanUp(): Promise<void> {
-    await unlink(caddyConfigPath).catch(() => { })
-    configContentRef('{}')
-    watchCaddyConfig.close()
+/**
+ * Writes through a temporary file so a concurrent reader never sees a partial
+ * document. `rename` is atomic within a filesystem, which keeps the shared
+ * config readable at all times.
+ */
+function writeConfig(proxies: ProxyMap): void {
+  const content = JSON.stringify(proxies, null, 2)
+  const temp = `${caddyConfigPath}.${process.pid}.tmp`
+  writeFileSync(temp, content)
+  renameSync(temp, caddyConfigPath)
+}
+
+/** Applies `mutate` under the file lock, re-reading the latest state first. */
+async function mutateConfig(
+  lock: ConfigLock,
+  mutate: (proxies: ProxyMap) => void,
+): Promise<ProxyMap> {
+  const release = await lock.acquire()
+  try {
+    const proxies = readConfig()
+    mutate(proxies)
+    writeConfig(proxies)
+    return proxies
+  }
+  finally {
+    release()
   }
+}
+
+export interface CaddyConfigOptions {
+  /** Injected in tests so they do not need the real lock. */
+  lock?: ConfigLock
+}
+
+export function useCaddyConfig(options: CaddyConfigOptions = {}): CaddyConfigApi {
+  const lock = options.lock ?? createFileLock()
 
   return {
-    configJsonRef,
-    writeCaddyConfig,
-    cleanUp,
+    configJsonRef: () => (existsSync(caddyConfigPath) ? readConfig() : undefined),
+
+    async writeCaddyConfig(_proxies, key) {
+      await mutateConfig(lock, (proxies) => {
+        for (const p of _proxies)
+          proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: process.pid }
+      })
+    },
+
+    async removeProxy(key) {
+      const proxies = await mutateConfig(lock, (current) => {
+        for (const route of Object.keys(current)) {
+          if (route.endsWith(`#${key}`))
+            delete current[route]
+        }
+      })
+
+      if (Object.keys(proxies).length === 0)
+        removeConfigFile()
+    },
+
+    readProxies: () => readConfig(),
+
+    async cleanUp() {
+      removeConfigFile()
+    },
+  }
+}
+
+function removeConfigFile(): void {
+  try {
+    if (existsSync(caddyConfigPath))
+      unlinkSync(caddyConfigPath)
+  }
+  catch {}
+}
+
+function normalizeBase(base: string | undefined): string {
+  let out = base || '/'
+  if (!out.startsWith('/'))
+    out = `/${out}`
+  if (out !== '/' && !out.endsWith('/'))
+    out = `${out}/`
+  return out
+}
+
+/**
+ * Route key: the domain it answers on, plus the owning project.
+ *
+ * Two projects can legitimately serve the same domain on different bases, so
+ * the key has to carry the base as well as the owner.
+ */
+export function routeKey(proxy: typeof ProxyType.infer, ownerKey: string): string {
+  return `${proxy.target}${proxy.portSuffix}${normalizeBase(proxy.base)}#${ownerKey}`
+}
+
+/**
+ * Builds the on-disk lock.
+ *
+ * `proper-lockfile` retries because the winner may hold the lock for a moment;
+ * `realpath: false` keeps it working when the temp directory is a symlink.
+ */
+function createFileLock(): ConfigLock {
+  return {
+    async acquire() {
+      if (!existsSync(caddyConfigPath))
+        writeFileSync(caddyConfigPath, '{}')
+
+      const release = await lockfile.lock(caddyConfigPath, {
+        realpath: false,
+        stale: 10_000,
+        retries: { retries: 20, minTimeout: 10, maxTimeout: 100 },
+      })
+      return () => {
+        void release().catch(() => {})
+      }
+    },
   }
 }

package/src/caddy/index.ts

@@ -1,20 +1,18 @@
 import type { Buffer } from 'node:buffer'
 import type { OpenedPrivilegedSession } from './privileged'
 import { execFile } from 'node:child_process'
-import { chmodSync, createWriteStream, existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs'
+import { chmodSync, createWriteStream, existsSync, mkdirSync, unlinkSync } from 'node:fs'
 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 { consola, once } from '../utils'
 import { genCaddyfile, validateTemplateContext } from './caddyfile'
 import { useCaddyConfig } from './config'
-import { caddyFilePath, caddyLockFilePath, caddyPath, supportList, TEMP_DIR } from './constants'
+import { caddyFilePath, caddyPath, supportList, TEMP_DIR } from './constants'
 import { isCaddyReloadCancellation } from './log'
 import { HelperCaddyProcess, openPrivilegedSession } from './privileged'
 import { formatTlsHealthFailure, waitForLocalTls } from './tls-health'
@@ -132,17 +130,21 @@ function splitHostPort(addr: string): { host: string, port: string } {
 
 /** Injection point for tests: opens the privileged helper without sudo. */
 export interface CaddyDependencies {
-  openSession: (runtimeDir: string) => Promise<OpenedPrivilegedSession>
+  openSession: (runtimeDir: string, reason?: { target: string, https: boolean }) => Promise<OpenedPrivilegedSession>
+  /** Shared route config; tests inject an in-memory one. */
+  config: () => ReturnType<typeof useCaddyConfig>
 }
 
 const defaultDependencies: CaddyDependencies = {
-  openSession: runtimeDir => openPrivilegedSession(runtimeDir, {
+  openSession: (runtimeDir, reason) => openPrivilegedSession(runtimeDir, {
     log: message => consola.debug(message),
     // Both paths are fixed here, before any socket traffic: the privileged
     // helper must never execute something named in a request.
     caddyBin: caddyPath,
     caddyConfigPath: caddyFilePath,
+    reason,
   }),
+  config: () => getCaddyConfig(),
 }
 
 export class CaddyInstant {
@@ -150,8 +152,6 @@ export class CaddyInstant {
   private stoped = false
   private readonly deps: CaddyDependencies
 
-  /** has locked when start */
-  private locked = false
   private caddyfile: string | undefined
 
   private _caddyChild: HelperCaddyProcess | undefined
@@ -160,21 +160,11 @@ export class CaddyInstant {
   private _source: string | undefined
   private _target: string | undefined
   private _stopEffects: Array<(() => void)> = []
+  /** Identifies this instance's routes in the shared config. */
+  private readonly proxyKey = `${process.pid}-${Math.random().toString(36).slice(2, 8)}`
 
   constructor(deps: Partial<CaddyDependencies> = {}) {
     this.deps = { ...defaultDependencies, ...deps }
-    this.locked = this.checkLock()
-  }
-
-  checkLock(): boolean {
-    if (!existsSync(caddyLockFilePath))
-      writeFileSync(caddyLockFilePath, '')
-    try {
-      return lockfile.checkSync(caddyLockFilePath)
-    }
-    catch {
-      return false
-    }
   }
 
   /**
@@ -182,14 +172,14 @@ export class CaddyInstant {
    * reused across instances so a second dev server does not ask for a
    * password again.
    */
-  private async session(): Promise<OpenedPrivilegedSession> {
+  private async session(reason?: { target: string, https: boolean }): Promise<OpenedPrivilegedSession> {
     // A crashed helper leaves the cached client permanently disconnected; drop
     // it so the next call starts a fresh helper instead of failing forever.
     if (this._session && !this._session.client.connected)
       this._session = undefined
 
     if (!this._session)
-      this._session = await this.deps.openSession(TEMP_DIR)
+      this._session = await this.deps.openSession(TEMP_DIR, reason)
     return this._session
   }
 
@@ -259,9 +249,15 @@ export class CaddyInstant {
       throw new Error(formatTlsHealthFailure(targetHost, health))
   }
 
+  /**
+   * Regenerates the Caddyfile from the config on disk.
+   *
+   * Reading the file rather than a cached view matters here: another project
+   * may have added its route since this instance last looked.
+   */
   private async updateCaddyfile(): Promise<void> {
-    const { configJsonRef } = getCaddyConfig()
-    const proxies = Object.values(configJsonRef() || {})
+    const { readProxies } = this.deps.config()
+    const proxies = Object.values(readProxies())
     const ctx = validateTemplateContext({
       caddy_root: this.caddyRoot,
       proxies,
@@ -313,10 +309,10 @@ export class CaddyInstant {
     if (!this.inited)
       await this.init()
 
-    const session = await this.session()
-
     const sourceHost = splitHostPort(source).host
     const targetHost = splitHostPort(target).host
+
+    const session = await this.session({ target: targetHost, https })
     await session.client.call('hosts.add', { ip: sourceHost, host: targetHost })
     consola.success('update host success\n')
 
@@ -341,32 +337,17 @@ export class CaddyInstant {
       },
     ]
 
-    const { writeCaddyConfig } = getCaddyConfig()
-    writeCaddyConfig(proxies)
+    const { writeCaddyConfig } = this.deps.config()
+    await writeCaddyConfig(proxies, this.proxyKey)
 
     await this.updateCaddyfile()
 
-    let skipInitialCaddyfileEffect = true
-    this._stopEffects.push(
-      effect(() => {
-        getCaddyConfig().configJsonRef()
-        if (skipInitialCaddyfileEffect) {
-          skipInitialCaddyfileEffect = false
-          return
-        }
-        void this.updateCaddyfile()
-      }),
-    )
-
-    if (!existsSync(caddyLockFilePath))
-      writeFileSync(caddyLockFilePath, '')
-
-    if (!this.locked) {
-      // Ports 80/443 may still be held by a previous, uncleanly stopped run.
-      await session.client.call('port.free', { port: 443 })
-      if (process.platform === 'win32' || !https)
-        await session.client.call('port.free', { port: 80 })
-    }
+    // Ports 80/443 may still be held by a previous, uncleanly stopped run.
+    // The helper skips its own Caddy, so this never kills a proxy another
+    // project is already using.
+    await session.client.call('port.free', { port: 443 })
+    if (process.platform === 'win32' || !https)
+      await session.client.call('port.free', { port: 80 })
 
     return new Promise<void>((resolve, reject) => {
       let startupCheckStarted = false
@@ -387,8 +368,7 @@ export class CaddyInstant {
           resolve()
         }
         catch (error) {
-          if (!this.locked)
-            await this.baseCleanup(restore)
+          await this.baseCleanup(restore)
           reject(error)
         }
       }
@@ -433,84 +413,65 @@ export class CaddyInstant {
         }
       }
 
-      if (!this.locked) {
-        lockfile.lockSync(caddyLockFilePath)
-        setupCleanup()
-
-        void (async () => {
-          try {
-            const child = new HelperCaddyProcess(session.client)
-            this._caddyChild = child
-
-            await session.client.call('caddy.start')
-
-            child.on('exit', (code: number | null) => {
-              if (code !== null && code !== 0)
-                reject(new Error(`Caddy exited with code ${code}`))
-            })
+      setupCleanup()
 
-            child.stderr.on('data', async (data: Buffer) => {
-              const lines = data.toString().split('\n').map((line: string) => line.trim())
-              for (const line of lines) {
-                // caddy log
-                // eslint-disable-next-line no-console
-                showCaddyLog && line && console.info(line)
-                if (isCaddyReloadCancellation(line)) {
-                  consola.info('Caddy restarted before TLS issuance completed; retrying.\n')
-                  continue
-                }
-                try {
-                  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`)
-                      return reject(line)
-                    }
+      void (async () => {
+        try {
+          const child = new HelperCaddyProcess(session.client)
+          this._caddyChild = child
+
+          await session.client.call('caddy.start')
+
+          child.on('exit', (code: number | null) => {
+            if (code !== null && code !== 0)
+              reject(new Error(`Caddy exited with code ${code}`))
+          })
+
+          child.stderr.on('data', async (data: Buffer) => {
+            const lines = data.toString().split('\n').map((line: string) => line.trim())
+            for (const line of lines) {
+              // caddy log
+              // eslint-disable-next-line no-console
+              showCaddyLog && line && console.info(line)
+              if (isCaddyReloadCancellation(line)) {
+                consola.info('Caddy restarted before TLS issuance completed; retrying.\n')
+                continue
+              }
+              try {
+                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`)
+                    return reject(line)
                   }
                 }
-                catch {}
-
-                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'))
-                  void resolveWhenReady()
               }
-            })
+              catch {}
 
-            child.stdout.on('data', (data: Buffer) => {
-              consola.info(data.toString())
-              void resolveWhenReady()
-            })
-          }
-          catch (error) {
-            // The hosts entry was written before Caddy started; a failed start
-            // must not leave it behind while the dev server keeps running.
-            if (!this.locked)
-              await this.baseCleanup(restore)
-            reject(error)
-          }
-        })()
-      }
-      else {
-        consola.info('Caddy is running in another process.')
+              if (line.includes('config file changed'))
+                consola.success('Detect added a new reverse proxy config, restarted.\n')
 
-        void (async () => {
-          try {
-            if (https)
-              await this.ensureTlsReady(targetHost)
-            setupCleanup()
-            resolve()
-          }
-          catch (error) {
-            reject(error)
-          }
-        })()
-      }
+              if (line.includes('caddy proxying') || line.includes('serving initial'))
+                void resolveWhenReady()
+            }
+          })
+
+          child.stdout.on('data', (data: Buffer) => {
+            consola.info(data.toString())
+            void resolveWhenReady()
+          })
+        }
+        catch (error) {
+          // The hosts entry was written before Caddy started; a failed start
+          // must not leave it behind while the dev server keeps running.
+          await this.baseCleanup(restore)
+          reject(error)
+        }
+      })()
     })
   }
 
@@ -540,15 +501,12 @@ export class CaddyInstant {
       }
     }
 
-    if (!this.locked && !this.stoped) {
-      await this.stopCaddy()
+    // Caddy and the shared Caddyfile belong to every project using this
+    // helper. Only this project's route is removed here; the helper stops
+    // Caddy when its last client disconnects.
+    if (!this.stoped) {
       try {
-        await lockfile.unlock(caddyLockFilePath).catch(() => {})
-        await unlink(caddyFilePath).catch(() => {})
-        await unlink(caddyLockFilePath).catch(() => {})
-        if (caddyConfig) {
-          await caddyConfig.cleanUp()
-        }
+        await this.deps.config().removeProxy(this.proxyKey)
       }
       catch (e) {
         consola.error(e)

package/src/caddy/privileged.ts

@@ -82,6 +82,8 @@ export interface PrivilegedSessionOptions {
   caddyBin: string
   /** Caddyfile the helper may load. */
   caddyConfigPath: string
+  /** Shown before the password prompt so the request is not a surprise. */
+  reason?: { target: string, https: boolean }
 }
 
 /** Where Caddy keeps its PKI, per platform. */
@@ -113,6 +115,7 @@ export function openPrivilegedSession(
     // execute a path supplied over the socket.
     caddyBin: options.caddyBin,
     caddyConfigPath: options.caddyConfigPath,
+    reason: options.reason,
     log: options.log,
   })
 }