@stacksjs/rpx 0.11.9 → 0.11.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/rpx",
   "type": "module",
-  "version": "0.11.9",
+  "version": "0.11.11",
   "description": "A modern and smart reverse proxy.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",

package/src/daemon.ts

@@ -28,6 +28,11 @@ import { checkExistingCertificates, generateCertificate } from './https'
 import { createProxyFetchHandler } from './proxy-handler'
 import { gcStaleEntries, getRegistryDir, isPidAlive, readAll, watchRegistry } from './registry'
 import type { RegistryEntry } from './registry'
+import {
+  reconcileStaleDevelopmentDns,
+  syncDevelopmentDnsFromRegistry,
+  tearDownDevelopmentDns,
+} from './dns'
 import { debugLog } from './utils'
 
 export interface DaemonOptions {
@@ -236,7 +241,15 @@ export async function runDaemon(opts: DaemonOptions = {}): Promise<DaemonHandle>
   await gcStaleEntries(registryDir, verbose).catch((err) => {
     debugLog('daemon', `initial gc failed: ${err}`, verbose)
   })
-  rebuild(await readAll(registryDir, verbose))
+  const initialEntries = await readAll(registryDir, verbose)
+  rebuild(initialEntries)
+
+  await reconcileStaleDevelopmentDns({ rpxDir, verbose }).catch((err) => {
+    debugLog('daemon', `DNS reconcile on start failed: ${err}`, verbose)
+  })
+  await syncDevelopmentDnsFromRegistry(initialEntries, { rpxDir, verbose, ownerPid: process.pid }).catch((err) => {
+    debugLog('daemon', `DNS setup on start failed: ${err}`, verbose)
+  })
 
   const sslConfig = await bootstrapTls(opts, registryDir)
 
@@ -280,7 +293,12 @@ export async function runDaemon(opts: DaemonOptions = {}): Promise<DaemonHandle>
   }
 
   const watcher = watchRegistry(
-    (entries) => { rebuild(entries) },
+    (entries) => {
+      rebuild(entries)
+      syncDevelopmentDnsFromRegistry(entries, { rpxDir, verbose, ownerPid: process.pid }).catch((err) => {
+        debugLog('daemon', `DNS sync on registry change failed: ${err}`, verbose)
+      })
+    },
     { dir: registryDir, verbose },
   )
 
@@ -311,6 +329,9 @@ export async function runDaemon(opts: DaemonOptions = {}): Promise<DaemonHandle>
     // `stop(false)` lets in-flight requests drain before closing the listener.
     httpsServer.stop(false)
     httpServer?.stop(false)
+    await tearDownDevelopmentDns({ rpxDir, verbose }).catch((err) => {
+      debugLog('daemon', `DNS teardown failed: ${err}`, verbose)
+    })
     await releaseDaemonLock(rpxDir)
     if (verbose)
       log.info('rpx daemon stopped')
@@ -391,6 +412,10 @@ export async function ensureDaemonRunning(opts: EnsureDaemonOptions = {}): Promi
   const rpxDir = opts.rpxDir ?? getDaemonRpxDir()
   const verbose = opts.verbose ?? false
 
+  await reconcileStaleDevelopmentDns({ rpxDir, verbose }).catch((err) => {
+    debugLog('daemon', `DNS reconcile before ensureDaemonRunning: ${err}`, verbose)
+  })
+
   const existingPid = await readDaemonPid(rpxDir)
   if (existingPid !== null && isPidAlive(existingPid)) {
     debugLog('daemon', `ensureDaemonRunning: already running pid=${existingPid}`, verbose)
@@ -477,6 +502,7 @@ export async function stopDaemon(opts: StopDaemonOptions = {}): Promise<StopDaem
   if (pid === null || !isPidAlive(pid)) {
     if (pid !== null)
       await releaseDaemonLock(rpxDir)
+    await reconcileStaleDevelopmentDns({ rpxDir, verbose }).catch(() => {})
     return { stopped: false, pid, forced: false }
   }
 
@@ -514,5 +540,18 @@ export async function stopDaemon(opts: StopDaemonOptions = {}): Promise<StopDaem
   }
   // SIGKILL bypasses the cleanup handler, so remove the pid file ourselves.
   await releaseDaemonLock(rpxDir)
+  await tearDownDevelopmentDns({ rpxDir, verbose }).catch((err) => {
+    debugLog('daemon', `DNS teardown after SIGKILL: ${err}`, verbose)
+  })
   return { stopped: true, pid, forced: true }
 }
