drawio-mcp-server 2.1.1 → 2.2.0

package/build/assets/auto-refresh.js

@@ -0,0 +1,21 @@
+import { rmSync } from "node:fs";
+import { SERVER_COMPAT_MATRIX, versionInWindow, } from "../drawio-compat/matrix.js";
+export { SERVER_COMPAT_MATRIX };
+import { getAssetRoot, getCacheDir } from "./manager.js";
+import { readCachedDrawioVersion } from "./version.js";
+export async function ensureSupportedAssets(config, matrix, log, ports) {
+    const cacheDir = getCacheDir(config.assetPath);
+    const assetRoot = getAssetRoot(config);
+    const cached = await readCachedDrawioVersion(assetRoot);
+    if (cached && versionInWindow(cached, matrix)) {
+        return { version: cached, refetched: false };
+    }
+    log.log("warning", `cached drawio v${cached ?? "?"} is outside supported window (>= v${matrix.supportedFloor}); refetching latest`);
+    rmSync(assetRoot, { recursive: true, force: true });
+    await ports.downloadAndExtract(cacheDir, log);
+    const after = await readCachedDrawioVersion(assetRoot);
+    if (!after || !versionInWindow(after, matrix)) {
+        log.log("error", `drawio latest v${after ?? "?"} is still outside supported window; tools may misbehave`);
+    }
+    return { version: after, refetched: true };
+}

package/build/assets/auto-refresh.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ensureSupportedAssets } from "./auto-refresh.js";
+import { SERVER_COMPAT_MATRIX } from "../drawio-compat/matrix.js";
+function makeCachedVersion(version) {
+    const root = mkdtempSync(join(tmpdir(), "auto-refresh-"));
+    const webapp = join(root, "webapp");
+    const jsDir = join(webapp, "js");
+    mkdirSync(jsDir, { recursive: true });
+    writeFileSync(join(jsDir, "app.min.js"), `pre;EditorUi.VERSION="${version}";post`);
+    return root;
+}
+const logger = {
+    log: jest.fn(),
+};
+describe("ensureSupportedAssets", () => {
+    it("returns cached version without refetch when in range", async () => {
+        const cacheDir = makeCachedVersion("30.2.6");
+        const download = jest.fn(async () => { });
+        const result = await ensureSupportedAssets({ assetPath: cacheDir }, SERVER_COMPAT_MATRIX, logger, { downloadAndExtract: download });
+        expect(download).not.toHaveBeenCalled();
+        expect(result).toEqual({ version: "30.2.6", refetched: false });
+    });
+    it("wipes cache and re-downloads when cached is out of window", async () => {
+        const cacheDir = makeCachedVersion("28.0.0");
+        const download = jest.fn(async (target) => {
+            const jsDir = join(target, "webapp", "js");
+            mkdirSync(jsDir, { recursive: true });
+            writeFileSync(join(jsDir, "app.min.js"), `pre;EditorUi.VERSION="30.2.6";post`);
+        });
+        const result = await ensureSupportedAssets({ assetPath: cacheDir }, SERVER_COMPAT_MATRIX, logger, { downloadAndExtract: download });
+        expect(download).toHaveBeenCalled();
+        expect(result).toEqual({ version: "30.2.6", refetched: true });
+    });
+    it("logs error when refetched version is still out of window", async () => {
+        const cacheDir = makeCachedVersion("28.0.0");
+        const download = jest.fn(async (target) => {
+            const jsDir = join(target, "webapp", "js");
+            mkdirSync(jsDir, { recursive: true });
+            writeFileSync(join(jsDir, "app.min.js"), `pre;EditorUi.VERSION="28.5.0";post`);
+        });
+        const errorLogs = [];
+        const trackingLogger = {
+            log: (level, ...args) => {
+                if (level === "error")
+                    errorLogs.push(args);
+            },
+        };
+        await ensureSupportedAssets({ assetPath: cacheDir }, SERVER_COMPAT_MATRIX, trackingLogger, { downloadAndExtract: download });
+        expect(errorLogs.length).toBeGreaterThan(0);
+    });
+});

package/build/assets/downloader.js

@@ -85,11 +85,15 @@ export async function downloadAndExtractAssets(targetDir, log) {
 }
 export async function ensureAssets(config, log) {
     const { getCacheDir, getAssetRoot, assetsExist } = await import("./manager.js");
+    const { ensureSupportedAssets, SERVER_COMPAT_MATRIX } = await import("./auto-refresh.js");
     const cacheDir = getCacheDir(config.assetPath);
     const assetRoot = getAssetRoot(config);
     if (!assetsExist(config)) {
         log.log("info", `Assets not found in ${assetRoot}. Downloading...`);
         await downloadAndExtractAssets(cacheDir, log);
     }
+    await ensureSupportedAssets(config, SERVER_COMPAT_MATRIX, log, {
+        downloadAndExtract: (targetDir) => downloadAndExtractAssets(targetDir, log),
+    });
     return { assetRoot, isLocal: true };
 }

package/build/assets/version.js

