drawio-mcp-server 2.2.0 → 2.3.0

package/build/install/install.integration.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BIN = join(__dirname, "..", "..", "build", "index.js");
+// Sandbox every adapter's defaultPaths() resolution so a spawned `install`
+// process can never resolve to the real developer's home directory.
+// homedir() reads HOME on POSIX and USERPROFILE/HOMEDRIVE+HOMEPATH on
+// Windows; claude-desktop's resolver reads APPDATA directly on win32.
+function isolateEnv(homeDir) {
+    const env = { ...process.env };
+    env.HOME = homeDir;
+    env.USERPROFILE = homeDir;
+    env.APPDATA = join(homeDir, "AppData", "Roaming");
+    env.LOCALAPPDATA = join(homeDir, "AppData", "Local");
+    env.HOMEDRIVE = "C:"; // benign default; ignored on POSIX
+    env.HOMEPATH = homeDir;
+    delete env.XDG_CONFIG_HOME;
+    delete env.XDG_DATA_HOME;
+    delete env.XDG_STATE_HOME;
+    delete env.XDG_CACHE_HOME;
+    return env;
+}
+describe("install subcommand — end to end", () => {
+    let dir;
+    let home;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "drawio-e2e-"));
+        home = mkdtempSync(join(tmpdir(), "drawio-home-"));
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+        rmSync(home, { recursive: true, force: true });
+    });
+    function run(args) {
+        return spawnSync("node", [BIN, "install", ...args], {
+            encoding: "utf8",
+            env: isolateEnv(home),
+            cwd: home,
+        });
+    }
+    it("codex --print emits TOML on stdout, no file written", () => {
+        const target = join(dir, "codex.toml");
+        const r = run(["codex", "--print", "--config-path", target]);
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain("[mcp_servers.drawio]");
+        expect(existsSync(target)).toBe(false);
+    });
+    it("zed --print emits JSON", () => {
+        const target = join(dir, "zed.json");
+        const r = run(["zed", "--print", "--config-path", target]);
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('"context_servers"');
+    });
+    it("codex writes to target when --yes passed", () => {
+        const target = join(dir, "codex.toml");
+        const r = run(["codex", "--yes", "--config-path", target]);
+        expect(r.status).toBe(0);
+        expect(existsSync(target)).toBe(true);
+        expect(readFileSync(target, "utf8")).toContain("[mcp_servers.drawio]");
+    });
+    it("codex refuses to overwrite non-empty target without --yes and returns exit 4", () => {
+        const target = join(dir, "codex.toml");
+        const first = run(["codex", "--yes", "--config-path", target]);
+        expect(first.status).toBe(0);
+        const modified = readFileSync(target, "utf8").replace("drawio-mcp-server", "drawio-mcp-server-old");
+        writeFileSync(target, modified);
+        const second = run(["codex", "--config-path", target]);
+        expect(second.status).toBe(4);
+        expect(second.stderr).toContain("Re-run with --yes");
+    });
+    it("all with per-host config paths writes to each, and never touches unoverridden adapters' real paths", () => {
+        const codexPath = join(dir, "codex.toml");
+        const zedPath = join(dir, "zed.json");
+        const r = run([
+            "all",
+            "--yes",
+            "--config-path",
+            `codex=${codexPath}`,
+            "--config-path",
+            `zed=${zedPath}`,
+        ]);
+        expect(r.status).toBe(0);
+        expect(existsSync(codexPath)).toBe(true);
+        expect(existsSync(zedPath)).toBe(true);
+        // opencode, claude-desktop, and claude-code got no --config-path
+        // override. With HOME sandboxed to a fresh temp dir, their
+        // defaultPaths() resolve to non-existent files, so detect() reports
+        // "absent" and applyAll() skips them entirely — proving isolation
+        // rather than just asserting the explicit overrides worked.
+        expect(existsSync(join(home, ".claude.json"))).toBe(false);
+        expect(existsSync(join(home, ".config", "Claude", "claude_desktop_config.json"))).toBe(false);
+        expect(existsSync(join(home, ".config", "opencode", "opencode.json"))).toBe(false);
+    });
+    it("returns exit 1 on unknown host", () => {
+        const r = run(["bogus"]);
+        expect(r.status).toBe(1);
+        expect(r.stderr).toContain("unknown host");
+    });
+});

package/build/install/types.js

@@ -0,0 +1 @@
+export {};

package/build/multi-transport.test.js

