brewpage-mcp 1.14.5 → 1.15.0

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.5
+npx -y brewpage-mcp@1.15.0
 ```
 
 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.5"]
+      "args": ["-y", "brewpage-mcp@1.15.0"]
     }
   }
 }
@@ -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.5
+claude mcp add --transport stdio --scope project brewpage -- npx -y brewpage-mcp@1.15.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).
@@ -58,7 +58,7 @@ Open **Settings > MCP** and add:
   "mcpServers": {
     "brewpage": {
       "command": "npx",
-      "args": ["-y", "brewpage-mcp@1.14.5"]
+      "args": ["-y", "brewpage-mcp@1.15.0"]
     }
   }
 }
@@ -72,7 +72,7 @@ Open the Cline MCP settings panel and add:
 {
   "brewpage": {
     "command": "npx",
-    "args": ["-y", "brewpage-mcp@1.14.5"]
+    "args": ["-y", "brewpage-mcp@1.15.0"]
   }
 }
 ```
@@ -80,7 +80,7 @@ Open the Cline MCP settings panel and add:
 ### Global Install
 
 ```bash
-npm install -g brewpage-mcp@1.14.5
+npm install -g brewpage-mcp@1.15.0
 brewpage-mcp
 ```
 
@@ -513,6 +513,10 @@ Every publish response includes an **owner token** -- the only credential that a
 
 ## Changelog
 
+## 1.15.0 -- 2026-10-27
+
+- Supports MCP protocol 2026-07-28 (SDK v2).
+
 ## 1.14.5 -- 2026-10-27
 
 - Site publish hints add 400 for an unreadable, password-protected or too complex PDF/Office file and 503 when busy; a failed publish on 503 prints `Retry-After`.

package/dist/http.js

@@ -5,9 +5,8 @@ import { lookup as dnsLookup } from "node:dns";
 import { BlockList, isIP } from "node:net";
 import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+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";
 const MIB = 1024 * 1024;
 /** Fits the largest site (25 MiB backend request: 20 MiB of inline text plus JSON escaping).
@@ -54,6 +53,7 @@ const VERSION = USER_AGENT.split("/")[1];
 const REMOTE_USER_AGENT = `${USER_AGENT} (remote)`;
 const PARSE_ERROR = -32700;
 const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
 const SERVER_ERROR = -32000;
 /** One JSON line per event on stdout; callers never pass arguments, tokens or IPs. */
 function log(fields) {
@@ -342,18 +342,40 @@ function readBody(req, limit, onLarge) {
             finish("aborted");
     });
 }
-/** Tool names from an in-memory handshake; logs name only these. */
+/** Tool names from an in-memory 2025 handshake (raw JSON-RPC, no client package); logs name only these. */
 async function registeredToolNames() {
     const [clientSide, serverSide] = InMemoryTransport.createLinkedPair();
     const server = createServer({ baseUrl: "http://127.0.0.1:9" });
-    const client = new Client({ name: "startup", version: VERSION });
+    const answers = new Map();
+    clientSide.onmessage = (message) => {
+        if ("id" in message && typeof message.id === "number")
+            answers.get(message.id)?.(message);
+    };
+    const call = (id, method, params) => new Promise((resolve) => {
+        answers.set(id, resolve);
+        void clientSide.send({ jsonrpc: "2.0", id, method, params });
+    });
     await server.connect(serverSide);
-    await client.connect(clientSide);
-    const { tools } = await client.listTools();
-    await client.close();
+    await clientSide.start();
+    await call(1, "initialize", { protocolVersion: LATEST_PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: "startup", version: VERSION } });
+    await clientSide.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    const listed = await call(2, "tools/list", {});
+    await clientSide.close();
     await server.close();
+    const tools = ("result" in listed ? listed.result.tools : undefined) ?? [];
+    if (tools.length === 0)
+        throw new Error("tools/list returned no tools");
     return new Set(tools.map(({ name }) => name));
 }
+/** Tool-level outcome of one JSON-RPC answer; undefined = success. */
+function rpcOutcome(outgoing) {
+    if (outgoing === null || typeof outgoing !== "object")
+        return undefined;
+    if ("error" in outgoing)
+        return "rpc_error";
+    const result = outgoing.result;
+    return result?.isError === true ? "tool_error" : undefined;
+}
 /** Slot pool: global limit with a FIFO wait queue, plus a per-client cap (client undefined = shared egress, no cap). */
 class Pool {
     limit;
@@ -540,6 +562,15 @@ 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;
+            // 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;
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ jsonrpc: "2.0", id: typeof id === "string" || typeof id === "number" ? id : null,
+                    error: { code: METHOD_NOT_FOUND, message: "subscriptions/listen is not supported by this stateless endpoint." } }));
+                entry.outcome = "rpc_error";
+                return;
+            }
             const isLight = rpc.method !== "tools/call" || (typeof toolName === "string" && LIGHT_TOOLS.has(toolName));
             if (toolName === "publish_file" && slot !== heavy && !(await acquire(heavy)))
                 return busy();
