@stacksjs/rpx 0.11.19 → 0.11.21

package/src/host-match.ts

@@ -1,52 +0,0 @@
-/**
- * Host-based route matching with wildcard support.
- *
- * The routing table is keyed by host pattern. A pattern is either an exact
- * hostname (`api.example.com`) or a wildcard (`*.example.com`). Lookup prefers
- * an exact match, then the most-specific (deepest-suffix) wildcard.
- *
- * Kept dependency-free and pure so it's reusable from both the daemon and the
- * in-process multi-proxy path, and trivially unit-testable.
- */
-
-export function isWildcardPattern(pattern: string): boolean {
-  return pattern.startsWith('*.')
-}
-
-/**
- * True if `hostname` matches the wildcard `pattern` (`*.suffix`). A wildcard
- * matches exactly one or more leading labels — `*.example.com` matches
- * `a.example.com` and `a.b.example.com`, but NOT the bare apex `example.com`.
- */
-export function matchesWildcard(hostname: string, pattern: string): boolean {
-  if (!isWildcardPattern(pattern))
-    return false
-  const suffix = pattern.slice(1) // '*.example.com' → '.example.com'
-  return hostname.length > suffix.length && hostname.endsWith(suffix)
-}
-
-/**
- * Find the route value for `hostname` in a host-keyed map. Exact match wins;
- * otherwise the matching wildcard with the longest (most-specific) suffix wins.
- * Returns `undefined` when nothing matches.
- */
-export function matchHost<T>(table: Map<string, T>, hostname: string): T | undefined {
-  const exact = table.get(hostname)
-  if (exact !== undefined)
-    return exact
-
-  let best: T | undefined
-  let bestLen = -1
-  for (const [pattern, value] of table) {
-    if (!isWildcardPattern(pattern))
-      continue
-    if (matchesWildcard(hostname, pattern)) {
-      const len = pattern.length - 1 // length of the matched suffix
-      if (len > bestLen) {
-        bestLen = len
-        best = value
-      }
-    }
-  }
-  return best
-}

package/src/host-routes.ts

