@elisoncampos/local-router 0.1.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

@@ -5,6 +5,7 @@ import chalk from "chalk";
 import * as fs8 from "fs";
 import * as path7 from "path";
 import { spawn as spawn2, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
 
 // src/certs.ts
 import * as crypto from "crypto";
@@ -44,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.");
   }
@@ -67,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;
@@ -298,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;
       }
@@ -321,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);
@@ -504,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;
       }
     }
@@ -666,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 = {
@@ -830,6 +854,9 @@ function spawnCommand(commandArgs, options) {
   const cleanup = () => {
     process.removeListener("SIGINT", onSigInt);
     process.removeListener("SIGTERM", onSigTerm);
+    process.removeListener("SIGHUP", onSigHup);
+    process.removeListener("uncaughtException", onUncaughtException);
+    process.removeListener("unhandledRejection", onUnhandledRejection);
     options?.onCleanup?.();
   };
   const handleSignal = (signal) => {
@@ -841,8 +868,28 @@ function spawnCommand(commandArgs, options) {
   };
   const onSigInt = () => handleSignal("SIGINT");
   const onSigTerm = () => handleSignal("SIGTERM");
+  const onSigHup = () => handleSignal("SIGHUP");
+  const onUncaughtException = (error) => {
+    if (exiting) return;
+    exiting = true;
+    console.error(error.stack || error.message);
+    child.kill("SIGTERM");
+    cleanup();
+    process.exit(1);
+  };
+  const onUnhandledRejection = (reason) => {
+    if (exiting) return;
+    exiting = true;
+    console.error(reason instanceof Error ? reason.stack || reason.message : String(reason));
+    child.kill("SIGTERM");
+    cleanup();
+    process.exit(1);
+  };
   process.on("SIGINT", onSigInt);
   process.on("SIGTERM", onSigTerm);
+  process.on("SIGHUP", onSigHup);
+  process.on("uncaughtException", onUncaughtException);
+  process.on("unhandledRejection", onUnhandledRejection);
   child.on("error", (error) => {
     if (exiting) return;
     exiting = true;
@@ -948,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) {
@@ -997,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.");
@@ -1016,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];
@@ -1066,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];
@@ -1171,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;
@@ -1255,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);
@@ -1271,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();
@@ -1309,6 +1388,51 @@ var DEBOUNCE_MS = 100;
 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));
