unplugin-https-reverse-proxy 4.0.3 → 4.1.0-beta.10

package/dist/webpack.js

@@ -1,8 +1,10 @@
 import {
   unpluginFactory
-} from "./chunk-MD5CVZP7.js";
-import "./chunk-RSBXFJ3Z.js";
-import "./chunk-2P7SUCQ3.js";
+} from "./chunk-U7KAIPZC.js";
+import "./chunk-EY3HXBJ4.js";
+import "./chunk-C5A7XLKL.js";
+import "./chunk-WOMR3ZLM.js";
+import "./chunk-RKHJN6KY.js";
 
 // src/webpack.ts
 import { createWebpackPlugin } from "unplugin";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unplugin-https-reverse-proxy",
   "type": "module",
-  "version": "4.0.3",
+  "version": "4.1.0-beta.10",
   "description": "",
   "license": "MIT",
   "homepage": "https://github.com/zcf0508/unplugin-https-reverse-proxy#readme",
@@ -119,7 +119,6 @@
     "console-table-printer": "^2.12.1",
     "dotenv-flow": "^4.1.0",
     "got-cjs": "^12.5.4",
-    "hostile": "^1.4.0",
     "http-proxy-agent": "^7.0.2",
     "https-proxy-agent": "^7.0.6",
     "ora": "5",
@@ -133,8 +132,6 @@
     "@nuxt/schema": "^3.16.1",
     "@rsbuild/core": "^0.4.15",
     "@rspack/core": "^0.5.9",
-    "@types/hostile": "^1.3.5",
-    "@types/kill-port": "^2.0.3",
     "@types/node": "^20.11.19",
     "@types/proper-lockfile": "^4.1.4",
     "@types/qrcode-terminal": "^0.12.2",

package/src/caddy/caddyfile.ts

@@ -12,6 +12,7 @@ export const ProxyType = type({
 
 const CaddyContext = type({
   caddy_root: 'string',
+  admin_socket: 'string',
   proxies: ProxyType.array(),
 })
 
@@ -26,6 +27,8 @@ export function validateTemplateContext(ctx: unknown): typeof CaddyContext.infer
 export const caddyTemplate = `{
   debug
   auto_https disable_redirects ignore_loaded_certs
+  skip_install_trust
+  admin unix/{{ admin_socket }}
 }
 
 :7601 {

package/src/caddy/config.ts

@@ -1,72 +1,214 @@
 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
-    }
-  })
+/** 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
+  }
+}
 
-  function setConfigContent(): void {
-    if (!existsSync(caddyConfigPath)) {
-      writeFileSync(caddyConfigPath, '{}')
-    }
+/**
+ * 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(path: string = caddyConfigPath): ProxyMap {
+  if (!existsSync(path))
+    return {}
+
+  let parsed: ProxyMap
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf-8')) as ProxyMap
+  }
+  catch {
+    // A half-written file is not worth preserving: it has no usable routes.
+    return {}
+  }
+
+  const alive: ProxyMap = {}
+  for (const [key, entry] of Object.entries(parsed)) {
+    if (isAlive(entry?.ownerPid))
+      alive[key] = entry
+  }
+  return alive
+}
+
+/**
+ * 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, path: string = caddyConfigPath): void {
+  const content = JSON.stringify(proxies, null, 2)
+  const temp = `${path}.${process.pid}.tmp`
+  writeFileSync(temp, content)
+  renameSync(temp, path)
+}
+
+export interface CaddyConfigOptions {
+  /** Injected in tests so they do not need the real lock. */
+  lock?: ConfigLock
+  /**
+   * Config file to operate on; defaults to the shared runtime path.
+   *
+   * Injectable so a test can own a file without racing every other test that
+   * happens to run against the same module-level constant.
+   */
+  configPath?: string
+  /**
+   * Renders the Caddyfile from the routes, called inside the config lock.
+   *
+   * Rendering here rather than in the caller is what keeps the file in step
+   * with the JSON: two projects writing concurrently would otherwise render
+   * from their own stale view and the later write would win.
+   */
+  renderCaddyfile?: (proxies: ProxyMap) => Promise<void>
+}
+
+export function useCaddyConfig(options: CaddyConfigOptions = {}): CaddyConfigApi {
+  const lock = options.lock ?? createFileLock()
+  const configPath = options.configPath ?? caddyConfigPath
+
+  /**
+   * Applies the change, then re-renders while still holding the lock.
+   *
+   * The Caddyfile has to follow every change: leaving a stopped project's site
+   * in it would keep proxying to an upstream that is gone. Doing it inside the
+   * lock also picks up routes whose owner process died, since `readConfig`
+   * drops those.
+   */
+  async function mutate(
+    apply: (proxies: ProxyMap) => void,
+  ): Promise<ProxyMap> {
+    const release = await lock.acquire()
     try {
-      configContentRef(readFileSync(caddyConfigPath, 'utf-8'))
+      const proxies = readConfig(configPath)
+      apply(proxies)
+      writeConfig(proxies, configPath)
+      await options.renderCaddyfile?.(proxies)
+      return proxies
     }
-    catch {
-      configContentRef('')
+    finally {
+      release()
     }
   }
 
-  if (!existsSync(caddyConfigPath)) {
-    writeFileSync(caddyConfigPath, '{}')
-  }
+  return {
+    configJsonRef: () => (existsSync(configPath) ? readConfig(configPath) : undefined),
+
+    async writeCaddyConfig(_proxies, key) {
+      await mutate((proxies) => {
+        for (const p of _proxies)
+          proxies[routeKey(p, key)] = { ...p, base: normalizeBase(p.base), ownerPid: process.pid }
+      })
+    },
 
-  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)
+    async removeProxy(key) {
+      // The empty config is written inside the lock rather than unlinked after
+      // it: between the release and the unlink another project can add its
+      // route, and the unlink would then drop a route that is in use.
+      await mutate((current) => {
+        for (const route of Object.keys(current)) {
+          if (route.endsWith(`#${key}`))
+            delete current[route]
+        }
+      })
+    },
+
+    readProxies: () => readConfig(configPath),
+
+    async cleanUp() {
+      removeConfigFile(configPath)
+    },
   }
