@stacksjs/rpx 0.11.2 → 0.11.4

package/src/index.ts

@@ -0,0 +1,33 @@
+import { startProxies as startProxiesFunc } from './start'
+
+export { colors } from './colors'
+
+export { config, config as defaultConfig } from './config'
+
+export {
+  addHosts,
+  checkHosts,
+  removeHosts,
+} from './hosts'
+
+export {
+  checkExistingCertificates,
+  cleanupCertificates,
+  forceTrustCertificate,
+  generateCertificate,
+  httpsConfig,
+  isCertTrusted,
+  loadSSLConfig,
+} from './https'
+
+export { DefaultPortManager, findAvailablePort, isPortInUse, portManager } from './port-manager'
+
+export { cleanup } from './start'
+
+export { startProxies, startProxy, startServer } from './start'
+
+export * from './types'
+
+export * from './utils'
+
+export default startProxiesFunc

package/src/logger.ts

@@ -0,0 +1,19 @@
+export const log: {
+  info: (...args: any[]) => void
+  success: (...args: any[]) => void
+  warn: (...args: any[]) => void
+  error: (...args: any[]) => void
+  debug: (...args: any[]) => void
+  log: (...args: any[]) => void
+  start: (...args: any[]) => void
+  box: (...args: any[]) => void
+} = {
+  info: (...args: any[]) => console.log('[info]', ...args),
+  success: (...args: any[]) => console.log('[success]', ...args),
+  warn: (...args: any[]) => console.warn('[warn]', ...args),
+  error: (...args: any[]) => console.error('[error]', ...args),
+  debug: (...args: any[]) => console.debug('[debug]', ...args),
+  log: (...args: any[]) => console.log(...args),
+  start: (...args: any[]) => console.log('[start]', ...args),
+  box: (...args: any[]) => console.log('[box]', ...args),
+}

package/src/port-manager.ts

@@ -0,0 +1,183 @@
+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

@@ -0,0 +1,164 @@
+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 } 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: ${JSON.stringify(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()