drawio-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,211 @@
+# Draw.io MCP server
+
+Let's do some Vibe Diagramming with the most wide-spread diagramming tool called Draw.io (Diagrams.net).
+
+## Introduction
+
+The Draw.io MCP server is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io) implementation that brings powerful diagramming capabilities to AI agentic systems. This integration enables:
+
+- **Seamless Draw.io Integration**: Connect your MCP-powered applications with Draw.io's rich diagramming functionality
+- **Programmatic Diagram Control**: Create, modify, and manage diagram content through MCP commands
+- **Intelligent Diagram Analysis**: Retrieve detailed information about diagrams and their components for processing by AI agents
+- **Agentic System Development**: Build sophisticated AI workflows that incorporate visual modeling and diagram automation
+
+As an MCP-compliant tool, it follows the standard protocol for tool integration, making it compatible with any MCP client. This implementation is particularly valuable for creating AI systems that need to:
+- Generate architectural diagrams
+- Visualize complex relationships
+- Annotate technical documentation
+- Create flowcharts and process maps programmatically
+
+The tool supports bidirectional communication, allowing both control of Draw.io instances and extraction of diagram information for further processing by AI agents in your MCP ecosystem.
+
+## Requirements
+
+To use the Draw.io MCP server, you'll need:
+
+### Core Components
+- **Node.js** (v18 or higher) - Runtime environment for the MCP server
+- **Draw.io MCP Browser Extension** - Enables communication between Draw.io and the MCP server
+
+### MCP Ecosystem
+- **MCP Client** (e.g., [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector)) - For testing and debugging the integration
+- **LLM with Tools Support** - Any language model capable of handling MCP tool calls (e.g., GPT-4, Claude 3, etc.)
+
+### Optional for Development
+- **pnpm** - Preferred package manager
+- **Chrome DevTools** - For debugging when using `--inspect` flag
+
+Note: The Draw.io desktop app or web version must be accessible to the system where the MCP server runs.
+
+## Installation
+
+### Connecting with Claude Desktop
+
+1. Install [Claude Desktop](https://claude.ai/download)
+2. Open or create the configuration file:
+   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+3. Update it to include this server:
+
+<details>
+  <summary>Using <code>npm</code></summary>
+
+```json
+{
+   "mcpServers":{
+      "drawio":{
+         "command":"npx",
+         "args":[
+            "-y",
+            "drawio-mcp-server"
+         ]
+      }
+   }
+}
+```
+</details>
+
+<details>
+  <summary>Using <code>pnpm</code></summary>
+
+```json
+{
+   "mcpServers":{
+      "drawio":{
+         "command":"pnpm",
+         "args":[
+            "dlx",
+            "drawio-mcp-server"
+         ]
+      }
+   }
+}
+```
+</details>
+
+4. Restart Claude Desktop
+
+### Connecting with oterm
+
+This is an alternative MCP client in case you like terminal and you plan to connect to your own Ollama instance.
+
+The configuration is usually in: ~/.local/share/oterm/config.json
+
+<details>
+  <summary>Using <code>npm</code></summary>
+
+```json
+{
+	"mcpServers": {
+		"drawio": {
+			"command": "npx",
+			"args": [
+			  "-y",
+        "drawio-mcp-server"
+			]
+		}
+	}
+}
+```
+</details>
+
+<details>
+  <summary>Using <code>pnpm</code></summary>
+
+```json
+{
+	"mcpServers": {
+		"drawio": {
+			"command": "pnpm",
+			"args": [
+			  "dlx",
+        "drawio-mcp-server"
+			]
+		}
+	}
+}
+```
+</details>
+
+### Browser Extension Setup
+
+In order to control the Draw.io diagram, you need to install dedicated Browser Extension.
+
+1. Open [Draw.io in your browser](https://app.diagrams.net/)
+2. Install the Draw.io MCP Browser Extension from a web store (**still pending review**) or [use other means](https://github.com/lgazo/drawio-mcp-extension)
+<p>
+  <a href="https://chrome.google.com/webstore/detail/drawio-mcp-extension/okdbbjbbccdhhfaefmcmekalmmdjjide">
+    <picture>
+      <source srcset="https://i.imgur.com/XBIE9pk.png" media="(prefers-color-scheme: dark)" />
+      <img height="58" src="https://i.imgur.com/oGxig2F.png" alt="Chrome Web Store" /></picture
+  ></a>
+  <a href="https://addons.mozilla.org/en-US/firefox/addon/drawio-mcp-extension/">
+    <picture>
+      <source srcset="https://i.imgur.com/ZluoP7T.png" media="(prefers-color-scheme: dark)" />
+      <img height="58" src="https://i.imgur.com/4PobQqE.png" alt="Firefox add-ons" /></picture
+  ></a>
+</p>
+3. Ensure it is connected, the Extension icon should indicate green signal overlay <img alt="Extension connected" src="https://raw.githubusercontent.com/lgazo/drawio-mcp-extension/refs/heads/main/public/icon/logo_connected_32.png" />
+
+
+## Features
+
+The Draw.io MCP server provides the following tools for programmatic diagram interaction:
+
+### Diagram Inspection Tools
+- **`get-selected-cell`**
+  Retrieves the currently selected cell in Draw.io with all its attributes
+  *Returns*: JSON object containing cell properties (ID, geometry, style, value, etc.)
+
+- **`get-shape-categories`**
+  Retrieves available shape categories from the diagram's library
+  *Returns*: Array of category objects with their IDs and names
+
+- **`get-shapes-in-category`**
+  Retrieves all shapes in a specified category from the diagram's library
+  *Parameters*:
+    - `category_id`: Identifier of the category to retrieve shapes from
+  *Returns*: Array of shape objects with their properties and styles
+
+- **`get-shape-by-name`**
+  Retrieves a specific shape by its name from all available shapes
+  *Parameters*:
+    - `shape_name`: Name of the shape to retrieve
+  *Returns*: Shape object including its category and style information
+
+### Diagram Modification Tools
+- **`add-rectangle`**
+  Creates a new rectangle shape on the active Draw.io page with customizable properties:
+  - Position (`x`, `y` coordinates)
+  - Dimensions (`width`, `height`)
+  - Text content
+  - Visual style (fill color, stroke, etc. using Draw.io style syntax)
+
+- **`add-edge`**
+  Creates a connection between two cells (vertexes)
+  *Parameters*:
+    - `source_id`: ID of the source cell
+    - `target_id`: ID of the target cell
+    - `text`: Optional text label for the edge
+    - `style`: Optional style properties for the edge
+
+- **`delete-cell-by-id`**
+  Removes a specified cell from the diagram
+  *Parameters*:
+    - `cell_id`: ID of the cell to delete
+
+- **`add-cell-of-shape`**
+  Adds a new cell of a specific shape type from the diagram's library
+  *Parameters*:
+    - `shape_name`: Name of the shape to create
+    - `x`, `y`: Position coordinates (optional)
+    - `width`, `height`: Dimensions (optional)
+    - `text`: Optional text content
+    - `style`: Optional additional style properties
+
+## Related Resources
+
+[Architecture](./ARCHITECTURE.md)
+
+[Development](./DEVELOPMENT.md)

package/build/emitter_bus.js

@@ -0,0 +1,23 @@
+import { bus_reply_stream, bus_request_stream, } from "./types.js";
+export function create_bus(log) {
+    return function (emitter) {
+        const listeners = [];
+        const bus = {
+            send_to_extension: (request) => {
+                log.debug(`[bus] sending to Extension`, request);
+                emitter.emit(bus_request_stream, request);
+            },
+            on_reply_from_extension: (event_name, reply) => {
+                const listener = (emitter_data) => {
+                    log.debug(`[bus] received from Extension`, emitter_data);
+                    if (emitter_data && emitter_data.__event === event_name) {
+                        reply(emitter_data);
+                    }
+                };
+                emitter.on(bus_reply_stream, listener);
+                listeners.push(reply);
+            },
+        };
+        return bus;
+    };
+}

package/build/emitter_bus.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect, jest } from "@jest/globals";
+import EventEmitter from "node:events";
+import { create_bus } from "./emitter_bus.js";
+import { bus_request_stream, bus_reply_stream } from "./types.js";
+import { create_logger } from "./standard_console_logger.js";
+describe("create_bus", () => {
+    let emitter;
+    let bus;
+    const log = create_logger();
+    beforeEach(() => {
+        emitter = new EventEmitter();
+        bus = create_bus(log)(emitter);
+    });
+    it("should send requests to extension via emitter", () => {
+        const mockRequest = { type: "test_request", data: "test" };
+        const emitSpy = jest.spyOn(emitter, "emit");
+        bus.send_to_extension(mockRequest);
+        expect(emitSpy).toHaveBeenCalledWith(bus_request_stream, mockRequest);
+    });
+    it("should register reply handlers and call them when matching events arrive", () => {
+        const mockReply1 = jest.fn();
+        const mockReply2 = jest.fn();
+        const eventName1 = "event1";
+        const eventName2 = "event2";
+        const matchingEvent1 = { __event: eventName1, data: "test1" };
+        const matchingEvent2 = { __event: eventName2, data: "test2" };
+        const nonMatchingEvent = { __event: "other_event", data: "test3" };
+        bus.on_reply_from_extension(eventName1, mockReply1);
+        bus.on_reply_from_extension(eventName2, mockReply2);
+        emitter.emit(bus_reply_stream, matchingEvent1);
+        emitter.emit(bus_reply_stream, matchingEvent2);
+        emitter.emit(bus_reply_stream, nonMatchingEvent);
+        expect(mockReply1).toHaveBeenCalledWith(matchingEvent1);
+        expect(mockReply2).toHaveBeenCalledWith(matchingEvent2);
+        expect(mockReply1).not.toHaveBeenCalledWith(nonMatchingEvent);
+        expect(mockReply2).not.toHaveBeenCalledWith(nonMatchingEvent);
+    });
+    it("should track all registered listeners", () => {
+        // This test assumes the listeners array is accessible or there's a way to verify listeners
+        // Since the original code doesn't expose the listeners array, we'll test indirectly
+        const mockReply1 = jest.fn();
+        const mockReply2 = jest.fn();
+        bus.on_reply_from_extension("event1", mockReply1);
+        bus.on_reply_from_extension("event2", mockReply2);
+        // Verify listeners are working by emitting events
+        const event1 = { __event: "event1", data: "test" };
+        const event2 = { __event: "event2", data: "test" };
+        emitter.emit(bus_reply_stream, event1);
+        emitter.emit(bus_reply_stream, event2);
+        expect(mockReply1).toHaveBeenCalledWith(event1);
+        expect(mockReply2).toHaveBeenCalledWith(event2);
+    });
+    it("should only call the correct reply handler for each event", () => {
+        const mockReply1 = jest.fn();
+        const mockReply2 = jest.fn();
+        const eventName1 = "event1";
+        const eventName2 = "event2";
+        const matchingEvent = { __event: eventName1, data: "test" };
+        bus.on_reply_from_extension(eventName1, mockReply1);
+        bus.on_reply_from_extension(eventName2, mockReply2);
+        emitter.emit(bus_reply_stream, matchingEvent);
+        expect(mockReply1).toHaveBeenCalledWith(matchingEvent);
+        expect(mockReply2).not.toHaveBeenCalled();
+    });
+});

package/build/events.js

@@ -0,0 +1,14 @@
+/**
+ * Removes top-level fields from an object that start with '__'
+ * @param obj The input object to process
+ * @returns A new object with internal fields (starting with '__') removed
+ */
+export function strip_internal_fields(obj) {
+    const result = {};
+    for (const key in obj) {
+        if (!key.startsWith("__")) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}

package/build/events.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "@jest/globals";
+import { strip_internal_fields } from "./events.js";
+describe("strip_internal_fields", () => {
+    describe("when object contains internal fields (starting with __)", () => {
+        it("should remove all fields that start with __", () => {
+            const input = {
+                __private: "secret-data",
+                publicField: "visible",
+                __config: { key: "value" },
+                count: 42,
+                __meta: { timestamp: "2023-01-01" },
+            };
+            const result = strip_internal_fields(input);
+            expect(result).toEqual({
+                publicField: "visible",
+                count: 42,
+            });
+        });
+        it("should return an empty object when all fields are internal", () => {
+            const input = {
+                __internal: true,
+                __version: "1.0.0",
+            };
+            const result = strip_internal_fields(input);
+            expect(result).toEqual({});
+        });
+        it("should not mutate the original object", () => {
+            const input = {
+                __temp: "value",
+                name: "original",
+            };
+            const originalInput = { ...input };
+            strip_internal_fields(input);
+            expect(input).toEqual(originalInput);
+        });
+    });
+    describe("when object contains no internal fields", () => {
+        it("should return the object unchanged when no fields start with __", () => {
+            const input = {
+                id: "abc123",
+                name: "Test Object",
+                metadata: { created: "2023-01-01" },
+            };
+            const result = strip_internal_fields(input);
+            expect(result).toStrictEqual(input); // Should return same reference
+            expect(result).toEqual(input); // With same content
+        });
+        it("should return an empty object when input is empty", () => {
+            const input = {};
+            const result = strip_internal_fields(input);
+            expect(result).toEqual({});
+        });
+    });
+    describe("TypeScript type behavior", () => {
+        it("should properly exclude __ prefixed fields from the return type", () => {
+            const input = {
+                id: "123",
+                __internal: true,
+                name: "Test",
+                __version: 1,
+            };
+            const result = strip_internal_fields(input);
+            // This test is mostly for TypeScript type checking
+            expect(result).toEqual({
+                id: "123",
+                name: "Test",
+            });
+            // @ts-expect-error - __internal should not exist in type
+            expect(result.__internal).toBeUndefined();
+            // @ts-expect-error - __version should not exist in type
+            expect(result.__version).toBeUndefined();
+        });
+    });
+});

package/build/index.js

@@ -0,0 +1,184 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import EventEmitter from "node:events";
+import uWS from "uWebSockets.js";
+import { bus_reply_stream, bus_request_stream, } from "./types.js";
+import { create_bus } from "./emitter_bus.js";
+import { default_tool } from "./tool.js";
+import { nanoid_id_generator } from "./nanoid_id_generator.js";
+import { create_logger } from "./mcp_console_logger.js";
+const log = create_logger();
+const emitter = new EventEmitter();
+const conns = [];
+const bus_to_ws_forwarder_listener = (event) => {
+    log.debug(`[bridge] received; passing to #${conns.length}`, event);
+    for (let i = 0; i < conns.length; i++) {
+        try {
+            conns[i].send(JSON.stringify(event));
+        }
+        catch (e) {
+            log.debug(`[bridge] error forwarding request at conn = ${i}`);
+        }
+    }
+};
+emitter.on(bus_request_stream, bus_to_ws_forwarder_listener);
+const ws_handler = {
+    open: (ws) => {
+        log.debug("A WebSocket connected!");
+        conns.push(ws);
+    },
+    message: (ws, message, isBinary) => {
+        // ws.send(message, isBinary);
+        const decoder = new TextDecoder();
+        const str = decoder.decode(message);
+        const json = JSON.parse(str);
+        log.debug(`[ws] received from Extension`, json);
+        // const event_name = message.__event;
+        emitter.emit(bus_reply_stream, json);
+    },
+    close: (ws, code, message) => {
+        log.debug("WebSocket closed");
+        //todo remove conn
+    },
+};
+const app = uWS
+    .App()
+    .ws("/*", ws_handler)
+    .listen(3000, (token) => {
+    if (token) {
+        log.debug("Listening to port 3000");
+    }
+});
+// Create server instance
+const server = new McpServer({
+    name: "drawio-mcp-server",
+    version: "1.0.0",
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+const bus = create_bus(log)(emitter);
+const id_generator = nanoid_id_generator();
+const context = {
+    bus,
+    id_generator,
+    log,
+};
+const TOOL_get_selected_cell = "get-selected-cell";
+server.tool(TOOL_get_selected_cell, "This tool allows you to retrieve selected cell (whether vertex or edge) on the current page of a Draw.io diagram. The response is a JSON containing attributes of the cell.", {}, default_tool(TOOL_get_selected_cell, context));
+const TOOL_add_rectangle = "add-rectangle";
+server.tool(TOOL_add_rectangle, "This tool allows you to add new Rectangle vertex cell (object) on the current page of a Draw.io diagram. It accepts multiple optional input parameter.", {
+    x: z
+        .number()
+        .optional()
+        .describe("X-axis position of the Rectangle vertex cell")
+        .default(100),
+    y: z
+        .number()
+        .optional()
+        .describe("Y-axis position of the Rectangle vertex cell")
+        .default(100),
+    width: z
+        .number()
+        .optional()
+        .describe("Width of the Rectangle vertex cell")
+        .default(200),
+    height: z
+        .number()
+        .optional()
+        .describe("Height of the Rectangle vertex cell")
+        .default(100),
+    text: z
+        .string()
+        .optional()
+        .describe("Text content placed inside of the Rectangle vertex cell")
+        .default("New Cell"),
+    style: z
+        .string()
+        .optional()
+        .describe("Semi-colon separated list of Draw.io visual styles, in the form of `key=value`. Example: `whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;`")
+        .default("whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;"),
+}, default_tool(TOOL_add_rectangle, context));
+const TOOL_add_edge = "add-edge";
+server.tool(TOOL_add_edge, "This tool creates an edge, sometimes called also a relation, between two vertexes (cells).", {
+    source_id: z
+        .string()
+        .describe("Source ID of a cell. It is represented by `id` attribute."),
+    target_id: z
+        .string()
+        .describe("Target ID of a cell. It is represented by `id` attribute."),
+    text: z
+        .string()
+        .optional()
+        .describe("Text content placed over the edge cell"),
+    style: z
+        .string()
+        .optional()
+        .describe("Semi-colon separated list of Draw.io visual styles, in the form of `key=value`. Example: `edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;`")
+        .default("edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;"),
+}, default_tool(TOOL_add_edge, context));
+const TOOL_delete_cell_by_id = "delete-cell-by-id";
+server.tool(TOOL_delete_cell_by_id, "Deletes a cell, whether it is a vertex or edge.", {
+    cell_id: z
+        .string()
+        .describe("The ID of a cell to delete. The cell can be either vertex or edge. The ID is located in `id` attribute."),
+}, default_tool(TOOL_delete_cell_by_id, context));
+const TOOL_get_shape_categories = "get-shape-categories";
+server.tool(TOOL_get_shape_categories, "Retrieves available shape categories from the diagram's library. Library is split into multiple categories.", {}, default_tool(TOOL_get_shape_categories, context));
+const TOOL_get_shapes_in_category = "get-shapes-in-category";
+server.tool(TOOL_get_shapes_in_category, "Retrieve all shapes in the provided category from the diagram's library. A shape primarily contains `style` based on which you can create new vertex cells.", {
+    category_id: z
+        .string()
+        .describe("Identifier (ID / key) of the category from which all the shapes should be retrieved."),
+}, default_tool(TOOL_get_shapes_in_category, context));
+const TOOL_get_shape_by_name = "get-shape-by-name";
+server.tool(TOOL_get_shape_by_name, "Retrieve a specific shape by its name from all available shapes in the diagram's library. It returns the shape and also the category it belongs.", {
+    shape_name: z
+        .string()
+        .describe("Name of the shape to retrieve from the shape library of the current diagram."),
+}, default_tool(TOOL_get_shape_by_name, context));
+const TOOL_add_cell_of_shape = "add-cell-of-shape";
+server.tool(TOOL_add_cell_of_shape, "This tool allows you to add new vertex cell (object) on the current page of a Draw.io diagram by its shape name. It accepts multiple optional input parameter.", {
+    shape_name: z
+        .string()
+        .describe("Name of the shape to retrieved from the shape library of the current diagram."),
+    x: z
+        .number()
+        .optional()
+        .describe("X-axis position of the vertex cell of the shape")
+        .default(100),
+    y: z
+        .number()
+        .optional()
+        .describe("Y-axis position of the vertex cell of the shape")
+        .default(100),
+    width: z
+        .number()
+        .optional()
+        .describe("Width of the vertex cell of the shape")
+        .default(200),
+    height: z
+        .number()
+        .optional()
+        .describe("Height of the vertex cell of the shape")
+        .default(100),
+    text: z
+        .string()
+        .optional()
+        .describe("Text content placed inside of the vertex cell of the shape"),
+    style: z
+        .string()
+        .optional()
+        .describe("Semi-colon separated list of Draw.io visual styles, in the form of `key=value`. Example: `whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;`"),
+}, default_tool(TOOL_add_cell_of_shape, context));
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log.debug("Draw.io MCP Server running on stdio");
+}
+main().catch((error) => {
+    log.debug("Fatal error in main():", error);
+    process.exit(1);
+});

package/build/mcp_console_logger.js

@@ -0,0 +1,10 @@
+export function create_logger() {
+    return {
+        log: (level, message, data) => {
+            return console.error(message, data);
+        },
+        debug: (message, data) => {
+            return console.error(message, data);
+        },
+    };
+}

package/build/mcp_console_logger.test.js

@@ -0,0 +1,51 @@
+import { jest } from "@jest/globals";
+import { create_logger } from "./mcp_console_logger.js";
+describe("create_logger", () => {
+    let originalConsoleError;
+    let mockConsoleError;
+    beforeEach(() => {
+        // Save original console.error
+        originalConsoleError = console.error;
+        // Create mock for console.error
+        mockConsoleError = jest.fn();
+        console.error = mockConsoleError;
+    });
+    afterEach(() => {
+        // Restore original console.error
+        console.error = originalConsoleError;
+        // Clear all mocks
+        jest.clearAllMocks();
+    });
+    it("should return a Logger object with log and debug methods", () => {
+        const logger = create_logger();
+        expect(logger).toBeDefined();
+        expect(typeof logger.log).toBe("function");
+        expect(typeof logger.debug).toBe("function");
+    });
+    it("log method should call console.error with message and data", () => {
+        const logger = create_logger();
+        const testMessage = "test message";
+        const testData = { key: "value" };
+        const testLevel = "info";
+        logger.log(testLevel, testMessage, testData);
+        expect(mockConsoleError).toHaveBeenCalledTimes(1);
+        expect(mockConsoleError).toHaveBeenCalledWith(testMessage, testData);
+    });
+    it("debug method should call console.error with message and data", () => {
+        const logger = create_logger();
+        const testMessage = "debug message";
+        const testData = { debug: true };
+        logger.debug(testMessage, testData);
+        expect(mockConsoleError).toHaveBeenCalledTimes(1);
+        expect(mockConsoleError).toHaveBeenCalledWith(testMessage, testData);
+    });
+    it("should handle undefined data parameter", () => {
+        const logger = create_logger();
+        const testMessage = "message without data";
+        logger.log("warn", testMessage);
+        expect(mockConsoleError).toHaveBeenCalledWith(testMessage, undefined);
+        mockConsoleError.mockClear();
+        logger.debug(testMessage);
+        expect(mockConsoleError).toHaveBeenCalledWith(testMessage, undefined);
+    });
+});

package/build/nanoid_id_generator.js

@@ -0,0 +1,6 @@
+import { nanoid } from "nanoid";
+export function nanoid_id_generator() {
+    return {
+        generate: () => nanoid(),
+    };
+}

package/build/nanoid_id_generator.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "@jest/globals";
+import { nanoid_id_generator } from "./nanoid_id_generator.js";
+describe("nanoid_id_generator", () => {
+    it("should return an object with a generate function", () => {
+        const generator = nanoid_id_generator();
+        expect(generator).toHaveProperty("generate");
+        expect(typeof generator.generate).toBe("function");
+    });
+    it("should generate a string ID", () => {
+        const generator = nanoid_id_generator();
+        const id = generator.generate();
+        expect(typeof id).toBe("string");
+        expect(id.length).toBeGreaterThan(0);
+    });
+    it("should generate different IDs on subsequent calls", () => {
+        const generator = nanoid_id_generator();
+        const id1 = generator.generate();
+        const id2 = generator.generate();
+        expect(id1).not.toBe(id2);
+    });
+    it("should generate IDs of default length (21 characters)", () => {
+        const generator = nanoid_id_generator();
+        const id = generator.generate();
+        expect(id).toHaveLength(21);
+    });
+});

package/build/standard_console_logger.js

@@ -0,0 +1,10 @@
+export function create_logger() {
+    return {
+        log: (level, message, data) => {
+            return console.log(message, data);
+        },
+        debug: (message, data) => {
+            return console.debug(message, data);
+        },
+    };
+}

package/build/tool.js

@@ -0,0 +1,40 @@
+import { strip_internal_fields } from "./events.js";
+export function build_channel({ bus, id_generator, log }, event_name, handler) {
+    const fn = async (_args, _extra) => {
+        const request_id = id_generator.generate();
+        // const event_name = `get-selected-cell`;
+        const reply_name = `${event_name}.${request_id}`;
+        bus.send_to_extension({
+            __event: event_name,
+            __request_id: request_id,
+            ..._args,
+        });
+        log.debug(`[${event_name}] emitted, waiting for reply @${reply_name}`);
+        const p = new Promise((resolve, _reject) => {
+            log.debug(`[${event_name}] waiting for response @${reply_name}`);
+            bus.on_reply_from_extension(reply_name, (reply) => {
+                // bus.on(reply_name, (args) => {
+                log.debug(`[${reply_name}] received response`, reply);
+                const data = strip_internal_fields(reply);
+                const response = handler(data);
+                resolve(response);
+            });
+        });
+        return p;
+    };
+    return fn;
+}
+export function default_tool(name, context) {
+    const fn = build_channel(context, name, (reply) => {
+        const response = {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(reply),
+                },
+            ],
+        };
+        return response;
+    });
+    return fn;
+}

package/build/tool.test.js

@@ -0,0 +1,104 @@
+import { jest } from "@jest/globals";
+import { build_channel, default_tool } from "./tool.js";
+import { create_logger } from "./standard_console_logger.js";
+describe("build_channel", () => {
+    let mockBus;
+    let mockIdGenerator;
+    let context;
+    const mockHandler = jest.fn();
+    const log = create_logger();
+    beforeEach(() => {
+        mockBus = {
+            send_to_extension: jest.fn(),
+            on_reply_from_extension: jest.fn(),
+        };
+        mockIdGenerator = {
+            generate: jest.fn().mockReturnValue("123"),
+        };
+        context = {
+            bus: mockBus,
+            id_generator: mockIdGenerator,
+            log,
+        };
+        mockHandler.mockReset();
+    });
+    it("should create a function that sends a message via bus", async () => {
+        const eventName = "test-event";
+        const toolFn = build_channel(context, eventName, mockHandler);
+        const args = { key: "value" };
+        const extra = {};
+        const promise = toolFn(args, extra);
+        expect(mockBus.send_to_extension).toHaveBeenCalledWith({
+            __event: eventName,
+            __request_id: "123",
+            key: "value",
+        });
+    });
+    it("should wait for reply and call handler with response", async () => {
+        const eventName = "test-event";
+        const toolFn = build_channel(context, eventName, mockHandler);
+        const mockResponse = {
+            content: [{ type: "text", text: "response" }],
+        };
+        mockHandler.mockReturnValue(mockResponse);
+        const promise = toolFn({}, {});
+        // Simulate reply callback
+        const replyCallback = mockBus.on_reply_from_extension.mock.calls[0][1];
+        replyCallback({ data: "test" });
+        const result = await promise;
+        expect(mockBus.on_reply_from_extension).toHaveBeenCalledWith("test-event.123", expect.any(Function));
+        expect(mockHandler).toHaveBeenCalledWith({ data: "test" });
+        expect(result).toEqual(mockResponse);
+    });
+    it("should use correct reply channel name format", async () => {
+        mockIdGenerator.generate.mockReturnValue("456");
+        const eventName = "another-event";
+        const toolFn = build_channel(context, eventName, mockHandler);
+        toolFn({}, {});
+        expect(mockBus.on_reply_from_extension).toHaveBeenCalledWith("another-event.456", expect.any(Function));
+    });
+});
+describe("default_tool", () => {
+    let mockBus;
+    let mockIdGenerator;
+    const log = create_logger();
+    let context;
+    beforeEach(() => {
+        mockBus = {
+            send_to_extension: jest.fn(),
+            on_reply_from_extension: jest.fn((_, callback) => {
+                callback({ test: "data" });
+            }),
+        };
+        mockIdGenerator = {
+            generate: jest.fn().mockReturnValue("789"),
+        };
+        context = {
+            bus: mockBus,
+            id_generator: mockIdGenerator,
+            log,
+        };
+    });
+    it("should create a tool that returns JSON stringified response", async () => {
+        const toolName = "default-tool";
+        const tool = default_tool(toolName, context);
+        const result = await tool({}, {});
+        expect(result).toEqual({
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ test: "data" }),
+                },
+            ],
+        });
+    });
+    it("should use the provided tool name in the channel", async () => {
+        const toolName = "custom-tool";
+        const tool = default_tool(toolName, context);
+        await tool({}, {});
+        expect(mockBus.send_to_extension).toHaveBeenCalledWith({
+            __event: toolName,
+            __request_id: "789",
+        });
+    });
+});

