portless-studio 0.1.2 → 0.1.3

package/dist/server/infrastructure/system/ephemeral-ports.js

@@ -0,0 +1,62 @@
+import { DEFAULT_EPHEMERAL_RANGES } from "../../../core/ports/helper-ports.js";
+/** Reads `/proc/sys/net/ipv4/ip_local_port_range`: two numbers separated by whitespace. */
+export function parseLinuxPortRange(text) {
+    const [first, last] = text.trim().split(/\s+/).map(Number);
+    return validRange(first, last);
+}
+/** Reads `sysctl -n net.inet.ip.portrange.first net.inet.ip.portrange.last`: one number per line. */
+export function parseSysctlPortRange(text) {
+    return parseLinuxPortRange(text);
+}
+/** Reads `netsh int ipv4 show dynamicport tcp`: a start port and a number of ports. */
+export function parseNetshDynamicPorts(text) {
+    const numbers = [...text.matchAll(/:\s*(\d+)/g)].map((match) => Number(match[1]));
+    const [start, count] = numbers;
+    if (start === undefined || count === undefined || count < 1)
+        return null;
+    return validRange(start, start + count - 1);
+}
+function validRange(first, last) {
+    if (first === undefined || last === undefined)
+        return null;
+    if (!Number.isInteger(first) || !Number.isInteger(last))
+        return null;
+    if (first < 1 || last > 65535 || first > last)
+        return null;
+    return { first, last };
+}
+/**
+ * The range the system hands out for port 0, read once and kept: it only changes when someone
+ * edits a kernel setting. Falls back to the platform default when it cannot be read.
+ */
+export function ephemeralRangeReader(platform, io) {
+    let reading = null;
+    return () => {
+        reading ??= readEphemeralRange(platform, io).catch(() => fallbackRange(platform));
+        return reading;
+    };
+}
+async function readEphemeralRange(platform, io) {
+    let range = null;
+    if (platform === "linux") {
+        range = parseLinuxPortRange(io.readFile("/proc/sys/net/ipv4/ip_local_port_range") ?? "");
+    }
+    else if (platform === "darwin") {
+        const out = await io.run("sysctl", [
+            "-n",
+            "net.inet.ip.portrange.first",
+            "net.inet.ip.portrange.last",
+        ]);
+        range = parseSysctlPortRange(out.stdout);
+    }
+    else if (platform === "win32") {
+        const out = await io.run("netsh", ["int", "ipv4", "show", "dynamicport", "tcp"]);
+        range = parseNetshDynamicPorts(out.stdout);
+    }
+    return range ?? fallbackRange(platform);
+}
+function fallbackRange(platform) {
+    if (platform === "darwin" || platform === "win32")
+        return DEFAULT_EPHEMERAL_RANGES[platform];
+    return DEFAULT_EPHEMERAL_RANGES.linux;
+}

package/dist/server/infrastructure/system/system-port-scanner.js

@@ -1,5 +1,6 @@
 import { request } from "node:http";
 import { STUDIO_HEADER } from "../../../core/api/contract.js";
+import { isDebuggerVersionInfo } from "../../../core/ports/helper-ports.js";
 import { listLinuxPorts } from "./linux-ports.js";
 import { listMacosPorts } from "./macos-ports.js";
 import { nodeSystemIo } from "./system-io.js";
