drawio-mcp-server 2.0.3 → 2.0.4

package/build/index.js

@@ -11,7 +11,7 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readFileSync, existsSync, statSync, readdirSync, realpathSync, } from "node:fs";
 import { WebSocket, WebSocketServer } from "ws";
-const VERSION = process.env.npm_package_version ?? "2.0.0";
+const VERSION = process.env.npm_package_version ?? "2.0.4";
 import { buildConfig, shouldShowHelp, getHttpFeatureConfig, } from "./config.js";
 import { bus_reply_stream, bus_request_stream, } from "./types.js";
 import { create_bus } from "./emitter_bus.js";
@@ -72,10 +72,12 @@ if (logger_type === "mcp_server") {
         },
     };
 }
-async function start_stdio_transport(server, log) {
+async function start_stdio_transport(createServer, log) {
+    const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     log.debug(`Draw.io MCP Server STDIO transport active`);
+    return server;
 }
 function setupCors(app) {
     app.use("*", cors({
@@ -175,28 +177,35 @@ function registerEditorRoutes(app, config, log) {
     });
     log.debug(`Draw.io editor enabled at: http://localhost:${config.httpPort}/`);
 }
-function registerMcpRoute(app) {
-    const transport = new WebStandardStreamableHTTPServerTransport();
-    app.all("/mcp", (c) => transport.handleRequest(c.req.raw));
-    return transport;
+function registerMcpRoute(app, createServer, disposeMcpServer) {
+    app.all("/mcp", async (c) => {
+        const transport = new WebStandardStreamableHTTPServerTransport();
+        const server = createServer();
+        await server.connect(transport);
+        // Remove the server from the tracking set immediately so it does not
+        // prevent garbage collection.  We intentionally do *not* call
+        // server.close() here because the response may be a long-lived SSE
+        // stream (e.g. for GET requests).  The transport / server will be
+        // collected once the response is fully consumed.
+        disposeMcpServer(server);
+        return transport.handleRequest(c.req.raw);
+    });
 }
-function createHttpApp(log, config, features) {
+function createHttpApp(log, config, features, createServer, disposeMcpServer) {
     const app = new Hono();
     setupCors(app);
     if (features.enableHealth)
         registerHealthRoute(app);
     if (features.enableConfig)
         registerConfigRoute(app, config);
-    const mcpTransport = features.enableMcp ? registerMcpRoute(app) : undefined;
+    if (features.enableMcp)
+        registerMcpRoute(app, createServer, disposeMcpServer);
     if (features.enableEditor)
         registerEditorRoutes(app, config, log);
-    return { app, mcpTransport };
+    return { app };
 }
-async function startHttpServer(server, log, httpPort, config, features) {
-    const { app, mcpTransport } = createHttpApp(log, config, features);
-    if (mcpTransport) {
-        await server.connect(mcpTransport);
-    }
+async function startHttpServer(createServer, disposeMcpServer, log, httpPort, config, features) {
+    const { app } = createHttpApp(log, config, features, createServer, disposeMcpServer);
     const httpServer = serve({
         fetch: app.fetch,
         port: httpPort,
@@ -217,28 +226,68 @@ async function startHttpServer(server, log, httpPort, config, features) {
     };
 }
 export function createDrawioMcpApp(overrides) {
-    const server = new McpServer({
-        name: "drawio-mcp-server",
-        version: VERSION,
-    }, {
-        capabilities,
-    });
-    const log = overrides?.log ??
-        (logger_type === "mcp_server"
-            ? create_server_logger(server)
-            : create_console_logger());
     const emitter = new EventEmitter();
     const conns = new Set();
-    const bus = create_bus(log)(emitter);
+    const mcpServers = new Set();
+    // Lazily resolved log — uses console logger until a server logger is
+    // explicitly requested via LOGGER_TYPE=mcp_server, in which case the
+    // first McpServer created will be used for the logger binding.
+    let _log = overrides?.log;
+    let _serverLoggerBound = false;
+    function getLog() {
+        if (_log)
+            return _log;
+        _log = create_console_logger();
+        return _log;
+    }
+    // Proxy logger that lazily resolves to the real logger, allowing the
+    // mcp_server_logger to be bound after the first McpServer is created.
+    const lazyLog = {
+        log: (level, message, ...data) => getLog().log(level, message, ...data),
+        debug: (message, ...data) => getLog().debug(message, ...data),
+    };
+    const bus = create_bus(lazyLog)(emitter);
     const id_generator = nanoid_id_generator();
     const context = {
         bus,
         id_generator,
-        log,
+        get log() {
+            return getLog();
+        },
     };
-    registerTools(server, context);
+    /**
+     * Factory: creates a new McpServer instance with all tools registered.
+     * Each transport must use its own McpServer since the MCP SDK only
+     * allows a single transport connection per Protocol instance.
+     */
+    function createMcpServer() {
+        const server = new McpServer({
+            name: "drawio-mcp-server",
+            version: VERSION,
+        }, {
+            capabilities,
+        });
+        // Bind the mcp_server logger to the first server created (if requested)
+        if (logger_type === "mcp_server" &&
+            !_serverLoggerBound &&
+            !overrides?.log) {
+            _log = create_server_logger(server);
+            _serverLoggerBound = true;
+        }
+        registerTools(server, context);
+        mcpServers.add(server);
+        return server;
+    }
+    /**
+     * Remove a previously created McpServer from the tracking set.
+     * Used by the HTTP route handler to prevent unbounded growth of
+     * the set when creating per-request servers in stateless mode.
+     */
+    function disposeMcpServer(server) {
+        mcpServers.delete(server);
+    }
     const bus_to_ws_forwarder_listener = (event) => {
-        log.debug(`[bridge] received; forwarding message to #${conns.size} clients`, event);
+        getLog().debug(`[bridge] received; forwarding message to #${conns.size} clients`, event);
         for (const ws of [...conns]) {
             if (ws.readyState !== WebSocket.OPEN) {
                 conns.delete(ws);
@@ -248,7 +297,7 @@ export function createDrawioMcpApp(overrides) {
                 ws.send(JSON.stringify(event));
             }
             catch (e) {
-                log.debug("[bridge] error forwarding request", e);
+                getLog().debug("[bridge] error forwarding request", e);
                 conns.delete(ws);
             }
         }
@@ -257,7 +306,7 @@ export function createDrawioMcpApp(overrides) {
     let wsServer;
     let httpServer;
     async function startWebSocketServer(extensionPort = 3333) {
-        log.debug(`Draw.io MCP Server (${VERSION}) starting (WebSocket extension port: ${extensionPort})`);
+        getLog().debug(`Draw.io MCP Server (${VERSION}) starting (WebSocket extension port: ${extensionPort})`);
         if (extensionPort !== 0) {
             const isPortAvailable = await checkPortAvailable(extensionPort);
             if (!isPortAvailable) {
@@ -266,25 +315,25 @@ export function createDrawioMcpApp(overrides) {
         }
         wsServer = new WebSocketServer({ port: extensionPort });
         wsServer.on("connection", (ws) => {
-            log.debug(`[ws_handler] A WebSocket client #${conns.size} connected, presumably MCP Extension!`);
+            getLog().debug(`[ws_handler] A WebSocket client #${conns.size} connected, presumably MCP Extension!`);
             conns.add(ws);
             ws.on("message", (data) => {
                 const str = typeof data === "string" ? data : data.toString();
                 try {
                     const json = JSON.parse(str);
-                    log.debug(`[ws] received from Extension`, json);
+                    getLog().debug(`[ws] received from Extension`, json);
                     emitter.emit(bus_reply_stream, json);
                 }
                 catch (error) {
-                    log.debug(`[ws] failed to parse message`, error);
+                    getLog().debug(`[ws] failed to parse message`, error);
                 }
             });
             ws.on("close", (code) => {
                 conns.delete(ws);
-                log.debug(`[ws_handler] WebSocket client closed with code ${code}`);
+                getLog().debug(`[ws_handler] WebSocket client closed with code ${code}`);
             });
             ws.on("error", (error) => {
-                log.debug(`[ws_handler] WebSocket client error`, error);
+                getLog().debug(`[ws_handler] WebSocket client error`, error);
                 conns.delete(ws);
             });
         });
@@ -292,7 +341,7 @@ export function createDrawioMcpApp(overrides) {
             const onListening = () => {
                 wsServer?.off("error", onError);
                 const address = wsServer?.address();
-                log.debug(`[start_websocket_server] Listening to port ${address?.port ?? extensionPort}`);
+                getLog().debug(`[start_websocket_server] Listening to port ${address?.port ?? extensionPort}`);
                 resolve();
             };
             const onError = (error) => {
@@ -315,7 +364,10 @@ export function createDrawioMcpApp(overrides) {
             }
         }
         conns.clear();
-        await server.close();
+        for (const s of mcpServers) {
+            await s.close();
+        }
+        mcpServers.clear();
         if (wsServer) {
             await new Promise((resolve, reject) => {
                 wsServer?.close((error) => {
@@ -342,15 +394,19 @@ export function createDrawioMcpApp(overrides) {
         }
     }
     return {
-        server,
-        log,
+        createMcpServer,
+        get log() {
+            return getLog();
+        },
         context,
         emitter,
         close,
         startWebSocketServer,
-        startStdioTransport: () => start_stdio_transport(server, log),
+        startStdioTransport: async () => {
+            await start_stdio_transport(createMcpServer, getLog());
+        },
         startHttpServer: async (httpPort, config, features) => {
-            const started = await startHttpServer(server, log, httpPort, config, features);
+            const started = await startHttpServer(createMcpServer, disposeMcpServer, getLog(), httpPort, config, features);
             httpServer = started.server;
             return started;
         },

package/build/multi-transport.test.js

@@ -0,0 +1,160 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createDrawioMcpApp } from "./index.js";
+import { MemoryLogger } from "./real-environment/logger.js";
+describe("multi-transport support", () => {
+    let app;
+    let logger;
+    beforeEach(() => {
+        logger = new MemoryLogger();
+        app = createDrawioMcpApp({ log: logger });
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("createMcpServer returns distinct instances", () => {
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        expect(server1).not.toBe(server2);
+    });
+    it("each McpServer instance has tools registered", async () => {
+        const [ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        const client1 = new Client({ name: "test-client-1", version: "1.0.0" });
+        const client2 = new Client({ name: "test-client-2", version: "1.0.0" });
+        await Promise.all([
+            server1.connect(st1),
+            client1.connect(ct1),
+            server2.connect(st2),
+            client2.connect(ct2),
+        ]);
+        const tools1 = await client1.listTools();
+        const tools2 = await client2.listTools();
+        expect(tools1.tools.length).toBeGreaterThan(0);
+        expect(tools2.tools.length).toBeGreaterThan(0);
+        const names1 = tools1.tools.map((t) => t.name).sort();
+        const names2 = tools2.tools.map((t) => t.name).sort();
+        expect(names1).toEqual(names2);
+        await client1.close();
+        await client2.close();
+    });
+    it("two InMemoryTransport connections work simultaneously without 'Already connected' error", async () => {
+        const [ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        const client1 = new Client({ name: "test-client-1", version: "1.0.0" });
+        const client2 = new Client({ name: "test-client-2", version: "1.0.0" });
+        // This is the exact scenario that was failing before the fix:
+        // connecting two transports should not throw.
+        await expect(Promise.all([
+            server1.connect(st1),
+            client1.connect(ct1),
+            server2.connect(st2),
+            client2.connect(ct2),
+        ])).resolves.not.toThrow();
+        // Both clients can independently list tools
+        const [tools1, tools2] = await Promise.all([
+            client1.listTools(),
+            client2.listTools(),
+        ]);
+        expect(tools1.tools.length).toBeGreaterThan(0);
+        expect(tools2.tools.length).toBeGreaterThan(0);
+        await client1.close();
+        await client2.close();
+    });
+    it("close() shuts down all created McpServer instances", async () => {
+        const [ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        const client1 = new Client({ name: "test-client-1", version: "1.0.0" });
+        const client2 = new Client({ name: "test-client-2", version: "1.0.0" });
+        await Promise.all([
+            server1.connect(st1),
+            client1.connect(ct1),
+            server2.connect(st2),
+            client2.connect(ct2),
+        ]);
+        // close() should succeed without errors even with multiple servers
+        await expect(app.close()).resolves.not.toThrow();
+        // After close, listing tools should fail because the servers are shut down
+        await expect(client1.listTools()).rejects.toThrow();
+        await expect(client2.listTools()).rejects.toThrow();
+    });
+    it("connecting the same McpServer instance to two transports still throws", async () => {
+        const [_ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [_ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server = app.createMcpServer();
+        await server.connect(st1);
+        // The SDK constraint hasn't changed — a single Protocol instance
+        // still rejects a second connect().
+        await expect(server.connect(st2)).rejects.toThrow(/already connected/i);
+    });
+});
+describe("HTTP transport (stateless per-request)", () => {
+    let app;
+    let logger;
+    let httpServer;
+    let port;
+    const config = {
+        extensionPort: 0,
+        httpPort: 0,
+        transports: ["http"],
+        editorEnabled: false,
+    };
+    const features = {
+        enableMcp: true,
+        enableEditor: false,
+        enableHealth: false,
+        enableConfig: false,
+    };
+    beforeEach(async () => {
+        logger = new MemoryLogger();
+        app = createDrawioMcpApp({ log: logger });
+        const started = await app.startHttpServer(0, config, features);
+        httpServer = started.server;
+        port = started.port;
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("handles a single HTTP client request", async () => {
+        const client = new Client({ name: "http-test-1", version: "1.0.0" });
+        const transport = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client.connect(transport);
+        const tools = await client.listTools();
+        expect(tools.tools.length).toBeGreaterThan(0);
+        await client.close();
+    });
+    it("handles multiple sequential HTTP client requests without reuse error", async () => {
+        // First request
+        const client1 = new Client({ name: "http-test-seq-1", version: "1.0.0" });
+        const transport1 = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client1.connect(transport1);
+        const tools1 = await client1.listTools();
+        expect(tools1.tools.length).toBeGreaterThan(0);
+        await client1.close();
+        // Second request — this was the exact scenario that triggered the
+        // "Stateless transport cannot be reused across requests" error.
+        const client2 = new Client({ name: "http-test-seq-2", version: "1.0.0" });
+        const transport2 = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client2.connect(transport2);
+        const tools2 = await client2.listTools();
+        expect(tools2.tools.length).toBeGreaterThan(0);
+        await client2.close();
+    });
+    it("close() succeeds after HTTP requests (per-request servers are cleaned up)", async () => {
+        const client = new Client({ name: "http-cleanup", version: "1.0.0" });
+        const transport = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client.connect(transport);
+        await client.listTools();
+        await client.close();
+        // close() should not hang or throw — the per-request McpServer
+        // was already disposed and removed from the tracking set.
+        await expect(app.close()).resolves.not.toThrow();
+    });
+});

package/build/real-environment/export-diagram.test.js

@@ -0,0 +1,473 @@
+import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
+import { existsSync, readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createRealEnvironmentContext, disposeRealEnvironmentContext, resetDiagram, selectCell, } from "./harness.js";
+import { expectNoBrowserErrors, expectNoServerErrors, withVerificationScreenshot, } from "./assertions.js";
+import { callToolJson, callToolRaw } from "./tools.js";
+import { expectToolSuccess } from "./test-helpers.js";
+function findText(content, substring) {
+    return content.find((item) => item.type === "text" && item.text?.includes(substring));
+}
+function parseDimensions(metaText) {
+    const match = metaText.match(/(\d+)x(\d+)/);
+    return {
+        width: match ? parseInt(match[1], 10) : 0,
+        height: match ? parseInt(match[2], 10) : 0,
+    };
+}
+async function saveArtifact(artifactRunDir, name, data) {
+    const filePath = join(artifactRunDir, name);
+    await writeFile(filePath, data);
+    return filePath;
+}
+describe("real environment/export-diagram", () => {
+    let context;
+    beforeAll(async () => {
+        context = await createRealEnvironmentContext();
+    }, 180000);
+    afterAll(async () => {
+        await disposeRealEnvironmentContext(context);
+    });
+    it("exports as XML with cell content, geometry, and style preserved", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 100,
+            y: 100,
+            width: 200,
+            height: 100,
+            text: "XML Export Cell",
+            style: "fillColor=#dae8fc;strokeColor=#6c8ebf;whiteSpace=wrap;html=1;",
+        });
+        expectToolSuccess(rectangle);
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "xml",
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-xml", "before-live-state-verification", async () => {
+            const xmlContent = findText(content, "mxGraphModel");
+            expect(xmlContent).toBeDefined();
+            const xml = xmlContent.text;
+            expect(xml).toContain("XML Export Cell");
+            expect(xml).toContain(rectangle.result.id);
+            expect(xml).toContain("fillColor=#dae8fc");
+            expect(xml).toContain("strokeColor=#6c8ebf");
+            expect(xml).toContain('width="200"');
+            expect(xml).toContain('height="100"');
+            expect(xml).toContain('x="100"');
+            expect(xml).toContain('y="100"');
+            expect(xml).toContain("mxGeometry");
+            expect(xml).toContain('vertex="1"');
+            const metaContent = findText(content, "Exported xml");
+            expect(metaContent).toBeDefined();
+            expect(metaContent.text).toContain("application/xml");
+            await saveArtifact(context.artifactRunDir, "export-xml.xml", xml);
+        });
+        await expectNoBrowserErrors(context, "export-xml");
+        await expectNoServerErrors(context, "export-xml", logCountBefore);
+    }, 180000);
+    it("exports as SVG with renderable structure and positive dimensions", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 50,
+            y: 50,
+            width: 160,
+            height: 80,
+            text: "SVG Export Cell",
+        });
+        expectToolSuccess(rectangle);
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            scale: 1,
+            border: 10,
+            background: "#f0f0f0",
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-svg", "before-live-state-verification", async () => {
+            const svgContent = findText(content, "<svg");
+            expect(svgContent).toBeDefined();
+            const svg = svgContent.text;
+            expect(svg).toContain("SVG Export Cell");
+            expect(svg).toContain("xmlns=");
+            expect(svg).toMatch(/width="\d+/);
+            expect(svg).toMatch(/height="\d+/);
+            expect(svg).toContain("</svg>");
+            const widthMatch = svg.match(/width="(\d+)/);
+            const heightMatch = svg.match(/height="(\d+)/);
+            expect(parseInt(widthMatch[1], 10)).toBeGreaterThan(0);
+            expect(parseInt(heightMatch[1], 10)).toBeGreaterThan(0);
+            const metaContent = findText(content, "Exported svg");
+            expect(metaContent).toBeDefined();
+            expect(metaContent.text).toContain("image/svg+xml");
+            const dims = parseDimensions(metaContent.text);
+            expect(dims.width).toBeGreaterThan(0);
+            expect(dims.height).toBeGreaterThan(0);
+            await saveArtifact(context.artifactRunDir, "export-svg.svg", svg);
+        });
+        await expectNoBrowserErrors(context, "export-svg");
+        await expectNoServerErrors(context, "export-svg", logCountBefore);
+    }, 180000);
+    it("exports as PNG with non-trivial image data and positive dimensions", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 80,
+            y: 80,
+            width: 140,
+            height: 70,
+            text: "PNG Export Cell",
+        });
+        expectToolSuccess(rectangle);
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "png",
+            scale: 2,
+            dpi: 150,
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-png", "before-live-state-verification", async () => {
+            const imageContent = content.find((item) => item.type === "image");
+            expect(imageContent).toBeDefined();
+            expect(imageContent.mimeType).toBe("image/png");
+            expect(imageContent.data).toBeTruthy();
+            const pngBuffer = Buffer.from(imageContent.data, "base64");
+            expect(pngBuffer[0]).toBe(0x89);
+            expect(pngBuffer[1]).toBe(0x50);
+            expect(pngBuffer[2]).toBe(0x4e);
+            expect(pngBuffer[3]).toBe(0x47);
+            expect(pngBuffer.length).toBeGreaterThan(500);
+            const metaContent = content.find((item) => item.type === "text" &&
+                item.text?.includes("Exported png"));
+            expect(metaContent).toBeDefined();
+            expect(metaContent.text).toContain("image/png");
+            const dims = parseDimensions(metaContent.text);
+            expect(dims.width).toBeGreaterThan(0);
+            expect(dims.height).toBeGreaterThan(0);
+            await saveArtifact(context.artifactRunDir, "export-png.png", pngBuffer);
+        });
+        await expectNoBrowserErrors(context, "export-png");
+        await expectNoServerErrors(context, "export-png", logCountBefore);
+    }, 180000);
+    it("exports XML to a file and file matches returned content", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 100,
+            y: 100,
+            width: 180,
+            height: 90,
+            text: "File Export Cell",
+            style: "fillColor=#ffe6cc;strokeColor=#d79b00;whiteSpace=wrap;html=1;",
+        });
+        expectToolSuccess(rectangle);
+        const exportPath = join(context.artifactRunDir, "export-xml-file.xml");
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "xml",
+            output_path: exportPath,
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-xml-file", "before-live-state-verification", async () => {
+            expect(existsSync(exportPath)).toBe(true);
+            const fileContent = readFileSync(exportPath, "utf-8");
+            expect(fileContent).toContain("mxGraphModel");
+            expect(fileContent).toContain("File Export Cell");
+            expect(fileContent).toContain(rectangle.result.id);
+            expect(fileContent).toContain("fillColor=#ffe6cc");
+            expect(fileContent).toContain('width="180"');
+            expect(fileContent).toContain('height="90"');
+            const returnedXml = findText(content, "mxGraphModel");
+            expect(returnedXml).toBeDefined();
+            expect(fileContent).toBe(returnedXml.text);
+            const savedContent = findText(content, "Saved to:");
+            expect(savedContent).toBeDefined();
+            expect(savedContent.text).toContain(exportPath);
+        });
+        await expectNoBrowserErrors(context, "export-xml-file");
+        await expectNoServerErrors(context, "export-xml-file", logCountBefore);
+    }, 180000);
+    it("exports SVG to a file with valid SVG structure", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 60,
+            y: 60,
+            width: 150,
+            height: 80,
+            text: "SVG File Cell",
+        });
+        expectToolSuccess(rectangle);
+        const exportPath = join(context.artifactRunDir, "export-svg-file.svg");
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            output_path: exportPath,
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-svg-file", "before-live-state-verification", async () => {
+            expect(existsSync(exportPath)).toBe(true);
+            const fileContent = readFileSync(exportPath, "utf-8");
+            expect(fileContent).toContain("<svg");
+            expect(fileContent).toContain("</svg>");
+            expect(fileContent).toContain("SVG File Cell");
+            expect(fileContent).toContain("xmlns=");
+            expect(fileContent).toMatch(/width="\d+/);
+            expect(fileContent).toMatch(/height="\d+/);
+            const returnedSvg = findText(content, "<svg");
+            expect(returnedSvg).toBeDefined();
+            expect(fileContent).toBe(returnedSvg.text);
+            const savedContent = findText(content, "Saved to:");
+            expect(savedContent).toBeDefined();
+        });
+        await expectNoBrowserErrors(context, "export-svg-file");
+        await expectNoServerErrors(context, "export-svg-file", logCountBefore);
+    }, 180000);
+    it("exports PNG to a file with valid PNG binary data", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 70,
+            y: 70,
+            width: 130,
+            height: 65,
+            text: "PNG File Cell",
+        });
+        expectToolSuccess(rectangle);
+        const exportPath = join(context.artifactRunDir, "export-png-file.png");
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "png",
+            output_path: exportPath,
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-png-file", "before-live-state-verification", async () => {
+            expect(existsSync(exportPath)).toBe(true);
+            const fileBuffer = readFileSync(exportPath);
+            expect(fileBuffer[0]).toBe(0x89);
+            expect(fileBuffer[1]).toBe(0x50);
+            expect(fileBuffer[2]).toBe(0x4e);
+            expect(fileBuffer[3]).toBe(0x47);
+            expect(fileBuffer.length).toBeGreaterThan(500);
+            const imageContent = content.find((item) => item.type === "image");
+            expect(imageContent).toBeDefined();
+            const returnedBuffer = Buffer.from(imageContent.data, "base64");
+            expect(fileBuffer.equals(returnedBuffer)).toBe(true);
+            const savedContent = content.find((item) => item.type === "text" &&
+                item.text?.includes("Saved to:"));
+            expect(savedContent).toBeDefined();
+        });
+        await expectNoBrowserErrors(context, "export-png-file");
+        await expectNoServerErrors(context, "export-png-file", logCountBefore);
+    }, 180000);
+    it("exports with transparent background and SVG has no background rect", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 100,
+            y: 100,
+            width: 120,
+            height: 60,
+            text: "Transparent BG",
+        });
+        expectToolSuccess(rectangle);
+        const opaqueResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            transparent: false,
+            background: "#ff0000",
+        });
+        const opaqueContent = opaqueResult.content;
+        const opaqueSvg = findText(opaqueContent, "<svg");
+        const transparentResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            transparent: true,
+        });
+        const transparentContent = transparentResult.content;
+        await withVerificationScreenshot(context, "export-transparent", "before-live-state-verification", async () => {
+            const svgContent = findText(transparentContent, "<svg");
+            expect(svgContent).toBeDefined();
+            expect(svgContent.text).toContain("Transparent BG");
+            expect(svgContent.text).toContain("</svg>");
+            expect(svgContent.text).not.toContain("#ff0000");
+            expect(opaqueSvg).toBeDefined();
+            expect(opaqueSvg.text).toContain("#ff0000");
+            const metaContent = findText(transparentContent, "Exported svg");
+            expect(metaContent).toBeDefined();
+            await saveArtifact(context.artifactRunDir, "export-transparent-opaque.svg", opaqueSvg.text);
+            await saveArtifact(context.artifactRunDir, "export-transparent-transparent.svg", svgContent.text);
+        });
+        await expectNoBrowserErrors(context, "export-transparent");
+        await expectNoServerErrors(context, "export-transparent", logCountBefore);
+    }, 180000);
+    it("exports SVG with embedded XML containing diagram data", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 90,
+            y: 90,
+            width: 150,
+            height: 75,
+            text: "Embed XML Cell",
+        });
+        expectToolSuccess(rectangle);
+        const plainResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            embed_xml: false,
+        });
+        const plainContent = plainResult.content;
+        const embeddedResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            embed_xml: true,
+        });
+        const embeddedContent = embeddedResult.content;
+        await withVerificationScreenshot(context, "export-svg-embed-xml", "before-live-state-verification", async () => {
+            const embeddedSvg = findText(embeddedContent, "Embed XML Cell");
+            expect(embeddedSvg).toBeDefined();
+            const embeddedData = embeddedSvg.text;
+            expect(embeddedData).toContain("mxGraphModel");
+            expect(embeddedData).toContain("mxfile");
+            const plainSvg = findText(plainContent, "<svg");
+            expect(plainSvg).toBeDefined();
+            expect(plainSvg.text).not.toContain("mxfile");
+            expect(embeddedData.length).toBeGreaterThan(plainSvg.text.length);
+            const metaContent = findText(embeddedContent, "Exported svg");
+            expect(metaContent).toBeDefined();
+            expect(metaContent.text).toContain("image/svg+xml");
+            await saveArtifact(context.artifactRunDir, "export-svg-plain.svg", plainSvg.text);
+            await saveArtifact(context.artifactRunDir, "export-svg-embedded.svg", embeddedData);
+        });
+        await expectNoBrowserErrors(context, "export-svg-embed-xml");
+        await expectNoServerErrors(context, "export-svg-embed-xml", logCountBefore);
+    }, 180000);
+    it("exports only the selected cell in SVG and excludes unselected cells", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: selectedRect } = await callToolJson(context, "add-rectangle", {
+            x: 100,
+            y: 100,
+            width: 140,
+            height: 70,
+            text: "Selected Cell",
+        });
+        expectToolSuccess(selectedRect);
+        const { payload: otherRect } = await callToolJson(context, "add-rectangle", {
+            x: 350,
+            y: 100,
+            width: 140,
+            height: 70,
+            text: "Unselected Cell",
+        });
+        expectToolSuccess(otherRect);
+        await selectCell(context.page, selectedRect.result.id);
+        // SVG export respects selection_only by rendering only the selected cells
+        const selectionResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+            selection_only: true,
+            size: "selection",
+        });
+        const selectionContent = selectionResult.content;
+        const fullResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+        });
+        const fullContent = fullResult.content;
+        await withVerificationScreenshot(context, "export-selection-only", "before-live-state-verification", async () => {
+            const selectionSvg = findText(selectionContent, "<svg");
+            expect(selectionSvg).toBeDefined();
+            expect(selectionSvg.text).toContain("Selected Cell");
+            expect(selectionSvg.text).not.toContain("Unselected Cell");
+            const fullSvg = findText(fullContent, "<svg");
+            expect(fullSvg).toBeDefined();
+            expect(fullSvg.text).toContain("Selected Cell");
+            expect(fullSvg.text).toContain("Unselected Cell");
+            await saveArtifact(context.artifactRunDir, "export-selection-only.svg", selectionSvg.text);
+            await saveArtifact(context.artifactRunDir, "export-selection-full.svg", fullSvg.text);
+        });
+        await expectNoBrowserErrors(context, "export-selection-only");
+        await expectNoServerErrors(context, "export-selection-only", logCountBefore);
+    }, 180000);
+    it("exports multiple cells and all appear in the output", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const cellNames = ["Alpha", "Beta", "Gamma"];
+        const cellIds = [];
+        for (let i = 0; i < cellNames.length; i++) {
+            const { payload } = await callToolJson(context, "add-rectangle", {
+                x: 50 + i * 200,
+                y: 100,
+                width: 140,
+                height: 70,
+                text: cellNames[i],
+            });
+            expectToolSuccess(payload);
+            cellIds.push(payload.result.id);
+        }
+        const xmlResult = await callToolRaw(context, "export-diagram", {
+            format: "xml",
+        });
+        const xmlContent = xmlResult.content;
+        const svgResult = await callToolRaw(context, "export-diagram", {
+            format: "svg",
+        });
+        const svgContent = svgResult.content;
+        const pngResult = await callToolRaw(context, "export-diagram", {
+            format: "png",
+        });
+        const pngContent = pngResult.content;
+        await withVerificationScreenshot(context, "export-multi-cell", "before-live-state-verification", async () => {
+            const xml = findText(xmlContent, "mxGraphModel");
+            expect(xml).toBeDefined();
+            for (const name of cellNames) {
+                expect(xml.text).toContain(name);
+            }
+            for (const id of cellIds) {
+                expect(xml.text).toContain(id);
+            }
+            const vertexMatches = xml.text.match(/vertex="1"/g);
+            expect(vertexMatches).not.toBeNull();
+            expect(vertexMatches.length).toBeGreaterThanOrEqual(cellNames.length);
+            const svg = findText(svgContent, "<svg");
+            expect(svg).toBeDefined();
+            for (const name of cellNames) {
+                expect(svg.text).toContain(name);
+            }
+            await saveArtifact(context.artifactRunDir, "export-multi-cell.xml", xml.text);
+            await saveArtifact(context.artifactRunDir, "export-multi-cell.svg", svg.text);
+            const pngImage = pngContent.find((item) => item.type === "image");
+            expect(pngImage).toBeDefined();
+            await saveArtifact(context.artifactRunDir, "export-multi-cell.png", Buffer.from(pngImage.data, "base64"));
+        });
+        await expectNoBrowserErrors(context, "export-multi-cell");
+        await expectNoServerErrors(context, "export-multi-cell", logCountBefore);
+    }, 180000);
+    it("exports an empty diagram with only root cells", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const result = await callToolRaw(context, "export-diagram", {
+            format: "xml",
+        });
+        const content = result.content;
+        await withVerificationScreenshot(context, "export-empty", "before-live-state-verification", async () => {
+            const xmlContent = findText(content, "mxGraphModel");
+            expect(xmlContent).toBeDefined();
+            const xml = xmlContent.text;
+            expect(xml).toContain("mxGraphModel");
+            expect(xml).toContain('<mxCell id="0"');
+            expect(xml).toContain('<mxCell id="1"');
+            expect(xml).not.toMatch(/vertex="1"/);
+            const metaContent = findText(content, "Exported xml");
+            expect(metaContent).toBeDefined();
+            expect(metaContent.text).toContain("application/xml");
+            await saveArtifact(context.artifactRunDir, "export-empty.xml", xml);
+        });
+        await expectNoBrowserErrors(context, "export-empty");
+        await expectNoServerErrors(context, "export-empty", logCountBefore);
+    }, 180000);
+});