@@ -0,0 +1,38 @@
+import { createReadStream, existsSync } from "node:fs";
+import { join } from "node:path";
+const CHUNK_BYTES = 1024 * 1024;
+const OVERLAP_BYTES = 64;
+const VERSION_RE = /EditorUi\.VERSION\s*=\s*"(\d+\.\d+\.\d+)"/;
+export async function readCachedDrawioVersion(assetRoot) {
+    const path = join(assetRoot, "js", "app.min.js");
+    if (!existsSync(path))
+        return null;
+    return new Promise((resolve, reject) => {
+        const stream = createReadStream(path, { highWaterMark: CHUNK_BYTES });
+        let tail = "";
+        let resolved = false;
+        const finish = (value) => {
+            if (resolved)
+                return;
+            resolved = true;
+            stream.destroy();
+            resolve(value);
+        };
+        stream.on("data", (chunk) => {
+            const text = tail + (typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+            const match = VERSION_RE.exec(text);
+            if (match) {
+                finish(match[1] ?? null);
+                return;
+            }
+            tail = text.slice(-OVERLAP_BYTES);
+        });
+        stream.on("end", () => finish(null));
+        stream.on("error", (err) => {
+            if (resolved)
+                return;
+            resolved = true;
+            reject(err);
+        });
+    });
+}

package/build/assets/version.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "@jest/globals";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { readCachedDrawioVersion } from "./version.js";
+function makeFixture(contents) {
+    const root = mkdtempSync(join(tmpdir(), "drawio-version-"));
+    const jsDir = join(root, "js");
+    mkdirSync(jsDir, { recursive: true });
+    writeFileSync(join(jsDir, "app.min.js"), contents);
+    return root;
+}
+describe("readCachedDrawioVersion", () => {
+    it("returns the version parsed from app.min.js", async () => {
+        const root = makeFixture(`prefix;EditorUi.VERSION="30.2.6";suffix`);
+        await expect(readCachedDrawioVersion(root)).resolves.toBe("30.2.6");
+    });
+    it("returns null when app.min.js is missing", async () => {
+        const root = mkdtempSync(join(tmpdir(), "drawio-version-"));
+        await expect(readCachedDrawioVersion(root)).resolves.toBeNull();
+    });
+    it("returns null when VERSION assignment is absent", async () => {
+        const root = makeFixture("no version marker here");
+        await expect(readCachedDrawioVersion(root)).resolves.toBeNull();
+    });
+});

package/build/documents-changed-broadcast.test.js

@@ -0,0 +1,123 @@
+import WebSocket from "ws";
+import { createDrawioMcpApp } from "./index.js";
+import { MemoryLogger } from "./real-environment/logger.js";
+const HOST = "127.0.0.1";
+async function waitForMessage(ws, predicate, timeoutMs = 2000) {
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            ws.off("message", onMessage);
+            reject(new Error("timeout waiting for matching WebSocket message"));
+        }, timeoutMs);
+        function onMessage(data) {
+            const text = typeof data === "string" ? data : data.toString();
+            let json;
+            try {
+                json = JSON.parse(text);
+            }
+            catch {
+                return;
+            }
+            if (predicate(json)) {
+                clearTimeout(timer);
+                ws.off("message", onMessage);
+                resolve(json);
+            }
+        }
+        ws.on("message", onMessage);
+    });
+}
+async function openClient(port) {
+    const ws = new WebSocket(`ws://${HOST}:${port}`);
+    await new Promise((resolve, reject) => {
+        ws.once("open", () => resolve());
+        ws.once("error", reject);
+    });
+    // Server sends `sync-document-state` on connect; ignore it here.
+    return ws;
+}
+describe("documents-changed broadcast", () => {
+    let app;
+    let logger;
+    let port;
+    beforeEach(async () => {
+        logger = new MemoryLogger();
+        app = createDrawioMcpApp({ log: logger });
+        const wsServer = await app.startWebSocketServer(0, HOST);
+        port = wsServer.address().port;
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("emits documents-changed after inbound document-state", async () => {
+        const ws = await openClient(port);
+        const received = waitForMessage(ws, (json) => json?.__control === "documents-changed");
+        ws.send(JSON.stringify({
+            __control: "document-state",
+            document: {
+                id: "doc-a",
+                title: "Alpha",
+                mode: "device",
+                hash: null,
+                file_url: null,
+                page_count: 1,
+                current_page: {
+                    index: 0,
+                    id: "p1",
+                    name: "Page-1",
+                    is_current: true,
+                },
+            },
+        }));
+        const payload = await received;
+        expect(payload.documents).toHaveLength(1);
+        expect(payload.documents[0].id).toBe("doc-a");
+        expect(payload.documents[0].title).toBe("Alpha");
+        ws.close();
+    });
+    it("emits documents-changed after inbound document-removed", async () => {
+        const ws = await openClient(port);
+        ws.send(JSON.stringify({
+            __control: "document-state",
+            document: {
+                id: "doc-b",
+                title: "Beta",
+                mode: "device",
+                hash: null,
+                file_url: null,
+                page_count: 1,
+                current_page: null,
+            },
+        }));
+        await waitForMessage(ws, (json) => json?.__control === "documents-changed" && json.documents.length === 1);
+        const removed = waitForMessage(ws, (json) => json?.__control === "documents-changed" && json.documents.length === 0);
+        ws.send(JSON.stringify({
+            __control: "document-removed",
+            document_id: "doc-b",
+        }));
+        const payload = await removed;
+        expect(payload.documents).toEqual([]);
+        ws.close();
+    });
+    it("emits documents-changed to remaining clients after peer disconnect", async () => {
+        const clientA = await openClient(port);
+        const clientB = await openClient(port);
+        clientA.send(JSON.stringify({
+            __control: "document-state",
+            document: {
+                id: "doc-c",
+                title: "Gamma",
+                mode: "device",
+                hash: null,
+                file_url: null,
+                page_count: 1,
+                current_page: null,
+            },
+        }));
+        await waitForMessage(clientB, (json) => json?.__control === "documents-changed" && json.documents.length === 1);
+        const drained = waitForMessage(clientB, (json) => json?.__control === "documents-changed" && json.documents.length === 0);
+        clientA.close();
+        const payload = await drained;
+        expect(payload.documents).toEqual([]);
+        clientB.close();
+    });
+});

package/build/drawio-compat/log-report.js

@@ -0,0 +1,21 @@
+export function handleCompatReport(payload, log) {
+    const v = payload.drawioVersion ?? "unknown";
+    switch (payload.state) {
+        case "ok":
+            log.log("info", `drawio v${v} is within supported window`);
+            return;
+        case "below-floor":
+            log.log("error", `drawio v${v} predates supported floor v${payload.floor}; ` +
+                `version-gated tools will return errors`);
+            return;
+        case "above-window":
+            log.log("warning", `drawio v${v} is newer than the tested window ` +
+                `(last tested min: v${payload.detail ?? "?"}); running on newest impl`);
+            return;
+        case "no-version":
+            log.log("warning", `plugin could not detect drawio version (${payload.detail ?? "?"})`);
+            return;
+        default:
+            log.log("warning", `unknown compat state \`${payload.state}\` (drawio v${v})`);
+    }
+}

package/build/drawio-compat/log-report.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "@jest/globals";
+import { handleCompatReport } from "./log-report.js";
+function makeLogger() {
+    const calls = [];
+    return {
+        calls,
+        logger: {
+            log: (lvl, msg) => calls.push([lvl, msg]),
+        },
+    };
+}
+describe("handleCompatReport", () => {
+    it("emits info for ok state", () => {
+        const { calls, logger } = makeLogger();
+        handleCompatReport({ drawioVersion: "30.2.6", state: "ok", floor: "29.0.0" }, logger);
+        expect(calls.some(([lvl]) => lvl === "info")).toBe(true);
+    });
+    it("emits error for below-floor state", () => {
+        const { calls, logger } = makeLogger();
+        handleCompatReport({ drawioVersion: "28.0.0", state: "below-floor", floor: "29.0.0" }, logger);
+        expect(calls.some(([lvl]) => lvl === "error")).toBe(true);
+    });
+    it("emits warning for above-window state", () => {
+        const { calls, logger } = makeLogger();
+        handleCompatReport({
+            drawioVersion: "31.0.0",
+            state: "above-window",
+            floor: "29.0.0",
+            detail: "30.0.0",
+        }, logger);
+        expect(calls.some(([lvl]) => lvl === "warning")).toBe(true);
+    });
+    it("emits warning for no-version state", () => {
+        const { calls, logger } = makeLogger();
+        handleCompatReport({
+            drawioVersion: null,
+            state: "no-version",
+            floor: "29.0.0",
+            detail: "missing",
+        }, logger);
+        expect(calls.some(([lvl]) => lvl === "warning")).toBe(true);
+    });
+});

package/build/drawio-compat/matrix.js

@@ -0,0 +1,14 @@
+import { isInRange, parseVersion, } from "../vendored/compat/index.js";
+export const SERVER_COMPAT_MATRIX = {
+    supportedFloor: "29.0.0",
+    supportedRanges: [
+        { min: "29.0.0", maxExclusive: "30.0.0" },
+        { min: "30.0.0", maxExclusive: null },
+    ],
+};
+export function versionInWindow(version, matrix) {
+    const parsed = parseVersion(version);
+    if (!parsed)
+        return false;
+    return matrix.supportedRanges.some((r) => isInRange(parsed, r));
+}

package/build/index.js

@@ -12,7 +12,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.1.1";
+const VERSION = process.env.npm_package_version ?? "2.2.0";
 import { buildConfig, defaultConfig, hasFlag, shouldShowHelp, getHttpFeatureConfig, } from "./config.js";
 import { installDesktopPlugin } from "./install-desktop-plugin.js";
 import { bus_reply_stream, bus_request_stream, } from "./types.js";
@@ -26,6 +26,7 @@ import { registerTools } from "./tools/index.js";
 import { createServerWithSchemaStripping } from "./register-tool.js";
 import { target_document_field } from "./tools/shared.js";
 import { resolveTlsMaterial } from "./tls/index.js";
+import { handleCompatReport } from "./drawio-compat/log-report.js";
 const fatalLog = create_console_logger();
 /**
  * Display help message and exit
@@ -320,12 +321,12 @@ export function createDrawioMcpApp(options) {
         };
     }
     function listKnownDocuments() {
-        return [...conns.values()]
-            .map((entry) => entry.document)
-            .filter((document) => document !== null);
+        return [...conns.values()].flatMap((entry) => [
+            ...entry.documents.values(),
+        ]);
     }
     function findConnectionByDocumentId(documentId) {
-        return [...conns.values()].find((entry) => entry.document?.id === documentId);
+        return [...conns.values()].find((entry) => entry.documents.has(documentId));
     }
     function flushSyncWaiters(entry) {
         for (const resolve of [...entry.sync_waiters]) {
@@ -347,6 +348,24 @@ export function createDrawioMcpApp(options) {
         }));
         return true;
     }
+    function broadcastDocumentsChanged() {
+        const documents = listKnownDocuments();
+        const frame = JSON.stringify({
+            __control: "documents-changed",
+            documents,
+        });
+        for (const entry of conns.values()) {
+            if (entry.ws.readyState !== WebSocket.OPEN) {
+                continue;
+            }
+            try {
+                entry.ws.send(frame);
+            }
+            catch (error) {
+                getLog().debug(`[ws] documents-changed send failed`, error);
+            }
+        }
+    }
     function requestDocumentSync(entry) {
         return new Promise((resolve) => {
             let settled = false;
@@ -392,13 +411,14 @@ export function createDrawioMcpApp(options) {
                     await syncAllDocuments();
                     entry = findConnectionByDocumentId(documentId);
                 }
-                if (!entry || !entry.document) {
+                const document = entry?.documents.get(documentId);
+                if (!entry || !document) {
                     throw new Error(`Document with ID ${documentId} was not found`);
                 }
                 return {
                     connection_id: entry.connection_id,
                     target_document: { id: documentId },
-                    document: entry.document,
+                    document,
                 };
             }
             await syncAllDocuments();
@@ -596,7 +616,7 @@ export function createDrawioMcpApp(options) {
             const entry = {
                 connection_id,
                 ws,
-                document: null,
+                documents: new Map(),
                 updated_at: Date.now(),
                 sync_waiters: new Set(),
             };
@@ -609,9 +629,26 @@ export function createDrawioMcpApp(options) {
                     const json = JSON.parse(str);
                     getLog().debug(`[ws] received from Extension`, json);
                     if (json?.__control === "document-state") {
-                        entry.document = normalizeDocumentState(json.document);
+                        const document = normalizeDocumentState(json.document);
+                        if (document) {
+                            entry.documents.set(document.id, document);
+                        }
                         entry.updated_at = Date.now();
                         flushSyncWaiters(entry);
+                        broadcastDocumentsChanged();
+                        return;
+                    }
+                    if (json?.__control === "document-removed") {
+                        const removedId = normalizeOptionalString(json.document_id);
+                        if (removedId) {
+                            entry.documents.delete(removedId);
+                            entry.updated_at = Date.now();
+                            broadcastDocumentsChanged();
+                        }
+                        return;
+                    }
+                    if (json?.__control === "compat-report") {
+                        handleCompatReport(json, getLog());
                         return;
                     }
                     emitter.emit(bus_reply_stream, json);
@@ -623,12 +660,14 @@ export function createDrawioMcpApp(options) {
             ws.on("close", (code) => {
                 flushSyncWaiters(entry);
                 conns.delete(connection_id);
+                broadcastDocumentsChanged();
                 getLog().debug(`[ws_handler] WebSocket client ${connection_id} closed with code ${code}`);
             });
             ws.on("error", (error) => {
                 getLog().debug(`[ws_handler] WebSocket client error`, error);
                 flushSyncWaiters(entry);
                 conns.delete(connection_id);
+                broadcastDocumentsChanged();
             });
         });
         if (!tlsMaterial) {
@@ -652,22 +691,44 @@ export function createDrawioMcpApp(options) {
         return wsServer;
     }
     async function close() {
+        getLog().debug(`[close] begin`);
         emitter.off(bus_request_stream, bus_to_ws_forwarder_listener);
+        // ws.close() is graceful and waits for the peer close frame; a dead or
+        // slow peer keeps the underlying TCP socket alive, which in turn keeps
+        // the ws server's internal http.Server from firing its close callback.
+        // terminate() destroys the socket immediately.
         for (const entry of [...conns.values()]) {
             try {
                 flushSyncWaiters(entry);
-                entry.ws.close();
+                entry.ws.terminate();
             }
             catch {
                 // ignore
             }
         }
         conns.clear();
+        getLog().debug(`[close] tracked ws clients terminated`);
         for (const s of mcpServers) {
             await s.close();
         }
         mcpServers.clear();
+        getLog().debug(`[close] mcp servers closed`);
         if (wsServer) {
+            // Also terminate any straggler clients that connected but never
+            // completed our handshake (not in `conns`).
+            for (const client of wsServer.clients) {
+                try {
+                    client.terminate();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            // For port-created WebSocketServer, `_server` is the underlying
+            // http.Server; force-close any lingering TCP connections so its
+            // close() callback fires promptly.
+            const internal = wsServer._server;
+            internal?.closeAllConnections?.();
             await new Promise((resolve, reject) => {
                 wsServer?.close((error) => {
                     if (error) {
@@ -678,6 +739,7 @@ export function createDrawioMcpApp(options) {
                 });
             });
             wsServer = undefined;
+            getLog().debug(`[close] wsServer closed`);
         }
         if (wssHttpsServer) {
             const hs = wssHttpsServer;
@@ -687,8 +749,13 @@ export function createDrawioMcpApp(options) {
             // WebSocket upgrade) so the server closes immediately.
             hs.closeAllConnections?.();
             await new Promise((resolve) => hs.close(() => resolve()));
+            getLog().debug(`[close] wssHttpsServer closed`);
         }
         if (httpServer) {
+            // Node http.Server.close() waits for keep-alive TCP sockets to drain;
+            // MCP HTTP clients keep them open. Force them shut like wssHttpsServer.
+            const hs = httpServer;
+            hs.closeAllConnections?.();
             await new Promise((resolve, reject) => {
                 httpServer?.close((error) => {
                     if (error) {
@@ -699,7 +766,9 @@ export function createDrawioMcpApp(options) {
                 });
             });
             httpServer = undefined;
+            getLog().debug(`[close] httpServer closed`);
         }
+        getLog().debug(`[close] done`);
     }
     return {
         createMcpServer,
@@ -772,8 +841,41 @@ async function main() {
         app.log.debug("Assets ready!");
     }
     await app.startWebSocketServer(config.extensionPort, config.host);
+    let shuttingDown = false;
+    const shutdown = async (reason) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        app.log.debug(`[shutdown] triggered by ${reason}`);
+        try {
+            await app.close();
+        }
+        catch (error) {
+            app.log.log("error", "[shutdown] error while closing app", error);
+        }
+        process.exit(0);
+    };
+    process.on("SIGTERM", () => {
+        void shutdown("SIGTERM");
+    });
+    process.on("SIGINT", () => {
+        void shutdown("SIGINT");
+    });
+    process.on("SIGHUP", () => {
+        void shutdown("SIGHUP");
+    });
     if (config.transports.indexOf("stdio") > -1) {
         await app.startStdioTransport();
+        // MCP hosts (e.g. Claude Desktop on Windows) signal disconnect by
+        // closing the stdio pipe rather than sending a POSIX signal. Without
+        // this, the WebSocket server keeps the event loop alive and port
+        // 3333 leaks across host restarts.
+        process.stdin.once("end", () => {
+            void shutdown("stdin-end");
+        });
+        process.stdin.once("close", () => {
+            void shutdown("stdin-close");
+        });
     }
     await app.startHttpServer(config.httpPort, config, features);
     app.log.debug(`Draw.io MCP Server running on ${config.transports}`);

package/build/plugin/mcp-plugin.js

@@ -224,94 +224,6 @@ var DrawMcp = (() => {
       );
     }
   }
-  function import_mermaid(ui2, options) {
-    const opts = options;
-    const mermaidSource = opts.mermaid_source;
-    const mode = opts.mode ?? "native";
-    const insertMode = opts.insert_mode ?? "add";
-    if (!mermaidSource || typeof mermaidSource !== "string") {
-      return Promise.resolve({
-        success: false,
-        message: "mermaid_source must be a non-empty string"
-      });
-    }
-    if (typeof ui2?.parseMermaidDiagram !== "function") {
-      return Promise.resolve({
-        success: false,
-        message: "ui.parseMermaidDiagram is not available; this Draw.io build does not expose Mermaid support."
-      });
-    }
-    const enableParser = mode === "native";
-    return new Promise((resolve) => {
-      let settled = false;
-      const settle = (result) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        resolve(result);
-      };
-      try {
-        ui2.parseMermaidDiagram(
-          mermaidSource,
-          void 0,
-          (xml) => {
-            if (!xml || typeof xml !== "string") {
-              settle({
-                success: false,
-                message: "Mermaid parser returned empty XML"
-              });
-              return;
-            }
-            try {
-              const importResult = import_diagram(ui2, {
-                data: xml,
-                format: "xml",
-                mode: insertMode
-              });
-              if (!importResult.success) {
-                settle({
-                  success: false,
-                  message: `Mermaid converted, but inserting into the diagram failed: ${importResult.message}`
-                });
-                return;
-              }
-              settle({
-                success: true,
-                mode,
-                message: importResult.message,
-                cells: importResult.cells,
-                xml
-              });
-            } catch (err) {
-              settle({
-                success: false,
-                message: `Insert after Mermaid conversion failed: ${err instanceof Error ? err.message : String(err)}`
-              });
-            }
-          },
-          (err) => {
-            settle({
-              success: false,
-              message: `Mermaid render failed: ${err?.message ?? String(err)}`
-            });
-          },
-          (err) => {
-            settle({
-              success: false,
-              message: `Mermaid parse error: ${err?.message ?? String(err)}`
-            });
-          },
-          enableParser
-        );
-      } catch (err) {
-        settle({
-          success: false,
-          message: `parseMermaidDiagram threw: ${err instanceof Error ? err.message : String(err)}`
-        });
-      }
-    });
-  }
   function transform_NamedNodeMap_to_record(attributes) {
     const tstr = Object.prototype.toString.call(attributes);
     if (tstr !== "[object NamedNodeMap]") {
@@ -2304,6 +2216,271 @@ var DrawMcp = (() => {
     return s.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "default";
   }
 
+  // ../drawio-mcp-compat/dist/index.js
+  var SEMVER_HEAD = /^(\d+)\.(\d+)\.(\d+)/;
+  function parseVersion(raw) {
+    const m = SEMVER_HEAD.exec(raw);
+    if (!m)
+      return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+  }
+  function compareVersion(a, b) {
+    for (let i = 0; i < 3; i++) {
+      if (a[i] < b[i])
+        return -1;
+      if (a[i] > b[i])
+        return 1;
+    }
+    return 0;
+  }
+  function isBelowFloor(v, floor) {
+    const parsed = parseVersion(floor);
+    if (!parsed)
+      return false;
+    return compareVersion(v, parsed) < 0;
+  }
+  function isInRange(v, r) {
+    const min = parseVersion(r.min);
+    if (!min)
+      return false;
+    if (compareVersion(v, min) < 0)
+      return false;
+    if (r.maxExclusive === null)
+      return true;
+    const max = parseVersion(r.maxExclusive);
+    if (!max)
+      return true;
+    return compareVersion(v, max) < 0;
+  }
+
+  // src/drawio-compat/detect.ts
+  function detectDrawioVersion(ui2) {
+    const raw = globalThis.EditorUi?.VERSION ?? ui2?.constructor?.VERSION;
+    if (typeof raw !== "string") {
+      return { ok: false, reason: "missing", raw: null };
+    }
+    const semver = parseVersion(raw);
+    if (!semver) return { ok: false, reason: "unparseable", raw };
+    return { ok: true, raw, semver };
+  }
+  var cached = null;
+  function getDetectedDrawioVersion(ui2) {
+    if (cached !== null) return cached;
+    const result = detectDrawioVersion(ui2);
+    if (result.ok) cached = result;
+    return result;
+  }
+
+  // src/drawio-compat/dispatch.ts
+  function dispatchTool(toolName, detected, matrix) {
+    const entries = matrix.versionedTools[toolName];
+    if (!entries || entries.length === 0) return null;
+    if (!detected.ok) {
+      return { kind: "no-version", reason: detected.reason };
+    }
+    if (isBelowFloor(detected.semver, matrix.supportedFloor)) {
+      return {
+        kind: "below-floor",
+        floor: matrix.supportedFloor,
+        detected: detected.raw
+      };
+    }
+    for (const entry of entries) {
+      if (isInRange(detected.semver, entry.range)) {
+        return { kind: "matched", impl: entry.impl };
+      }
+    }
+    const sorted = [...entries].sort((a, b) => {
+      const am = parseVersion(a.range.min);
+      const bm = parseVersion(b.range.min);
+      return compareVersion(am, bm);
+    });
+    return {
+      kind: "above-window",
+      lastRangeMin: sorted.at(-1).range.min,
+      detected: detected.raw
+    };
+  }
+
+  // src/tools/import-mermaid/shared.ts
+  function validateOptions(options) {
+    const opts = options;
+    const source = opts.mermaid_source;
+    if (!source || typeof source !== "string") {
+      return {
+        success: false,
+        message: "mermaid_source must be a non-empty string"
+      };
+    }
+    return {
+      source,
+      mode: opts.mode ?? "native",
+      insertMode: opts.insert_mode ?? "add"
+    };
+  }
+  function runInsertFlow(ui2, mode, insertMode, resolve) {
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    const onXml = (xml) => {
+      if (!xml || typeof xml !== "string") {
+        settle({ success: false, message: "Mermaid parser returned empty XML" });
+        return;
+      }
+      try {
+        const importResult = import_diagram(ui2, {
+          data: xml,
+          format: "xml",
+          mode: insertMode
+        });
+        if (!importResult.success) {
+          settle({
+            success: false,
+            message: `Mermaid converted, but inserting into the diagram failed: ${importResult.message}`
+          });
+          return;
+        }
+        settle({
+          success: true,
+          mode,
+          message: importResult.message,
+          cells: importResult.cells,
+          xml
+        });
+      } catch (err) {
+        settle({
+          success: false,
+          message: `Insert after Mermaid conversion failed: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    };
+    const onError = (err) => {
+      settle({
+        success: false,
+        message: `Mermaid render failed: ${err?.message ?? String(err)}`
+      });
+    };
+    return { onXml, onError };
+  }
+
+  // src/tools/import-mermaid/v29.ts
+  function import_mermaid(ui2, options) {
+    const validated = validateOptions(options);
+    if ("success" in validated) return Promise.resolve(validated);
+    const { source, mode, insertMode } = validated;
+    if (typeof ui2?.parseMermaidDiagram !== "function") {
+      return Promise.resolve({
+        success: false,
+        message: "ui.parseMermaidDiagram is not available; this Draw.io build does not expose Mermaid support."
+      });
+    }
+    const enableParser = mode === "native";
+    return new Promise((resolve) => {
+      const { onXml, onError } = runInsertFlow(ui2, mode, insertMode, resolve);
+      try {
+        ui2.parseMermaidDiagram(
+          source,
+          void 0,
+          onXml,
+          onError,
+          onError,
+          enableParser
+        );
+      } catch (err) {
+        resolve({
+          success: false,
+          message: `parseMermaidDiagram threw: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    });
+  }
+
+  // src/tools/import-mermaid/v30.ts
+  function import_mermaid2(ui2, options) {
+    const validated = validateOptions(options);
+    if ("success" in validated) return Promise.resolve(validated);
+    const { source, mode, insertMode } = validated;
+    if (typeof ui2?.parseMermaidDiagram !== "function") {
+      return Promise.resolve({
+        success: false,
+        message: "ui.parseMermaidDiagram is not available; this Draw.io build does not expose Mermaid support."
+      });
+    }
+    return new Promise((resolve) => {
+      const { onXml, onError } = runInsertFlow(ui2, mode, insertMode, resolve);
+      try {
+        if (mode === "embed" && typeof ui2.parseMermaidImage === "function") {
+          ui2.parseMermaidImage(source, onXml, onError);
+        } else {
+          ui2.parseMermaidDiagram(source, void 0, onXml, onError, onError);
+        }
+      } catch (err) {
+        resolve({
+          success: false,
+          message: `Mermaid API threw: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    });
+  }
+
+  // src/drawio-compat/matrix.ts
+  var COMPAT_MATRIX = {
+    supportedFloor: "29.0.0",
+    versionedTools: {
+      "import-mermaid": [
+        {
+          range: { min: "29.0.0", maxExclusive: "30.0.0" },
+          impl: import_mermaid
+        },
+        {
+          range: { min: "30.0.0", maxExclusive: null },
+          impl: import_mermaid2
+        }
+      ]
+    }
+  };
+
+  // src/tools/import-mermaid/index.ts
+  var TOOL_NAME = "import-mermaid";
+  function import_mermaid3(ui2, options) {
+    const detected = getDetectedDrawioVersion(ui2);
+    const outcome = dispatchTool(TOOL_NAME, detected, COMPAT_MATRIX);
+    if (outcome === null) {
+      return Promise.resolve({
+        success: false,
+        message: `import-mermaid has no matrix entry; refusing to guess.`
+      });
+    }
+    switch (outcome.kind) {
+      case "matched":
+        return outcome.impl(ui2, options);
+      case "above-window": {
+        const entries = COMPAT_MATRIX.versionedTools[TOOL_NAME] ?? [];
+        const fallback = entries.at(-1);
+        if (!fallback) {
+          return Promise.resolve({
+            success: false,
+            message: `no impl available for drawio v${outcome.detected}`
+          });
+        }
+        return fallback.impl(ui2, options);
+      }
+      case "below-floor":
+        return Promise.resolve({
+          success: false,
+          message: `drawio v${outcome.detected} predates supported floor v${outcome.floor}. Upgrade drawio.`
+        });
+      case "no-version":
+        return Promise.resolve({
+          success: false,
+          message: `cannot detect drawio version (${outcome.reason}); pin a supported drawio build.`
+        });
+    }
+  }
+
   // src/tool-registry.ts
   var VISIBLE_PAGE_EXECUTION = {
     mode: "visible-page"
@@ -2583,7 +2760,7 @@ var DrawMcp = (() => {
     page_tool({
       name: "import-mermaid",
       params: /* @__PURE__ */ new Set(["mermaid_source", "mode", "insert_mode", "target_page"]),
-      handler: import_mermaid,
+      handler: import_mermaid3,
       pageExecution: VISIBLE_PAGE_MUTATION_EXECUTION,
       skip: skip_page_execution_for_new_page_mermaid
     }),
