drawio-mcp-server 2.1.0 → 2.2.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]") {
@@ -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/register-tool.js

@@ -1,31 +1,83 @@
 import { stripSchemaRecursively } from "./strip-schema.js";
 /**
- * Creates a wrapped version of McpServer.tool that automatically strips
- * `$schema` from the inputSchema after tool registration.
+ * Wraps an `McpServer` so that the `tools/list` response strips the
+ * `$schema` key from every tool's `inputSchema` and `outputSchema`.
  *
- * The `$schema` key injected by zodToJsonSchema causes Claude Code to silently
- * drop tools because the `$` character fails Anthropic's validation regex
- * `^[a-zA-Z0-9_.-]{1,64}$`.
+ * Why this is necessary:
  *
- * @param server - The McpServer instance to wrap
- * @returns The same server instance, but with a modified tool() method
+ * - The MCP SDK lazily serializes tool schemas: it stores the Zod object
+ *   verbatim at registration time and only converts to JSON Schema
+ *   (via `zodToJsonSchema` / `z4mini.toJSONSchema`) when a client issues
+ *   `tools/list`. The conversion emits a top-level
+ *   `"$schema": "http://json-schema.org/draft-07/schema#"` field.
+ *
+ * - Claude Code's MCP ingest layer can't tolerate the `$` character in
+ *   schema keys (Anthropic's parameter-name regex is
+ *   `^[a-zA-Z0-9_.-]{1,64}$`). When `$schema` is present, the entire
+ *   `properties` object is dropped, leaving tools effectively schemaless.
+ *   The user can see the tool name but the LLM has no way to know which
+ *   arguments to send, so calls fail at runtime.
+ *
+ * - A previous attempt at this fix tried to strip `$schema` from the
+ *   stored `_registeredTools[name].inputSchema` via `setTimeout(0)`.
+ *   That was a no-op against modern SDKs because the stored value at
+ *   that point is the raw Zod object (which doesn't have `$schema`).
+ *   The `$schema` key is added by `toJsonSchemaCompat` at serialization
+ *   time, not at registration time.
+ *
+ * The fix here intercepts the `tools/list` request handler that the SDK
+ * registers internally on the first `server.tool(...)` call, and wraps
+ * it so the response runs through `stripSchemaRecursively` before being
+ * returned to the client.
  */
 export function createServerWithSchemaStripping(server) {
-    // Store original tool method
     const originalTool = server.tool.bind(server);
-    // Override tool method
-    server.tool = function tool(name, description, inputSchema, handler) {
-        // Call original tool method
-        const result = originalTool(name, description, inputSchema, handler);
-        // Strip $schema from the registered tool's inputSchema
-        // This must be done after registration
-        setTimeout(() => {
-            const registeredTool = server._registeredTools?.[name];
-            if (registeredTool?.inputSchema) {
-                registeredTool.inputSchema = stripSchemaRecursively(registeredTool.inputSchema);
-            }
-        }, 0);
+    let patched = false;
+    server.tool = function tool(...args) {
+        const result = originalTool(...args);
+        // The SDK lazily registers the tools/list handler on the first
+        // server.tool() call (via setToolRequestHandlers). After that call
+        // returns, the handler is in place and we can wrap it.
+        if (!patched) {
+            patched = true;
+            patchToolsListHandler(server);
+        }
         return result;
     };
     return server;
 }
+function patchToolsListHandler(server) {
+    // The McpServer wraps an inner Server (the low-level protocol layer).
+    // Its `_requestHandlers` Map stores per-method handlers keyed by the
+    // method name literal (e.g. "tools/list").
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const innerServer = server.server;
+    const handlers = innerServer?._requestHandlers;
+    if (!handlers) {
+        // SDK internals changed; fail closed (no-op) so we don't crash the
+        // server. The tools will still work but schemas will leak `$schema`.
+        return;
+    }
+    const original = handlers.get("tools/list");
+    if (!original) {
+        return;
+    }
+    handlers.set("tools/list", async (...callArgs) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const response = await original(...callArgs);
+        if (response && Array.isArray(response.tools)) {
+            response.tools = response.tools.map(stripToolSchemas);
+        }
+        return response;
+    });
+}
+function stripToolSchemas(tool) {
+    const next = { ...tool };
+    if (next.inputSchema) {
+        next.inputSchema = stripSchemaRecursively(next.inputSchema);
+    }
+    if (next.outputSchema) {
+        next.outputSchema = stripSchemaRecursively(next.outputSchema);
+    }
+    return next;
+}

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