vite-plugin-rpx 0.11.23 → 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) => {
@@ -24278,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";
@@ -25310,6 +25483,7 @@ 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();
@@ -25325,6 +25499,7 @@ var init_daemon = __esm(() => {
   init_registry();
   init_dns();
   init_utils();
+  registryUpstreamPools = new Map;
 });
 
 // src/index.ts
@@ -25392,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({
@@ -25834,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;
@@ -25873,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);
@@ -26030,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];
@@ -26111,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: {
@@ -26121,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: "/",
@@ -26134,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,
@@ -26148,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";
@@ -26215,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}`);
@@ -26323,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 {
@@ -26349,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 {
@@ -26559,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,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-plugin-rpx",
   "type": "module",
-  "version": "0.11.23",
+  "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.23",
+    "@stacksjs/rpx": "0.11.24",
     "@stacksjs/tlsx": "^0.13.9"
   },
   "simple-git-hooks": {