@@ -30,6 +31,7 @@ export class SystemPortScanner {
     #timeoutMs;
     #pidByPort = new Map();
     #answers = new Map();
+    #debuggers = new Map();
     constructor(list, timeoutMs = PROBE_TIMEOUT_MS) {
         this.#list = list;
         this.#timeoutMs = timeoutMs;
@@ -44,13 +46,28 @@ export class SystemPortScanner {
         }
         this.#pidByPort = new Map(ports.map((port) => [port.port, port.pid]));
         // Forget answers for processes that are gone, so the cache does not grow forever.
-        for (const key of this.#answers.keys()) {
-            const [port, pid] = key.split(":");
-            if (String(this.#pidByPort.get(Number(port))) !== pid)
-                this.#answers.delete(key);
+        for (const cache of [this.#answers, this.#debuggers]) {
+            for (const key of cache.keys()) {
+                const [port, pid] = key.split(":");
+                if (String(this.#pidByPort.get(Number(port))) !== pid)
+                    cache.delete(key);
+            }
         }
         return ports;
     }
+    /** Asked once per port and process, like `answersHttp`. */
+    probeDebugger(port) {
+        const pid = this.#pidByPort.get(port) ?? null;
+        if (pid === null)
+            return probeDebuggerPort(port, this.#timeoutMs);
+        const key = `${port}:${pid}`;
+        let answer = this.#debuggers.get(key);
+        if (!answer) {
+            answer = probeDebuggerPort(port, this.#timeoutMs);
+            this.#debuggers.set(key, answer);
+        }
+        return answer;
+    }
     answersHttp(port) {
         const pid = this.#pidByPort.get(port) ?? null;
         // Without a pid we cannot tell a restarted process apart, so the answer is not kept.
@@ -65,6 +82,49 @@ export class SystemPortScanner {
         return answer;
     }
 }
+/** A `/json/version` answer is a few hundred bytes; anything longer is not a debugger. */
+const MAX_VERSION_BODY = 16_384;
+/**
+ * Asks `GET /json/version`, which Node's inspector and Chrome DevTools answer with JSON naming
+ * the browser and protocol. `other` when the port answered something else, `unknown` when
+ * nothing answered in time.
+ */
+export async function probeDebuggerPort(port, timeoutMs = PROBE_TIMEOUT_MS) {
+    for (const host of LOOPBACK_HOSTS) {
+        const body = await getText(host, port, "/json/version", timeoutMs);
+        if (body === null)
+            continue;
+        try {
+            return isDebuggerVersionInfo(JSON.parse(body)) ? "debugger" : "other";
+        }
+        catch {
+            return "other";
+        }
+    }
+    return "unknown";
+}
+function getText(host, port, path, timeoutMs) {
+    return new Promise((resolve) => {
+        const options = { host, port, method: "GET", path, timeout: timeoutMs, agent: false };
+        const req = request(options, (res) => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                body += chunk;
+                if (body.length <= MAX_VERSION_BODY)
+                    return;
+                resolve("");
+                req.destroy();
+            });
+            res.on("end", () => resolve(body));
+            res.on("error", () => resolve(body));
+        });
+        req.on("timeout", () => req.destroy());
+        req.on("error", () => resolve(null));
+        req.on("close", () => resolve(null));
+        req.end();
+    });
+}
 /**
  * True when anything on loopback answers `HEAD /` with an HTTP response, whatever its status,
  * unless the response comes from a Portless Studio.

package/dist/server/main.js

@@ -24,6 +24,7 @@ import { PortlessRegistry } from "./infrastructure/portless/portless-registry.js
 import { inspectRoutesFile, resolveStateDir } from "./infrastructure/portless/state-files.js";
 import { DockerContainers } from "./infrastructure/system/docker-containers.js";
 import { collectDoctorFacts, proxyPidsAmong, reachesPortless, testBind, } from "./infrastructure/system/doctor-facts.js";
+import { ephemeralRangeReader } from "./infrastructure/system/ephemeral-ports.js";
 import { FaviconFetcher } from "./infrastructure/system/favicon-fetcher.js";
 import { fetchLatestVersion } from "./infrastructure/system/npm-registry.js";
 import { OsNotifier } from "./infrastructure/system/os-notifier.js";
@@ -82,6 +83,7 @@ export function createStudioServices(options = {}) {
         routeProjectStore: new JsonRouteProjectStore(routeProjectsPathFor(configPath)),
         containers,
         shortUrls,
+        ephemeralRange: ephemeralRangeReader(process.platform, nodeSystemIo),
     });
     const openWith = new OpenWith({
         catalog: systemAppCatalog(),