drawio-mcp-server 1.1.2 → 1.2.0

package/build/emitter_bus.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, jest } from "@jest/globals";
-import EventEmitter from "node:events";
+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";

package/build/index.js

@@ -9,9 +9,8 @@ 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";
+import { create_logger, validLogLevels } from "./mcp_console_logger.js";
 const PORT = 3333;
-const log = create_logger();
 async function checkPortAvailable(port) {
     return new Promise((resolve) => {
         const server = createServer();
@@ -78,12 +77,18 @@ async function start_websocket_server() {
 // Create server instance
 const server = new McpServer({
     name: "drawio-mcp-server",
-    version: "1.0.3",
+    version: "1.2.0",
+}, {
     capabilities: {
         resources: {},
         tools: {},
+        logging: {
+            setLevels: true,
+            levels: validLogLevels,
+        },
     },
 });
+const log = create_logger(server);
 const bus = create_bus(log)(emitter);
 const id_generator = nanoid_id_generator();
 const context = {
@@ -198,6 +203,14 @@ server.tool(TOOL_add_cell_of_shape, "This tool allows you to add new vertex cell
         .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));
+const Attributes = z.lazy(() => z
+    .array(z.union([
+    z.string(),
+    Attributes, // recursion: nested arrays
+]))
+    .refine((arr) => arr.length === 0 || typeof arr[0] === "string", {
+    message: "If not empty, the first element must be a string operator",
+}));
 const TOOL_list_paged_model = "list-paged-model";
 server.tool(TOOL_list_paged_model, "Retrieves a paginated view of all cells (vertices and edges) in the current Draw.io diagram. This tool provides access to the complete model data with essential fields only, sanitized to remove circular dependencies and excessive data. It allows to filter based on multiple criteria and attribute boolean logic. Useful for programmatic inspection of diagram structure without overwhelming response sizes.", {
     page: z
@@ -216,10 +229,9 @@ server.tool(TOOL_list_paged_model, "Retrieves a paginated view of all cells (ver
             .enum(["edge", "vertex", "object", "layer", "group"])
             .optional()
             .describe("Filter by cell type: 'edge' for connection lines, 'vertex' for vertices/shapes, 'object' for any cell type, 'layer' for layer cells, 'group' for grouped cells"),
-        attributes: z
-            .array(z.any())
-            .optional()
-            .describe('Boolean logic array expressions for filtering cell attributes. Format: ["and" | "or", ...expressions] or ["equal", key, value]. Matches against cell attributes and parsed style properties.'),
+        attributes: Attributes.optional()
+            .describe('Boolean logic array expressions for filtering cell attributes. Format: ["and" | "or", ...expressions] or ["equal", key, value]. Matches against cell attributes and parsed style properties.')
+            .default([]),
     })
         .optional()
         .describe("Optional filter criteria to apply to cells before pagination")

package/build/mcp_console_logger.js

@@ -1,14 +1,133 @@
-export function create_logger() {
+import { z } from "zod";
+// Log levels (lower is more severe)
+const LogLevelMap = {
+    emergency: 0,
+    alert: 1,
+    critical: 2,
+    error: 3,
+    warning: 4,
+    notice: 5,
+    info: 6,
+    debug: 7,
+};
+export const validLogLevels = Object.keys(LogLevelMap);
+// Define the request schema for setLevels
+const SetLevelsRequestSchema = z.object({
+    method: z.literal("logging/setLevels"),
+    params: z.object({
+        levels: z.record(z.string(), z.enum(validLogLevels).nullable()),
+    }),
+});
+// Define the request schema for setLevel
+const SetLevelRequestSchema = z.object({
+    method: z.literal("logging/setLevel"),
+    params: z.object({
+        level: z.enum(validLogLevels),
+    }),
+});
+// Per-logger log levels (default is root `"."`)
+let logLevels = {
+    ".": LogLevelMap.info, // Start with info level
+};
+// Helper: Effective log level for a logger
+const getEffectiveLogLevel = (loggerName) => {
+    return loggerName in logLevels
+        ? logLevels[loggerName]
+        : (logLevels["."] ?? LogLevelMap.info);
+};
+// Helper: Should we log at this level?
+const shouldLog = (level, loggerName) => {
+    const numericLevel = LogLevelMap[level];
+    const effectiveLevel = getEffectiveLogLevel(loggerName);
+    return numericLevel <= effectiveLevel;
+};
+// Helper: Actually send a log if allowed
+const log = (server) => (level, loggerName, data) => {
+    if (!(level in LogLevelMap)) {
+        console.error(`Internal Error: Invalid log level used: ${level}`);
+        return;
+    }
+    if (shouldLog(level, loggerName)) {
+        server.server.sendLoggingMessage({
+            level,
+            logger: loggerName,
+            data,
+        });
+    }
+};
+export function create_logger(server) {
+    const log3 = log(server);
+    // 2. Register handler for logging/setLevels (only override requested loggers)
+    server.server.setRequestHandler(SetLevelsRequestSchema, async (request) => {
+        const newLevels = request.params.levels;
+        // Only update logLevels for specified keys; unset any set to null
+        for (const loggerName in newLevels) {
+            if (Object.prototype.hasOwnProperty.call(newLevels, loggerName)) {
+                const levelName = newLevels[loggerName];
+                if (levelName === null) {
+                    if (loggerName !== ".") {
+                        delete logLevels[loggerName]; // Remove override
+                        log3("debug", "logging", {
+                            message: `Reset log level for logger: ${loggerName}`,
+                        });
+                    }
+                }
+                else if (levelName &&
+                    validLogLevels.includes(levelName)) {
+                    logLevels[loggerName] = LogLevelMap[levelName];
+                    log3("debug", "logging", {
+                        message: `Set log level for logger '${loggerName}' to '${levelName}'`,
+                    });
+                }
+                else {
+                    log3("warning", "logging", {
+                        message: `Invalid log level '${levelName}' received for logger '${loggerName}'`,
+                    });
+                }
+            }
+        }
+        return {};
+    });
+    // Register handler for logging/setLevel (sets root logger level)
+    server.server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+        const log3 = log(server);
+        const levelName = request.params.level;
+        if (validLogLevels.includes(levelName)) {
+            logLevels["."] = LogLevelMap[levelName];
+            log3("debug", "logging", {
+                message: `Set root log level to '${levelName}'`,
+            });
+        }
+        else {
+            log3("warning", "logging", {
+                message: `Invalid log level '${levelName}' received`,
+            });
+        }
+        return {};
+    });
     return {
         log: (level, message, ...data) => {
-            return data.length > 0
-                ? console.error(`${level?.toUpperCase()}: ${message}`, ...data)
-                : console.error(`${level?.toUpperCase()}: ${message}`);
+            log3(level, ".", { message, data });
+            // return server.server.sendLoggingMessage({
+            //   // level: LogLevelMap[level?.toLowerCase()],
+            //   level: level?.toLowerCase() as McpLogLevel,
+            //   logger: "root",
+            //   data,
+            // });
+            // return data.length > 0
+            //   ? console.error(`${level?.toUpperCase()}: ${message}`, ...data)
+            //   : console.error(`${level?.toUpperCase()}: ${message}`);
         },
         debug: (message, ...data) => {
-            return data.length > 0
-                ? console.error(`DEBUG: ${message}`, ...data)
-                : console.error(`DEBUG: ${message}`);
+            log3("debug", ".", { message, data });
+            // return server.server.sendLoggingMessage({
+            //   level: "debug" as McpLogLevel,
+            //   logger: "root",
+            //   data,
+            // });
+            // return data.length > 0
+            //   ? console.error(`DEBUG: ${message}`, ...data)
+            //   : console.error(`DEBUG: ${message}`);
         },
     };
 }

package/build/mcp_console_logger.test.js

@@ -1,63 +1,196 @@
 import { jest } from "@jest/globals";
 import { create_logger } from "./mcp_console_logger.js";
 describe("create_logger", () => {
-    let originalConsoleError;
-    let mockConsoleError;
+    let mock_send_logging_message;
+    let mock_set_request_handler;
+    let mock_server;
     beforeEach(() => {
-        // Save original console.error
-        originalConsoleError = console.error;
-        // Create mock for console.error
-        mockConsoleError = jest.fn();
-        console.error = mockConsoleError;
+        mock_send_logging_message = jest.fn();
+        mock_set_request_handler = jest.fn();
+        mock_server = {
+            server: {
+                sendLoggingMessage: mock_send_logging_message,
+                setRequestHandler: mock_set_request_handler,
+            },
+        };
     });
     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();
+        const logger = create_logger(mock_server);
         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(`${testLevel.toUpperCase()}: ${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(`DEBUG: ${testMessage}`, testData);
-    });
-    it("should handle no additional data parameters", () => {
-        const logger = create_logger();
-        const testMessage = "message without data";
-        logger.log("warn", testMessage);
-        expect(mockConsoleError).toHaveBeenCalledWith(`WARN: ${testMessage}`);
-        mockConsoleError.mockClear();
-        logger.debug(testMessage);
-        expect(mockConsoleError).toHaveBeenCalledWith(`DEBUG: ${testMessage}`);
-    });
-    it("should handle multiple data parameters", () => {
-        const logger = create_logger();
-        const testMessage = "message with multiple data";
+    it("log should call sendLoggingMessage with level and data (message is ignored by implementation)", () => {
+        const logger = create_logger(mock_server);
+        const test_message = "test message";
+        const test_data = { key: "value" };
+        const test_level = "info";
+        logger.log(test_level, test_message, test_data);
+        expect(mock_send_logging_message).toHaveBeenCalledTimes(1);
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "info",
+            logger: ".",
+            data: { message: test_message, data: [test_data] },
+        });
+    });
+    it("debug should call sendLoggingMessage with debug level and data", async () => {
+        const logger = create_logger(mock_server);
+        const test_message = "debug message";
+        const test_data = { debug: true };
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "debug" },
+        });
+        mock_send_logging_message.mockClear();
+        logger.debug(test_message, test_data);
+        expect(mock_send_logging_message).toHaveBeenCalledTimes(1);
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "debug",
+            logger: ".",
+            data: { message: test_message, data: [test_data] },
+        });
+    });
+    it("should handle no additional data parameters", async () => {
+        const logger = create_logger(mock_server);
+        const test_message = "message without data";
+        logger.log("warning", test_message);
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "warning",
+            logger: ".",
+            data: { message: test_message, data: [] },
+        });
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "debug" },
+        });
+        mock_send_logging_message.mockClear();
+        logger.debug(test_message);
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "debug",
+            logger: ".",
+            data: { message: test_message, data: [] },
+        });
+    });
+    it("should handle multiple data parameters", async () => {
+        const logger = create_logger(mock_server);
+        const test_message = "message with multiple data";
         const data1 = { key1: "value1" };
         const data2 = { key2: "value2" };
         const data3 = "string data";
-        logger.log("error", testMessage, data1, data2, data3);
-        expect(mockConsoleError).toHaveBeenCalledWith(`ERROR: ${testMessage}`, data1, data2, data3);
-        mockConsoleError.mockClear();
-        logger.debug(testMessage, data1, data2, data3);
-        expect(mockConsoleError).toHaveBeenCalledWith(`DEBUG: ${testMessage}`, data1, data2, data3);
+        logger.log("error", test_message, data1, data2, data3);
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "error",
+            logger: ".",
+            data: { message: test_message, data: [data1, data2, data3] },
+        });
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "debug" },
+        });
+        mock_send_logging_message.mockClear();
+        logger.debug(test_message, data1, data2, data3);
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "debug",
+            logger: ".",
+            data: { message: test_message, data: [data1, data2, data3] },
+        });
+    });
+    it("should not log and print error if an invalid log level is used directly", () => {
+        const logger = create_logger(mock_server);
+        const console_error_spy = jest
+            .spyOn(console, "error")
+            .mockImplementation(() => { });
+        logger.log("invalid_level", "this should not be logged");
+        expect(console_error_spy).toHaveBeenCalledWith("Internal Error: Invalid log level used: invalid_level");
+        expect(mock_send_logging_message).not.toHaveBeenCalled();
+        console_error_spy.mockRestore();
+    });
+    it("should log a warning if logging/setLevel receives an invalid log level", async () => {
+        create_logger(mock_server);
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "not_a_level" },
+        });
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "warning",
+            logger: "logging",
+            data: {
+                message: "Invalid log level 'not_a_level' received",
+            },
+        });
+    });
+    it("should support valid per-logger setLevels, and emit debug message", async () => {
+        create_logger(mock_server);
+        const set_levels_handler = mock_set_request_handler.mock.calls[0][1];
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "debug" },
+        });
+        mock_send_logging_message.mockClear();
+        await set_levels_handler({
+            method: "logging/setLevels",
+            params: { levels: { app: "error" } },
+        });
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "debug",
+            logger: "logging",
+            data: {
+                message: "Set log level for logger 'app' to 'error'",
+            },
+        });
+    });
+    it("should reset per-logger level to default when null is provided", async () => {
+        create_logger(mock_server);
+        const set_levels_handler = mock_set_request_handler.mock.calls[0][1];
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "debug" },
+        });
+        mock_send_logging_message.mockClear();
+        await set_levels_handler({
+            method: "logging/setLevels",
+            params: { levels: { app: "warning" } },
+        });
+        await set_levels_handler({
+            method: "logging/setLevels",
+            params: { levels: { app: null } },
+        });
+        expect(mock_send_logging_message.mock.calls.some((call) => {
+            const arg = call[0];
+            return (arg.level === "debug" &&
+                arg.logger === "logging" &&
+                arg.data &&
+                arg.data.message === "Reset log level for logger: app");
+        })).toBe(true);
+    });
+    it("should log a warning for invalid per-logger level in setLevels", async () => {
+        create_logger(mock_server);
+        const set_levels_handler = mock_set_request_handler.mock.calls[0][1];
+        const set_level_handler = mock_set_request_handler.mock.calls[1][1];
+        await set_level_handler({
+            method: "logging/setLevel",
+            params: { level: "debug" },
+        });
+        mock_send_logging_message.mockClear();
+        await set_levels_handler({
+            method: "logging/setLevels",
+            params: { levels: { "my.logger": "invalid" } },
+        });
+        expect(mock_send_logging_message).toHaveBeenCalledWith({
+            level: "warning",
+            logger: "logging",
+            data: {
+                message: "Invalid log level 'invalid' received for logger 'my.logger'",
+            },
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drawio-mcp-server",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Provides Draw.io services to MCP Clients",
   "type": "module",
   "main": "index.js",
@@ -27,30 +27,28 @@
   "author": "Ladislav Gazo",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.10.1",
+    "@modelcontextprotocol/sdk": "1.17.5",
     "nanoid": "5.1.5",
-    "pino": "9.6.0",
-    "pino-pretty": "13.0.0",
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.52.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",
+    "@jest/globals": "30.1.2",
+    "@types/jest": "30.0.0",
+    "@types/node": "24.3.1",
+    "globals": "16.3.0",
+    "jest": "30.1.3",
+    "jest-environment-node": "30.1.2",
     "prettier": "3.5.3",
     "rimraf": "6.0.1",
-    "ts-jest": "29.3.2",
-    "typescript": "5.8.3"
+    "ts-jest": "29.4.1",
+    "typescript": "5.9.2"
   },
   "scripts": {
     "build": "tsc",
     "ci": "pnpm install --frozen-lockfile",
     "dev": "tsc --watch",
-    "inspect": "HOST=0.0.0.0 pnpx @modelcontextprotocol/inspector node build/index.js",
+    "inspect": "HOST=0.0.0.0 pnpx @modelcontextprotocol/inspector --config ./inspector.json --server drawio",
     "lint": "tsc --noEmit",
     "format": "prettier --write \"src/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\"",