drawio-mcp-server 2.0.3 → 2.1.0

package/build/install-desktop-plugin.js

@@ -0,0 +1,56 @@
+import { copyFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve drawio-desktop's plugins directory for the current platform.
+ *
+ * Mirrors Electron's `app.getPath("userData")` for the productName "draw.io":
+ *   linux:  $XDG_CONFIG_HOME/draw.io/plugins  (defaults to ~/.config/draw.io/plugins)
+ *   darwin: ~/Library/Application Support/draw.io/plugins
+ *   win32:  %APPDATA%/draw.io/plugins
+ */
+export function resolveDrawioPluginsDir(platform = process.platform, env = process.env) {
+    if (platform === "win32") {
+        const appData = env.APPDATA;
+        if (!appData || appData.length === 0) {
+            throw new Error("APPDATA environment variable is not set; cannot locate drawio-desktop plugins directory.");
+        }
+        return join(appData, "draw.io", "plugins");
+    }
+    if (platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "draw.io", "plugins");
+    }
+    // linux + everything else: XDG
+    const xdg = env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : join(homedir(), ".config");
+    return join(base, "draw.io", "plugins");
+}
+/**
+ * Source path of the bundled mcp-plugin.js produced by the server build.
+ * Same resolution style as `assets/manager.ts:getLocalPluginPath`.
+ */
+function getBundledPluginPath() {
+    return join(__dirname, "..", "build", "plugin", "mcp-plugin.js");
+}
+/**
+ * Copy the bundled mcp-plugin.js into drawio-desktop's plugins directory.
+ *
+ * Always overwrites an existing file (plugin version tracks server version).
+ *
+ * @param opts.targetDir override the resolved plugins directory (used by tests)
+ */
+export async function installDesktopPlugin(opts = {}) {
+    const pluginsDir = opts.targetDir ?? resolveDrawioPluginsDir();
+    const source = getBundledPluginPath();
+    if (!existsSync(source)) {
+        throw new Error(`Bundled mcp-plugin.js not found at ${source}. Run "pnpm --filter drawio-mcp-server build" first.`);
+    }
+    await mkdir(pluginsDir, { recursive: true });
+    const installedPath = join(pluginsDir, "mcp-plugin.js");
+    const overwrote = existsSync(installedPath);
+    await copyFile(source, installedPath);
+    return { pluginsDir, installedPath, overwrote };
+}

package/build/install-desktop-plugin.test.js

@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeAll } from "@jest/globals";
+import { mkdtempSync, writeFileSync, mkdirSync, readFileSync, existsSync, } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveDrawioPluginsDir, installDesktopPlugin, } from "./install-desktop-plugin.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+describe("resolveDrawioPluginsDir", () => {
+    test("linux with XDG_CONFIG_HOME unset uses ~/.config", () => {
+        const result = resolveDrawioPluginsDir("linux", {});
+        expect(result).toBe(join(homedir(), ".config", "draw.io", "plugins"));
+    });
+    test("linux with XDG_CONFIG_HOME set uses it", () => {
+        const result = resolveDrawioPluginsDir("linux", {
+            XDG_CONFIG_HOME: "/custom/xdg",
+        });
+        expect(result).toBe("/custom/xdg/draw.io/plugins");
+    });
+    test("darwin uses Library/Application Support", () => {
+        const result = resolveDrawioPluginsDir("darwin", {});
+        expect(result).toBe(join(homedir(), "Library", "Application Support", "draw.io", "plugins"));
+    });
+    test("win32 uses APPDATA", () => {
+        const result = resolveDrawioPluginsDir("win32", {
+            APPDATA: "C:\\Users\\test\\AppData\\Roaming",
+        });
+        expect(result).toBe(join("C:\\Users\\test\\AppData\\Roaming", "draw.io", "plugins"));
+    });
+    test("win32 without APPDATA throws", () => {
+        expect(() => resolveDrawioPluginsDir("win32", {})).toThrow(/APPDATA/);
+    });
+});
+describe("installDesktopPlugin", () => {
+    // The compiled tests live in build/, so __dirname is .../build, which makes
+    // getBundledPluginPath() resolve to .../build/../build/plugin/mcp-plugin.js
+    // i.e. .../build/plugin/mcp-plugin.js — same path the build script populates.
+    const expectedSource = join(__dirname, "..", "build", "plugin", "mcp-plugin.js");
+    beforeAll(() => {
+        if (!existsSync(expectedSource)) {
+            mkdirSync(dirname(expectedSource), { recursive: true });
+            writeFileSync(expectedSource, "// fixture mcp-plugin.js\n");
+        }
+    });
+    test("copies bundled plugin to target dir", async () => {
+        const targetDir = mkdtempSync(join(tmpdir(), "drawio-plugin-install-"));
+        const result = await installDesktopPlugin({ targetDir });
+        expect(result.pluginsDir).toBe(targetDir);
+        expect(result.installedPath).toBe(join(targetDir, "mcp-plugin.js"));
+        expect(result.overwrote).toBe(false);
+        expect(existsSync(result.installedPath)).toBe(true);
+        expect(readFileSync(result.installedPath, "utf8")).toBe(readFileSync(expectedSource, "utf8"));
+    });
+    test("second install overwrites and reports overwrote: true", async () => {
+        const targetDir = mkdtempSync(join(tmpdir(), "drawio-plugin-install-"));
+        await installDesktopPlugin({ targetDir });
+        const result = await installDesktopPlugin({ targetDir });
+        expect(result.overwrote).toBe(true);
+    });
+    test("creates plugins dir if missing", async () => {
+        const parent = mkdtempSync(join(tmpdir(), "drawio-plugin-install-"));
+        const targetDir = join(parent, "nested", "plugins");
+        expect(existsSync(targetDir)).toBe(false);
+        const result = await installDesktopPlugin({ targetDir });
+        expect(existsSync(result.installedPath)).toBe(true);
+    });
+});

