brewpage-mcp 1.17.0 → 1.18.1

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 twenty-one 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 twenty-five 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.
 
@@ -17,14 +17,14 @@ Choosing a host? See how BrewPage compares with GitHub Pages, Netlify Drop, Tiin
 ## Quick Start
 
 ```bash
-npx -y brewpage-mcp@1.17.0
+npx -y brewpage-mcp@1.18.1
 ```
 
 Requires Node.js 20 or newer. This starts the stdio server for an MCP client.
 
 ### Remote (no install)
 
-Add `https://brewpage.app/mcp` as a custom connector / remote MCP server by URL in Claude.ai, ChatGPT or any Streamable HTTP client. No auth; same 21 tools.
+Add `https://brewpage.app/mcp` as a custom connector / remote MCP server by URL in Claude.ai, ChatGPT or any Streamable HTTP client. No auth; same 25 tools.
 
 Claude Code: `claude mcp add --transport http brewpage https://brewpage.app/mcp`, or in `.mcp.json`:
 
@@ -50,7 +50,7 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.17.0"]
+      "args": ["-y", "brewpage-mcp@1.18.1"]
     }
   }
 }
@@ -61,7 +61,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.17.0
+claude mcp add --transport stdio --scope project brewpage -- npx -y brewpage-mcp@1.18.1
 ```
 
 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).
@@ -75,7 +75,7 @@ Open **Settings > MCP** and add:
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.17.0"]
+      "args": ["-y", "brewpage-mcp@1.18.1"]
     }
   }
 }
@@ -89,7 +89,7 @@ Open the Cline MCP settings panel and add:
 {
   "brewpage": {
     "command": "npx",
-    "args": ["-y", "brewpage-mcp@1.17.0"]
+    "args": ["-y", "brewpage-mcp@1.18.1"]
   }
 }
 ```
@@ -97,13 +97,13 @@ Open the Cline MCP settings panel and add:
 ### Global Install
 
 ```bash
-npm install -g brewpage-mcp@1.17.0
+npm install -g brewpage-mcp@1.18.1
 brewpage-mcp
 ```
 
 ## Tools
 
-Twenty-one 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.
+Twenty-five 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 |
 |------|---------|