@@ -138,6 +138,7 @@ describe("HTTP transport (stateless per-request)", () => {
         await client.connect(transport);
         const tools = await client.listTools();
         expect(tools.tools.length).toBeGreaterThan(0);
+        expect(tools.tools.map((tool) => tool.name)).toEqual(expect.arrayContaining(["set-document-title", "save-document"]));
         await client.close();
     });
     it("handles multiple sequential HTTP client requests without reuse error", async () => {

package/build/plugin/mcp-plugin.js

@@ -1909,6 +1909,7 @@ var DrawMcp = (() => {
             );
             codec.decode(graphModelElement, model);
           }
+          sync_live_current_page_state(ui2);
           return {
             success: true,
             message: `Diagram replaced successfully${filename ? ` from ${filename}` : ""}`,
@@ -2072,6 +2073,7 @@ var DrawMcp = (() => {
           } finally {
             model.endUpdate();
           }
+          sync_live_current_page_state(ui2);
           return {
             success: true,
             message: `Diagram imported successfully (new page created)${filename ? `: ${filename}` : ""}`,
@@ -2481,6 +2483,78 @@ var DrawMcp = (() => {
     }
   }
 
+  // src/tools/save-document/index.ts
+  function normalize_optional_string2(value) {
+    if (value === void 0 || value === null || value === "") {
+      return null;
+    }
+    return String(value);
+  }
+  var save_document = (ui2) => {
+    const saveAction = ui2?.actions?.get?.("save");
+    if (!saveAction || typeof saveAction.funct !== "function") {
+      throw new Error("The Draw.io save action is not available");
+    }
+    if (typeof saveAction.isEnabled === "function" && saveAction.isEnabled() !== true) {
+      throw new Error("The Draw.io save action is currently disabled");
+    }
+    saveAction.funct();
+    const file = ui2?.getCurrentFile?.();
+    return {
+      triggered: true,
+      title: normalize_optional_string2(file?.getTitle?.()),
+      mode: normalize_optional_string2(file?.getMode?.())
+    };
+  };
+
+  // src/tools/set-document-title/index.ts
+  var DRAWIO_FILE_SUFFIX = /(\.drawio\.(?:svg|png)|\.drawio|\.xml|\.svg|\.png)$/i;
+  function normalize_optional_string3(value) {
+    if (value === void 0 || value === null || value === "") {
+      return null;
+    }
+    return String(value);
+  }
+  function title_with_preserved_suffix(currentTitle, requestedTitle) {
+    const title = normalize_optional_string3(requestedTitle)?.trim() ?? "";
+    if (!title) {
+      throw new Error("`title` must not be empty");
+    }
+    const currentSuffix = currentTitle?.match(DRAWIO_FILE_SUFFIX)?.[1] ?? "";
+    if (!currentSuffix || DRAWIO_FILE_SUFFIX.test(title)) {
+      return title;
+    }
+    return `${title}${currentSuffix}`;
+  }
+  function tool_error(error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  var set_document_title = (ui2, options) => {
+    const file = ui2?.getCurrentFile?.();
+    if (!file) {
+      throw new Error("No active Draw.io file is available");
+    }
+    if (typeof file.rename !== "function") {
+      throw new Error("Document renaming is not supported by this storage mode");
+    }
+    const previousTitle = normalize_optional_string3(file.getTitle?.());
+    const nextTitle = title_with_preserved_suffix(previousTitle, options.title);
+    return new Promise(
+      (resolve, reject) => {
+        file.rename?.(
+          nextTitle,
+          () => {
+            resolve({
+              previous_title: previousTitle,
+              title: normalize_optional_string3(file.getTitle?.()) ?? nextTitle
+            });
+          },
+          (error) => reject(tool_error(error))
+        );
+      }
+    );
+  };
+
   // src/tool-registry.ts
   var VISIBLE_PAGE_EXECUTION = {
     mode: "visible-page"
@@ -2788,6 +2862,16 @@ var DrawMcp = (() => {
       name: "rename-page",
       params: /* @__PURE__ */ new Set(["page", "name"]),
       handler: rename_page
+    },
+    {
+      name: "set-document-title",
+      params: /* @__PURE__ */ new Set(["title"]),
+      handler: set_document_title
+    },
+    {
+      name: "save-document",
+      params: /* @__PURE__ */ new Set([]),
+      handler: save_document
     }
   ];
   var toolDefinitions = rawToolDefinitions.map(

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

@@ -79,4 +79,111 @@ describe("real environment/import export", () => {
         await expectNoBrowserErrors(context, "import-export");
         await expectNoServerErrors(context, "import-export", logCountBefore);
     }, 180000);
+    it("keeps ui.currentPage.root in sync with graph.model.root after replace import (regression for #56)", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const importXml = '<mxGraphModel dx="0" dy="0" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0"><root><mxCell id="0"/><mxCell id="1" parent="0"/><mxCell id="regression-1" value="Regression cell" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1"><mxGeometry x="40" y="40" width="120" height="60" as="geometry"/></mxCell></root></mxGraphModel>';
+        const { payload: importResult } = await callToolJson(context, "import-diagram", {
+            data: importXml,
+            format: "xml",
+            mode: "replace",
+            filename: "regression.drawio",
+        });
+        expectToolSuccess(importResult);
+        await context.page.waitForFunction(() => {
+            const maybeWindow = window;
+            const graph = maybeWindow.ui?.editor?.graph;
+            const model = graph?.getModel?.();
+            const cells = Object.values(model?.cells ?? {});
+            return cells.some((cell) => cell?.value === "Regression cell");
+        });
+        const pageState = await context.page.evaluate(() => {
+            const maybeWindow = window;
+            const ui = maybeWindow.ui;
+            const page = ui?.currentPage;
+            const model = ui?.editor?.graph?.getModel?.();
+            const modelRoot = model?.getRoot?.() ?? model?.root ?? null;
+            return {
+                pageRootMatchesModelRoot: page?.root === modelRoot,
+                graphModelNodeIsNull: page?.graphModelNode == null,
+                pageRootHasImportedCell: (() => {
+                    if (!page?.root || typeof page.root.getChildAt !== "function")
+                        return null;
+                    const rootChild = page.root.getChildAt(0);
+                    if (!rootChild || typeof rootChild.getChildAt !== "function")
+                        return null;
+                    for (let i = 0; i < (rootChild.getChildCount?.() ?? 0); i++) {
+                        const child = rootChild.getChildAt(i);
+                        if (child?.value === "Regression cell")
+                            return true;
+                    }
+                    return false;
+                })(),
+            };
+        });
+        expect(pageState.pageRootMatchesModelRoot).toBe(true);
+        expect(pageState.graphModelNodeIsNull).toBe(true);
+        expect(pageState.pageRootHasImportedCell).toBe(true);
+        // The page-root identity asserted above is a proxy for correctness. What a
+        // user actually loses when currentPage goes stale is the *serialized* file:
+        // drawio serializes through the Page abstraction, so a stale page root ends
+        // up in the saved bytes while the live graph (holding the import) does not.
+        // Assert the import survives serialization, not just the in-memory model.
+        const serializedFileData = await context.page.evaluate(() => {
+            const maybeWindow = window;
+            const ui = maybeWindow.ui;
+            try {
+                if (typeof ui?.getXmlFileData === "function" &&
+                    typeof maybeWindow.mxUtils?.getXml === "function") {
+                    return String(maybeWindow.mxUtils.getXml(ui.getXmlFileData(true, false, true)));
+                }
+            }
+            catch {
+                /* fall through to getFileData */
+            }
+            try {
+                if (typeof ui?.getFileData === "function") {
+                    return String(ui.getFileData(true, null, null, null, true, null, null, null, null, true));
+                }
+            }
+            catch {
+                /* unsupported build */
+            }
+            return null;
+        });
+        if (serializedFileData !== null) {
+            expect(serializedFileData).toContain("Regression cell");
+        }
+        const survivesPageRoundTrip = await context.page.evaluate(async () => {
+            const maybeWindow = window;
+            const ui = maybeWindow.ui;
+            if (!ui?.insertPage || !ui?.selectPage || !ui?.currentPage) {
+                return { skipped: true };
+            }
+            const originalPage = ui.currentPage;
+            const scratch = ui.insertPage();
+            ui.selectPage(scratch);
+            await new Promise((r) => setTimeout(r, 20));
+            ui.selectPage(originalPage);
+            await new Promise((r) => setTimeout(r, 20));
+            const model = ui.editor.graph.getModel();
+            const cells = Object.values(model?.cells ?? {});
+            const stillPresent = cells.some((cell) => cell?.value === "Regression cell");
+            if (typeof ui.removePage === "function") {
+                try {
+                    ui.removePage(scratch);
+                }
+                catch {
+                    /* best-effort cleanup */
+                }
+            }
+            return { skipped: false, stillPresent };
+        });
+        if (!survivesPageRoundTrip.skipped) {
+            expect(survivesPageRoundTrip.stillPresent).toBe(true);
+        }
+        await expectNoBrowserErrors(context, "import-export");
+        await expectNoServerErrors(context, "import-export", logCountBefore);
+    }, 180000);
 });

package/build/stdio-shutdown.test.js

@@ -134,6 +134,34 @@ describe("graceful shutdown releases WebSocket port", () => {
         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();

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drawio-mcp-server",
-  "version": "2.2.0",
+  "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.25",
-    "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,22 +45,26 @@
     "@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.2.0"
+    "drawio-mcp-plugin": "2.3.0"
   },
   "scripts": {
     "vendor:compat": "rimraf src/vendored/compat && mkdir -p src/vendored/compat && cp ../drawio-mcp-compat/src/index.ts src/vendored/compat/index.ts",