+
+/**
+ * When the daemon is not running, ensure no stale macOS resolver overrides remain.
+ */
+export async function reconcileDevelopmentDnsOnIdle(opts: { rpxDir?: string, verbose?: boolean } = {}): Promise<void> {
+  const rpxDir = opts.rpxDir ?? getDaemonRpxDir()
+  if (await isDaemonRunning(rpxDir))
+    return
+  await reconcileStaleDevelopmentDns({ rpxDir, verbose: opts.verbose })
+}

package/src/dns-state.ts

@@ -0,0 +1,116 @@
+import * as fsp from 'node:fs/promises'
+import { homedir } from 'node:os'
+import * as path from 'node:path'
+
+export const DNS_STATE_VERSION = 1 as const
+export const RPX_DNS_STATE_FILE = 'dns-state.json'
+
+/** Single-label /etc/resolver files created by older rpx versions (whole-TLD hijack). */
+export const LEGACY_TLD_RESOLVER_LABELS = [
+  'com',
+  'test',
+  'dev',
+  'app',
+  'page',
+  'local',
+  'localhost',
+  'example',
+  'invalid',
+] as const
+
+export interface DnsState {
+  version: typeof DNS_STATE_VERSION
+  /** Basenames under /etc/resolver/ (e.g. `postline.test`, not `test`). */
+  resolvers: string[]
+  domains: string[]
+  ownerPid: number | null
+  updatedAt: string
+}
+
+export function defaultRpxDir(): string {
+  return path.join(homedir(), '.stacks', 'rpx')
+}
+
+export function getDnsStatePath(rpxDir: string = defaultRpxDir()): string {
+  return path.join(rpxDir, RPX_DNS_STATE_FILE)
+}
+
+export async function loadDnsState(rpxDir: string = defaultRpxDir()): Promise<DnsState | null> {
+  try {
+    const raw = await fsp.readFile(getDnsStatePath(rpxDir), 'utf8')
+    const parsed = JSON.parse(raw) as Partial<DnsState>
+    if (parsed.version !== DNS_STATE_VERSION || !Array.isArray(parsed.resolvers))
+      return null
+    return {
+      version: DNS_STATE_VERSION,
+      resolvers: parsed.resolvers.filter((r): r is string => typeof r === 'string'),
+      domains: Array.isArray(parsed.domains)
+        ? parsed.domains.filter((d): d is string => typeof d === 'string')
+        : [],
+      ownerPid: typeof parsed.ownerPid === 'number' ? parsed.ownerPid : null,
+      updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : '',
+    }
+  }
+  catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT')
+      return null
+    throw err
+  }
+}
+
+export async function saveDnsState(rpxDir: string, state: DnsState): Promise<void> {
+  await fsp.mkdir(rpxDir, { recursive: true })
+  await fsp.writeFile(getDnsStatePath(rpxDir), `${JSON.stringify(state, null, 2)}\n`, 'utf8')
+}
+
+export async function clearDnsState(rpxDir: string): Promise<void> {
+  await fsp.rm(getDnsStatePath(rpxDir), { force: true })
+}
+
+/**
+ * Normalize a dev hostname. Returns null for localhost / IPs — those use /etc/hosts only.
+ */
+export function normalizeDevDomain(raw: string): string | null {
+  const domain = raw.trim().toLowerCase().replace(/\.$/, '')
+  if (!domain || domain.includes('127.0.0.1'))
+    return null
+  if (domain === 'localhost' || domain.endsWith('.localhost'))
+    return null
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(domain))
+    return null
+  return domain
+}
+
+/**
+ * macOS resolver basename for a dev domain. Uses the registrable base (last two labels)
+ * so `api.postline.test` and `postline.test` share one `/etc/resolver/postline.test` file.
+ */
+export function resolverBasenameForDomain(raw: string): string | null {
+  const domain = normalizeDevDomain(raw)
+  if (!domain)
+    return null
+  const parts = domain.split('.')
+  if (parts.length < 2)
+    return null
+  return parts.slice(-2).join('.')
+}
+
+export function resolverBasenamesForDomains(domains: string[]): string[] {
+  const basenames = new Set<string>()
+  for (const raw of domains) {
+    const basename = resolverBasenameForDomain(raw)
+    if (basename)
+      basenames.add(basename)
+  }
+  return Array.from(basenames).sort()
+}
+
+export function devDomainsFromHosts(hosts: string[]): string[] {
+  const out = new Set<string>()
+  for (const raw of hosts) {
+    const domain = normalizeDevDomain(raw)
+    if (domain)
+      out.add(domain)
+  }
+  return Array.from(out).sort()
+}