portless-studio 0.1.0 → 0.1.2

package/dist/server/infrastructure/portless/portless-registry.js

@@ -2,7 +2,10 @@ import * as fs from "node:fs";
 import { err, ok } from "../../../core/result.js";
 import { appError } from "../../application/app-error.js";
 import { addAlias, detectPortless, installPortless, removeAlias, startProxy, stopProxy, } from "./portless-cli.js";
-import { readProxyPid, readProxyStatus, readRoutes } from "./state-files.js";
+import { readProxyPid, readProxyStatus, readRouteEntries, routesFromEntries, } from "./state-files.js";
+/** How long a write waits for a half-written `routes.json` to be whole again. */
+const TORN_RETRIES = 10;
+const TORN_RETRY_MS = 50;
 /** Reads portless state files directly and writes through the portless CLI, which owns the lock. */
 export class PortlessRegistry {
     #stateDir;
@@ -16,6 +19,8 @@ export class PortlessRegistry {
     // Bumped by an install, so a detection that started before it cannot cache a stale answer.
     #detectGeneration = 0;
     #installing = false;
+    /** The entries of the last `routes.json` that parsed, shown while portless rewrites it. */
+    #lastEntries = [];
     /** One per watcher: compares the installation with what that watcher last saw. */
     #installationChecks = new Set();
     constructor(options) {
@@ -29,7 +34,7 @@ export class PortlessRegistry {
     async readSnapshot() {
         const portless = await this.#detect();
         const proxy = readProxyStatus(this.#stateDir);
-        return { proxy, portless, routes: readRoutes(this.#stateDir, proxy), readAt: Date.now() };
+        return { proxy, portless, routes: this.#routes(proxy), readAt: Date.now() };
     }
     watch(onChange) {
         let last = this.#fingerprint();
@@ -103,8 +108,9 @@ export class PortlessRegistry {
     }
     async createAlias(name, port, force) {
         // `portless alias` silently replaces an existing alias, so the conflict check lives here.
+        await this.#waitForWholeRoutesFile();
         const proxy = readProxyStatus(this.#stateDir);
-        const existing = readRoutes(this.#stateDir, proxy).find((route) => route.name === name);
+        const existing = this.#routes(proxy).find((route) => route.name === name);
         if (existing && !force) {
             if (existing.port === port)
                 return ok(undefined);
@@ -149,6 +155,27 @@ export class PortlessRegistry {
     /** The snapshot without its read time, so two reads of the same state compare equal. */
     #fingerprint() {
         const proxy = readProxyStatus(this.#stateDir);
-        return JSON.stringify({ proxy, routes: readRoutes(this.#stateDir, proxy) });
+        return JSON.stringify({ proxy, routes: this.#routes(proxy) });
+    }
+    /**
+     * Routes from `routes.json`. portless rewrites the file in place, so a read can land on an empty
+     * or cut-off file; that read keeps the last entries that parsed, and the next file event or poll
+     * reads it again. A missing file, or one in a format Studio does not know, means no routes.
+     */
+    #routes(proxy) {
+        const read = readRouteEntries(this.#stateDir);
+        if (read.kind === "ok")
+            this.#lastEntries = read.entries;
+        else if (read.kind !== "torn")
+            this.#lastEntries = [];
+        return routesFromEntries(this.#lastEntries, proxy);
+    }
+    /** Gives portless a moment to finish a write, so a name check never runs on a torn file. */
+    async #waitForWholeRoutesFile() {
+        for (let attempt = 0; attempt < TORN_RETRIES; attempt += 1) {
+            if (readRouteEntries(this.#stateDir).kind !== "torn")
+                return;
+            await new Promise((resolve) => setTimeout(resolve, TORN_RETRY_MS));
+        }
     }
 }

package/dist/server/infrastructure/portless/state-files.js

@@ -34,21 +34,29 @@ export function readProxyPid(dir) {
     const pid = Number.parseInt(readText(dir, PID_FILE) ?? "", 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
 }
-/** Live routes from `routes.json`. Invalid entries and apps whose process died are left out. */
-export function readRoutes(dir, proxy) {
+export function readRouteEntries(dir) {
     const raw = readText(dir, ROUTES_FILE);
     if (raw === null)
-        return [];
+        return { kind: "missing" };
+    if (raw.trim() === "")
+        return { kind: "torn" };
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        return [];
+        return { kind: "torn" };
     }
-    if (!Array.isArray(parsed))
-        return [];
-    return parsed
+    return Array.isArray(parsed) ? { kind: "ok", entries: parsed } : { kind: "unexpected" };
+}
+/** Live routes from `routes.json`. Invalid entries and apps whose process died are left out. */
+export function readRoutes(dir, proxy) {
+    const read = readRouteEntries(dir);
+    return read.kind === "ok" ? routesFromEntries(read.entries, proxy) : [];
+}
+/** The routes in a parsed `routes.json`, without invalid entries and apps whose process died. */
+export function routesFromEntries(entries, proxy) {
+    return entries
         .flatMap((entry) => {
         const route = toRoute(entry, proxy);
         return route ? [route] : [];
@@ -56,6 +64,14 @@ export function readRoutes(dir, proxy) {
         .filter((route) => route.pid === null || isProcessAlive(route.pid))
         .sort((a, b) => a.name.localeCompare(b.name));
 }
+export function inspectRoutesFile(dir) {
+    const read = readRouteEntries(dir);
+    if (read.kind !== "ok")
+        return { state: read.kind, entries: 0, unreadable: 0 };
+    const proxy = { running: false, port: null, https: false, tlds: [DEFAULT_TLD] };
+    const unreadable = read.entries.filter((entry) => toRoute(entry, proxy) === null).length;
+    return { state: "ok", entries: read.entries.length, unreadable };
+}
 /** Signal 0 checks existence without touching the process; EPERM means it exists. */
 export function isProcessAlive(pid) {
     try {

package/dist/server/infrastructure/system/docker-containers.js

@@ -0,0 +1,64 @@
+import { parseDockerPs } from "../../../core/ports/docker-container.js";
+import { err, ok } from "../../../core/result.js";
+import { appError } from "../../application/app-error.js";
+import { execute } from "../portless/portless-cli.js";
+/** A scan runs every few seconds; one `docker ps` serves the scans in between. */
+const FRESH_MS = 3000;
+/** Docker that is stopped or refuses this user is asked again less often. */
+const UNAVAILABLE_MS = 15_000;
+/** No `docker` on PATH: asked again in case it gets installed. */
+const MISSING_MS = 60_000;
+const LIST_TIMEOUT_MS = 2000;
+/** `docker stop` waits up to 10 seconds for the container before it kills it. */
+const STOP_TIMEOUT_MS = 30_000;
+const LIST_ARGS = ["ps", "--format", "{{json .}}"];
+const defaultRun = (args, timeoutMs) => execute("docker", args, { timeoutMs });
+/**
+ * Reads running containers with `docker ps`, which works the same with Docker Engine on Linux and
+ * with Docker Desktop, OrbStack or Colima on macOS and Windows. Any failure reads as no containers.
+ */
+export class DockerContainers {
+    #run;
+    #now;
+    #last = null;
+    #reading = null;
+    constructor(options = {}) {
+        this.#run = options.run ?? defaultRun;
+        this.#now = options.now ?? Date.now;
+    }
+    read() {
+        const last = this.#last;
+        if (last && this.#now() - last.at < maxAge(last.reading))
+            return Promise.resolve(last.reading);
+        this.#reading ??= this.#list().then((reading) => {
+            this.#last = { reading, at: this.#now() };
+            this.#reading = null;
+            return reading;
+        });
+        return this.#reading;
+    }
+    async stop(name) {
+        const outcome = await this.#run(["stop", name], STOP_TIMEOUT_MS).catch(() => null);
+        // The next read lists the containers again instead of showing the stopped one.
+        this.#last = null;
+        if (outcome?.exitCode === 0)
+            return ok(undefined);
+        const printed = outcome?.combined.trim() ?? "";
+        return err(appError("command_failed", printed || `docker stop ${name} did not finish.`, `docker stop ${name}`));
+    }
+    async #list() {
+        const outcome = await this.#run(LIST_ARGS, LIST_TIMEOUT_MS).catch(() => null);
+        if (outcome === null)
+            return { state: "unavailable" };
+        if (outcome.missing)
+            return { state: "missing" };
+        if (outcome.exitCode !== 0)
+            return { state: "unavailable" };
+        return { state: "ok", containers: parseDockerPs(outcome.stdout) };
+    }
+}
+function maxAge(reading) {
+    if (reading.state === "ok")
+        return FRESH_MS;
+    return reading.state === "missing" ? MISSING_MS : UNAVAILABLE_MS;
+}

package/dist/server/infrastructure/system/doctor-facts.js

@@ -1,3 +1,4 @@
+import { request } from "node:http";
 import { createServer } from "node:net";
 import * as path from "node:path";
 import { DEFAULT_CONFIG } from "../../../core/config/studio-config.js";
@@ -99,19 +100,22 @@ export async function proxyPidsAmong(platform, io, pids) {
 /** Gathers the facts the doctor checks. Each part is read once; nothing is changed. */
 export async function collectDoctorFacts(options) {
     const { platform, registry, configStore } = options;
-    const [state, proxyPid, stored, proxyProcesses, loginService, systemNotifier] = await Promise.all([
+    const [state, proxyPid, stored, proxyProcesses, loginService, systemNotifier, docker, port80] = await Promise.all([
         registry.readSnapshot(),
         registry.proxyPid(),
         configStore.read(),
         listProxyProcesses(platform, options.io, options.uid),
         options.loginService ? options.loginService() : Promise.resolve(null),
         options.systemNotifier ? options.systemNotifier() : Promise.resolve(undefined),
+        options.docker ? dockerFacts(options.docker) : Promise.resolve(undefined),
+        options.lowPort ? options.lowPort(80) : Promise.resolve(undefined),
     ]);
     const config = stored.ok ? stored.value : DEFAULT_CONFIG;
     const proxyOwner = state.proxy.running && proxyPid !== null
         ? await options.processes.ownerOf(proxyPid)
         : "unknown";
     const https = state.proxy.running ? state.proxy.https : config.proxyHttps;
+    const shortUrls = await options.shortUrls?.(config).catch(() => undefined);
     return {
         platform,
         portless: state.portless,
@@ -127,8 +131,47 @@ export async function collectDoctorFacts(options) {
         studioPort: { port: config.port, holder: await portHolder(config.port, options) },
         loginService,
         ...(systemNotifier === undefined ? {} : { systemNotifier }),
+        ...(options.routesFile ? { routesFile: options.routesFile() } : {}),
+        ...(docker === undefined ? {} : { docker }),
+        ...(port80 === undefined ? {} : { port80 }),
+        ...(shortUrls === undefined ? {} : { shortUrls }),
     };
 }
+/** Only how many containers run reaches the doctor, never their names. */
+async function dockerFacts(read) {
+    const reading = await read().catch(() => ({ state: "unavailable" }));
+    return reading.state === "ok"
+        ? { state: "ok", containers: reading.containers.length }
+        : { state: reading.state };
+}
+/**
+ * Tries to listen on a loopback port and closes it at once, without sudo: `denied` when the system
+ * refuses this user (Linux below `ip_unprivileged_port_start`), `in-use` when a program holds it.
+ */
+export function testBind(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", (error) => resolve(error.code === "EADDRINUSE" ? "in-use" : "denied"));
+        server.listen({ port, host: "127.0.0.1", exclusive: true }, () => server.close(() => resolve("free")));
+    });
+}
+/**
+ * Whether a request to this loopback port reaches a portless proxy (it sends `X-Portless`), as it
+ * does through Studio's short-URL forwarder.
+ */
+export function reachesPortless(port, timeoutMs = 1000) {
+    return new Promise((resolve) => {
+        const req = request({ host: "127.0.0.1", port, method: "HEAD", path: "/", timeout: timeoutMs, agent: false }, (res) => {
+            res.resume();
+            req.destroy();
+            resolve(res.headers["x-portless"] !== undefined);
+        });
+        req.on("timeout", () => req.destroy());
+        req.on("error", () => resolve(false));
+        req.on("close", () => resolve(false));
+        req.end();
+    });
+}
 /** Paths are built for the platform the facts describe, not the one running the code. */
 function pathsOf(platform) {
     return platform === "win32" ? path.win32 : path.posix;

package/dist/server/infrastructure/system/npm-registry.js

@@ -0,0 +1,20 @@
+/** Public npm metadata of the latest release; Studio sends nothing but this GET. */
+export const LATEST_RELEASE_URL = "https://registry.npmjs.org/portless-studio/latest";
+const TIMEOUT_MS = 3000;
+/** The `version` npm reports as latest, or null on any failure, including the 3 s timeout. */
+export async function fetchLatestVersion(options = {}) {
+    const fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+    try {
+        const response = await fetchImpl(options.url ?? LATEST_RELEASE_URL, {
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        const body = await response.json();
+        const version = typeof body === "object" && body !== null ? Reflect.get(body, "version") : undefined;
+        return typeof version === "string" && /^\d+\.\d+\.\d+\S*$/.test(version) ? version : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,78 @@
+import { createServer, connect as tcpConnect } from "node:net";
+import { err, ok } from "../../../core/result.js";
+/** Loopback on IPv4 and IPv6, because browsers may resolve `name.localhost` to either. */
+export const LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
+/** A system without IPv6 cannot bind `::1`; that is not a failure when IPv4 works. */
+const NO_ADDRESS = new Set(["EADDRNOTAVAIL", "EAFNOSUPPORT"]);
+/**
+ * Listens on loopback and pipes every TCP connection to the target, byte for byte. Piping the
+ * connection rather than re-sending requests keeps the Host header, the method, streamed bodies,
+ * keep-alive and WebSocket upgrades exactly as the browser sent them; portless then adds its own
+ * `X-Forwarded-*` headers from that Host. Never asks for more rights: a refused bind is reported.
+ */
+export async function startForwarder(options) {
+    const hosts = options.hosts ?? LOOPBACK_HOSTS;
+    const targetHost = options.targetHost ?? "127.0.0.1";
+    const sockets = new Set();
+    const servers = [];
+    let port = options.port;
+    const handle = (client) => {
+        const upstream = tcpConnect({ host: targetHost, port: options.targetPort });
+        sockets.add(client);
+        sockets.add(upstream);
+        client.setNoDelay(true);
+        upstream.setNoDelay(true);
+        const finish = () => {
+            client.destroy();
+            upstream.destroy();
+            sockets.delete(client);
+            sockets.delete(upstream);
+        };
+        client.on("error", finish);
+        upstream.on("error", finish);
+        client.on("close", finish);
+        upstream.on("close", finish);
+        client.pipe(upstream);
+        upstream.pipe(client);
+    };
+    const close = async () => {
+        for (const socket of sockets)
+            socket.destroy();
+        sockets.clear();
+        await Promise.all(servers.map((server) => new Promise((resolve) => server.close(() => resolve()))));
+    };
+    for (const [index, host] of hosts.entries()) {
+        const server = createServer(handle);
+        const bound = await new Promise((resolve) => {
+            server.once("error", resolve);
+            server.listen({ port, host, exclusive: true }, () => {
+                server.off("error", resolve);
+                resolve(null);
+            });
+        });
+        if (bound === null) {
+            servers.push(server);
+            // Port 0 picks a free port on the first host; the others use that same one.
+            if (index === 0)
+                port = server.address().port;
+            continue;
+        }
+        if (index > 0 && NO_ADDRESS.has(bound.code ?? ""))
+            continue;
+        await close();
+        return err(failureOf(bound, port));
+    }
+    return ok({ port, close });
+}
+function failureOf(error, port) {
+    if (error.code === "EADDRINUSE") {
+        return { reason: "in-use", message: `port ${port} is in use by another program.` };
+    }
+    if (error.code === "EACCES" || error.code === "EPERM") {
+        return {
+            reason: "denied",
+            message: `this system does not let this user listen on port ${port} without sudo.`,
+        };
+    }
+    return { reason: "failed", message: `could not listen on port ${port}: ${error.message}` };
+}

package/dist/server/infrastructure/system/process-runner.js

@@ -64,7 +64,8 @@ export function resolveWindowsCommand(bin, lookup) {
     return null;
 }
 const found = new Map();
-function nodeWindowsLookup() {
+/** PATH, PATHEXT and file checks of this machine, for `resolveWindowsCommand`. */
+export function nodeWindowsLookup() {
     const pathValue = process.env.PATH ?? process.env.Path ?? "";
     return {
         pathDirs: pathValue

package/dist/server/infrastructure/terminal/process-tree.js

@@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+import { runProcess } from "../system/process-runner.js";
+/** Deeper than any real chain of shells and tools; a guard against a bad read. */
+const MAX_DEPTH = 64;
+/** One `ps` answer serves every pid of a scan on macOS. */
+const PS_CACHE_MS = 2_000;
+/** The parent pid in the text of `/proc/<pid>/stat`; the name in parentheses may hold anything. */
+export function parseStatParent(stat) {
+    const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+    const parent = Number(fields[1]);
+    return stat.includes(")") && Number.isInteger(parent) ? parent : null;
+}
+/** Every pid's parent from `ps -A -o pid=,ppid=`. */
+export function parsePsParents(output) {
+    const parents = new Map();
+    for (const line of output.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+        if (match)
+            parents.set(Number(match[1]), Number(match[2]));
+    }
+    return parents;
+}
+/** The parent, its parent and so on, ending before pid 0 or at a pid already seen. */
+export function walkAncestors(pid, parentOf) {
+    const ancestors = [];
+    const seen = new Set([pid]);
+    let current = parentOf(pid);
+    while (current !== null && current > 0 && !seen.has(current) && ancestors.length < MAX_DEPTH) {
+        ancestors.push(current);
+        seen.add(current);
+        current = parentOf(current);
+    }
+    return ancestors;
+}
+/**
+ * Parent processes on this machine: `/proc` on Linux, one `ps` on macOS. Windows answers nothing,
+ * so terminals there list no ports.
+ */
+export function systemProcessTree(platform = process.platform) {
+    if (platform === "linux") {
+        return {
+            ancestors: async (pid) => walkAncestors(pid, (current) => {
+                try {
+                    return parseStatParent(fs.readFileSync(`/proc/${current}/stat`, "utf8"));
+                }
+                catch {
+                    return null;
+                }
+            }),
+        };
+    }
+    if (platform === "darwin") {
+        let cached = null;
+        const table = () => {
+            if (!cached || Date.now() - cached.at > PS_CACHE_MS) {
+                cached = {
+                    at: Date.now(),
+                    parents: runProcess("ps", ["-A", "-o", "pid=,ppid="], { timeoutMs: 3_000 }).then((outcome) => parsePsParents(outcome.exitCode === 0 ? outcome.stdout : "")),
+                };
+            }
+            return cached.parents;
+        };
+        return {
+            ancestors: async (pid) => {
+                const parents = await table();
+                return walkAncestors(pid, (current) => parents.get(current) ?? null);
+            },
+        };
+    }
+    return { ancestors: async () => [] };
+}

package/dist/server/infrastructure/terminal/terminal-spawner.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { runProcess, stopProcessTree } from "../system/process-runner.js";
+import { nodeWindowsLookup, resolveWindowsCommand, runProcess, stopProcessTree, } from "../system/process-runner.js";
 /** Output still in the pipes when a process exits arrives right after; a child holding them does not. */
 const DRAIN_AFTER_EXIT_MS = 500;
 /**
@@ -15,6 +15,16 @@ export function planTerminal(request, context) {
     const env = { ...request.env };
     if (context.platform === "win32") {
         env.FORCE_COLOR = "1";
+        if (request.command === null && context.windowsShell) {
+            // With pipes PowerShell shows no prompt, but reads and runs each line it is given.
+            return {
+                file: context.windowsShell,
+                args: ["-NoLogo", "-Command", "-"],
+                env,
+                detached: false,
+                windowsVerbatimArguments: false,
+            };
+        }
         const args = request.command === null ? ["/d"] : ["/d", "/s", "/c", `"${request.command}"`];
         return {
             file: context.comSpec,
@@ -27,11 +37,12 @@ export function planTerminal(request, context) {
     if (context.mode === "pipes") {
         env.FORCE_COLOR = "1";
         const args = request.command === null
-            ? ["-c", `exec ${quote(context.shell)} -i`]
+            ? ["-c", `exec ${quote(context.shell)} -l -i`]
             : ["-c", request.command];
         return { file: "/bin/sh", args, env, detached: true, windowsVerbatimArguments: false };
     }
-    const run = request.command ?? `exec ${quote(context.shell)}`;
+    // A login shell reads the profile the person's own terminal reads (PATH, nvm and the like).
+    const run = request.command ?? `exec ${quote(context.shell)} -l`;
     const inner = `stty cols ${request.cols} rows ${request.rows} 2>/dev/null; ${run}`;
     // util-linux script runs `$SHELL -c`; /bin/sh keeps the command's meaning the same everywhere.
     env.SHELL = "/bin/sh";
@@ -40,6 +51,15 @@ export function planTerminal(request, context) {
         : ["-q", "-f", "-e", "-c", inner, "/dev/null"];
     return { file: "script", args, env, detached: true, windowsVerbatimArguments: false };
 }
+/** The interactive shell's short name, e.g. `zsh` or `pwsh`: the default title of a shell terminal. */
+export function shellName(context) {
+    if (context.platform === "win32") {
+        if (!context.windowsShell)
+            return "cmd";
+        return path.win32.basename(context.windowsShell).replace(/\.exe$/i, "");
+    }
+    return path.posix.basename(context.shell) || "shell";
+}
 /**
  * Whether this machine can run pseudo-terminals through `script`: util-linux's on Linux (BusyBox
  * and others take different flags), the system one on macOS, never on Windows.
@@ -62,9 +82,15 @@ export function createTerminalSpawner(options) {
         mode,
         shell: baseEnv.SHELL || "/bin/sh",
         comSpec: baseEnv.ComSpec ?? "cmd.exe",
+        windowsShell: platform === "win32"
+            ? options.windowsShell === undefined
+                ? findWindowsShell()
+                : options.windowsShell
+            : null,
     };
     return {
         mode,
+        shellName: shellName(context),
         spawn: async (request) => {
             const plan = planTerminal(request, context);
             const child = spawn(plan.file, plan.args, {
@@ -171,6 +197,21 @@ export function nodeTerminalFolders(platform = process.platform) {
         },
     };
 }
+/** The short name of the shell a terminal with no command starts on this machine. */
+export function interactiveShellName(platform = process.platform, env = process.env) {
+    return shellName({
+        platform,
+        mode: "pipes",
+        shell: env.SHELL || "/bin/sh",
+        comSpec: env.ComSpec ?? "cmd.exe",
+        windowsShell: platform === "win32" ? findWindowsShell() : null,
+    });
+}
+/** `pwsh` when installed, else Windows PowerShell, else null for cmd.exe. */
+function findWindowsShell() {
+    const lookup = nodeWindowsLookup();
+    return resolveWindowsCommand("pwsh", lookup) ?? resolveWindowsCommand("powershell", lookup);
+}
 /** Single quotes for sh, with any single quote inside closed, escaped and reopened. */
 function quote(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;

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

@@ -1,5 +1,5 @@
 import { createServer } from "node:http";
-import { API_PATHS, STUDIO_HEADER, TOKEN_HEADER, TOKEN_PARAM, } from "../../../core/api/contract.js";
+import { API_PATHS, INCLUDE_STUDIO_PARAM, STUDIO_HEADER, TOKEN_HEADER, TOKEN_PARAM, } from "../../../core/api/contract.js";
 import { createAlias, installPortless, removeAlias, renameAlias, } from "../../application/route-use-cases.js";
 import { FocusBroker, focusQuery, resolveFocusTarget } from "./focus-broker.js";
 import { MAX_BODY_BYTES, readJsonBody, sendError, sendJson } from "./json-io.js";
@@ -13,6 +13,7 @@ const DOCTOR_FIX = /^\/api\/doctor\/fix\/([^/]+)$/;
 const PROXY_ACTION = /^\/api\/proxy\/(start|stop|restart)$/;
 const STUDIO_ACTION = /^\/api\/studio\/(restart|stop)$/;
 const STOP_PROCESS = /^\/api\/processes\/([^/]+)\/stop$/;
+const STOP_CONTAINER = /^\/api\/containers\/([^/]+)\/stop$/;
 const TERMINAL = /^\/api\/terminals\/([^/]+)(?:\/(output|stream|input|stop|restart))?$/;
 /** Lets the 202 reach the browser before Studio restarts or exits. */
 const STUDIO_ACTION_DELAY_MS = 200;
@@ -99,9 +100,15 @@ export function createHttpServer(options) {
             return;
         }
         if (pathname === API_PATHS.snapshot && method === "GET") {
-            sendJson(res, 200, await options.studio.readSnapshot());
+            const includeStudio = query.get(INCLUDE_STUDIO_PARAM) === "1";
+            sendJson(res, 200, await options.studio.readSnapshot({ includeStudio }));
             return;
         }
+        if (pathname === API_PATHS.update && method === "GET") {
+            if (!options.updates)
+                return sendAppError(res, unsupported);
+            return sendJson(res, 200, await options.updates.status());
+        }
         if (pathname === API_PATHS.config && method === "GET") {
             const result = await options.studio.readConfig();
             if (!result.ok)
@@ -171,6 +178,16 @@ export function createHttpServer(options) {
             res.writeHead(204, { "Cache-Control": "no-store" }).end();
             return;
         }
+        const stopBox = STOP_CONTAINER.exec(pathname);
+        if (stopBox?.[1] && method === "POST") {
+            if (!options.stopContainer)
+                return sendAppError(res, unsupported);
+            const result = await options.stopContainer(decodeName(stopBox[1]) ?? "");
+            if (!result.ok)
+                return sendAppError(res, result.error);
+            res.writeHead(204, { "Cache-Control": "no-store" }).end();
+            return;
+        }
         if (pathname.startsWith(`${API_PATHS.openWith}/`) || pathname === API_PATHS.openWith) {
             return handleOpenWith(req, res, pathname, method);
         }
@@ -230,6 +247,18 @@ export function createHttpServer(options) {
             terminalStreams.list(res);
             return;
         }
+        if (pathname === API_PATHS.terminalsInFolder && method === "POST") {
+            const body = await readJsonBody(req);
+            if (!body.ok)
+                return sendBodyError(res, body.error);
+            const created = await terminals.create(toTerminalRequest(body.value), {
+                trusted: isLocalProgram(req),
+                picked: true,
+            });
+            if (!created.ok)
+                return sendAppError(res, created.error);
+            return sendJson(res, 201, created.value);
+        }
         const match = TERMINAL.exec(pathname);
         const id = match?.[1] ? decodeName(match[1]) : null;
         if (id === null)
@@ -241,6 +270,18 @@ export function createHttpServer(options) {
                 return sendError(res, "not_found", `No terminal has the id "${id}".`);
             return sendJson(res, 200, info);
         }
+        if (action === undefined && method === "PATCH") {
+            const body = await readJsonBody(req);
+            if (!body.ok)
+                return sendBodyError(res, body.error);
+            const title = asRecord(body.value).title;
+            if (typeof title !== "string")
+                return sendError(res, "invalid_request", "title must be text.");
+            const renamed = terminals.rename(id, title);
+            if (!renamed.ok)
+                return sendAppError(res, renamed.error);
+            return sendJson(res, 200, renamed.value);
+        }
         if (action === undefined && method === "DELETE") {
             return sendResult(res, terminals.remove(id), 204);
         }

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

@@ -16,6 +16,7 @@ const STATUS_BY_CODE = {
     process_not_allowed: 403,
     unsupported: 501,
     command_failed: 502,
+    port_in_use: 409,
     unknown_app: 404,
     path_not_allowed: 403,
     terminal_not_running: 409,