brewpage-mcp 1.19.1 → 1.21.0

package/README.md

@@ -8,7 +8,7 @@ MCP server for [BrewPage](https://brewpage.app) -- publish and manage HTML, KV,
 
 ## What is BrewPage
 
-[BrewPage](https://brewpage.app) is a free instant hosting platform designed for AI agents and developers. One `POST` request publishes HTML, Markdown, a multi-file site, a JSON document, or a binary file and returns its primary HTTPS link -- no account needed, no API keys, no infrastructure setup. Every resource carries an **owner token** returned at creation time: use it to update content in place, delete the resource, or authenticate list operations across sessions. `brewpage-mcp` exposes this API as thirty typed MCP tools so any compatible agent -- Claude, Codex, Gemini, Cursor, Cline -- can publish, update, fetch, and manage BrewPage HTML, JSON, KV, and file content without leaving the conversation.
+[BrewPage](https://brewpage.app) is a free instant hosting platform designed for AI agents and developers. One `POST` request publishes HTML, Markdown, a multi-file site, a JSON document, or a binary file and returns its primary HTTPS link -- no account needed, no API keys, no infrastructure setup. Every resource carries an **owner token** returned at creation time: use it to update content in place, delete the resource, or authenticate list operations across sessions. `brewpage-mcp` exposes this API as thirty-two typed MCP tools so any compatible agent -- Claude, Codex, Gemini, Cursor, Cline -- can publish, update, fetch, and manage BrewPage HTML, JSON, KV, and file content without leaving the conversation.
 
 Optional: sign in free (Google or any email) at https://account.brewpage.app to never lose your pages or tokens and to mint tokens that never expire. Not needed to publish.
 
@@ -18,7 +18,7 @@ Choosing a host? See how BrewPage compares with GitHub Pages, Netlify Drop, Tiin
 
 ### Remote (no install)
 
-One remote MCP server for every client: `https://brewpage.app/mcp` (Streamable HTTP, no authentication, same 30 tools). Add it by URL in Claude (a custom connector), ChatGPT (a custom MCP server) or any Streamable HTTP client.
+One remote MCP server for every client: `https://brewpage.app/mcp` (Streamable HTTP, no authentication, same 32 tools). Add it by URL in Claude (a custom connector), ChatGPT (a custom MCP server) or any Streamable HTTP client.
 
 Claude Code: `claude mcp add --transport http brewpage --scope user https://brewpage.app/mcp` (leave out `--scope user` to add it to the current project only), or in `.mcp.json`:
 
@@ -38,7 +38,7 @@ Claude Code: `claude mcp add --transport http brewpage --scope user https://brew
 For clients that only start local servers; the same tools as the server URL.
 
 ```bash
-npx -y brewpage-mcp@1.19.1
+npx -y brewpage-mcp@1.21.0
 ```
 
 Requires Node.js 20 or newer. This starts the stdio server for an MCP client.
@@ -63,7 +63,7 @@ Local fallback (stdio, needs Node.js; the same tools): add to `~/Library/Applica
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.19.1"]
+      "args": ["-y", "brewpage-mcp@1.21.0"]
     }
   }
 }
@@ -86,7 +86,7 @@ Custom servers follow your ChatGPT plan and workspace settings.
 The remote command above is the default. Local fallback: register a project-scoped stdio server:
 
 ```bash
-claude mcp add --transport stdio --scope project brewpage -- npx -y brewpage-mcp@1.19.1
+claude mcp add --transport stdio --scope project brewpage -- npx -y brewpage-mcp@1.21.0
 ```
 
 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).
@@ -110,7 +110,7 @@ Local fallback (stdio, needs Node.js; the same tools): open **Settings > MCP** a
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.19.1"]
+      "args": ["-y", "brewpage-mcp@1.21.0"]
     }
   }
 }
