@stacksjs/rpx 0.11.4 → 0.11.7

package/dist/process-manager.d.ts

@@ -1,3 +1,4 @@
+import * as process from 'node:process';
 import type { ChildProcess } from 'node:child_process';
 import type { StartOptions } from './types';
 export declare const processManager: ProcessManager;

package/dist/proxy-handler.d.ts

@@ -0,0 +1,15 @@
+import type { PathRewrite } from './types';
+/**
+ * Build a Bun.serve-compatible `fetch` handler that routes requests based on
+ * the `Host` header. Returns 404 when no route matches and 502 on upstream
+ * failures.
+ */
+export declare function createProxyFetchHandler(getRoute: GetRoute, verbose?: boolean): ProxyFetchHandler;
+export declare interface ProxyRoute {
+  sourceHost: string
+  cleanUrls?: boolean
+  changeOrigin?: boolean
+  pathRewrites?: PathRewrite[]
+}
+export type GetRoute = (hostname: string) => ProxyRoute | undefined;
+export type ProxyFetchHandler = (req: Request) => Promise<Response>;

package/dist/registry.d.ts

@@ -0,0 +1,74 @@
+import type { PathRewrite } from './types';
+/**
+ * Default location for the registry directory. The daemon's PID file and log
+ * sit alongside it under `~/.stacks/rpx/`.
+ */
+export declare function getRegistryDir(): string;
+/**
+ * Validate an entry id. Rejects anything that could escape the registry dir
+ * (path traversal, slashes) or that would round-trip oddly through a filename.
+ */
+export declare function isValidId(id: string): boolean;
+/**
+ * Check whether a PID is alive. `kill(pid, 0)` returns without sending a
+ * signal but throws ESRCH if the process is gone — exactly the probe we need.
+ * EPERM means the process exists but we don't own it; treat as alive.
+ */
+export declare function isPidAlive(pid: number): boolean;
+/**
+ * Atomically write an entry to disk.
+ *
+ * Writes to a temp file in the same directory, then renames into place. POSIX
+ * rename within the same filesystem is atomic, so a concurrent reader either
+ * sees the old file or the new file — never a half-written one.
+ */
+export declare function writeEntry(entry: RegistryEntry, dir?: string, verbose?: boolean): Promise<void>;
+/**
+ * Remove an entry by id. No-op if the file is already gone.
+ */
+export declare function removeEntry(id: string, dir?: string, verbose?: boolean): Promise<void>;
+/**
+ * Read a single entry by id. Returns `null` if missing or malformed (malformed
+ * files are deleted so they don't keep poisoning subsequent reads).
+ */
+export declare function readEntry(id: string, dir?: string, verbose?: boolean): Promise<RegistryEntry | null>;
+/**
+ * Read all entries from the registry directory. Malformed files are pruned.
+ * This does NOT GC stale PIDs — call `gcStaleEntries` for that explicitly.
+ */
+export declare function readAll(dir?: string, verbose?: boolean): Promise<RegistryEntry[]>;
+/**
+ * Remove entries whose writer PID is no longer alive. Returns the count of
+ * entries removed. Safe to call repeatedly; intended to run on daemon startup
+ * and on a slow timer (e.g. every 5s) while the daemon is up.
+ */
+export declare function gcStaleEntries(dir?: string, verbose?: boolean): Promise<number>;
+/**
+ * Watch the registry directory and invoke `onChange` with the full current
+ * entry list whenever something changes. Events are debounced so a flurry of
+ * rapid writes (e.g. several `./buddy dev` invocations starting in parallel)
+ * triggers at most one rebuild.
+ *
+ * The watcher tolerates a missing directory at startup — it creates the dir
+ * before opening the watch, so the first `writeEntry` doesn't race the daemon.
+ */
+export declare function watchRegistry(onChange: (entries: RegistryEntry[]) => void | Promise<void>, opts?: WatchOptions & { dir?: string }): WatchHandle;
+export declare interface RegistryEntry {
+  id: string
+  from: string
+  to: string
+  pid?: number
+  cwd?: string
+  createdAt: string
+  pathRewrites?: PathRewrite[]
+  cleanUrls?: boolean
+  changeOrigin?: boolean
+}
+export declare interface WatchHandle {
+  close: () => void
+}
+export declare interface WatchOptions {
+  debounceMs?: number
+  pollMs?: number
+  verbose?: boolean
+}

