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

package/src/index.ts

@@ -7,6 +7,8 @@ import c from 'picocolors'
 import { createUnplugin } from 'unplugin'
 import { CaddyInstant } from './caddy'
 import { hmrSseBridgeClientScript, setupHmrSseBridge } from './hmr-sse-bridge'
+import { isPrivilegeDenied, markPrivilegeDenied } from './privilege-state'
+import { PrivilegeDeniedError } from './privileged/launch'
 import { consola, generateQrcode, getIpv4List, once } from './utils'
 
 let config: ResolvedConfig
@@ -62,10 +64,15 @@ export const vitePrintUrls = once((
 ) => {
   _printUrls?.()
 
+  // Declined earlier in this process; a hot restart must not ask again.
+  if (isPrivilegeDenied())
+    return
+
   if (caddy)
     return
-  caddy = new CaddyInstant()
-  caddy.run(source, target, {
+  const instance = new CaddyInstant()
+  caddy = instance
+  instance.run(source, target, {
     base,
     ...options,
   }).then(async () => {
@@ -73,6 +80,16 @@ export const vitePrintUrls = once((
 
     consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}${base}`)}`)
   }).catch((e) => {
+    // Declining the password is a choice, not a crash: drop the half-started
+    // instance so a later attempt can prompt again.
+    if (caddy === instance)
+      caddy = undefined as unknown as CaddyInstant
+    if (e instanceof PrivilegeDeniedError) {
+      markPrivilegeDenied()
+      consola.warn('reverse proxy skipped: administrator permission was not granted.')
+      consola.info('Restart the dev server to enable it again.')
+      return
+    }
     throw e
   })
 })
@@ -168,6 +185,9 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
     }
     const source = `${devServer.host}:${devServer.port}`
 
+    if (isPrivilegeDenied())
+      return
+
     if (caddy)
       return
 
@@ -195,9 +215,10 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
       options.https = false
     }
 
-    caddy = new CaddyInstant()
+    const instance = new CaddyInstant()
+    caddy = instance
 
-    caddy.run(source, target, {
+    instance.run(source, target, {
       base,
       ...options,
     }).then(() => {
@@ -207,6 +228,14 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
         consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}${base}`)}`)
       })
     }).catch((e) => {
+      if (caddy === instance)
+        caddy = undefined as unknown as CaddyInstant
+      if (e instanceof PrivilegeDeniedError) {
+        markPrivilegeDenied()
+        consola.warn('reverse proxy skipped: administrator permission was not granted.')
+        consola.info('Restart the dev server to enable it again.')
+        return
+      }
       throw e
     })
   },
@@ -243,10 +272,11 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
 
     const source = `${devServer.host}:${devServer.port}`
 
-    if (caddy)
+    if (isPrivilegeDenied())
       return
 
-    caddy = new CaddyInstant()
+    if (caddy)
+      return
 
     let base = '/'
     const publicPath = compiler.options.output?.publicPath as unknown
@@ -258,7 +288,10 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
     if (base !== '/' && !base.endsWith('/'))
       base = `${base}/`
 