@@ -124,14 +124,14 @@ Open the Cline MCP settings panel and add:
 {
   "brewpage": {
     "command": "npx",
-    "args": ["-y", "brewpage-mcp@1.19.1"]
+    "args": ["-y", "brewpage-mcp@1.21.0"]
   }
 }
 ```
 
 ## Tools
 
-Thirty tools are available. Creation returns an owner token; keep it to modify or delete the resource later. Owner tools take `ownerToken`, else `BREWPAGE_OWNER_TOKEN` (local server only). Supported password inputs use `X-Password`. Secrets allowed; likely ones are flagged in notices. For a secret: private namespace + password.
+Thirty-two tools are available. Creation returns an owner token; keep it to modify or delete the resource later. Owner tools take `ownerToken`, else `BREWPAGE_OWNER_TOKEN` (local server only). Supported password inputs use `X-Password`. Secrets allowed; likely ones are flagged in notices. For a secret: private namespace + password.
 
 | Tool | Purpose |
 |------|---------|
@@ -149,7 +149,9 @@ Thirty tools are available. Creation returns an owner token; keep it to modify o
 | `get_kv` | Read a KV value |
 | `update_hosting` | Change eligible delivery mode with owner token and hosting version |
 | `delete_resource` | Delete an HTML page, site, JSON document, KV store or file |
-| `set_visibility` | Hide or show a public publication in the gallery and sitemap; link unchanged |
+| `set_visibility` | List or unlist a public publication in the gallery and sitemap; link unchanged |
+| `make_private` | Make a public publication private: new private link, the public link stops working; one-way |
+| `set_badge` | Hide or show the BrewPage badge on a publication of your profile, up to 5 hidden |
 | `set_title` | Rename an HTML page or site; the title stays on republish; link unchanged |
 | `bind_token` | Add an owner token to your profile (admin token) |
 | `mint_token` | Mint a profile token, shown once (admin token) |
@@ -436,9 +438,9 @@ delete_resource(type="html", namespace="public", id="aBcDeFgHiJ", ownerToken="to
 
 ### `set_visibility`
 
-Hide or show a public publication in the gallery and sitemap; the link stays the same. Only public, password-free HTML, sites and files can be listed; others answer with a `visibility-not-listable` notice.
+List or unlist a public publication in the gallery and sitemap; the link stays the same. Only public, password-free HTML, sites and files can be listed; others answer with a `visibility-not-listable` notice.
 
-Parameters: `type` (`html` | `site` | `file` | `json` | `kv`), `namespace`, `id`, `listed` (boolean), `ownerToken` (optional).
+Parameters: `type` (`html` | `site` | `file` | `json` | `kv`), `namespace`, `id`, `listed` (boolean: `true` = listed, `false` = unlisted), `ownerToken` (optional).
 
 ```
 set_visibility(type="html", namespace="public", id="aBcDeFgHiJ", listed=false)
@@ -448,6 +450,34 @@ Output: `LISTED: false · link unchanged`.
 
 ---
 
+### `make_private`
+
+Make a public publication private (`POST /api/{type}/{ns}/{id}/private`): it gets a new private link in a private namespace under a new id, and the public link stops working. Views and stats stay; a custom domain on it is detached. One-way: to go public again, publish again. The owner token stays the same; later calls take the new namespace and id.
+
+Parameters: `type` (`html` | `site` | `file` | `json` | `kv`), `namespace` (`public`), `id`, `ownerToken` (optional).
+
+```
+make_private(type="html", namespace="public", id="aBcDeFgHiJ")
+```
+
+Output: `MADE PRIVATE · the public link no longer works`, then the new link, namespace and id, and the new management link when the publication had one. Give the user the new link and the management link. A publication outside `public` answers 409 `NOT_PUBLIC`.
+
+---
+
+### `set_badge`
+
+Hide or show the BrewPage badge on a publication (`POST /api/{type}/{ns}/{id}/badge`). HTML pages and sites show a small BrewPage badge; page code must not hide or alter it. Hiding works when the publication's owner token is in a BrewPage profile: sign in free at https://account.brewpage.app, then `bind_token`. A profile hides the badge on up to 5 publications; showing it again frees the slot.
+
+Parameters: `type` (`html` | `site` | `file` | `json` | `kv`), `namespace`, `id`, `hidden` (optional boolean: `true` = hide, `false` = show; omitted reports the current state), `ownerToken` (optional).
+
+```
+set_badge(type="html", namespace="public", id="aBcDeFgHiJ", hidden=true)
+```
+
+Output: `BADGE: hidden · 2 of 5 hidden in the profile · link unchanged`. Without a profile the badge stays shown and the result carries the `badge-hide-needs-profile` notice; a sixth hide answers 409 `BADGE_HIDDEN_LIMIT`.
+
+---
+
 ### `set_title`
 
 Rename an HTML page or site: the title shown in the gallery, profile, search and link cards (`POST /api/{html|sites}/{ns}/{id}/title`). The new title stays when you republish; the link stays the same. Works when the publication's owner token is in a BrewPage profile: sign in at https://account.brewpage.app, then `bind_token`; otherwise 403 with a hint.
@@ -701,12 +731,14 @@ Every publish response includes an **owner token** -- the only credential that a
 - 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.
