drawio-mcp-server 2.0.4 → 2.1.0

package/build/config.test.js

@@ -1,4 +1,4 @@
-import { parseExtensionPortValue, parseHttpPortValue, findArgValue, hasFlag, shouldShowHelp, parseConfig, buildConfig, parseTransports, } from "./config.js";
+import { parseExtensionPortValue, parseHttpPortValue, findArgValue, hasFlag, shouldShowHelp, parseConfig, buildConfig, parseTransports, parseWebSocketUrlValue, parseHostValue, parseLoggerValue, envToArgs, defaultConfig, } from "./config.js";
 describe("parseExtensionPortValue", () => {
     test("valid port returns number", () => {
         expect(parseExtensionPortValue("8080")).toBe(8080);
@@ -115,6 +115,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("--extension-port flag sets custom port", () => {
@@ -123,6 +126,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("-p flag sets custom port", () => {
@@ -131,6 +137,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("--http-port flag sets custom port", () => {
@@ -139,6 +148,9 @@ describe("parseConfig", () => {
             httpPort: 4242,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("both ports can be configured", () => {
@@ -147,6 +159,9 @@ describe("parseConfig", () => {
             httpPort: 4242,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("help flag is ignored in config parsing", () => {
@@ -155,6 +170,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("invalid port returns Error", () => {
@@ -183,6 +201,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("short and long form both work, last wins", () => {
@@ -191,6 +212,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("last http-port flag wins", () => {
@@ -199,6 +223,9 @@ describe("parseConfig", () => {
             httpPort: 5000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("sets single transport", () => {
@@ -207,6 +234,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("sets multiple transports", () => {
@@ -215,6 +245,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio", "http"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("rejects unknown transport", () => {
@@ -227,6 +260,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: true,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("-e flag enables editor", () => {
@@ -235,6 +271,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: true,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("--editor false disables editor explicitly", () => {
@@ -243,6 +282,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("--editor=true enables editor", () => {
@@ -251,6 +293,9 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: true,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("--editor=false disables editor explicitly", () => {
@@ -259,13 +304,278 @@ describe("parseConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
 });
+describe("parseConfig --host", () => {
+    test("--host sets host in config", () => {
+        const result = parseConfig(["--host", "127.0.0.1"]);
+        expect(result).not.toBeInstanceOf(Error);
+        expect(result.host).toBe("127.0.0.1");
+    });
+    test("--host with IPv6 sets host in config", () => {
+        const result = parseConfig(["--host", "::1"]);
+        expect(result).not.toBeInstanceOf(Error);
+        expect(result.host).toBe("::1");
+    });
+    test("--host with invalid value returns Error", () => {
+        const result = parseConfig(["--host", "localhost"]);
+        expect(result).toBeInstanceOf(Error);
+    });
+    test("omitting --host leaves host undefined", () => {
+        const result = parseConfig([]);
+        expect(result).not.toBeInstanceOf(Error);
+        expect(result.host).toBeUndefined();
+    });
+    test("--host without value returns Error", () => {
+        const result = parseConfig(["--host"]);
+        expect(result).toBeInstanceOf(Error);
+        expect(result.message).toContain("--host flag requires an IP address");
+    });
+});
+describe("parseWebSocketUrlValue", () => {
+    test("accepts ws:// URL", () => {
+        expect(parseWebSocketUrlValue("ws://example.com:3333")).toBe("ws://example.com:3333");
+    });
+    test("accepts wss:// URL", () => {
+        expect(parseWebSocketUrlValue("wss://example.com/ws")).toBe("wss://example.com/ws");
+    });
+    test("rejects http:// URL", () => {
+        const result = parseWebSocketUrlValue("http://example.com");
+        expect(result).toBeInstanceOf(Error);
+    });
+    test("rejects empty string", () => {
+        const result = parseWebSocketUrlValue("");
+        expect(result).toBeInstanceOf(Error);
+    });
+    test("rejects undefined", () => {
+        const result = parseWebSocketUrlValue(undefined);
+        expect(result).toBeInstanceOf(Error);
+    });
+    test("rejects garbage", () => {
+        const result = parseWebSocketUrlValue("not a url");
+        expect(result).toBeInstanceOf(Error);
+    });
+});
+describe("parseLoggerValue", () => {
+    test("accepts console", () => {
+        expect(parseLoggerValue("console")).toBe("console");
+    });
+    test("accepts mcp-server", () => {
+        expect(parseLoggerValue("mcp-server")).toBe("mcp-server");
+    });
+    test("normalises legacy mcp_server to mcp-server", () => {
+        expect(parseLoggerValue("mcp_server")).toBe("mcp-server");
+    });
+    test("rejects unknown value", () => {
+        expect(parseLoggerValue("foo")).toBeInstanceOf(Error);
+    });
+    test("rejects undefined", () => {
+        expect(parseLoggerValue(undefined)).toBeInstanceOf(Error);
+    });
+    test("rejects empty string", () => {
+        expect(parseLoggerValue("")).toBeInstanceOf(Error);
+    });
+});
+describe("parseConfig --logger", () => {
+    test("default logger is console", () => {
+        const result = parseConfig([]);
+        expect(result).not.toBeInstanceOf(Error);
+        expect(result.logger).toBe("console");
+    });
+    test("--logger console keeps default", () => {
+        const result = parseConfig(["--logger", "console"]);
+        expect(result.logger).toBe("console");
+    });
+    test("--logger mcp-server is accepted", () => {
+        const result = parseConfig(["--logger", "mcp-server"]);
+        expect(result.logger).toBe("mcp-server");
+    });
+    test("--logger mcp_server is normalised", () => {
+        const result = parseConfig(["--logger", "mcp_server"]);
+        expect(result.logger).toBe("mcp-server");
+    });
+    test("--logger without value returns Error", () => {
+        const result = parseConfig(["--logger"]);
+        expect(result).toBeInstanceOf(Error);
+        expect(result.message).toContain("--logger flag requires a mode");
+    });
+    test("--logger with invalid value returns Error", () => {
+        const result = parseConfig(["--logger", "syslog"]);
+        expect(result).toBeInstanceOf(Error);
+        expect(result.message).toContain('Invalid logger "syslog"');
+    });
+    test("last --logger wins", () => {
+        const result = parseConfig([
+            "--logger",
+            "mcp-server",
+            "--logger",
+            "console",
+        ]);
+        expect(result.logger).toBe("console");
+    });
+});
+describe("defaultConfig", () => {
+    test("returns config with default logger", () => {
+        const config = defaultConfig();
+        expect(config.logger).toBe("console");
+        expect(config.extensionPort).toBe(3333);
+        expect(config.httpPort).toBe(3000);
+        expect(config.transports).toEqual(["stdio"]);
+        expect(config.editorEnabled).toBe(false);
+    });
+});
+describe("parseHostValue", () => {
+    test("undefined input returns Error", () => {
+        expect(parseHostValue(undefined)).toBeInstanceOf(Error);
+    });
+    test("empty string returns Error", () => {
+        expect(parseHostValue("")).toBeInstanceOf(Error);
+    });
+    test("valid IPv4 loopback returns value", () => {
+        expect(parseHostValue("127.0.0.1")).toBe("127.0.0.1");
+    });
+    test("valid IPv4 wildcard returns value", () => {
+        expect(parseHostValue("0.0.0.0")).toBe("0.0.0.0");
+    });
+    test("valid IPv6 loopback returns value", () => {
+        expect(parseHostValue("::1")).toBe("::1");
+    });
+    test("valid IPv6 wildcard returns value", () => {
+        expect(parseHostValue("::")).toBe("::");
+    });
+    test("hostname string returns Error", () => {
+        expect(parseHostValue("localhost")).toBeInstanceOf(Error);
+    });
+    test("arbitrary string returns Error", () => {
+        expect(parseHostValue("not-an-ip")).toBeInstanceOf(Error);
+    });
+});
+describe("parseConfig --websocket-url", () => {
+    test("accepts wss:// override", () => {
+        const result = parseConfig(["--websocket-url", "wss://example.com/ws"]);
+        expect(result).not.toBeInstanceOf(Error);
+        expect(result.webSocketUrl).toBe("wss://example.com/ws");
+    });
+    test("rejects http:// scheme", () => {
+        const result = parseConfig(["--websocket-url", "http://example.com"]);
+        expect(result).toBeInstanceOf(Error);
+    });
+    test("missing value returns Error", () => {
+        const result = parseConfig(["--websocket-url"]);
+        expect(result).toBeInstanceOf(Error);
+        expect(result.message).toContain("--websocket-url flag requires a URL");
+    });
+    test("last --websocket-url wins", () => {
+        const result = parseConfig([
+            "--websocket-url",
+            "ws://first.example/ws",
+            "--websocket-url",
+            "wss://second.example/ws",
+        ]);
+        expect(result.webSocketUrl).toBe("wss://second.example/ws");
+    });
+});
+describe("envToArgs", () => {
+    test("empty env yields empty args", () => {
+        expect(envToArgs({})).toEqual([]);
+    });
+    test("maps DRAWIO_MCP_EXTENSION_PORT", () => {
+        expect(envToArgs({ DRAWIO_MCP_EXTENSION_PORT: "8080" })).toEqual([
+            "--extension-port",
+            "8080",
+        ]);
+    });
+    test("maps DRAWIO_MCP_HTTP_PORT", () => {
+        expect(envToArgs({ DRAWIO_MCP_HTTP_PORT: "4242" })).toEqual([
+            "--http-port",
+            "4242",
+        ]);
+    });
+    test("maps DRAWIO_MCP_TRANSPORT", () => {
+        expect(envToArgs({ DRAWIO_MCP_TRANSPORT: "stdio,http" })).toEqual([
+            "--transport",
+            "stdio,http",
+        ]);
+    });
+    test("maps DRAWIO_MCP_EDITOR true/false", () => {
+        expect(envToArgs({ DRAWIO_MCP_EDITOR: "true" })).toEqual([
+            "--editor",
+            "true",
+        ]);
+        expect(envToArgs({ DRAWIO_MCP_EDITOR: "false" })).toEqual([
+            "--editor",
+            "false",
+        ]);
+    });
+    test("ignores invalid DRAWIO_MCP_EDITOR value", () => {
+        expect(envToArgs({ DRAWIO_MCP_EDITOR: "yes" })).toEqual([]);
+    });
+    test("maps DRAWIO_MCP_ASSET_PATH", () => {
+        expect(envToArgs({ DRAWIO_MCP_ASSET_PATH: "/tmp/assets" })).toEqual([
+            "--asset-path",
+            "/tmp/assets",
+        ]);
+    });
+    test("maps DRAWIO_MCP_WEBSOCKET_URL", () => {
+        expect(envToArgs({ DRAWIO_MCP_WEBSOCKET_URL: "wss://example.com/ws" })).toEqual(["--websocket-url", "wss://example.com/ws"]);
+    });
+    test("ignores empty values", () => {
+        expect(envToArgs({
+            DRAWIO_MCP_EXTENSION_PORT: "",
+            DRAWIO_MCP_WEBSOCKET_URL: "",
+        })).toEqual([]);
+    });
+    test("maps multiple env vars together", () => {
+        expect(envToArgs({
+            DRAWIO_MCP_EXTENSION_PORT: "8080",
+            DRAWIO_MCP_WEBSOCKET_URL: "wss://example.com/ws",
+            DRAWIO_MCP_TRANSPORT: "http",
+        })).toEqual([
+            "--extension-port",
+            "8080",
+            "--transport",
+            "http",
+            "--websocket-url",
+            "wss://example.com/ws",
+        ]);
+    });
+    test("DRAWIO_MCP_HOST maps to --host", () => {
+        const result = envToArgs({ DRAWIO_MCP_HOST: "0.0.0.0" });
+        expect(result).toEqual(["--host", "0.0.0.0"]);
+    });
+    test("missing DRAWIO_MCP_HOST produces no args", () => {
+        const result = envToArgs({});
+        expect(result).toEqual([]);
+    });
+    test("DRAWIO_MCP_LOGGER maps to --logger", () => {
+        expect(envToArgs({ DRAWIO_MCP_LOGGER: "mcp-server" })).toEqual([
+            "--logger",
+            "mcp-server",
+        ]);
+    });
+    test("DRAWIO_MCP_LOGGER empty produces no args", () => {
+        expect(envToArgs({ DRAWIO_MCP_LOGGER: "" })).toEqual([]);
+    });
+});
 describe("buildConfig", () => {
     const originalArgv = process.argv;
+    const originalEnv = process.env;
+    beforeEach(() => {
+        // Strip any host-set DRAWIO_MCP_* vars so they don't leak into tests
+        const clean = { ...originalEnv };
+        for (const key of Object.keys(clean)) {
+            if (key.startsWith("DRAWIO_MCP_"))
+                delete clean[key];
+        }
+        process.env = clean;
+    });
     afterEach(() => {
         process.argv = originalArgv;
+        process.env = originalEnv;
     });
     test("uses default config with empty args", () => {
         process.argv = ["node", "script.js"];
@@ -275,6 +585,9 @@ describe("buildConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("parses custom port from argv", () => {
@@ -285,6 +598,9 @@ describe("buildConfig", () => {
             httpPort: 3000,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("parses custom http port from argv", () => {
@@ -295,6 +611,9 @@ describe("buildConfig", () => {
             httpPort: 4242,
             transports: ["stdio"],
             editorEnabled: false,
+            logger: "console",
+            tlsEnabled: false,
+            tlsAuto: false,
         });
     });
     test("returns Error for invalid config", () => {
@@ -302,4 +621,133 @@ describe("buildConfig", () => {
         const result = buildConfig();
         expect(result).toBeInstanceOf(Error);
     });
+    test("env var DRAWIO_MCP_WEBSOCKET_URL is honored", () => {
+        process.argv = ["node", "script.js"];
+        process.env = {
+            ...originalEnv,
+            DRAWIO_MCP_WEBSOCKET_URL: "wss://env.example/ws",
+        };
+        const result = buildConfig();
+        expect(result.webSocketUrl).toBe("wss://env.example/ws");
+    });
+    test("CLI flag overrides env var (last-wins)", () => {
+        process.argv = [
+            "node",
+            "script.js",
+            "--websocket-url",
+            "wss://flag.example/ws",
+        ];
+        process.env = {
+            ...originalEnv,
+            DRAWIO_MCP_WEBSOCKET_URL: "wss://env.example/ws",
+        };
+        const result = buildConfig();
+        expect(result.webSocketUrl).toBe("wss://flag.example/ws");
+    });
+    test("env var DRAWIO_MCP_EXTENSION_PORT is honored", () => {
+        process.argv = ["node", "script.js"];
+        process.env = { ...originalEnv, DRAWIO_MCP_EXTENSION_PORT: "9090" };
+        const result = buildConfig();
+        expect(result.extensionPort).toBe(9090);
+    });
+    test("CLI port overrides env var port", () => {
+        process.argv = ["node", "script.js", "--extension-port", "7777"];
+        process.env = { ...originalEnv, DRAWIO_MCP_EXTENSION_PORT: "9090" };
+        const result = buildConfig();
+        expect(result.extensionPort).toBe(7777);
+    });
+    test("env var DRAWIO_MCP_LOGGER is honored", () => {
+        process.argv = ["node", "script.js"];
+        process.env = { ...originalEnv, DRAWIO_MCP_LOGGER: "mcp-server" };
+        const result = buildConfig();
+        expect(result.logger).toBe("mcp-server");
+    });
+    test("CLI --logger overrides DRAWIO_MCP_LOGGER", () => {
+        process.argv = ["node", "script.js", "--logger", "console"];
+        process.env = { ...originalEnv, DRAWIO_MCP_LOGGER: "mcp-server" };
+        const result = buildConfig();
+        expect(result.logger).toBe("console");
+    });
+});
+describe("TLS configuration", () => {
+    it("--tls alone sets tlsEnabled with no mode", () => {
+        const cfg = parseConfig(["--tls"]);
+        expect(cfg).not.toBeInstanceOf(Error);
+        if (cfg instanceof Error)
+            return;
+        expect(cfg.tlsEnabled).toBe(true);
+        expect(cfg.tlsAuto).toBe(false);
+        expect(cfg.tlsCert).toBeUndefined();
+        expect(cfg.tlsKey).toBeUndefined();
+    });
+    it("--tls --tls-cert X --tls-key Y configures manual mode", () => {
+        const cfg = parseConfig([
+            "--tls",
+            "--tls-cert",
+            "/c.pem",
+            "--tls-key",
+            "/k.pem",
+        ]);
+        expect(cfg).not.toBeInstanceOf(Error);
+        if (cfg instanceof Error)
+            return;
+        expect(cfg.tlsEnabled).toBe(true);
+        expect(cfg.tlsCert).toBe("/c.pem");
+        expect(cfg.tlsKey).toBe("/k.pem");
+        expect(cfg.tlsAuto).toBe(false);
+    });
+    it("--tls --tls-auto configures auto mode", () => {
+        const cfg = parseConfig(["--tls", "--tls-auto"]);
+        expect(cfg).not.toBeInstanceOf(Error);
+        if (cfg instanceof Error)
+            return;
+        expect(cfg.tlsEnabled).toBe(true);
+        expect(cfg.tlsAuto).toBe(true);
+    });
+    it("--tls-dir captures override path", () => {
+        const cfg = parseConfig(["--tls", "--tls-auto", "--tls-dir", "/data/tls"]);
+        expect(cfg).not.toBeInstanceOf(Error);
+        if (cfg instanceof Error)
+            return;
+        expect(cfg.tlsDir).toBe("/data/tls");
+    });
+    it("--tls-cert without --tls-key is an error", () => {
+        expect(parseConfig(["--tls", "--tls-cert", "/c.pem"])).toBeInstanceOf(Error);
+    });
+    it("--tls-key without --tls-cert is an error", () => {
+        expect(parseConfig(["--tls", "--tls-key", "/k.pem"])).toBeInstanceOf(Error);
+    });
+    it("--tls-auto + --tls-cert is an error", () => {
+        expect(parseConfig([
+            "--tls",
+            "--tls-auto",
+            "--tls-cert",
+            "/c",
+            "--tls-key",
+            "/k",
+        ])).toBeInstanceOf(Error);
+    });
+    it("--tls-cert without --tls is an error", () => {
+        expect(parseConfig(["--tls-cert", "/c", "--tls-key", "/k"])).toBeInstanceOf(Error);
+    });
+    it("envToArgs maps DRAWIO_MCP_TLS=true to --tls", () => {
+        expect(envToArgs({ DRAWIO_MCP_TLS: "true" })).toEqual(["--tls"]);
+    });
+    it("envToArgs maps DRAWIO_MCP_TLS_AUTO=true to --tls-auto", () => {
+        expect(envToArgs({ DRAWIO_MCP_TLS_AUTO: "true" })).toEqual(["--tls-auto"]);
+    });
+    it("envToArgs maps cert/key/dir env vars to flags", () => {
+        expect(envToArgs({
+            DRAWIO_MCP_TLS_CERT: "/c.pem",
+            DRAWIO_MCP_TLS_KEY: "/k.pem",
+            DRAWIO_MCP_TLS_DIR: "/data/tls",
+        })).toEqual([
+            "--tls-cert",
+            "/c.pem",
+            "--tls-key",
+            "/k.pem",
+            "--tls-dir",
+            "/data/tls",
+        ]);
+    });
 });

package/build/emitter_bus.js

@@ -15,6 +15,9 @@ export function create_bus(log) {
                     }
                 };
                 emitter.on(bus_reply_stream, listener);
+                return () => {
+                    emitter.off(bus_reply_stream, listener);
+                };
             },
         };
         return bus;

package/build/emitter_bus.test.js

@@ -62,4 +62,11 @@ describe("create_bus", () => {
         expect(mockReply1).toHaveBeenCalledWith(matchingEvent);
         expect(mockReply2).not.toHaveBeenCalled();
     });
+    it("should allow callers to unsubscribe pending reply handlers", () => {
+        const mockReply = jest.fn();
+        const unsubscribe = bus.on_reply_from_extension("event1", mockReply);
+        unsubscribe();
+        emitter.emit(bus_reply_stream, { __event: "event1", data: "late" });
+        expect(mockReply).not.toHaveBeenCalled();
+    });
 });

package/build/index.capabilities.test.js

@@ -0,0 +1,45 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createDrawioMcpApp } from "./index.js";
+import { defaultConfig } from "./config.js";
+import { MemoryLogger } from "./real-environment/logger.js";
+describe("createDrawioMcpApp capabilities", () => {
+    let app;
+    afterEach(async () => {
+        if (app)
+            await app.close();
+    });
+    it("does not advertise logging capability when logger is console", async () => {
+        app = createDrawioMcpApp({
+            config: { ...defaultConfig(), logger: "console" },
+            log: new MemoryLogger(),
+        });
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        const server = app.createMcpServer();
+        const client = new Client({ name: "cap-test", version: "1.0.0" });
+        await Promise.all([
+            server.connect(serverTransport),
+            client.connect(clientTransport),
+        ]);
+        const capabilities = client.getServerCapabilities();
+        expect(capabilities?.logging).toBeUndefined();
+        await client.close();
+    });
+    it("advertises logging capability when logger is mcp-server", async () => {
+        app = createDrawioMcpApp({
+            config: { ...defaultConfig(), logger: "mcp-server" },
+            log: new MemoryLogger(),
+        });
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        const server = app.createMcpServer();
+        const client = new Client({ name: "cap-test", version: "1.0.0" });
+        await Promise.all([
+            server.connect(serverTransport),
+            client.connect(clientTransport),
+        ]);
+        const capabilities = client.getServerCapabilities();
+        expect(capabilities?.logging).toBeDefined();
+        expect(capabilities?.logging).toEqual(expect.objectContaining({ setLevels: true }));
+        await client.close();
+    });
+});