package/build/multi-transport.test.js

@@ -0,0 +1,277 @@
+import { mkdtempSync } from "node:fs";
+import * as https from "node:https";
+import { Socket } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { connect as tlsConnect } from "node:tls";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createDrawioMcpApp } from "./index.js";
+import { MemoryLogger } from "./real-environment/logger.js";
+import { defaultConfig } from "./config.js";
+describe("multi-transport support", () => {
+    let app;
+    let logger;
+    beforeEach(() => {
+        logger = new MemoryLogger();
+        app = createDrawioMcpApp({ log: logger });
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("createMcpServer returns distinct instances", () => {
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        expect(server1).not.toBe(server2);
+    });
+    it("each McpServer instance has tools registered", async () => {
+        const [ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        const client1 = new Client({ name: "test-client-1", version: "1.0.0" });
+        const client2 = new Client({ name: "test-client-2", version: "1.0.0" });
+        await Promise.all([
+            server1.connect(st1),
+            client1.connect(ct1),
+            server2.connect(st2),
+            client2.connect(ct2),
+        ]);
+        const tools1 = await client1.listTools();
+        const tools2 = await client2.listTools();
+        expect(tools1.tools.length).toBeGreaterThan(0);
+        expect(tools2.tools.length).toBeGreaterThan(0);
+        const names1 = tools1.tools.map((t) => t.name).sort();
+        const names2 = tools2.tools.map((t) => t.name).sort();
+        expect(names1).toEqual(names2);
+        await client1.close();
+        await client2.close();
+    });
+    it("two InMemoryTransport connections work simultaneously without 'Already connected' error", async () => {
+        const [ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        const client1 = new Client({ name: "test-client-1", version: "1.0.0" });
+        const client2 = new Client({ name: "test-client-2", version: "1.0.0" });
+        // This is the exact scenario that was failing before the fix:
+        // connecting two transports should not throw.
+        await expect(Promise.all([
+            server1.connect(st1),
+            client1.connect(ct1),
+            server2.connect(st2),
+            client2.connect(ct2),
+        ])).resolves.not.toThrow();
+        // Both clients can independently list tools
+        const [tools1, tools2] = await Promise.all([
+            client1.listTools(),
+            client2.listTools(),
+        ]);
+        expect(tools1.tools.length).toBeGreaterThan(0);
+        expect(tools2.tools.length).toBeGreaterThan(0);
+        await client1.close();
+        await client2.close();
+    });
+    it("close() shuts down all created McpServer instances", async () => {
+        const [ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server1 = app.createMcpServer();
+        const server2 = app.createMcpServer();
+        const client1 = new Client({ name: "test-client-1", version: "1.0.0" });
+        const client2 = new Client({ name: "test-client-2", version: "1.0.0" });
+        await Promise.all([
+            server1.connect(st1),
+            client1.connect(ct1),
+            server2.connect(st2),
+            client2.connect(ct2),
+        ]);
+        // close() should succeed without errors even with multiple servers
+        await expect(app.close()).resolves.not.toThrow();
+        // After close, listing tools should fail because the servers are shut down
+        await expect(client1.listTools()).rejects.toThrow();
+        await expect(client2.listTools()).rejects.toThrow();
+    });
+    it("connecting the same McpServer instance to two transports still throws", async () => {
+        const [_ct1, st1] = InMemoryTransport.createLinkedPair();
+        const [_ct2, st2] = InMemoryTransport.createLinkedPair();
+        const server = app.createMcpServer();
+        await server.connect(st1);
+        // The SDK constraint hasn't changed — a single Protocol instance
+        // still rejects a second connect().
+        await expect(server.connect(st2)).rejects.toThrow(/already connected/i);
+    });
+});
+describe("HTTP transport (stateless per-request)", () => {
+    let app;
+    let logger;
+    let httpServer;
+    let port;
+    const config = {
+        extensionPort: 0,
+        httpPort: 0,
+        transports: ["http"],
+        editorEnabled: false,
+        logger: "console",
+        tlsEnabled: false,
+        tlsAuto: false,
+    };
+    const features = {
+        enableMcp: true,
+        enableEditor: false,
+        enableHealth: false,
+        enableConfig: false,
+    };
+    beforeEach(async () => {
+        logger = new MemoryLogger();
+        app = createDrawioMcpApp({ log: logger });
+        const started = await app.startHttpServer(0, config, features);
+        httpServer = started.server;
+        port = started.port;
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("handles a single HTTP client request", async () => {
+        const client = new Client({ name: "http-test-1", version: "1.0.0" });
+        const transport = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client.connect(transport);
+        const tools = await client.listTools();
+        expect(tools.tools.length).toBeGreaterThan(0);
+        await client.close();
+    });
+    it("handles multiple sequential HTTP client requests without reuse error", async () => {
+        // First request
+        const client1 = new Client({ name: "http-test-seq-1", version: "1.0.0" });
+        const transport1 = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client1.connect(transport1);
+        const tools1 = await client1.listTools();
+        expect(tools1.tools.length).toBeGreaterThan(0);
+        await client1.close();
+        // Second request — this was the exact scenario that triggered the
+        // "Stateless transport cannot be reused across requests" error.
+        const client2 = new Client({ name: "http-test-seq-2", version: "1.0.0" });
+        const transport2 = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client2.connect(transport2);
+        const tools2 = await client2.listTools();
+        expect(tools2.tools.length).toBeGreaterThan(0);
+        await client2.close();
+    });
+    it("close() succeeds after HTTP requests (per-request servers are cleaned up)", async () => {
+        const client = new Client({ name: "http-cleanup", version: "1.0.0" });
+        const transport = new StreamableHTTPClientTransport(new URL(`http://localhost:${port}/mcp`));
+        await client.connect(transport);
+        await client.listTools();
+        await client.close();
+        // close() should not hang or throw — the per-request McpServer
+        // was already disposed and removed from the tracking set.
+        await expect(app.close()).resolves.not.toThrow();
+    });
+});
+describe("WebSocket TLS", () => {
+    let app;
+    let logger;
+    let wsPort;
+    let tlsDir;
+    beforeEach(async () => {
+        logger = new MemoryLogger();
+        tlsDir = mkdtempSync(join(tmpdir(), "tls-ws-"));
+        const baseCfg = defaultConfig();
+        app = createDrawioMcpApp({
+            log: logger,
+            config: { ...baseCfg, tlsEnabled: true, tlsAuto: true, tlsDir },
+        });
+        const wsServer = await app.startWebSocketServer(0);
+        wsPort = wsServer.address().port;
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("accepts TLS handshakes (wss)", async () => {
+        await new Promise((resolve, reject) => {
+            const socket = tlsConnect({ port: wsPort, host: "127.0.0.1", rejectUnauthorized: false }, () => {
+                expect(socket.authorized || !socket.authorized).toBe(true);
+                socket.end();
+                resolve();
+            });
+            socket.on("error", reject);
+        });
+    });
+    it("rejects plain TCP traffic", async () => {
+        await new Promise((resolve) => {
+            const s = new Socket();
+            s.connect(wsPort, "127.0.0.1", () => {
+                s.write("plain text\r\n");
+            });
+            // The server sends a TLS alert and destroys the socket.
+            // In Jest's ESM VM environment "close" can be slow to propagate,
+            // so we also resolve on "data" (the TLS alert bytes) and "end".
+            const done = () => {
+                s.destroy();
+                resolve();
+            };
+            s.on("error", done);
+            s.on("close", done);
+            s.on("data", done);
+            s.on("end", done);
+        });
+    });
+});
+describe("HTTP transport — TLS (https)", () => {
+    let app;
+    let logger;
+    let httpServer;
+    let port;
+    let tlsDir;
+    beforeEach(async () => {
+        logger = new MemoryLogger();
+        tlsDir = mkdtempSync(join(tmpdir(), "tls-http-"));
+        const cfg = {
+            ...defaultConfig(),
+            extensionPort: 0,
+            httpPort: 0,
+            transports: ["http"],
+            editorEnabled: false,
+            tlsEnabled: true,
+            tlsAuto: true,
+            tlsDir,
+        };
+        app = createDrawioMcpApp({ log: logger, config: cfg });
+        const features = {
+            enableMcp: true,
+            enableEditor: false,
+            enableHealth: true,
+            enableConfig: false,
+        };
+        const started = await app.startHttpServer(0, cfg, features);
+        httpServer = started.server;
+        port = started.port;
+    });
+    afterEach(async () => {
+        await app.close();
+    });
+    it("serves /health over HTTPS", async () => {
+        const body = await new Promise((resolve, reject) => {
+            const req = https.request({
+                hostname: "localhost",
+                port,
+                path: "/health",
+                method: "GET",
+                rejectUnauthorized: false,
+            }, (res) => {
+                expect(res.statusCode).toBe(200);
+                let data = "";
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+                res.on("end", () => resolve(data));
+            });
+            req.on("error", reject);
+            req.end();
+        });
+        expect(JSON.parse(body)).toEqual({ status: "ok" });
+    });
+    it("rejects plain HTTP", async () => {
+        await expect(fetch(`http://localhost:${port}/health`)).rejects.toThrow();
+    });
+});