+}
 
-  async function cleanUp(): Promise<void> {
-    await unlink(caddyConfigPath).catch(() => { })
-    configContentRef('{}')
-    watchCaddyConfig.close()
+function removeConfigFile(path: string = caddyConfigPath): void {
+  try {
+    if (existsSync(path))
+      unlinkSync(path)
   }
+  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 {
-    configJsonRef,
-    writeCaddyConfig,
-    cleanUp,
+    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/constants.ts

@@ -13,13 +13,42 @@ function resolvePath(path: string): string {
   return path
 }
 
-export const TEMP_DIR = resolvePath(process.env.UHRP_CADDY_PATH || process.env.TEMP || process.env.TMPDIR || '/tmp')
+/**
+ * Directory for the Caddy binary, Caddyfile and the admin socket.
+ *
+ * The Caddy binary is executed as root, so this must not be a directory other
+ * users can write to. macOS gives every user a private `TMPDIR`, and `TEMP` on
+ * Windows is per-user too. On Linux `TMPDIR` is usually unset and `/tmp` is
+ * world-writable (sticky bit only prevents deleting other users' files, not
+ * creating `/tmp/caddy` first), so the fallback goes under the user's own cache
+ * directory instead.
+ */
+function defaultTempDir(): string {
+  const fromEnv = process.env.TEMP || process.env.TMPDIR
+  if (fromEnv)
+    return resolvePath(fromEnv)
+  if (process.platform === 'linux')
+    return join(process.env.XDG_CACHE_HOME || join(os.homedir(), '.cache'), 'uhrp')
+  return '/tmp'
+}
+
+export const TEMP_DIR = resolvePath(process.env.UHRP_CADDY_PATH || defaultTempDir())
 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')
 
+/**
+ * Admin API socket, shared by every project using this helper.
+ *
+ * Caddy runs as root, so its admin API must not listen on a TCP port any local
+ * user can reach: `POST /load` there reconfigures the proxy with no further
+ * check. A unix socket inside the runtime directory is reachable only by whoever
+ * can open that directory, and the directory is private on macOS.
+ */
+export const caddyAdminSocketPath = join(TEMP_DIR, 'caddy-admin.sock')
+
 export const supportList = [
   {
     platform: 'dragonfly',