+- `GET /metrics` (Prometheus text) only for peers in `BREWPAGE_METRICS_CIDRS`, else 404: `brewpage_mcp_requests_total{method,client}`, `brewpage_mcp_tool_calls_total{tool,client,outcome}` and the gauge `brewpage_mcp_clients_today{client}` (distinct caller addresses with a tool call since 00:00 UTC, kept only as hashes with a random salt drawn each day; resets on restart). `client` is `claude` (an address in `BREWPAGE_SHARED_EGRESS_CIDRS` or a `Claude...` User-Agent), `chatgpt` (an address in a published egress list or an `openai-mcp`/`ChatGPT` User-Agent), else `other`; `outcome` is `ok`, `tool_error`, `error` or `client_closed`. No IPs, arguments or content in any label.
 
 | 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_METRICS_CIDRS` | empty | Comma list of CIDRs or IPs allowed to read `GET /metrics`; empty = `/metrics` answers 404 |
 | `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 |
@@ -725,6 +757,14 @@ Every publish response includes an **owner token** -- the only credential that a
 
 ## Changelog
 
+## 1.21.0 -- 2026-11-12
+
+- Remote mode only: optional `GET /metrics` with usage counts for the operator (calls per tool, Claude, ChatGPT or other clients, distinct clients per day), served only to the addresses in `BREWPAGE_METRICS_CIDRS`. No addresses, arguments or content are kept or shown. Tools, inputs and stdio are unchanged: thirty-two tools, contract 2.27.0. `User-Agent: brewpage-mcp/1.21.0`.
+
+## 1.20.0 -- 2026-11-12
+
+- Two new tools. `make_private` turns a public publication into a private one: new private link, the public link stops working, views and stats stay; one-way. `set_badge` hides or shows the BrewPage badge on a publication of your profile, up to 5 hidden. `set_visibility` reads as list or unlist; inputs unchanged. The server instructions and the tools that send page code say that page code must not hide or alter the badge. Thirty-two tools. Contract 2.27.0. `User-Agent: brewpage-mcp/1.20.0`.
+
 ## 1.19.1 -- 2026-11-12
 
 - README only: the remote server `https://brewpage.app/mcp` comes first, with setup steps for Claude and ChatGPT; the local `npx` server is the fallback; the global install section is removed. No tool or input change. Contract 2.22.0. `User-Agent: brewpage-mcp/1.19.1`.

package/dist/http.js