@@ -559,13 +590,34 @@ async function main() {
                     : 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 request = await toWebRequest(req, message, { signal: abort.signal });
+            if (!(await isLegacyRequest(request, message))) {
+                // 2026-07-28 envelope: one exchange through the SDK entry; any SSE body is read to its end.
+                const modern = createMcpHandler(() => server, { legacy: "reject" });
+                try {
+                    const response = await modern.fetch(request, { parsedBody: message });
+                    const text = await response.text();
+                    if ((response.headers.get("content-type") ?? "").startsWith("application/json")) {
+                        try {
+                            entry.outcome = rpcOutcome(JSON.parse(text)) ?? null;
+                        }
+                        catch {
+                            entry.outcome = null;
+                        }
+                    }
+                    res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+                    res.end(text);
+                }
+                finally {
+                    await modern.close();
+                    await server.close();
+                }
+                return;
+            }
+            const transport = new NodeStreamableHTTPServerTransport({ 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";
+                entry.outcome = rpcOutcome(outgoing) ?? entry.outcome;
                 return send(outgoing, options);
             };
             try {

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { createServer, DEFAULT_BASE_URL, OWNER_TOKEN_ENV } from "./tools.js";
 const OWNER_TOKEN_SHAPE = /^[A-Za-z0-9]{32}$/;
 /** Optional default owner token for every call; a malformed value is ignored with one stderr line. */
@@ -12,12 +12,5 @@ const ENV_OWNER_TOKEN = (() => {
     console.error(`${OWNER_TOKEN_ENV} ignored: expected 32 letters/digits.`);
     return undefined;
 })();
-async function main() {
-    const server = createServer({ baseUrl: process.env.BREWPAGE_URL || DEFAULT_BASE_URL, ownerToken: ENV_OWNER_TOKEN });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}
-main().catch((error) => {
-    console.error("Fatal error:", error);
-    process.exit(1);
-});
+/** Serves 2026-07-28 (server/discover) and 2025-era initialize openings from one factory. */
+serveStdio(() => createServer({ baseUrl: process.env.BREWPAGE_URL || DEFAULT_BASE_URL, ownerToken: ENV_OWNER_TOKEN }));

package/dist/tools.d.ts

@@ -1,6 +1,6 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/server";
 export declare const DEFAULT_BASE_URL = "https://brewpage.app";
-export declare const USER_AGENT = "brewpage-mcp/1.14.5";
+export declare const USER_AGENT = "brewpage-mcp/1.15.0";
 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 { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 export const DEFAULT_BASE_URL = "https://brewpage.app";
-export const USER_AGENT = "brewpage-mcp/1.14.5";
+export const USER_AGENT = "brewpage-mcp/1.15.0";
 export const OWNER_TOKEN_ENV = "BREWPAGE_OWNER_TOKEN";
 const READ_ONLY = { readOnlyHint: true };
 const DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true };
@@ -188,7 +188,7 @@ export function createServer(options = {}) {
     const apiFetch = options.fetch ?? fetch;
     const server = new McpServer({
         name: "brewpage-mcp",
-        version: "1.14.5",
+        version: "1.15.0",
     });
     /** Caller argument first, then the configured default; `fromEnv` marks the configured one. */
     function ownerTokenFor(argument) {
@@ -750,7 +750,7 @@ export function createServer(options = {}) {
         inputSchema: {
             deliveryMode: DELIVERY_MODE_SCHEMA,
             json: z
-                .union([z.string(), z.record(z.unknown()), z.array(z.unknown())])
+                .union([z.string(), z.record(z.string(), z.unknown()), z.array(z.unknown())])
                 .describe("JSON document to publish (object, array, or JSON-encoded string)"),
             namespace: z
                 .string()
@@ -849,7 +849,7 @@ export function createServer(options = {}) {
             namespace: z.string().describe("Document namespace"),
             id: z.string().describe("Document ID"),
             json: z
-                .union([z.string(), z.record(z.unknown()), z.array(z.unknown())])
+                .union([z.string(), z.record(z.string(), z.unknown()), z.array(z.unknown())])
                 .describe("New JSON document (object, array, or JSON-encoded string)"),
             ownerToken: z.string().optional().describe(OWNER_TOKEN_DESCRIPTION),
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brewpage-mcp",
-  "version": "1.14.5",
+  "version": "1.15.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",
@@ -22,7 +22,7 @@
     "start": "node dist/index.js",
     "start:http": "node dist/http.js",
     "dev": "tsx src/index.ts",
-    "test": "npm run build && node --import tsx --test test/smoke.test.ts test/http.test.ts",
+    "test": "npm run build && node --import tsx --test test/smoke.test.ts test/http.test.ts test/protocol.test.ts",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -54,21 +54,18 @@
     "url": "https://github.com/kochetkov-ma/brewpage-openapi/issues"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.29.0",
-    "zod": "3.25.76"
+    "@modelcontextprotocol/node": "2.1.2",
+    "@modelcontextprotocol/server": "2.4.0",
+    "zod": "4.6.7"
   },
   "devDependencies": {
+    "@modelcontextprotocol/client": "2.4.0",
     "@types/node": "22.19.15",
     "tsx": "4.22.0",
     "typescript": "5.9.3"
   },
   "overrides": {
     "@hono/node-server": "1.19.15",
-    "body-parser": "2.3.0",
-    "fast-uri": "3.1.8",
-    "hono": "4.13.7",
-    "ip-address": "10.7.1",
-    "proxy-addr": "2.0.8",
-    "qs": "6.16.0"
+    "hono": "4.13.14"
   }
 }