vite-plugin-rpx 0.11.22 → 0.11.24

package/dist/index.js

@@ -22443,6 +22443,151 @@ var init_https = __esm(() => {
   SHARED_DEV_HOST_CERT_PATH = join12(homedir8(), ".stacks", "ssl", "rpx.localhost.crt");
 });
 
+// ../rpx/src/load-balancer.ts
+function resolveHealthCheckConfig(config6) {
+  return {
+    enabled: config6?.enabled ?? false,
+    path: config6?.path ?? DEFAULT_HEALTH_CHECK_PATH,
+    interval: config6?.interval ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS,
+    timeout: config6?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT_MS,
+    healthyThreshold: config6?.healthyThreshold ?? DEFAULT_HEALTHY_THRESHOLD,
+    unhealthyThreshold: config6?.unhealthyThreshold ?? DEFAULT_UNHEALTHY_THRESHOLD
+  };
+}
+function normalizeUpstreams(from) {
+  const list = Array.isArray(from) ? from : [from];
+  return list.map((entry) => {
+    const target = typeof entry === "string" ? { url: entry } : entry;
+    return {
+      url: target.url,
+      weight: target.weight && target.weight > 0 ? target.weight : 1,
+      healthy: true,
+      activeConnections: 0,
+      consecutiveFailures: 0,
+      consecutiveSuccesses: 0
+    };
+  });
+}
+function primaryUpstreamUrl(from) {
+  if (!from)
+    return "localhost:5173";
+  const first = Array.isArray(from) ? from[0] : from;
+  if (!first)
+    return "localhost:5173";
+  return typeof first === "string" ? first : first.url;
+}
+function createUpstreamPool(from, lbConfig) {
+  return {
+    upstreams: normalizeUpstreams(from),
+    strategy: lbConfig?.strategy ?? "round-robin",
+    healthCheck: resolveHealthCheckConfig(lbConfig?.healthCheck),
+    cursor: 0,
+    wrrCurrentWeights: [],
+    healthCheckTimer: null
+  };
+}
+function healthyUpstreams(pool) {
+  const healthy = pool.upstreams.filter((u2) => u2.healthy);
+  if (healthy.length === 0 && pool.upstreams.length === 1)
+    return pool.upstreams;
+  return healthy;
+}
+function selectRoundRobin(pool, candidates) {
+  const idx = pool.cursor % candidates.length;
+  pool.cursor = (pool.cursor + 1) % candidates.length;
+  return candidates[idx];
+}
+function selectWeightedRoundRobin(pool, candidates) {
+  if (pool.wrrCurrentWeights.length !== candidates.length)
+    pool.wrrCurrentWeights = candidates.map(() => 0);
+  const totalWeight = candidates.reduce((sum, u2) => sum + u2.weight, 0);
+  let bestIdx = 0;
+  for (let i2 = 0;i2 < candidates.length; i2++) {
+    pool.wrrCurrentWeights[i2] += candidates[i2].weight;
+    if (pool.wrrCurrentWeights[i2] > pool.wrrCurrentWeights[bestIdx])
+      bestIdx = i2;
+  }
+  pool.wrrCurrentWeights[bestIdx] -= totalWeight;
+  return candidates[bestIdx];
+}
+function selectLeastConnections(candidates) {
+  let best = candidates[0];
+  for (let i2 = 1;i2 < candidates.length; i2++) {
+    if (candidates[i2].activeConnections < best.activeConnections)
+      best = candidates[i2];
+  }
+  return best;
+}
+function selectUpstream(pool) {
+  const candidates = healthyUpstreams(pool);
+  if (candidates.length === 0)
+    return;
+  if (candidates.length === 1)
+    return candidates[0];
+  switch (pool.strategy) {
+    case "weighted-round-robin":
+      return selectWeightedRoundRobin(pool, candidates);
+    case "least-connections":
+      return selectLeastConnections(candidates);
+    case "round-robin":
+    default:
+      return selectRoundRobin(pool, candidates);
+  }
+}
+function markSuccess(pool, upstream) {
+  upstream.consecutiveFailures = 0;
+  upstream.consecutiveSuccesses += 1;
+  if (!upstream.healthy && upstream.consecutiveSuccesses >= pool.healthCheck.healthyThreshold)
+    upstream.healthy = true;
+}
+function markFailure(pool, upstream) {
+  upstream.consecutiveSuccesses = 0;
+  upstream.consecutiveFailures += 1;
+  if (upstream.healthy && upstream.consecutiveFailures >= pool.healthCheck.unhealthyThreshold)
+    upstream.healthy = false;
+}
+function splitHostPort(hostPort) {
+  const idx = hostPort.lastIndexOf(":");
+  if (idx === -1)
+    return { hostname: hostPort, port: 80 };
+  const port = Number(hostPort.slice(idx + 1));
+  return { hostname: hostPort.slice(0, idx), port: Number.isFinite(port) ? port : 80 };
+}
+async function probeUpstream(pool, upstream) {
+  const { hostname, port } = splitHostPort(upstream.url);
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), pool.healthCheck.timeout);
+  try {
+    const res = await fetch(`http://${hostname}:${port}${pool.healthCheck.path}`, {
+      signal: controller.signal,
+      redirect: "manual"
+    });
+    res.body?.cancel().catch(() => {});
+    markSuccess(pool, upstream);
+  } catch {
+    markFailure(pool, upstream);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function startHealthChecks(pool) {
+  if (!pool.healthCheck.enabled || pool.healthCheckTimer || pool.upstreams.length < 2)
+    return;
+  const timer = setInterval(() => {
+    for (const upstream of pool.upstreams)
+      probeUpstream(pool, upstream);
+  }, pool.healthCheck.interval);
+  timer.unref?.();
+  pool.healthCheckTimer = timer;
+}
+function stopHealthChecks(pool) {
+  if (pool.healthCheckTimer) {
+    clearInterval(pool.healthCheckTimer);
+    pool.healthCheckTimer = null;
+  }
+}
+var DEFAULT_HEALTHY_THRESHOLD = 2, DEFAULT_UNHEALTHY_THRESHOLD = 3, DEFAULT_HEALTH_CHECK_PATH = "/", DEFAULT_HEALTH_CHECK_INTERVAL_MS = 1e4, DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 2000;
+
 // ../rpx/src/auth.ts
 import { createHash, timingSafeEqual } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -23542,8 +23687,15 @@ function stripBasePath(pathname, basePath) {
   }
   return pathname;
 }
