drawio-mcp-server 2.0.4 → 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

@@ -1,8 +1,15 @@
+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;
@@ -105,6 +112,9 @@ describe("HTTP transport (stateless per-request)", () => {
         httpPort: 0,
         transports: ["http"],
         editorEnabled: false,
+        logger: "console",
+        tlsEnabled: false,
+        tlsAuto: false,
     };
     const features = {
         enableMcp: true,
@@ -158,3 +168,110 @@ describe("HTTP transport (stateless per-request)", () => {
         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();
+    });
+});