drawio-mcp-server 2.1.1 → 2.3.0

package/build/stdio-shutdown.test.js

@@ -0,0 +1,177 @@
+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("keeps the HTTP port free in stdio-only mode", async () => {
+        const extensionPort = await getFreePort();
+        const httpPort = await getFreePort();
+        proc = spawnServer(extensionPort, httpPort);
+        const portTaken = await waitForPortHeld(extensionPort, HOST, 5000);
+        expect(portTaken).toBe(true);
+        // Give any (wrongly) eager HTTP listener time to bind before asserting.
+        await new Promise((r) => setTimeout(r, 1000));
+        expect(await isPortFree(httpPort, HOST)).toBe(true);
+    }, 20000);
+    it("exits fatally when the HTTP port cannot be bound in http transport", async () => {
+        const extensionPort = await getFreePort();
+        // Occupy the HTTP port so the server's bind attempt fails.
+        const blocker = createServer();
+        await new Promise((resolve) => {
+            blocker.listen({ port: 0, host: HOST }, () => resolve());
+        });
+        const takenPort = blocker.address().port;
+        proc = spawnServer(extensionPort, takenPort, "http");
+        let stderr = "";
+        proc.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        const exitCode = await waitForExit(proc, 10000);
+        expect(exitCode).toBe(1);
+        expect(stderr).toContain("Failed to bind HTTP server");
+        blocker.close();
+    }, 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/tool-registry.test.js

@@ -20,6 +20,8 @@ describe("shared tool registry", () => {
             "create-page",
             "copy-page",
             "rename-page",
+            "set-document-title",
+            "save-document",
             "import-mermaid",
         ]));
     });