-function resolveTarget(pathname, route, verbose) {
-  let targetHost = route.sourceHost ?? "";
+function pickUpstream(route) {
+  if (route.upstreamPool)
+    return selectUpstream(route.upstreamPool);
+  if (route.sourceHost)
+    return { url: route.sourceHost, weight: 1, healthy: true, activeConnections: 0, consecutiveFailures: 0, consecutiveSuccesses: 0 };
+  return;
+}
+function resolveTarget(pathname, route, upstream, verbose) {
+  let targetHost = upstream?.url ?? route.sourceHost ?? "";
   const stripBase = route.stripBasePathPrefix ?? false;
   let targetPath = stripBase ? stripBasePath(pathname, route.basePath) : pathname;
   const rewriteMatch = resolvePathRewrite(targetPath, route.pathRewrites);
@@ -23598,9 +23750,10 @@ function createProxyFetchHandler(getRoute, verbose, onNoRoute) {
       return serveStaticFile(staticPath, route.static);
     }
     if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
-      if (!server || !route.sourceHost)
+      const wsUpstream = pickUpstream(route);
+      if (!server || !wsUpstream)
         return new Response("WebSocket upgrade not supported here", { status: 400 });
-      const { targetHost: targetHost2, targetPath: targetPath2 } = resolveTarget(pathname, route, verbose);
+      const { targetHost: targetHost2, targetPath: targetPath2 } = resolveTarget(pathname, route, wsUpstream, verbose);
       const targetUrl = `ws://${targetHost2}${targetPath2}${search}`;
       const forwardHeaders = {};
       for (const [k2, v2] of req.headers) {
@@ -23619,8 +23772,10 @@ function createProxyFetchHandler(getRoute, verbose, onNoRoute) {
       }
       return new Response("WebSocket upgrade failed", { status: 400 });
     }
-    if (!route.sourceHost)
+    const upstream = pickUpstream(route);
+    if (!upstream) {
       return new Response(`No upstream configured for ${hostname}`, { status: 502 });
+    }
     if (route.cleanUrls && pathname.endsWith(".html")) {
       const cleanPath = pathname.replace(/\.html$/, "");
       return new Response(null, {
@@ -23628,11 +23783,14 @@ function createProxyFetchHandler(getRoute, verbose, onNoRoute) {
         headers: { Location: cleanPath }
       });
     }
-    const { targetHost, targetPath } = resolveTarget(pathname, route, verbose);
-    const originOverride = route.changeOrigin ? `http://${route.sourceHost}` : undefined;
+    const { targetHost, targetPath } = resolveTarget(pathname, route, upstream, verbose);
+    const originOverride = route.changeOrigin ? `http://${targetHost}` : undefined;
     const hasBody = req.body != null && req.method !== "GET" && req.method !== "HEAD";
+    const pool = route.upstreamPool;
+    if (pool)
+      upstream.activeConnections++;
     try {
-      return await proxyViaPool({
+      const res = await proxyViaPool({
         hostPort: targetHost,
         method: req.method,
         path: `${targetPath}${search}`,
@@ -23641,9 +23799,14 @@ function createProxyFetchHandler(getRoute, verbose, onNoRoute) {
         originOverride,
         body: req.body
       });
+      if (pool)
+        markSuccess(pool, upstream);
+      return res;
     } catch (err) {
       if (err === TIMEOUT) {
         debugLog("request", `Upstream timeout for ${hostname}`, verbose);
+        if (pool)
+          markFailure(pool, upstream);
         return new Response("Gateway Timeout", { status: 504 });
       }
       if (err === POOL_BUSY) {
@@ -23659,19 +23822,29 @@ function createProxyFetchHandler(getRoute, verbose, onNoRoute) {
           headers.set("x-forwarded-host", hostname);
           if (originOverride !== undefined)
             headers.set("origin", originOverride);
-          return await fetch(`http://${targetHost}${targetPath}${search}`, {
+          const res = await fetch(`http://${targetHost}${targetPath}${search}`, {
             method: req.method,
             headers,
             body: req.body,
             redirect: "manual"
           });
+          if (pool)
+            markSuccess(pool, upstream);
+          return res;
         } catch (fetchErr) {
           debugLog("request", `Proxy error for ${hostname}: ${fetchErr}`, verbose);
+          if (pool)
+            markFailure(pool, upstream);
           return new Response(`Proxy Error: ${fetchErr}`, { status: 502 });
         }
       }
       debugLog("request", `Proxy error for ${hostname}: ${err}`, verbose);
+      if (pool)
+        markFailure(pool, upstream);
       return new Response(`Proxy Error: ${err}`, { status: 502 });
+    } finally {
+      if (pool)
+        upstream.activeConnections--;
     }
   };
   return async (req, server) => {
@@ -23778,6 +23951,24 @@ var init_proxy_handler = __esm(() => {
   ]);
 });
 
+// ../rpx/src/acme-challenge.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+function readAcmeChallenge(webroot, pathname) {
+  if (!webroot || !pathname.startsWith(ACME_CHALLENGE_PREFIX2))
+    return null;
+  const token = pathname.slice(ACME_CHALLENGE_PREFIX2.length);
+  if (!token || !/^[A-Za-z0-9_-]+$/.test(token))
+    return null;
+  try {
+    return fs3.readFileSync(path3.join(webroot, token), "utf8");
+  } catch {
+    return null;
+  }
+}
+var ACME_CHALLENGE_PREFIX2 = "/.well-known/acme-challenge/";
+var init_acme_challenge = () => {};
+
 // ../rpx/src/host-match.ts
 function isWildcardPattern(pattern) {
   return pattern.startsWith("*.");
@@ -23790,10 +23981,10 @@ function matchesWildcard(hostname, pattern) {
 }
 
 // ../rpx/src/host-routes.ts
-function normalizePathPrefix(path3) {
-  if (!path3 || path3 === "/")
+function normalizePathPrefix(path4) {
+  if (!path4 || path4 === "/")
     return "/";
-  let p2 = path3.trim();
+  let p2 = path4.trim();
   if (!p2.startsWith("/"))
     p2 = `/${p2}`;
   p2 = p2.replace(/\/+$/, "");
@@ -23820,8 +24011,8 @@ function buildHostRoutes(entries) {
   const table = new Map;
   for (const [host, paths] of byHost) {
     const list = [];
-    for (const [path3, route] of paths)
-      list.push({ path: path3, route });
+    for (const [path4, route] of paths)
+      list.push({ path: path4, route });
     list.sort((a2, b2) => b2.path.length - a2.path.length);
     table.set(host, list);
   }
@@ -23860,7 +24051,7 @@ var init_host_routes = () => {};
 
 // ../rpx/src/sni.ts
 import * as fsp from "node:fs/promises";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 function serverNameFromCertFilename(filename) {
   if (!filename.endsWith(".crt"))
     return null;
@@ -23898,8 +24089,8 @@ async function buildSniTlsConfig(cfg, verbose) {
         continue;
       const base = name.slice(0, -".crt".length);
       bySrvName.set(serverName, {
-        certPath: path3.join(cfg.certsDir, name),
-        keyPath: path3.join(cfg.certsDir, `${base}.key`)
+        certPath: path4.join(cfg.certsDir, name),
+        keyPath: path4.join(cfg.certsDir, `${base}.key`)
       });
     }
   }
@@ -23921,7 +24112,7 @@ var init_sni = __esm(() => {
 
 // ../rpx/src/on-demand.ts
 import * as fsp2 from "node:fs/promises";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 function matchesAllowedSuffix(host, suffixes) {
   if (!suffixes || suffixes.length === 0)
     return false;
@@ -24072,8 +24263,8 @@ class OnDemandCertManager {
   }
   pathsFor(host) {
     return {
-      certPath: path4.join(this.certsDir, `${host}.crt`),
-      keyPath: path4.join(this.certsDir, `${host}.key`)
+      certPath: path5.join(this.certsDir, `${host}.crt`),
+      keyPath: path5.join(this.certsDir, `${host}.key`)
     };
   }
   async persist(host, certPem, keyPem) {
@@ -24232,10 +24423,10 @@ var init_port_manager = __esm(() => {
 // ../rpx/src/registry.ts
 import * as fsp3 from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import * as process23 from "node:process";
 function getRegistryDir() {
-  return path5.join(homedir9(), ".stacks", "rpx", "registry.d");
+  return path6.join(homedir9(), ".stacks", "rpx", "registry.d");
 }
 function isValidId(id) {
   return typeof id === "string" && id.length > 0 && id.length <= 128 && ID_PATTERN.test(id);
@@ -24243,7 +24434,7 @@ function isValidId(id) {
 function entryPath(dir, id) {
   if (!isValidId(id))
     throw new Error(`invalid registry id: ${JSON.stringify(id)}`);
-  return path5.join(dir, `${id}.json`);
+  return path6.join(dir, `${id}.json`);
 }
 function isPidAlive(pid2) {
   if (!Number.isInteger(pid2) || pid2 <= 0)
@@ -24260,7 +24451,7 @@ function isValidEntry(value) {
     return false;
   const e = value;
   const pidOk = e.pid === undefined || typeof e.pid === "number" && Number.isInteger(e.pid) && e.pid > 0;
-  const hasFrom = typeof e.from === "string" && e.from.length > 0;
+  const hasFrom = typeof e.from === "string" && e.from.length > 0 || Array.isArray(e.from) && e.from.length > 0;
   const hasStatic = typeof e.static === "string" || !!e.static && typeof e.static === "object" && typeof e.static.dir === "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";
@@ -24301,11 +24492,11 @@ var init_registry = __esm(() => {
 });
 
 // ../rpx/src/site-supervisor.ts
-import { closeSync as closeSync6, openSync as openSync6, readFileSync as readFileSync3 } from "node:fs";
+import { closeSync as closeSync6, openSync as openSync6, readFileSync as readFileSync4 } from "node:fs";
 import * as fsp4 from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { homedir as homedir10 } from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import * as process25 from "node:process";
 
 class SiteSupervisor {
@@ -24331,7 +24522,7 @@ class SiteSupervisor {
   constructor(opts) {
     this.resolver = opts.resolver;
     this.registryDir = opts.registryDir ?? getRegistryDir();
-    this.rpxDir = opts.rpxDir ?? path6.join(homedir10(), ".stacks", "rpx");
+    this.rpxDir = opts.rpxDir ?? path7.join(homedir10(), ".stacks", "rpx");
     this.verbose = opts.verbose ?? false;
     this.startupTimeoutMs = opts.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
     this.pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
@@ -24386,8 +24577,8 @@ class SiteSupervisor {
         ports.set(route.portEnv, port);
       }
     }
-    const logPath = path6.join(this.rpxDir, "sites", `${site.id}.log`);
-    await fsp4.mkdir(path6.dirname(logPath), { recursive: true }).catch(() => {});
+    const logPath = path7.join(this.rpxDir, "sites", `${site.id}.log`);
+    await fsp4.mkdir(path7.dirname(logPath), { recursive: true }).catch(() => {});
     const env2 = this.buildEnv(site, ports);
     let handle = null;
     let startError;
@@ -24525,7 +24716,7 @@ class SiteSupervisor {
   }
   readLogTail(state, lines = 40) {
     try {
-      const text = readFileSync3(state.logPath, "utf8");
+      const text = readFileSync4(state.logPath, "utf8");
       return text.split(`
 `).slice(-lines).join(`
 `).trim();
@@ -24683,12 +24874,12 @@ var init_site_supervisor = __esm(() => {
 // ../rpx/src/dns-state.ts
 import * as fsp5 from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 function defaultRpxDir() {
-  return path7.join(homedir11(), ".stacks", "rpx");
+  return path8.join(homedir11(), ".stacks", "rpx");
 }
 function getDnsStatePath(rpxDir = defaultRpxDir()) {
-  return path7.join(rpxDir, RPX_DNS_STATE_FILE);
+  return path8.join(rpxDir, RPX_DNS_STATE_FILE);
 }
 async function loadDnsState(rpxDir = defaultRpxDir()) {
   try {
@@ -24792,7 +24983,7 @@ __export(exports_dns, {
 });
 import dgram from "node:dgram";
 import * as fsp6 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import * as process26 from "node:process";
 function parseHeader(buffer) {
   return {
@@ -25027,7 +25218,7 @@ port ${DNS_PORT}
 `;
 }
 function resolverFilePath(basename) {
-  return path8.join(MACOS_RESOLVER_DIR, basename);
+  return path9.join(MACOS_RESOLVER_DIR, basename);
 }
 function contentLooksLikeRpxResolver(content) {
   return content.includes("127.0.0.1") && content.includes(String(DNS_PORT));
@@ -25212,13 +25403,13 @@ var init_dns = __esm(() => {
 import { spawn as nodeSpawn } from "node:child_process";
 import * as fsp7 from "node:fs/promises";
 import { homedir as homedir12 } from "node:os";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import * as process27 from "node:process";
 function getDaemonRpxDir() {
-  return path9.join(homedir12(), ".stacks", "rpx");
+  return path10.join(homedir12(), ".stacks", "rpx");
 }
 function getDaemonPidPath(rpxDir = getDaemonRpxDir()) {
-  return path9.join(rpxDir, "daemon.pid");
+  return path10.join(rpxDir, "daemon.pid");
 }
 async function readDaemonPid(rpxDir = getDaemonRpxDir()) {
   try {
@@ -25238,7 +25429,7 @@ async function releaseDaemonLock(rpxDir = getDaemonRpxDir()) {
 }
 function defaultDaemonSpawnCommand() {
   const exec = process27.execPath;
-  const interpName = path9.basename(exec).toLowerCase();
+  const interpName = path10.basename(exec).toLowerCase();
   const isInterpreter = interpName === "bun" || interpName === "node" || interpName.startsWith("bun-");
   if (isInterpreter && process27.argv[1])
     return [exec, process27.argv[1], "daemon:start"];
@@ -25292,10 +25483,12 @@ async function ensureDaemonRunning(opts = {}) {
     throw spawnError;
   throw new Error(`rpx daemon failed to start within ${timeoutMs}ms (rpxDir=${rpxDir})`);
 }
+var registryUpstreamPools;
 var init_daemon = __esm(() => {
   init_logger();
   init_https();
   init_proxy_handler();
+  init_acme_challenge();
   init_host_routes();
   init_sni();
   init_on_demand();
@@ -25306,6 +25499,7 @@ var init_daemon = __esm(() => {
   init_registry();
   init_dns();
   init_utils();
+  registryUpstreamPools = new Map;
 });
 
 // src/index.ts
@@ -25337,8 +25531,8 @@ init_daemon();
 init_logger();
 init_registry();
 init_utils();
-import * as fs3 from "node:fs";
-import * as path10 from "node:path";
+import * as fs4 from "node:fs";
+import * as path11 from "node:path";
 import * as process28 from "node:process";
 function deriveIdFromTarget(to, routePath) {
   const base = routePath && routePath !== "/" ? `${to}${routePath}` : to;
@@ -25373,7 +25567,8 @@ async function runViaDaemon(opts) {
       cleanUrls: p2.cleanUrls,
       changeOrigin: p2.changeOrigin,
       pathRewrites: p2.pathRewrites,
-      static: p2.static
+      static: p2.static,
+      loadBalancer: p2.loadBalancer
     }, registryDir, verbose);
   }
   const result = await ensureDaemonRunning({
@@ -25414,7 +25609,7 @@ async function runViaDaemon(opts) {
       return;
     for (const id of idsForCleanup) {
       try {
-        fs3.unlinkSync(path10.join(dirForCleanup, `${id}.json`));
+        fs4.unlinkSync(path11.join(dirForCleanup, `${id}.json`));
       } catch {}
     }
   });
@@ -25424,9 +25619,9 @@ async function runViaDaemon(opts) {
 // ../rpx/src/hosts.ts
 init_utils();
 import { exec } from "node:child_process";
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os2 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import * as process29 from "node:process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
@@ -25434,7 +25629,7 @@ function isLoopbackDevelopmentHost(host) {
   const normalized = host.trim().toLowerCase();
   return normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".localhost.");
 }
-var hostsFilePath = process29.platform === "win32" ? path11.join(process29.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
+var hostsFilePath = process29.platform === "win32" ? path12.join(process29.env.windir || "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
 var sudoPrivilegesAcquired = false;
 async function execSudo(command) {
   if (process29.platform === "win32")
@@ -25483,7 +25678,7 @@ async function addHosts(hosts, verbose) {
   try {
     let existingContent;
     try {
-      existingContent = await fs4.promises.readFile(hostsFilePath, "utf-8");
+      existingContent = await fs5.promises.readFile(hostsFilePath, "utf-8");
     } catch {
       debugLog("hosts", "Reading hosts file requires elevated permissions, using sudo", verbose);
       try {
@@ -25508,9 +25703,9 @@ async function addHosts(hosts, verbose) {
 127.0.0.1 ${host}
 ::1 ${host}`).join(`
 `);
-    const tmpFile = path11.join(os2.tmpdir(), `rpx-hosts-${Date.now()}.tmp`);
+    const tmpFile = path12.join(os2.tmpdir(), `rpx-hosts-${Date.now()}.tmp`);
     try {
-      await fs4.promises.writeFile(tmpFile, existingContent + hostEntries, "utf8");
+      await fs5.promises.writeFile(tmpFile, existingContent + hostEntries, "utf8");
       await execSudo(`cat "${tmpFile}" | tee "${hostsFilePath}" > /dev/null`);
       console.log(`  Hosts updated: ${newEntries.join(", ")}`);
     } catch (error) {
@@ -25523,7 +25718,7 @@ async function addHosts(hosts, verbose) {
       console.log(`  Or run: sudo nano ${hostsFilePath}`);
     } finally {
       try {
-        await fs4.promises.unlink(tmpFile);
+        await fs5.promises.unlink(tmpFile);
       } catch {}
     }
   } catch (err) {
@@ -25536,7 +25731,7 @@ async function removeHosts(hosts, verbose) {
   try {
     let content;
     try {
-      content = await fs4.promises.readFile(hostsFilePath, "utf-8");
+      content = await fs5.promises.readFile(hostsFilePath, "utf-8");
     } catch {
       debugLog("hosts", "Reading hosts file requires elevated permissions, using sudo", verbose);
       try {
@@ -25570,16 +25765,16 @@ async function removeHosts(hosts, verbose) {
     const newContent = `${filteredLines.join(`
 `)}
 `;
-    const tmpFile = path11.join(os2.tmpdir(), `rpx-hosts-${Date.now()}.tmp`);
+    const tmpFile = path12.join(os2.tmpdir(), `rpx-hosts-${Date.now()}.tmp`);
     try {
-      await fs4.promises.writeFile(tmpFile, newContent, "utf8");
+      await fs5.promises.writeFile(tmpFile, newContent, "utf8");
       await execSudo(`cat "${tmpFile}" | tee "${hostsFilePath}" > /dev/null`);
       debugLog("hosts", "Hosts removed successfully", verbose);
     } catch (error) {
       debugLog("hosts", "Could not clean up hosts file automatically", verbose);
     } finally {
       try {
-        await fs4.promises.unlink(tmpFile);
+        await fs5.promises.unlink(tmpFile);
       } catch (unlinkErr) {
         debugLog("hosts", `Failed to remove temporary file: ${unlinkErr}`, verbose);
       }
@@ -25592,7 +25787,7 @@ async function checkHosts(hosts, verbose) {
   debugLog("hosts", `Checking hosts: ${hosts}`, verbose);
   let content;
   try {
-    content = await fs4.promises.readFile(hostsFilePath, "utf-8");
+    content = await fs5.promises.readFile(hostsFilePath, "utf-8");
   } catch (readErr) {
     debugLog("hosts", `Error reading hosts file: ${readErr}`, verbose);
     try {
@@ -25805,25 +26000,7 @@ function createOriginGuard(options) {
 
 // ../rpx/src/start.ts
 init_proxy_handler();
-
-// ../rpx/src/acme-challenge.ts
-import * as fs5 from "node:fs";
-import * as path12 from "node:path";
-var ACME_CHALLENGE_PREFIX2 = "/.well-known/acme-challenge/";
-function readAcmeChallenge(webroot, pathname) {
-  if (!webroot || !pathname.startsWith(ACME_CHALLENGE_PREFIX2))
-    return null;
-  const token = pathname.slice(ACME_CHALLENGE_PREFIX2.length);
-  if (!token || !/^[A-Za-z0-9_-]+$/.test(token))
-    return null;
-  try {
-    return fs5.readFileSync(path12.join(webroot, token), "utf8");
-  } catch {
-    return null;
-  }
-}
-
-// ../rpx/src/start.ts
+init_acme_challenge();
 init_auth();
 init_host_routes();
 init_sni();
@@ -25833,6 +26010,7 @@ var processManager2 = new ProcessManager;
 var version3 = "0.12.0";
 var globalPortManager = new DefaultPortManager("0.0.0.0");
 var activeServers = new Set;
+var activeUpstreamPools = new Set;
 var isCleaningUp = false;
 var cleanupPromiseResolve = null;
 var cleanupPromise = null;
@@ -25872,6 +26050,9 @@ async function cleanup(options) {
     }));
     cleanupPromises.push(...serverClosePromises);
     activeServers.clear();
+    for (const pool of activeUpstreamPools)
+      stopHealthChecks(pool);
+    activeUpstreamPools.clear();
     if (options?.hosts && options.domains?.length) {
       debugLog("cleanup", "Cleaning up hosts file entries", options?.verbose);
       debugLog("cleanup", `Original domains for cleanup: ${JSON.stringify(options.domains)}`, options?.verbose);
@@ -26029,7 +26210,8 @@ async function testConnection(hostname, port, verbose, retries = 5) {
 }
 async function startServer(options) {
   debugLog("server", `Starting server with options: ${safeStringify(options)}`, options.verbose);
-  const fromUrl = new URL((options.from?.startsWith("http") ? options.from : `http://${options.from}`) || "localhost:5173");
+  const primaryFrom = primaryUpstreamUrl(options.from);
+  const fromUrl = new URL(primaryFrom.startsWith("http") ? primaryFrom : `http://${primaryFrom}`);
   const toUrl = new URL((options.to?.startsWith("http") ? options.to : `http://${options.to}`) || "rpx.localhost");
   const fromPort = Number.parseInt(fromUrl.port) || (fromUrl.protocol.includes("https:") ? 443 : 80);
   const hostsToCheck = [toUrl.hostname];
@@ -26110,7 +26292,8 @@ async function startServer(options) {
   debugLog("server", `Setting up reverse proxy with SSL config for ${toUrl.hostname}`, options.verbose);
   await setupProxy({
     ...options,
-    from: options.from || "localhost:5173",
+    from: primaryFrom,
+    originalFrom: options.from || primaryFrom,
     to: toUrl.hostname,
     fromPort,
     sourceUrl: {
@@ -26120,12 +26303,15 @@ async function startServer(options) {
     ssl: sslConfig
   });
 }
-async function createProxyServer(from, to, listenPort, sourceUrl, ssl, vitePluginUsage, verbose, cleanUrls, changeOrigin, auth) {
+async function createProxyServer(from, to, listenPort, sourceUrl, ssl, vitePluginUsage, verbose, cleanUrls, changeOrigin, auth, originalFrom, loadBalancer) {
   debugLog("proxy", `Creating proxy server ${from} -> ${to} with cleanUrls: ${cleanUrls}`, verbose);
+  const pool = createUpstreamPool(originalFrom ?? sourceUrl.host, loadBalancer);
+  startHealthChecks(pool);
   const routeEntries = [{
     host: to,
     route: {
       sourceHost: sourceUrl.host,
+      upstreamPool: pool,
       cleanUrls: cleanUrls || false,
       changeOrigin: changeOrigin || false,
       basePath: "/",
@@ -26133,8 +26319,11 @@ async function createProxyServer(from, to, listenPort, sourceUrl, ssl, vitePlugi
     }
   }];
   const server = createSharedProxyServer({ routeEntries, listenPort, sslConfig: ssl, originGuard: null, verbose: verbose ?? false });
-  if (!server)
+  if (!server) {
+    stopHealthChecks(pool);
     throw new Error(`Failed to start proxy server for ${to} on port ${listenPort}`);
+  }
+  activeUpstreamPools.add(pool);
   logToConsole({
     from,
     to,
@@ -26147,7 +26336,7 @@ async function createProxyServer(from, to, listenPort, sourceUrl, ssl, vitePlugi
 }
 async function setupProxy(options) {
   debugLog("setup", `Setting up reverse proxy: ${safeStringify(options)}`, options.verbose);
-  const { from, to, sourceUrl, ssl, verbose, cleanup: cleanupOptions, vitePluginUsage, changeOrigin, cleanUrls } = options;
+  const { from, originalFrom, to, sourceUrl, ssl, verbose, cleanup: cleanupOptions, vitePluginUsage, changeOrigin, cleanUrls } = options;
   const httpPort = 80;
   const httpsPort = 443;
   const hostname = "0.0.0.0";
@@ -26214,7 +26403,7 @@ async function setupProxy(options) {
       portManager2.usedPorts.add(finalPort);
       debugLog("setup", `Using standard ${targetPort === 443 ? "HTTPS" : "HTTP"} port ${targetPort} for ${to}`, verbose);
     }
-    await createProxyServer(from, to, finalPort, sourceUrl, ssl, vitePluginUsage, verbose, cleanUrls, changeOrigin, resolveAuth(options.auth));
+    await createProxyServer(from, to, finalPort, sourceUrl, ssl, vitePluginUsage, verbose, cleanUrls, changeOrigin, resolveAuth(options.auth), originalFrom, options.loadBalancer);
   } catch (err) {
     debugLog("setup", `Setup failed: ${err}`, verbose);
     log.error(`Failed to setup reverse proxy: ${err.message}`);
@@ -26322,7 +26511,8 @@ async function startProxies(options) {
           debugLog("watch", `Starting command for ${proxyId} with command: ${proxy.start.command}`, verbose);
           log.info(`Starting command for ${proxyId}...`);
           await processManager2.startProcess(proxyId, proxy.start, verbose);
-          const fromUrl = new URL(proxy.from?.startsWith("http") ? proxy.from : `http://${proxy.from}`);
+          const proxyPrimaryFrom = primaryUpstreamUrl(proxy.from);
+          const fromUrl = new URL(proxyPrimaryFrom.startsWith("http") ? proxyPrimaryFrom : `http://${proxyPrimaryFrom}`);
           const hostname = fromUrl.hostname || "localhost";
           const port = Number(fromUrl.port) || 80;
           try {
@@ -26348,7 +26538,8 @@ async function startProxies(options) {
         debugLog("watch", `Starting command: ${mergedOptions.start.command}`, verbose);
         await processManager2.startProcess(proxyId, mergedOptions.start, verbose);
       }
-      const fromUrl = new URL(mergedOptions.from?.startsWith("http") ? mergedOptions.from : `http://${mergedOptions.from}`);
+      const mergedPrimaryFrom = primaryUpstreamUrl(mergedOptions.from);
+      const fromUrl = new URL(mergedPrimaryFrom.startsWith("http") ? mergedPrimaryFrom : `http://${mergedPrimaryFrom}`);
       const hostname = fromUrl.hostname || "localhost";
       const port = Number(fromUrl.port) || 80;
       try {
@@ -26558,12 +26749,17 @@ async function collectRouteEntries(proxyOptions, hostsEnabled, verbose) {
       });
       debugLog("proxies", `Route: ${domain}${routePath ?? ""} → static ${typeof option.static === "string" ? option.static : option.static.dir}${auth ? " (auth)" : ""}`, verbose);
     } else {
-      const fromUrl = new URL(option.from?.startsWith("http") ? option.from : `http://${option.from}`);
+      const primaryFrom = primaryUpstreamUrl(option.from);
+      const fromUrl = new URL(primaryFrom.startsWith("http") ? primaryFrom : `http://${primaryFrom}`);
+      const pool = createUpstreamPool(option.from ?? fromUrl.host, option.loadBalancer);
+      startHealthChecks(pool);
+      activeUpstreamPools.add(pool);
       routeEntries.push({
         host: domain,
         path: routePath,
         route: {
           sourceHost: fromUrl.host,
+          upstreamPool: pool,
           cleanUrls,
           changeOrigin: option.changeOrigin || false,
           pathRewrites: option.pathRewrites,
@@ -26655,6 +26851,7 @@ init_dns();
 init_dns_state();
 init_daemon();
 init_proxy_handler();
+init_acme_challenge();
 init_auth();
 init_host_routes();
 init_static_files();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-plugin-rpx",
   "type": "module",
-  "version": "0.11.22",
+  "version": "0.11.24",
   "description": "A modern and smart reverse proxy. Vite plugin.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "typecheck": "bunx tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/rpx": "0.11.22",
+    "@stacksjs/rpx": "0.11.24",
     "@stacksjs/tlsx": "^0.13.9"
   },
   "simple-git-hooks": {