@elisoncampos/local-router 0.2.0 → 0.2.1

package/bin/.installed-node-path

@@ -0,0 +1 @@
+/opt/hostedtoolcache/node/24.14.0/x64/bin/node

package/bin/local-router

@@ -0,0 +1,104 @@
+#!/bin/sh
+
+set -eu
+
+SOURCE="$0"
+
+while [ -h "$SOURCE" ]; do
+  DIR=$(CDPATH= cd -- "$(dirname -- "$SOURCE")" && pwd)
+  TARGET=$(readlink "$SOURCE")
+  case "$TARGET" in
+    /*) SOURCE="$TARGET" ;;
+    *) SOURCE="$DIR/$TARGET" ;;
+  esac
+done
+
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$SOURCE")" && pwd)
+PACKAGE_ROOT=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
+INSTALLED_NODE_PATH_FILE="$PACKAGE_ROOT/bin/.installed-node-path"
+
+PRIMARY_NODE="$(command -v node 2>/dev/null || true)"
+
+can_run_node() {
+  CANDIDATE="$1"
+  [ -n "$CANDIDATE" ] || return 1
+  [ -x "$CANDIDATE" ] || return 1
+  "$CANDIDATE" -e "process.exit(0)" >/dev/null 2>&1
+}
+
+find_fallback_node() {
+  OLD_IFS=$IFS
+  IFS=:
+  for DIR in $PATH; do
+    [ -n "$DIR" ] || continue
+    CANDIDATE="$DIR/node"
+    [ -x "$CANDIDATE" ] || continue
+
+    if [ -n "$PRIMARY_NODE" ] && [ "$CANDIDATE" = "$PRIMARY_NODE" ]; then
+      continue
+    fi
+
+    case "$CANDIDATE" in
+      */.asdf/shims/node|*/asdf/shims/node|*/.mise/shims/node|*/mise/shims/node)
+        continue
+        ;;
+    esac
+
+    if can_run_node "$CANDIDATE"; then
+      printf '%s\n' "$CANDIDATE"
+      IFS=$OLD_IFS
+      return 0
+    fi
+  done
+  IFS=$OLD_IFS
+  return 1
+}
+
+SELECTED_NODE=""
+USED_FALLBACK="0"
+
+if [ -n "$PRIMARY_NODE" ] && can_run_node "$PRIMARY_NODE"; then
+  SELECTED_NODE="$PRIMARY_NODE"
+else
+  if [ -f "$INSTALLED_NODE_PATH_FILE" ]; then
+    INSTALLED_NODE="$(tr -d '\r\n' < "$INSTALLED_NODE_PATH_FILE")"
+    if can_run_node "$INSTALLED_NODE"; then
+      SELECTED_NODE="$INSTALLED_NODE"
+    fi
+  fi
+
+  if [ -z "$SELECTED_NODE" ]; then
+    SELECTED_NODE="$(find_fallback_node || true)"
+  fi
+
+  if [ -n "$SELECTED_NODE" ]; then
+    USED_FALLBACK="1"
+  fi
+fi
+
+if [ -z "$SELECTED_NODE" ]; then
+  echo "local-router: could not find a working Node.js runtime." >&2
+  echo "local-router: install the project's Node version or make a global node available in PATH." >&2
+  exit 1
+fi
+
+CLI_JS="$PACKAGE_ROOT/dist/cli.js"
+TSX_CLI="$PACKAGE_ROOT/node_modules/tsx/dist/cli.mjs"
+CLI_TS="$PACKAGE_ROOT/src/cli.ts"
+
+if [ -f "$CLI_JS" ]; then
+  exec env \
+    LOCAL_ROUTER_NODE_BIN="$SELECTED_NODE" \
+    LOCAL_ROUTER_NODE_FALLBACK="$USED_FALLBACK" \
+    "$SELECTED_NODE" "$CLI_JS" "$@"
+fi
+
+if [ -f "$TSX_CLI" ] && [ -f "$CLI_TS" ]; then
+  exec env \
+    LOCAL_ROUTER_NODE_BIN="$SELECTED_NODE" \
+    LOCAL_ROUTER_NODE_FALLBACK="$USED_FALLBACK" \
+    "$SELECTED_NODE" "$TSX_CLI" "$CLI_TS" "$@"
+fi
+
+echo "local-router: CLI entrypoint not found. Build the project first." >&2
+exit 1