@@ -38,6 +40,9 @@ describe("shared tool registry", () => {
         expect(registry.get("list-paged-model")?.params.has("target_document")).toBe(true);
         expect(registry.get("rename-page")?.params.has("page")).toBe(true);
         expect(registry.get("rename-page")?.params.has("target_document")).toBe(true);
+        expect(registry.get("set-document-title")?.params.has("title")).toBe(true);
+        expect(registry.get("set-document-title")?.params.has("target_document")).toBe(true);
+        expect(registry.get("save-document")?.params.has("target_document")).toBe(true);
         expect(registry.get("copy-page")?.params.has("page")).toBe(true);
         expect(registry.get("copy-page")?.params.has("target_document")).toBe(true);
         expect(registry.get("import-mermaid")?.params.has("target_page")).toBe(true);
@@ -45,6 +50,58 @@ describe("shared tool registry", () => {
         expect(registry.get("get-shape-by-name")?.params.has("target_page")).toBe(false);
         expect(registry.get("get-shape-by-name")?.params.has("target_document")).toBe(true);
     });
+    it("renames the current document while preserving its file extension", async () => {
+        await activateDocument();
+        const toolDefinitions = await loadToolDefinitions();
+        const registry = new Map(toolDefinitions.map((definition) => [definition.name, definition]));
+        const handler = registry.get("set-document-title")?.handler;
+        expect(handler).toBeDefined();
+        let title = "Untitled Diagram.drawio";
+        const rename = jest.fn((nextTitle, success, _error) => {
+            title = nextTitle;
+            success();
+        });
+        const ui = {
+            getCurrentFile: jest.fn(() => ({
+                getTitle: () => title,
+                rename,
+            })),
+        };
+        await expect(handler?.(ui, {
+            target_document: { id: "doc-1" },
+            title: "Architecture",
+        })).resolves.toEqual({
+            previous_title: "Untitled Diagram.drawio",
+            title: "Architecture.drawio",
+        });
+        expect(rename).toHaveBeenCalledWith("Architecture.drawio", expect.any(Function), expect.any(Function));
+    });
+    it("triggers the editor's existing save action", async () => {
+        await activateDocument();
+        const toolDefinitions = await loadToolDefinitions();
+        const registry = new Map(toolDefinitions.map((definition) => [definition.name, definition]));
+        const handler = registry.get("save-document")?.handler;
+        expect(handler).toBeDefined();
+        const save = jest.fn();
+        const ui = {
+            actions: {
+                get: jest.fn((name) => name === "save" ? { funct: save } : null),
+            },
+            getCurrentFile: jest.fn(() => ({
+                getTitle: () => "Architecture.drawio",
+                getMode: () => "device",
+            })),
+        };
+        expect(handler?.(ui, {
+            target_document: { id: "doc-1" },
+        })).toEqual({
+            triggered: true,
+            title: "Architecture.drawio",
+            mode: "device",
+        });
+        expect(ui.actions.get).toHaveBeenCalledWith("save");
+        expect(save).toHaveBeenCalledTimes(1);
+    });
     it("classifies background-safe and UI-bound page tools in the shared registry", async () => {
         const toolDefinitions = await loadToolDefinitions();
         const registry = new Map(toolDefinitions.map((definition) => [definition.name, definition]));

package/build/tools/index.js

@@ -22,10 +22,12 @@ import { registerListPagesTool } from "./list-pages.js";
 import { registerListPagedModelTool } from "./list-paged-model.js";
 import { registerMoveCellToLayerTool } from "./move-cell-to-layer.js";
 import { registerRenamePageTool } from "./rename-page.js";
+import { registerSaveDocumentTool } from "./save-document.js";
 import { registerSetActiveLayerTool } from "./set-active-layer.js";
 import { registerSetCellDataTool } from "./set-cell-data.js";
 import { registerSetCellParentTool } from "./set-cell-parent.js";
 import { registerSetCellShapeTool } from "./set-cell-shape.js";
+import { registerSetDocumentTitleTool } from "./set-document-title.js";
 const registrars = [
     registerGetSelectedCellTool,
     registerAddRectangleTool,
@@ -55,6 +57,8 @@ const registrars = [
     registerCreatePageTool,
     registerCopyPageTool,
     registerRenamePageTool,
+    registerSetDocumentTitleTool,
+    registerSaveDocumentTool,
 ];
 export function registerTools(...args) {
     for (const register of registrars) {

package/build/tools/save-document.js

@@ -0,0 +1,5 @@
+import { default_tool } from "../tool.js";
+export const TOOL_save_document = "save-document";
+export const registerSaveDocumentTool = (server, context) => {
+    server.tool(TOOL_save_document, "Triggers Draw.io's existing File > Save action for the current document. The active storage provider may display an authentication, conflict, or Save As prompt that requires user interaction.", {}, default_tool(TOOL_save_document, context, { queue: true }));
+};

package/build/tools/set-document-title.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_set_document_title = "set-document-title";
+export const registerSetDocumentTitleTool = (server, context) => {
+    server.tool(TOOL_set_document_title, "Renames the current Draw.io document through its active storage provider while preserving the existing file extension when one is present.", {
+        title: z
+            .string()
+            .trim()
+            .min(1)
+            .describe("New document title, with or without the existing extension"),
+    }, default_tool(TOOL_set_document_title, context, { queue: true }));
+};

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.3.0",
   "description": "Provides Draw.io services to MCP Clients",
   "type": "module",
   "main": "build/index.js",
@@ -31,11 +31,11 @@
     "url": "git+https://github.com/lgazo/drawio-mcp-server.git"
   },
   "dependencies": {
-    "@hono/node-server": "1.19.13",
-    "@modelcontextprotocol/sdk": "1.29.0",
+    "@hono/node-server": "1.19.17",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "cachedir": "2.4.0",
-    "hono": "4.12.23",
-    "nanoid": "5.1.6",
+    "hono": "4.13.5",
+    "nanoid": "5.1.16",
     "node-forge": "1.4.0",
     "unzipper": "0.12.3",
     "ws": "8.21.0",
@@ -45,30 +45,35 @@
     "@biomejs/biome": "2.4.13",
     "@jest/globals": "30.2.0",
     "@playwright/test": "1.59.1",
+    "@types/diff": "8.0.0",
     "@types/jest": "30.0.0",
     "@types/node": "25.0.3",
     "@types/node-forge": "1.3.11",
     "@types/unzipper": "0.10.11",
     "@types/ws": "8.18.1",
     "concurrently": "9.1.2",
+    "diff": "8.0.4",
     "esbuild": "0.25.12",
     "globals": "16.5.0",
     "jest": "30.2.0",
     "jest-environment-node": "30.2.0",
+    "jsonc-parser": "3.3.1",
     "prettier": "3.7.4",
     "rimraf": "6.1.3",
+    "smol-toml": "1.8.0",
     "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.3.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\"",