portless-studio 0.1.2 → 0.1.4

package/dist/server/infrastructure/config/json-terminal-history-store.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseTerminalHistory, } from "../../../core/terminals/terminal-history.js";
+import { writeFileAtomic } from "./atomic-write.js";
+const FILE_NAME = "terminals.json";
+/** `terminals.json` in the config file's folder. */
+export function terminalHistoryPathFor(configPath) {
+    return path.join(path.dirname(configPath), FILE_NAME);
+}
+/**
+ * The terminals running when Studio stopped and the recent commands per folder, as
+ * `{ "running": [...], "recentCommands": { "<folder>": [...] } }`. Studio writes it on its own.
+ */
+export class JsonTerminalHistoryStore {
+    path;
+    constructor(filePath) {
+        this.path = filePath;
+    }
+    read() {
+        try {
+            return parseTerminalHistory(JSON.parse(fs.readFileSync(this.path, "utf8")));
+        }
+        catch {
+            return parseTerminalHistory(null);
+        }
+    }
+    write(history) {
+        writeFileAtomic(this.path, `${JSON.stringify(history, null, 2)}\n`);
+    }
+}

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/linux-ports.js

@@ -19,22 +19,51 @@ export function parseProcNetTcp(text) {
     }
     return sockets;
 }
+/** Clock ticks per second, the unit of `/proc/<pid>/stat` times; 100 on every common kernel. */
+export const DEFAULT_CLOCK_TICKS = 100;
+/**
+ * When a process started, in epoch milliseconds, from field 22 of `/proc/<pid>/stat` (clock ticks
+ * since boot) and `btime` in `/proc/stat` (boot time in epoch seconds). Null when unreadable.
+ */
+export function processStartTime(stat, procStat, ticksPerSecond) {
+    if (stat === null || procStat === null || ticksPerSecond <= 0)
+        return null;
+    // The command name in field 2 may hold spaces and parentheses, so count fields after the last ")".
+    const fields = stat
+        .slice(stat.lastIndexOf(")") + 1)
+        .trim()
+        .split(/\s+/);
+    const ticks = Number(fields[19]);
+    const boot = Number(/^btime\s+(\d+)$/m.exec(procStat)?.[1]);
+    if (!Number.isFinite(ticks) || !Number.isFinite(boot) || boot <= 0)
+        return null;
+    return Math.round(boot * 1000 + (ticks * 1000) / ticksPerSecond);
+}
+/** `getconf CLK_TCK`, or the usual 100 when it cannot run. */
+export async function readClockTicks(io) {
+    const answer = await io.run("getconf", ["CLK_TCK"]).catch(() => null);
+    const ticks = Number(answer?.stdout.trim());
+    return Number.isInteger(ticks) && ticks > 0 ? ticks : DEFAULT_CLOCK_TICKS;
+}
 /**
  * Lists listening ports from `/proc`. A socket is linked to its process through the
  * `/proc/<pid>/fd/*` links; processes of other users cannot be read and stay unknown.
  */
