@elisoncampos/local-router 0.1.0 → 0.2.0

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";
@@ -830,6 +831,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 +845,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;
@@ -1309,6 +1333,27 @@ 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 CLI_ENTRY_PATH = fileURLToPath(import.meta.url);
+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 +1483,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 +1492,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 +1617,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 +1633,37 @@ 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;
+  const clearIdleTimer = () => {
+    if (!idleTimer) return;
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  const scheduleIdleShutdown = () => {
+    if (!runtime.autoStopWhenIdle || idleTimer || cachedRoutes.length > 0) return;
+    idleTimer = setTimeout(() => {
+      idleTimer = null;
+      cachedRoutes = store.loadRoutes(true);
+      if (cachedRoutes.length === 0) {
+        cleanup();
+      }
+    }, AUTO_STOP_IDLE_MS);
+    idleTimer.unref();
+  };
   const reloadRoutes = () => {
     try {
-      cachedRoutes = store.loadRoutes();
-      syncHostsFile(cachedRoutes.map((route) => route.hostname));
+      cachedRoutes = store.loadRoutes(true);
+      syncHostsFromStore(store);
+      if (cachedRoutes.length > 0) {
+        clearIdleTimer();
+      } else {
+        scheduleIdleShutdown();
+      }
     } catch {
     }
   };
@@ -1591,9 +1673,11 @@ 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);
+  scheduleIdleShutdown();
   let tlsOptions;
   if (runtime.httpsEnabled) {
     const certs = ensureCerts(stateDir);
@@ -1626,7 +1710,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) {
@@ -1657,8 +1748,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 +1777,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 +1802,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 +1817,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 +1869,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 +1907,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 +1989,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elisoncampos/local-router",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Named local domains with automatic HTTP/HTTPS routing for development.",
   "license": "MIT",
   "type": "module",
@@ -40,6 +40,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",