brewpage-mcp 1.14.3 → 1.14.4

package/README.md

@@ -17,7 +17,7 @@ Choosing a host? See how BrewPage compares with GitHub Pages, Netlify Drop, Tiin
 ## Quick Start
 
 ```bash
-npx -y brewpage-mcp@1.14.3
+npx -y brewpage-mcp@1.14.4
 ```
 
 Requires Node.js 20 or newer. This starts the stdio server for an MCP client.
@@ -33,7 +33,7 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.14.3"]
+      "args": ["-y", "brewpage-mcp@1.14.4"]
     }
   }
 }
@@ -44,7 +44,7 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
 Register a project-scoped stdio server:
 
 ```bash
-claude mcp add --transport stdio --scope project brewpage -- npx -y brewpage-mcp@1.14.3
+claude mcp add --transport stdio --scope project brewpage -- npx -y brewpage-mcp@1.14.4
 ```
 
 This writes `.mcp.json` in the project root. Use `--scope user` for user-scoped registration. See the [official Claude Code MCP guide](https://code.claude.com/docs/en/mcp).
@@ -58,7 +58,7 @@ Open **Settings > MCP** and add:
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.14.3"]
+      "args": ["-y", "brewpage-mcp@1.14.4"]
     }
   }
 }
@@ -72,7 +72,7 @@ Open the Cline MCP settings panel and add:
 {
   "brewpage": {
     "command": "npx",
-    "args": ["-y", "brewpage-mcp@1.14.3"]
+    "args": ["-y", "brewpage-mcp@1.14.4"]
   }
 }
 ```
@@ -80,7 +80,7 @@ Open the Cline MCP settings panel and add:
 ### Global Install
 
 ```bash
-npm install -g brewpage-mcp@1.14.3
+npm install -g brewpage-mcp@1.14.4
 brewpage-mcp
 ```
 
@@ -485,12 +485,16 @@ Every publish response includes an **owner token** -- the only credential that a
 - `POST /mcp` only, JSON responses, no `Mcp-Session-Id`; `GET`/`DELETE /mcp` -> 405. `GET /healthz` for the container healthcheck.
 - Requests with an `Origin` header -> 403 (no browser access). Only peers in `BREWPAGE_TRUSTED_PROXY_CIDRS` are served (others -> 403); the last `X-Forwarded-For` IP goes to the API with `X-Forwarded-Proto`/`X-Forwarded-Host` of the public origin.
 - `publish_file` downloads only from public addresses (every redirect re-checked, at most 3, 20 MiB).
+- Request body up to 32 MiB (`413` above), sent at least ~250 KiB/s after the first 2 s (`408` below). Light calls (handshake, `tools/list`, small reads), writes and large calls (over 1 MiB, `publish_file`) have separate slot pools; a full pool queues a request up to 30 s before `503`. A body without `Content-Length` that grows past 1 MiB gets `503` at once when the large-call slot is busy. A slot is held until the tool finishes; a client disconnect cancels its backend calls. Per-IP caps and the `publish_file` download budget skip shared platform egress (`BREWPAGE_SHARED_EGRESS_CIDRS` plus the published lists).
+- Memory: run with `--max-old-space-size=192` and a 512 MiB container limit.
 - Never reads `BREWPAGE_OWNER_TOKEN`; refuses to start when it is set. Pass `ownerToken` per call.
 - One JSON log line per request on stdout (method, tool, status, outcome, ms); no arguments, tokens or IPs. `SIGTERM` drains for up to 30 s.
 
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `BREWPAGE_TRUSTED_PROXY_CIDRS` | required | Comma list of reverse-proxy CIDRs or IPs |
+| `BREWPAGE_SHARED_EGRESS_CIDRS` | empty | Comma list of platform egress CIDRs (one IP, many users): global limits only, no per-IP caps |
+| `BREWPAGE_SHARED_EGRESS_LIST_URLS` | empty | Comma list of `https` URLs of published egress lists (`{"prefixes":[{"ipv4Prefix"}]}`, at least 100 prefixes, at most 1 MiB, no redirects); fetched at startup and daily, last good list kept |
 | `BREWPAGE_BACKEND_URL` | `http://brewpage-backend-mcp:8080` | API base URL (internal address) |
 | `BREWPAGE_PUBLIC_ORIGIN` | `https://brewpage.app` | Origin for returned links and forwarded proto/host |
 | `BREWPAGE_MCP_PORT` | `8787` | Listen port |