@@ -2621,6 +2798,61 @@ var DrawMcp = (() => {
     })
   );
 
+  // src/drawio-compat/report.ts
+  function computeCompatReport(matrix = COMPAT_MATRIX) {
+    const detected = getDetectedDrawioVersion();
+    if (!detected.ok) {
+      return {
+        drawioVersion: detected.raw,
+        state: "no-version",
+        floor: matrix.supportedFloor,
+        detail: detected.reason
+      };
+    }
+    if (isBelowFloor(detected.semver, matrix.supportedFloor)) {
+      return {
+        drawioVersion: detected.raw,
+        state: "below-floor",
+        floor: matrix.supportedFloor
+      };
+    }
+    const anyBounded = Object.values(matrix.versionedTools).some(
+      (entries) => entries.at(-1)?.range.maxExclusive !== null
+    );
+    if (anyBounded) {
+      const boundedFor = Object.entries(matrix.versionedTools).filter(
+        ([, entries]) => entries.at(-1)?.range.maxExclusive !== null
+      );
+      for (const [, entries] of boundedFor) {
+        const newest = entries.at(-1);
+        const max = parseVersion(newest.range.maxExclusive);
+        if (max) {
+          if (detected.semver[0] > max[0] || detected.semver[0] === max[0] && detected.semver[1] > max[1] || detected.semver[0] === max[0] && detected.semver[1] === max[1] && detected.semver[2] >= max[2]) {
+            return {
+              drawioVersion: detected.raw,
+              state: "above-window",
+              floor: matrix.supportedFloor,
+              detail: newest.range.min
+            };
+          }
+        }
+      }
+    }
+    return {
+      drawioVersion: detected.raw,
+      state: "ok",
+      floor: matrix.supportedFloor
+    };
+  }
+  function sendCompatReport(send, log = console.log.bind(console)) {
+    const report = computeCompatReport();
+    send({ __control: "compat-report", ...report });
+    log(
+      `[drawio-mcp] drawio version: ${report.drawioVersion ?? "unknown"} \u2014 compat state: ${report.state} (floor: ${report.floor})`
+    );
+    return report;
+  }
+
   // src/bootstrap.ts
   var SHAPE_EXTRACTION_MAX_ATTEMPTS = 10;
   var SHAPE_EXTRACTION_INTERVAL_MS = 1e3;