@@ -1,147 +0,0 @@
-/**
- * Path-aware routing within a single host.
- *
- * `host-match.ts` answers "which host pattern owns this hostname?" (exact wins,
- * then most-specific wildcard). That is sufficient when every host maps to a
- * single backend. But a single domain often needs to serve several things at
- * once — e.g. `stacksjs.com/api/*` proxied to an app on `:3000`,
- * `stacksjs.com/docs*` served from `/var/www/docs`, and `stacksjs.com/` served
- * from `/var/www/public`. That requires a second routing dimension: the
- * request **path**.
- *
- * This module layers path routing on top of host routing without disturbing
- * host-only routing:
- *   - Each host pattern maps to a list of `(path, route)` entries.
- *   - Lookup first resolves the host (reusing `matchHost` semantics), then picks
- *     the entry whose `path` is the longest prefix of the request pathname.
- *   - A host with a single entry whose `path` is `'/'` (or empty) behaves
- *     exactly like the old host-only table — full backward compatibility.
- *
- * Kept dependency-free and pure so it's reusable from both the daemon and the
- * in-process multi-proxy path, and trivially unit-testable.
- */
-import { isWildcardPattern, matchesWildcard } from './host-match'
-
-/** One path-scoped route under a host. */
-export interface PathRoute<T> {
-  /**
-   * Path prefix this route owns, e.g. `'/api'`. `'/'` (or `''`) is the host
-   * default that catches everything not claimed by a more specific prefix.
-   */
-  path: string
-  /** The route value (e.g. a {@link import('./proxy-handler').ProxyRoute}). */
-  route: T
-}
-
-/**
- * A host-keyed routing table where each host owns an ordered set of
- * path-scoped routes. Build it with {@link buildHostRoutes}.
- */
-export type HostRoutes<T> = Map<string, Array<PathRoute<T>>>
-
-/**
- * Normalize a path prefix to a leading-slash, no-trailing-slash form so prefix
- * comparisons are predictable. `''`/`undefined`/`'/'` all normalize to `'/'`
- * (the host default). `'/api/'` → `'/api'`, `'docs'` → `'/docs'`.
- */
-export function normalizePathPrefix(path: string | undefined): string {
-  if (!path || path === '/')
-    return '/'
-  let p = path.trim()
-  if (!p.startsWith('/'))
-    p = `/${p}`
-  // Strip trailing slashes (but keep the root '/').
-  p = p.replace(/\/+$/, '')
-  return p === '' ? '/' : p
-}
-
-/**
- * True if `pathname` is matched by the prefix `prefix`. The root prefix `'/'`
- * matches everything. A non-root prefix matches when the pathname equals it
- * (`/api`), or continues with a `/` (`/api/x`) — so `/api` does NOT match
- * `/apifoo`, only a real path-segment boundary.
- */
-export function pathPrefixMatches(pathname: string, prefix: string): boolean {
-  if (prefix === '/')
-    return true
-  if (pathname === prefix)
-    return true
-  return pathname.startsWith(`${prefix}/`)
-}
-
-/**
- * Build a {@link HostRoutes} table from a flat list of entries. Entries are
- * grouped by host; within each host the path-routes are sorted longest-prefix
- * first so {@link matchHostRoute} can take the first match. If two entries
- * collide on the same (host, path) the later one wins (matching `Map.set`).
- */
-export function buildHostRoutes<T>(
-  entries: Array<{ host: string, path?: string, route: T }>,
-): HostRoutes<T> {
-  const byHost = new Map<string, Map<string, T>>()
-  for (const e of entries) {
-    const prefix = normalizePathPrefix(e.path)
-    let paths = byHost.get(e.host)
-    if (!paths) {
-      paths = new Map<string, T>()
-      byHost.set(e.host, paths)
-    }
-    paths.set(prefix, e.route)
-  }
-
-  const table: HostRoutes<T> = new Map()
-  for (const [host, paths] of byHost) {
-    const list: Array<PathRoute<T>> = []
-    for (const [path, route] of paths)
-      list.push({ path, route })
-    // Longest prefix first; '/' (length 1) naturally sorts last as the default.
-    list.sort((a, b) => b.path.length - a.path.length)
-    table.set(host, list)
-  }
-  return table
-}
-
-/**
- * Find the path-route list for `hostname` in a {@link HostRoutes} table. Exact
- * host match wins; otherwise the most-specific (deepest-suffix) wildcard wins —
- * mirroring {@link import('./host-match').matchHost}.
- */
-export function matchHostList<T>(table: HostRoutes<T>, hostname: string): Array<PathRoute<T>> | undefined {
-  const exact = table.get(hostname)
-  if (exact !== undefined)
-    return exact
-
-  let best: Array<PathRoute<T>> | undefined
-  let bestLen = -1
-  for (const [pattern, value] of table) {
-    if (!isWildcardPattern(pattern))
-      continue
-    if (matchesWildcard(hostname, pattern)) {
-      const len = pattern.length - 1
-      if (len > bestLen) {
-        bestLen = len
-        best = value
-      }
-    }
-  }
-  return best
-}
-
-/**
- * Resolve a (hostname, pathname) pair to a single route value. First the host
- * is resolved ({@link matchHostList}); then the longest matching path prefix
- * within that host wins. Returns `undefined` when no host matches, or a host
- * matches but no path prefix (including the `'/'` default) covers the request.
- */
-export function matchHostRoute<T>(table: HostRoutes<T>, hostname: string, pathname: string): T | undefined {
-  const list = matchHostList(table, hostname)
-  if (!list)
-    return undefined
-  // `list` is pre-sorted longest-prefix-first, so the first match is the most
-  // specific one ('/' is last and matches everything as the host default).
-  for (const entry of list) {
-    if (pathPrefixMatches(pathname, entry.path))
-      return entry.route
-  }
-  return undefined
-}

package/src/hosts.ts

