brewpage-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maksim Kochetkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# brewpage-mcp
+
+[![npm version](https://img.shields.io/npm/v/brewpage-mcp.svg)](https://www.npmjs.com/package/brewpage-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+MCP server for [BrewPage](https://brewpage.app) -- publish and manage HTML, KV, JSON, and file content directly from AI assistants.
+
+## Quick Start
+
+```bash
+npx brewpage-mcp
+```
+
+## Installation
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "brewpage": {
+      "command": "npx",
+      "args": ["-y", "brewpage-mcp"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "brewpage": {
+      "command": "npx",
+      "args": ["-y", "brewpage-mcp"]
+    }
+  }
+}
+```
+
+### Global Install
+
+```bash
+npm install -g brewpage-mcp
+brewpage-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `publish_html` | Publish HTML or Markdown content -> URL + owner token |
+| `publish_file` | Upload file from URL -> URL + owner token |
+| `delete_resource` | Delete resource with owner token |
+| `get_page` | Fetch published page content |
+| `get_stats` | Platform-wide statistics |
+
+## Usage Examples
+
+Ask Claude:
+
+- *"Publish this HTML to BrewPage"* -> Creates a page, returns public URL
+- *"Create a BrewPage with my meeting notes in Markdown"* -> Markdown page
+- *"Upload this image to BrewPage"* -> File upload
+- *"Delete my page demo/abc123, token tok_xyz"* -> Deletes resource
+- *"Show BrewPage stats"* -> Platform statistics
+
+## Owner Token
+
+Every publish response includes an **owner token** -- the only way to update or delete your content. **Save it! It cannot be recovered.**
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BREWPAGE_URL` | `https://brewpage.app` | API base URL |
+
+## What is BrewPage?
+
+[BrewPage](https://brewpage.app) is a free content hosting platform. No signup required.
+
+- **HTML/Markdown pages** with instant short URLs
+- **Key-value store** (1,000 keys per store)
+- **JSON documents** (10,000 per collection)
+- **File hosting** (5 MB per file)
+
+Both [brewpage.app](https://brewpage.app) and [brewdata.app](https://brewdata.app) serve the same API.
+
+## Links
+
+- [brewpage.app](https://brewpage.app) -- Live platform
+- [API Documentation](https://kochetkov-ma.github.io/brewpage-openapi/) -- Interactive docs
+- [API Reference](https://kochetkov-ma.github.io/brewpage-openapi/api-reference/) -- Scalar API explorer
+- [OpenAPI Spec](https://github.com/kochetkov-ma/brewpage-openapi/blob/main/openapi/openapi.yaml) -- Full specification
+- [Claude Skill](https://github.com/kochetkov-ma/claude-brewcode/tree/main/skills/brewpage-publish) -- `/brewpage` command
+- [Brewcode Plugin](https://github.com/kochetkov-ma/claude-brewcode) -- Claude Code plugin suite
+
+## License
+
+[MIT](LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+const BASE_URL = process.env.BREWPAGE_URL || "https://brewpage.app";
+const server = new McpServer({
+    name: "brewpage-mcp",
+    version: "1.0.0",
+});
+async function apiRequest(method, path, body, headers) {
+    const url = `${BASE_URL}${path}`;
+    const res = await fetch(url, {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            ...headers,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const data = await res.json().catch(() => null);
+    return { ok: res.ok, status: res.status, data };
+}
+function formatPublishResponse(data) {
+    const lines = [
+        `Published successfully!`,
+        ``,
+        `URL: ${data.url || "N/A"}`,
+    ];
+    if (data.shortUrl)
+        lines.push(`Short URL: ${data.shortUrl}`);
+    lines.push(`Namespace: ${data.namespace || "N/A"}`, `ID: ${data.id || "N/A"}`);
+    if (data.expiresAt)
+        lines.push(`Expires: ${data.expiresAt}`);
+    lines.push(``, `===================================`, `OWNER TOKEN: ${data.ownerToken}`, `===================================`, ``, `IMPORTANT: Save your owner token! You need it to update or delete this resource later. It cannot be recovered if lost.`);
+    return lines.join("\n");
+}
+server.tool("publish_html", "Publish HTML or Markdown content to BrewPage. Returns a public URL and owner token. Supports password protection and custom TTL.", {
+    content: z.string().describe("HTML or Markdown content to publish"),
+    format: z
+        .enum(["HTML", "MARKDOWN"])
+        .default("HTML")
+        .describe("Content format: HTML or MARKDOWN"),
+    namespace: z
+        .string()
+        .optional()
+        .describe("Namespace for the page (optional, defaults to 'public')"),
+    password: z
+        .string()
+        .optional()
+        .describe("Optional password to protect the page"),
+    ttlDays: z
+        .number()
+        .min(30)
+        .max(365)
+        .optional()
+        .describe("Time to live in days (30-365, default: 365)"),
+}, async ({ content, format, namespace, password, ttlDays }) => {
+    const body = { content, format };
+    if (namespace)
+        body.namespace = namespace;
+    if (password)
+        body.password = password;
+    if (ttlDays)
+        body.ttlDays = ttlDays;
+    const { ok, data } = await apiRequest("POST", "/api/html", body);
+    if (!ok) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to publish: ${JSON.stringify(data)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatPublishResponse(data),
+            },
+        ],
+    };
+});
+server.tool("publish_file", "Upload a file to BrewPage via URL. Returns a public URL and owner token.", {
+    url: z.string().url().describe("URL of the file to upload"),
+    namespace: z
+        .string()
+        .optional()
+        .describe("Namespace for the file (optional, defaults to 'public')"),
+    filename: z.string().optional().describe("Custom filename (optional)"),
+}, async ({ url: fileUrl, namespace, filename }) => {
+    const fileRes = await fetch(fileUrl);
+    if (!fileRes.ok) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to fetch file from URL: ${fileRes.status} ${fileRes.statusText}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const blob = await fileRes.blob();
+    const formData = new FormData();
+    formData.append("file", blob, filename || fileUrl.split("/").pop() || "file");
+    if (namespace)
+        formData.append("namespace", namespace);
+    const res = await fetch(`${BASE_URL}/api/files/uploads`, {
+        method: "POST",
+        body: formData,
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to upload file: ${JSON.stringify(data)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatPublishResponse(data),
+            },
+        ],
+    };
+});
+server.tool("delete_resource", "Delete a BrewPage resource (HTML page, KV store, JSON collection, or file) using the owner token.", {
+    type: z
+        .enum(["html", "kv", "json", "file"])
+        .describe("Resource type to delete"),
+    namespace: z.string().describe("Resource namespace"),
+    id: z.string().describe("Resource ID"),
+    ownerToken: z
+        .string()
+        .describe("Owner token received when the resource was created"),
+}, async ({ type, namespace, id, ownerToken }) => {
+    const pathMap = {
+        html: `/api/html/${namespace}/${id}`,
+        kv: `/api/kv/${namespace}/${id}`,
+        json: `/api/json/${namespace}/${id}`,
+        file: `/api/files/${namespace}/${id}`,
+    };
+    const { ok, status, data } = await apiRequest("DELETE", pathMap[type], undefined, { "X-Owner-Token": ownerToken });
+    if (!ok) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to delete (${status}): ${JSON.stringify(data)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Successfully deleted ${type} resource: ${namespace}/${id}`,
+            },
+        ],
+    };
+});
+server.tool("get_page", "Fetch a published BrewPage HTML page content by namespace and ID.", {
+    namespace: z.string().describe("Page namespace"),
+    id: z.string().describe("Page ID"),
+    password: z
+        .string()
+        .optional()
+        .describe("Password if the page is protected"),
+}, async ({ namespace, id, password }) => {
+    const headers = {};
+    if (password)
+        headers["X-Password"] = password;
+    const { ok, status, data } = await apiRequest("GET", `/api/html/${namespace}/${id}`, undefined, headers);
+    if (!ok) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to fetch page (${status}): ${JSON.stringify(data)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const page = data;
+    const lines = [
+        `Page: ${namespace}/${id}`,
+        `URL: ${page.url || `${BASE_URL}/${namespace}/${id}`}`,
+        `Format: ${page.format || "HTML"}`,
+        `Created: ${page.createdAt || "N/A"}`,
+        ``,
+        `--- Content ---`,
+        `${page.content || ""}`,
+    ];
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+    };
+});
+server.tool("get_stats", "Get BrewPage platform-wide usage statistics including page count, file count, and storage usage.", {}, async () => {
+    const { ok, data } = await apiRequest("GET", "/api/stats");
+    if (!ok) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to fetch stats: ${JSON.stringify(data)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `BrewPage Platform Statistics:\n\n${JSON.stringify(data, null, 2)}`,
+            },
+        ],
+    };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "brewpage-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for BrewPage — publish and manage HTML, KV, JSON, and file content from AI assistants",
+  "type": "module",
+  "bin": {
+    "brewpage-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "brewpage",
+    "claude",
+    "claude-desktop",
+    "claude-code",
+    "ai",
+    "hosting",
+    "html",
+    "markdown",
+    "api"
+  ],
+  "author": {
+    "name": "Maksim Kochetkov",
+    "url": "https://github.com/kochetkov-ma"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kochetkov-ma/brewpage-openapi.git",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://brewpage.app",
+  "bugs": {
+    "url": "https://github.com/kochetkov-ma/brewpage-openapi/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  }
+}