@stacksjs/rpx 0.11.18 → 0.11.20

package/src/proxy-handler.ts

@@ -1,315 +0,0 @@
-/**
- * The request handlers used by the shared :443 server. Both the in-process
- * multi-proxy mode in `start.ts` and the long-running daemon delegate to this
- * module so routing semantics stay in one place.
- *
- * Routes are looked up via a caller-supplied `getRoute(hostname)` callback.
- * The callback indirection lets each caller use whatever data structure makes
- * sense (a fixed Map at startup, or a hot-swappable registry view) without
- * coupling this module to either.
- *
- * Three transports are supported per route:
- *   - HTTP(S) proxying via `fetch()` to an upstream `host:port`.
- *   - WebSocket proxying via `server.upgrade()` + an upstream `WebSocket`.
- *   - Static file serving from a local directory (`route.static`).
- */
-import type { ServerWebSocket } from 'bun'
-import type { ResolvedStaticRoute } from './static-files'
-import type { PathRewrite } from './types'
-import { serveStaticFile } from './static-files'
-import { debugLog, resolvePathRewrite } from './utils'
-
-export interface ProxyRoute {
-  /**
-   * Upstream `host:port` to forward requests to (e.g. `localhost:5173`).
-   * Optional when `static` is set.
-   */
-  sourceHost?: string
-  /** Strip `.html` suffix and 301 to clean URLs. */
-  cleanUrls?: boolean
-  /** Set the `origin` header to the target. */
-  changeOrigin?: boolean
-  /** Per-route path rewrites (vite/nginx-style prefix routing). */
-  pathRewrites?: PathRewrite[]
-  /** When set, serve files from a local directory instead of proxying. */
-  static?: ResolvedStaticRoute
-  /**
-   * Path prefix this route is mounted under (e.g. `/docs`). Used together with
-   * {@link stripBasePathPrefix} to map request paths to the target. `/` (the
-   * host default) is a no-op.
-   */
-  basePath?: string
-  /**
-   * Whether to strip {@link basePath} from the request pathname before
-   * resolving the target.
-   *
-   * - Static routes default to `true`: a directory mounted at `/docs` serves
-   *   its own `index.html` for `/docs` and `<root>/guide` for `/docs/guide`.
-   * - Proxy routes default to `false`: most apps own their namespace (an app
-   *   mounted at `/api` expects to still see `/api/...`), matching rpx's
-   *   `PathRewrite.stripPrefix` default and nginx `proxy_pass` (no trailing
-   *   slash) behavior.
-   *
-   * When unset, the per-transport default above applies.
-   */
-  stripBasePathPrefix?: boolean
-}
-
-/**
- * Resolve a route for an incoming request. `pathname` enables path-based
- * routing within a host (e.g. `/api/*` → app, `/docs*` → static dir). Callers
- * that only route by host can ignore the second argument — it's optional so
- * existing host-only `getRoute` callbacks remain valid.
- */
-export type GetRoute = (hostname: string, pathname: string) => ProxyRoute | undefined
-
-export type ProxyFetchHandler = (req: Request, server?: ProxyServer) => Promise<Response | undefined>
-
-/** Minimal shape of the Bun server needed for WebSocket upgrades. */
-export interface ProxyServer {
-  // Loose `any` so it structurally accepts Bun's `Server<WebSocketData>` for
-  // any data generic (the daemon/start callers parameterize differently).
-  upgrade: (req: Request, options?: { data?: any, headers?: any }) => boolean
-}
-
-/** Data attached to an upgraded client socket so the ws handler can dial upstream. */
-interface WsData {
-  targetUrl: string
-  forwardHeaders: Record<string, string>
-}
-
-/** Per-socket state: the upstream client + a buffer for early client frames. */
-interface WsState {
-  upstream: WebSocket
-  upstreamOpen: boolean
-  pending: Array<string | ArrayBufferLike | Uint8Array>
-}
-
-const HOP_BY_HOP = new Set([
-  'connection',
-  'keep-alive',
-  'proxy-authenticate',
-  'proxy-authorization',
-  'te',
-  'trailer',
-  'transfer-encoding',
-  'upgrade',
-  'sec-websocket-key',
-  'sec-websocket-version',
-  'sec-websocket-extensions',
-])
-
-function extractHostname(req: Request): string {
-  const hostHeader = req.headers.get('host') || ''
-  // Strip port (`stacks.localhost:443` → `stacks.localhost`).
-  return hostHeader.split(':')[0]
-}
-
-/**
- * Strip the route's mount prefix (`basePath`) from a request pathname so a
- * target mounted under `/docs` sees `/` for `/docs` and `/guide` for
- * `/docs/guide`. A `/` (or empty) base strips nothing. The result always keeps
- * a leading `/`.
- */
-export function stripBasePath(pathname: string, basePath?: string): string {
-  if (!basePath || basePath === '/')
-    return pathname
-  if (pathname === basePath)
-    return '/'
-  if (pathname.startsWith(`${basePath}/`)) {
-    const rest = pathname.slice(basePath.length)
-    return rest === '' ? '/' : rest
-  }
-  return pathname
-}
-
-/**
- * Resolve the upstream target (`host` + `path`) for a request against a route,
- * applying any matching path rewrite.
- */
-function resolveTarget(req: Request, route: ProxyRoute, verbose?: boolean): { targetHost: string, targetPath: string, search: string } {
-  const url = new URL(req.url)
-  let targetHost = route.sourceHost ?? ''
-  // Proxy backends preserve their mount prefix by default (most apps own their
-  // `/api` namespace), opting in to stripping via `stripBasePathPrefix`.
-  // Explicit `pathRewrites` still apply on top of this.
-  const stripBase = route.stripBasePathPrefix ?? false
-  let targetPath = stripBase ? stripBasePath(url.pathname, route.basePath) : url.pathname
-
-  const rewriteMatch = resolvePathRewrite(targetPath, route.pathRewrites)
-  if (rewriteMatch) {
-    targetHost = rewriteMatch.targetHost
-    targetPath = rewriteMatch.targetPath
-    debugLog('request', `Path rewrite: ${url.pathname} → ${targetHost}${targetPath}`, verbose)
-  }
-
-  return { targetHost, targetPath, search: url.search }
-}
-
-/**
- * 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. When a request is a WebSocket upgrade and `server` is supplied, it
- * is upgraded (returns `undefined` so Bun completes the handshake) and the
- * traffic is handled by the `websocket` handler from {@link createProxyWebSocketHandler}.
- */
-export function createProxyFetchHandler(getRoute: GetRoute, verbose?: boolean): ProxyFetchHandler {
-  return async (req: Request, server?: ProxyServer): Promise<Response | undefined> => {
-    const url = new URL(req.url)
-    const hostname = extractHostname(req)
-
-    const route = getRoute(hostname, url.pathname)
-    if (!route) {
-      debugLog('request', `No route found for host: ${hostname}`, verbose)
-      return new Response(`No proxy configured for ${hostname}`, { status: 404 })
-    }
-
-    // Static file serving short-circuits everything else. Strip the route's
-    // mount prefix (default for static) so a dir mounted at `/docs` serves its
-    // own root for `/docs`.
-    if (route.static) {
-      const strip = route.stripBasePathPrefix ?? true
-      const staticPath = strip ? stripBasePath(url.pathname, route.basePath) : url.pathname
-      return serveStaticFile(staticPath, route.static)
-    }
-
-    // WebSocket upgrade: hand the socket to Bun and dial the upstream on open.
-    if (req.headers.get('upgrade')?.toLowerCase() === 'websocket') {
-      if (!server || !route.sourceHost)
-        return new Response('WebSocket upgrade not supported here', { status: 400 })
-
-      const { targetHost, targetPath, search } = resolveTarget(req, route, verbose)
-      const targetUrl = `ws://${targetHost}${targetPath}${search}`
-
-      const forwardHeaders: Record<string, string> = {}
-      for (const [k, v] of req.headers) {
-        if (!HOP_BY_HOP.has(k.toLowerCase()) && k.toLowerCase() !== 'host')
-          forwardHeaders[k] = v
-      }
-      forwardHeaders.host = targetHost
-      forwardHeaders['x-forwarded-for'] = '127.0.0.1'
-      forwardHeaders['x-forwarded-proto'] = 'https'
-      forwardHeaders['x-forwarded-host'] = hostname
-
-      const data: WsData = { targetUrl, forwardHeaders }
-      const ok = server.upgrade(req, { data })
-      if (ok) {
-        debugLog('ws', `upgraded ${hostname}${targetPath} → ${targetUrl}`, verbose)
-        return undefined
-      }
-      return new Response('WebSocket upgrade failed', { status: 400 })
-    }
-
-    if (!route.sourceHost)
-      return new Response(`No upstream configured for ${hostname}`, { status: 502 })
-
-    const { targetHost, targetPath, search } = resolveTarget(req, route, verbose)
-    const targetUrl = `http://${targetHost}${targetPath}${search}`
-
-    try {
-      const headers = new Headers(req.headers)
-      headers.set('host', targetHost)
-      if (route.changeOrigin)
-        headers.set('origin', `http://${route.sourceHost}`)
-      headers.set('x-forwarded-for', '127.0.0.1')
-      headers.set('x-forwarded-proto', 'https')
-      headers.set('x-forwarded-host', hostname)
-
-      const response = await fetch(targetUrl, {
-        method: req.method,
-        headers,
-        body: req.body,
-        redirect: 'manual',
-      })
-
-      // Strip `.html` and 301 to the clean URL when enabled.
-      if (route.cleanUrls && url.pathname.endsWith('.html')) {
-        const cleanPath = url.pathname.replace(/\.html$/, '')
-        return new Response(null, {
-          status: 301,
-          headers: { Location: cleanPath },
-        })
-      }
-
-      const responseHeaders = new Headers(response.headers)
-      return new Response(response.body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-      })
-    }
-    catch (err) {
-      debugLog('request', `Proxy error for ${hostname}: ${err}`, verbose)
-      return new Response(`Proxy Error: ${err}`, { status: 502 })
-    }
-  }
-}
-
-/**
- * Build the `websocket` handler block for Bun.serve. It opens an upstream
- * `WebSocket` per client socket, buffers client→upstream frames until the
- * upstream connection is open, and pipes messages, closes and errors in both
- * directions with a clean teardown.
- */
-export function createProxyWebSocketHandler(verbose?: boolean) {
-  const state = new WeakMap<ServerWebSocket<WsData>, WsState>()
-
-  return {
-    open(ws: ServerWebSocket<WsData>): void {
-      const { targetUrl, forwardHeaders } = ws.data
-      let upstream: WebSocket
-      try {
-        // Bun's WebSocket accepts a `headers` option (control-channel auth etc.).
-        upstream = new WebSocket(targetUrl, { headers: forwardHeaders } as any)
-      }
-      catch (err) {
-        debugLog('ws', `failed to open upstream ${targetUrl}: ${err}`, verbose)
-        ws.close(1011, 'upstream connect failed')
-        return
-      }
-      upstream.binaryType = 'arraybuffer'
-      const st: WsState = { upstream, upstreamOpen: false, pending: [] }
-      state.set(ws, st)
-
-      upstream.addEventListener('open', () => {
-        st.upstreamOpen = true
-        for (const frame of st.pending)
-          upstream.send(frame as any)
-        st.pending = []
-      })
-      upstream.addEventListener('message', (ev: MessageEvent) => {
-        // Forward both binary (ArrayBuffer) and text frames to the client.
-        ws.send(ev.data as any)
-      })
-      upstream.addEventListener('close', (ev: CloseEvent) => {
-        try { ws.close(ev.code || 1000, ev.reason || '') }
-        catch { /* already closing */ }
-      })
-      upstream.addEventListener('error', () => {
-        debugLog('ws', `upstream error for ${targetUrl}`, verbose)
-        try { ws.close(1011, 'upstream error') }
-        catch { /* already closing */ }
-      })
-    },
-
-    message(ws: ServerWebSocket<WsData>, message: string | Buffer): void {
-      const st = state.get(ws)
-      if (!st)
-        return
-      const frame = typeof message === 'string' ? message : new Uint8Array(message)
-      if (st.upstreamOpen)
-        st.upstream.send(frame as any)
-      else
-        st.pending.push(frame)
-    },
-
-    close(ws: ServerWebSocket<WsData>, code: number, reason: string): void {
-      const st = state.get(ws)
-      if (!st)
-        return
-      state.delete(ws)
-      try { st.upstream.close(code || 1000, reason || '') }
-      catch { /* already closed */ }
-    },
-  }
-}

