@eraserlabs/eraser-mcp 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @eraserlabs/eraser-mcp
+
+MCP (Model Context Protocol) server for generating diagrams with [eraser.io](https://eraser.io/?r=0).
+
+## Installation
+
+```bash
+npx @eraserlabs/eraser-mcp
+```
+
+## Configuration
+
+### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "eraser": {
+      "command": "npx",
+      "args": ["@eraserlabs/eraser-mcp"],
+      "env": {
+        "ERASER_API_TOKEN": "your-api-token"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to your Claude Desktop config:
+
+```json
+{
+  "mcpServers": {
+    "eraser": {
+      "command": "npx",
+      "args": ["@eraserlabs/eraser-mcp"],
+      "env": {
+        "ERASER_API_TOKEN": "your-api-token"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+- `ERASER_API_TOKEN` (required) - Your Eraser API token
+- `ERASER_API_URL` (optional) - Custom API URL (defaults to `https://app.eraser.io/api/mcp`)
+- `ERASER_OUTPUT_DIR` (optional) - Local directory to save rendered diagrams (defaults to `.eraser/scratchpad`)
+
+## Available Tools
+
+- `renderSequenceDiagram` - Render sequence diagrams
+- `renderEntityRelationshipDiagram` - Render ERD diagrams
+- `renderCloudArchitectureDiagram` - Render cloud architecture diagrams
+- `renderFlowchart` - Render flowcharts
+- `renderBpmnDiagram` - Render BPMN diagrams
+- `renderPrompt` - Generate diagrams from natural language using AI
+- `renderElements` - Render multiple diagram elements
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { McpToolDefinition, RenderElementsInput, RenderPromptInput, SingleDiagramInput, McpToolName, } from './tools';
+export { mcpTools, mcpToolMap, isMcpToolName, DiagramTypes, singleDiagramTools, isSingleDiagramTool, } from './tools';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,GACZ,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,QAAQ,EACR,UAAU,EACV,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSingleDiagramTool = exports.singleDiagramTools = exports.DiagramTypes = exports.isMcpToolName = exports.mcpToolMap = exports.mcpTools = void 0;
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "mcpTools", { enumerable: true, get: function () { return tools_1.mcpTools; } });
+Object.defineProperty(exports, "mcpToolMap", { enumerable: true, get: function () { return tools_1.mcpToolMap; } });
+Object.defineProperty(exports, "isMcpToolName", { enumerable: true, get: function () { return tools_1.isMcpToolName; } });
+Object.defineProperty(exports, "DiagramTypes", { enumerable: true, get: function () { return tools_1.DiagramTypes; } });
+Object.defineProperty(exports, "singleDiagramTools", { enumerable: true, get: function () { return tools_1.singleDiagramTools; } });
+Object.defineProperty(exports, "isSingleDiagramTool", { enumerable: true, get: function () { return tools_1.isSingleDiagramTool; } });

package/dist/stdio.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Eraser MCP stdio adapter
+ *
+ * This adapter allows MCP clients (like Cursor, Claude Desktop) to communicate
+ * with the Eraser API via stdio transport.
+ *
+ * Usage:
+ *   ERASER_API_TOKEN=your-token npx @eraserlabs/eraser-mcp
+ *
+ * Or configure in .cursor/mcp.json:
+ *   {
+ *     "mcpServers": {
+ *       "eraser": {
+ *         "command": "npx",
+ *         "args": ["@eraserlabs/eraser-mcp"],
+ *         "env": { "ERASER_API_TOKEN": "your-token" }
+ *       }
+ *     }
+ *   }
+ */
+export {};
+//# sourceMappingURL=stdio.d.ts.map

package/dist/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/stdio.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Eraser MCP stdio adapter
+ *
+ * This adapter allows MCP clients (like Cursor, Claude Desktop) to communicate
+ * with the Eraser API via stdio transport.
+ *
+ * Usage:
+ *   ERASER_API_TOKEN=your-token npx @eraserlabs/eraser-mcp
+ *
+ * Or configure in .cursor/mcp.json:
+ *   {
+ *     "mcpServers": {
+ *       "eraser": {
+ *         "command": "npx",
+ *         "args": ["@eraserlabs/eraser-mcp"],
+ *         "env": { "ERASER_API_TOKEN": "your-token" }
+ *       }
+ *     }
+ *   }
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tools_1 = require("./tools");
+const API_URL = process.env.ERASER_API_URL || 'https://app.eraser.io/api/mcp';
+const ERASER_OUTPUT_DIR = process.env.ERASER_OUTPUT_DIR || '.eraser/scratchpad';
+const API_TOKEN = process.env.ERASER_API_TOKEN;
+function sendResponse(response) {
+    process.stdout.write(JSON.stringify(response) + '\n');
+}
+function sendError(id, code, message, data) {
+    sendResponse({
+        jsonrpc: '2.0',
+        id,
+        error: { code, message, data },
+    });
+}
+// Server capabilities and info for MCP handshake
+const SERVER_INFO = {
+    name: 'eraser-mcp',
+    version: '1.0.0',
+};
+const SERVER_CAPABILITIES = {
+    tools: {},
+};
+// Convert mcpTools to MCP tool list format
+function getToolsList() {
+    return tools_1.mcpTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.jsonSchema,
+    }));
+}
+/**
+ * Extracts the title from diagram code (looks for a line starting with "title ").
+ * Normalizes it to a valid filename.
+ */
+function extractTitleFromCode(code) {
+    if (!code) {
+        return undefined;
+    }
+    const lines = code.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.toLowerCase().startsWith('title ')) {
+            const title = trimmed.slice(6).trim(); // Remove "title " prefix
+            // Normalize to filename: lowercase, replace spaces/special chars with hyphens
+            return title
+                .toLowerCase()
+                .replace(/[^a-z0-9]+/g, '-')
+                .replace(/^-+|-+$/g, ''); // Trim leading/trailing hyphens
+        }
+    }
+    return undefined;
+}
+/**
+ * Downloads an image from a URL and saves it locally.
+ * Returns the local file path if successful, undefined otherwise.
+ */
+async function saveImageLocally(imageUrl, diagramCode) {
+    try {
+        const outputDir = path.resolve(process.cwd(), ERASER_OUTPUT_DIR);
+        // Ensure output directory exists
+        await fs.promises.mkdir(outputDir, { recursive: true });
+        // Generate filename from title or timestamp
+        const title = extractTitleFromCode(diagramCode);
+        const timestamp = Date.now();
+        const filename = title ? `${title}-${timestamp}.png` : `diagram-${timestamp}.png`;
+        const localPath = path.join(outputDir, filename);
+        // Fetch the image
+        const response = await fetch(imageUrl);
+        if (!response.ok) {
+            return undefined;
+        }
+        // Save to disk
+        const buffer = Buffer.from(await response.arrayBuffer());
+        await fs.promises.writeFile(localPath, buffer);
+        return localPath;
+    }
+    catch {
+        // Silently fail - local saving is a nice-to-have
+        return undefined;
+    }
+}
+async function handleRequest(request) {
+    const id = request.id ?? null;
+    // Handle MCP protocol methods locally
+    if (request.method === 'initialize') {
+        sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+                protocolVersion: '2024-11-05',
+                capabilities: SERVER_CAPABILITIES,
+                serverInfo: SERVER_INFO,
+            },
+        });
+        return;
+    }
+    if (request.method === 'notifications/initialized') {
+        // This is a notification, no response needed
+        return;
+    }
+    if (request.method === 'tools/list') {
+        sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+                tools: getToolsList(),
+            },
+        });
+        return;
+    }
+    // For tools/call, forward to the API
+    if (request.method === 'tools/call') {
+        if (!API_TOKEN) {
+            sendError(id, -32000, 'ERASER_API_TOKEN environment variable is required');
+            return;
+        }
+        try {
+            const response = await fetch(API_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${API_TOKEN}`,
+                },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                sendError(id, -32000, `HTTP ${response.status}: ${text}`);
+                return;
+            }
+            const rpcResponse = (await response.json());
+            // Try to save the image locally if there's an imageUrl in the result
+            if (rpcResponse.result) {
+                const result = rpcResponse.result;
+                if (result.content?.[0]?.type === 'text' && result.content[0].text) {
+                    try {
+                        const renderResult = JSON.parse(result.content[0].text);
+                        if (renderResult.imageUrl) {
+                            // Extract diagram code from request params for title extraction
+                            const params = request.params;
+                            const diagramCode = params?.arguments?.code;
+                            const localPath = await saveImageLocally(renderResult.imageUrl, diagramCode);
+                            if (localPath) {
+                                renderResult.localPath = localPath;
+                                result.content[0].text = JSON.stringify(renderResult);
+                            }
+                        }
+                    }
+                    catch {
+                        // If parsing fails, just return the original response
+                    }
+                }
+            }
+            sendResponse(rpcResponse);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            sendError(id, -32000, `Request failed: ${message}`);
+        }
+        return;
+    }
+    // Unknown method
+    sendError(id, -32601, `Method not found: ${request.method}`);
+}
+function main() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+    });
+    rl.on('line', (line) => {
+        if (!line.trim()) {
+            return;
+        }
+        try {
+            const request = JSON.parse(line);
+            if (request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+                sendError(request.id ?? null, -32600, 'Invalid Request');
+                return;
+            }
+            void handleRequest(request);
+        }
+        catch {
+            sendError(null, -32700, 'Parse error');
+        }
+    });
+    rl.on('close', () => {
+        process.exit(0);
+    });
+    // Prevent unhandled promise rejections from crashing
+    process.on('unhandledRejection', (error) => {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        sendError(null, -32000, `Unhandled error: ${message}`);
+    });
+}
+main();

package/dist/tools.d.ts

@@ -0,0 +1,304 @@
+import { z } from 'zod';
+type JsonSchema = Record<string, unknown>;
+/**
+ * Settings duplicated from @eraserlabs/shared/modules/diagram-parser/settings
+ * We avoid importing to keep eraser-mcp buildable independently.
+ */
+export declare const colorModeSettings: readonly ["pastel", "bold", "outline"];
+export declare const styleModeSettings: readonly ["plain", "shadow", "watercolor"];
+export declare const typefaceSettings: readonly ["rough", "clean", "mono"];
+export declare const directionSettings: readonly ["up", "down", "left", "right"];
+/**
+ * The diagram types supported by the MCP tools.
+ * Duplicated from DiagramTypes enum, excluding 'custom-diagram'.
+ */
+export declare enum DiagramTypes {
+    SD = "sequence-diagram",
+    ERD = "entity-relationship-diagram",
+    CAD = "cloud-architecture-diagram",
+    FLOW = "flowchart-diagram",
+    BPMN = "bpmn-diagram"
+}
+declare const diagramElementSchema: z.ZodObject<{
+    type: z.ZodLiteral<"diagram">;
+    diagramType: z.ZodNativeEnum<typeof DiagramTypes>;
+    code: z.ZodString;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "diagram";
+    code: string;
+    diagramType: DiagramTypes;
+    x?: number | undefined;
+    y?: number | undefined;
+}, {
+    type: "diagram";
+    code: string;
+    diagramType: DiagramTypes;
+    x?: number | undefined;
+    y?: number | undefined;
+}>;
+declare const renderPromptSchema: z.ZodObject<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreElements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limitToSelection: z.ZodOptional<z.ZodBoolean>;
+    customIcons: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    title: z.ZodOptional<z.ZodString>;
+} & {
+    text: z.ZodString;
+    returnFile: z.ZodOptional<z.ZodBoolean>;
+    diagramType: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    priorRequestId: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contextId: z.ZodOptional<z.ZodString>;
+    git: z.ZodOptional<z.ZodUnknown>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreElements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limitToSelection: z.ZodOptional<z.ZodBoolean>;
+    customIcons: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    title: z.ZodOptional<z.ZodString>;
+} & {
+    text: z.ZodString;
+    returnFile: z.ZodOptional<z.ZodBoolean>;
+    diagramType: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    priorRequestId: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contextId: z.ZodOptional<z.ZodString>;
+    git: z.ZodOptional<z.ZodUnknown>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreElements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limitToSelection: z.ZodOptional<z.ZodBoolean>;
+    customIcons: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    title: z.ZodOptional<z.ZodString>;
+} & {
+    text: z.ZodString;
+    returnFile: z.ZodOptional<z.ZodBoolean>;
+    diagramType: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    priorRequestId: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    contextId: z.ZodOptional<z.ZodString>;
+    git: z.ZodOptional<z.ZodUnknown>;
+    fileOptions: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodBoolean>;
+        linkAccess: z.ZodOptional<z.ZodEnum<["no-link-access", "anyone-with-link-can-edit", "publicly-viewable", "publicly-editable"]>>;
+    }, "strip", z.ZodTypeAny, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }, {
+        create?: boolean | undefined;
+        linkAccess?: "no-link-access" | "anyone-with-link-can-edit" | "publicly-viewable" | "publicly-editable" | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const renderElementsSchema: z.ZodObject<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreElements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limitToSelection: z.ZodOptional<z.ZodBoolean>;
+    customIcons: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    title: z.ZodOptional<z.ZodString>;
+} & {
+    elements: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof DiagramTypes>;
+        code: z.ZodString;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }>, "many">;
+    returnFile: z.ZodOptional<z.ZodBoolean>;
+    fileName: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    returnElements: z.ZodOptional<z.ZodBoolean>;
+    skipCache: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreElements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limitToSelection: z.ZodOptional<z.ZodBoolean>;
+    customIcons: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    title: z.ZodOptional<z.ZodString>;
+} & {
+    elements: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof DiagramTypes>;
+        code: z.ZodString;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }>, "many">;
+    returnFile: z.ZodOptional<z.ZodBoolean>;
+    fileName: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    returnElements: z.ZodOptional<z.ZodBoolean>;
+    skipCache: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    padding: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    format: z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>;
+    selection: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ignoreElements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limitToSelection: z.ZodOptional<z.ZodBoolean>;
+    customIcons: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    direction: z.ZodOptional<z.ZodEnum<["up", "down", "left", "right"]>>;
+    title: z.ZodOptional<z.ZodString>;
+} & {
+    elements: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"diagram">;
+        diagramType: z.ZodNativeEnum<typeof DiagramTypes>;
+        code: z.ZodString;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "diagram";
+        code: string;
+        diagramType: DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }, {
+        type: "diagram";
+        code: string;
+        diagramType: DiagramTypes;
+        x?: number | undefined;
+        y?: number | undefined;
+    }>, "many">;
+    returnFile: z.ZodOptional<z.ZodBoolean>;
+    fileName: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    returnElements: z.ZodOptional<z.ZodBoolean>;
+    skipCache: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const singleDiagramSchema: z.ZodObject<{
+    code: z.ZodString;
+    theme: z.ZodOptional<z.ZodEnum<["light", "dark"]>>;
+    colorMode: z.ZodOptional<z.ZodEnum<["pastel", "bold", "outline"]>>;
+    styleMode: z.ZodOptional<z.ZodEnum<["plain", "shadow", "watercolor"]>>;
+    typeface: z.ZodOptional<z.ZodEnum<["rough", "clean", "mono"]>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    background?: boolean | undefined;
+    theme?: "light" | "dark" | undefined;
+    typeface?: "rough" | "clean" | "mono" | undefined;
+    colorMode?: "pastel" | "bold" | "outline" | undefined;
+    styleMode?: "plain" | "shadow" | "watercolor" | undefined;
+}, {
+    code: string;
+    background?: boolean | undefined;
+    theme?: "light" | "dark" | undefined;
+    typeface?: "rough" | "clean" | "mono" | undefined;
+    colorMode?: "pastel" | "bold" | "outline" | undefined;
+    styleMode?: "plain" | "shadow" | "watercolor" | undefined;
+}>;
+export type RenderPromptInput = z.infer<typeof renderPromptSchema>;
+export type DiagramElementInput = z.infer<typeof diagramElementSchema>;
+export type RenderElementsInput = z.infer<typeof renderElementsSchema>;
+export type SingleDiagramInput = z.infer<typeof singleDiagramSchema>;
+export type McpToolDefinition<TInput> = {
+    name: string;
+    description: string;
+    schema: z.ZodType<TInput>;
+    jsonSchema: JsonSchema;
+};
+export declare const mcpTools: ReadonlyArray<McpToolDefinition<unknown>>;
+export type McpToolName = typeof mcpTools[number]['name'];
+export declare function isMcpToolName(name: unknown): name is McpToolName;
+export declare const mcpToolMap: Map<string, McpToolDefinition<unknown>>;
+export declare const singleDiagramTools: Record<string, DiagramTypes>;
+export declare function isSingleDiagramTool(name: string): name is keyof typeof singleDiagramTools;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,wCAAyC,CAAC;AACxE,eAAO,MAAM,iBAAiB,4CAA6C,CAAC;AAC5E,eAAO,MAAM,gBAAgB,qCAAsC,CAAC;AACpE,eAAO,MAAM,iBAAiB,0CAA2C,CAAC;AAE1E;;;GAGG;AACH,oBAAY,YAAY;IACtB,EAAE,qBAAqB;IACvB,GAAG,gCAAgC;IACnC,GAAG,+BAA+B;IAClC,IAAI,sBAAsB;IAC1B,IAAI,iBAAiB;CACtB;AAED,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EAMxB,CAAC;AAqBH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAwBR,CAAC;AAEjB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCASV,CAAC;AAGjB,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE,MAAM,MAAM,iBAAiB,CAAC,MAAM,IAAI;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1B,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AA+RF,eAAO,MAAM,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CA6C9D,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,WAAW,CAEhE;AAED,eAAO,MAAM,UAAU,yCAAqD,CAAC;AAG7E,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAM3D,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,MAAM,OAAO,kBAAkB,CAEzF"}

package/dist/tools.js

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSingleDiagramTool = exports.singleDiagramTools = exports.mcpToolMap = exports.isMcpToolName = exports.mcpTools = exports.DiagramTypes = exports.directionSettings = exports.typefaceSettings = exports.styleModeSettings = exports.colorModeSettings = void 0;
+const zod_1 = require("zod");
+/**
+ * Settings duplicated from @eraserlabs/shared/modules/diagram-parser/settings
+ * We avoid importing to keep eraser-mcp buildable independently.
+ */
+exports.colorModeSettings = ['pastel', 'bold', 'outline'];
+exports.styleModeSettings = ['plain', 'shadow', 'watercolor'];
+exports.typefaceSettings = ['rough', 'clean', 'mono'];
+exports.directionSettings = ['up', 'down', 'left', 'right'];
+/**
+ * The diagram types supported by the MCP tools.
+ * Duplicated from DiagramTypes enum, excluding 'custom-diagram'.
+ */
+var DiagramTypes;
+(function (DiagramTypes) {
+    DiagramTypes["SD"] = "sequence-diagram";
+    DiagramTypes["ERD"] = "entity-relationship-diagram";
+    DiagramTypes["CAD"] = "cloud-architecture-diagram";
+    DiagramTypes["FLOW"] = "flowchart-diagram";
+    DiagramTypes["BPMN"] = "bpmn-diagram";
+})(DiagramTypes = exports.DiagramTypes || (exports.DiagramTypes = {}));
+const diagramElementSchema = zod_1.z.object({
+    type: zod_1.z.literal('diagram'),
+    diagramType: zod_1.z.nativeEnum(DiagramTypes),
+    code: zod_1.z.string(),
+    x: zod_1.z.number().optional(),
+    y: zod_1.z.number().optional(),
+});
+const renderOptionsSchema = zod_1.z
+    .object({
+    padding: zod_1.z.number().optional(),
+    scale: zod_1.z.union([zod_1.z.literal(1), zod_1.z.literal(2), zod_1.z.literal(3)]).optional(),
+    background: zod_1.z.boolean().optional(),
+    theme: zod_1.z.enum(['light', 'dark']).optional(),
+    format: zod_1.z.enum(['png', 'jpeg']).optional(),
+    selection: zod_1.z.array(zod_1.z.string()).optional(),
+    ignoreElements: zod_1.z.array(zod_1.z.string()).optional(),
+    limitToSelection: zod_1.z.boolean().optional(),
+    customIcons: zod_1.z.array(zod_1.z.unknown()).optional(),
+    typeface: zod_1.z.enum(exports.typefaceSettings).optional(),
+    colorMode: zod_1.z.enum(exports.colorModeSettings).optional(),
+    styleMode: zod_1.z.enum(exports.styleModeSettings).optional(),
+    direction: zod_1.z.enum(exports.directionSettings).optional(),
+    title: zod_1.z.string().optional(),
+})
+    .passthrough();
+const renderPromptSchema = renderOptionsSchema
+    .extend({
+    text: zod_1.z.string(),
+    returnFile: zod_1.z.boolean().optional(),
+    diagramType: zod_1.z.string().optional(),
+    mode: zod_1.z.string().optional(),
+    priorRequestId: zod_1.z.string().optional(),
+    attachments: zod_1.z.array(zod_1.z.unknown()).optional(),
+    contextId: zod_1.z.string().optional(),
+    git: zod_1.z.unknown().optional(),
+    fileOptions: zod_1.z
+        .object({
+        create: zod_1.z.boolean().optional(),
+        linkAccess: zod_1.z
+            .enum([
+            'no-link-access',
+            'anyone-with-link-can-edit',
+            'publicly-viewable',
+            'publicly-editable',
+        ])
+            .optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const renderElementsSchema = renderOptionsSchema
+    .extend({
+    elements: zod_1.z.array(diagramElementSchema),
+    returnFile: zod_1.z.boolean().optional(),
+    fileName: zod_1.z.string().optional(),
+    teamId: zod_1.z.string().optional(),
+    returnElements: zod_1.z.boolean().optional(),
+    skipCache: zod_1.z.boolean().optional(),
+})
+    .passthrough();
+// Schema for individual diagram type tools
+const singleDiagramSchema = zod_1.z.object({
+    code: zod_1.z.string(),
+    theme: zod_1.z.enum(['light', 'dark']).optional(),
+    colorMode: zod_1.z.enum(exports.colorModeSettings).optional(),
+    styleMode: zod_1.z.enum(exports.styleModeSettings).optional(),
+    typeface: zod_1.z.enum(exports.typefaceSettings).optional(),
+    background: zod_1.z.boolean().optional(),
+});
+const renderPromptJsonSchema = {
+    type: 'object',
+    additionalProperties: true,
+    required: ['text'],
+    properties: {
+        text: { type: 'string' },
+        returnFile: { type: 'boolean' },
+        diagramType: { type: 'string' },
+        mode: { type: 'string' },
+        priorRequestId: { type: 'string' },
+        attachments: { type: 'array', items: {} },
+        contextId: { type: 'string' },
+        git: {},
+        fileOptions: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                create: { type: 'boolean' },
+                linkAccess: {
+                    type: 'string',
+                    enum: [
+                        'no-link-access',
+                        'anyone-with-link-can-edit',
+                        'publicly-viewable',
+                        'publicly-editable',
+                    ],
+                },
+            },
+        },
+        padding: { type: 'number' },
+        scale: { type: 'number', enum: [1, 2, 3] },
+        background: { type: 'boolean' },
+        theme: { type: 'string', enum: ['light', 'dark'] },
+        format: { type: 'string', enum: ['png', 'jpeg'] },
+        selection: { type: 'array', items: { type: 'string' } },
+        typeface: { type: 'string', enum: [...exports.typefaceSettings] },
+        colorMode: { type: 'string', enum: [...exports.colorModeSettings] },
+        styleMode: { type: 'string', enum: [...exports.styleModeSettings] },
+        direction: { type: 'string', enum: [...exports.directionSettings] },
+        title: { type: 'string' },
+    },
+};
+const renderElementsJsonSchema = {
+    type: 'object',
+    additionalProperties: true,
+    required: ['elements'],
+    properties: {
+        elements: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['type', 'diagramType', 'code'],
+                properties: {
+                    type: { type: 'string', const: 'diagram' },
+                    diagramType: {
+                        type: 'string',
+                        enum: Object.values(DiagramTypes),
+                    },
+                    code: { type: 'string' },
+                },
+            },
+        },
+        fileName: { type: 'string' },
+        teamId: { type: 'string' },
+        returnElements: { type: 'boolean' },
+        skipCache: { type: 'boolean' },
+        padding: { type: 'number' },
+        scale: { type: 'number', enum: [1, 2, 3] },
+        background: { type: 'boolean' },
+        theme: { type: 'string', enum: ['light', 'dark'] },
+        format: { type: 'string', enum: ['png', 'jpeg'] },
+        typeface: { type: 'string', enum: [...exports.typefaceSettings] },
+        colorMode: { type: 'string', enum: [...exports.colorModeSettings] },
+        styleMode: { type: 'string', enum: [...exports.styleModeSettings] },
+        direction: { type: 'string', enum: [...exports.directionSettings] },
+    },
+};
+const singleDiagramJsonSchema = {
+    type: 'object',
+    required: ['code'],
+    properties: {
+        code: { type: 'string', description: 'The diagram code in Eraser syntax' },
+        theme: { type: 'string', enum: ['light', 'dark'] },
+        colorMode: { type: 'string', enum: [...exports.colorModeSettings] },
+        styleMode: { type: 'string', enum: [...exports.styleModeSettings] },
+        typeface: { type: 'string', enum: [...exports.typefaceSettings] },
+        background: { type: 'boolean', description: 'Whether to include a solid background' },
+    },
+};
+// Diagram type descriptions with syntax examples
+const SEQUENCE_DIAGRAM_DESCRIPTION = `Render a sequence diagram. Use Eraser's sequence diagram syntax.
+
+Example syntax:
+\`\`\`
+title Authentication Flow
+
+// Define actors with icons
+User [icon: user]
+Browser [icon: globe]
+Server [icon: server]
+Database [icon: database]
+
+// Messages between actors
+User > Browser: Enter credentials
+Browser > Server: POST /login
+Server > Database: Query user
+Database > Server: User data
+Server > Browser: JWT token
+Browser > User: Login success
+
+// Control flow
+alt [label: "Valid credentials"] {
+  Server > Browser: 200 OK
+}
+else [label: "Invalid"] {
+  Server > Browser: 401 Unauthorized
+}
+
+// Activation bars
+activate Server
+Server > Database: Query
+deactivate Server
+
+// Loops
+loop [label: "Retry 3 times"] {
+  Browser > Server: Request
+}
+\`\`\``;
+const ERD_DESCRIPTION = `Render an entity-relationship diagram. Use Eraser's ERD syntax.
+
+Example syntax:
+\`\`\`
+title E-commerce Database
+
+// Define tables with columns
+users [icon: user, color: blue] {
+  id int pk
+  email string
+  name string
+  created_at timestamp
+}
+
+orders [icon: shopping-cart, color: green] {
+  id int pk
+  user_id int
+  total decimal
+  status string
+  created_at timestamp
+}
+
+products [icon: box, color: orange] {
+  id int pk
+  name string
+  price decimal
+  stock int
+}
+
+order_items [icon: list] {
+  order_id int pk
+  product_id int pk
+  quantity int
+  price decimal
+}
+
+// Relationships
+users.id < orders.user_id
+orders.id < order_items.order_id
+products.id < order_items.product_id
+\`\`\``;
+const CLOUD_ARCHITECTURE_DESCRIPTION = `Render a cloud architecture diagram. Use Eraser's cloud architecture syntax.
+
+Example syntax:
+\`\`\`
+title AWS Microservices Architecture
+
+// Groups with cloud provider icons
+AWS Cloud [icon: aws] {
+  VPC [icon: aws-vpc] {
+    Public Subnet {
+      ALB [icon: aws-elb]
+      NAT Gateway [icon: aws-nat-gateway]
+    }
+    Private Subnet {
+      ECS Cluster [icon: aws-ecs] {
+        API Service [icon: aws-lambda]
+        Worker Service [icon: aws-lambda]
+      }
+      RDS [icon: aws-rds]
+      ElastiCache [icon: aws-elasticache]
+    }
+  }
+  S3 [icon: aws-s3]
+  CloudFront [icon: aws-cloudfront]
+}
+
+Users [icon: users]
+
+// Connections
+Users > CloudFront
+CloudFront > ALB
+ALB > API Service
+API Service > RDS
+API Service > ElastiCache
+Worker Service > S3
+\`\`\``;
+const FLOWCHART_DESCRIPTION = `Render a flowchart diagram. Use Eraser's flowchart syntax.
+
+Example syntax:
+\`\`\`
+title User Registration Flow
+
+// Nodes with shapes and icons
+Start [shape: oval, icon: play]
+Enter Details [icon: edit]
+Valid Email? [shape: diamond, icon: help-circle]
+Send Verification [icon: mail]
+Email Verified? [shape: diamond]
+Create Account [icon: user-plus, color: green]
+Show Error [icon: alert-triangle, color: red]
+End [shape: oval, icon: check]
+
+// Groups
+Validation [color: blue] {
+  Check Password Strength [icon: lock]
+  Password OK? [shape: diamond]
+}
+
+// Connections with labels
+Start > Enter Details
+Enter Details > Valid Email?
+Valid Email? > Send Verification: Yes
+Valid Email? > Show Error: No
+Send Verification > Email Verified?
+Email Verified? > Create Account: Yes
+Email Verified? > Show Error: No
+Create Account > End
+Show Error > Enter Details
+\`\`\``;
+const BPMN_DESCRIPTION = `Render a BPMN (Business Process Model and Notation) diagram. Use Eraser's BPMN syntax.
+
+Example syntax:
+\`\`\`
+title Order Fulfillment Process
+
+// Swimlanes (pools)
+Customer [color: blue] {
+  Place Order [type: event, icon: shopping-cart]
+  Receive Confirmation [type: event, icon: mail]
+  Receive Package [type: event, icon: package]
+}
+
+Sales [color: green] {
+  Process Order [icon: clipboard]
+  Check Inventory [icon: database]
+  In Stock? [type: gateway, icon: help-circle]
+  Create Backorder [icon: clock]
+  Confirm Order [icon: check]
+}
+
+Warehouse [color: orange] {
+  Pick Items [icon: box]
+  Pack Order [icon: package]
+  Ship Order [icon: truck]
+}
+
+// Flow connections (use --> for message flows between pools)
+Place Order --> Process Order: Order details
+Process Order > Check Inventory
+Check Inventory > In Stock?
+In Stock? > Confirm Order: Yes
+In Stock? > Create Backorder: No
+Confirm Order --> Receive Confirmation: Confirmation email
+Confirm Order > Pick Items
+Pick Items > Pack Order
+Pack Order > Ship Order
+Ship Order --> Receive Package: Delivery
+\`\`\``;
+exports.mcpTools = [
+    {
+        name: 'renderPrompt',
+        description: 'Generate a diagram using AI from a natural language prompt, existing code, infrastructure configuration, or other diagram languages. Best for when you want AI to create the diagram code for you.',
+        schema: renderPromptSchema,
+        jsonSchema: renderPromptJsonSchema,
+    },
+    {
+        name: 'renderElements',
+        description: 'Render multiple diagram elements. Advanced use case for rendering multiple diagrams at once.',
+        schema: renderElementsSchema,
+        jsonSchema: renderElementsJsonSchema,
+    },
+    {
+        name: 'renderSequenceDiagram',
+        description: SEQUENCE_DIAGRAM_DESCRIPTION,
+        schema: singleDiagramSchema,
+        jsonSchema: singleDiagramJsonSchema,
+    },
+    {
+        name: 'renderEntityRelationshipDiagram',
+        description: ERD_DESCRIPTION,
+        schema: singleDiagramSchema,
+        jsonSchema: singleDiagramJsonSchema,
+    },
+    {
+        name: 'renderCloudArchitectureDiagram',
+        description: CLOUD_ARCHITECTURE_DESCRIPTION,
+        schema: singleDiagramSchema,
+        jsonSchema: singleDiagramJsonSchema,
+    },
+    {
+        name: 'renderFlowchart',
+        description: FLOWCHART_DESCRIPTION,
+        schema: singleDiagramSchema,
+        jsonSchema: singleDiagramJsonSchema,
+    },
+    {
+        name: 'renderBpmnDiagram',
+        description: BPMN_DESCRIPTION,
+        schema: singleDiagramSchema,
+        jsonSchema: singleDiagramJsonSchema,
+    },
+];
+function isMcpToolName(name) {
+    return exports.mcpTools.some((tool) => tool.name === name);
+}
+exports.isMcpToolName = isMcpToolName;
+exports.mcpToolMap = new Map(exports.mcpTools.map((tool) => [tool.name, tool]));
+// Mapping from single diagram tool names to their diagram types
+exports.singleDiagramTools = {
+    renderSequenceDiagram: DiagramTypes.SD,
+    renderEntityRelationshipDiagram: DiagramTypes.ERD,
+    renderCloudArchitectureDiagram: DiagramTypes.CAD,
+    renderFlowchart: DiagramTypes.FLOW,
+    renderBpmnDiagram: DiagramTypes.BPMN,
+};
+function isSingleDiagramTool(name) {
+    return name in exports.singleDiagramTools;
+}
+exports.isSingleDiagramTool = isSingleDiagramTool;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@eraserlabs/eraser-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for generating diagrams with Eraser.io",
+  "private": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "eraser-mcp": "dist/stdio.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "eraser",
+    "diagrams",
+    "model-context-protocol"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eraserlabs/eraserio.git",
+    "directory": "packages/eraser-mcp"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^4.8.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}