drawio-mcp-server 2.1.1 → 2.3.0

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]") {
@@ -1997,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}` : ""}`,
@@ -2160,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}` : ""}`,
@@ -2304,6 +2218,343 @@ 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/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"
@@ -2583,7 +2834,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
     }),
@@ -2611,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(
@@ -2621,6 +2882,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 +3138,7 @@ var DrawMcp = (() => {
         cleanups.push(() => clearInterval(intervalId));
       }
     }
+    sendCompatReport(transport2.send.bind(transport2));
     return {
       syncDocumentState,
       dispose: () => {

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);
 });