drawio-mcp-server 1.1.3 → 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 = {

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.3",
+  "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\"",