-    caddy.run(source, target, {
+    const instance = new CaddyInstant()
+    caddy = instance
+
+    instance.run(source, target, {
       base,
       ...options,
     }).then(async () => {
@@ -266,6 +299,14 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
 
       consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`${options.https ? 'https' : 'http'}://${target}${base}`)}`)
     }).catch((e) => {
+      if (caddy === instance)
+        caddy = undefined as unknown as CaddyInstant
+      if (e instanceof PrivilegeDeniedError) {
+        markPrivilegeDenied()
+        consola.warn('reverse proxy skipped: administrator permission was not granted.')
+        consola.info('Restart the dev server to enable it again.')
+        return
+      }
       throw e
     })
   },

package/src/privilege-state.ts

@@ -0,0 +1,23 @@
+/**
+ * Whether the user dismissed the password prompt in this process.
+ *
+ * Kept in its own module so the flag outlives a hot restart. Vite rebuilds the
+ * dev server in place (`Object.assign(server, newServer)`) rather than starting
+ * a new process, so module scope is the only place that distinguishes "saved
+ * the config again" from "started the dev server again".
+ */
+let denied = false
+
+/** Records that the user declined; every entry point checks this first. */
+export function markPrivilegeDenied(): void {
+  denied = true
+}
+
+export function isPrivilegeDenied(): boolean {
+  return denied
+}
+
+/** Test hook: restores the initial state between cases. */
+export function resetPrivilegeDenied(): void {
+  denied = false
+}

package/src/privileged/entry.ts

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import process from 'node:process'
 
 export interface HelperEntry {
@@ -26,20 +26,48 @@ export interface ResolveHelperEntryOptions {
  * Published builds ship a compiled `privileged-helper.js` and start it with
  * node; running from the repository uses `tsx` so the TypeScript source works
  * without a build step.
+ *
+ * The running module sits in a subdirectory (`src/caddy`, `src/privileged`),
+ * while the helper lives one level up in `src`, so both lookups walk up instead
+ * of assuming a fixed depth.
  */
 export function resolveHelperEntry(options: ResolveHelperEntryOptions): HelperEntry {
   const { moduleDir, nodeBin = process.execPath, exists = existsSync } = options
 
   for (const name of ['privileged-helper.js', 'privileged-helper.cjs', 'privileged-helper.mjs']) {
-    const candidate = join(moduleDir, name)
-    if (exists(candidate))
+    const candidate = findUp(moduleDir, name, exists)
+    if (candidate)
       return { entry: nodeBin, args: [candidate] }
   }
 
-  const source = join(moduleDir, 'privileged-helper.ts')
-  const tsxCli = join(moduleDir, '../node_modules/tsx/dist/cli.mjs')
-  if (exists(source) && exists(tsxCli))
+  const source = findUp(moduleDir, 'privileged-helper.ts', exists)
+  const tsxCli = findUp(moduleDir, 'node_modules/tsx/dist/cli.mjs', exists)
+  if (source && tsxCli)
     return { entry: nodeBin, args: [tsxCli, source] }
 
   throw new Error(`privileged helper entry not found in ${moduleDir}. Build the package first.`)
 }
+
+/**
+ * Walks up from `from` looking for a relative path.
+ *
+ * Stops at the filesystem root so a helper outside the project is never picked
+ * up by accident.
+ */
+function findUp(
+  from: string,
+  relative: string,
+  exists: (path: string) => boolean,
+): string | undefined {
+  let current = from
+  while (true) {
+    const candidate = join(current, relative)
+    if (exists(candidate))
+      return candidate
+
+    const parent = dirname(current)
+    if (parent === current)
+      return undefined
+    current = parent
+  }
+}

package/src/privileged/launch.ts

@@ -39,6 +39,25 @@ export interface LaunchOptions {
   caddyBin: string
   /** Caddyfile the helper is allowed to load. */
   caddyConfigPath: string
+  /** Shown before the password prompt so the request is not a surprise. */
+  reason?: { target: string, https: boolean }
+}
+
+/**
+ * Explains why a password is about to be requested. Without this the prompt
+ * appears out of nowhere in the middle of `npm run dev` and looks like something
+ * went wrong.
+ */
+export function describePasswordReason(target: string, https: boolean): string[] {
+  const port = https ? '443' : '80'
+  return [
+    `reverse proxy needs administrator permission for ${target}`,
+    `  · bind port ${port}${https ? ` for https://${target}` : ''}`,
+    `  · add ${target} to the hosts file`,
+    '',
+    'This is the only prompt; the rest of the dev server keeps running as you.',
+    'Press Ctrl+C at the prompt to skip the proxy and keep the dev server.',
+  ]
 }
 
 /**
@@ -47,23 +66,44 @@ export interface LaunchOptions {
  * The credential cache is keyed by terminal, so a later `sudo -n` only finds
  * this entry when the child stays in the same session. That is why the helper
  * is spawned without `detached`.
+ *
+ * Returns `denied` when the user dismissed the prompt, so the caller can keep
+ * the dev server running instead of treating it as a crash.
  */
-export function authenticateSudo(sudoCommand = 'sudo'): { ok: boolean, message?: string } {
+export function authenticateSudo(
+  sudoCommand = 'sudo',
+  options: { target?: string, https?: boolean } = {},
+): { ok: boolean, denied?: boolean, message?: string } {
   if (platform() === 'win32')
     return { ok: true }
 
   if (spawnSync(sudoCommand, ['-n', 'true'], { stdio: 'ignore' }).status === 0)
     return { ok: true }
 
+  if (options.target) {
+    for (const line of describePasswordReason(options.target, options.https ?? false))
+      process.stderr.write(`${line}\n`)
+    process.stderr.write('\n')
+  }
+
   if (spawnSync(sudoCommand, ['-v'], { stdio: 'inherit' }).status === 0)
     return { ok: true }
 
   return {
     ok: false,
+    denied: true,
     message: 'administrator permission is required to edit the hosts file and bind ports 80/443',
   }
 }
 
+/** The user dismissed the password prompt; this is a choice, not a failure. */
+export class PrivilegeDeniedError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'PrivilegeDeniedError'
+  }
+}
+
 export interface PrivilegedHelperHandle {
   client: PrivilegedClient
   close: () => Promise<void>
@@ -92,9 +132,11 @@ export async function startPrivilegedHelper(options: LaunchOptions): Promise<Pri
   } = options
 
   if (!skipAuth && !direct) {
-    const auth = authenticateSudo(sudoCommand)
-    if (!auth.ok)
-      throw new Error(auth.message)
+    const auth = authenticateSudo(sudoCommand, options.reason)
+    if (!auth.ok) {
+      const message = auth.message ?? 'administrator permission is required'
+      throw auth.denied ? new PrivilegeDeniedError(message) : new Error(message)
+    }
   }
 
   const forwarded = collectForwardedEnv(env)

package/src/privileged/session.ts

@@ -24,6 +24,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
 }
 
@@ -81,6 +83,7 @@ export async function openHelperSession(scope: SessionScope): Promise<OpenedSess
     caddyStoragePath: scope.caddyStoragePath,
     caddyBin: scope.caddyBin,
     caddyConfigPath: scope.caddyConfigPath,
+    reason: scope.reason,
     log: scope.log,
   })