@stacksjs/rpx 0.11.19 → 0.11.21

package/src/origin-guard.ts

@@ -1,127 +0,0 @@
-/**
- * Origin verification guard for "CDN in front of rpx" topologies.
- *
- * When rpx is the origin behind a CDN (e.g. CloudFront → rpx), the origin host
- * is publicly resolvable, so a client could resolve it and hit rpx directly,
- * bypassing the CDN's caching/WAF. The standard mitigation is a shared secret:
- * the CDN injects a secret request header on the origin fetch, and the origin
- * rejects any request to the protected hosts that lacks it.
- *
- * `createOriginGuard` returns a tiny pre-router gate you place in front of your
- * fetch handler. It only guards the listed hosts (exact or `*.wildcard`) — every
- * other host (e.g. apps served directly, not via the CDN) passes through
- * untouched. ACME HTTP-01 challenge paths are exempt by default so cert renewal
- * keeps working on the open `:80` listener.
- *
- * @example
- * const guard = createOriginGuard({
- *   header: 'x-origin-verify',
- *   value: process.env.ORIGIN_SECRET!,
- *   hosts: ['stacksjs.com', 'www.stacksjs.com', 'origin.stacksjs.com'],
- * })
- * Bun.serve({ fetch: req => guard(req) ?? handler(req, server) })
- */
-import { timingSafeEqual } from 'node:crypto'
-import { matchesWildcard } from './host-match'
-
-/**
- * Compare a request-supplied secret against the expected value in constant time,
- * so the shared secret can't be recovered byte-by-byte via response timing. The
- * length check leaks only the secret's length (standard and acceptable); the
- * byte comparison itself is timing-safe.
- */
-function secretMatches(provided: string | null, expected: string): boolean {
-  if (provided == null)
-    return false
-  const a = Buffer.from(provided)
-  const b = Buffer.from(expected)
-  if (a.length !== b.length)
-    return false
-  return timingSafeEqual(a, b)
-}
-
-/** Lowercase and strip a single trailing dot so `Host: example.com.` ≡ `example.com`. */
-function normalizeHost(host: string): string {
-  return host.toLowerCase().replace(/\.$/, '')
-}
-
-export interface OriginGuardOptions {
-  /** Header the CDN injects on the origin hop (case-insensitive), e.g. `x-origin-verify`. */
-  header: string
-  /** Expected secret value. Requests to protected hosts must carry `header: value`. */
-  value: string
-  /** Hosts to protect — exact (`stacksjs.com`) or wildcard (`*.stacksjs.com`). Others pass through. */
-  hosts: string[]
-  /**
-   * Request paths exempt from the check (prefix match). Defaults to the ACME
-   * HTTP-01 challenge prefix so cert issuance/renewal is never blocked.
-   */
-  exemptPaths?: string[]
-  /** Body returned on rejection. Defaults to a short plain-text message. */
-  forbiddenMessage?: string
-}
-
-export interface OriginGuard {
-  /** Returns a 403 Response to short-circuit, or `undefined` to let the request proceed. */
-  (req: Request): Response | undefined
-  /** Whether a given hostname is in the protected set. */
-  protects: (hostname: string) => boolean
-}
-
-const DEFAULT_EXEMPT = ['/.well-known/acme-challenge/']
-
-function hostnameOf(req: Request): string {
-  const hostHeader = req.headers.get('host')
-  if (hostHeader)
-    return normalizeHost(hostHeader.split(':')[0])
-  try {
-    return normalizeHost(new URL(req.url).hostname)
-  }
-  catch {
-    return ''
-  }
-}
-
-export function createOriginGuard(options: OriginGuardOptions): OriginGuard {
-  const header = options.header.toLowerCase()
-  const exact = new Set<string>()
-  const wildcards: string[] = []
-  for (const h of options.hosts) {
-    const host = normalizeHost(h)
-    if (host.startsWith('*.'))
-      wildcards.push(host)
-    else
-      exact.add(host)
-  }
-  const exemptPaths = options.exemptPaths ?? DEFAULT_EXEMPT
-  const forbidden = options.forbiddenMessage
-    ?? 'Forbidden: direct origin access is not allowed; requests must arrive via the CDN.\n'
-
-  const protects = (hostname: string): boolean => {
-    const h = normalizeHost(hostname)
-    return exact.has(h) || wildcards.some(w => matchesWildcard(h, w))
-  }
-
-  const guard: OriginGuard = ((req: Request): Response | undefined => {
-    const host = hostnameOf(req)
-    if (!protects(host))
-      return undefined
-
-    let pathname = '/'
-    try {
-      pathname = new URL(req.url).pathname
-    }
-    catch {
-      // fall through with '/'
-    }
-    if (exemptPaths.some(p => pathname.startsWith(p)))
-      return undefined
-
-    if (secretMatches(req.headers.get(header), options.value))
-      return undefined
-
-    return new Response(forbidden, { status: 403, headers: { 'content-type': 'text/plain' } })
-  }) as OriginGuard
-  guard.protects = protects
-  return guard
-}

