drawio-mcp-server 1.1.3 → 1.2.1

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,9 @@ 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 as create_console_logger } from "./mcp_console_logger.js";
+import { create_logger as create_server_logger, validLogLevels, } from "./mcp_server_logger.js";
 const PORT = 3333;
-const log = create_logger();
 async function checkPortAvailable(port) {
     return new Promise((resolve) => {
         const server = createServer();
@@ -75,15 +75,30 @@ async function start_websocket_server() {
     });
     return app;
 }
+const logger_type = process.env.LOGGER_TYPE;
+let capabilities = {
+    resources: {},
+    tools: {},
+};
+if (logger_type === "mcp_server") {
+    capabilities = {
+        ...capabilities,
+        logging: {
+            setLevels: true,
+            levels: validLogLevels,
+        },
+    };
+}
 // Create server instance
 const server = new McpServer({
     name: "drawio-mcp-server",
-    version: "1.0.3",
-    capabilities: {
-        resources: {},
-        tools: {},
-    },
+    version: "1.2.1",
+}, {
+    capabilities,
 });
+const log = logger_type === "mcp_server"
+    ? create_server_logger(server)
+    : create_console_logger();
 const bus = create_bus(log)(emitter);
 const id_generator = nanoid_id_generator();
 const context = {

package/build/mcp_server_logger.js

@@ -0,0 +1,116 @@
+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) => {
+            log3(level, ".", { message, data });
+        },
+        debug: (message, ...data) => {
+            log3("debug", ".", { message, data });
+        },
+    };
+}

package/build/mcp_server_logger.test.js

@@ -0,0 +1,196 @@
+import { jest } from "@jest/globals";
+import { create_logger } from "./mcp_server_logger.js";
+describe("create_logger", () => {
+    let mock_send_logging_message;
+    let mock_set_request_handler;
+    let mock_server;
+    beforeEach(() => {
+        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(() => {
+        jest.clearAllMocks();
+    });
+    it("should return a Logger object with log and debug methods", () => {
+        const logger = create_logger(mock_server);
+        expect(logger).toBeDefined();
+        expect(typeof logger.log).toBe("function");
+        expect(typeof logger.debug).toBe("function");
+    });
+    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", 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.1",
   "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\"",