@@ -125,6 +125,10 @@ Twenty-one tools are available. Creation returns an owner token; keep it to modi
 | `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) |
+| `set_domain` | Connect a domain you own to an HTML page or site; returns the DNS records to create |
+| `list_domains` | List the profile's custom domains with status and DNS records (admin token) |
+| `check_domain` | Check a custom domain's DNS now; status `pending_dns` -> `verifying` -> `active` |
+| `remove_domain` | Remove a custom domain and free its slot; the BrewPage link keeps working |
 | `search_gallery` | Browse public content or list owned resources |
 | `get_stats` | Read platform-wide statistics |
 | `get_limits` | Read the current upload limits (`GET /api/limits`) |
@@ -159,7 +163,7 @@ update_hosting(type="html", namespace="public", id="aBcDeFgHiJ", ownerToken="tok
 
 Publish HTML, Markdown, code or JSON content to BrewPage; with `format` omitted the server detects it. Returns a public URL and owner token. Markdown raw HTML is rendered through an allowlist: scripts, styles, event handlers, forms, frames/embeds and `meta`/`base`/`link` are removed; links allow `http`, `https`, `mailto`, `tel` and relative URLs, images also `data:`; a lone unknown tag such as `<author>` shows as text.
 
-Parameters: `content` (string), `format` (optional; omit to let the server detect HTML, Markdown, code or JSON; `html` keeps code/JSON as HTML; also `markdown`/`md` or a code language), `namespace` (optional -- **omit for private, unlisted content**; `public` lists the page in the gallery and sitemap for Google, Bing and AI search, served on the brewpage.app domain; never put secrets there), `password` (optional), `ttlDays` (days or a string such as `2w`; default 15; the server clamps to 1--30, up to 90 with an owner token in a profile), `filename` (optional, used as title fallback), `showTopBar` (optional boolean -- adds a toolbar with filename, Download button, and theme toggle), `deliveryMode` (optional).
+Parameters: `content` (string), `format` (optional; omit to let the server detect HTML, Markdown, code or JSON; `html` keeps code/JSON as HTML; also `markdown`/`md` or a code language), `namespace` (optional -- **omit for private, unlisted content**; `public` lists the page in the gallery and sitemap for Google, Bing and AI search, served on the brewpage.app domain; never put secrets there), `password` (optional), `ttlDays` (days or a string such as `2w`; default 15; the server clamps to 1--30, up to 90 with an owner token in a profile), `filename` (optional, used as title fallback), `showTopBar` (optional boolean -- adds a toolbar with filename, Download button, and theme toggle), `deliveryMode` (optional), `domain` (optional; a domain you own to connect to an HTML-format page, see Custom domains).
 
 The result includes `deliveryModeReason` and a `Delivery notice:` line when the server returns them (see above).
 
@@ -237,7 +241,7 @@ Publish a single-page or multi-file HTML site. Pass `entryContent` for a single
 
 Limits (current values from `get_limits`): a request is at most 25 MiB; a site at most 200 files, 5 MiB per file and 20 MiB in total; each path at most 380 characters. System files such as `.DS_Store` and `__MACOSX/` are skipped and never count; files with an unsupported extension or a too-long path are skipped and reported in notices. Entry: `entry`, else root `index.html`, else the shallowest HTML file. A site limit hit answers 400 with a message naming the limit, as does a PDF/Office file that is unreadable or password-protected; 413 means the request is over 25 MiB, has too many files and form fields, or a file name/path is too long; 422 means no servable file is left; 503 means busy: retry after `Retry-After` seconds (failed publish tools print it).
 
-Parameters: exactly one of `entryContent` (string) or non-empty `files` (array of `{path, content}`), `entry` (optional entry file path, default `index.html`), `namespace` (optional -- omit for private, unlisted content; `public` lists the site in the gallery and sitemap for Google, Bing and AI search; a site always gets its own subdomain), `password` (optional), `ttlDays` (days or a string such as `2w`; default 15; the server clamps to 1--30, up to 90 with an owner token in a profile), `ownerToken` (optional, groups site under an existing owner), `deliveryMode` (optional; fresh sites require `subdomain`).
+Parameters: exactly one of `entryContent` (string) or non-empty `files` (array of `{path, content}`), `entry` (optional entry file path, default `index.html`), `namespace` (optional -- omit for private, unlisted content; `public` lists the site in the gallery and sitemap for Google, Bing and AI search; a site always gets its own subdomain), `password` (optional), `ttlDays` (days or a string such as `2w`; default 15; the server clamps to 1--30, up to 90 with an owner token in a profile), `ownerToken` (optional, groups site under an existing owner), `deliveryMode` (optional; fresh sites require `subdomain`), `domain` (optional; a domain you own to connect to the site, see Custom domains).
 
 Example prompt:
 
@@ -441,6 +445,56 @@ Parameters: `label` (optional), `scope` (`publish` default | `admin`), `expiresI
 
 ---
 