+    const tsxBin = path7.join(
+      projectRoot,
+      "node_modules",
+      ".bin",
+      isWindows2 ? "tsx.cmd" : "tsx"
+    );
+    return {
+      command: tsxBin,
+      args: [CLI_ENTRY_PATH, ...args]
+    };
+  }
+  return {
+    command: process.execPath,
+    args: [CLI_ENTRY_PATH, ...args]
+  };
+}
 function printHelp() {
   console.log(`
 ${chalk.bold("local-router")} - Stable local domains with HTTP and HTTPS on the real hostnames you want.
@@ -1438,7 +1562,8 @@ function parseProxyArgs(args) {
     httpsPort: getDefaultHttpsPort(),
     httpEnabled: true,
     httpsEnabled: true,
-    foreground: false
+    foreground: false,
+    autoStopWhenIdle: false
   };
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
@@ -1446,6 +1571,10 @@ function parseProxyArgs(args) {
       options.foreground = true;
       continue;
     }
+    if (token === "--auto-stop-when-idle") {
+      options.autoStopWhenIdle = true;
+      continue;
+    }
     if (token === "--http-port") {
       options.httpPort = parseNumberFlag("--http-port", args[index + 1]);
       index += 1;
@@ -1567,6 +1696,15 @@ function writeEmptyRoutesIfNeeded(store) {
     fixOwnership(store.routesPath);
   }
 }
+function syncHostsFromStore(store) {
+  const activeRoutes = store.loadRoutes(true);
+  const hostnames = activeRoutes.map((route) => route.hostname);
+  if (hostnames.length === 0) {
+    cleanHostsFile();
+    return;
+  }
+  syncHostsFile(hostnames);
+}
 function needsPrivileges(runtime) {
   if (isWindows2) return false;
   return runtime.httpEnabled && runtime.httpPort < PRIVILEGED_PORT_THRESHOLD || runtime.httpsEnabled && runtime.httpsPort < PRIVILEGED_PORT_THRESHOLD;
@@ -1574,14 +1712,40 @@ function needsPrivileges(runtime) {
 function startProxyServer(store, runtime, stateDir) {
   store.ensureDir();
   writeEmptyRoutesIfNeeded(store);
-  let cachedRoutes = store.loadRoutes();
+  let cachedRoutes = store.loadRoutes(true);
   let debounceTimer = null;
   let watcher = null;
   let poller = null;
+  let idleTimer = null;
+  let cleaningUp = false;
+  let hasSeenRoutes = cachedRoutes.length > 0;
+  const clearIdleTimer = () => {
+    if (!idleTimer) return;
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  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();
+      }
+    }, delay);
+    idleTimer.unref();
+  };
   const reloadRoutes = () => {
     try {
-      cachedRoutes = store.loadRoutes();
-      syncHostsFile(cachedRoutes.map((route) => route.hostname));
+      cachedRoutes = store.loadRoutes(true);
+      syncHostsFromStore(store);
+      if (cachedRoutes.length > 0) {
+        hasSeenRoutes = true;
+        clearIdleTimer();
+      } else {
+        scheduleIdleShutdown();
+      }
     } catch {
     }
   };
@@ -1591,9 +1755,10 @@ function startProxyServer(store, runtime, stateDir) {
       debounceTimer = setTimeout(reloadRoutes, DEBOUNCE_MS);
     });
   } catch {
-    poller = setInterval(reloadRoutes, POLL_INTERVAL_MS);
   }
-  syncHostsFile(cachedRoutes.map((route) => route.hostname));
+  poller = setInterval(reloadRoutes, POLL_INTERVAL_MS);
+  poller.unref();
+  syncHostsFromStore(store);
   let tlsOptions;
   if (runtime.httpsEnabled) {
     const certs = ensureCerts(stateDir);
@@ -1626,7 +1791,14 @@ function startProxyServer(store, runtime, stateDir) {
     pendingListeners -= 1;
     if (pendingListeners > 0) return;
     fs8.writeFileSync(store.pidPath, String(process.pid), { mode: FILE_MODE });
-    writeProxyState(stateDir, { pid: process.pid, ...runtime });
+    writeProxyState(stateDir, {
+      pid: process.pid,
+      httpPort: runtime.httpPort,
+      httpsPort: runtime.httpsPort,
+      httpEnabled: runtime.httpEnabled,
+      httpsEnabled: runtime.httpsEnabled,
+      autoStopWhenIdle: runtime.autoStopWhenIdle
+    });
     fixOwnership(store.pidPath, store.statePath);
     console.log(chalk.green("local-router proxy is listening."));
     if (runtime.httpEnabled) {
@@ -1635,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") {
@@ -1657,8 +1830,11 @@ function startProxyServer(store, runtime, stateDir) {
     servers.httpsServer.listen(runtime.httpsPort, onListening);
   }
   const cleanup = () => {
+    if (cleaningUp) return;
+    cleaningUp = true;
     if (debounceTimer) clearTimeout(debounceTimer);
     if (poller) clearInterval(poller);
+    clearIdleTimer();
     watcher?.close();
     try {
       fs8.unlinkSync(store.pidPath);
@@ -1683,7 +1859,8 @@ async function ensureProxy(runtime) {
   const { dir, state } = await discoverState();
   const effectiveState = state ?? {
     pid: 0,
-    ...runtime
+    ...runtime,
+    autoStopWhenIdle: true
   };
   const stateDir = resolveStateDir(runtime);
   const store = new RouteStore(stateDir, {
@@ -1707,12 +1884,13 @@ async function ensureProxy(runtime) {
     if (answer === "s" || answer === "skip") {
       throw new Error("Skipping the proxy is not supported for this command.");
     }
-    const childArgs = [process.execPath, process.argv[1], "proxy", "start"];
+    const invocation = getSelfInvocation(["proxy", "start"]);
+    const childArgs = [...invocation.args, "--auto-stop-when-idle"];
     if (!runtime.httpEnabled) childArgs.push("--no-http");
     if (!runtime.httpsEnabled) childArgs.push("--no-https");
     if (runtime.httpPort !== getDefaultHttpPort()) childArgs.push("--http-port", String(runtime.httpPort));
     if (runtime.httpsPort !== getDefaultHttpsPort()) childArgs.push("--https-port", String(runtime.httpsPort));
-    const result = spawnSync("sudo", childArgs, {
+    const result = spawnSync("sudo", [invocation.command, ...childArgs], {
       stdio: "inherit",
       timeout: START_TIMEOUT_MS
     });
@@ -1721,12 +1899,13 @@ async function ensureProxy(runtime) {
       process.exit(1);
     }
   } else {
-    const childArgs = [process.argv[1], "proxy", "start"];
+    const invocation = getSelfInvocation(["proxy", "start"]);
+    const childArgs = [...invocation.args, "--auto-stop-when-idle"];
     if (!runtime.httpEnabled) childArgs.push("--no-http");
     if (!runtime.httpsEnabled) childArgs.push("--no-https");
     if (runtime.httpPort !== getDefaultHttpPort()) childArgs.push("--http-port", String(runtime.httpPort));
     if (runtime.httpsPort !== getDefaultHttpsPort()) childArgs.push("--https-port", String(runtime.httpsPort));
-    const result = spawnSync(process.execPath, childArgs, {
+    const result = spawnSync(invocation.command, childArgs, {
       stdio: "inherit",
       timeout: START_TIMEOUT_MS
     });
@@ -1772,6 +1951,18 @@ async function handleRun(args) {
     isSystemDir: dir === SYSTEM_STATE_DIR,
     onWarning: (message) => console.warn(chalk.yellow(message))
   });
+  const cleanupRoutes = () => {
+    for (const hostname of resolved.hostnames) {
+      try {
+        store.removeRoute(hostname);
+      } catch {
+      }
+    }
+    try {
+      syncHostsFromStore(store);
+    } catch {
+    }
+  };
   const port = parsed.appPort ?? await findFreePort();
   console.log(chalk.green(`App port: ${port}`));
   try {
@@ -1798,14 +1989,7 @@ async function handleRun(args) {
       LOCAL_ROUTER_URLS_HTTP: allHttpUrls,
       __VITE_ADDITIONAL_SERVER_ALLOWED_HOSTS: ".localhost"
     },
-    onCleanup: () => {
-      for (const hostname of resolved.hostnames) {
-        try {
-          store.removeRoute(hostname);
-        } catch {
-        }
-      }
-    }
+    onCleanup: cleanupRoutes
   });
 }
 async function handleHosts(args) {
@@ -1887,12 +2071,14 @@ ${chalk.bold("Usage:")}
     } catch {
     }
     fixOwnership(logPath, stateDir);
-    const daemonArgs = [process.argv[1], "proxy", "start", "--foreground"];
+    const invocation = getSelfInvocation(["proxy", "start", "--foreground"]);
+    const daemonArgs = [...invocation.args];
+    if (options.autoStopWhenIdle) daemonArgs.push("--auto-stop-when-idle");
     if (!options.httpEnabled) daemonArgs.push("--no-http");
     if (!options.httpsEnabled) daemonArgs.push("--no-https");
     if (options.httpPort !== getDefaultHttpPort()) daemonArgs.push("--http-port", String(options.httpPort));
     if (options.httpsPort !== getDefaultHttpsPort()) daemonArgs.push("--https-port", String(options.httpsPort));
-    const child = spawn2(process.execPath, daemonArgs, {
+    const child = spawn2(invocation.command, daemonArgs, {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: process.env,
@@ -1919,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") {
@@ -1926,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.1.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",
@@ -40,6 +43,7 @@
     "json5": "^2.2.3"
   },
   "devDependencies": {
+    "@changesets/changelog-github": "^0.5.1",
     "@changesets/cli": "^2.29.5",
     "@types/node": "^24.0.0",
     "tsup": "^8.3.5",

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");