@@ -509,6 +513,10 @@ Every publish response includes an **owner token** -- the only credential that a
 
 ## Changelog
 
+## 1.14.4 -- 2026-10-26
+
+- Remote mode: a request keeps its slot until the tool finishes, and a client disconnect cancels its backend calls and source download; backend calls time out after 60 s. Separate pools for light, write and large calls queue briefly instead of refusing; request body up to 32 MiB. `BREWPAGE_SHARED_EGRESS_CIDRS` and `BREWPAGE_SHARED_EGRESS_LIST_URLS` exempt platform egress from per-IP caps. Tools are unchanged.
+
 ## 1.14.3 -- 2026-10-26
 
 - Old publications (made before 5 October 2026): the 409 hint says to POST the content to `createUrl` (sent for every type) with the matching publish tool in that namespace; `republishUrl` is browser-only. Update tool descriptions mention `createUrl`.

package/dist/http.d.ts

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
+interface Cidr {
+    address: string;
+    prefix: number;
+    family: "ipv4" | "ipv6";
+}
+/** `{prefixes: [{ipv4Prefix | ipv6Prefix}]}`; drops unparsable and over-wide prefixes, rejects a truncated or reshaped file. */
+export declare function parseEgressList(text: string): Cidr[];
 export declare function isBlockedSource(address: string): boolean;
-/** SSRF-safe publish_file download: every hop re-checked, at most 3 redirects, one Blob copy. */
-export declare function fetchSourceSafely(url: string, isBlocked?: (address: string) => boolean): Promise<Blob>;
+/** SSRF-safe publish_file download: every hop re-checked, at most 3 redirects, one Blob copy; `abort` cancels it. */
+export declare function fetchSourceSafely(url: string, isBlocked?: (address: string) => boolean, abort?: AbortSignal): Promise<Blob>;
+export {};

package/dist/http.js

@@ -10,14 +10,35 @@ import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createServer, OWNER_TOKEN_ENV, USER_AGENT } from "./tools.js";
 const MIB = 1024 * 1024;
-/** A 31 MiB tools/call peaked at 375 MiB RSS, 7.9 MiB at 164 MiB; 8 MiB keeps a 320 MiB container safe. */
-const MAX_BODY_BYTES = 8 * MIB;
+/** Fits the largest site (25 MiB backend request: 20 MiB of inline text plus JSON escaping).
+ * Two 32 MiB sites + 8x1 MiB + 32 light per round peaked at 373 MiB (heap 192): run with mem_limit 512m. */
+const MAX_BODY_BYTES = 32 * MIB;
 const LARGE_BODY_BYTES = 1 * MIB;
-const BODY_TIMEOUT_MS = 10_000;
+const SMALL_BODY_BYTES = 64 * 1024;
+/** After a 2 s grace a body must average ~250 KiB/s (checked every second), so a trickle cannot pin a slot. */
+const BODY_GRACE_MS = 2_000;
+const BODY_MIN_BYTES_PER_MS = 256;
+/** Light = small body, not tools/call or a LIGHT_TOOLS call; own pool so writes cannot starve handshakes. */
+const MAX_LIGHT_IN_FLIGHT = 32;
+const MAX_LIGHT_PER_CLIENT = 4;
 const MAX_IN_FLIGHT = 8;
 const MAX_PER_CLIENT = 2;
-/** Heavy = body over 1 MiB or publish_file; each peaks ~100 MiB RSS, two reached 313 MiB, too close to 320 MiB. */
+/** Heavy = body over 1 MiB or publish_file; one at a time keeps a 32 MiB call inside the container memory. */
 const MAX_HEAVY_IN_FLIGHT = 1;
+const MAX_HEAVY_PER_CLIENT = 1;
+/** A full pool queues a request (before its body is read) for up to 30 s instead of answering 503. */
+const QUEUE_WAIT_MS = 30_000;
+const MAX_QUEUED = 64;
+/** Read-only tools with small answers; content reads (get_page/json/kv) stay in the standard pool. */
+const LIGHT_TOOLS = new Set(["get_limits", "get_stats", "search_gallery"]);
+const BACKEND_TIMEOUT_MS = 60_000;
+/** Published egress lists (backend `openai-chatgpt-connectors` rules): daily refresh, last good set kept on failure. */
+const SHARED_LIST_REFRESH_MS = 24 * 60 * 60_000;
+const SHARED_LIST_TIMEOUT_MS = 15_000;
+const SHARED_LIST_MAX_BYTES = 1 * MIB;
+const SHARED_LIST_MIN_RANGES = 100;
+const MIN_LISTED_PREFIX_V4 = 16;
+const MIN_LISTED_PREFIX_V6 = 32;
 const MAX_SOURCE_BYTES = 20 * MIB;
 const MAX_REDIRECTS = 3;
 const SOURCE_TIMEOUT_MS = 30_000;