+### Custom domains
+
+Show one HTML page (format html, no password) or one site on a domain you own, such as `www.example.com` or `example.com`. Free, 5 per profile. The owner token must be in a free BrewPage profile: sign in at https://account.brewpage.app and add the token there, or with `bind_token`. The BrewPage link keeps working.
+
+How it goes: `set_domain` returns the DNS records, the domain owner creates exactly those records at their DNS provider, then `check_domain` reports the status: `pending_dns` (records not seen yet), `verifying` (DNS found, HTTPS being issued), `active` (live). HTTPS is issued automatically. The records come from the result, never from memory: a subdomain takes a TXT record at `_brewpage.<host>` plus a CNAME to `domains.brewpage.app`; a root domain takes the TXT record plus the A record shown, or the optional ALIAS row.
+
+`publish_html` and `publish_site` accept an optional `domain` to connect it while publishing. The publication is always created; the result prints a `CUSTOM DOMAIN` block with the records, or says the domain was not set next to the notice that explains why.
+
+### `set_domain`
+
+Connect a domain to an HTML page or site (`PUT /api/publications/{html|site}/{ns}/{id}/domain`). A hostname already in the profile moves to this publication. A page on a BrewPage path address moves to its own subdomain, and its BrewPage link keeps working.
+
+Parameters: `type` (`html` | `site`), `namespace`, `id`, `hostname` (e.g. `www.example.com` or `example.com`), `ownerToken` (optional; the publication's owner token added to a profile, or a profile token).
+
+```
+set_domain(type="html", namespace="public", id="aBcDeFgHiJ", hostname="www.example.com")
+```
+
+Output: `Custom domain connected.`, then `Domain:`, `Status:`, `Problem:` (what is still missing), `Serving:`, `Shows:`, the `records[]` rows verbatim as JSON (`type`, `name`, `host`, `value`, `state`) and the next step. `host` is the name DNS panels ask for.
+
+---
+
+### `list_domains`
+
+List the custom domains of a profile (`GET /api/domains`): how many are used and allowed, and for each one its status, DNS records and the publication it shows.
+
+Parameters: `ownerToken` (admin token of the profile; optional, default `BREWPAGE_OWNER_TOKEN`, local server only).
+
+---
+
+### `check_domain`
+
+Check DNS now and return the updated status and records. By publication: `type`, `namespace`, `id` with an owner token in the profile (`POST /api/publications/{html|site}/{ns}/{id}/domain/check`). By hostname: `hostname` with an admin token of the profile (`POST /api/domains/{hostname}/check`). Checks are spaced: a repeat too soon answers 429 and the result prints `Retry-After`.
+
+Parameters: either `type` + `namespace` + `id`, or `hostname`; `ownerToken` (optional).
+
+```
+check_domain(type="html", namespace="public", id="aBcDeFgHiJ")
+```
+
+---
+
+### `remove_domain`
+
+Remove a custom domain from the profile and free its slot (`DELETE /api/publications/{html|site}/{ns}/{id}/domain` or `DELETE /api/domains/{hostname}`). The BrewPage link keeps working; the DNS records can be deleted at the DNS provider afterwards.
+
+Parameters: either `type` + `namespace` + `id`, or `hostname`; `ownerToken` (optional; by hostname an admin token of the profile).
+
+---
+
 ### `get_stats`
 
 Get platform-wide BrewPage usage statistics (page count, file count, storage, daily totals). Supports an optional IANA timezone for the "today" boundary.
@@ -495,6 +549,10 @@ get_limits()
 | "What did I store under that key?" | `get_kv` | By `namespace` + `id` + `key` |
 | "List my published pages" / "What did I publish?" | `search_gallery` | Set `mine=true` + `ownerToken` |
 | "Browse the public BrewPage gallery" | `search_gallery` | Optional `q`, `sort=date\|views` |
+| "Put this page on my own domain" | `set_domain` | Owner token in a free profile; returns the DNS records to create |
+| "I added the DNS records, is my domain live?" | `check_domain` | Status `pending_dns` -> `verifying` -> `active` |
+| "Which domains do I have?" | `list_domains` | Admin token of the profile |
+| "Disconnect my domain" | `remove_domain` | The BrewPage link keeps working |
 
 ## Owner Token
 
@@ -547,6 +605,14 @@ Every publish response includes an **owner token** -- the only credential that a
 
 ## Changelog
 
+## 1.18.1 -- 2026-11-10
+
+- Publish results tell the assistant to give the user the management link together with the page link: anyone who has it can edit or delete the publication, so it is never posted publicly. Text only: no tool or input change. Contract 2.20.5. `User-Agent: brewpage-mcp/1.18.1`.
+
+## 1.18.0 -- 2026-11-10
+
+- Custom domains: four new tools. `set_domain` connects a domain you own to an HTML page or site and returns the DNS records to create at your DNS provider; `check_domain` checks DNS and reports the status (`pending_dns`, `verifying`, `active`); `list_domains` lists the profile's domains; `remove_domain` removes one and frees its slot. `publish_html` and `publish_site` take an optional `domain`. Free, 5 per profile; the owner token must be in a BrewPage profile (free sign-in at account.brewpage.app). Twenty-five tools. `User-Agent: brewpage-mcp/1.18.0`.
+
 ## 1.17.0 -- 2026-11-09
 
 - New tool `set_title`: rename an HTML page or site you own (owner token in a BrewPage profile); the title shows in the gallery, profile, search and link cards and stays when you republish. Empty title restores the one from the content. Twenty-one tools. `User-Agent: brewpage-mcp/1.17.0`.

package/dist/http.js

@@ -29,7 +29,7 @@ const MAX_HEAVY_PER_CLIENT = 1;
 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 LIGHT_TOOLS = new Set(["get_limits", "get_stats", "search_gallery", "list_domains"]);
 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;

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.17.0";
+export declare const USER_AGENT = "brewpage-mcp/1.18.1";
 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/server";
 import { z } from "zod";
 export const DEFAULT_BASE_URL = "https://brewpage.app";
-export const USER_AGENT = "brewpage-mcp/1.17.0";
+export const USER_AGENT = "brewpage-mcp/1.18.1";
 export const OWNER_TOKEN_ENV = "BREWPAGE_OWNER_TOKEN";
 const READ_ONLY = { readOnlyHint: true };
 const DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true };