@@ -8,6 +8,7 @@ import { pathToFileURL } from "node:url";
 import { createMcpHandler, InMemoryTransport, isLegacyRequest, LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/server";
 import { NodeStreamableHTTPServerTransport, toWebRequest } from "@modelcontextprotocol/node";
 import { createServer, OWNER_TOKEN_ENV, USER_AGENT } from "./tools.js";
+import { classifyClient, UsageMetrics } from "./metrics.js";
 const MIB = 1024 * 1024;
 /** 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. */
@@ -143,6 +144,8 @@ function loadConfig() {
         /** 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"),
+        /** Peers allowed to read GET /metrics (the Prometheus network); empty = /metrics answers 404. */
+        metricsPeers: parseCidrs("BREWPAGE_METRICS_CIDRS", false),
         host: process.env.BREWPAGE_MCP_HOST || "0.0.0.0",
         port,
     };
@@ -457,7 +460,10 @@ async function main() {
     const heavy = new Pool(MAX_HEAVY_IN_FLIGHT, MAX_HEAVY_PER_CLIENT);
     let draining = false;
     const listed = new Map();
-    let sharedEgress = blockList(config.sharedEgress);
+    const staticEgress = blockList(config.sharedEgress);
+    let listedEgress = blockList([]);
+    const metricsPeers = config.metricsPeers.length > 0 ? blockList(config.metricsPeers) : undefined;
+    const metrics = new UsageMetrics([...toolNames]);
     /** Never throws: a failed fetch or parse keeps the last good set and logs a warning. */
     async function loadEgressList(url) {
         try {
@@ -469,7 +475,7 @@ async function main() {
             }
             const ranges = parseEgressList(await readCapped(res, SHARED_LIST_MAX_BYTES));
             listed.set(url, ranges);
-            sharedEgress = blockList([...config.sharedEgress, ...[...listed.values()].flat()]);
+            listedEgress = blockList([...listed.values()].flat());
             log({ event: "shared_egress_list", url, ranges: ranges.length });
         }
         catch (error) {
@@ -479,7 +485,7 @@ async function main() {
     const refreshEgressLists = () => config.sharedEgressLists.forEach((url) => void loadEgressList(url));
     refreshEgressLists();
     setInterval(refreshEgressLists, SHARED_LIST_REFRESH_MS).unref();
-    async function handleMcp(req, res, entry) {
+    async function handleMcp(req, res, entry, usage) {
         if (req.headers.origin !== undefined)
             return rpcError(res, 403, SERVER_ERROR, "Origin not allowed.");
         const peer = peerAddress(req);
@@ -502,7 +508,9 @@ async function main() {
             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 family = isIP(client) === 6 ? "ipv6" : "ipv4";
+        const egress = staticEgress.check(client, family) ? "static" : listedEgress.check(client, family) ? "listed" : undefined;
+        const shared = egress !== undefined;
         const capKey = shared ? undefined : client;
         // Registered first: a client that leaves at any point, even while queued, aborts the call.
         const abort = new AbortController();
@@ -562,6 +570,8 @@ async function main() {
             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;
+            usage.client = classifyClient(egress, (req.headers["user-agent"] ?? "").slice(0, MAX_LOGGED_METHOD));
+            usage.address = client;
             // Stateless: no server-push streams, as the 2025 GET stream (405); a refused auto-open never fails a connect.
             if (rpc.method === "subscriptions/listen") {
                 const id = message.id;
@@ -634,18 +644,24 @@ async function main() {
             slot?.give(capKey);
         }
     }
-    function handle(req, res, entry) {
+    function handle(req, res, entry, usage) {
         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 Promise.resolve();
         }
+        const peer = peerAddress(req);
+        if (path === "/metrics" && req.method === "GET" && isIP(peer) !== 0 && metricsPeers?.check(peer, isIP(peer) === 6 ? "ipv6" : "ipv4")) {
+            res.writeHead(200, { "Content-Type": "text/plain; version=0.0.4; charset=utf-8" });
+            res.end(metrics.render());
+            return Promise.resolve();
+        }
         if (path !== "/mcp") {
             rpcError(res, 404, SERVER_ERROR, "Not found.");
             return Promise.resolve();
         }
-        return handleMcp(req, res, entry).catch((error) => {
+        return handleMcp(req, res, entry, usage).catch((error) => {
             entry.outcome = "exception";
             log({ event: "request_failed", message: error instanceof Error ? error.message : String(error) });
             if (!res.headersSent)
@@ -657,11 +673,12 @@ async function main() {
     const httpServer = createHttpServer((req, res) => {
         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");
+        const usage = {};
+        const logged = !(req.url ?? "").startsWith("/healthz") && !(req.url ?? "").startsWith("/metrics");
         const closedEarly = new Promise((resolve) => res.once("close", () => resolve(!res.writableFinished)));
         let done;
         try {
-            done = handle(req, res, entry);
+            done = handle(req, res, entry, usage);
         }
         catch (error) {
             entry.outcome = "exception";
@@ -681,6 +698,11 @@ async function main() {
                 entry.outcome ??= res.statusCode < 400 ? "ok" : `http_${res.statusCode}`;
             entry.ms = Math.round(performance.now() - started);
             log(entry);
+            if (usage.client === undefined || typeof entry.method !== "string")
+                return;
+            metrics.request(entry.method, usage.client);
+            if (typeof entry.tool === "string")
+                metrics.toolCall(entry.tool, usage.client, String(entry.outcome), usage.address);
         });
     });
     // Whole request incl. queue wait: 30 s queue + 2 s grace + 32 MiB at the body floor (~131 s) + margin.

package/dist/metrics.d.ts

@@ -0,0 +1,24 @@
+/** Client class: Claude (Anthropic egress or Claude UA), ChatGPT (OpenAI egress or UA), else other. */
+export type ClientClass = "claude" | "chatgpt" | "other";
+/** Egress source of the caller's IP: static shared CIDRs = Anthropic, published lists = OpenAI (deploy contract). */
+export type Egress = "static" | "listed" | undefined;
+export declare function classifyClient(egress: Egress, userAgent: string): ClientClass;
+/** Bounded outcome label from the request log outcome. */
+export declare function outcomeClass(outcome: string | number | null | undefined): string;
+/** In-memory MCP usage counters in Prometheus text format; labels are closed sets, never IPs or arguments. */
+export declare class UsageMetrics {
+    private readonly tools;
+    private readonly now;
+    private readonly requests;
+    private readonly toolCalls;
+    private day;
+    private salt;
+    private readonly daily;
+    constructor(tools: readonly string[], now?: () => Date);
+    request(method: string, client: ClientClass): void;
+    /** One tools/call; `address` only feeds the daily distinct set as a keyed hash. */
+    toolCall(tool: string, client: ClientClass, outcome: string, address: string): void;
+    render(): string;
+    /** New UTC day: forget every hash and draw a new random salt, so days cannot be linked. */
+    private roll;
+}

package/dist/metrics.js

@@ -0,0 +1,84 @@
+import { createHmac, randomBytes } from "node:crypto";
+const CLIENTS = ["claude", "chatgpt", "other"];
+const METHODS = ["initialize", "notifications/initialized", "tools/list", "tools/call", "ping", "server/discover", "other"];
+const OUTCOMES = ["ok", "tool_error", "error", "client_closed"];
+/** Distinct-client memory bound (~100 bytes each); past it the day's gauge stops growing. */
+const MAX_DAILY_CLIENTS = 100_000;
+export function classifyClient(egress, userAgent) {
+    if (egress === "static" || /^claude/i.test(userAgent))
+        return "claude";
+    if (egress === "listed" || /^openai-mcp|chatgpt/i.test(userAgent))
+        return "chatgpt";
+    return "other";
+}
+/** Bounded outcome label from the request log outcome. */
+export function outcomeClass(outcome) {
+    return outcome === "ok" || outcome === "tool_error" || outcome === "client_closed" ? outcome : "error";
+}
+/** In-memory MCP usage counters in Prometheus text format; labels are closed sets, never IPs or arguments. */
+export class UsageMetrics {
+    tools;
+    now;
+    requests = new Map();
+    toolCalls = new Map();
+    day = "";
+    salt = Buffer.alloc(0);
+    daily = new Map();
+    constructor(tools, now = () => new Date()) {
+        this.tools = tools;
+        this.now = now;
+        // Every series born at 0, so increase() sees the first call after a restart.
+        for (const client of CLIENTS) {
+            for (const method of METHODS)
+                this.requests.set(`${method}\t${client}`, 0);
+            for (const tool of [...tools, "unknown"])
+                for (const outcome of OUTCOMES)
+                    this.toolCalls.set(`${tool}\t${client}\t${outcome}`, 0);
+        }
+    }
+    request(method, client) {
+        const key = `${METHODS.includes(method) ? method : "other"}\t${client}`;
+        this.requests.set(key, (this.requests.get(key) ?? 0) + 1);
+    }
+    /** One tools/call; `address` only feeds the daily distinct set as a keyed hash. */
+    toolCall(tool, client, outcome, address) {
+        const key = `${this.tools.includes(tool) ? tool : "unknown"}\t${client}\t${outcomeClass(outcome)}`;
+        this.toolCalls.set(key, (this.toolCalls.get(key) ?? 0) + 1);
+        this.roll();
+        const seen = this.daily.get(client);
+        if ([...this.daily.values()].reduce((sum, set) => sum + set.size, 0) >= MAX_DAILY_CLIENTS)
+            return;
+        seen.add(createHmac("sha256", this.salt).update(address).digest("base64").slice(0, 22));
+    }
+    render() {
+        this.roll();
+        const lines = [
+            "# HELP brewpage_mcp_requests_total Remote MCP JSON-RPC requests by method and client class.",
+            "# TYPE brewpage_mcp_requests_total counter",
+            ...[...this.requests].map(([key, value]) => {
+                const [method, client] = key.split("\t");
+                return `brewpage_mcp_requests_total{method="${method}",client="${client}"} ${value}`;
+            }),
+            "# HELP brewpage_mcp_tool_calls_total Remote MCP tools/call by tool, client class and outcome.",
+            "# TYPE brewpage_mcp_tool_calls_total counter",
+            ...[...this.toolCalls].map(([key, value]) => {
+                const [tool, client, outcome] = key.split("\t");
+                return `brewpage_mcp_tool_calls_total{tool="${tool}",client="${client}",outcome="${outcome}"} ${value}`;
+            }),
+            "# HELP brewpage_mcp_clients_today Distinct client addresses with a tools/call since 00:00 UTC (since start if later).",
+            "# TYPE brewpage_mcp_clients_today gauge",
+            ...CLIENTS.map((client) => `brewpage_mcp_clients_today{client="${client}"} ${this.daily.get(client).size}`),
+        ];
+        return `${lines.join("\n")}\n`;
+    }
+    /** New UTC day: forget every hash and draw a new random salt, so days cannot be linked. */
+    roll() {
+        const day = this.now().toISOString().slice(0, 10);
+        if (day === this.day)
+            return;
+        this.day = day;
+        this.salt = randomBytes(32);
+        for (const client of CLIENTS)
+            this.daily.set(client, new Set());
+    }
+}

package/dist/tools.d.ts

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/server";
 export declare const DEFAULT_BASE_URL = "https://brewpage.app";
-export declare const USER_AGENT = "brewpage-mcp/1.19.1";
+export declare const USER_AGENT = "brewpage-mcp/1.21.0";
 export declare const OWNER_TOKEN_ENV = "BREWPAGE_OWNER_TOKEN";
 /** Server instructions of the handshake: one paragraph per line; the first stands alone within 512 chars. */
 export declare const SERVER_INSTRUCTIONS: string;

package/dist/tools.js

@@ -2,13 +2,14 @@ import { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { PAGE_DATA_CALLS, PAGE_DATA_GUIDE } from "./guides/page-data.js";
 export const DEFAULT_BASE_URL = "https://brewpage.app";
-export const USER_AGENT = "brewpage-mcp/1.19.1";
+export const USER_AGENT = "brewpage-mcp/1.21.0";
 export const OWNER_TOKEN_ENV = "BREWPAGE_OWNER_TOKEN";
 /** Server instructions of the handshake: one paragraph per line; the first stands alone within 512 chars. */
 export const SERVER_INSTRUCTIONS = [
     "BrewPage publishes HTML, Markdown, sites, files, JSON and KV and returns a share link plus an owner token. Keep the owner token private and send it as ownerToken on every later call for that publication; it cannot be recovered. A page that must save what its visitors enter (form answers, guestbook, votes, scores, game progress) needs Page data: read get_guide topic page-data BEFORE writing the page, then publish with the state argument.",
     "After publishing, give the user the page link and the management link from the result. Say that the management link is private: whoever has it can edit or delete the page, and its Data tab shows what visitors saved.",
     "KV and JSON tools hold your own data. Page data holds what a page's visitors save: get_page_data reads it, set_page_data writes author entries, configure_page_data changes who can read a list, delete_page_data moderates. In a later chat these four take the management link as manageUrl.",
+    "HTML pages and sites show a small BrewPage badge; page code must not hide or alter it. A profile can turn it off on up to 5 pages (set_badge).",
 ].join("\n");
 const READ_ONLY = { readOnlyHint: true };
 const DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true };
@@ -27,6 +28,10 @@ const NO_PUBLIC_CREDENTIALS = "BrewPage tokens and manage links must never be in
 const SECRETS = "Secrets allowed; likely ones are flagged in notices. Private namespace + password suit secrets. " +
     NO_PUBLIC_CREDENTIALS;
 const MANAGE_URL_TEXT = "Returns manageUrl, a private management link (grants control; not for public sharing).";
+/** Badge sentence of the four tools that publish or replace page code. */
+const BADGE_TEXT = "Page code must not hide or alter the BrewPage badge; a profile can turn the badge off for a page.";
+const BADGE_NEEDS_PROFILE_CODE = "badge-hide-needs-profile";
+const BADGE_NEEDS_PROFILE_NEXT = "Next: sign in at https://account.brewpage.app, add this publication's owner token with bind_token, then retry.";
 const OLD_READ_ONLY_CODE = "OLD_PUBLICATION_READ_ONLY";
 const WRONG_TYPE_CODE = "WRONG_RESOURCE_TYPE";
 /** 403 message of a rename on a publication no profile owns. */
@@ -466,7 +471,7 @@ function ownerLinkLines(data) {
         lines.push(``, `MANAGE LINK (private): ${data.manageUrl}`, `Give it to the user with the link: anyone who has it can edit or delete this publication. Never post it publicly.`);
     }
     if (data.listed === true && !hasCredentialNotice(data))
-        lines.push(``, `VISIBILITY: public, listed. Hide: set_visibility listed=false`);
+        lines.push(``, `VISIBILITY: public, listed. Unlist: set_visibility listed=false`);
     return lines;
 }
 /** Optional delivery fields on HTML and hosting responses: why the mode was chosen, flagged or not applied. */
@@ -513,7 +518,7 @@ export function createServer(options = {}) {
     const apiFetch = options.fetch ?? fetch;
     const server = new McpServer({
         name: "brewpage-mcp",
-        version: "1.19.1",
+        version: "1.21.0",
     }, { instructions: SERVER_INSTRUCTIONS });
     /** Caller argument first, then the configured default; `fromEnv` marks the configured one. */
     function ownerTokenFor(argument) {
@@ -595,7 +600,7 @@ export function createServer(options = {}) {
             "A `public` page without deliveryMode may get its own subdomain if it needs browser features a BrewPage link lacks; " +
             "the result then has deliveryModeReason and a delivery notice. Markdown raw HTML is allowlisted: scripts, styles, event handlers, forms, embeds removed. " +
             "Optional `domain` connects a domain the user owns to an HTML-format page. " +
-            MANAGE_URL_TEXT + " " + SECRETS + " " + PUBLISH_STATE_TEXT,
+            MANAGE_URL_TEXT + " " + SECRETS + " " + BADGE_TEXT + " " + PUBLISH_STATE_TEXT,
         inputSchema: {
             content: z.string().describe("HTML, Markdown, code or JSON to publish"),
             deliveryMode: DELIVERY_MODE_SCHEMA,
@@ -858,7 +863,7 @@ export function createServer(options = {}) {
         ...toolMeta("Publish site", ADDITIVE),
         description: "Publish an HTML site to BrewPage. " + PUBLIC_HINT + "Single-page: `entryContent`. Multi-page: `files` (`{path, content}` array). Optional `entry` overrides `index.html`. Returns its primary share link and owner token. " +
             "Static only: HTML, CSS, JS (incl. built React/Vue bundles) run in the browser; server code (PHP etc.) never runs. " + SITE_LIMITS_TEXT +
-            " Optional `domain` connects a domain the user owns. " + MANAGE_URL_TEXT + " " + SECRETS + " " + PUBLISH_STATE_TEXT,
+            " Optional `domain` connects a domain the user owns. " + MANAGE_URL_TEXT + " " + SECRETS + " " + BADGE_TEXT + " " + PUBLISH_STATE_TEXT,
         inputSchema: {
             deliveryMode: DELIVERY_MODE_SCHEMA,
             entryContent: z
@@ -977,7 +982,7 @@ export function createServer(options = {}) {
     });
     server.registerTool("republish_site", {
         ...toolMeta("Republish site", DESTRUCTIVE),
-        description: "Republish (full-replace) an existing multi-file BrewPage site in place at the SAME URL/ID. Requires owner token. The uploaded bundle becomes the complete new file set — files absent from it are removed, new files added, matching files overwritten. Single-page: `entryContent`. Multi-page: `files` (array of `{path, content}`). Optional `entry` overrides the default `index.html`. Republishing preserves existing expiry." + OLD_READ_ONLY_TEXT + " " + SITE_LIMITS_TEXT + " " + NO_PUBLIC_CREDENTIALS,
+        description: "Republish (full-replace) an existing multi-file BrewPage site in place at the SAME URL/ID. Requires owner token. The uploaded bundle becomes the complete new file set — files absent from it are removed, new files added, matching files overwritten. Single-page: `entryContent`. Multi-page: `files` (array of `{path, content}`). Optional `entry` overrides the default `index.html`. Republishing preserves existing expiry." + OLD_READ_ONLY_TEXT + " " + SITE_LIMITS_TEXT + " " + NO_PUBLIC_CREDENTIALS + " " + BADGE_TEXT,
         inputSchema: {
             namespace: z.string().describe("Site namespace"),
             id: z.string().describe("Site ID"),
@@ -1076,7 +1081,7 @@ export function createServer(options = {}) {
         ...toolMeta("Update page", DESTRUCTIVE),
         description: "Update an existing BrewPage HTML, Markdown, code or JSON page. Requires owner token. Returns the updated page metadata. " +
             "Format omitted keeps the stored format, except a whole HTML document makes a Markdown page an HTML page. " +
-            "The link and delivery mode never change on update; an advisory deliveryModeReason and delivery notice are included when the new content uses browser features that may not work fully on a BrewPage link." + OLD_READ_ONLY_TEXT + " " + NO_PUBLIC_CREDENTIALS,
+            "The link and delivery mode never change on update; an advisory deliveryModeReason and delivery notice are included when the new content uses browser features that may not work fully on a BrewPage link." + OLD_READ_ONLY_TEXT + " " + NO_PUBLIC_CREDENTIALS + " " + BADGE_TEXT,
         inputSchema: {
             namespace: z.string().describe("Page namespace"),
             id: z.string().describe("Page ID"),
@@ -1475,12 +1480,12 @@ export function createServer(options = {}) {
     });
     server.registerTool("set_visibility", {
         ...toolMeta("Set gallery visibility", ADDITIVE),
-        description: "Hide or show a public publication in the gallery and sitemap. Link unchanged.",
+        description: "List or unlist a public publication in the gallery and sitemap. Link unchanged.",
         inputSchema: {
             type: z.enum(["html", "site", "file", "json", "kv"]).describe("Publication type; only public html, site and file can be listed"),
             namespace: z.string().describe("Publication namespace"),
             id: z.string().describe("Publication ID"),
-            listed: z.boolean().describe("false = hide, true = show"),
+            listed: z.boolean().describe("true = listed, false = unlisted"),
             ownerToken: z.string().optional().describe(OWNER_TOKEN_DESCRIPTION),
         },
     }, async ({ type, namespace, id, listed, ownerToken }) => {
@@ -1494,6 +1499,64 @@ export function createServer(options = {}) {
         const result = data;
         return textResult([...credentialAlertLines(result), `LISTED: ${result.listed} · link unchanged`, ...noticeLines(result)].join("\n"));
     });
+    server.registerTool("make_private", {
+        ...toolMeta("Make private", DESTRUCTIVE),
+        description: "Make a public publication private: it gets a new private link and the public link stops working; a custom domain on it is detached. One-way. " +
+            "Returns the new link, namespace and id, plus a new management link when the publication had one; the owner token stays the same.",
+        inputSchema: {
+            type: z.enum(["html", "site", "file", "json", "kv"]).describe("Publication type"),
+            namespace: z.string().describe("Publication namespace; only `public` publications can be made private"),
+            id: z.string().describe("Publication ID"),
+            ownerToken: z.string().optional().describe(OWNER_TOKEN_DESCRIPTION),
+        },
+    }, async ({ type, namespace, id, ownerToken }) => {
+        const auth = ownerTokenFor(ownerToken);
+        if (!auth.token)
+            return textResult(NO_OWNER_TOKEN, true);
+        const path = apiPath(TYPE_SEGMENTS[type], namespace, id, "private");
+        const { ok, status, data, headers: answerHeaders } = await apiRequest("POST", path, undefined, { "X-Owner-Token": auth.token });
+        if (!ok)
+            return ownerFailure("make private", status, data, auth.fromEnv, answerHeaders);
+        const result = data;
+        return textResult([
+            ...credentialAlertLines(result),
+            `MADE PRIVATE · the public link no longer works`,
+            ``,
+            `New link: ${result.link || "N/A"}`,
+            `Namespace: ${result.namespace || "N/A"}`,
+            `ID: ${result.id || "N/A"}`,
+            `Give the user the new link. Later calls take this namespace and ID with the same owner token.`,
+            ...noticeLines(result),
+            ...ownerLinkLines(result),
+        ].join("\n"));
+    });
+    server.registerTool("set_badge", {
+        ...toolMeta("Hide or show badge", ADDITIVE),
+        description: "Hide or show the BrewPage badge on a publication. Needs an owner token that is in a BrewPage profile (free sign-in at https://account.brewpage.app); up to 5 hidden per profile.",
+        inputSchema: {
+            type: z.enum(["html", "site", "file", "json", "kv"]).describe("Publication type"),
+            namespace: z.string().describe("Publication namespace"),
+            id: z.string().describe("Publication ID"),
+            hidden: z.boolean().optional().describe("true = hide the badge, false = show it. Omit: report the current state."),
+            ownerToken: z.string().optional().describe(OWNER_TOKEN_DESCRIPTION),
+        },
+    }, async ({ type, namespace, id, hidden, ownerToken }) => {
+        const auth = ownerTokenFor(ownerToken);
+        if (!auth.token)
+            return textResult(NO_OWNER_TOKEN, true);
+        const path = apiPath(TYPE_SEGMENTS[type], namespace, id, "badge");
+        const { ok, status, data, headers: answerHeaders } = await apiRequest("POST", path, hidden === undefined ? {} : { hidden }, { "X-Owner-Token": auth.token });
+        if (!ok)
+            return ownerFailure("set badge", status, data, auth.fromEnv, answerHeaders);
+        const result = data;
+        const used = typeof result.used === "number" && result.used > 0 ? ` · ${result.used} of ${result.limit} hidden in the profile` : "";
+        return textResult([
+            ...credentialAlertLines(result),
+            `BADGE: ${result.hidden === true ? "hidden" : "shown"}${used} · link unchanged`,
+            ...noticeLines(result),
+            ...(notices(result).some((n) => n.code === BADGE_NEEDS_PROFILE_CODE) ? [BADGE_NEEDS_PROFILE_NEXT] : []),
+        ].join("\n"));
+    });
     server.registerTool("set_title", {
         ...toolMeta("Rename page or site", ADDITIVE),
         description: "Rename an HTML page or site: the title shown in the gallery, profile, search and link cards. " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brewpage-mcp",
-  "version": "1.19.1",
+  "version": "1.21.0",
   "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",