package/dist/cli.js

@@ -45,8 +45,11 @@ function formatUrl(hostname, https2, port) {
 function removeProtocol(hostname) {
   return hostname.replace(/^https?:\/\//i, "").split("/")[0].trim();
 }
+function trimTrailingDots(hostname) {
+  return hostname.replace(/\.+$/, "");
+}
 function normalizeExplicitHostname(hostname) {
-  const normalized = removeProtocol(hostname).toLowerCase();
+  const normalized = trimTrailingDots(removeProtocol(hostname).toLowerCase());
   if (!normalized) {
     throw new Error("Hostname cannot be empty.");
   }
@@ -68,6 +71,18 @@ function normalizeExplicitHostname(hostname) {
   }
   return normalized;
 }
+function normalizeRequestHostname(hostname) {
+  const authority = removeProtocol(hostname);
+  if (!authority) return "";
+  if (authority.startsWith("[")) {
+    const closingBracketIndex = authority.indexOf("]");
+    const bracketedHost = closingBracketIndex === -1 ? authority.slice(1) : authority.slice(1, closingBracketIndex);
+    return trimTrailingDots(bracketedHost.toLowerCase());
+  }
+  const lastColonIndex = authority.lastIndexOf(":");
+  const withoutPort = lastColonIndex === -1 || authority.includes(":", lastColonIndex + 1) ? authority : authority.slice(0, lastColonIndex);
+  return trimTrailingDots(withoutPort.toLowerCase());
+}
 
 // src/certs.ts
 var CA_VALIDITY_DAYS = 3650;
@@ -299,22 +314,23 @@ function createSNICallback(stateDir, defaultCert, defaultKey) {
   const defaultContext = tls.createSecureContext({ cert: defaultCert, key: defaultKey });
   return async (servername, callback) => {
     try {
-      if (!servername || servername === "localhost") {
+      const normalizedServername = normalizeRequestHostname(servername);
+      if (!normalizedServername || normalizedServername === "localhost") {
         callback(null, defaultContext);
         return;
       }
-      const cached = cache.get(servername);
+      const cached = cache.get(normalizedServername);
       if (cached) {
         callback(null, cached);
         return;
       }
-      const safeName = sanitizeHostForFilename(servername);
+      const safeName = sanitizeHostForFilename(normalizedServername);
       const certPath = path.join(stateDir, HOST_CERTS_DIR, `${safeName}.pem`);
       const keyPath = path.join(stateDir, HOST_CERTS_DIR, `${safeName}-key.pem`);
       let resolvedCertPath = certPath;
       let resolvedKeyPath = keyPath;
       if (!fileExists(certPath) || !fileExists(keyPath) || !isCertValid(certPath) || !isCertSignatureStrong(certPath)) {
-        const generated = await generateHostCertAsync(stateDir, servername);
+        const generated = await generateHostCertAsync(stateDir, normalizedServername);
         resolvedCertPath = generated.certPath;
         resolvedKeyPath = generated.keyPath;
       }
@@ -322,7 +338,7 @@ function createSNICallback(stateDir, defaultCert, defaultKey) {
         cert: fs2.readFileSync(resolvedCertPath),
         key: fs2.readFileSync(resolvedKeyPath)
       });
-      cache.set(servername, context);
+      cache.set(normalizedServername, context);
       callback(null, context);
     } catch (error) {
       callback(error instanceof Error ? error : new Error(String(error)), defaultContext);
@@ -505,12 +521,19 @@ function inferProjectName(cwd = process.cwd()) {
 
 // src/config.ts
 var CONFIG_FILENAMES = [".local-router", ".local-router.json", "local-router.config.json"];
+function isReadableFile(candidate) {
+  try {
+    return fs4.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
 function findLocalRouterConfig(cwd = process.cwd()) {
   let dir = cwd;
   for (; ; ) {
     for (const filename of CONFIG_FILENAMES) {
       const candidate = path3.join(dir, filename);
-      if (fs4.existsSync(candidate)) {
+      if (isReadableFile(candidate)) {
         return candidate;
       }
     }
@@ -667,7 +690,7 @@ var MIN_APP_PORT = 4e3;
 var MAX_APP_PORT = 4999;
 var RANDOM_PORT_ATTEMPTS = 50;
 var SOCKET_TIMEOUT_MS = 750;
-var WAIT_FOR_PROXY_MAX_ATTEMPTS = 24;
+var WAIT_FOR_PROXY_MAX_ATTEMPTS = 60;
 var WAIT_FOR_PROXY_INTERVAL_MS = 250;
 var HEALTH_HEADER = "x-local-router";
 var SIGNAL_CODES = {
@@ -972,19 +995,34 @@ function getHealthHeader() {
 }
 
 // src/proxy.ts
-function getRequestHost(req) {
+function getRequestAuthority(req) {
   const authority = req.headers[":authority"];
   if (typeof authority === "string" && authority) return authority;
+  if (Array.isArray(req.headers.host)) {
+    return req.headers.host[0] ?? "";
+  }
   return req.headers.host ?? "";
 }
-function buildForwardedHeaders(req, tls2) {
+function getAuthorityPort(authority) {
+  if (!authority) return void 0;
+  if (authority.startsWith("[")) {
+    const closingBracketIndex = authority.indexOf("]");
+    if (closingBracketIndex !== -1 && authority[closingBracketIndex + 1] === ":") {
+      return authority.slice(closingBracketIndex + 2);
+    }
+    return void 0;
+  }
+  const lastColonIndex = authority.lastIndexOf(":");
+  if (lastColonIndex === -1) return void 0;
+  return authority.slice(lastColonIndex + 1);
+}
+function buildForwardedHeaders(req, authority, tls2) {
   const remoteAddress = req.socket.remoteAddress || "127.0.0.1";
-  const hostHeader = getRequestHost(req);
   return {
     "x-forwarded-for": req.headers["x-forwarded-for"] ? `${req.headers["x-forwarded-for"]}, ${remoteAddress}` : remoteAddress,
     "x-forwarded-proto": req.headers["x-forwarded-proto"] || (tls2 ? "https" : "http"),
-    "x-forwarded-host": req.headers["x-forwarded-host"] || hostHeader,
-    "x-forwarded-port": req.headers["x-forwarded-port"] || hostHeader.split(":")[1] || (tls2 ? "443" : "80")
+    "x-forwarded-host": req.headers["x-forwarded-host"] || authority,
+    "x-forwarded-port": req.headers["x-forwarded-port"] || getAuthorityPort(authority) || (tls2 ? "443" : "80")
   };
 }
 function findRoute(routes, host) {
@@ -1021,7 +1059,8 @@ function createProxyServers(options) {
       res.end();
       return;
     }
-    const host = getRequestHost(req).split(":")[0];
+    const authority = getRequestAuthority(req);
+    const host = normalizeRequestHostname(authority);
     if (!host) {
       res.writeHead(400, { "content-type": "text/plain" });
       res.end("Missing Host header.");
@@ -1040,8 +1079,8 @@ function createProxyServers(options) {
       );
       return;
     }
-    const headers = { ...req.headers, ...buildForwardedHeaders(req, httpsRequest) };
-    headers.host = getRequestHost(req);
+    const headers = { ...req.headers, ...buildForwardedHeaders(req, authority, httpsRequest) };
+    headers.host = authority;
     for (const key of Object.keys(headers)) {
       if (key.startsWith(":")) {
         delete headers[key];
@@ -1090,14 +1129,15 @@ function createProxyServers(options) {
   };
   const handleUpgrade = (httpsRequest) => (req, socket, head) => {
     socket.on("error", () => socket.destroy());
-    const host = getRequestHost(req).split(":")[0];
+    const authority = getRequestAuthority(req);
+    const host = normalizeRequestHostname(authority);
     const route = findRoute(options.getRoutes(), host);
     if (!route) {
       socket.destroy();
       return;
     }
-    const headers = { ...req.headers, ...buildForwardedHeaders(req, httpsRequest) };
-    headers.host = getRequestHost(req);
+    const headers = { ...req.headers, ...buildForwardedHeaders(req, authority, httpsRequest) };
+    headers.host = authority;
     for (const key of Object.keys(headers)) {
       if (key.startsWith(":")) {
         delete headers[key];
@@ -1195,6 +1235,16 @@ var RouteConflictError = class extends Error {
 function isValidRoute(value) {
   return typeof value === "object" && value !== null && typeof value.hostname === "string" && typeof value.port === "number" && typeof value.pid === "number";
 }
+function normalizeRoute(route) {
+  try {
+    return {
+      ...route,
+      hostname: normalizeExplicitHostname(route.hostname)
+    };
+  } catch {
+    return null;
+  }
+}
 var RouteStore = class _RouteStore {
   dir;
   routesPath;
@@ -1279,7 +1329,10 @@ var RouteStore = class _RouteStore {
         this.onWarning?.(`Corrupted routes file: expected an array at ${this.routesPath}.`);
         return [];
       }
-      const routes = parsed.filter(isValidRoute);
+      const routes = parsed.filter(isValidRoute).flatMap((route) => {
+        const normalized = normalizeRoute(route);
+        return normalized ? [normalized] : [];
+      });
       const aliveRoutes = routes.filter((route) => this.isProcessAlive(route.pid));
       if (persistCleanup && aliveRoutes.length !== routes.length) {
         this.saveRoutes(aliveRoutes);
@@ -1295,30 +1348,32 @@ var RouteStore = class _RouteStore {
     fixOwnership(this.routesPath);
   }
   addRoute(hostname, port, pid, force = false) {
+    const normalizedHostname = normalizeExplicitHostname(hostname);
     this.ensureDir();
     if (!this.acquireLock()) {
       throw new Error("Failed to acquire route lock.");
     }
     try {
       const routes = this.loadRoutes(true);
-      const existing = routes.find((route) => route.hostname === hostname);
+      const existing = routes.find((route) => route.hostname === normalizedHostname);
       if (existing && existing.pid !== pid && this.isProcessAlive(existing.pid) && !force) {
-        throw new RouteConflictError(hostname, existing.pid);
+        throw new RouteConflictError(normalizedHostname, existing.pid);
       }
-      const nextRoutes = routes.filter((route) => route.hostname !== hostname);
-      nextRoutes.push({ hostname, port, pid });
+      const nextRoutes = routes.filter((route) => route.hostname !== normalizedHostname);
+      nextRoutes.push({ hostname: normalizedHostname, port, pid });
       this.saveRoutes(nextRoutes);
     } finally {
       this.releaseLock();
     }
   }
   removeRoute(hostname) {
+    const normalizedHostname = normalizeExplicitHostname(hostname);
     this.ensureDir();
     if (!this.acquireLock()) {
       throw new Error("Failed to acquire route lock.");
     }
     try {
-      const nextRoutes = this.loadRoutes(true).filter((route) => route.hostname !== hostname);
+      const nextRoutes = this.loadRoutes(true).filter((route) => route.hostname !== normalizedHostname);
       this.saveRoutes(nextRoutes);
     } finally {
       this.releaseLock();
@@ -1334,7 +1389,31 @@ var POLL_INTERVAL_MS = 3e3;
 var EXIT_TIMEOUT_MS = 2e3;
 var START_TIMEOUT_MS = 3e4;
 var AUTO_STOP_IDLE_MS = 3e3;
+var AUTO_STOP_STARTUP_GRACE_MS = 15e3;
 var CLI_ENTRY_PATH = fileURLToPath(import.meta.url);
+var PACKAGE_VERSION = getPackageVersion();
+function getPackageVersion() {
+  try {
+    const packageJsonPath = path7.join(path7.dirname(path7.dirname(CLI_ENTRY_PATH)), "package.json");
+    const packageJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function maybeWarnAboutNodeFallback() {
+  if (process.env.LOCAL_ROUTER_NODE_FALLBACK !== "1") return;
+  const fallbackNode = process.env.LOCAL_ROUTER_NODE_BIN;
+  if (!fallbackNode) return;
+  console.warn(
+    chalk.yellow(
+      `Warning: the project-local Node.js runtime was not available. Falling back to ${fallbackNode}.`
+    )
+  );
+  console.warn(
+    chalk.gray("Install the project's Node version in asdf, mise, nvm, or your preferred manager.\n")
+  );
+}
 function getSelfInvocation(args) {
   if (CLI_ENTRY_PATH.endsWith(".ts")) {
     const projectRoot = path7.dirname(path7.dirname(CLI_ENTRY_PATH));
@@ -1639,6 +1718,7 @@ function startProxyServer(store, runtime, stateDir) {
   let poller = null;
   let idleTimer = null;
   let cleaningUp = false;
+  let hasSeenRoutes = cachedRoutes.length > 0;
   const clearIdleTimer = () => {
     if (!idleTimer) return;
     clearTimeout(idleTimer);
@@ -1646,13 +1726,14 @@ function startProxyServer(store, runtime, stateDir) {
   };
   const scheduleIdleShutdown = () => {
     if (!runtime.autoStopWhenIdle || idleTimer || cachedRoutes.length > 0) return;
+    const delay = hasSeenRoutes ? AUTO_STOP_IDLE_MS : AUTO_STOP_STARTUP_GRACE_MS;
     idleTimer = setTimeout(() => {
       idleTimer = null;
       cachedRoutes = store.loadRoutes(true);
       if (cachedRoutes.length === 0) {
         cleanup();
       }
-    }, AUTO_STOP_IDLE_MS);
+    }, delay);
     idleTimer.unref();
   };
   const reloadRoutes = () => {
@@ -1660,6 +1741,7 @@ function startProxyServer(store, runtime, stateDir) {
       cachedRoutes = store.loadRoutes(true);
       syncHostsFromStore(store);
       if (cachedRoutes.length > 0) {
+        hasSeenRoutes = true;
         clearIdleTimer();
       } else {
         scheduleIdleShutdown();
@@ -1677,7 +1759,6 @@ function startProxyServer(store, runtime, stateDir) {
   poller = setInterval(reloadRoutes, POLL_INTERVAL_MS);
   poller.unref();
   syncHostsFromStore(store);
-  scheduleIdleShutdown();
   let tlsOptions;
   if (runtime.httpsEnabled) {
     const certs = ensureCerts(stateDir);
@@ -1726,6 +1807,7 @@ function startProxyServer(store, runtime, stateDir) {
     if (runtime.httpsEnabled) {
       console.log(chalk.gray(`HTTPS -> ${runtime.httpsPort}`));
     }
+    scheduleIdleShutdown();
   };
   const registerServerError = (label, port) => (error) => {
     if (error.code === "EADDRINUSE") {
@@ -2023,6 +2105,7 @@ async function handleTrust() {
   console.log(chalk.green("Local CA added to the trust store."));
 }
 async function main() {
+  maybeWarnAboutNodeFallback();
   const args = process.argv.slice(2);
   const command = args[0];
   if (!command || command === "--help" || command === "-h") {
@@ -2030,7 +2113,7 @@ async function main() {
     return;
   }
   if (command === "--version" || command === "-v") {
-    console.log("0.1.0");
+    console.log(PACKAGE_VERSION);
     return;
   }
   if (command === "run") {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@elisoncampos/local-router",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Named local domains with automatic HTTP/HTTPS routing for development.",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "local-router": "dist/cli.js"
+    "local-router": "bin/local-router"
   },
   "repository": {
     "type": "git",
@@ -19,7 +19,9 @@
     "access": "public"
   },
   "files": [
-    "dist"
+    "bin",
+    "dist",
+    "scripts"
   ],
   "engines": {
     "node": ">=20.0.0"
@@ -28,6 +30,7 @@
     "build": "tsup src/cli.ts --format esm --target node20 --out-dir dist --clean",
     "changeset": "changeset",
     "dev": "tsx src/cli.ts",
+    "postinstall": "node scripts/write-node-path.js",
     "prepack": "npm run build",
     "prepublishOnly": "npm run typecheck && npm test",
     "release": "npm run typecheck && npm test && npm run build && changeset publish",

package/scripts/write-node-path.js

@@ -0,0 +1,10 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.dirname(scriptDir);
+const outputPath = path.join(projectRoot, "bin", ".installed-node-path");
+
+fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+fs.writeFileSync(outputPath, `${process.execPath}\n`, "utf8");