portless 0.5.2 → 0.7.0

package/dist/{chunk-P3DHZHEZ.js → chunk-Y6FWHU6F.js}

@@ -1,6 +1,7 @@
 // src/utils.ts
 import * as fs from "fs";
 function fixOwnership(...paths) {
+  if (process.platform === "win32") return;
   const uid = process.env.SUDO_UID;
   const gid = process.env.SUDO_GID;
   if (!uid || process.getuid?.() !== 0) return;
@@ -22,15 +23,19 @@ function formatUrl(hostname, proxyPort, tls = false) {
   const defaultPort = tls ? 443 : 80;
   return proxyPort === defaultPort ? `${proto}://${hostname}` : `${proto}://${hostname}:${proxyPort}`;
 }
-function parseHostname(input) {
+function parseHostname(input, tld = "localhost") {
+  const suffix = `.${tld}`;
   let hostname = input.trim().replace(/^https?:\/\//, "").split("/")[0].toLowerCase();
-  if (!hostname || hostname === ".localhost") {
+  if (tld !== "localhost" && hostname.endsWith(".localhost")) {
+    hostname = hostname.slice(0, -".localhost".length);
+  }
+  if (!hostname || hostname === suffix) {
     throw new Error("Hostname cannot be empty");
   }
-  if (!hostname.endsWith(".localhost")) {
-    hostname = `${hostname}.localhost`;
+  if (!hostname.endsWith(suffix)) {
+    hostname = `${hostname}${suffix}`;
   }
-  const name = hostname.replace(/\.localhost$/, "");
+  const name = hostname.slice(0, -suffix.length);
   if (name.includes("..")) {
     throw new Error(`Invalid hostname "${name}": consecutive dots are not allowed`);
   }
@@ -39,6 +44,14 @@ function parseHostname(input) {
       `Invalid hostname "${name}": must contain only lowercase letters, digits, hyphens, and dots`
     );
   }
+  const labels = name.split(".");
+  for (const label of labels) {
+    if (label.length > 63) {
+      throw new Error(
+        `Invalid hostname "${name}": label "${label}" exceeds 63-character DNS limit`
+      );
+    }
+  }
   return hostname;
 }
 
@@ -291,7 +304,14 @@ function findRoute(routes, host) {
   return routes.find((r) => r.hostname === host) || routes.find((r) => host.endsWith("." + r.hostname));
 }
 function createProxyServer(options) {
-  const { getRoutes, proxyPort, onError = (msg) => console.error(msg), tls } = options;
+  const {
+    getRoutes,
+    proxyPort,
+    tld = "localhost",
+    onError = (msg) => console.error(msg),
+    tls
+  } = options;
+  const tldSuffix = `.${tld}`;
   const isTls = !!tls;
   const handleRequest = (req, res) => {
     res.setHeader(PORTLESS_HEADER, "1");
@@ -314,7 +334,7 @@ function createProxyServer(options) {
           "Loop Detected",
           `<div class="content"><p class="desc">This request has passed through portless ${hops} times. This usually means a dev server (Vite, webpack, etc.) is proxying requests back through portless without rewriting the Host header.</p><div class="section"><p class="label">Fix: add changeOrigin to your proxy config</p><pre class="terminal">proxy: {
   "/api": {
-    target: "http://&lt;backend&gt;.localhost:&lt;port&gt;",
+    target: "http://&lt;backend&gt;${escapeHtml(tldSuffix)}:&lt;port&gt;",
     changeOrigin: true,
   },
 }</pre></div></div>`
@@ -325,13 +345,15 @@ function createProxyServer(options) {
     const route = findRoute(routes, host);
     if (!route) {
       const safeHost = escapeHtml(host);
-      const routesList = routes.length > 0 ? `<div class="section"><p class="label">Active apps</p><ul class="card">${routes.map((r) => `<li><a href="${escapeHtml(formatUrl(r.hostname, proxyPort, isTls))}" class="card-link"><span class="name">${escapeHtml(r.hostname)}</span><span class="meta"><code class="port">localhost:${escapeHtml(String(r.port))}</code><span class="arrow">${ARROW_SVG}</span></span></a></li>`).join("")}</ul></div>` : '<p class="empty">No apps running.</p>';
+      const strippedHost = host.endsWith(tldSuffix) ? host.slice(0, -tldSuffix.length) : host;
+      const safeSuggestion = escapeHtml(strippedHost);
+      const routesList = routes.length > 0 ? `<div class="section"><p class="label">Active apps</p><ul class="card">${routes.map((r) => `<li><a href="${escapeHtml(formatUrl(r.hostname, proxyPort, isTls))}" class="card-link"><span class="name">${escapeHtml(r.hostname)}</span><span class="meta"><code class="port">127.0.0.1:${escapeHtml(String(r.port))}</code><span class="arrow">${ARROW_SVG}</span></span></a></li>`).join("")}</ul></div>` : '<p class="empty">No apps running.</p>';
       res.writeHead(404, { "Content-Type": "text/html" });
       res.end(
         renderPage(
           404,
           "Not Found",
-          `<div class="content"><p class="desc">No app registered for <strong>${safeHost}</strong></p>${routesList}<div class="section"><div class="terminal"><span class="prompt">$ </span>portless ${safeHost.replace(".localhost", "")} your-command</div></div></div>`
+          `<div class="content"><p class="desc">No app registered for <strong>${safeHost}</strong></p>${routesList}<div class="section"><div class="terminal"><span class="prompt">$ </span>portless ${safeSuggestion} your-command</div></div></div>`
         )
       );
       return;
@@ -523,7 +545,9 @@ function createProxyServer(options) {
 // src/hosts.ts
 import * as fs2 from "fs";
 import * as dns from "dns";
-var HOSTS_PATH = "/etc/hosts";
+import * as path from "path";
+var isWindows = process.platform === "win32";
+var HOSTS_PATH = isWindows ? path.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "drivers", "etc", "hosts") : "/etc/hosts";
 var MARKER_START = "# portless-start";
 var MARKER_END = "# portless-end";
 function readHostsFile() {
@@ -587,7 +611,7 @@ function getManagedHostnames() {
     return parts.length >= 2 ? parts[1] : "";
   }).filter(Boolean);
 }
-function checkLocalhostResolution(hostname) {
+function checkHostResolution(hostname) {
   return new Promise((resolve) => {
     dns.lookup(hostname, { family: 4 }, (err, address) => {
       if (err) {
@@ -605,18 +629,19 @@ import * as http3 from "http";
 import * as https from "https";
 import * as net2 from "net";
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 import * as readline from "readline";
 import { execSync, spawn } from "child_process";
+var isWindows2 = process.platform === "win32";
 var DEFAULT_PROXY_PORT = 1355;
 var PRIVILEGED_PORT_THRESHOLD = 1024;
-var SYSTEM_STATE_DIR = "/tmp/portless";
-var USER_STATE_DIR = path.join(os.homedir(), ".portless");
+var SYSTEM_STATE_DIR = path2.join(os.tmpdir(), "portless");
+var USER_STATE_DIR = path2.join(os.homedir(), ".portless");
 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 PID_LOOKUP_TIMEOUT_MS = 5e3;
 var WAIT_FOR_PROXY_MAX_ATTEMPTS = 20;
 var WAIT_FOR_PROXY_INTERVAL_MS = 250;
 var SIGNAL_CODES = {
@@ -637,11 +662,12 @@ function getDefaultPort() {
 }
 function resolveStateDir(port) {
   if (process.env.PORTLESS_STATE_DIR) return process.env.PORTLESS_STATE_DIR;
+  if (isWindows2) return USER_STATE_DIR;
   return port < PRIVILEGED_PORT_THRESHOLD ? SYSTEM_STATE_DIR : USER_STATE_DIR;
 }
 function readPortFromDir(dir) {
   try {
-    const raw = fs3.readFileSync(path.join(dir, "proxy.port"), "utf-8").trim();
+    const raw = fs3.readFileSync(path2.join(dir, "proxy.port"), "utf-8").trim();
     const port = parseInt(raw, 10);
     return isNaN(port) ? null : port;
   } catch {
@@ -651,13 +677,13 @@ function readPortFromDir(dir) {
 var TLS_MARKER_FILE = "proxy.tls";
 function readTlsMarker(dir) {
   try {
-    return fs3.existsSync(path.join(dir, TLS_MARKER_FILE));
+    return fs3.existsSync(path2.join(dir, TLS_MARKER_FILE));
   } catch {
     return false;
   }
 }
 function writeTlsMarker(dir, enabled) {
-  const markerPath = path.join(dir, TLS_MARKER_FILE);
+  const markerPath = path2.join(dir, TLS_MARKER_FILE);
   if (enabled) {
     fs3.writeFileSync(markerPath, "1", { mode: 420 });
   } else {
@@ -667,6 +693,54 @@ function writeTlsMarker(dir, enabled) {
     }
   }
 }
+var DEFAULT_TLD = "localhost";
+var RISKY_TLDS = /* @__PURE__ */ new Map([
+  ["local", "conflicts with mDNS/Bonjour on macOS"],
+  ["dev", "Google-owned; browsers force HTTPS via preloaded HSTS"],
+  ["com", "public TLD -- DNS requests will leak to the internet"],
+  ["org", "public TLD -- DNS requests will leak to the internet"],
+  ["net", "public TLD -- DNS requests will leak to the internet"],
+  ["io", "public TLD -- DNS requests will leak to the internet"],
+  ["app", "public TLD -- DNS requests will leak to the internet"],
+  ["edu", "public TLD -- DNS requests will leak to the internet"],
+  ["gov", "public TLD -- DNS requests will leak to the internet"],
+  ["mil", "public TLD -- DNS requests will leak to the internet"],
+  ["int", "public TLD -- DNS requests will leak to the internet"]
+]);
+function validateTld(tld) {
+  if (!tld) return "TLD cannot be empty";
+  if (!/^[a-z0-9]+$/.test(tld)) {
+    return `Invalid TLD "${tld}": must contain only lowercase letters and digits`;
+  }
+  return null;
+}
+var TLD_FILE = "proxy.tld";
+function readTldFromDir(dir) {
+  try {
+    const raw = fs3.readFileSync(path2.join(dir, TLD_FILE), "utf-8").trim();
+    return raw || DEFAULT_TLD;
+  } catch {
+    return DEFAULT_TLD;
+  }
+}
+function writeTldFile(dir, tld) {
+  const filePath = path2.join(dir, TLD_FILE);
+  if (tld === DEFAULT_TLD) {
+    try {
+      fs3.unlinkSync(filePath);
+    } catch {
+    }
+  } else {
+    fs3.writeFileSync(filePath, tld, { mode: 420 });
+  }
+}
+function getDefaultTld() {
+  const val = process.env.PORTLESS_TLD?.trim().toLowerCase();
+  if (!val) return DEFAULT_TLD;
+  const err = validateTld(val);
+  if (err) throw new Error(`PORTLESS_TLD: ${err}`);
+  return val;
+}
 function isHttpsEnvEnabled() {
   const val = process.env.PORTLESS_HTTPS;
   return val === "1" || val === "true";
@@ -676,24 +750,36 @@ async function discoverState() {
     const dir = process.env.PORTLESS_STATE_DIR;
     const port = readPortFromDir(dir) ?? getDefaultPort();
     const tls = readTlsMarker(dir);
-    return { dir, port, tls };
+    const tld = readTldFromDir(dir);
+    return { dir, port, tls, tld };
   }
   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 };
+    if (await isProxyRunning(userPort)) {
+      const tls = readTlsMarker(USER_STATE_DIR);
+      const tld = readTldFromDir(USER_STATE_DIR);
+      return { dir: USER_STATE_DIR, port: userPort, tls, tld };
     }
   }
   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 };
+    if (await isProxyRunning(systemPort)) {
+      const tls = readTlsMarker(SYSTEM_STATE_DIR);
+      const tld = readTldFromDir(SYSTEM_STATE_DIR);
+      return { dir: SYSTEM_STATE_DIR, port: systemPort, tls, tld };
     }
   }
   const defaultPort = getDefaultPort();
-  return { dir: resolveStateDir(defaultPort), port: defaultPort, tls: false };
+  const probePorts = /* @__PURE__ */ new Set([defaultPort, 443, 80]);
+  for (const port of probePorts) {
+    if (await isProxyRunning(port)) {
+      const dir = resolveStateDir(port);
+      const tls = readTlsMarker(dir);
+      const tld = readTldFromDir(dir);
+      return { dir, port, tls, tld };
+    }
+  }
+  return { dir: resolveStateDir(defaultPort), port: defaultPort, tls: false, tld: getDefaultTld() };
 }
 async function findFreePort(minPort = MIN_APP_PORT, maxPort = MAX_APP_PORT) {
   if (minPort > maxPort) {
@@ -746,11 +832,34 @@ function isProxyRunning(port, tls = false) {
     req.end();
   });
 }
+function parsePidFromNetstat(output, port) {
+  for (const line of output.split(/\r?\n/)) {
+    if (!line.includes("LISTENING")) continue;
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 5) continue;
+    const localAddr = parts[1];
+    const lastColon = localAddr.lastIndexOf(":");
+    if (lastColon === -1) continue;
+    const addrPort = parseInt(localAddr.substring(lastColon + 1), 10);
+    if (addrPort === port) {
+      const pid = parseInt(parts[parts.length - 1], 10);
+      if (!isNaN(pid) && pid > 0) return pid;
+    }
+  }
+  return null;
+}
 function findPidOnPort(port) {
   try {
+    if (isWindows2) {
+      const output2 = execSync("netstat -ano -p tcp", {
+        encoding: "utf-8",
+        timeout: PID_LOOKUP_TIMEOUT_MS
+      });
+      return parsePidFromNetstat(output2, port);
+    }
     const output = execSync(`lsof -ti tcp:${port} -sTCP:LISTEN`, {
       encoding: "utf-8",
-      timeout: LSOF_TIMEOUT_MS
+      timeout: PID_LOOKUP_TIMEOUT_MS
     });
     const pid = parseInt(output.trim().split("\n")[0], 10);
     return isNaN(pid) ? null : pid;
@@ -774,11 +883,11 @@ function collectBinPaths(cwd) {
   const dirs = [];
   let dir = cwd;
   for (; ; ) {
-    const bin = path.join(dir, "node_modules", ".bin");
+    const bin = path2.join(dir, "node_modules", ".bin");
     if (fs3.existsSync(bin)) {
       dirs.push(bin);
     }
-    const parent = path.dirname(dir);
+    const parent = path2.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -787,12 +896,15 @@ function collectBinPaths(cwd) {
 function augmentedPath(env) {
   const base = (env ?? process.env).PATH ?? "";
   const bins = collectBinPaths(process.cwd());
-  return bins.length > 0 ? bins.join(path.delimiter) + path.delimiter + base : base;
+  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) };
-  const shellCmd = commandArgs.map(shellEscape).join(" ");
-  const child = spawn("/bin/sh", ["-c", shellCmd], {
+  const child = isWindows2 ? spawn(commandArgs[0], commandArgs.slice(1), {
+    stdio: "inherit",
+    env,
+    shell: true
+  }) : spawn("/bin/sh", ["-c", commandArgs.map(shellEscape).join(" ")], {
     stdio: "inherit",
     env
   });
@@ -844,7 +956,7 @@ var FRAMEWORKS_NEEDING_PORT = {
 function injectFrameworkFlags(commandArgs, port) {
   const cmd = commandArgs[0];
   if (!cmd) return;
-  const basename2 = path.basename(cmd);
+  const basename2 = path2.basename(cmd);
   const framework = FRAMEWORKS_NEEDING_PORT[basename2];
   if (!framework) return;
   if (!commandArgs.includes("--port")) {
@@ -874,7 +986,7 @@ function prompt(question) {
 
 // src/routes.ts
 import * as fs4 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 var STALE_LOCK_THRESHOLD_MS = 1e4;
 var LOCK_MAX_RETRIES = 20;
 var LOCK_RETRY_DELAY_MS = 50;
@@ -907,10 +1019,10 @@ var RouteStore = class _RouteStore {
   onWarning;
   constructor(dir, options) {
     this.dir = dir;
-    this.routesPath = path2.join(dir, "routes.json");
-    this.lockPath = path2.join(dir, "routes.lock");
-    this.pidPath = path2.join(dir, "proxy.pid");
-    this.portFilePath = path2.join(dir, "proxy.port");
+    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() {
@@ -1067,12 +1179,19 @@ export {
   syncHostsFile,
   cleanHostsFile,
   getManagedHostnames,
-  checkLocalhostResolution,
+  checkHostResolution,
+  isWindows2 as isWindows,
   PRIVILEGED_PORT_THRESHOLD,
   getDefaultPort,
   resolveStateDir,
   readTlsMarker,
   writeTlsMarker,
+  DEFAULT_TLD,
+  RISKY_TLDS,
+  validateTld,
+  readTldFromDir,
+  writeTldFile,
+  getDefaultTld,
   isHttpsEnvEnabled,
   discoverState,
   findFreePort,