portless-studio 0.1.1 → 0.1.3

package/dist/core/api/contract.js

@@ -29,6 +29,8 @@ export const API_PATHS = {
     studio: (action) => `/api/studio/${action}`,
     /** POST: stops a dev server listening on a detected or routed port. */
     stopProcess: (pid) => `/api/processes/${pid}/stop`,
+    /** POST: runs `docker stop` for a container the last `docker ps` listed. */
+    stopContainer: (name) => `/api/containers/${encodeURIComponent(name)}/stop`,
     /** GET: the editors found on this machine, the file manager and the custom apps. */
     openWithApps: "/api/open-with/apps",
     /** POST `OpenWithRequest`: opens a folder Studio knows with one of those apps. */
@@ -43,7 +45,16 @@ export const API_PATHS = {
     terminals: "/api/terminals",
     /** Server-sent events: `terminals` with the whole list on connect and after every change. */
     terminalsEvents: "/api/terminals/events",
-    /** GET returns `TerminalInfo`; DELETE stops the command if it runs and closes the terminal. */
+    /**
+     * POST `CreateTerminalRequest` from the page's folder picker: `cwd` may be any existing folder,
+     * typed by the person (`~` is the home folder). Every other page request runs only in folders
+     * Studio shows.
+     */
+    terminalsInFolder: "/api/terminals/in-folder",
+    /**
+     * GET returns `TerminalInfo`; PATCH `RenameTerminalRequest` renames it; DELETE stops the command
+     * if it runs and closes the terminal.
+     */
     terminal: (id) => `/api/terminals/${encodeURIComponent(id)}`,
     /** GET `?from=<seq>&max=<chars>` returns `TerminalOutputResponse`. */
     terminalOutput: (id) => `/api/terminals/${encodeURIComponent(id)}/output`,
@@ -70,6 +81,11 @@ export const API_PATHS = {
  * no custom headers.
  */
 export const TOKEN_PARAM = "token";
+/**
+ * `GET /api/snapshot?includeStudio=1` keeps Studio's own route in `routes`, which the snapshot
+ * leaves out unless `showStudioRoute` is on.
+ */
+export const INCLUDE_STUDIO_PARAM = "includeStudio";
 export const SNAPSHOT_EVENT = "snapshot";
 /** Server-sent event type that carries one `StudioEvent`. */
 export const STUDIO_EVENT = "event";

package/dist/core/config/studio-config.js

@@ -36,6 +36,9 @@ export const DEFAULT_CONFIG = {
     projectIcons: {},
     nameTemplate: DEFAULT_NAME_TEMPLATE,
     checkForUpdates: true,
+    shortUrls: false,
+    showStudioRoute: false,
+    showEphemeralPorts: false,
 };
 const MIN_SCAN_INTERVAL_MS = 1000;
 /**
@@ -57,6 +60,9 @@ export function parseConfig(input) {
         "desktopNotifications",
         "systemNotifications",
         "checkForUpdates",
+        "shortUrls",
+        "showStudioRoute",
+        "showEphemeralPorts",
     ]) {
         const value = raw[key];
         if (value === undefined)

package/dist/core/doctor/platform-commands.js

@@ -27,9 +27,12 @@ export function killCommand(platform, pids, admin) {
 export function adminWords(platform) {
     return platform === "win32" ? "from a terminal opened with Run as Administrator" : "with sudo";
 }
-/** Whether binding this port needs root. Windows and macOS (10.14 and later) let anyone bind it. */
+/**
+ * Whether portless asks for sudo to start its proxy on this port. It does on Linux and macOS for
+ * every port below 1024, even where the system would let this user bind it; Windows never asks.
+ */
 export function portNeedsRoot(platform, port) {
-    return port < 1024 && platform !== "win32" && platform !== "darwin";
+    return port < 1024 && platform !== "win32";
 }
 /** Trusts the portless certificate authority in the store this system's browsers read. */
 export function trustCertificateCommand(platform, caFile) {

package/dist/core/ports/direct-url.js

@@ -0,0 +1,7 @@
+/**
+ * The address a dev server answers on without the portless proxy, e.g. `http://localhost:3000`.
+ * For a Docker container it is the host port the container publishes.
+ */
+export function directUrl(port) {
+    return `http://localhost:${port}`;
+}

package/dist/core/ports/docker-container.js

@@ -0,0 +1,85 @@
+// Docker's own rule for container names; it also keeps names from reading as flags.
+const CONTAINER_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
+// A host binding such as `0.0.0.0:8000-8002->8000-8002/tcp` or `[::]:8080->80/tcp`.
+const BINDING = /:(\d+)(?:-(\d+))?->\d+(?:-\d+)?\/(tcp|udp|sctp)$/;
+// A range wider than this is a mistake in the compose file, not something to probe port by port.
+const MAX_RANGE = 1000;
+export function isContainerName(value) {
+    return CONTAINER_NAME.test(value);
+}
+/** Host TCP ports from the `Ports` column; unpublished ports (`80/tcp`) and UDP are skipped. */
+export function parsePublishedPorts(text) {
+    const ports = new Set();
+    for (const part of text.split(",")) {
+        const match = BINDING.exec(part.trim());
+        if (match?.[3] !== "tcp")
+            continue;
+        const first = Number(match[1]);
+        const last = match[2] === undefined ? first : Number(match[2]);
+        if (last < first || last - first >= MAX_RANGE)
+            continue;
+        for (let port = first; port <= last; port += 1) {
+            if (port >= 1 && port <= 65535)
+                ports.add(port);
+        }
+    }
+    return [...ports].sort((a, b) => a - b);
+}
+/** Reads `docker ps --format '{{json .}}'`: one JSON object per line. Bad lines are skipped. */
+export function parseDockerPs(text) {
+    const containers = [];
+    for (const raw of text.split("\n")) {
+        const row = parseLine(raw.trim());
+        if (row === null)
+            continue;
+        const name = (stringField(row, "Names") ?? "").split(",")[0]?.trim() ?? "";
+        if (!isContainerName(name))
+            continue;
+        const labels = parseLabels(stringField(row, "Labels") ?? "");
+        containers.push({
+            name,
+            image: stringField(row, "Image") ?? "",
+            composeProject: labels.get("com.docker.compose.project") || null,
+            composeService: labels.get("com.docker.compose.service") || null,
+            ports: parsePublishedPorts(stringField(row, "Ports") ?? ""),
+        });
+    }
+    return containers;
+}
+/**
+ * What the name template reads for a container: the compose service as the package and the
+ * compose project as the repository (`api.acme`), else the container name as the folder.
+ */
+export function containerProjectInfo(container) {
+    return {
+        packageName: container.composeService,
+        repoName: container.composeProject,
+        folderName: container.name,
+        worktreeName: null,
+    };
+}
+function parseLine(line) {
+    if (!line.startsWith("{"))
+        return null;
+    try {
+        const value = JSON.parse(line);
+        return typeof value === "object" && value !== null ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(row, key) {
+    const value = row[key];
+    return typeof value === "string" ? value : null;
+}
+/** `a=1,b=2`; label values with commas are rare and only the compose labels matter here. */
+function parseLabels(text) {
+    const labels = new Map();
+    for (const pair of text.split(",")) {
+        const index = pair.indexOf("=");
+        if (index > 0)
+            labels.set(pair.slice(0, index).trim(), pair.slice(index + 1).trim());
+    }
+    return labels;
+}

package/dist/core/ports/helper-ports.js

@@ -0,0 +1,86 @@
+/** Where the operating systems hand out ports for port 0 when nobody changed the setting. */
+export const DEFAULT_EPHEMERAL_RANGES = {
+    linux: { first: 32768, last: 60999 },
+    darwin: { first: 49152, last: 65535 },
+    win32: { first: 49152, last: 65535 },
+};
+/** Node (`--inspect`) and Chrome (`--remote-debugging-port`) debugger defaults. */
+export const DEBUGGER_PORTS = [9229, 9222];
+/** True for the `/json/version` answer of a V8 inspector or a Chrome DevTools endpoint. */
+export function isDebuggerVersionInfo(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    return ["V8-Version", "Browser", "Protocol-Version"].some((key) => Object.hasOwn(value, key));
+}
+export function isInRange(port, range) {
+    return range !== null && port >= range.first && port <= range.last;
+}
+/**
+ * Splits detected ports into the main list and "Other ports". A debugger, another port of the
+ * process that serves a named route, and a port in the ephemeral range are helpers, not
+ * servers a person opens. The rest is grouped per process: the lowest port outside the ephemeral
+ * range is the row, the others are its `extraPorts`.
+ */
+export function arrangeDetected(input) {
+    const main = [];
+    const otherPorts = [];
+    for (const item of input.detected) {
+        const route = siblingRoute(item, input.routes);
+        const reason = otherReason(item, route, input);
+        if (reason === null) {
+            main.push(item);
+            continue;
+        }
+        otherPorts.push({ ...item, reason, ...(route === null ? {} : { routeName: route.name }) });
+    }
+    return {
+        detected: groupByProcess(main, input.ephemeralRange),
+        otherPorts: otherPorts.sort((a, b) => a.port - b.port),
+    };
+}
+function otherReason(item, route, input) {
+    const probe = input.debuggers.get(item.port) ?? "unknown";
+    if (probe === "debugger" || (probe === "unknown" && DEBUGGER_PORTS.includes(item.port))) {
+        return "debugger";
+    }
+    if (route !== null)
+        return "sibling";
+    // Docker picks a host port in this range for `-P`; people do open those.
+    if (!item.container && !input.showEphemeral && isInRange(item.port, input.ephemeralRange)) {
+        return "ephemeral";
+    }
+    return null;
+}
+/**
+ * The named route whose process also listens on this port, like an HMR socket. Another process
+ * in the same folder is a separate server (an app and its Storybook) and stays in the main list.
+ */
+function siblingRoute(item, routes) {
+    if (item.pid === null)
+        return null;
+    return routes.find((route) => route.pid === item.pid) ?? null;
+}
+function groupByProcess(items, range) {
+    const byPid = new Map();
+    const rows = [];
+    for (const item of items) {
+        if (item.pid === null) {
+            rows.push(item);
+            continue;
+        }
+        const group = byPid.get(item.pid);
+        if (group)
+            group.push(item);
+        else
+            byPid.set(item.pid, [item]);
+    }
+    for (const group of byPid.values()) {
+        const sorted = [...group].sort((a, b) => a.port - b.port);
+        const head = sorted.find((item) => !isInRange(item.port, range)) ?? sorted[0];
+        if (head === undefined)
+            continue;
+        const extraPorts = sorted.filter((item) => item !== head).map((item) => item.port);
+        rows.push(extraPorts.length === 0 ? head : { ...head, extraPorts });
+    }
+    return rows.sort((a, b) => a.port - b.port);
+}

package/dist/core/routes/env-lines.js

@@ -0,0 +1,72 @@
+import { directUrl } from "../ports/direct-url.js";
+import { err, ok } from "../result.js";
+const VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** `api.acme` -> `API_ACME_URL`, with the strip suffix removed and the prefix in front. */
+export function envKey(name, options = {}) {
+    const suffix = stripSuffix(options.strip);
+    const base = suffix !== null && name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;
+    const words = base
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    const key = `${words === "" ? "" : `${words}_`}URL`;
+    const prefix = options.prefix ?? "";
+    if (prefix === "")
+        return /^[0-9]/.test(key) ? `_${key}` : key;
+    return `${prefix.endsWith("_") ? prefix : `${prefix}_`}${key}`;
+}
+/**
+ * Keeps the routes the names point at: a name matches itself and every route ending in `.<name>`,
+ * so `acme` picks `api.acme` and `web.acme`. No names keeps every route.
+ */
+export function selectEnvRoutes(routes, names) {
+    if (names.length === 0)
+        return ok([...routes]);
+    const matches = (route, name) => route.name === name || route.name.endsWith(`.${name}`);
+    const missing = names.find((name) => !routes.some((route) => matches(route, name)));
+    if (missing !== undefined)
+        return err(`No route matches "${missing}".`);
+    return ok(routes.filter((route) => names.some((name) => matches(route, name))));
+}
+/** One key and value per route, sorted by route name; fails on a bad prefix or a repeated key. */
+export function envEntries(routes, options = {}) {
+    const prefix = options.prefix ?? "";
+    if (prefix !== "" && !VARIABLE_NAME.test(prefix)) {
+        return err(`The prefix "${prefix}" must use letters, digits and _, and not start with a digit.`);
+    }
+    const sorted = [...routes].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const entries = [];
+    for (const route of sorted) {
+        const key = envKey(route.name, options);
+        const taken = entries.find((entry) => entry.key === key);
+        if (taken) {
+            return err(`${taken.name} and ${route.name} both become ${key}. Pass only one of them, or change the strip suffix.`);
+        }
+        entries.push({
+            name: route.name,
+            key,
+            value: options.direct ? directUrl(route.port) : route.url,
+        });
+    }
+    return ok(entries);
+}
+/** `KEY=value` lines for a `.env` file, one per route. */
+export function envLines(routes, options = {}) {
+    const entries = envEntries(routes, options);
+    if (!entries.ok)
+        return entries;
+    return ok(entries.value.map(formatEnvLine));
+}
+export function formatEnvLine(entry) {
+    return `${entry.key}=${quoteEnvValue(entry.value)}`;
+}
+/** Double quotes only when a `.env` reader would otherwise cut or change the value. */
+function quoteEnvValue(value) {
+    if (value !== "" && !/[\s#"'`$\\]/.test(value))
+        return value;
+    return `"${value.replace(/[\\"]/g, (char) => `\\${char}`)}"`;
+}
+function stripSuffix(strip) {
+    const trimmed = strip?.trim().replace(/^\.+/, "") ?? "";
+    return trimmed === "" ? null : `.${trimmed}`;
+}

package/dist/core/routes/route.js

@@ -19,10 +19,22 @@ export function nameFromHostname(hostname, tlds) {
     }
     return hostname;
 }
-/** Builds the browser URL; omits the port when it is the protocol default. */
+/**
+ * Builds the browser URL on the port names open on: the public port when there is one, else the
+ * proxy's. Omits the port when it is the protocol default.
+ */
 export function routeUrl(hostname, proxy) {
     const scheme = proxy.https ? "https" : "http";
     const defaultPort = proxy.https ? 443 : 80;
-    const port = proxy.port === null || proxy.port === defaultPort ? "" : `:${proxy.port}`;
+    const open = proxy.publicPort ?? proxy.port;
+    const port = open === null || open === defaultPort ? "" : `:${open}`;
     return `${scheme}://${hostname}${port}`;
 }
+/** Points every route URL at `publicPort`, the port Studio forwards to the proxy; null keeps them. */
+export function withPublicPort(state, publicPort) {
+    if (publicPort === null)
+        return state;
+    const proxy = { ...state.proxy, publicPort };
+    const routes = state.routes.map((route) => ({ ...route, url: routeUrl(route.hostname, proxy) }));
+    return { ...state, proxy, routes };
+}

package/dist/server/application/container-source.js

@@ -0,0 +1,19 @@
+import { isContainerName } from "../../core/ports/docker-container.js";
+import { err, ok } from "../../core/result.js";
+import { appError } from "./app-error.js";
+/**
+ * Stops a container from its row. Only a container the last `docker ps` listed can be stopped, so
+ * the endpoint cannot be used to stop anything else.
+ */
+export async function stopContainer(name, source) {
+    if (!isContainerName(name)) {
+        return err(appError("invalid_request", "That is not a Docker container name."));
+    }
+    const reading = await source.read();
+    const listed = reading.state === "ok" && reading.containers.some((item) => item.name === name);
+    if (!listed) {
+        return err(appError("process_not_allowed", `Container ${name} is not one Studio shows; it may have stopped.`));
+    }
+    const stopped = await source.stop(name);
+    return stopped.ok ? ok({ name }) : stopped;
+}

package/dist/server/application/doctor.js

@@ -10,11 +10,13 @@ export function diagnose(facts) {
         pushIf(checks, proxyCountCheck(facts));
         pushIf(checks, httpsTrustCheck(facts));
         pushIf(checks, routesFileCheck(facts));
+        pushIf(checks, shorterUrlsCheck(facts));
     }
     checks.push(studioPortCheck(facts));
     pushIf(checks, loginServiceCheck(facts));
     pushIf(checks, safariCheck(facts));
     pushIf(checks, notificationsCheck(facts));
+    pushIf(checks, dockerCheck(facts));
     return checks;
 }
 export function createDoctorService(deps) {
@@ -42,15 +44,59 @@ async function runAction(action, facts, deps) {
         return deps.controlProxy("start");
     if (action === "restart-proxy")
         return deps.controlProxy("restart");
-    const saved = await deps.updateConfig({ ...facts.config, proxyPort: 1355, proxyHttps: false });
+    if (action === "use-short-urls")
+        return turnOnShortUrls(facts, deps);
+    const http = { ...facts.config, proxyPort: 1355, proxyHttps: false };
+    return applyProxyConfig(http, "HTTP on port 1355", facts, deps);
+}
+/**
+ * Turns `shortUrls` on and checks that Studio really listens on port 80. The proxy keeps its
+ * port and keeps running; when the listen fails, the previous config comes back.
+ */
+async function turnOnShortUrls(facts, deps) {
+    const config = { ...facts.config, shortUrls: true };
+    const saved = await deps.updateConfig(config);
     if (!saved.ok)
         return saved;
-    if (!facts.proxy.running)
-        return deps.controlProxy("start");
-    if (facts.proxyOwner === "you")
-        return deps.controlProxy("restart");
-    return ok(`Saved HTTP on port 1355. Stop the current proxy with \`${stopProxyAsAdminCommand(facts.platform)}\` ` +
-        `${adminWords(facts.platform)}, then start the new one from the proxy menu.`);
+    const status = await deps.syncShortUrls(config);
+    if (status.state === "listening") {
+        return ok("Names now open as http://name.localhost: Studio forwards port " +
+            `${status.port} to the proxy on port ${status.target}.`);
+    }
+    await deps.updateConfig(facts.config);
+    await deps.syncShortUrls(facts.config);
+    const why = status.state === "failed" ? `${status.message} ` : "";
+    const code = status.state === "failed" && status.reason === "in-use" ? "port_in_use" : "command_failed";
+    return err(appError(code, `${why}Studio kept the previous settings, so names still open with ` +
+        `:${facts.config.proxyPort}.`));
+}
+/**
+ * Saves the proxy settings, then starts or restarts the proxy with them when Studio may. When
+ * that start fails, the previous settings come back and a proxy that was running starts again on
+ * them, so names keep working.
+ */
+async function applyProxyConfig(config, what, facts, deps) {
+    const saved = await deps.updateConfig(config);
+    if (!saved.ok)
+        return saved;
+    if (facts.proxy.running && facts.proxyOwner !== "you") {
+        return ok(`Saved ${what}. Stop the current proxy with \`${stopProxyAsAdminCommand(facts.platform)}\` ` +
+            `${adminWords(facts.platform)}, then start the new one from the proxy menu.`);
+    }
+    const started = await deps.controlProxy(facts.proxy.running ? "restart" : "start");
+    if (started.ok)
+        return started;
+    await deps.updateConfig(facts.config);
+    let back = "Studio went back to the previous settings.";
+    if (facts.proxy.running) {
+        const again = await deps.controlProxy("start");
+        if (again.ok) {
+            back =
+                "Studio went back to the previous settings and started the proxy on port " +
+                    `${facts.config.proxyPort} again.`;
+        }
+    }
+    return err({ ...started.error, message: `${started.error.message} ${back}` });
 }
 function portlessCheck({ portless }) {
     if (portless.installed) {
@@ -106,8 +152,9 @@ function proxyRunningCheck(facts) {
         status: "warn",
         title: "The proxy is not running",
         detail: needsSudo
-            ? `Names do not open until it runs. Port ${config.proxyPort} needs sudo, so Studio cannot ` +
-                "start it; HTTP on port 1355 needs nothing."
+            ? `Names do not open until it runs. portless asks for sudo below port 1024, so Studio ` +
+                `cannot start it on port ${config.proxyPort}; HTTP on port 1355 needs nothing, and short ` +
+                "URLs drop the port from names."
             : "Names do not open until it runs.",
         fix: needsSudo
             ? { label: "Use HTTP on port 1355", action: "use-http-1355" }
@@ -327,6 +374,149 @@ function notificationsCheck({ config, systemNotifier }) {
         fix: { label: "Install notify-send", command: "sudo apt install libnotify-bin" },
     };
 }
+const UNPRIVILEGED_PORT_SETTING = "net.ipv4.ip_unprivileged_port_start=80";
+/**
+ * Short URLs drop the port number from every name (`http://name.localhost`). Studio itself listens
+ * on port 80 and forwards to the proxy, only when a test bind shows this user may listen there
+ * without sudo; it never changes the system.
+ */
+function shorterUrlsCheck(facts) {
+    const { proxy, config, platform, port80, shortUrls } = facts;
+    const https = proxy.running ? proxy.https : config.proxyHttps;
+    if (https) {
+        if (!config.shortUrls)
+            return null;
+        return {
+            id: "shorter-urls",
+            status: "ok",
+            title: "Short URLs work over HTTP only",
+            detail: "The proxy serves HTTPS, so names keep their port. Switch the proxy to HTTP to open " +
+                "them as http://name.localhost.",
+        };
+    }
+    const port = (proxy.running ? proxy.port : null) ?? config.proxyPort;
+    if (port === 80) {
+        return {
+            id: "shorter-urls",
+            status: "ok",
+            title: "Names open without a port number",
+            detail: "The proxy uses port 80, so names open as http://name.localhost.",
+        };
+    }
+    if (shortUrls?.state === "listening") {
+        return {
+            id: "shorter-urls",
+            status: "ok",
+            title: "Names open without a port number",
+            detail: `Studio listens on port ${shortUrls.port} and forwards to the proxy on port ` +
+                `${shortUrls.target}, so names open as http://name.localhost.`,
+        };
+    }
+    const now = `Names open as http://name.localhost:${port}`;
+    if (config.shortUrls)
+        return failedShortUrlsCheck(facts, now);
+    if (port80 === undefined)
+        return null;
+    if (port80 === "free") {
+        return {
+            id: "shorter-urls",
+            status: "ok",
+            title: "Shorter URLs: port 80 is available",
+            detail: `${now}. This user can listen on port 80 without sudo, so Studio can listen there and ` +
+                `forward to the proxy, and names open as http://name.localhost. The proxy stays on ` +
+                `port ${port}.`,
+            fix: { label: "Use short URLs", action: "use-short-urls" },
+        };
+    }
+    if (port80 === "in-use") {
+        return {
+            id: "shorter-urls",
+            status: "ok",
+            title: "Port 80 is taken by another program",
+            detail: `${now}. Stop the program on port 80 to drop the port number from names.`,
+        };
+    }
+    if (platform !== "linux") {
+        return {
+            id: "shorter-urls",
+            status: "ok",
+            title: "Shorter URLs: this system does not allow port 80",
+            detail: `${now}. This user cannot listen on port 80 here, so names keep the port.`,
+        };
+    }
+    return {
+        id: "shorter-urls",
+        status: "ok",
+        title: "Shorter URLs need a one-time system setting",
+        detail: `${now}. ${SYSCTL_ADVICE} Then run the checks again and choose Use short URLs.`,
+        fix: SYSCTL_FIX,
+    };
+}
+/** `shortUrls` is on and Studio does not listen: names still work, with the port. */
+function failedShortUrlsCheck(facts, now) {
+    const { platform, port80, shortUrls } = facts;
+    const reason = shortUrls?.state === "failed" ? shortUrls.reason : port80;
+    const retry = port80 === "free"
+        ? { fix: { label: "Try port 80 again", action: "use-short-urls" } }
+        : {};
+    if (reason === "in-use") {
+        return {
+            id: "shorter-urls",
+            status: "warn",
+            title: "Short URLs are on, but port 80 is taken by another program",
+            detail: `${now}. Stop the program on port 80, then run the checks again.`,
+            ...retry,
+        };
+    }
+    if (reason === "denied" && platform === "linux" && port80 !== "free") {
+        return {
+            id: "shorter-urls",
+            status: "warn",
+            title: "Short URLs are on, but Linux does not let this user listen on port 80",
+            detail: `${now}. ${SYSCTL_ADVICE} Then run the checks again and choose Try port 80 again.`,
+            fix: SYSCTL_FIX,
+        };
+    }
+    return {
+        id: "shorter-urls",
+        status: "warn",
+        title: "Short URLs are on, but Studio does not listen on port 80",
+        detail: shortUrls?.state === "failed"
+            ? `${now}. Studio could not listen there: ${shortUrls.message}`
+            : `${now}. Studio is not running, or has not tried port 80 yet.`,
+        ...retry,
+    };
+}
+const SYSCTL_ADVICE = "Linux lets only root listen on ports below 1024. The command lets every user on this machine " +
+    "listen on port 80 and up until the next restart; Studio never runs it. To keep it after a " +
+    `restart, also run \`echo '${UNPRIVILEGED_PORT_SETTING}' | sudo tee ` +
+    "/etc/sysctl.d/99-portless-studio.conf`.";
+const SYSCTL_FIX = {
+    label: "Allow port 80 until the next restart",
+    command: `sudo sysctl -w ${UNPRIVILEGED_PORT_SETTING}`,
+};
+/** Information only: without Docker, container ports simply do not show. */
+function dockerCheck({ docker }) {
+    if (docker === undefined || docker.state === "missing")
+        return null;
+    if (docker.state === "ok") {
+        const count = docker.containers === 1 ? "1 running container" : `${docker.containers} running containers`;
+        return {
+            id: "docker",
+            status: "ok",
+            title: "Studio reads Docker containers",
+            detail: `docker ps lists ${count}; the ports they publish show under Detected.`,
+        };
+    }
+    return {
+        id: "docker",
+        status: "ok",
+        title: "Studio cannot read Docker containers",
+        detail: "The docker command is installed, but docker ps did not answer: Docker is not running, " +
+            "or this user may not use it (on Linux, the docker group). Ports of containers do not " +
+            "show under Detected until it answers.",
+    };
+}
 function startCommand(config) {
     const tls = config.proxyHttps ? "--https" : "--no-tls";
     return `portless proxy start --port ${config.proxyPort} ${tls}`;