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

package/src/privileged/session.ts

@@ -4,6 +4,7 @@ import { existsSync } from 'node:fs'
 import { readFile, writeFile } from 'node:fs/promises'
 import { platform } from 'node:os'
 import { join } from 'node:path'
+import * as lockfile from 'proper-lockfile'
 import { connectExistingHelper, createHelperToken, startPrivilegedHelper } from './launch'
 
 export interface SessionScope {
@@ -24,6 +25,8 @@ export interface SessionScope {
   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 }
   log?: (message: string) => void
 }
 
@@ -48,26 +51,50 @@ export function sessionSocketPath(runtimeDir: string): string {
  * Connects to the helper already serving this runtime directory, or starts a
  * new one. Reuse matters for multi-instance dev servers: the second instance
  * attaches to the running Caddy instead of asking for a password again.
+ *
+ * The check-then-start sequence runs under a lock. Two projects starting at the
+ * same moment would otherwise both fail to find a socket, both spawn a helper,
+ * and the second would delete the first one's socket while it was still
+ * serving.
  */
 export async function openHelperSession(scope: SessionScope): Promise<OpenedSession> {
   const socketPath = sessionSocketPath(scope.runtimeDir)
+  const release = await acquireStartLock(scope.runtimeDir)
 
-  if (existsSync(socketPath) || platform() === 'win32') {
-    const token = await readToken(scope.runtimeDir)
-    if (token) {
-      const reused = await connectExistingHelper(socketPath, token)
-      if (reused) {
-        return {
-          client: reused,
-          reused: true,
-          close: async () => {
-            await reused.close()
-          },
-        }
-      }
-    }
+  try {
+    const reused = await tryReuse(socketPath, scope)
+    if (reused)
+      return reused
+
+    return await startNew(socketPath, scope)
   }
+  finally {
+    release()
+  }
+}
+
+async function tryReuse(socketPath: string, scope: SessionScope): Promise<OpenedSession | undefined> {
+  if (!existsSync(socketPath) && platform() !== 'win32')
+    return undefined
+
+  const token = await readToken(scope.runtimeDir)
+  if (!token)
+    return undefined
+
+  const reused = await connectExistingHelper(socketPath, token)
+  if (!reused)
+    return undefined
 
+  return {
+    client: reused,
+    reused: true,
+    close: async () => {
+      await reused.close()
+    },
+  }
+}
+
+async function startNew(socketPath: string, scope: SessionScope): Promise<OpenedSession> {
   const token = createHelperToken()
   const started = await startPrivilegedHelper({
     socketPath,
@@ -81,6 +108,7 @@ export async function openHelperSession(scope: SessionScope): Promise<OpenedSess
     caddyStoragePath: scope.caddyStoragePath,
     caddyBin: scope.caddyBin,
     caddyConfigPath: scope.caddyConfigPath,
+    reason: scope.reason,
     log: scope.log,
   })
 
@@ -95,6 +123,30 @@ export async function openHelperSession(scope: SessionScope): Promise<OpenedSess
   }
 }
 
+/**
+ * Serialises "is a helper running? if not, start one" across processes.
+ *
+ * The lock file is separate from the socket: the socket only exists once a
+ * helper is listening, while this lock guards the window before that.
+ */
+async function acquireStartLock(runtimeDir: string): Promise<() => void> {
+  const lockPath = join(runtimeDir, 'helper.start.lock')
+  try {
+    await writeFile(lockPath, '', { flag: 'a' })
+  }
+  catch {}
+
+  const release = await lockfile.lock(lockPath, {
+    realpath: false,
+    stale: 30_000,
+    retries: { retries: 100, minTimeout: 50, maxTimeout: 200 },
+  })
+
+  return () => {
+    void release().catch(() => {})
+  }
+}
+
 async function readToken(runtimeDir: string): Promise<string | undefined> {
   try {
     const content = await readFile(tokenPath(runtimeDir), 'utf8')