@@ -32,6 +32,106 @@ const CREDENTIAL_CODE = "credential-published";
 const CREDENTIAL_ALERT_TAIL = "Tell the user now: anyone with this link can use that token; they must remove it and reset it.";
 /** MCP type name -> REST path segment. */
 const TYPE_SEGMENTS = { html: "html", site: "sites", file: "files", json: "json", kv: "kv" };
+const DOMAIN_PROFILE_TEXT = "Works when the owner token is in a free BrewPage profile (sign-in at https://account.brewpage.app); free, 5 domains per profile.";
+const DOMAIN_ADDRESS_TEXT = "Addressed by publication (type, namespace, id; an owner token in the profile) or by hostname (an admin token of the profile).";
+const DOMAIN_OWNER_TOKEN = `Owner token in a BrewPage profile: the publication's own token added to the profile, or a profile token. Default: ${ENV_DEFAULT}.`;
+const DOMAIN_EITHER_TOKEN = `By publication: an owner token in the profile. By hostname: an admin token of the profile. Default: ${ENV_DEFAULT}.`;
+const DOMAIN_ADDRESS_ERROR = "Provide either `hostname` (admin token of the profile) or `type`, `namespace` and `id` (an owner token in the profile).";
+const DOMAIN_ARGUMENT = "Optional domain the user owns (www.example.com or example.com) to connect to the new publication. " +
+    "Works when the owner token is in a free BrewPage profile, without a password. The publication is always created; " +
+    "the result lists the DNS records for the domain owner to create, or says why the domain was not set.";
+/** Plain words for `DomainItem.problem`; other codes print bare. */
+const DOMAIN_PROBLEMS = {
+    TXT_MISSING: "the TXT record is not visible yet",
+    TXT_WRONG: "the TXT record has another value",
+    ROUTING_MISSING: "the CNAME or A record is not visible yet",
+    ROUTING_WRONG: "the CNAME or A record points elsewhere",
+    FOREIGN_AAAA: "an AAAA record points elsewhere: delete it",
+    CAA_BLOCKS: "a CAA record stops the HTTPS certificate: add the CAA record listed",
+    DOMAIN_TAKEN: "this hostname is not available",
+    QUEUE_FULL: "DNS is right; the next step is queued and retried automatically",
+    CERT_PENDING: "the HTTPS certificate is on its way",
+    CERT_FAILED: "the HTTPS certificate was not issued: check DNS, then check again",
+    DNS_LOST: "the records stayed broken: restore them, then check again",
+    CHECK_PAUSED: "automatic checks are paused; a check resumes them",
+    RESOLVER_UNAVAILABLE: "DNS did not answer; retried automatically",
+    PUBLICATION_GONE: "the publication is gone: set the domain on another one",
+};
+const DOMAIN_NEXT_CREATE = "Next: ask the user to add exactly these records at their DNS provider and change nothing else (keep MX/email records); `host` is the name DNS panels ask for. Then call check_domain. BrewPage also checks on its own and issues HTTPS automatically.";
+/** One custom domain (`DomainItem`): status, `records[]` verbatim and the next step. */
+function domainLines(item) {
+    const { hostname, displayHostname, problem, url } = item;
+    const records = Array.isArray(item.records) ? item.records : [];
+    const lines = [
+        `Domain: ${hostname}${typeof displayHostname === "string" && displayHostname !== hostname ? ` (${displayHostname})` : ""}`,
+        `Status: ${item.status}`,
+    ];
+    if (typeof problem === "string" && problem)
+        lines.push(`Problem: ${problem}${DOMAIN_PROBLEMS[problem] ? ` (${DOMAIN_PROBLEMS[problem]})` : ""}`);
+    lines.push(`Serving: ${item.serving === true}`);
+    if (item.suspended === true)
+        lines.push(`suspended: true`);
+    if (typeof url === "string" && url)
+        lines.push(`Domain URL: ${url}`);
+    const shown = item.attachedTo;
+    lines.push(shown && typeof shown === "object" ? `Shows: ${shown.type} ${shown.namespace}/${shown.id} · ${shown.link}` : `Shows: no publication yet`);
+    if (typeof item.provider === "string" && item.provider)
+        lines.push(`DNS provider: ${item.provider}`);
+    if (item.deliveryModeChanged === true)
+        lines.push(`The publication moved to its own BrewPage subdomain (a custom domain needs it); its BrewPage link keeps working.`);
+    if (typeof item.detached === "string" && item.detached)
+        lines.push(`Earlier domain ${item.detached} stays in the profile, not attached.`);
+    for (const [field, label] of [["checkedAt", "Checked"], ["nextCheckAt", "Next automatic check"], ["graceEndsAt", "Shown until"]]) {
+        if (typeof item[field] === "string")
+            lines.push(`${label}: ${item[field]}`);
+    }
+    lines.push(`DNS records (records[], verbatim):`, ...records.map((record) => `  ${JSON.stringify(record)}`));
+    if (records.some((record) => record.optional === true))
+        lines.push(`A row with "optional":true is an alternative to the A record: one of the two is enough.`);
+    if (records.some((record) => record.type === "AAAA"))
+        lines.push(`An AAAA row is a record to delete, not to create.`);
+    if (item.provider === "cloudflare")
+        lines.push(`Cloudflare: Proxy status "DNS only" on the CNAME or A record.`);
+    if (item.suspended === true)
+        return lines;
+    if (item.status === "pending_dns")
+        lines.push(DOMAIN_NEXT_CREATE);
+    if (item.status === "verifying")
+        lines.push(`Next: DNS is found and HTTPS is being issued. Call check_domain again shortly.`);
+    if (item.status === "active")
+        lines.push(`Live: the domain shows the publication over HTTPS. The BrewPage link keeps working.`);
+    if (item.status === "lost")
+        lines.push(`Next: DNS changed after going live. Ask the user to restore exactly these records at their DNS provider, then call check_domain.`);
+    return lines;
+}
+/** Create with `domain`: the returned `customDomain`, else a line saying it was not set (the reason is a `domain-*` notice). */
+function publishDomainLines(data, requested) {
+    const item = data.customDomain;
+    if (item && typeof item === "object")
+        return [``, `CUSTOM DOMAIN`, ...domainLines(item)];
+    if (!requested)
+        return [];
+    const reason = notices(data).some((n) => n.code.startsWith("domain-")) ? " The domain notice above says why." : "";
+    return [``, `CUSTOM DOMAIN: ${requested} was not set; the publication is live at its BrewPage link.${reason} set_domain connects it later.`];
+}
+/** Next step after a custom-domain refusal; other codes keep the server answer alone. */
+function domainHints(data, byHostname) {
+    const { code, limit, used } = (data ?? {});
+    if (code === "DOMAIN_NEEDS_ACCOUNT") {
+        return ["Custom domains need a free BrewPage account: sign in at https://account.brewpage.app and add this token to your profile (bind_token), then retry."];
+    }
+    if (code === "DOMAIN_LIMIT" && typeof limit === "number" && limit > 0) {
+        return [`The profile uses ${typeof used === "number" ? used : limit} of ${limit} custom domains: remove_domain frees one; a hostname already in the profile moves here with set_domain.`];
+    }
+    if (code === "ADMIN_TOKEN_REQUIRED") {
+        return ["Custom domains need an admin token from a free BrewPage profile." + (byHostname ? " With an owner token of the publication, pass type, namespace and id instead of hostname." : "")];
+    }
+    if (code === "DOMAIN_CHECK_TOO_SOON")
+        return ["Checked a moment ago: wait, then call check_domain again."];
+    if (code === "DOMAIN_NOT_FOUND")
+        return ["No custom domain there: list_domains shows the profile's domains; set_domain connects one."];
+    return [];
+}
 /** `/api/<segments>` with each segment encoded; empty, `.` and `..` refused (URL parsing would resolve them away). */
 export function apiPath(...segments) {
     for (const segment of segments) {
@@ -67,7 +167,7 @@ const PUBLISH_TOOL_FOR = {
     "update HTML": "publish_html", "republish site": "publish_site", "update JSON": "publish_json", "set KV": "publish_kv",
 };
 /** Owner-tool failure: server answer verbatim plus a hint for wrong-token or no-profile 403, wrong type/missing row, frozen old row. */
-function ownerFailure(operation, status, data, fromEnv, headers) {
+function ownerFailure(operation, status, data, fromEnv, headers, extraHints = []) {
     const lines = [`Failed to ${operation} (${status}): ${JSON.stringify(data)}${retryAfterText(status, headers)}`];
     const { code, message, result } = (data ?? {});
     if (status === 403 && code === "OWNER_AUTHORIZATION_FAILED" && message === RENAME_NEEDS_PROFILE) {
@@ -92,6 +192,7 @@ function ownerFailure(operation, status, data, fromEnv, headers) {
             (typeof republishUrl === "string" ? " republishUrl is a browser-only composer link." : "") +
             (operation === "set KV" ? " A new KV store holds only the keys published to it." : ""));
     }
+    lines.push(...extraHints);
     return textResult(lines.join("\n"), true);
 }
 const PUBLIC_NAMESPACE = "public";
@@ -178,7 +279,7 @@ const SIGN_IN_HINT = "Optional: sign in free (Google or any email) at https://ac
 function ownerLinkLines(data) {
     const lines = [];
     if (typeof data.manageUrl === "string" && data.manageUrl.length > 0) {
-        lines.push(``, `MANAGE LINK (private): ${data.manageUrl}`, `Give it to the user privately; never publish it.`);
+        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`);
@@ -228,7 +329,7 @@ export function createServer(options = {}) {
     const apiFetch = options.fetch ?? fetch;
     const server = new McpServer({
         name: "brewpage-mcp",
-        version: "1.17.0",
+        version: "1.18.1",
     });
     /** Caller argument first, then the configured default; `fromEnv` marks the configured one. */
     function ownerTokenFor(argument) {
@@ -280,7 +381,7 @@ export function createServer(options = {}) {
     function titleLines(data) {
         return typeof data.title === "string" && data.title ? [`Title: ${data.title}`] : [];
     }
-    function formatPublishResponse(data, effectiveNamespace, sentOwnerToken, listable = true) {
+    function formatPublishResponse(data, effectiveNamespace, sentOwnerToken, listable = true, requestedDomain) {
         const lines = [
             ...credentialAlertLines(data),
             `Published successfully!`,
@@ -293,6 +394,7 @@ export function createServer(options = {}) {
         if (data.expiresAt)
             lines.push(`Expires: ${data.expiresAt}`);
         lines.push(...hostingResponseLines(data));
+        lines.push(...publishDomainLines(data, requestedDomain));
         lines.push(...ownerTokenLines(data, "update or delete this resource later", sentOwnerToken));
         lines.push(...ownerLinkLines(data));
         const ns = (data.namespace ?? effectiveNamespace) || "";
@@ -307,6 +409,7 @@ export function createServer(options = {}) {
             "Format order: `format`, then a known filename extension, else the server detects it. Returns its primary share link and owner token. Optional password, TTL, filename, top toolbar (showTopBar). " +
             "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,
         inputSchema: {
             content: z.string().describe("HTML, Markdown, code or JSON to publish"),
@@ -334,11 +437,12 @@ export function createServer(options = {}) {
                 .boolean()
                 .optional()
                 .describe("Add a thin top toolbar (filename + Download button + theme toggle) on the served page. Default: hidden."),
+            domain: z.string().optional().describe(DOMAIN_ARGUMENT),
             ownerToken: z.string().optional().describe(CREATE_OWNER_TOKEN_DESCRIPTION),
         },
-    }, async ({ content, format, namespace, password, ttlDays, filename, showTopBar, deliveryMode, ownerToken }) => {
+    }, async ({ content, format, namespace, password, ttlDays, filename, showTopBar, deliveryMode, domain, ownerToken }) => {
         const effectiveNamespace = resolveNamespace(namespace);
-        const path = withQuery(apiPath("html"), [["ns", effectiveNamespace], ["format", format?.toLowerCase()], ["ttl", ttlDays]]);
+        const path = withQuery(apiPath("html"), [["ns", effectiveNamespace], ["format", format?.toLowerCase()], ["ttl", ttlDays], ["domain", domain || undefined]]);
         const body = { content };
         if (filename)
             body.filename = filename;
@@ -368,7 +472,7 @@ export function createServer(options = {}) {
             content: [
                 {
                     type: "text",
-                    text: formatPublishResponse(data, effectiveNamespace, owner),
+                    text: formatPublishResponse(data, effectiveNamespace, owner, true, domain || undefined),
                 },
             ],
         };
@@ -562,7 +666,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 +
-            " " + MANAGE_URL_TEXT + " " + SECRETS,
+            " Optional `domain` connects a domain the user owns. " + MANAGE_URL_TEXT + " " + SECRETS,
         inputSchema: {
             deliveryMode: DELIVERY_MODE_SCHEMA,
             entryContent: z
@@ -586,9 +690,10 @@ export function createServer(options = {}) {
                 .optional()
                 .describe("Optional password to protect the site"),
             ttlDays: TTL_SCHEMA,
+            domain: z.string().optional().describe(DOMAIN_ARGUMENT),
             ownerToken: z.string().optional().describe(CREATE_OWNER_TOKEN_DESCRIPTION),
         },
-    }, async ({ entryContent, files, entry, namespace, password, ttlDays, ownerToken, deliveryMode }) => {
+    }, async ({ entryContent, files, entry, namespace, password, ttlDays, ownerToken, deliveryMode, domain }) => {
         const hasEntry = typeof entryContent === "string";
         const hasFiles = Array.isArray(files) && files.length > 0;
         if (hasEntry === hasFiles) {
@@ -624,7 +729,7 @@ export function createServer(options = {}) {
         if (deliveryMode)
             headers["X-Delivery-Mode"] = deliveryMode;
         const effectiveNamespace = resolveNamespace(namespace);
-        const url = baseUrl + withQuery(apiPath("sites"), [["entry", entry || undefined], ["ns", effectiveNamespace], ["ttl", ttlDays || undefined]]);
+        const url = baseUrl + withQuery(apiPath("sites"), [["entry", entry || undefined], ["ns", effectiveNamespace], ["ttl", ttlDays || undefined], ["domain", domain || undefined]]);
         const res = await bpFetch(url, { method: "POST", headers, body: formData });
         const data = await res.json().catch(() => null);
         if (!res.ok) {
@@ -659,6 +764,7 @@ export function createServer(options = {}) {
         if (site.expiresAt)
             lines.push(`Expires: ${site.expiresAt}`);
         lines.push(...hostingResponseLines(site));
+        lines.push(...publishDomainLines(site, domain || undefined));
         lines.push(...ownerTokenLines(site, "view info or delete this site", owner));
         lines.push(...ownerLinkLines(site));
         const ns = (site.namespace || effectiveNamespace) || "";
@@ -1244,5 +1350,108 @@ export function createServer(options = {}) {
             `Save it now; it cannot be shown again. Never publish it.`,
         ].join("\n"));
     });
+    /** Publication route or hostname route of a custom domain; null when the arguments name neither or both. */
+    function domainPath(type, namespace, id, hostname, suffix = []) {
+        const parts = [type, namespace, id].filter((part) => part !== undefined).length;
+        if (hostname !== undefined && parts === 0)
+            return apiPath("domains", hostname, ...suffix);
+        if (hostname === undefined && parts === 3)
+            return apiPath("publications", type, namespace, id, "domain", ...suffix);
+        return null;
+    }
+    server.registerTool("set_domain", {
+        ...toolMeta("Connect custom domain", ADDITIVE),
+        description: "Connect a domain the user owns (www.example.com or example.com) to one HTML page or site. " + DOMAIN_PROFILE_TEXT +
+            " Returns the DNS records for the domain owner to create at their DNS provider: TXT for ownership plus CNAME, or A/ALIAS for a root domain. " +
+            "A DNS check after that moves the status pending_dns -> verifying -> active; HTTPS is issued automatically. " +
+            "HTML pages of format html and sites, without a password. A hostname already in the profile moves to this publication. The BrewPage link keeps working.",
+        inputSchema: {
+            type: z.enum(["html", "site"]).describe("Publication type"),
+            namespace: z.string().describe("Publication namespace"),
+            id: z.string().describe("Publication ID"),
+            hostname: z.string().describe("Domain or subdomain the user owns, e.g. www.example.com or example.com"),
+            ownerToken: z.string().optional().describe(DOMAIN_OWNER_TOKEN),
+        },
+    }, async ({ type, namespace, id, hostname, ownerToken }) => {
+        const auth = ownerTokenFor(ownerToken);
+        if (!auth.token)
+            return textResult(NO_OWNER_TOKEN, true);
+        const path = apiPath("publications", type, namespace, id, "domain");
+        const { ok, status, data, headers: answerHeaders } = await apiRequest("PUT", path, { hostname }, { "X-Owner-Token": auth.token });
+        if (!ok)
+            return ownerFailure("set domain", status, data, auth.fromEnv, answerHeaders, domainHints(data, false));
+        const lead = status === 201 ? "Custom domain connected." : "Custom domain set: it was already in the profile (moved here or unchanged).";
+        return textResult([lead, ``, ...domainLines(data)].join("\n"));
+    });
+    server.registerTool("list_domains", {
+        ...toolMeta("List custom domains", READ_ONLY),
+        description: "List the custom domains of a BrewPage profile: status, DNS records and the publication each one shows, plus how many the profile holds and may hold. Needs an admin token of the profile.",
+        inputSchema: {
+            ownerToken: z.string().optional().describe(`Admin token of the profile. Default: ${ENV_DEFAULT}.`),
+        },
+    }, async ({ ownerToken }) => {
+        const auth = ownerTokenFor(ownerToken);
+        if (!auth.token)
+            return textResult(NO_OWNER_TOKEN, true);
+        const { ok, status, data, headers: answerHeaders } = await apiRequest("GET", "/api/domains", undefined, { "X-Owner-Token": auth.token });
+        if (!ok)
+            return ownerFailure("list domains", status, data, auth.fromEnv, answerHeaders, domainHints(data, false));
+        const list = data;
+        const items = Array.isArray(list.items) ? list.items : [];
+        const lines = [`Custom domains: ${list.used} of ${list.limit} used`];
+        if (items.length === 0)
+            lines.push(``, `None yet: set_domain connects one to an HTML page or site.`);
+        for (const item of items)
+            lines.push(``, ...domainLines(item));
+        return textResult(lines.join("\n"));
+    });
+    server.registerTool("check_domain", {
+        ...toolMeta("Check custom domain DNS", ADDITIVE),
+        description: "Check the DNS of a custom domain now and return its status and records. Status: pending_dns (records not seen yet), " +
+            "verifying (DNS found, HTTPS being issued), active (live). " + DOMAIN_ADDRESS_TEXT +
+            " Checks are spaced: a repeat too soon answers 429 with Retry-After.",
+        inputSchema: {
+            type: z.enum(["html", "site"]).optional().describe("Publication type; with namespace and id, instead of hostname"),
+            namespace: z.string().optional().describe("Publication namespace"),
+            id: z.string().optional().describe("Publication ID"),
+            hostname: z.string().optional().describe("Custom domain, e.g. www.example.com; instead of type, namespace and id"),
+            ownerToken: z.string().optional().describe(DOMAIN_EITHER_TOKEN),
+        },
+    }, async ({ type, namespace, id, hostname, ownerToken }) => {
+        const auth = ownerTokenFor(ownerToken);
+        if (!auth.token)
+            return textResult(NO_OWNER_TOKEN, true);
+        const path = domainPath(type, namespace, id, hostname, ["check"]);
+        if (path === null)
+            return textResult(DOMAIN_ADDRESS_ERROR, true);
+        const { ok, status, data, headers: answerHeaders } = await apiRequest("POST", path, undefined, { "X-Owner-Token": auth.token });
+        if (!ok)
+            return ownerFailure("check domain", status, data, auth.fromEnv, answerHeaders, domainHints(data, hostname !== undefined));
+        return textResult([`DNS checked.`, ``, ...domainLines(data)].join("\n"));
+    });
+    server.registerTool("remove_domain", {
+        ...toolMeta("Remove custom domain", DESTRUCTIVE),
+        description: "Remove a custom domain from the profile: it stops showing the publication and its slot is free at once. The BrewPage link keeps working. " +
+            DOMAIN_ADDRESS_TEXT + " DNS records at the provider stay until the domain owner deletes them.",
+        inputSchema: {
+            type: z.enum(["html", "site"]).optional().describe("Publication type; with namespace and id, instead of hostname"),
+            namespace: z.string().optional().describe("Publication namespace"),
+            id: z.string().optional().describe("Publication ID"),
+            hostname: z.string().optional().describe("Custom domain, e.g. www.example.com; instead of type, namespace and id"),
+            ownerToken: z.string().optional().describe(DOMAIN_EITHER_TOKEN),
+        },
+    }, async ({ type, namespace, id, hostname, ownerToken }) => {
+        const auth = ownerTokenFor(ownerToken);
+        if (!auth.token)
+            return textResult(NO_OWNER_TOKEN, true);
+        const path = domainPath(type, namespace, id, hostname);
+        if (path === null)
+            return textResult(DOMAIN_ADDRESS_ERROR, true);
+        const { ok, status, data, headers: answerHeaders } = await apiRequest("DELETE", path, undefined, { "X-Owner-Token": auth.token });
+        if (!ok)
+            return ownerFailure("remove domain", status, data, auth.fromEnv, answerHeaders, domainHints(data, hostname !== undefined));
+        const what = hostname !== undefined ? `Custom domain removed: ${hostname}` : `No custom domain on ${type} ${namespace}/${id} now`;
+        return textResult(`${what} · slot free · BrewPage link unchanged\nIts DNS records can be deleted at the DNS provider.`);
+    });
     return server;
 }

package/package.json

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