@@ -1,283 +0,0 @@
-import { exec } from 'node:child_process'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import * as process from 'node:process'
-import { promisify } from 'node:util'
-import { debugLog, getSudoPassword, isProcessElevated } from './utils'
-
-const execAsync = promisify(exec)
-
-/** `.localhost` names resolve to loopback per RFC 6761 — no /etc/hosts entry needed. */
-export function isLoopbackDevelopmentHost(host: string): boolean {
-  const normalized = host.trim().toLowerCase()
-  return normalized === 'localhost'
-    || normalized.endsWith('.localhost')
-    || normalized.endsWith('.localhost.')
-}
-
-export const hostsFilePath: string = process.platform === 'win32'
-  ? path.join(process.env.windir || 'C:\\Windows', 'System32', 'drivers', 'etc', 'hosts')
-  : '/etc/hosts'
-
-// Flag to track if we've already received sudo privileges in this session
-let sudoPrivilegesAcquired = false
-
-// Single function to execute sudo commands, with caching for permissions.
-// Wraps in sh -c so pipes/redirects all run under sudo.
-async function execSudo(command: string): Promise<string> {
-  if (process.platform === 'win32')
-    throw new Error('Administrator privileges required on Windows')
-
-  if (isProcessElevated()) {
-    const { stdout } = await execAsync(command)
-    return stdout
-  }
-
-  const sudoPassword = getSudoPassword()
-  const escaped = command.replace(/'/g, `'\\''`)
-
-  try {
-    if (sudoPassword) {
-      const { stdout } = await execAsync(`echo '${sudoPassword}' | sudo -S sh -c '${escaped}' 2>/dev/null`)
-      sudoPrivilegesAcquired = true
-      return stdout
-    }
-
-    if (sudoPrivilegesAcquired) {
-      try {
-        const { stdout } = await execAsync(`sudo -n sh -c '${escaped}'`)
-        return stdout
-      }
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      catch (error) {
-        debugLog('hosts', 'Cached sudo privileges expired, requesting again', true)
-      }
-    }
-
-    try {
-      const { stdout } = await execAsync(`sudo -n sh -c '${escaped}'`)
-      sudoPrivilegesAcquired = true
-      return stdout
-    }
-    catch {
-      throw new Error('sudo required but no cached credentials (set SUDO_PASSWORD in .env or run sudo -v)')
-    }
-  }
-  catch (error) {
-    throw new Error(`Failed to execute sudo command: ${(error as Error).message}`)
-  }
-}
-
-export async function addHosts(hosts: string[], verbose?: boolean): Promise<void> {
-  const needsHostsFile = hosts.filter(h => !isLoopbackDevelopmentHost(h))
-  const skipped = hosts.filter(h => isLoopbackDevelopmentHost(h))
-  if (skipped.length > 0) {
-    debugLog('hosts', `Skipping /etc/hosts for loopback dev names: ${skipped.join(', ')}`, verbose)
-  }
-  if (needsHostsFile.length === 0)
-    return
-
-  debugLog('hosts', `Adding hosts: ${needsHostsFile.join(', ')}`, verbose)
-  debugLog('hosts', `Using hosts file at: ${hostsFilePath}`, verbose)
-
-  try {
-    // Read existing hosts file content
-    let existingContent: string
-    try {
-      existingContent = await fs.promises.readFile(hostsFilePath, 'utf-8')
-    }
-    catch {
-      // /etc/hosts typically requires elevated permissions — fall back to sudo
-      debugLog('hosts', 'Reading hosts file requires elevated permissions, using sudo', verbose)
-
-      try {
-        existingContent = await execSudo(`cat "${hostsFilePath}"`)
-      }
-      catch (sudoErr) {
-        console.log('  Could not read hosts file — skipping hosts setup')
-        debugLog('hosts', `sudo read also failed: ${sudoErr}`, verbose)
-        throw new Error(`Cannot read hosts file: ${sudoErr}`)
-      }
-    }
-
-    // Prepare new entries, only including those that don't exist
-    const newEntries = needsHostsFile.filter((host) => {
-      const ipv4Entry = `127.0.0.1 ${host}`
-      const ipv6Entry = `::1 ${host}`
-      return !existingContent.includes(ipv4Entry) && !existingContent.includes(ipv6Entry)
-    })
-
-    if (newEntries.length === 0) {
-      debugLog('hosts', 'All hosts already exist in hosts file', verbose)
-      return
-    }
-
-    // Create content for new entries
-    const hostEntries = newEntries.map(host =>
-      `\n# Added by rpx\n127.0.0.1 ${host}\n::1 ${host}`,
-    ).join('\n')
-
-    const tmpFile = path.join(os.tmpdir(), `rpx-hosts-${Date.now()}.tmp`)
-
-    try {
-      // Write to temporary file
-      await fs.promises.writeFile(tmpFile, existingContent + hostEntries, 'utf8')
-
-      // Use tee with sudo to write the content to hosts file
-      await execSudo(`cat "${tmpFile}" | tee "${hostsFilePath}" > /dev/null`)
-      console.log(`  Hosts updated: ${newEntries.join(', ')}`)
-    }
-    // eslint-disable-next-line unused-imports/no-unused-vars
-    catch (error) {
-      // Don't throw — just tell the user what to add manually
-      console.log('  Could not update hosts file automatically')
-      console.log('  Add these entries to /etc/hosts:')
-      newEntries.forEach((host) => {
-        console.log(`    127.0.0.1 ${host}`)
-        console.log(`    ::1 ${host}`)
-      })
-      console.log(`  Or run: sudo nano ${hostsFilePath}`)
-    }
-    finally {
-      try {
-        await fs.promises.unlink(tmpFile)
-      }
-      catch {
-        // Ignore cleanup errors
-      }
-    }
-  }
-  catch (err) {
-    const error = err as Error
-    debugLog('hosts', `Failed to manage hosts file: ${error.message}`, verbose)
-    // Don't throw - hosts file management is best-effort
-  }
-}
-
-export async function removeHosts(hosts: string[], verbose?: boolean): Promise<void> {
-  debugLog('hosts', `Removing hosts: ${hosts.join(', ')}`, verbose)
-
-  try {
-    // Read existing hosts file content
-    let content: string
-    try {
-      content = await fs.promises.readFile(hostsFilePath, 'utf-8')
-    }
-    catch {
-      debugLog('hosts', 'Reading hosts file requires elevated permissions, using sudo', verbose)
-
-      try {
-        content = await execSudo(`cat "${hostsFilePath}"`)
-      }
-      catch (sudoErr) {
-        debugLog('hosts', `sudo read also failed: ${sudoErr}`, verbose)
-        throw new Error(`Cannot read hosts file: ${sudoErr}`)
-      }
-    }
-
-    const lines = content.split('\n')
-    let modified = false
-
-    // Filter out our added entries and their comments
-    const filteredLines = lines.filter((line) => {
-      // Check if this line contains one of our hosts
-      const isHostLine = hosts.some(host =>
-        line.includes(` ${host}`)
-        && (line.includes('127.0.0.1') || line.includes('::1')),
-      )
-
-      if (isHostLine) {
-        modified = true
-        return false
-      }
-
-      // If it's our comment line, remove it
-      if (line.trim() === '# Added by rpx') {
-        modified = true
-        return false
-      }
-
-      return true
-    })
-
-    // If nothing was removed, we're done
-    if (!modified) {
-      debugLog('hosts', 'No matching hosts found to remove', verbose)
-      return
-    }
-
-    // Remove empty lines at the end of the file
-    while (filteredLines[filteredLines.length - 1]?.trim() === '')
-      filteredLines.pop()
-
-    // Ensure file ends with a single newline
-    const newContent = `${filteredLines.join('\n')}\n`
-
-    const tmpFile = path.join(os.tmpdir(), `rpx-hosts-${Date.now()}.tmp`)
-
-    try {
-      // Write to temporary file
-      await fs.promises.writeFile(tmpFile, newContent, 'utf8')
-
-      // Use tee with sudo to write the content to hosts file
-      await execSudo(`cat "${tmpFile}" | tee "${hostsFilePath}" > /dev/null`)
-      debugLog('hosts', 'Hosts removed successfully', verbose)
-    }
-    // eslint-disable-next-line unused-imports/no-unused-vars
-    catch (error) {
-      debugLog('hosts', 'Could not clean up hosts file automatically', verbose)
-    }
-    finally {
-      try {
-        // Clean up the temp file
-        await fs.promises.unlink(tmpFile)
-      }
-      catch (unlinkErr) {
-        // Ignore cleanup errors
-        debugLog('hosts', `Failed to remove temporary file: ${unlinkErr}`, verbose)
-      }
-    }
-  }
-  catch (err) {
-    debugLog('hosts', `Failed to clean up hosts file: ${(err as Error).message}`, verbose)
-    // Don't throw - hosts file cleanup is best-effort
-  }
-}
-
-export async function checkHosts(hosts: string[], verbose?: boolean): Promise<boolean[]> {
-  debugLog('hosts', `Checking hosts: ${hosts}`, verbose)
-
-  let content: string
-  try {
-    content = await fs.promises.readFile(hostsFilePath, 'utf-8')
-  }
-  catch (readErr) {
-    debugLog('hosts', `Error reading hosts file: ${readErr}`, verbose)
-
-    // Try with sudo using SUDO_PASSWORD if available
-    try {
-      const sudoPassword = getSudoPassword()
-      let cmd: string
-      if (sudoPassword) {
-        cmd = `echo '${sudoPassword}' | sudo -S cat "${hostsFilePath}" 2>/dev/null`
-      }
-      else {
-        cmd = `sudo -n cat "${hostsFilePath}" 2>/dev/null || cat "${hostsFilePath}" 2>/dev/null || echo ""`
-      }
-      const { stdout } = await execAsync(cmd)
-      content = stdout
-    }
-    catch (sudoErr) {
-      // Can't read hosts file - assume entries don't exist
-      debugLog('hosts', `Cannot read hosts file, assuming entries don't exist: ${sudoErr}`, verbose)
-      return hosts.map(() => false)
-    }
-  }
-
-  return hosts.map((host) => {
-    const ipv4Entry = `127.0.0.1 ${host}`
-    const ipv6Entry = `::1 ${host}`
-    return content.includes(ipv4Entry) || content.includes(ipv6Entry)
-  })
-}