drawio-mcp-server 2.0.3 → 2.1.0

package/build/index.js

@@ -7,25 +7,31 @@ import { Hono } from "hono";
 import { cors } from "hono/cors";
 import EventEmitter from "node:events";
 import { createServer } from "node:net";
+import { createServer as createHttpsServer } from "node:https";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readFileSync, existsSync, statSync, readdirSync, realpathSync, } from "node:fs";
 import { WebSocket, WebSocketServer } from "ws";
-const VERSION = process.env.npm_package_version ?? "2.0.0";
-import { buildConfig, shouldShowHelp, getHttpFeatureConfig, } from "./config.js";
+const VERSION = process.env.npm_package_version ?? "2.1.0";
+import { buildConfig, defaultConfig, hasFlag, shouldShowHelp, getHttpFeatureConfig, } from "./config.js";
+import { installDesktopPlugin } from "./install-desktop-plugin.js";
 import { bus_reply_stream, bus_request_stream, } from "./types.js";
 import { create_bus } from "./emitter_bus.js";
 import { nanoid_id_generator } from "./nanoid_id_generator.js";
+import { create_request_queue } from "./request_queue.js";
 import { create_logger as create_console_logger } from "./mcp_console_logger.js";
 import { create_logger as create_server_logger, validLogLevels, } from "./mcp_server_logger.js";
 import { getLocalPluginPath, isUsingLocalAssets, getAssetRoot, ensureAssets, } from "./assets/index.js";
 import { registerTools } from "./tools/index.js";
+import { createServerWithSchemaStripping } from "./register-tool.js";
+import { target_document_field } from "./tools/shared.js";
+import { resolveTlsMaterial } from "./tls/index.js";
 const fatalLog = create_console_logger();
 /**
  * Display help message and exit
  */
 function showHelp() {
-    console.log(`
+    fatalLog.log("info", `
 Draw.io MCP Server (${VERSION})
 
 Usage: drawio-mcp-server [options]
@@ -35,7 +41,15 @@ Options:
   --editor, -e                   Enable draw.io editor endpoint
   --http-port                    HTTP server port for Streamable HTTP transport (default: 3000)
   --transport                    Transport type: stdio, http (default: stdio)
-  --asset-path <path>           Custom path for downloaded assets
+  --asset-path <path>            Custom path for downloaded assets
+  --host <ip>                    Bind address for all servers (default: OS-assigned, e.g. 127.0.0.1 or ::1)
+  --logger <mode>                Logger mode: console (stderr) or mcp-server (MCP notifications/message) (default: console)
+  --tls                          Enable TLS (HTTPS + WSS) on HTTP and WebSocket endpoints
+  --tls-cert <path>              Manual TLS cert PEM (requires --tls and --tls-key)
+  --tls-key <path>               Manual TLS key PEM (requires --tls and --tls-cert)
+  --tls-auto                     Auto-generate self-signed cert via local CA (requires --tls)
+  --tls-dir <path>               Override XDG data dir for TLS material (default: per-OS)
+  --install-desktop-plugin       Install mcp-plugin.js into draw.io desktop's plugins directory, then start normally
   --help, -h                     Show this help message
 
 Examples:
@@ -45,37 +59,27 @@ Examples:
   drawio-mcp-server --editor                  # Enable draw.io editor endpoint
   drawio-mcp-server -e --http                 # Enable editor and HTTP transport
   drawio-mcp-server --editor --asset-path /data/assets # Use custom asset path
+  drawio-mcp-server --editor --tls --tls-auto    # HTTPS editor with auto self-signed cert
+  drawio-mcp-server --install-desktop-plugin  # Install plugin into draw.io desktop, then run server
   `);
     process.exit(0);
 }
 // No PORT constant needed - using dynamic config
-async function checkPortAvailable(port) {
+async function checkPortAvailable(port, host) {
     return new Promise((resolve) => {
         const server = createServer();
-        server.listen(port, () => {
+        server.listen({ port, ...(host !== undefined ? { host } : {}) }, () => {
             server.close(() => resolve(true));
         });
         server.on("error", () => resolve(false));
     });
 }
-const logger_type = process.env.LOGGER_TYPE;
-let capabilities = {
-    resources: {},
-    tools: {},
-};
-if (logger_type === "mcp_server") {
-    capabilities = {
-        ...capabilities,
-        logging: {
-            setLevels: true,
-            levels: validLogLevels,
-        },
-    };
-}
-async function start_stdio_transport(server, log) {
+async function start_stdio_transport(createServer, log) {
+    const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     log.debug(`Draw.io MCP Server STDIO transport active`);
+    return server;
 }
 function setupCors(app) {
     app.use("*", cors({
@@ -93,11 +97,13 @@ function setupCors(app) {
 function registerHealthRoute(app) {
     app.get("/health", (c) => c.json({ status: "ok" }));
 }
-function registerConfigRoute(app, config) {
-    app.get("/api/config", (c) => c.json({
-        websocketPort: config.extensionPort,
-        serverUrl: `http://localhost:${config.httpPort}`,
-    }));
+function registerConfigRoute(app, config, scheme) {
+    app.get("/api/config", (c) => {
+        const serverUrl = `${scheme}://localhost:${config.httpPort}`;
+        return c.json(config.webSocketUrl
+            ? { serverUrl, websocketUrl: config.webSocketUrl }
+            : { serverUrl, websocketPort: config.extensionPort });
+    });
 }
 function registerEditorRoutes(app, config, log) {
     const assetConfig = {
@@ -175,147 +181,492 @@ function registerEditorRoutes(app, config, log) {
     });
     log.debug(`Draw.io editor enabled at: http://localhost:${config.httpPort}/`);
 }