-export async function listLinuxPorts(io) {
+export async function listLinuxPorts(io, ticksPerSecond = async () => DEFAULT_CLOCK_TICKS) {
     const sockets = [
         ...parseProcNetTcp(io.readFile("/proc/net/tcp") ?? ""),
         ...parseProcNetTcp(io.readFile("/proc/net/tcp6") ?? ""),
     ];
     const pids = pidsByInode(io, new Set(sockets.map((socket) => socket.inode)));
+    const ticks = pids.size > 0 ? await ticksPerSecond() : DEFAULT_CLOCK_TICKS;
+    const procStat = pids.size > 0 ? io.readFile("/proc/stat") : null;
     const byPort = new Map();
     for (const socket of sockets) {
         const known = byPort.get(socket.port);
         if (known?.pid != null)
             continue;
         const pid = pids.get(socket.inode) ?? null;
+        const startedAt = pid === null ? null : processStartTime(io.readFile(`/proc/${pid}/stat`), procStat, ticks);
         byPort.set(socket.port, {
             port: socket.port,
             pid,
@@ -43,6 +72,7 @@ export async function listLinuxPorts(io) {
             executable: pid === null
                 ? null
                 : (io.readLink(`/proc/${pid}/exe`)?.replace(DELETED_SUFFIX, "") ?? null),
+            ...(startedAt === null ? {} : { startedAt }),
         });
     }
     return [...byPort.values()].sort((a, b) => a.port - b.port);

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

@@ -48,28 +48,57 @@ export function parsePsExecutables(text) {
     }
     return executables;
 }
+/**
+ * Reads `ps -o pid=,etime= -p ...` into pid -> start in epoch milliseconds. `etime` is the time
+ * since the process started as `[[dd-]hh:]mm:ss`, which unlike `lstart` reads the same in every
+ * locale.
+ */
+export function parsePsStartTimes(text, now) {
+    const starts = new Map();
+    for (const line of text.split("\n")) {
+        const match = /^\s*(\d+)\s+(?:(\d+)-)?(?:(\d{1,2}):)?(\d{1,2}):(\d{2})\s*$/.exec(line);
+        if (!match)
+            continue;
+        const [, pid, days, hours, minutes, seconds] = match;
+        const elapsed = ((Number(days ?? 0) * 24 + Number(hours ?? 0)) * 60 + Number(minutes)) * 60 + Number(seconds);
+        starts.set(Number(pid), now - elapsed * 1000);
+    }
+    return starts;
+}
 /** Lists listening ports with `lsof` and `ps`, which ship with macOS. */
-export async function listMacosPorts(io) {
+export async function listMacosPorts(io, starts = new Map(), now = Date.now) {
     const listen = await io.run("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-F", "pcn"]);
     const rows = parseLsofListen(listen.stdout);
     if (rows.length === 0)
         return [];
     const pids = [...new Set(rows.map((row) => row.pid))];
-    const [cwd, ps] = await Promise.all([
+    for (const pid of starts.keys())
+        if (!pids.includes(pid))
+            starts.delete(pid);
+    const unknownStarts = pids.filter((pid) => !starts.has(pid));
+    const [cwd, ps, elapsed] = await Promise.all([
         io.run("lsof", ["-a", "-d", "cwd", "-p", pids.join(","), "-F", "pn"]),
         // -ww: without it ps cuts long paths at the terminal width.
         io.run("ps", ["-ww", "-o", "pid=,comm=", "-p", pids.join(",")]),
+        unknownStarts.length === 0
+            ? null
+            : io.run("ps", ["-o", "pid=,etime=", "-p", unknownStarts.join(",")]),
     ]);
+    const read = parsePsStartTimes(elapsed?.stdout ?? "", now());
+    for (const pid of unknownStarts)
+        starts.set(pid, read.get(pid) ?? null);
     const cwds = parseLsofCwds(cwd.stdout);
     const executables = parsePsExecutables(ps.stdout);
     const byPort = new Map();
     for (const row of rows) {
         if (byPort.has(row.port))
             continue;
+        const startedAt = starts.get(row.pid) ?? null;
         byPort.set(row.port, {
             ...row,
             cwd: cwds.get(row.pid) ?? null,
             executable: executables.get(row.pid) ?? null,
+            ...(startedAt === null ? {} : { startedAt }),
         });
     }
     return [...byPort.values()].sort((a, b) => a.port - b.port);

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

@@ -1,6 +1,7 @@
 import { request } from "node:http";
 import { STUDIO_HEADER } from "../../../core/api/contract.js";
-import { listLinuxPorts } from "./linux-ports.js";
+import { isDebuggerVersionInfo } from "../../../core/ports/helper-ports.js";
+import { listLinuxPorts, readClockTicks } from "./linux-ports.js";
 import { listMacosPorts } from "./macos-ports.js";
 import { nodeSystemIo } from "./system-io.js";
 import { listWindowsPorts } from "./windows-ports.js";
@@ -17,9 +18,12 @@ export function listPortsFor(platform, io) {
         const cache = new Map();
         return () => listWindowsPorts(io, cache);
     }
-    if (platform === "darwin")
-        return () => listMacosPorts(io);
-    return () => listLinuxPorts(io);
+    if (platform === "darwin") {
+        const starts = new Map();
+        return () => listMacosPorts(io, starts);
+    }
+    let ticks = null;
+    return () => listLinuxPorts(io, () => (ticks ??= readClockTicks(io)));
 }
 /**
  * Wraps a platform lister with the HTTP check. A port is probed once per process that owns it,
@@ -30,6 +34,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 +49,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 +85,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/infrastructure/system/windows-ports.js

@@ -58,10 +58,12 @@ export function parseWin32Processes(text) {
             continue;
         const executable = Reflect.get(item, "ExecutablePath");
         const commandLine = Reflect.get(item, "CommandLine");
+        const startedAt = Reflect.get(item, "StartedAt");
         processes.set(pid, {
             name: name.replace(/\.exe$/i, ""),
             executable: typeof executable === "string" && executable !== "" ? executable : null,
             commandLine: typeof commandLine === "string" && commandLine !== "" ? commandLine : null,
+            ...(typeof startedAt === "number" && startedAt > 0 ? { startedAt } : {}),
         });
     }
     return processes;
@@ -159,6 +161,9 @@ export async function listWindowsPorts(io, cache = new Map(), now = Date.now) {
             processName: system ?? info?.name ?? "",
             cwd: folderFromCommandLine(info?.commandLine ?? null),
             executable: info?.executable ?? null,
+            ...(system === undefined && info?.startedAt !== undefined
+                ? { startedAt: info.startedAt }
+                : {}),
         });
     }
     return [...byPort.values()].sort((a, b) => a.port - b.port);
@@ -181,7 +186,10 @@ async function readProcesses(io, pids) {
         return { processes: new Map(), complete: true };
     const filter = pids.map((pid) => `ProcessId=${pid}`).join(" OR ");
     const script = `Get-CimInstance Win32_Process -Filter '${filter}' | ` +
-        "Select-Object ProcessId, Name, ExecutablePath, CommandLine | ConvertTo-Json -Compress";
+        "Select-Object ProcessId, Name, ExecutablePath, CommandLine, " +
+        // A plain number, because ConvertTo-Json writes dates differently in each PowerShell version.
+        "@{n='StartedAt';e={if ($_.CreationDate) { [DateTimeOffset]::new($_.CreationDate).ToUnixTimeMilliseconds() }}} | " +
+        "ConvertTo-Json -Compress";
     const queried = await io.run("powershell", powershellArgs(script));
     const processes = queried.exitCode === 0 ? parseWin32Processes(queried.stdout) : new Map();
     if (processes.size > 0)

package/dist/server/interface/http/http-server.js

@@ -243,6 +243,10 @@ export function createHttpServer(options) {
                 return sendAppError(res, created.error);
             return sendJson(res, 201, created.value);
         }
+        if (pathname === API_PATHS.terminalsRecentCommands && method === "GET") {
+            const body = { recentCommands: terminals.recentCommands() };
+            return sendJson(res, 200, body);
+        }
         if (pathname === API_PATHS.terminalsEvents && method === "GET") {
             terminalStreams.list(res);
             return;

package/dist/server/interface/http/static-files.js

@@ -23,9 +23,13 @@ const CONTENT_TYPES = {
 };
 const COMPRESSIBLE = new Set([".html", ".js", ".mjs", ".css", ".json", ".map", ".svg", ".txt"]);
 const MIN_COMPRESS_BYTES = 1024;
-/** No inline scripts, no third parties, never framed. Vite builds need nothing more. */
+/**
+ * No inline scripts, no third parties, never framed. Inline styles are allowed because the
+ * terminal (xterm.js) paints ANSI colors through <style> elements it creates at runtime; scripts
+ * stay locked to the page's own files.
+ */
 const HTML_HEADERS = {
-    "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; " +
+    "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; " +
         "font-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; " +
         "form-action 'none'; frame-ancestors 'none'",
     "X-Frame-Options": "DENY",

package/dist/server/main.js

@@ -18,12 +18,14 @@ import { createDetachedLauncher } from "./infrastructure/apps/detached-launcher.
 import { JsonCustomAppStore, JsonRouteProjectStore, openWithPathFor, routeProjectsPathFor, } from "./infrastructure/apps/json-stores.js";
 import { autoNamedPathFor, JsonAutoNamedStore, } from "./infrastructure/config/json-auto-named-store.js";
 import { defaultConfigPath, JsonConfigStore } from "./infrastructure/config/json-config-store.js";
+import { JsonTerminalHistoryStore, terminalHistoryPathFor, } from "./infrastructure/config/json-terminal-history-store.js";
 import { JsonUpdateCache, updateCheckPathFor } from "./infrastructure/config/json-update-cache.js";
 import { proxyStartRecordPathFor, readProxyStartRecord, recordProxyStarts, } from "./infrastructure/config/proxy-start-record.js";
 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 +84,7 @@ export function createStudioServices(options = {}) {
         routeProjectStore: new JsonRouteProjectStore(routeProjectsPathFor(configPath)),
         containers,
         shortUrls,
+        ephemeralRange: ephemeralRangeReader(process.platform, nodeSystemIo),
     });
     const openWith = new OpenWith({
         catalog: systemAppCatalog(),
@@ -94,6 +97,7 @@ export function createStudioServices(options = {}) {
         folders: nodeTerminalFolders(),
         processTree: systemProcessTree(),
         homeDir: os.homedir(),
+        history: new JsonTerminalHistoryStore(terminalHistoryPathFor(configPath)),
         workspace: {
             openableFolders: () => runtime.openableFolders(),
             snapshot: () => runtime.readSnapshot(),
@@ -176,6 +180,7 @@ export function createUninstallServices(configPath = defaultConfigPath()) {
         routeProjectsPathFor(configPath),
         openWithPathFor(configPath),
         updateCheckPathFor(configPath),
+        terminalHistoryPathFor(configPath),
     ];
     const processes = new SystemProcessControl({
         platform: process.platform,
@@ -236,6 +241,11 @@ export async function startServer(options) {
     studio.start();
     // The short-URL forwarder settles before anyone prints or registers a URL.
     await studio.ready();
+    // Terminals that were running when Studio stopped; never holds up the start.
+    void studio
+        .settings()
+        .then((config) => services.terminals?.restore(config.restoreTerminals))
+        .catch(() => { });
     return {
         url: `http://${LOOPBACK}:${port}`,
         port,