peakroute 0.5.0

package/dist/chunk-OWNUHDR5.js

@@ -0,0 +1,846 @@
+// src/platform.ts
+import * as path from "path";
+import * as os from "os";
+var IS_WINDOWS = process.platform === "win32";
+var IS_MACOS = process.platform === "darwin";
+var IS_LINUX = process.platform === "linux";
+var SYSTEM_STATE_DIR = IS_WINDOWS ? path.join(os.tmpdir(), "peakroute") : "/tmp/peakroute";
+var USER_STATE_DIR = path.join(os.homedir(), ".peakroute");
+var PRIVILEGED_PORT_THRESHOLD = 1024;
+
+// src/utils.ts
+import * as fs from "fs";
+function chmodSafe(path4, mode) {
+  if (IS_WINDOWS) return;
+  try {
+    fs.chmodSync(path4, mode);
+  } catch {
+  }
+}
+async function chmodSafeAsync(path4, mode) {
+  if (IS_WINDOWS) return;
+  try {
+    await fs.promises.chmod(path4, mode);
+  } catch {
+  }
+}
+function fixOwnership(...paths) {
+  if (IS_WINDOWS) return;
+  const uid = process.env.SUDO_UID;
+  const gid = process.env.SUDO_GID;
+  if (!uid || process.getuid?.() !== 0) return;
+  for (const p of paths) {
+    try {
+      fs.chownSync(p, parseInt(uid, 10), parseInt(gid || uid, 10));
+    } catch {
+    }
+  }
+}
+function isErrnoException(err) {
+  return err instanceof Error && "code" in err && typeof err.code === "string";
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function formatUrl(hostname, proxyPort, tls = false) {
+  const proto = tls ? "https" : "http";
+  const defaultPort = tls ? 443 : 80;
+  return proxyPort === defaultPort ? `${proto}://${hostname}` : `${proto}://${hostname}:${proxyPort}`;
+}
+function parseHostname(input) {
+  let hostname = input.trim().replace(/^https?:\/\//, "").split("/")[0].toLowerCase();
+  if (!hostname || hostname === ".localhost") {
+    throw new Error("Hostname cannot be empty");
+  }
+  if (!hostname.endsWith(".localhost")) {
+    hostname = `${hostname}.localhost`;
+  }
+  const name = hostname.replace(/\.localhost$/, "");
+  if (name.includes("..")) {
+    throw new Error(`Invalid hostname "${name}": consecutive dots are not allowed`);
+  }
+  if (!/^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/.test(name)) {
+    throw new Error(
+      `Invalid hostname "${name}": must contain only lowercase letters, digits, hyphens, and dots`
+    );
+  }
+  return hostname;
+}
+
+// src/proxy.ts
+import * as http from "http";
+import * as http2 from "http2";
+import * as net from "net";
+var PEAKROUTE_HEADER = "X-Peakroute";
+var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "upgrade"
+]);
+function getRequestHost(req) {
+  const authority = req.headers[":authority"];
+  if (typeof authority === "string" && authority) return authority;
+  return req.headers.host || "";
+}
+function buildForwardedHeaders(req, tls) {
+  const headers = {};
+  const remoteAddress = req.socket.remoteAddress || "127.0.0.1";
+  const proto = tls ? "https" : "http";
+  const defaultPort = tls ? "443" : "80";
+  const hostHeader = getRequestHost(req);
+  headers["x-forwarded-for"] = req.headers["x-forwarded-for"] ? `${req.headers["x-forwarded-for"]}, ${remoteAddress}` : remoteAddress;
+  headers["x-forwarded-proto"] = req.headers["x-forwarded-proto"] || proto;
+  headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || hostHeader;
+  headers["x-forwarded-port"] = req.headers["x-forwarded-port"] || hostHeader.split(":")[1] || defaultPort;
+  return headers;
+}
+var PEAKROUTE_HOPS_HEADER = "x-peakroute-hops";
+var MAX_PROXY_HOPS = 5;
+function createProxyServer(options) {
+  const { getRoutes, proxyPort, onError = (msg) => console.error(msg), tls } = options;
+  const isTls = !!tls;
+  const handleRequest = (req, res) => {
+    res.setHeader(PEAKROUTE_HEADER, "1");
+    const routes = getRoutes();
+    const host = getRequestHost(req).split(":")[0];
+    if (!host) {
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end("Missing Host header");
+      return;
+    }
+    const hops = parseInt(req.headers[PEAKROUTE_HOPS_HEADER], 10) || 0;
+    if (hops >= MAX_PROXY_HOPS) {
+      onError(
+        `Loop detected for ${host}: request has passed through peakroute ${hops} times. This usually means a backend is proxying back through peakroute without rewriting the Host header. If you use Vite/webpack proxy, set changeOrigin: true.`
+      );
+      res.writeHead(508, { "Content-Type": "text/plain" });
+      res.end(
+        `Loop Detected: this request has passed through peakroute ${hops} times.
+
+This usually means a dev server (Vite, webpack, etc.) is proxying
+requests back through peakroute without rewriting the Host header.
+
+Fix: add changeOrigin: true to your proxy config, e.g.:
+
+  proxy: {
+    "/api": {
+      target: "http://<backend>.localhost:<port>",
+      changeOrigin: true,
+    },
+  }
+`
+      );
+      return;
+    }
+    const route = routes.find((r) => r.hostname === host);
+    if (!route) {
+      const safeHost = escapeHtml(host);
+      res.writeHead(404, { "Content-Type": "text/html" });
+      res.end(`
+        <html>
+          <head><title>peakroute - Not Found</title></head>
+          <body style="font-family: system-ui; padding: 40px; max-width: 600px; margin: 0 auto;">
+            <h1>Not Found</h1>
+            <p>No app registered for <strong>${safeHost}</strong></p>
+            ${routes.length > 0 ? `
+              <h2>Active apps:</h2>
+              <ul>
+                ${routes.map((r) => `<li><a href="${escapeHtml(formatUrl(r.hostname, proxyPort, isTls))}">${escapeHtml(r.hostname)}</a> - localhost:${escapeHtml(String(r.port))}</li>`).join("")}
+              </ul>
+            ` : "<p><em>No apps running.</em></p>"}
+            <p>Start an app with: <code>peakroute ${safeHost.replace(".localhost", "")} your-command</code></p>
+          </body>
+        </html>
+      `);
+      return;
+    }
+    const forwardedHeaders = buildForwardedHeaders(req, isTls);
+    const proxyReqHeaders = { ...req.headers };
+    for (const [key, value] of Object.entries(forwardedHeaders)) {
+      proxyReqHeaders[key] = value;
+    }
+    proxyReqHeaders[PEAKROUTE_HOPS_HEADER] = String(hops + 1);
+    for (const key of Object.keys(proxyReqHeaders)) {
+      if (key.startsWith(":")) {
+        delete proxyReqHeaders[key];
+      }
+    }
+    const proxyReq = http.request(
+      {
+        hostname: "127.0.0.1",
+        port: route.port,
+        path: req.url,
+        method: req.method,
+        headers: proxyReqHeaders
+      },
+      (proxyRes) => {
+        const responseHeaders = { ...proxyRes.headers };
+        if (isTls) {
+          for (const h of HOP_BY_HOP_HEADERS) {
+            delete responseHeaders[h];
+          }
+        }
+        res.writeHead(proxyRes.statusCode || 502, responseHeaders);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      onError(`Proxy error for ${getRequestHost(req)}: ${err.message}`);
+      if (!res.headersSent) {
+        const errWithCode = err;
+        const message = errWithCode.code === "ECONNREFUSED" ? "Bad Gateway: the target app is not responding. It may have crashed." : "Bad Gateway: the target app may not be running.";
+        res.writeHead(502, { "Content-Type": "text/plain" });
+        res.end(message);
+      }
+    });
+    res.on("close", () => {
+      if (!proxyReq.destroyed) {
+        proxyReq.destroy();
+      }
+    });
+    req.on("error", () => {
+      if (!proxyReq.destroyed) {
+        proxyReq.destroy();
+      }
+    });
+    req.pipe(proxyReq);
+  };
+  const handleUpgrade = (req, socket, head) => {
+    const hops = parseInt(req.headers[PEAKROUTE_HOPS_HEADER], 10) || 0;
+    if (hops >= MAX_PROXY_HOPS) {
+      const host2 = getRequestHost(req).split(":")[0];
+      onError(
+        `WebSocket loop detected for ${host2}: request has passed through peakroute ${hops} times. Set changeOrigin: true in your proxy config.`
+      );
+      socket.end(
+        "HTTP/1.1 508 Loop Detected\r\nContent-Type: text/plain\r\n\r\nLoop Detected: request has passed through peakroute too many times.\nAdd changeOrigin: true to your dev server proxy config.\n"
+      );
+      return;
+    }
+    const routes = getRoutes();
+    const host = getRequestHost(req).split(":")[0];
+    const route = routes.find((r) => r.hostname === host);
+    if (!route) {
+      socket.destroy();
+      return;
+    }
+    const forwardedHeaders = buildForwardedHeaders(req, isTls);
+    const proxyReqHeaders = { ...req.headers };
+    for (const [key, value] of Object.entries(forwardedHeaders)) {
+      proxyReqHeaders[key] = value;
+    }
+    proxyReqHeaders[PEAKROUTE_HOPS_HEADER] = String(hops + 1);
+    for (const key of Object.keys(proxyReqHeaders)) {
+      if (key.startsWith(":")) {
+        delete proxyReqHeaders[key];
+      }
+    }
+    const proxyReq = http.request({
+      hostname: "127.0.0.1",
+      port: route.port,
+      path: req.url,
+      method: req.method,
+      headers: proxyReqHeaders
+    });
+    proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+      let response = `HTTP/1.1 101 Switching Protocols\r
+`;
+      for (let i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+        response += `${proxyRes.rawHeaders[i]}: ${proxyRes.rawHeaders[i + 1]}\r
+`;
+      }
+      response += "\r\n";
+      socket.write(response);
+      if (proxyHead.length > 0) {
+        socket.write(proxyHead);
+      }
+      proxySocket.pipe(socket);
+      socket.pipe(proxySocket);
+      proxySocket.on("error", () => socket.destroy());
+      socket.on("error", () => proxySocket.destroy());
+    });
+    proxyReq.on("error", (err) => {
+      onError(`WebSocket proxy error for ${getRequestHost(req)}: ${err.message}`);
+      socket.destroy();
+    });
+    proxyReq.on("response", (res) => {
+      if (!socket.destroyed) {
+        let response = `HTTP/1.1 ${res.statusCode} ${res.statusMessage}\r
+`;
+        for (let i = 0; i < res.rawHeaders.length; i += 2) {
+          response += `${res.rawHeaders[i]}: ${res.rawHeaders[i + 1]}\r
+`;
+        }
+        response += "\r\n";
+        socket.write(response);
+        res.pipe(socket);
+      }
+    });
+    if (head.length > 0) {
+      proxyReq.write(head);
+    }
+    proxyReq.end();
+  };
+  if (tls) {
+    const h2Server = http2.createSecureServer({
+      cert: tls.cert,
+      key: tls.key,
+      allowHTTP1: true,
+      ...tls.SNICallback ? { SNICallback: tls.SNICallback } : {}
+    });
+    h2Server.on("request", (req, res) => {
+      handleRequest(req, res);
+    });
+    h2Server.on("upgrade", (req, socket, head) => {
+      handleUpgrade(req, socket, head);
+    });
+    const plainServer = http.createServer(handleRequest);
+    plainServer.on("upgrade", handleUpgrade);
+    const wrapper = net.createServer((socket) => {
+      socket.once("readable", () => {
+        const buf = socket.read(1);
+        if (!buf) {
+          socket.destroy();
+          return;
+        }
+        socket.unshift(buf);
+        if (buf[0] === 22) {
+          h2Server.emit("connection", socket);
+        } else {
+          plainServer.emit("connection", socket);
+        }
+      });
+    });
+    const origClose = wrapper.close.bind(wrapper);
+    wrapper.close = function(cb) {
+      h2Server.close();
+      plainServer.close();
+      return origClose(cb);
+    };
+    return wrapper;
+  }
+  const httpServer = http.createServer(handleRequest);
+  httpServer.on("upgrade", handleUpgrade);
+  return httpServer;
+}
+
+// src/cli-utils.ts
+import * as fs2 from "fs";
+import * as http3 from "http";
+import * as https from "https";
+import * as net2 from "net";
+import * as path2 from "path";
+import * as readline from "readline";
+import { execSync, spawn } from "child_process";
+var DEFAULT_PROXY_PORT = 1355;
+var MIN_APP_PORT = 4e3;
+var MAX_APP_PORT = 4999;
+var RANDOM_PORT_ATTEMPTS = 50;
+var SOCKET_TIMEOUT_MS = 500;
+var LSOF_TIMEOUT_MS = 5e3;
+var WAIT_FOR_PROXY_MAX_ATTEMPTS = 20;
+var WAIT_FOR_PROXY_INTERVAL_MS = 250;
+var SIGNAL_CODES = {
+  SIGHUP: 1,
+  SIGINT: 2,
+  SIGQUIT: 3,
+  SIGABRT: 6,
+  SIGKILL: 9,
+  SIGTERM: 15
+};
+function getDefaultPort() {
+  const envPort = process.env.PEAKROUTE_PORT;
+  if (envPort) {
+    const port = parseInt(envPort, 10);
+    if (!isNaN(port) && port >= 1 && port <= 65535) return port;
+  }
+  return DEFAULT_PROXY_PORT;
+}
+function resolveStateDir(port) {
+  if (process.env.PEAKROUTE_STATE_DIR) return process.env.PEAKROUTE_STATE_DIR;
+  if (IS_WINDOWS) return USER_STATE_DIR;
+  return port < PRIVILEGED_PORT_THRESHOLD ? SYSTEM_STATE_DIR : USER_STATE_DIR;
+}
+function readPortFromDir(dir) {
+  try {
+    const raw = fs2.readFileSync(path2.join(dir, "proxy.port"), "utf-8").trim();
+    const port = parseInt(raw, 10);
+    return isNaN(port) ? null : port;
+  } catch {
+    return null;
+  }
+}
+var TLS_MARKER_FILE = "proxy.tls";
+function readTlsMarker(dir) {
+  try {
+    return fs2.existsSync(path2.join(dir, TLS_MARKER_FILE));
+  } catch {
+    return false;
+  }
+}
+function writeTlsMarker(dir, enabled) {
+  const markerPath = path2.join(dir, TLS_MARKER_FILE);
+  if (enabled) {
+    fs2.writeFileSync(markerPath, "1", { mode: 420 });
+  } else {
+    try {
+      fs2.unlinkSync(markerPath);
+    } catch {
+    }
+  }
+}
+function isHttpsEnvEnabled() {
+  const val = process.env.PEAKROUTE_HTTPS;
+  return val === "1" || val === "true";
+}
+async function discoverState() {
+  if (process.env.PEAKROUTE_STATE_DIR) {
+    const dir = process.env.PEAKROUTE_STATE_DIR;
+    const port = readPortFromDir(dir) ?? getDefaultPort();
+    const tls = readTlsMarker(dir);
+    return { dir, port, tls };
+  }
+  const userPort = readPortFromDir(USER_STATE_DIR);
+  if (userPort !== null) {
+    const tls = readTlsMarker(USER_STATE_DIR);
+    if (await isProxyRunning(userPort, tls)) {
+      return { dir: USER_STATE_DIR, port: userPort, tls };
+    }
+  }
+  const systemPort = readPortFromDir(SYSTEM_STATE_DIR);
+  if (systemPort !== null) {
+    const tls = readTlsMarker(SYSTEM_STATE_DIR);
+    if (await isProxyRunning(systemPort, tls)) {
+      return { dir: SYSTEM_STATE_DIR, port: systemPort, tls };
+    }
+  }
+  const defaultPort = getDefaultPort();
+  return { dir: resolveStateDir(defaultPort), port: defaultPort, tls: false };
+}
+async function findFreePort(minPort = MIN_APP_PORT, maxPort = MAX_APP_PORT) {
+  if (minPort > maxPort) {
+    throw new Error(`minPort (${minPort}) must be <= maxPort (${maxPort})`);
+  }
+  const tryPort = (port) => {
+    return new Promise((resolve) => {
+      const server = net2.createServer();
+      server.listen(port, () => {
+        server.close(() => resolve(true));
+      });
+      server.on("error", () => resolve(false));
+    });
+  };
+  for (let i = 0; i < RANDOM_PORT_ATTEMPTS; i++) {
+    const port = minPort + Math.floor(Math.random() * (maxPort - minPort + 1));
+    if (await tryPort(port)) {
+      return port;
+    }
+  }
+  for (let port = minPort; port <= maxPort; port++) {
+    if (await tryPort(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No free port found in range ${minPort}-${maxPort}`);
+}
+function isProxyRunning(port, tls = false) {
+  return new Promise((resolve) => {
+    const requestFn = tls ? https.request : http3.request;
+    const req = requestFn(
+      {
+        hostname: "127.0.0.1",
+        port,
+        path: "/",
+        method: "HEAD",
+        timeout: SOCKET_TIMEOUT_MS,
+        ...tls ? { rejectUnauthorized: false } : {}
+      },
+      (res) => {
+        res.resume();
+        resolve(res.headers[PEAKROUTE_HEADER.toLowerCase()] === "1");
+      }
+    );
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.end();
+  });
+}
+function parsePidFromNetstat(output, port) {
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 5) continue;
+    const localAddr = parts[1];
+    const addrMatch = localAddr.match(/:(\d+)$/);
+    if (!addrMatch) continue;
+    const foundPort = parseInt(addrMatch[1], 10);
+    if (foundPort === port && parts[3] === "LISTENING") {
+      const pid = parseInt(parts[4], 10);
+      if (!isNaN(pid)) return pid;
+    }
+  }
+  return null;
+}
+function findPidOnPort(port) {
+  if (IS_WINDOWS) {
+    try {
+      const output = execSync(`netstat -ano -p tcp`, {
+        encoding: "utf-8",
+        timeout: LSOF_TIMEOUT_MS
+      });
+      return parsePidFromNetstat(output, port);
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const output = execSync(`lsof -ti tcp:${port} -sTCP:LISTEN`, {
+      encoding: "utf-8",
+      timeout: LSOF_TIMEOUT_MS
+    });
+    const pid = parseInt(output.trim().split("\n")[0], 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+async function waitForProxy(port, maxAttempts = WAIT_FOR_PROXY_MAX_ATTEMPTS, intervalMs = WAIT_FOR_PROXY_INTERVAL_MS, tls = false) {
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    if (await isProxyRunning(port, tls)) {
+      return true;
+    }
+  }
+  return false;
+}
+function shellEscape(arg) {
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+function collectBinPaths(cwd) {
+  const dirs = [];
+  let dir = cwd;
+  for (; ; ) {
+    const bin = path2.join(dir, "node_modules", ".bin");
+    if (fs2.existsSync(bin)) {
+      dirs.push(bin);
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirs;
+}
+function augmentedPath(env) {
+  const base = (env ?? process.env).PATH ?? "";
+  const bins = collectBinPaths(process.cwd());
+  return bins.length > 0 ? bins.join(path2.delimiter) + path2.delimiter + base : base;
+}
+function spawnCommand(commandArgs, options) {
+  const env = { ...options?.env ?? process.env, PATH: augmentedPath(options?.env) };
+  let child;
+  if (IS_WINDOWS) {
+    child = spawn(commandArgs[0], commandArgs.slice(1), {
+      stdio: "inherit",
+      env,
+      shell: true,
+      windowsHide: true
+      // Esconde janela do console
+    });
+  } else {
+    const shellCmd = commandArgs.map(shellEscape).join(" ");
+    child = spawn("/bin/sh", ["-c", shellCmd], {
+      stdio: "inherit",
+      env
+    });
+  }
+  let exiting = false;
+  const cleanup = () => {
+    process.removeListener("SIGINT", onSigInt);
+    process.removeListener("SIGTERM", onSigTerm);
+    options?.onCleanup?.();
+  };
+  const handleSignal = (signal) => {
+    if (exiting) return;
+    exiting = true;
+    child.kill(signal);
+    cleanup();
+    process.exit(128 + (SIGNAL_CODES[signal] || 15));
+  };
+  const onSigInt = () => handleSignal("SIGINT");
+  const onSigTerm = () => handleSignal("SIGTERM");
+  process.on("SIGINT", onSigInt);
+  process.on("SIGTERM", onSigTerm);
+  child.on("error", (err) => {
+    if (exiting) return;
+    exiting = true;
+    console.error(`Failed to run command: ${err.message}`);
+    if (err.code === "ENOENT") {
+      console.error(`Is "${commandArgs[0]}" installed and in your PATH?`);
+    }
+    cleanup();
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    if (exiting) return;
+    exiting = true;
+    cleanup();
+    if (signal) {
+      process.exit(128 + (SIGNAL_CODES[signal] || 15));
+    }
+    process.exit(code ?? 1);
+  });
+}
+var FRAMEWORKS_NEEDING_PORT = {
+  vite: { strictPort: true },
+  "react-router": { strictPort: true },
+  astro: { strictPort: false },
+  ng: { strictPort: false }
+};
+function injectFrameworkFlags(commandArgs, port) {
+  const cmd = commandArgs[0];
+  if (!cmd) return;
+  const basename2 = path2.basename(cmd);
+  const framework = FRAMEWORKS_NEEDING_PORT[basename2];
+  if (!framework) return;
+  if (!commandArgs.includes("--port")) {
+    commandArgs.push("--port", port.toString());
+    if (framework.strictPort) {
+      commandArgs.push("--strictPort");
+    }
+  }
+  if (!commandArgs.includes("--host")) {
+    commandArgs.push("--host", "127.0.0.1");
+  }
+}
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.on("close", () => resolve(""));
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+// src/routes.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var STALE_LOCK_THRESHOLD_MS = 1e4;
+var LOCK_MAX_RETRIES = 20;
+var LOCK_RETRY_DELAY_MS = 50;
+var FILE_MODE = 420;
+var DIR_MODE = 493;
+var SYSTEM_DIR_MODE = 1023;
+var SYSTEM_FILE_MODE = 438;
+function isValidRoute(value) {
+  return typeof value === "object" && value !== null && typeof value.hostname === "string" && typeof value.port === "number" && typeof value.pid === "number";
+}
+var RouteConflictError = class extends Error {
+  hostname;
+  existingPid;
+  constructor(hostname, existingPid) {
+    super(
+      `"${hostname}" is already registered by a running process (PID ${existingPid}). Use --force to override.`
+    );
+    this.name = "RouteConflictError";
+    this.hostname = hostname;
+    this.existingPid = existingPid;
+  }
+};
+var RouteStore = class _RouteStore {
+  /** The state directory path. */
+  dir;
+  routesPath;
+  lockPath;
+  pidPath;
+  portFilePath;
+  onWarning;
+  constructor(dir, options) {
+    this.dir = dir;
+    this.routesPath = path3.join(dir, "routes.json");
+    this.lockPath = path3.join(dir, "routes.lock");
+    this.pidPath = path3.join(dir, "proxy.pid");
+    this.portFilePath = path3.join(dir, "proxy.port");
+    this.onWarning = options?.onWarning;
+  }
+  isSystemDir() {
+    return this.dir === SYSTEM_STATE_DIR;
+  }
+  get dirMode() {
+    return this.isSystemDir() ? SYSTEM_DIR_MODE : DIR_MODE;
+  }
+  get fileMode() {
+    return this.isSystemDir() ? SYSTEM_FILE_MODE : FILE_MODE;
+  }
+  ensureDir() {
+    if (!fs3.existsSync(this.dir)) {
+      fs3.mkdirSync(this.dir, { recursive: true, mode: this.dirMode });
+    }
+    try {
+      fs3.chmodSync(this.dir, this.dirMode);
+    } catch {
+    }
+    fixOwnership(this.dir);
+  }
+  getRoutesPath() {
+    return this.routesPath;
+  }
+  // -- Locking ---------------------------------------------------------------
+  static sleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+  syncSleep(ms) {
+    Atomics.wait(_RouteStore.sleepBuffer, 0, 0, ms);
+  }
+  acquireLock(maxRetries = LOCK_MAX_RETRIES, retryDelayMs = LOCK_RETRY_DELAY_MS) {
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        fs3.mkdirSync(this.lockPath);
+        return true;
+      } catch (err) {
+        if (isErrnoException(err) && err.code === "EEXIST") {
+          try {
+            const stat = fs3.statSync(this.lockPath);
+            if (Date.now() - stat.mtimeMs > STALE_LOCK_THRESHOLD_MS) {
+              fs3.rmSync(this.lockPath, { recursive: true });
+              continue;
+            }
+          } catch {
+            continue;
+          }
+          this.syncSleep(retryDelayMs);
+        } else {
+          return false;
+        }
+      }
+    }
+    return false;
+  }
+  releaseLock() {
+    try {
+      fs3.rmSync(this.lockPath, { recursive: true });
+    } catch {
+    }
+  }
+  // -- Route I/O -------------------------------------------------------------
+  isProcessAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Load routes from disk, filtering out stale entries whose owning process
+   * is no longer alive. Stale-route cleanup is only persisted when the caller
+   * already holds the lock (i.e. inside addRoute/removeRoute) to avoid
+   * unprotected concurrent writes.
+   */
+  loadRoutes(persistCleanup = false) {
+    if (!fs3.existsSync(this.routesPath)) {
+      return [];
+    }
+    try {
+      const raw = fs3.readFileSync(this.routesPath, "utf-8");
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        this.onWarning?.(`Corrupted routes file (invalid JSON): ${this.routesPath}`);
+        return [];
+      }
+      if (!Array.isArray(parsed)) {
+        this.onWarning?.(`Corrupted routes file (expected array): ${this.routesPath}`);
+        return [];
+      }
+      const routes = parsed.filter(isValidRoute);
+      const alive = routes.filter((r) => this.isProcessAlive(r.pid));
+      if (persistCleanup && alive.length !== routes.length) {
+        try {
+          fs3.writeFileSync(this.routesPath, JSON.stringify(alive, null, 2), {
+            mode: this.fileMode
+          });
+        } catch {
+        }
+      }
+      return alive;
+    } catch {
+      return [];
+    }
+  }
+  saveRoutes(routes) {
+    fs3.writeFileSync(this.routesPath, JSON.stringify(routes, null, 2), { mode: this.fileMode });
+    fixOwnership(this.routesPath);
+  }
+  addRoute(hostname, port, pid, force = false) {
+    this.ensureDir();
+    if (!this.acquireLock()) {
+      throw new Error("Failed to acquire route lock");
+    }
+    try {
+      const routes = this.loadRoutes(true);
+      const existing = routes.find((r) => r.hostname === hostname);
+      if (existing && existing.pid !== pid && this.isProcessAlive(existing.pid) && !force) {
+        throw new RouteConflictError(hostname, existing.pid);
+      }
+      const filtered = routes.filter((r) => r.hostname !== hostname);
+      filtered.push({ hostname, port, pid });
+      this.saveRoutes(filtered);
+    } finally {
+      this.releaseLock();
+    }
+  }
+  removeRoute(hostname) {
+    this.ensureDir();
+    if (!this.acquireLock()) {
+      throw new Error("Failed to acquire route lock");
+    }
+    try {
+      const routes = this.loadRoutes(true).filter((r) => r.hostname !== hostname);
+      this.saveRoutes(routes);
+    } finally {
+      this.releaseLock();
+    }
+  }
+};
+
+export {
+  IS_WINDOWS,
+  PRIVILEGED_PORT_THRESHOLD,
+  chmodSafe,
+  chmodSafeAsync,
+  fixOwnership,
+  isErrnoException,
+  escapeHtml,
+  formatUrl,
+  parseHostname,
+  PEAKROUTE_HEADER,
+  createProxyServer,
+  getDefaultPort,
+  resolveStateDir,
+  readTlsMarker,
+  writeTlsMarker,
+  isHttpsEnvEnabled,
+  discoverState,
+  findFreePort,
+  isProxyRunning,
+  findPidOnPort,
+  waitForProxy,
+  spawnCommand,
+  injectFrameworkFlags,
+  prompt,
+  FILE_MODE,
+  DIR_MODE,
+  SYSTEM_DIR_MODE,
+  SYSTEM_FILE_MODE,
+  RouteConflictError,
+  RouteStore
+};