package/dist/start.d.ts

@@ -1,3 +1,6 @@
+import * as http from 'node:http';
+import * as http2 from 'node:http2';
+import * as https from 'node:https';
 import type { CleanupOptions, ProxyOption, ProxyOptions, ProxySetupOptions, SingleProxyConfig } from './types';
 export declare function cleanup(options?: CleanupOptions): Promise<void>;
 export declare function startServer(options: SingleProxyConfig): Promise<void>;

package/dist/types.d.ts

@@ -15,6 +15,7 @@ export declare interface BaseProxyConfig {
   to: string
   start?: StartOptions
   pathRewrites?: PathRewrite[]
+  id?: string
 }
 export declare interface CleanupConfig {
   domains: string[]
@@ -33,6 +34,7 @@ export declare interface SharedProxyConfig {
   cleanUrls: boolean
   changeOrigin?: boolean
   regenerateUntrustedCerts?: boolean
+  viaDaemon?: boolean
 }
 export declare interface SingleProxyConfig extends BaseProxyConfig, SharedProxyConfig {}
 export declare interface MultiProxyConfig extends SharedProxyConfig {

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { MultiProxyConfig, ProxyConfigs, ProxyOption, ProxyOptions, SingleProxyConfig } from './types';
+import type { MultiProxyConfig, PathRewrite, ProxyConfigs, ProxyOption, ProxyOptions, SingleProxyConfig } from './types';
 /**
  * Get sudo password from environment variable if set
  */
@@ -8,6 +8,8 @@ export declare function getSudoPassword(): string | undefined;
  */
 export declare function execSudoSync(command: string): string;
 export declare function debugLog(category: string, message: string, verbose?: boolean): void;
+export declare function redactSensitive(value: unknown): unknown;
+export declare function safeStringify(value: unknown, space?: number): string;
 /**
  * Extracts hostnames from proxy configuration
  */
@@ -27,6 +29,16 @@ export declare function isMultiProxyOptions(options: ProxyOption | ProxyOptions)
  */
 export declare function isSingleProxyOptions(options: ProxyOption | ProxyOptions): options is SingleProxyConfig;
 export declare function isSingleProxyConfig(options: ProxyConfigs | ProxyOptions): options is SingleProxyConfig;
+/**
+ * Resolve a path against a list of `pathRewrites`.
+ *
+ * Returns `null` if no rewrite matches; otherwise returns `{ targetHost, targetPath }`
+ * with the prefix preserved by default (or stripped when `stripPrefix === true`).
+ *
+ * Matching rule: rewrite matches if `pathname` is exactly `from` OR starts with
+ * `from + '/'`. So `/api` matches `/api`, `/api/`, `/api/cart` — but not `/apidocs`.
+ */
+export declare function resolvePathRewrite(pathname: string, rewrites: PathRewrite[] | undefined): { targetHost: string, targetPath: string } | null;
 /**
  * Safely delete a file if it exists
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/rpx",
   "type": "module",
-  "version": "0.11.4",
+  "version": "0.11.7",
   "description": "A modern and smart reverse proxy.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "src"
   ],
   "scripts": {
-    "build": "bun build.ts && bun run compile",
+    "build": "bun build.ts && bun build ./bin/cli.ts --compile --minify --outfile bin/rpx",
     "compile": "bun build ./bin/cli.ts --compile --minify --outfile bin/rpx",
     "compile:all": "bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:windows-x64 && bun run compile:darwin-x64 && bun run compile:darwin-arm64",
     "compile:linux-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-x64 --outfile bin/rpx-linux-x64",
@@ -51,11 +51,12 @@
     "compile:windows-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-windows-x64 --outfile bin/rpx-windows-x64.exe",
     "compile:darwin-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-x64 --outfile bin/rpx-darwin-x64",
     "compile:darwin-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-arm64 --outfile bin/rpx-darwin-arm64",
-    "lint": "bunx --bun eslint .",
-    "lint:fix": "bunx --bun eslint . --fix",
+    "lint": "bunx --bun pickier .",
+    "lint:fix": "bunx --bun pickier . --fix",
     "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
     "changelog": "changelogen --output CHANGELOG.md",
-    "prepublishOnly": "bun --bun run build && bun run compile:all && bun run zip",
+    "prepublishOnly": "bun build.ts",
+    "release:binaries": "bun run compile:all && bun run zip",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
     "zip": "bun run zip:all",
@@ -66,10 +67,11 @@
     "zip:darwin-x64": "zip -j bin/rpx-darwin-x64.zip bin/rpx-darwin-x64",
     "zip:darwin-arm64": "zip -j bin/rpx-darwin-arm64.zip bin/rpx-darwin-arm64"
   },
+  "dependencies": {
+    "@stacksjs/clapp": "^0.2.10",
+    "@stacksjs/tlsx": "^0.13.6"
+  },
   "devDependencies": {
-    "@stacksjs/clapp": "^0.2.0",
-    "@stacksjs/tlsx": "^0.13.0",
-    "bun-plugin-dtsx": "^0.21.17",
     "bunfig": "^0.15.6",
     "typescript": "^5.9.3"
   },
@@ -77,6 +79,6 @@
     "pre-commit": "bunx lint-staged"
   },
   "lint-staged": {
-    "*.{js,ts}": "bunx eslint . --fix"
+    "*.{js,ts}": "bunx --bun pickier . --fix"
   }
 }

package/src/daemon-runner.ts

@@ -0,0 +1,148 @@
+/**
+ * Bridges the `startProxy` / `startProxies` entrypoints to the long-running
+ * rpx daemon. When `viaDaemon: true` is set on a proxy config (or
+ * `--via-daemon` is passed to the CLI), we don't bind our own `:443` —
+ * instead we:
+ *
+ *   1. Write a registry entry per proxy under `~/.stacks/rpx/registry.d`.
+ *   2. Ensure the daemon is running (lazy-spawn if needed).
+ *   3. Block until SIGINT/SIGTERM, then unregister our entries.
+ *
+ * The daemon's PID-GC reaps anything we miss if this process dies `kill -9`.
+ */
+import type { PathRewrite } from './types'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as process from 'node:process'
+import { ensureDaemonRunning } from './daemon'
+import { log } from './logger'
+import { getRegistryDir, isValidId, removeEntry, writeEntry } from './registry'
+import { debugLog } from './utils'
+
+export interface DaemonRunnerProxy {
+  id?: string
+  from: string
+  to: string
+  cleanUrls?: boolean
+  changeOrigin?: boolean
+  pathRewrites?: PathRewrite[]
+}
+
+export interface DaemonRunnerOptions {
+  proxies: DaemonRunnerProxy[]
+  verbose?: boolean
+  /** Override the registry dir (tests). Defaults to `~/.stacks/rpx/registry.d`. */
+  registryDir?: string
+  /** Override the rpx state dir (tests). Defaults to `~/.stacks/rpx`. */
+  rpxDir?: string
+  /**
+   * Skip the blocking await + signal handlers. Tests use this to register
+   * entries, verify, and tear down without keeping the test runner alive.
+   */
+  detached?: boolean
+  /** Override the daemon spawn command (tests). */
+  spawnCommand?: string[]
+}
+
+/**
+ * Sanitize an arbitrary `to` host into a valid registry id. Drops anything
+ * that isn't `[a-zA-Z0-9._-]`, collapses runs to a single dash, and trims
+ * leading/trailing dashes. Falls back to `'rpx'` if nothing's left.
+ */
+export function deriveIdFromTarget(to: string): string {
+  const cleaned = to.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 128)
+  return cleaned.length > 0 ? cleaned : 'rpx'
+}
+
+/**
+ * Register every proxy with the daemon and (unless `detached`) block until a
+ * shutdown signal arrives. Throws if any id collides or the daemon fails to
+ * spawn.
+ */
+export async function runViaDaemon(opts: DaemonRunnerOptions): Promise<void> {
+  if (opts.proxies.length === 0)
+    throw new Error('runViaDaemon: no proxies provided')
+
+  const verbose = opts.verbose ?? false
+  const registryDir = opts.registryDir
+  const ids = new Set<string>()
+
+  // Resolve and validate all ids up front so we don't half-register and bail.
+  const resolved = opts.proxies.map((p) => {
+    const id = p.id ?? deriveIdFromTarget(p.to)
+    if (!isValidId(id))
+      throw new Error(`invalid registry id "${id}" derived from to="${p.to}"`)
+    if (ids.has(id))
+      throw new Error(`duplicate registry id "${id}" — set an explicit \`id\` on one of the proxies`)
+    ids.add(id)
+    return { ...p, id }
+  })
+
+  for (const p of resolved) {
+    await writeEntry({
+      id: p.id,
+      from: p.from,
+      to: p.to,
+      pid: process.pid,
+      cwd: process.cwd(),
+      createdAt: new Date().toISOString(),
+      cleanUrls: p.cleanUrls,
+      changeOrigin: p.changeOrigin,
+      pathRewrites: p.pathRewrites,
+    }, registryDir, verbose)
+  }
+
+  const result = await ensureDaemonRunning({
+    rpxDir: opts.rpxDir,
+    verbose,
+    spawnCommand: opts.spawnCommand,
+  })
+
+  for (const p of resolved)
+    log.success(`https://${p.to}  →  ${p.from}`)
+  log.info(`(via rpx daemon pid=${result.pid}; \`rpx daemon:status\` to inspect)`)
+
+  if (opts.detached)
+    return
+
+  // Cleanup registry entries on shutdown so the daemon's routing table reflects
+  // reality immediately (its PID-GC would catch us eventually, but this is
+  // faster and avoids a stale-route window).
+  let cleaned = false
+  const dirForCleanup = registryDir ?? getRegistryDir()
+  const idsForCleanup = resolved.map(p => p.id)
+
+  const cleanup = async (): Promise<void> => {
+    if (cleaned)
+      return
+    cleaned = true
+    for (const id of idsForCleanup) {
+      await removeEntry(id, registryDir, verbose).catch((err) => {
+        debugLog('runner', `removeEntry(${id}) failed: ${err}`, verbose)
+      })
+    }
+  }
+
+  const onSignal = (sig: NodeJS.Signals): void => {
+    debugLog('runner', `received ${sig}, unregistering ${idsForCleanup.length} entries`, verbose)
+    cleanup().finally(() => process.exit(0))
+  }
+  process.once('SIGINT', onSignal)
+  process.once('SIGTERM', onSignal)
+
+  // Last-resort sync cleanup if the process exits without our signal handlers
+  // running (e.g. a thrown uncaught exception or `process.exit()` from elsewhere).
+  process.once('exit', () => {
+    if (cleaned)
+      return
+    for (const id of idsForCleanup) {
+      try {
+        fs.unlinkSync(path.join(dirForCleanup, `${id}.json`))
+      }
+      catch {}
+    }
+  })
+
+  // Park forever; signal handlers do the actual exiting.
+  await new Promise<void>(() => {})
+}