package/build/real-environment/harness.js

@@ -17,7 +17,7 @@ export async function createRealEnvironmentContext() {
     const config = {
         extensionPort: wsPort,
         httpPort: 0,
-        transports: ["http"],
+        transports: [],
         editorEnabled: true,
     };
     const startedHttp = await app.startHttpServer(0, config, getHttpFeatureConfig(config));
@@ -27,8 +27,9 @@ export async function createRealEnvironmentContext() {
         name: "real-environment-test",
         version: "1.0.0",
     });
+    const testServer = app.createMcpServer();
     await Promise.all([
-        app.server.connect(serverTransport),
+        testServer.connect(serverTransport),
         client.connect(clientTransport),
     ]);
     const browser = await chromium.launch({ headless: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drawio-mcp-server",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Provides Draw.io services to MCP Clients",
   "type": "module",
   "main": "build/index.js",
@@ -31,31 +31,31 @@
     "url": "git+https://github.com/lgazo/drawio-mcp-server.git"
   },
   "dependencies": {
-    "@hono/node-server": "1.19.7",
-    "@modelcontextprotocol/sdk": "1.25.1",
-    "cachedir": "^2.4.0",
-    "hono": "4.11.1",
+    "@hono/node-server": "1.19.13",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "cachedir": "2.4.0",
+    "hono": "4.12.12",
     "nanoid": "5.1.6",
-    "unzipper": "^0.12.0",
+    "unzipper": "0.12.3",
     "ws": "8.18.3",
     "zod": "4.2.1"
   },
   "devDependencies": {
     "@jest/globals": "30.2.0",
-    "@playwright/test": "1.54.2",
+    "@playwright/test": "1.59.1",
     "@types/jest": "30.0.0",
     "@types/node": "25.0.3",
-    "@types/unzipper": "^0.10.11",
-    "@types/ws": "^8.18.1",
-    "esbuild": "^0.24.0",
+    "@types/unzipper": "0.10.11",
+    "@types/ws": "8.18.1",
+    "esbuild": "0.25.12",
     "globals": "16.5.0",
     "jest": "30.2.0",
     "jest-environment-node": "30.2.0",
     "prettier": "3.7.4",
-    "rimraf": "6.1.2",
-    "ts-jest": "29.4.6",
+    "rimraf": "6.1.3",
+    "ts-jest": "29.4.9",
     "typescript": "5.9.3",
-    "drawio-mcp-plugin": "2.0.0"
+    "drawio-mcp-plugin": "2.0.1"
   },
   "scripts": {
     "build": "rimraf build && tsc && mkdir -p build/plugin && cp node_modules/drawio-mcp-plugin/dist/mcp-plugin.js build/plugin/mcp-plugin.js",