package/src/port-manager.ts

@@ -1,183 +0,0 @@
-import type { PortManager } from './types'
-import * as net from 'node:net'
-import { debugLog } from './utils'
-
-/**
- * Check if a port is in use
- */
-export function isPortInUse(port: number, hostname: string, verbose?: boolean): Promise<boolean> {
-  debugLog('port', `Checking if port ${port} is in use on ${hostname}`, verbose)
-  return new Promise((resolve) => {
-    const server = net.createServer()
-
-    // Add a timeout to ensure we don't hang indefinitely
-    const timeout = setTimeout(() => {
-      debugLog('port', `Checking port ${port} timed out, assuming it's in use`, verbose)
-      server.close()
-      resolve(true)
-    }, 3000) // 3 second timeout
-
-    server.once('error', (err: NodeJS.ErrnoException) => {
-      clearTimeout(timeout)
-      if (err.code === 'EADDRINUSE') {
-        debugLog('port', `Port ${port} is in use`, verbose)
-        resolve(true)
-      }
-      else {
-        // Other errors should also be treated as port unavailable
-        debugLog('port', `Error checking port ${port}: ${err.message}`, verbose)
-        resolve(true)
-      }
-    })
-
-    server.once('listening', () => {
-      clearTimeout(timeout)
-      debugLog('port', `Port ${port} is available`, verbose)
-      server.close()
-      resolve(false)
-    })
-
-    try {
-      server.listen(port, hostname)
-    }
-    catch (err) {
-      clearTimeout(timeout)
-      debugLog('port', `Exception checking port ${port}: ${err}`, verbose)
-      resolve(true)
-    }
-  })
-}
-
-/**
- * Find next available port
- */
-export async function findAvailablePort(
-  startPort: number,
-  hostname: string,
-  verbose?: boolean,
-  maxAttempts = 50,
-): Promise<number> {
-  debugLog('port', `Finding available port starting from ${startPort} (max attempts: ${maxAttempts})`, verbose)
-  let port = startPort
-  let attempts = 0
-
-  while (attempts < maxAttempts) {
-    attempts++
-    const isInUse = await isPortInUse(port, hostname, verbose)
-
-    if (!isInUse) {
-      debugLog('port', `Found available port: ${port} after ${attempts} attempts`, verbose)
-      return port
-    }
-
-    debugLog('port', `Port ${port} is in use, trying ${port + 1} (attempt ${attempts}/${maxAttempts})`, verbose)
-    port++
-  }
-
-  throw new Error(`Unable to find available port after ${maxAttempts} attempts starting from ${startPort}`)
-}
-
-/**
- * Test if a port is actually connectable
- */
-export function testPortConnectivity(
-  port: number,
-  hostname: string,
-  timeout = 5000,
-  verbose?: boolean,
-): Promise<boolean> {
-  debugLog('port', `Testing connection to ${hostname}:${port}`, verbose)
-  return new Promise((resolve) => {
-    const socket = net.connect({
-      host: hostname,
-      port,
-      timeout,
-    })
-
-    socket.once('connect', () => {
-      debugLog('port', `Successfully connected to ${hostname}:${port}`, verbose)
-      socket.end()
-      resolve(true)
-    })
-
-    socket.once('timeout', () => {
-      debugLog('port', `Connection to ${hostname}:${port} timed out`, verbose)
-      socket.destroy()
-      resolve(false)
-    })
-
-    socket.once('error', (err) => {
-      debugLog('port', `Failed to connect to ${hostname}:${port}: ${err.message}`, verbose)
-      socket.destroy()
-      resolve(false)
-    })
-  })
-}
-
-export class DefaultPortManager implements PortManager {
-  usedPorts: Set<number> = new Set()
-  private hostname: string
-  private verbose?: boolean
-  private maxRetries: number
-
-  constructor(hostname: string = '0.0.0.0', verbose?: boolean, maxRetries = 50) {
-    this.hostname = hostname
-    this.verbose = verbose
-    this.maxRetries = maxRetries
-  }
-
-  async getNextAvailablePort(startPort: number, testConnectivity = false): Promise<number> {
-    if (this.usedPorts.has(startPort)) {
-      // If we already have this port registered as used, find another one
-      return this.findNextAvailablePort(startPort + 1, testConnectivity)
-    }
-
-    const isInUse = await isPortInUse(startPort, this.hostname, this.verbose)
-
-    if (isInUse) {
-      return this.findNextAvailablePort(startPort + 1, testConnectivity)
-    }
-
-    // If requested, test that we can actually connect to this port
-    if (testConnectivity) {
-      const isConnectable = await testPortConnectivity(startPort, this.hostname, 3000, this.verbose)
-      if (!isConnectable) {
-        debugLog('port', `Port ${startPort} is available but not connectable, trying next port`, this.verbose)
-        return this.findNextAvailablePort(startPort + 1, testConnectivity)
-      }
-    }
-
-    // Port is available, register it
-    this.usedPorts.add(startPort)
-    return startPort
-  }
-
-  private async findNextAvailablePort(startPort: number, testConnectivity = false): Promise<number> {
-    const port = await findAvailablePort(startPort, this.hostname, this.verbose, this.maxRetries)
-
-    // If requested, test that we can actually connect to this port
-    if (testConnectivity) {
-      const isConnectable = await testPortConnectivity(port, this.hostname, 3000, this.verbose)
-      if (!isConnectable) {
-        // If the port isn't connectable, try the next one
-        if (port < startPort + this.maxRetries) {
-          return this.findNextAvailablePort(port + 1, testConnectivity)
-        }
-        else {
-          throw new Error(`Unable to find a connectable port after ${this.maxRetries} attempts`)
-        }
-      }
-    }
-
-    this.usedPorts.add(port)
-    return port
-  }
-
-  releasePort(port: number): void {
-    debugLog('port', `Releasing port ${port}`, this.verbose)
-    this.usedPorts.delete(port)
-  }
-}
-
-// Global port manager instance
-export const portManager: DefaultPortManager = new DefaultPortManager()