-function registerMcpRoute(app) {
-    const transport = new WebStandardStreamableHTTPServerTransport();
-    app.all("/mcp", (c) => transport.handleRequest(c.req.raw));
-    return transport;
+function registerMcpRoute(app, createServer, disposeMcpServer) {
+    app.all("/mcp", async (c) => {
+        const transport = new WebStandardStreamableHTTPServerTransport();
+        const server = createServer();
+        await server.connect(transport);
+        // Remove the server from the tracking set immediately so it does not
+        // prevent garbage collection.  We intentionally do *not* call
+        // server.close() here because the response may be a long-lived SSE
+        // stream (e.g. for GET requests).  The transport / server will be
+        // collected once the response is fully consumed.
+        disposeMcpServer(server);
+        return transport.handleRequest(c.req.raw);
+    });
 }
-function createHttpApp(log, config, features) {
+function createHttpApp(log, config, features, createServer, disposeMcpServer, tlsMaterial) {
     const app = new Hono();
     setupCors(app);
+    const scheme = tlsMaterial ? "https" : "http";
     if (features.enableHealth)
         registerHealthRoute(app);
     if (features.enableConfig)
-        registerConfigRoute(app, config);
-    const mcpTransport = features.enableMcp ? registerMcpRoute(app) : undefined;
+        registerConfigRoute(app, config, scheme);
+    if (features.enableMcp)
+        registerMcpRoute(app, createServer, disposeMcpServer);
     if (features.enableEditor)
         registerEditorRoutes(app, config, log);
-    return { app, mcpTransport };
+    return { app };
 }
-async function startHttpServer(server, log, httpPort, config, features) {
-    const { app, mcpTransport } = createHttpApp(log, config, features);
-    if (mcpTransport) {
-        await server.connect(mcpTransport);
-    }
+async function startHttpServer(createServer, disposeMcpServer, log, httpPort, config, features, tlsMaterial) {
+    const { app } = createHttpApp(log, config, features, createServer, disposeMcpServer, tlsMaterial);
     const httpServer = serve({
         fetch: app.fetch,
         port: httpPort,
+        ...(config.host !== undefined ? { hostname: config.host } : {}),
+        ...(tlsMaterial
+            ? {
+                createServer: createHttpsServer,
+                serverOptions: { cert: tlsMaterial.cert, key: tlsMaterial.key },
+            }
+            : {}),
     });
     const listeningPort = httpPort === 0
         ? (httpServer.address()?.port ?? httpPort)
         : httpPort;
-    log.debug(`Draw.io MCP Server HTTP active on port ${listeningPort}`);
+    const scheme = tlsMaterial ? "https" : "http";
+    log.debug(`Draw.io MCP Server HTTP active on port ${listeningPort} (${scheme})`);
     if (features.enableMcp) {
-        log.debug(`MCP endpoint: http://localhost:${listeningPort}/mcp`);
+        log.debug(`MCP endpoint: ${scheme}://localhost:${listeningPort}/mcp`);
     }
     if (features.enableEditor) {
-        log.debug(`Editor: http://localhost:${listeningPort}/`);
+        log.debug(`Editor: ${scheme}://localhost:${listeningPort}/`);
     }
     return {
         server: httpServer,
         port: listeningPort,
     };
 }
-export function createDrawioMcpApp(overrides) {
-    const server = new McpServer({
-        name: "drawio-mcp-server",
-        version: VERSION,
-    }, {
-        capabilities,
-    });
-    const log = overrides?.log ??
-        (logger_type === "mcp_server"
-            ? create_server_logger(server)
-            : create_console_logger());
+export function createDrawioMcpApp(options) {
+    const config = options?.config ?? defaultConfig();
     const emitter = new EventEmitter();
-    const conns = new Set();
-    const bus = create_bus(log)(emitter);
+    const connectionIdGenerator = nanoid_id_generator();
+    const mcpServers = new Set();
+    const capabilities = {
+        resources: {},
+        tools: {},
+    };
+    if (config.logger === "mcp-server") {
+        capabilities.logging = {
+            setLevels: true,
+            levels: validLogLevels,
+        };
+    }
+    const conns = new Map();
+    const DOCUMENT_SYNC_TIMEOUT_MS = 1000;
+    // Lazily resolved log — uses console logger until a server logger is
+    // explicitly requested via --logger mcp-server, in which case the first
+    // McpServer created will be used for the logger binding.
+    let _log = options?.log;
+    let _serverLoggerBound = false;
+    function getLog() {
+        if (_log)
+            return _log;
+        _log = create_console_logger();
+        return _log;
+    }
+    // Proxy logger that lazily resolves to the real logger, allowing the
+    // mcp_server_logger to be bound after the first McpServer is created.
+    const lazyLog = {
+        log: (level, message, ...data) => getLog().log(level, message, ...data),
+        debug: (message, ...data) => getLog().debug(message, ...data),
+    };
+    const bus = create_bus(lazyLog)(emitter);
     const id_generator = nanoid_id_generator();
+    const request_queue = create_request_queue(lazyLog);
+    function normalizeOptionalString(value) {
+        if (value === undefined || value === null || value === "") {
+            return null;
+        }
+        return String(value);
+    }
+    function normalizeCurrentPage(value) {
+        if (!value || typeof value !== "object") {
+            return null;
+        }
+        const record = value;
+        const id = normalizeOptionalString(record.id);
+        const name = normalizeOptionalString(record.name);
+        const index = Number(record.index);
+        if (!id || !name || !Number.isInteger(index) || index < 0) {
+            return null;
+        }
+        return {
+            index,
+            id,
+            name,
+            is_current: true,
+        };
+    }
+    function normalizeDocumentState(value) {
+        if (!value || typeof value !== "object") {
+            return null;
+        }
+        const record = value;
+        const id = normalizeOptionalString(record.id);
+        if (!id) {
+            return null;
+        }
+        const page_count = Number(record.page_count);
+        return {
+            id,
+            title: normalizeOptionalString(record.title),
+            mode: normalizeOptionalString(record.mode),
+            hash: normalizeOptionalString(record.hash),
+            file_url: normalizeOptionalString(record.file_url),
+            page_count: Number.isInteger(page_count) && page_count >= 0 ? page_count : 0,
+            current_page: normalizeCurrentPage(record.current_page),
+        };
+    }
+    function listKnownDocuments() {
+        return [...conns.values()]
+            .map((entry) => entry.document)
+            .filter((document) => document !== null);
+    }
+    function findConnectionByDocumentId(documentId) {
+        return [...conns.values()].find((entry) => entry.document?.id === documentId);
+    }
+    function flushSyncWaiters(entry) {
+        for (const resolve of [...entry.sync_waiters]) {
+            try {
+                resolve();
+            }
+            catch {
+                // ignore
+            }
+        }
+        entry.sync_waiters.clear();
+    }
+    function sendControlMessage(entry, control) {
+        if (entry.ws.readyState !== WebSocket.OPEN) {
+            return false;
+        }
+        entry.ws.send(JSON.stringify({
+            __control: control,
+        }));
+        return true;
+    }
+    function requestDocumentSync(entry) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let timeout;
+            const wrappedFinish = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                entry.sync_waiters.delete(wrappedFinish);
+                resolve();
+            };
+            entry.sync_waiters.add(wrappedFinish);
+            timeout = setTimeout(() => {
+                wrappedFinish();
+            }, DOCUMENT_SYNC_TIMEOUT_MS);
+            if (!sendControlMessage(entry, "sync-document-state")) {
+                wrappedFinish();
+            }
+        });
+    }
+    async function syncAllDocuments() {
+        await Promise.all([...conns.values()].map((entry) => requestDocumentSync(entry)));
+    }
+    const document_routing = {
+        list_documents: async () => {
+            await syncAllDocuments();
+            return listKnownDocuments();
+        },
+        resolve_target_document: async (args) => {
+            const rawSelector = args.target_document;
+            if (rawSelector && typeof rawSelector === "object") {
+                const selector = rawSelector;
+                const documentId = normalizeOptionalString(selector.id);
+                if (!documentId) {
+                    throw new Error("`target_document.id` is required");
+                }
+                let entry = findConnectionByDocumentId(documentId);
+                if (!entry) {
+                    await syncAllDocuments();
+                    entry = findConnectionByDocumentId(documentId);
+                }
+                if (!entry || !entry.document) {
+                    throw new Error(`Document with ID ${documentId} was not found`);
+                }
+                return {
+                    connection_id: entry.connection_id,
+                    target_document: { id: documentId },
+                    document: entry.document,
+                };
+            }
+            await syncAllDocuments();
+            const documents = listKnownDocuments();
+            if (documents.length === 0) {
+                throw new Error("No connected Draw.io documents");
+            }
+            if (documents.length > 1) {
+                throw new Error("Multiple Draw.io documents are connected. Call `list-documents` and retry with `target_document`.");
+            }
+            const document = documents[0];
+            const entry = findConnectionByDocumentId(document.id);
+            if (!entry) {
+                throw new Error(`Document with ID ${document.id} was not found`);
+            }
+            return {
+                connection_id: entry.connection_id,
+                target_document: { id: document.id },
+                document,
+            };
+        },
+    };
     const context = {
         bus,
         id_generator,
-        log,
+        request_queue,
+        document_routing,
+        get log() {
+            return getLog();
+        },
     };
-    registerTools(server, context);
+    function createDocumentScopedServer(server) {
+        return new Proxy(server, {
+            get(target, prop, receiver) {
+                if (prop !== "tool") {
+                    return Reflect.get(target, prop, receiver);
+                }
+                return (name, description, params, handler) => {
+                    const scopedParams = name === "list-documents"
+                        ? params
+                        : {
+                            ...params,
+                            target_document: target_document_field().optional(),
+                        };
+                    return target.tool.call(target, name, description, scopedParams, handler);
+                };
+            },
+        });
+    }
+    /**
+     * Factory: creates a new McpServer instance with all tools registered.
+     * Each transport must use its own McpServer since the MCP SDK only
+     * allows a single transport connection per Protocol instance.
+     */
+    function createMcpServer() {
+        const server = new McpServer({
+            name: "drawio-mcp-server",
+            version: VERSION,
+        }, {
+            capabilities,
+        });
+        // Bind the mcp_server logger to the first server created when the
+        // mcp-server logger mode was selected.
+        if (config.logger === "mcp-server" &&
+            !_serverLoggerBound &&
+            !options?.log) {
+            _log = create_server_logger(server);
+            _serverLoggerBound = true;
+        }
+        registerTools(createDocumentScopedServer(createServerWithSchemaStripping(server)), context);
+        mcpServers.add(server);
+        return server;
+    }
+    /**
+     * Remove a previously created McpServer from the tracking set.
+     * Used by the HTTP route handler to prevent unbounded growth of
+     * the set when creating per-request servers in stateless mode.
+     */
+    function disposeMcpServer(server) {
+        mcpServers.delete(server);
+    }
+    function createDisconnectedDocumentError(event) {
+        const targetDocumentId = typeof event.target_document?.id ===
+            "string" && event.target_document.id
+            ? event.target_document.id
+            : null;
+        const targetConnectionId = typeof event.__target_connection_id === "string"
+            ? event.__target_connection_id
+            : null;
+        const targetLabel = targetDocumentId
+            ? `Target document ${targetDocumentId}`
+            : targetConnectionId
+                ? `Target connection ${targetConnectionId}`
+                : "Target Draw.io connection";
+        return new Error(`${targetLabel} is no longer connected; call list-documents and retry`);
+    }
     const bus_to_ws_forwarder_listener = (event) => {
-        log.debug(`[bridge] received; forwarding message to #${conns.size} clients`, event);
-        for (const ws of [...conns]) {
-            if (ws.readyState !== WebSocket.OPEN) {
-                conns.delete(ws);
+        const targetConnectionId = typeof event?.__target_connection_id === "string"
+            ? event.__target_connection_id
+            : null;
+        if (targetConnectionId) {
+            const entry = conns.get(targetConnectionId);
+            getLog().debug(`[bridge] forwarding message to #${targetConnectionId}`, event);
+            if (!entry) {
+                getLog().debug(`[bridge] target connection ${targetConnectionId} not found`);
+                throw createDisconnectedDocumentError(event);
+            }
+            if (entry.ws.readyState !== WebSocket.OPEN) {
+                flushSyncWaiters(entry);
+                conns.delete(targetConnectionId);
+                throw createDisconnectedDocumentError(event);
+            }
+            try {
+                entry.ws.send(JSON.stringify(event));
+            }
+            catch (error) {
+                getLog().debug("[bridge] error forwarding request", error);
+                flushSyncWaiters(entry);
+                conns.delete(targetConnectionId);
+                throw createDisconnectedDocumentError(event);
+            }
+            return;
+        }
+        getLog().debug(`[bridge] received; forwarding message to #${conns.size} clients`, event);
+        for (const [connectionId, entry] of [...conns.entries()]) {
+            if (entry.ws.readyState !== WebSocket.OPEN) {
+                flushSyncWaiters(entry);
+                conns.delete(connectionId);
                 continue;
             }
             try {
-                ws.send(JSON.stringify(event));
+                entry.ws.send(JSON.stringify(event));
             }
-            catch (e) {
-                log.debug("[bridge] error forwarding request", e);
-                conns.delete(ws);
+            catch (error) {
+                getLog().debug("[bridge] error forwarding request", error);
+                flushSyncWaiters(entry);
+                conns.delete(connectionId);
             }
         }
     };
     emitter.on(bus_request_stream, bus_to_ws_forwarder_listener);
+    const tlsMaterial = resolveTlsMaterial({
+        config: {
+            tlsEnabled: config.tlsEnabled,
+            tlsAuto: config.tlsAuto,
+            tlsCert: config.tlsCert,
+            tlsKey: config.tlsKey,
+            tlsDir: config.tlsDir,
+            host: config.host,
+        },
+        log: (msg) => getLog().log("info", msg),
+    });
     let wsServer;
+    let wssHttpsServer;
     let httpServer;
-    async function startWebSocketServer(extensionPort = 3333) {
-        log.debug(`Draw.io MCP Server (${VERSION}) starting (WebSocket extension port: ${extensionPort})`);
+    async function startWebSocketServer(extensionPort = 3333, host) {
+        getLog().debug(`Draw.io MCP Server (${VERSION}) starting (${tlsMaterial ? "WSS" : "WebSocket"} extension port: ${extensionPort})`);
         if (extensionPort !== 0) {
-            const isPortAvailable = await checkPortAvailable(extensionPort);
+            const isPortAvailable = await checkPortAvailable(extensionPort, host);
             if (!isPortAvailable) {
                 throw new Error(`[start_websocket_server] Error: Port ${extensionPort} is already in use. Please stop the process using this port and try again.`);
             }
         }
-        wsServer = new WebSocketServer({ port: extensionPort });
+        if (tlsMaterial) {
+            const httpsServer = createHttpsServer({
+                cert: tlsMaterial.cert,
+                key: tlsMaterial.key,
+            });
+            // Destroy sockets that send plain-text to the TLS port so clients get
+            // a prompt close rather than a half-open connection.
+            httpsServer.on("tlsClientError", (_err, tlsSocket) => {
+                tlsSocket.destroy();
+            });
+            await new Promise((resolve, reject) => {
+                httpsServer.once("error", reject);
+                httpsServer.listen({
+                    port: extensionPort,
+                    ...(host !== undefined ? { host } : {}),
+                }, () => {
+                    httpsServer.off("error", reject);
+                    resolve();
+                });
+            });
+            wssHttpsServer = httpsServer;
+            wsServer = new WebSocketServer({ server: httpsServer });
+        }
+        else {
+            wsServer = new WebSocketServer({
+                port: extensionPort,
+                ...(host !== undefined ? { host } : {}),
+            });
+        }
         wsServer.on("connection", (ws) => {
-            log.debug(`[ws_handler] A WebSocket client #${conns.size} connected, presumably MCP Extension!`);
-            conns.add(ws);
+            const connection_id = connectionIdGenerator.generate();
+            const entry = {
+                connection_id,
+                ws,
+                document: null,
+                updated_at: Date.now(),
+                sync_waiters: new Set(),
+            };
+            getLog().debug(`[ws_handler] WebSocket client ${connection_id} connected, presumably MCP Extension!`);
+            conns.set(connection_id, entry);
+            sendControlMessage(entry, "sync-document-state");
             ws.on("message", (data) => {
                 const str = typeof data === "string" ? data : data.toString();
                 try {
                     const json = JSON.parse(str);
-                    log.debug(`[ws] received from Extension`, json);
+                    getLog().debug(`[ws] received from Extension`, json);
+                    if (json?.__control === "document-state") {
+                        entry.document = normalizeDocumentState(json.document);
+                        entry.updated_at = Date.now();
+                        flushSyncWaiters(entry);
+                        return;
+                    }
                     emitter.emit(bus_reply_stream, json);
                 }
                 catch (error) {
-                    log.debug(`[ws] failed to parse message`, error);
+                    getLog().debug(`[ws] failed to parse message`, error);
                 }
             });
             ws.on("close", (code) => {
-                conns.delete(ws);
-                log.debug(`[ws_handler] WebSocket client closed with code ${code}`);
+                flushSyncWaiters(entry);
+                conns.delete(connection_id);
+                getLog().debug(`[ws_handler] WebSocket client ${connection_id} closed with code ${code}`);
             });
             ws.on("error", (error) => {
-                log.debug(`[ws_handler] WebSocket client error`, error);
-                conns.delete(ws);
+                getLog().debug(`[ws_handler] WebSocket client error`, error);
+                flushSyncWaiters(entry);
+                conns.delete(connection_id);
             });
         });
-        await new Promise((resolve, reject) => {
-            const onListening = () => {
-                wsServer?.off("error", onError);
-                const address = wsServer?.address();
-                log.debug(`[start_websocket_server] Listening to port ${address?.port ?? extensionPort}`);
-                resolve();
-            };
-            const onError = (error) => {
-                wsServer?.off("listening", onListening);
-                reject(error);
-            };
-            wsServer?.once("listening", onListening);
-            wsServer?.once("error", onError);
-        });
+        if (!tlsMaterial) {
+            await new Promise((resolve, reject) => {
+                const onListening = () => {
+                    wsServer?.off("error", onError);
+                    resolve();
+                };
+                const onError = (error) => {
+                    wsServer?.off("listening", onListening);
+                    reject(error);
+                };
+                wsServer?.once("listening", onListening);
+                wsServer?.once("error", onError);
+            });
+        }
+        const address = wsServer?.address();
+        getLog().debug(`[start_websocket_server] Listening to port ${address?.port ?? extensionPort}`);
+        // wsServer is always set by one of the two branches above
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return wsServer;
     }
     async function close() {
         emitter.off(bus_request_stream, bus_to_ws_forwarder_listener);
-        for (const ws of [...conns]) {
+        for (const entry of [...conns.values()]) {
             try {
-                ws.close();
+                flushSyncWaiters(entry);
+                entry.ws.close();
             }
             catch {
                 // ignore
             }
         }
         conns.clear();
-        await server.close();
+        for (const s of mcpServers) {
+            await s.close();
+        }
+        mcpServers.clear();
         if (wsServer) {
             await new Promise((resolve, reject) => {
                 wsServer?.close((error) => {
@@ -328,6 +679,15 @@ export function createDrawioMcpApp(overrides) {
             });
             wsServer = undefined;
         }
+        if (wssHttpsServer) {
+            const hs = wssHttpsServer;
+            wssHttpsServer = undefined;
+            // Forcefully terminate all connections (including half-open TLS
+            // connections from clients that called socket.end() before the
+            // WebSocket upgrade) so the server closes immediately.
+            hs.closeAllConnections?.();
+            await new Promise((resolve) => hs.close(() => resolve()));
+        }
         if (httpServer) {
             await new Promise((resolve, reject) => {
                 httpServer?.close((error) => {
@@ -342,46 +702,76 @@ export function createDrawioMcpApp(overrides) {
         }
     }
     return {
-        server,
-        log,
+        createMcpServer,
+        get log() {
+            return getLog();
+        },
         context,
         emitter,
         close,
         startWebSocketServer,
-        startStdioTransport: () => start_stdio_transport(server, log),
+        startStdioTransport: async () => {
+            await start_stdio_transport(createMcpServer, getLog());
+        },
         startHttpServer: async (httpPort, config, features) => {
-            const started = await startHttpServer(server, log, httpPort, config, features);
+            const started = await startHttpServer(createMcpServer, disposeMcpServer, getLog(), httpPort, config, features, tlsMaterial);
             httpServer = started.server;
             return started;
         },
     };
 }
+async function runInstallDesktopPlugin() {
+    try {
+        const result = await installDesktopPlugin();
+        fatalLog.log("info", `Plugin installed at ${result.installedPath}${result.overwrote ? " (overwrote existing)" : ""}.
+
+To enable in draw.io desktop:
+  1. Launch draw.io with: --enable-plugins
+  2. Open: Extras -> Configuration -> Preferences (Configuration JSON dialog)
+  3. Add this entry to the JSON (merge with any existing keys):
+       { "plugins": ["mcp-plugin.js"] }
+  4. Click Save and restart draw.io.
+
+Continuing with normal server startup...`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        fatalLog.log("error", `Failed to install desktop plugin: ${message}`);
+        process.exit(1);
+    }
+}
 async function main() {
+    const cliArgs = process.argv.slice(2);
     // Check if help was requested (before parsing config)
-    if (shouldShowHelp(process.argv.slice(2))) {
+    if (shouldShowHelp(cliArgs)) {
         showHelp();
         // never returns
     }
+    // Run install side-effect before normal startup, so users can keep a single
+    // command in their MCP host config (install once, then run every time).
+    if (hasFlag(cliArgs, "--install-desktop-plugin")) {
+        await runInstallDesktopPlugin();
+    }
     // Build configuration from command line args
     const configResult = buildConfig();
     // Handle errors from configuration parsing
     if (configResult instanceof Error) {
-        console.error(`Error: ${configResult.message}`);
+        fatalLog.log("error", `Error: ${configResult.message}`);
         process.exit(1);
     }
     const config = configResult;
     const features = getHttpFeatureConfig(config);
+    const app = createDrawioMcpApp({ config });
     // Initialize assets if needed
     if (features.enableEditor) {
-        console.log("Initializing draw.io assets...");
+        app.log.debug("Initializing draw.io assets...");
         const assetConfig = {
             assetPath: config.assetPath,
         };
-        await ensureAssets(assetConfig, (msg) => console.log(msg));
-        console.log("Assets ready!");
+        await ensureAssets(assetConfig, app.log);
+        app.log.debug("Assets ready!");
     }
-    const app = createDrawioMcpApp();
-    await app.startWebSocketServer(config.extensionPort);
+    await app.startWebSocketServer(config.extensionPort, config.host);
     if (config.transports.indexOf("stdio") > -1) {
         await app.startStdioTransport();
     }
@@ -394,7 +784,7 @@ const isMainModule = process.argv[1]
     : false;
 if (isMainModule) {
     main().catch((error) => {
-        fatalLog.debug("Fatal error in main():", error);
+        fatalLog.log("error", "Fatal error in main():", error);
         process.exit(1);
     });
 }