package/src/registry.ts

@@ -1,366 +0,0 @@
-/**
- * Registry of currently-active rpx proxies.
- *
- * Each running upstream (e.g. a `./buddy dev` invocation) writes a small JSON
- * file into `~/.stacks/rpx/registry.d/<id>.json` describing where to forward
- * traffic. The rpx daemon watches this directory and rebuilds its routing
- * table whenever entries appear, change, or disappear.
- *
- * Design choices worth knowing about:
- *   - One file per entry → no shared-file locking, no merge conflicts.
- *   - Atomic write via temp file + rename → readers never see partial JSON.
- *   - Each entry carries the writer's PID so the daemon can GC files left
- *     behind by a writer that was killed -9.
- *   - `id` is validated against a strict charset to keep it from escaping
- *     the registry directory.
- */
-import type { PathRewrite, StaticRouteConfig } from './types'
-import * as fs from 'node:fs'
-import * as fsp from 'node:fs/promises'
-import { homedir } from 'node:os'
-import * as path from 'node:path'
-import * as process from 'node:process'
-import { debugLog } from './utils'
-
-export interface RegistryEntry {
-  id: string
-  /** Upstream `host:port`. Optional when `static` is set. */
-  from?: string
-  to: string
-  /**
-   * Optional path prefix this route owns under the host `to` (e.g. `'/api'`).
-   * Enables several routes to share one host, each claiming a different path
-   * (`/api` → app, `/docs` → static dir, `/` → public). Omitted (or `'/'`)
-   * means the route is the host default and behaves exactly like host-only
-   * routing did before path routing existed.
-   */
-  path?: string
-  /**
-   * Optional. PID of the long-running process that owns this entry. When set,
-   * the daemon's PID-GC reaps the entry the moment that process dies. Omit
-   * (or set to `undefined`) for manually-managed entries created via
-   * `rpx register` — those persist until explicit `rpx unregister`.
-   */
-  pid?: number
-  cwd?: string
-  createdAt: string
-  pathRewrites?: PathRewrite[]
-  cleanUrls?: boolean
-  changeOrigin?: boolean
-  /** Serve a local directory for this route instead of proxying. */
-  static?: string | StaticRouteConfig
-}
-
-const ID_PATTERN = /^[a-zA-Z0-9._-]+$/
-
-/**
- * Default location for the registry directory. The daemon's PID file and log
- * sit alongside it under `~/.stacks/rpx/`.
- */
-export function getRegistryDir(): string {
-  return path.join(homedir(), '.stacks', 'rpx', 'registry.d')
-}
-
-/**
- * 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 function isValidId(id: string): boolean {
-  return typeof id === 'string' && id.length > 0 && id.length <= 128 && ID_PATTERN.test(id)
-}
-
-function entryPath(dir: string, id: string): string {
-  if (!isValidId(id))
-    throw new Error(`invalid registry id: ${JSON.stringify(id)}`)
-  return path.join(dir, `${id}.json`)
-}
-
-/**
- * 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 function isPidAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false
-  try {
-    process.kill(pid, 0)
-    return true
-  }
-  catch (err) {
-    return (err as NodeJS.ErrnoException).code === 'EPERM'
-  }
-}
-
-function isValidEntry(value: unknown): value is RegistryEntry {
-  if (!value || typeof value !== 'object')
-    return false
-  const e = value as Partial<RegistryEntry>
-  // pid is optional. When present it must be a positive integer; when absent
-  // (manual entries from `rpx register`) the daemon's PID-GC skips it.
-  const pidOk = e.pid === undefined
-    || (typeof e.pid === 'number' && Number.isInteger(e.pid) && e.pid > 0)
-  // A route forwards to an upstream (`from`) OR serves files (`static`).
-  const hasFrom = typeof e.from === 'string' && e.from.length > 0
-  const hasStatic = typeof e.static === 'string'
-    || (!!e.static && typeof e.static === 'object' && typeof (e.static as StaticRouteConfig).dir === 'string')
-  // path is optional; when present it must be a string.
-  const pathOk = e.path === undefined || typeof e.path === 'string'
-  return (
-    typeof e.id === 'string' && isValidId(e.id)
-    && (hasFrom || hasStatic)
-    && typeof e.to === 'string' && e.to.length > 0
-    && pathOk
-    && pidOk
-    && typeof e.createdAt === 'string'
-  )
-}
-
-async function ensureDir(dir: string): Promise<void> {
-  await fsp.mkdir(dir, { recursive: true })
-}
-
-/**
- * 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 async function writeEntry(entry: RegistryEntry, dir: string = getRegistryDir(), verbose?: boolean): Promise<void> {
-  if (!isValidEntry(entry))
-    throw new Error(`invalid registry entry: ${JSON.stringify(entry)}`)
-
-  await ensureDir(dir)
-  const finalPath = entryPath(dir, entry.id)
-  const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`
-  const json = JSON.stringify(entry, null, 2)
-
-  try {
-    await fsp.writeFile(tmpPath, json, { encoding: 'utf8', mode: 0o644 })
-    await fsp.rename(tmpPath, finalPath)
-    debugLog('registry', `wrote entry ${entry.id} → ${finalPath}`, verbose)
-  }
-  catch (err) {
-    // Best-effort cleanup of the temp file if the rename never landed.
-    await fsp.unlink(tmpPath).catch(() => {})
-    throw err
-  }
-}
-
-/**
- * Remove an entry by id. No-op if the file is already gone.
- */
-export async function removeEntry(id: string, dir: string = getRegistryDir(), verbose?: boolean): Promise<void> {
-  const target = entryPath(dir, id)
-  try {
-    await fsp.unlink(target)
-    debugLog('registry', `removed entry ${id}`, verbose)
-  }
-  catch (err) {
-    if ((err as NodeJS.ErrnoException).code !== 'ENOENT')
-      throw err
-  }
-}
-
-/**
- * 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 async function readEntry(id: string, dir: string = getRegistryDir(), verbose?: boolean): Promise<RegistryEntry | null> {
-  const target = entryPath(dir, id)
-  try {
-    const raw = await fsp.readFile(target, 'utf8')
-    const parsed = JSON.parse(raw)
-    if (!isValidEntry(parsed)) {
-      debugLog('registry', `entry ${id} failed validation, removing`, verbose)
-      await fsp.unlink(target).catch(() => {})
-      return null
-    }
-    return parsed
-  }
-  catch (err) {
-    const code = (err as NodeJS.ErrnoException).code
-    if (code === 'ENOENT')
-      return null
-    if (err instanceof SyntaxError) {
-      debugLog('registry', `entry ${id} has invalid JSON, removing`, verbose)
-      await fsp.unlink(target).catch(() => {})
-      return null
-    }
-    throw err
-  }
-}
-
-/**
- * Read all entries from the registry directory. Malformed files are pruned.
- * This does NOT GC stale PIDs — call `gcStaleEntries` for that explicitly.
- */
-export async function readAll(dir: string = getRegistryDir(), verbose?: boolean): Promise<RegistryEntry[]> {
-  let names: string[]
-  try {
-    names = await fsp.readdir(dir)
-  }
-  catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT')
-      return []
-    throw err
-  }
-
-  const out: RegistryEntry[] = []
-  for (const name of names) {
-    if (!name.endsWith('.json'))
-      continue
-    const id = name.slice(0, -'.json'.length)
-    if (!isValidId(id))
-      continue
-    const entry = await readEntry(id, dir, verbose)
-    if (entry)
-      out.push(entry)
-  }
-  return out
-}
-
-/**
- * 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 async function gcStaleEntries(dir: string = getRegistryDir(), verbose?: boolean): Promise<number> {
-  const entries = await readAll(dir, verbose)
-  let removed = 0
-  for (const entry of entries) {
-    // Manually-managed entries (no pid) opt out of PID-GC. The user is
-    // responsible for `rpx unregister` when they're done.
-    if (entry.pid === undefined)
-      continue
-    if (!isPidAlive(entry.pid)) {
-      debugLog('registry', `GC: pid ${entry.pid} for ${entry.id} is dead, removing`, verbose)
-      await removeEntry(entry.id, dir, verbose).catch(() => {})
-      removed++
-    }
-  }
-  return removed
-}
-
-export interface WatchHandle {
-  close: () => void
-}
-
-export interface WatchOptions {
-  debounceMs?: number
-  pollMs?: number
-  verbose?: boolean
-}
-
-/**
- * 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 function watchRegistry(
-  onChange: (entries: RegistryEntry[]) => void | Promise<void>,
-  opts: WatchOptions & { dir?: string } = {},
-): WatchHandle {
-  const dir = opts.dir ?? getRegistryDir()
-  const debounceMs = opts.debounceMs ?? 100
-  const pollMs = opts.pollMs ?? Math.max(debounceMs * 2, 250)
-  const verbose = opts.verbose
-
-  // Create the dir up front so fs.watch has something to attach to.
-  fs.mkdirSync(dir, { recursive: true })
-
-  let pending: ReturnType<typeof setTimeout> | null = null
-  let closed = false
-  let lastSignature: string | null = null
-  let pollInFlight = false
-
-  const signatureFor = (entries: RegistryEntry[]): string => {
-    return JSON.stringify(
-      entries
-        .map(entry => ({
-          id: entry.id,
-          from: entry.from,
-          to: entry.to,
-          path: entry.path,
-          pid: entry.pid,
-          pathRewrites: entry.pathRewrites,
-          cleanUrls: entry.cleanUrls,
-          changeOrigin: entry.changeOrigin,
-          static: entry.static,
-        }))
-        .sort((a, b) => a.id.localeCompare(b.id)),
-    )
-  }
-
-  const fire = () => {
-    pending = null
-    if (closed)
-      return
-    readAll(dir, verbose)
-      .then((entries) => {
-        lastSignature = signatureFor(entries)
-        return onChange(entries)
-      })
-      .catch((err) => {
-        debugLog('registry', `watcher onChange failed: ${err}`, verbose)
-      })
-  }
-
-  const schedule = () => {
-    if (closed)
-      return
-    if (pending)
-      clearTimeout(pending)
-    pending = setTimeout(fire, debounceMs)
-  }
-
-  const poll = () => {
-    if (closed || pollInFlight)
-      return
-
-    pollInFlight = true
-    readAll(dir, verbose)
-      .then((entries) => {
-        const signature = signatureFor(entries)
-        if (signature !== lastSignature)
-          schedule()
-      })
-      .catch((err) => {
-        debugLog('registry', `watcher poll failed: ${err}`, verbose)
-      })
-      .finally(() => {
-        pollInFlight = false
-      })
-  }
-
-  const pollInterval = setInterval(poll, pollMs)
-
-  const watcher = fs.watch(dir, { persistent: true }, (_eventType, filename) => {
-    // Ignore temp files from our own atomic-write protocol.
-    if (filename && /\.tmp\.\d+\.\d+$/.test(filename))
-      return
-    schedule()
-  })
-
-  watcher.on('error', (err) => {
-    debugLog('registry', `watcher error: ${err}`, verbose)
-  })
-
-  // Fire once on startup so the daemon picks up entries that already exist.
-  schedule()
-
-  return {
-    close: () => {
-      closed = true
-      if (pending)
-        clearTimeout(pending)
-      clearInterval(pollInterval)
-      watcher.close()
-    },
-  }
-}