package/src/process-manager.ts

@@ -1,164 +0,0 @@
-import type { ChildProcess } from 'node:child_process'
-import type { StartOptions } from './types'
-import { spawn } from 'node:child_process'
-import * as process from 'node:process'
-import { log } from './logger'
-import { debugLog, safeStringify } from './utils'
-
-export interface ManagedProcess {
-  command: string
-  cwd: string
-  process: ChildProcess | null
-  env?: Record<string, string>
-}
-
-export class ProcessManager {
-  private processes: Map<string, ManagedProcess> = new Map()
-  private isShuttingDown = false
-
-  async startProcess(id: string, options: StartOptions, verbose?: boolean): Promise<void> {
-    if (this.processes.has(id)) {
-      debugLog('start', `Process ${id} is already running`, verbose)
-      return
-    }
-
-    const [cmd, ...args] = options.command.split(' ')
-    const cwd = options.cwd || process.cwd()
-
-    debugLog('start', `Starting process ${id}:`, verbose)
-    debugLog('start', `  Command: ${cmd} ${args.join(' ')}`, verbose)
-    debugLog('start', `  Working directory: ${cwd}`, verbose)
-    debugLog('start', `  Environment variables: ${safeStringify(options.env)}`, verbose)
-
-    const childProcess = spawn(cmd, args, {
-      cwd,
-      env: { ...process.env, ...options.env },
-      shell: true,
-      stdio: 'inherit',
-    })
-
-    this.processes.set(id, {
-      command: options.command,
-      cwd,
-      process: childProcess,
-      env: options.env,
-    })
-
-    return new Promise((resolve, reject) => {
-      childProcess.on('error', (err) => {
-        if (!this.isShuttingDown) {
-          debugLog('start', `Process ${id} failed to start: ${err}`, verbose)
-          this.processes.delete(id)
-          reject(err)
-          // Trigger cleanup on process error
-          process.emit('SIGINT')
-        }
-      })
-
-      childProcess.on('exit', (code) => {
-        if (!this.isShuttingDown && code !== null && code !== 0) {
-          debugLog('start', `Process ${id} exited with code ${code}`, verbose)
-          this.processes.delete(id)
-          reject(new Error(`Process ${id} exited with code ${code}`))
-          // Trigger cleanup on non-zero exit
-          process.emit('SIGINT')
-        }
-      })
-
-      if (verbose) {
-        childProcess.stdout?.on('data', (data) => {
-          debugLog('process', `[${id}] ${data.toString().trim()}`, true)
-        })
-
-        childProcess.stderr?.on('data', (data) => {
-          debugLog('process', `[${id}] ERR: ${data.toString().trim()}`, true)
-        })
-      }
-
-      // Resolve after a delay to allow the process to start
-      setTimeout(() => {
-        if (!this.isShuttingDown && childProcess.killed) {
-          this.processes.delete(id)
-          reject(new Error(`Process ${id} was killed during startup`))
-        }
-        else {
-          debugLog('start', `Process ${id} started successfully`, verbose)
-          resolve()
-        }
-      }, 1000)
-    })
-  }
-
-  async stopProcess(id: string, verbose?: boolean): Promise<void> {
-    const managed = this.processes.get(id)
-    if (!managed?.process) {
-      debugLog('start', `No process found for ${id}`, verbose)
-      return
-    }
-
-    debugLog('start', `Stopping process ${id}`, verbose)
-
-    return new Promise((resolve) => {
-      if (!managed.process) {
-        resolve()
-        return
-      }
-
-      managed.process.once('exit', () => {
-        this.processes.delete(id)
-        debugLog('start', `Process ${id} stopped`, verbose)
-        resolve()
-      })
-
-      try {
-        managed.process.kill('SIGTERM')
-
-        // Force kill after 3 seconds if process hasn't exited
-        setTimeout(() => {
-          if (managed.process) {
-            debugLog('start', `Force killing process ${id}`, verbose)
-            try {
-              managed.process.kill('SIGKILL')
-            }
-            // eslint-disable-next-line unused-imports/no-unused-vars
-            catch (err) {
-              // Ignore errors during force kill
-            }
-          }
-        }, 3000)
-      }
-      catch (err) {
-        debugLog('start', `Error stopping process ${id}: ${err}`, verbose)
-        this.processes.delete(id)
-        resolve()
-      }
-    })
-  }
-
-  async stopAll(verbose?: boolean): Promise<void> {
-    if (this.isShuttingDown) {
-      debugLog('start', 'Already shutting down, skipping duplicate stopAll call', verbose)
-      return
-    }
-
-    this.isShuttingDown = true
-    debugLog('start', 'Stopping all processes', verbose)
-
-    const promises = Array.from(this.processes.keys()).map(id =>
-      this.stopProcess(id, verbose).catch((err) => {
-        log.error(`Failed to stop process ${id}:`, err)
-      }),
-    )
-
-    await Promise.allSettled(promises)
-    this.processes.clear()
-    this.isShuttingDown = false
-  }
-
-  isRunning(id: string): boolean {
-    const managed = this.processes.get(id)
-    return !!managed?.process && !managed.process.killed
-  }
-}
-
-export const processManager: ProcessManager = new ProcessManager()