package/build/types.js

@@ -0,0 +1,2 @@
+export const bus_request_stream = "BUS_REQUEST";
+export const bus_reply_stream = "BUS_REPLY";

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "drawio-mcp-server",
+  "version": "1.0.0",
+  "description": "Provides Draw.io services to MCP Clients",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "drawio-mcp-server": "./build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "server",
+    "draw.io",
+    "drawio",
+    "diagrams.net",
+    "diagramsnet",
+    "diagram",
+    "claude"
+  ],
+  "author": "Ladislav Gazo",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.10.1",
+    "nanoid": "5.1.5",
+    "pino": "9.6.0",
+    "pino-pretty": "13.0.0",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.51.0",
+    "zod": "3.24.3"
+  },
+  "devDependencies": {
+    "@jest/globals": "29.7.0",
+    "@types/jest": "29.5.12",
+    "@types/node": "22.14.1",
+    "globals": "15.0.0",
+    "jest": "29.7.0",
+    "jest-environment-node": "29.7.0",
+    "prettier": "3.5.3",
+    "rimraf": "6.0.1",
+    "ts-jest": "29.3.2",
+    "typescript": "5.8.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "ci": "pnpm install --frozen-lockfile",
+    "dev": "tsc --watch",
+    "inspect": "pnpx @modelcontextprotocol/inspector node build/index.js",
+    "lint": "tsc --noEmit",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "clean": "rimraf build coverage .eslintcache",
+    "prebuild": "pnpm run clean"
+  }
+}