@@ -2822,6 +3054,7 @@ var DrawMcp = (() => {
         cleanups.push(() => clearInterval(intervalId));
       }
     }
+    sendCompatReport(transport2.send.bind(transport2));
     return {
       syncDocumentState,
       dispose: () => {

package/build/stdio-shutdown.test.js

@@ -0,0 +1,149 @@
+import { afterEach, describe, expect, it } from "@jest/globals";
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import WebSocket from "ws";
+async function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = createServer();
+        srv.once("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            if (addr && typeof addr === "object") {
+                const port = addr.port;
+                srv.close(() => resolve(port));
+            }
+            else {
+                srv.close(() => reject(new Error("could not resolve free port")));
+            }
+        });
+    });
+}
+async function isPortFree(port, host = "127.0.0.1") {
+    return new Promise((resolve) => {
+        const srv = createServer();
+        srv.once("error", () => resolve(false));
+        srv.listen({ port, host }, () => {
+            srv.close(() => resolve(true));
+        });
+    });
+}
+async function waitForPortHeld(port, host, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const free = await isPortFree(port, host);
+        if (!free)
+            return true;
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    return false;
+}
+async function waitForExit(proc, timeoutMs) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), timeoutMs);
+        proc.once("exit", (code) => {
+            clearTimeout(timer);
+            resolve(code ?? 0);
+        });
+    });
+}
+const here = dirname(fileURLToPath(import.meta.url));
+const SERVER_BIN = join(here, "index.js");
+const HOST = "127.0.0.1";
+function spawnServer(extensionPort, httpPort, transport = "stdio") {
+    return spawn(process.execPath, [
+        SERVER_BIN,
+        "--transport",
+        transport,
+        "--extension-port",
+        String(extensionPort),
+        "--http-port",
+        String(httpPort),
+        "--host",
+        HOST,
+    ], { stdio: ["pipe", "pipe", "pipe"] });
+}
+describe("graceful shutdown releases WebSocket port", () => {
+    let proc;
+    afterEach(async () => {
+        if (proc && !proc.killed) {
+            proc.kill("SIGKILL");
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        proc = undefined;
+    });
+    it("releases extension port after SIGTERM", async () => {
+        const extensionPort = await getFreePort();
+        const httpPort = await getFreePort();
+        proc = spawnServer(extensionPort, httpPort);
+        const portTaken = await waitForPortHeld(extensionPort, HOST, 5000);
+        expect(portTaken).toBe(true);
+        proc.kill("SIGTERM");
+        const exitCode = await waitForExit(proc, 5000);
+        expect(exitCode).not.toBeNull();
+        const free = await isPortFree(extensionPort, HOST);
+        expect(free).toBe(true);
+    }, 20000);
+    it("releases extension port after SIGINT", async () => {
+        const extensionPort = await getFreePort();
+        const httpPort = await getFreePort();
+        proc = spawnServer(extensionPort, httpPort);
+        const portTaken = await waitForPortHeld(extensionPort, HOST, 5000);
+        expect(portTaken).toBe(true);
+        proc.kill("SIGINT");
+        const exitCode = await waitForExit(proc, 5000);
+        expect(exitCode).not.toBeNull();
+        const free = await isPortFree(extensionPort, HOST);
+        expect(free).toBe(true);
+    }, 20000);
+    it("releases HTTP and extension ports after SIGTERM in http transport", async () => {
+        const extensionPort = await getFreePort();
+        const httpPort = await getFreePort();
+        proc = spawnServer(extensionPort, httpPort, "http");
+        const extTaken = await waitForPortHeld(extensionPort, HOST, 5000);
+        const httpTaken = await waitForPortHeld(httpPort, HOST, 5000);
+        expect(extTaken).toBe(true);
+        expect(httpTaken).toBe(true);
+        proc.kill("SIGTERM");
+        const exitCode = await waitForExit(proc, 5000);
+        expect(exitCode).not.toBeNull();
+        expect(await isPortFree(extensionPort, HOST)).toBe(true);
+        expect(await isPortFree(httpPort, HOST)).toBe(true);
+    }, 20000);
+    it("releases extension port after SIGINT with a live WebSocket client", async () => {
+        const extensionPort = await getFreePort();
+        const httpPort = await getFreePort();
+        proc = spawnServer(extensionPort, httpPort);
+        const portTaken = await waitForPortHeld(extensionPort, HOST, 5000);
+        expect(portTaken).toBe(true);
+        const ws = new WebSocket(`ws://${HOST}:${extensionPort}`);
+        await new Promise((resolve, reject) => {
+            ws.once("open", () => resolve());
+            ws.once("error", reject);
+        });
+        proc.kill("SIGINT");
+        const exitCode = await waitForExit(proc, 5000);
+        expect(exitCode).not.toBeNull();
+        try {
+            ws.terminate();
+        }
+        catch {
+            // ignore
+        }
+        const free = await isPortFree(extensionPort, HOST);
+        expect(free).toBe(true);
+    }, 20000);
+    it("releases extension port when stdio host closes stdin pipe", async () => {
+        const extensionPort = await getFreePort();
+        const httpPort = await getFreePort();
+        proc = spawnServer(extensionPort, httpPort);
+        const portTaken = await waitForPortHeld(extensionPort, HOST, 5000);
+        expect(portTaken).toBe(true);
+        proc.stdin.end();
+        const exitCode = await waitForExit(proc, 5000);
+        expect(exitCode).not.toBeNull();
+        const free = await isPortFree(extensionPort, HOST);
+        expect(free).toBe(true);
+    }, 20000);
+});

package/build/vendored/compat/index.js

@@ -0,0 +1,35 @@
+const SEMVER_HEAD = /^(\d+)\.(\d+)\.(\d+)/;
+export function parseVersion(raw) {
+    const m = SEMVER_HEAD.exec(raw);
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+export function compareVersion(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] < b[i])
+            return -1;
+        if (a[i] > b[i])
+            return 1;
+    }
+    return 0;
+}
+export function isBelowFloor(v, floor) {
+    const parsed = parseVersion(floor);
+    if (!parsed)
+        return false;
+    return compareVersion(v, parsed) < 0;
+}
+export function isInRange(v, r) {
+    const min = parseVersion(r.min);
+    if (!min)
+        return false;
+    if (compareVersion(v, min) < 0)
+        return false;
+    if (r.maxExclusive === null)
+        return true;
+    const max = parseVersion(r.maxExclusive);
+    if (!max)
+        return true;
+    return compareVersion(v, max) < 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drawio-mcp-server",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Provides Draw.io services to MCP Clients",
   "type": "module",
   "main": "build/index.js",
@@ -34,7 +34,7 @@
     "@hono/node-server": "1.19.13",
     "@modelcontextprotocol/sdk": "1.29.0",
     "cachedir": "2.4.0",
-    "hono": "4.12.23",
+    "hono": "4.12.25",
     "nanoid": "5.1.6",
     "node-forge": "1.4.0",
     "unzipper": "0.12.3",
@@ -60,15 +60,16 @@
     "ts-jest": "29.4.9",
     "typescript": "5.9.3",
     "drawio-mcp-dev-proxy": "1.0.0",
-    "drawio-mcp-plugin": "2.1.0"
+    "drawio-mcp-plugin": "2.2.0"
   },
   "scripts": {
-    "build": "rimraf build && tsc && mkdir -p build/plugin && cp node_modules/drawio-mcp-plugin/dist/mcp-plugin.js build/plugin/mcp-plugin.js",
+    "vendor:compat": "rimraf src/vendored/compat && mkdir -p src/vendored/compat && cp ../drawio-mcp-compat/src/index.ts src/vendored/compat/index.ts",
+    "build": "pnpm run vendor:compat && rimraf build && tsc && mkdir -p build/plugin && cp node_modules/drawio-mcp-plugin/dist/mcp-plugin.js build/plugin/mcp-plugin.js",
     "ci": "pnpm install --frozen-lockfile",
-    "dev": "tsc --watch",
-    "dev:server": "concurrently --kill-others-on-fail -n tsc,node -c cyan,green \"tsc --watch --preserveWatchOutput\" \"node --watch --watch-path=build build/index.js\"",
+    "dev": "pnpm run vendor:compat && tsc --watch",
+    "dev:server": "pnpm run vendor:compat && concurrently --kill-others-on-fail -n tsc,node -c cyan,green \"tsc --watch --preserveWatchOutput\" \"node --watch --watch-path=build build/index.js\"",
     "inspect": "HOST=0.0.0.0 pnpx @modelcontextprotocol/inspector --config ./inspector.json --server drawio",
-    "lint": "biome check src/ && tsc --noEmit",
+    "lint": "pnpm run vendor:compat && biome check src/ && tsc --noEmit",
     "lint:fix": "biome check --write src/",
     "prefetch-assets": "node build/prefetch-assets.js",
     "format": "prettier --write \"**/*.ts\"",