@@ -42,23 +63,68 @@ function fail(message) {
     process.stderr.write(`${JSON.stringify({ ts: new Date().toISOString(), event: "startup_failed", message })}\n`);
     process.exit(1);
 }
-/** Comma list of CIDRs or bare IPs; empty entries skipped, any invalid entry is fatal. */
-function parseCidrs(raw) {
+/** An IP or IP/prefix: one slash, 1-3 decimal digits, prefix within the family's range; else undefined. */
+function parseCidr(entry) {
+    const parts = entry.split("/");
+    const version = isIP(parts[0]);
+    const max = version === 6 ? 128 : 32;
+    const prefix = parts.length === 1 ? max : parts.length === 2 && /^\d{1,3}$/.test(parts[1]) ? Number(parts[1]) : -1;
+    if (version === 0 || prefix < 0 || prefix > max)
+        return undefined;
+    return { address: parts[0], prefix, family: version === 6 ? "ipv6" : "ipv4" };
+}
+function blockList(cidrs) {
     const list = new BlockList();
-    const entries = (raw ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-    if (entries.length === 0)
-        fail("BREWPAGE_TRUSTED_PROXY_CIDRS is required: comma list of proxy CIDRs.");
+    for (const { address, prefix, family } of cidrs)
+        list.addSubnet(address, prefix, family);
+    return list;
+}
+/** Comma list of CIDRs or bare IPs from env `name`; empty entries skipped, any invalid entry is fatal. */
+function parseCidrs(name, required) {
+    const entries = (process.env[name] ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    if (entries.length === 0 && required)
+        fail(`${name} is required: comma list of proxy CIDRs.`);
+    return entries.map((entry) => parseCidr(entry) ?? fail(`${name}: invalid entry ${JSON.stringify(entry)}.`));
+}
+/** `{prefixes: [{ipv4Prefix | ipv6Prefix}]}`; drops unparsable and over-wide prefixes, rejects a truncated or reshaped file. */
+export function parseEgressList(text) {
+    const prefixes = JSON.parse(text)?.prefixes;
+    if (!Array.isArray(prefixes))
+        throw new Error("no prefixes array");
+    const valid = prefixes
+        .map((entry) => entry?.ipv4Prefix ?? entry?.ipv6Prefix)
+        .map((cidr) => typeof cidr === "string" ? parseCidr(cidr) : undefined)
+        .filter((cidr) => cidr !== undefined && cidr.prefix >= (cidr.family === "ipv6" ? MIN_LISTED_PREFIX_V6 : MIN_LISTED_PREFIX_V4));
+    const invalid = prefixes.length - valid.length;
+    if (valid.length < SHARED_LIST_MIN_RANGES || invalid * 10 > prefixes.length)
+        throw new Error(`${valid.length} valid, ${invalid} invalid prefixes`);
+    return valid;
+}
+/** Comma list of https URLs from env `name`; any other entry is fatal. */
+function parseListUrls(name) {
+    const entries = (process.env[name] ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
     for (const entry of entries) {
-        const [address, prefixText] = entry.split("/");
-        const family = isIP(address);
-        const prefix = prefixText === undefined ? (family === 6 ? 128 : 32) : Number(prefixText);
-        const maxPrefix = family === 6 ? 128 : 32;
-        if (family === 0 || !Number.isInteger(prefix) || prefix < 0 || prefix > maxPrefix) {
-            fail(`BREWPAGE_TRUSTED_PROXY_CIDRS: invalid entry ${JSON.stringify(entry)}.`);
+        if (!URL.canParse(entry) || new URL(entry).protocol !== "https:")
+            fail(`${name}: invalid entry ${JSON.stringify(entry)}.`);
+    }
+    return entries;
+}
+/** Body bytes after decompression, cancelled past `limit`: a gzip bomb never grows past it. */
+async function readCapped(res, limit) {
+    if (Number(res.headers.get("content-length") ?? 0) > limit)
+        throw new Error("list over 1 MiB");
+    const reader = res.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (let next = await reader.read(); !next.done; next = await reader.read()) {
+        size += next.value.length;
+        if (size > limit) {
+            await reader.cancel();
+            throw new Error("list over 1 MiB");
         }
-        list.addSubnet(address, prefix, family === 6 ? "ipv6" : "ipv4");
+        chunks.push(next.value);
     }
-    return list;
+    return Buffer.concat(chunks).toString("utf8");
 }
 function loadConfig() {
     if (process.env[OWNER_TOKEN_ENV] !== undefined)
@@ -73,7 +139,10 @@ function loadConfig() {
         publicOrigin: publicOrigin.origin,
         forwardedProto: publicOrigin.protocol.replace(/:$/, ""),
         forwardedHost: publicOrigin.host,
-        trustedProxies: parseCidrs(process.env.BREWPAGE_TRUSTED_PROXY_CIDRS),
+        trustedProxies: blockList(parseCidrs("BREWPAGE_TRUSTED_PROXY_CIDRS", true)),
+        /** Platform egress (one IP, many users): global pools only, no per-client caps or download budget. */
+        sharedEgress: parseCidrs("BREWPAGE_SHARED_EGRESS_CIDRS", false),
+        sharedEgressLists: parseListUrls("BREWPAGE_SHARED_EGRESS_LIST_URLS"),
         host: process.env.BREWPAGE_MCP_HOST || "0.0.0.0",
         port,
     };
@@ -100,6 +169,7 @@ export function isBlockedSource(address) {
     return BLOCKED_SOURCES.check(bare, family === 6 ? "ipv6" : "ipv4");
 }
 const SOURCE_REFUSED = "Source URL refused: private or reserved address.";
+const BODY_TOO_LARGE = "Request body over 32 MiB.";
 const SOURCE_TOO_LARGE = "Source file over 20 MiB.";
 /** DNS lookup that fails when any resolved address is blocked; runs on every connection. */
 function guardedLookup(isBlocked) {
@@ -169,9 +239,10 @@ function sourceHop(url, signal, isBlocked) {
         req.end();
     });
 }
-/** SSRF-safe publish_file download: every hop re-checked, at most 3 redirects, one Blob copy. */
-export async function fetchSourceSafely(url, isBlocked = isBlockedSource) {
-    const signal = AbortSignal.timeout(SOURCE_TIMEOUT_MS);
+/** SSRF-safe publish_file download: every hop re-checked, at most 3 redirects, one Blob copy; `abort` cancels it. */
+export async function fetchSourceSafely(url, isBlocked = isBlockedSource, abort) {
+    const timeout = AbortSignal.timeout(SOURCE_TIMEOUT_MS);
+    const signal = abort ? AbortSignal.any([timeout, abort]) : timeout;
     let current = new URL(url);
     for (let hop = 0;; hop++) {
         const answer = await sourceHop(current, signal, isBlocked);
@@ -215,7 +286,7 @@ const backendFetch = async (input, init) => {
             return await fetch(input, init);
         }
         catch (error) {
-            if (!isDialFailure(error) || Date.now() >= deadline)
+            if (!isDialFailure(error) || Date.now() >= deadline || init?.signal?.aborted)
                 throw error;
             await new Promise((resolve) => setTimeout(resolve, DIAL_RETRY_PAUSE_MS));
         }
@@ -235,8 +306,8 @@ function rpcError(res, status, code, message, headers = {}) {
     res.writeHead(status, { "Content-Type": "application/json", ...headers });
     res.end(JSON.stringify({ jsonrpc: "2.0", error: { code, message }, id: null }));
 }
-/** Reads at most `limit` bytes within `timeoutMs`; never rejects. */
-function readBody(req, limit, timeoutMs) {
+/** Reads at most `limit` bytes above the minimum rate; `onLarge` (false = busy) runs once past LARGE_BODY_BYTES; never rejects. */
+function readBody(req, limit, onLarge) {
     return new Promise((resolve) => {
         const chunks = [];
         let size = 0;
@@ -245,20 +316,30 @@ function readBody(req, limit, timeoutMs) {
             if (done)
                 return;
             done = true;
-            clearTimeout(timer);
+            clearInterval(timer);
             resolve(value);
         };
-        const timer = setTimeout(() => finish("timeout"), timeoutMs);
+        const started = Date.now();
+        const timer = setInterval(() => {
+            if (size < (Date.now() - started - BODY_GRACE_MS) * BODY_MIN_BYTES_PER_MS)
+                finish("timeout");
+        }, 1_000);
         req.on("data", (chunk) => {
+            const before = size;
             size += chunk.length;
             if (size > limit)
                 return finish("too_large");
+            if (before <= LARGE_BODY_BYTES && size > LARGE_BODY_BYTES && !onLarge())
+                return finish("busy");
             if (!done)
                 chunks.push(chunk);
         });
         req.on("end", () => finish(Buffer.concat(chunks)));
         req.on("error", () => finish("aborted"));
         req.on("close", () => finish("aborted"));
+        // A client that left while the request was queued closed before these listeners existed.
+        if (req.socket.destroyed)
+            finish("aborted");
     });
 }
 /** Tool names from an in-memory handshake; logs name only these. */
@@ -273,13 +354,109 @@ async function registeredToolNames() {
     await server.close();
     return new Set(tools.map(({ name }) => name));
 }
+/** Slot pool: global limit with a FIFO wait queue, plus a per-client cap (client undefined = shared egress, no cap). */
+class Pool {
+    limit;
+    perClient;
+    active = 0;
+    clients = new Map();
+    waiters = [];
+    constructor(limit, perClient) {
+        this.limit = limit;
+        this.perClient = perClient;
+    }
+    /** A free slot now, or false; never queues. */
+    tryTake(client) {
+        if (!this.reserve(client))
+            return false;
+        if (this.active < this.limit) {
+            this.active++;
+            return true;
+        }
+        this.release(client);
+        return false;
+    }
+    /** True once a slot is held; false at once over the per-client cap or a full queue, or after QUEUE_WAIT_MS. */
+    async take(client) {
+        if (!this.reserve(client))
+            return false;
+        if (this.active < this.limit) {
+            this.active++;
+            return true;
+        }
+        const granted = this.waiters.length < MAX_QUEUED && await new Promise((resolve) => {
+            const wake = () => {
+                clearTimeout(timer);
+                resolve(true);
+            };
+            const timer = setTimeout(() => {
+                this.waiters.splice(this.waiters.indexOf(wake), 1);
+                resolve(false);
+            }, QUEUE_WAIT_MS);
+            this.waiters.push(wake);
+        });
+        if (!granted)
+            this.release(client);
+        return granted;
+    }
+    /** Frees a slot; a queued request inherits it directly. */
+    give(client) {
+        this.release(client);
+        const next = this.waiters.shift();
+        if (next)
+            next();
+        else
+            this.active--;
+    }
+    reserve(client) {
+        if (client === undefined)
+            return true;
+        const held = this.clients.get(client) ?? 0;
+        if (held >= this.perClient)
+            return false;
+        this.clients.set(client, held + 1);
+        return true;
+    }
+    release(client) {
+        if (client === undefined)
+            return;
+        const left = (this.clients.get(client) ?? 1) - 1;
+        if (left > 0)
+            this.clients.set(client, left);
+        else
+            this.clients.delete(client);
+    }
+}
 async function main() {
     const config = loadConfig();
     const toolNames = await registeredToolNames();
-    const perClient = new Map();
-    let inFlight = 0;
-    let heavyInFlight = 0;
+    const light = new Pool(MAX_LIGHT_IN_FLIGHT, MAX_LIGHT_PER_CLIENT);
+    const standard = new Pool(MAX_IN_FLIGHT, MAX_PER_CLIENT);
+    const heavy = new Pool(MAX_HEAVY_IN_FLIGHT, MAX_HEAVY_PER_CLIENT);
     let draining = false;
+    const listed = new Map();
+    let sharedEgress = blockList(config.sharedEgress);
+    /** Never throws: a failed fetch or parse keeps the last good set and logs a warning. */
+    async function loadEgressList(url) {
+        try {
+            const res = await fetch(url, { redirect: "error", signal: AbortSignal.timeout(SHARED_LIST_TIMEOUT_MS),
+                headers: { "User-Agent": REMOTE_USER_AGENT } });
+            if (!res.ok) {
+                await res.body?.cancel();
+                throw new Error(`HTTP ${res.status}`);
+            }
+            const ranges = parseEgressList(await readCapped(res, SHARED_LIST_MAX_BYTES));
+            listed.set(url, ranges);
+            sharedEgress = blockList([...config.sharedEgress, ...[...listed.values()].flat()]);
+            log({ event: "shared_egress_list", url, ranges: ranges.length });
+        }
+        catch (error) {
+            log({ event: "shared_egress_list_failed", url, message: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    const refreshEgressLists = () => config.sharedEgressLists.forEach((url) => void loadEgressList(url));
+    refreshEgressLists();
+    setInterval(refreshEgressLists, SHARED_LIST_REFRESH_MS).unref();
     async function handleMcp(req, res, entry) {
         if (req.headers.origin !== undefined)
             return rpcError(res, 403, SERVER_ERROR, "Origin not allowed.");
@@ -296,92 +473,127 @@ async function main() {
             return rpcError(res, 503, SERVER_ERROR, "Shutting down.", { "Retry-After": "5" });
         const declared = Number(req.headers["content-length"]);
         if (declared > MAX_BODY_BYTES)
-            return rpcError(res, 413, SERVER_ERROR, "Request body over 8 MiB.");
-        const busy = () => rpcError(res, 503, SERVER_ERROR, "Busy, retry shortly.", { "Retry-After": "1" });
-        let heavy = !(Number.isFinite(declared) && declared <= LARGE_BODY_BYTES);
-        if (inFlight >= MAX_IN_FLIGHT || (perClient.get(client) ?? 0) >= MAX_PER_CLIENT || (heavy && heavyInFlight >= MAX_HEAVY_IN_FLIGHT)) {
-            return busy();
-        }
-        inFlight++;
-        perClient.set(client, (perClient.get(client) ?? 0) + 1);
-        if (heavy)
-            heavyInFlight++;
-        res.once("close", () => {
-            inFlight--;
-            const left = (perClient.get(client) ?? 1) - 1;
-            if (left > 0)
-                perClient.set(client, left);
-            else
-                perClient.delete(client);
-            if (heavy)
-                heavyInFlight--;
-        });
-        const body = await readBody(req, MAX_BODY_BYTES, BODY_TIMEOUT_MS);
-        if (!(body instanceof Buffer)) {
-            if (body === "aborted")
-                return;
-            res.once("finish", () => req.socket.destroy());
-            return body === "timeout"
-                ? rpcError(res, 408, SERVER_ERROR, "Request body too slow.", { Connection: "close" })
-                : rpcError(res, 413, SERVER_ERROR, "Request body over 8 MiB.", { Connection: "close" });
-        }
-        let message;
+            return rpcError(res, 413, SERVER_ERROR, BODY_TOO_LARGE);
+        // Discards any unread body so the 503 is delivered and the connection stays usable.
+        const busy = () => {
+            req.resume();
+            rpcError(res, 503, SERVER_ERROR, "Busy, retry shortly.", { "Retry-After": "1" });
+        };
+        const known = Number.isFinite(declared);
+        const shared = sharedEgress.check(client, isIP(client) === 6 ? "ipv6" : "ipv4");
+        const capKey = shared ? undefined : client;
+        // Registered first: a client that leaves at any point, even while queued, aborts the call.
+        const abort = new AbortController();
+        res.once("close", () => abort.abort());
+        // One slot per request, released only after the handler settles, never on socket close.
+        let slot;
+        const acquire = async (pool) => {
+            // A light slot is freed before waiting, so queued writes never hold handshake capacity.
+            if (slot === light) {
+                light.give(capKey);
+                slot = undefined;
+            }
+            if (!(await pool.take(capKey)))
+                return false;
+            slot?.give(capKey);
+            slot = pool;
+            return true;
+        };
         try {
-            message = JSON.parse(body.toString("utf8"));
-        }
-        catch {
-            return rpcError(res, 400, PARSE_ERROR, "Parse error.");
-        }
-        if (Array.isArray(message))
-            return rpcError(res, 400, INVALID_REQUEST, "Batch requests are not supported.");
-        if (message === null || typeof message !== "object")
-            return rpcError(res, 400, INVALID_REQUEST, "Invalid Request.");
-        const rpc = message;
-        const toolName = rpc.method === "tools/call" ? rpc.params?.name : undefined;
-        entry.method = typeof rpc.method === "string" ? rpc.method.slice(0, MAX_LOGGED_METHOD) : null;
-        entry.tool = rpc.method === "tools/call" ? (typeof toolName === "string" && toolNames.has(toolName) ? toolName : "unknown") : null;
-        if (toolName === "publish_file" && !heavy) {
-            if (heavyInFlight >= MAX_HEAVY_IN_FLIGHT)
+            const first = !known ? standard : declared <= SMALL_BODY_BYTES ? light : declared <= LARGE_BODY_BYTES ? standard : heavy;
+            if (!(await acquire(first)))
+                return busy();
+            if (abort.signal.aborted)
+                return;
+            // Unknown length that grows past 1 MiB must find a free heavy slot at once.
+            const body = await readBody(req, MAX_BODY_BYTES, () => {
+                if (slot === heavy)
+                    return true;
+                if (!heavy.tryTake(capKey))
+                    return false;
+                slot?.give(capKey);
+                slot = heavy;
+                return true;
+            });
+            if (!(body instanceof Buffer)) {
+                if (body === "aborted")
+                    return;
+                if (body === "busy")
+                    return busy();
+                res.once("finish", () => req.socket.destroy());
+                return body === "timeout"
+                    ? rpcError(res, 408, SERVER_ERROR, "Request body too slow.", { Connection: "close" })
+                    : rpcError(res, 413, SERVER_ERROR, BODY_TOO_LARGE, { Connection: "close" });
+            }
+            let message;
+            try {
+                message = JSON.parse(body.toString("utf8"));
+            }
+            catch {
+                return rpcError(res, 400, PARSE_ERROR, "Parse error.");
+            }
+            if (Array.isArray(message))
+                return rpcError(res, 400, INVALID_REQUEST, "Batch requests are not supported.");
+            if (message === null || typeof message !== "object")
+                return rpcError(res, 400, INVALID_REQUEST, "Invalid Request.");
+            const rpc = message;
+            const toolName = rpc.method === "tools/call" ? rpc.params?.name : undefined;
+            entry.method = typeof rpc.method === "string" ? rpc.method.slice(0, MAX_LOGGED_METHOD) : null;
+            entry.tool = rpc.method === "tools/call" ? (typeof toolName === "string" && toolNames.has(toolName) ? toolName : "unknown") : null;
+            const isLight = rpc.method !== "tools/call" || (typeof toolName === "string" && LIGHT_TOOLS.has(toolName));
+            if (toolName === "publish_file" && slot !== heavy && !(await acquire(heavy)))
+                return busy();
+            if (slot === light && !isLight && !(await acquire(standard)))
                 return busy();
-            heavy = true;
-            heavyInFlight++;
+            if (abort.signal.aborted)
+                return;
+            const forwarded = { "X-Forwarded-For": client, "X-Forwarded-Proto": config.forwardedProto, "X-Forwarded-Host": config.forwardedHost };
+            const callBackend = (input, init) => backendFetch(input, { ...init, signal: AbortSignal.any([abort.signal, AbortSignal.timeout(BACKEND_TIMEOUT_MS)]) });
+            const server = createServer({
+                baseUrl: config.backendUrl,
+                publicOrigin: config.publicOrigin,
+                userAgent: REMOTE_USER_AGENT,
+                headers: forwarded,
+                fetchSource: (url) => shared || takeDownload(client)
+                    ? fetchSourceSafely(url, isBlockedSource, abort.signal)
+                    : Promise.reject(new Error("Download limit reached for this address; try again in a few minutes.")),
+                fetch: callBackend,
+            });
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+            const send = transport.send.bind(transport);
+            transport.send = (outgoing, options) => {
+                if ("error" in outgoing)
+                    entry.outcome = "rpc_error";
+                else if ("result" in outgoing && outgoing.result.isError === true)
+                    entry.outcome = "tool_error";
+                return send(outgoing, options);
+            };
+            try {
+                await server.connect(transport);
+                // JSON mode resolves only after the response is sent, i.e. after the handler settled.
+                await transport.handleRequest(req, res, message);
+            }
+            finally {
+                await transport.close();
+                await server.close();
+            }
+        }
+        finally {
+            slot?.give(capKey);
         }
-        const server = createServer({
-            baseUrl: config.backendUrl,
-            publicOrigin: config.publicOrigin,
-            userAgent: REMOTE_USER_AGENT,
-            headers: { "X-Forwarded-For": client, "X-Forwarded-Proto": config.forwardedProto, "X-Forwarded-Host": config.forwardedHost },
-            fetchSource: (url) => takeDownload(client)
-                ? fetchSourceSafely(url)
-                : Promise.reject(new Error("Download limit reached for this address; try again in a few minutes.")),
-            fetch: backendFetch,
-        });
-        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
-        const send = transport.send.bind(transport);
-        transport.send = (outgoing, options) => {
-            if ("error" in outgoing)
-                entry.outcome = "rpc_error";
-            else if ("result" in outgoing && outgoing.result.isError === true)
-                entry.outcome = "tool_error";
-            return send(outgoing, options);
-        };
-        res.once("close", () => {
-            void transport.close();
-            void server.close();
-        });
-        await server.connect(transport);
-        await transport.handleRequest(req, res, message);
     }
     function handle(req, res, entry) {
         const path = (req.url ?? "/").split("?")[0];
         if (path === "/healthz") {
             res.writeHead(draining ? 503 : 200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ status: draining ? "draining" : "ok", version: VERSION }));
-            return;
+            return Promise.resolve();
         }
-        if (path !== "/mcp")
-            return rpcError(res, 404, SERVER_ERROR, "Not found.");
-        handleMcp(req, res, entry).catch((error) => {
+        if (path !== "/mcp") {
+            rpcError(res, 404, SERVER_ERROR, "Not found.");
+            return Promise.resolve();
+        }
+        return handleMcp(req, res, entry).catch((error) => {
             entry.outcome = "exception";
             log({ event: "request_failed", message: error instanceof Error ? error.message : String(error) });
             if (!res.headersSent)
@@ -394,30 +606,38 @@ async function main() {
         const started = performance.now();
         const entry = { http: req.method ?? "", method: null, tool: null, status: 0, outcome: null, ms: 0 };
         const logged = !(req.url ?? "").startsWith("/healthz");
-        res.once("close", () => {
-            if (!logged)
-                return;
-            entry.status = res.statusCode;
-            entry.outcome ??= res.statusCode < 400 ? "ok" : `http_${res.statusCode}`;
-            entry.ms = Math.round(performance.now() - started);
-            log(entry);
-        });
+        const closedEarly = new Promise((resolve) => res.once("close", () => resolve(!res.writableFinished)));
+        let done;
         try {
-            handle(req, res, entry);
+            done = handle(req, res, entry);
         }
         catch (error) {
             entry.outcome = "exception";
             log({ event: "request_failed", message: error instanceof Error ? error.message : String(error) });
             if (!res.headersSent)
                 rpcError(res, 500, SERVER_ERROR, "Internal error.");
+            done = Promise.resolve();
         }
+        // One line once the socket closed and the handler settled (slots released); ms covers both.
+        void Promise.all([closedEarly, done]).then(([early]) => {
+            if (!logged)
+                return;
+            entry.status = res.statusCode;
+            if (early)
+                entry.outcome = "client_closed";
+            else
+                entry.outcome ??= res.statusCode < 400 ? "ok" : `http_${res.statusCode}`;
+            entry.ms = Math.round(performance.now() - started);
+            log(entry);
+        });
     });
-    httpServer.requestTimeout = 120_000;
+    // Whole request incl. queue wait: 30 s queue + 2 s grace + 32 MiB at the body floor (~131 s) + margin.
+    httpServer.requestTimeout = QUEUE_WAIT_MS + BODY_GRACE_MS + MAX_BODY_BYTES / BODY_MIN_BYTES_PER_MS + 5_000;
     const shutdown = () => {
         if (draining)
             return;
         draining = true;
-        log({ event: "draining", inFlight });
+        log({ event: "draining", inFlight: light.active + standard.active + heavy.active });
         httpServer.close(() => process.exit(0));
         httpServer.closeIdleConnections();
         setTimeout(() => {

package/dist/tools.d.ts

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare const DEFAULT_BASE_URL = "https://brewpage.app";
-export declare const USER_AGENT = "brewpage-mcp/1.14.3";
+export declare const USER_AGENT = "brewpage-mcp/1.14.4";
 export declare const OWNER_TOKEN_ENV = "BREWPAGE_OWNER_TOKEN";
 export interface ServerOptions {
     /** BrewPage origin for API calls; default https://brewpage.app. */

package/dist/tools.js

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 export const DEFAULT_BASE_URL = "https://brewpage.app";
-export const USER_AGENT = "brewpage-mcp/1.14.3";
+export const USER_AGENT = "brewpage-mcp/1.14.4";
 export const OWNER_TOKEN_ENV = "BREWPAGE_OWNER_TOKEN";
 const READ_ONLY = { readOnlyHint: true };
 const DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true };
@@ -182,7 +182,7 @@ export function createServer(options = {}) {
     const apiFetch = options.fetch ?? fetch;
     const server = new McpServer({
         name: "brewpage-mcp",
-        version: "1.14.3",
+        version: "1.14.4",
     });
     /** Caller argument first, then the configured default; `fromEnv` marks the configured one. */
     function ownerTokenFor(argument) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brewpage-mcp",
-  "version": "1.14.3",
+  "version": "1.14.4",
   "mcpName": "io.github.kochetkov-ma/brewpage-mcp",
   "description": "MCP server for BrewPage — publish and manage HTML, sites, KV, JSON and files from AI assistants",
   "type": "module",