gopeak 2.1.0 → 2.2.0

package/build/index.js

@@ -12,17 +12,18 @@ import { existsSync, readdirSync, mkdirSync, readFileSync, appendFileSync, write
 import { spawn } from 'child_process';
 import { promisify } from 'util';
 import { exec } from 'child_process';
-import { createServer } from 'http';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { setupResourceHandlers } from './resources.js';
 import { GodotLSPClient, createLSPTools, handleLSPTool } from './lsp_client.js';
 import { GodotDAPClient, createDAPTools, handleDAPTool } from './dap_client.js';
+import { mapProject } from './gdscript_parser.js';
+import { serveVisualization, setProjectPath } from './visualizer-server.js';
+import { getDefaultBridge } from './godot-bridge.js';
 // Check if debug mode is enabled
 const DEBUG_MODE = process.env.DEBUG === 'true';
 const GODOT_DEBUG_MODE = true; // Always use GODOT DEBUG MODE
-const HEALTH_PORT = parseInt(process.env.MCP_HEALTH_PORT || '8080', 10);
 const execAsync = promisify(exec);
 // Derive __filename and __dirname in ESM
 const __filename = fileURLToPath(import.meta.url);
@@ -44,6 +45,33 @@ class GodotServer {
     logQueue = [];
     logFlushTimer = null;
     logFlushIntervalMs = 1500;
+    godotBridge;
+    cachedToolDefinitions = [];
+    toolExposureProfile;
+    toolsListPageSize;
+    compactAliasToLegacy = {
+        'tool.catalog': 'tool_catalog',
+        'project.list': 'list_projects',
+        'project.info': 'get_project_info',
+        'project.search': 'search_project',
+        'editor.launch': 'launch_editor',
+        'editor.run': 'run_project',
+        'editor.stop': 'stop_project',
+        'editor.debug_output': 'get_debug_output',
+        'editor.status': 'get_editor_status',
+        'scene.create': 'create_scene',
+        'scene.node.add': 'add_node',
+        'scene.save': 'save_scene',
+        'script.create': 'create_script',
+        'script.modify': 'modify_script',
+        'script.info': 'get_script_info',
+        'class.query': 'query_classes',
+        'class.info': 'query_class_info',
+        'runtime.status': 'get_runtime_status',
+        'visualizer.map': 'map_project',
+        'lsp.diagnostics': 'lsp_get_diagnostics',
+        'dap.output': 'dap_get_output',
+    };
     /**
      * Parameter name mappings between snake_case and camelCase
      * This allows the server to accept both formats
@@ -91,6 +119,17 @@ class GodotServer {
      */
     reverseParameterMappings = {};
     constructor(config) {
+        const rawProfile = (process.env.GOPEAK_TOOL_PROFILE || process.env.MCP_TOOL_PROFILE || 'compact').toLowerCase();
+        if (rawProfile === 'full' || rawProfile === 'legacy' || rawProfile === 'compact') {
+            this.toolExposureProfile = rawProfile;
+        }
+        else {
+            this.toolExposureProfile = 'compact';
+        }
+        const rawToolsPageSize = parseInt(process.env.GOPEAK_TOOLS_PAGE_SIZE || '20', 10);
+        this.toolsListPageSize = Number.isFinite(rawToolsPageSize) && rawToolsPageSize > 0
+            ? rawToolsPageSize
+            : 20;
         // Initialize reverse parameter mappings
         for (const [snakeCase, camelCase] of Object.entries(this.parameterMappings)) {
             this.reverseParameterMappings[camelCase] = snakeCase;
@@ -122,6 +161,8 @@ class GodotServer {
         }
         // Set the path to the operations script
         this.operationsScriptPath = join(__dirname, 'scripts', 'godot_operations.gd');
+        // Initialize the Godot Editor Bridge (WebSocket server for editor plugin)
+        this.godotBridge = getDefaultBridge();
         if (debugMode)
             console.error(`[DEBUG] Operations script path: ${this.operationsScriptPath}`);
         // Initialize the MCP server
@@ -372,6 +413,12 @@ class GodotServer {
             catch { }
             this.dapClient = null;
         }
+        if (this.godotBridge) {
+            try {
+                await this.godotBridge.stop();
+            }
+            catch { }
+        }
         await this.server.close();
     }
     async handleRuntimeCommand(command, args) {
@@ -440,6 +487,86 @@ class GodotServer {
         }
         return handleDAPTool(this.dapClient, toolName, args);
     }
+    resolveToolAlias(requestedToolName) {
+        return this.compactAliasToLegacy[requestedToolName] || requestedToolName;
+    }
+    buildCompactTools(allTools) {
+        const compactTools = [];
+        for (const [compactName, legacyName] of Object.entries(this.compactAliasToLegacy)) {
+            const source = allTools.find((tool) => tool.name === legacyName);
+            if (!source) {
+                continue;
+            }
+            compactTools.push({
+                ...source,
+                name: compactName,
+                description: `[compact alias of ${legacyName}] ${source.description}`,
+            });
+        }
+        return compactTools;
+    }
+    getExposedTools(allTools) {
+        if (this.toolExposureProfile === 'full' || this.toolExposureProfile === 'legacy') {
+            return allTools;
+        }
+        return this.buildCompactTools(allTools);
+    }
+    parseToolsListCursor(cursor, total) {
+        if (typeof cursor !== 'string' || cursor.length === 0) {
+            return 0;
+        }
+        const offset = Number.parseInt(cursor, 10);
+        if (!Number.isInteger(offset) || offset < 0 || offset > total) {
+            throw new McpError(ErrorCode.InvalidParams, `Invalid tools/list cursor: ${cursor}`);
+        }
+        return offset;
+    }
+    paginateToolsForList(tools, cursor) {
+        const start = this.parseToolsListCursor(cursor, tools.length);
+        const end = Math.min(start + this.toolsListPageSize, tools.length);
+        const page = tools.slice(start, end);
+        if (end < tools.length) {
+            return {
+                tools: page,
+                nextCursor: String(end),
+            };
+        }
+        return { tools: page };
+    }
+    async handleToolCatalog(args) {
+        const normalizedArgs = this.normalizeParameters(args || {});
+        const query = typeof normalizedArgs.query === 'string' ? normalizedArgs.query.trim().toLowerCase() : '';
+        const rawLimit = typeof normalizedArgs.limit === 'number' ? normalizedArgs.limit : 30;
+        const limit = Math.max(1, Math.min(100, rawLimit));
+        const tools = this.cachedToolDefinitions;
+        const reverseAlias = new Map();
+        for (const [compactName, legacyName] of Object.entries(this.compactAliasToLegacy)) {
+            reverseAlias.set(legacyName, compactName);
+        }
+        const filtered = tools.filter((tool) => {
+            if (!query)
+                return true;
+            const haystack = `${tool.name} ${tool.description}`.toLowerCase();
+            return haystack.includes(query);
+        });
+        const items = filtered.slice(0, limit).map((tool) => ({
+            tool: tool.name,
+            compactAlias: reverseAlias.get(tool.name) || null,
+            description: tool.description,
+        }));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        profile: this.toolExposureProfile,
+                        totalTools: tools.length,
+                        query: query || null,
+                        returned: items.length,
+                        tools: items,
+                    }, null, 2),
+                }],
+        };
+    }
     /**
      * Check if the Godot version is 4.4 or later
      * @param version The Godot version string
@@ -684,8 +811,8 @@ class GodotServer {
      */
     setupToolHandlers() {
         // Define available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
+        this.server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+            const allTools = [
                 {
                     name: 'launch_editor',
                     description: 'Opens the Godot editor GUI for a project. Use when visual inspection or manual editing of scenes/scripts is needed. Opens a new window on the host system. Requires: project directory with project.godot file.',
@@ -975,6 +1102,18 @@ class GodotServer {
                         required: [],
                     },
                 },
+                {
+                    name: 'tool_catalog',
+                    description: 'Discover available tools including hidden legacy tools. Use query to search by capability keywords (e.g., animation, import, tilemap, audio).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Optional keyword search over tool names and descriptions.' },
+                            limit: { type: 'number', description: 'Maximum results to return. Default: 30, max: 100.' },
+                        },
+                        required: [],
+                    },
+                },
                 {
                     name: 'create_scene',
                     description: 'Creates a new Godot scene file (.tscn) with a specified root node type. Use to start building new game levels, UI screens, or reusable components. The scene is saved automatically after creation.',
@@ -1990,6 +2129,10 @@ class GodotServer {
                                 type: 'string',
                                 description: 'Optional: template name - "singleton", "state_machine", "component", "resource"',
                             },
+                            reason: {
+                                type: 'string',
+                                description: 'Optional reason/context for this change. Displayed in visualizer audit timeline.',
+                            },
                         },
                         required: ['projectPath', 'scriptPath'],
                     },
@@ -2062,6 +2205,10 @@ class GodotServer {
                                     required: ['type', 'name'],
                                 },
                             },
+                            reason: {
+                                type: 'string',
+                                description: 'Optional reason/context for this change. Displayed in visualizer audit timeline.',
+                            },
                         },
                         required: ['projectPath', 'scriptPath', 'modifications'],
                     },
@@ -2885,12 +3032,38 @@ class GodotServer {
                         required: ['x', 'y'],
                     },
                 },
+                // Editor Plugin Bridge Status
+                {
+                    name: 'get_editor_status',
+                    description: 'Returns the connection status of the Godot Editor Plugin bridge. Use to check if the editor is connected before using scene/resource tools that require the editor plugin.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                // Project Visualizer Tool
+                {
+                    name: 'map_project',
+                    description: 'Crawl the entire Godot project and build an interactive visual map of all scripts showing their structure (variables, functions, signals), connections (extends, preloads, signal connections), and descriptions. Opens an interactive browser-based visualization at localhost:6505.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            projectPath: { type: 'string', description: 'Absolute path to the Godot project directory' },
+                            root: { type: 'string', description: 'Root path to start crawling from (default: res://)' },
+                            include_addons: { type: 'boolean', description: 'Whether to include scripts in addons/ folder (default: false)' },
+                        },
+                        required: ['projectPath'],
+                    },
+                },
                 // Godot LSP Tools (GDScript diagnostics via Godot editor LSP on port 6005)
                 ...createLSPTools(),
                 // Godot DAP Tools (Debug Adapter Protocol via Godot editor DAP on port 6006)
                 ...createDAPTools(),
-            ],
-        }));
+            ];
+            this.cachedToolDefinitions = allTools;
+            const exposedTools = this.getExposedTools(allTools);
+            return this.paginateToolsForList(exposedTools, request.params?.cursor);
+        });
         // Handle tool calls
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             this.logDebug(`Handling tool request: ${request.params.name}`);
@@ -2898,7 +3071,8 @@ class GodotServer {
             if (rawArgs?.projectPath && typeof rawArgs.projectPath === 'string') {
                 this.lastProjectPath = rawArgs.projectPath;
             }
-            switch (request.params.name) {
+            const resolvedToolName = this.resolveToolAlias(request.params.name);
+            switch (resolvedToolName) {
                 case 'launch_editor':
                     return await this.handleLaunchEditor(request.params.arguments);
                 case 'run_project':
@@ -2937,31 +3111,33 @@ class GodotServer {
                     return await this.handleSetRecordingMode(request.params.arguments);
                 case 'get_recording_mode':
                     return await this.handleGetRecordingMode();
+                case 'tool_catalog':
+                    return await this.handleToolCatalog(request.params.arguments);
                 case 'create_scene':
-                    return await this.handleCreateScene(request.params.arguments);
+                    return await this.handleViaBridge('create_scene', request.params.arguments);
                 case 'add_node':
-                    return await this.handleAddNode(request.params.arguments);
+                    return await this.handleViaBridge('add_node', request.params.arguments);
                 case 'load_sprite':
-                    return await this.handleLoadSprite(request.params.arguments);
+                    return await this.handleViaBridge('load_sprite', request.params.arguments);
                 case 'save_scene':
-                    return await this.handleSaveScene(request.params.arguments);
+                    return await this.handleViaBridge('save_scene', request.params.arguments);
                 case 'get_uid':
                     return await this.handleGetUid(request.params.arguments);
                 case 'update_project_uids':
                     return await this.handleUpdateProjectUids(request.params.arguments);
                 // Phase 1: Scene Operations handlers
                 case 'list_scene_nodes':
-                    return await this.handleListSceneNodes(request.params.arguments);
+                    return await this.handleViaBridge('list_scene_nodes', request.params.arguments);
                 case 'get_node_properties':
-                    return await this.handleGetNodeProperties(request.params.arguments);
+                    return await this.handleViaBridge('get_node_properties', request.params.arguments);
                 case 'set_node_properties':
-                    return await this.handleSetNodeProperties(request.params.arguments);
+                    return await this.handleViaBridge('set_node_properties', request.params.arguments);
                 case 'delete_node':
-                    return await this.handleDeleteNode(request.params.arguments);
+                    return await this.handleViaBridge('delete_node', request.params.arguments);
                 case 'duplicate_node':
-                    return await this.handleDuplicateNode(request.params.arguments);
+                    return await this.handleViaBridge('duplicate_node', request.params.arguments);
                 case 'reparent_node':
-                    return await this.handleReparentNode(request.params.arguments);
+                    return await this.handleViaBridge('reparent_node', request.params.arguments);
                 // Phase 2: Import/Export Pipeline handlers
                 case 'get_import_status':
                     return await this.handleGetImportStatus(request.params.arguments);
@@ -3001,11 +3177,11 @@ class GodotServer {
                     return await this.handleSetMainScene(request.params.arguments);
                 // Signal Management handlers
                 case 'connect_signal':
-                    return await this.handleConnectSignal(request.params.arguments);
+                    return await this.handleViaBridge('connect_signal', request.params.arguments);
                 case 'disconnect_signal':
-                    return await this.handleDisconnectSignal(request.params.arguments);
+                    return await this.handleViaBridge('disconnect_signal', request.params.arguments);
                 case 'list_connections':
-                    return await this.handleListConnections(request.params.arguments);
+                    return await this.handleViaBridge('list_connections', request.params.arguments);
                 // Phase 4: Runtime Tools handlers
                 case 'get_runtime_status':
                     return await this.handleGetRuntimeStatus(request.params.arguments);
@@ -3019,11 +3195,11 @@ class GodotServer {
                     return await this.handleGetRuntimeMetrics(request.params.arguments);
                 // Resource Creation Tools handlers
                 case 'create_resource':
-                    return await this.handleCreateResource(request.params.arguments);
+                    return await this.handleViaBridge('create_resource', request.params.arguments);
                 case 'create_material':
-                    return await this.handleCreateMaterial(request.params.arguments);
+                    return await this.handleViaBridge('create_material', request.params.arguments);
                 case 'create_shader':
-                    return await this.handleCreateShader(request.params.arguments);
+                    return await this.handleViaBridge('create_shader', request.params.arguments);
                 // GDScript File Operations handlers
                 case 'create_script':
                     return await this.handleCreateScript(request.params.arguments);
@@ -3033,9 +3209,9 @@ class GodotServer {
                     return await this.handleGetScriptInfo(request.params.arguments);
                 // Animation Tools handlers
                 case 'create_animation':
-                    return await this.handleCreateAnimation(request.params.arguments);
+                    return await this.handleViaBridge('create_animation', request.params.arguments);
                 case 'add_animation_track':
-                    return await this.handleAddAnimationTrack(request.params.arguments);
+                    return await this.handleViaBridge('add_animation_track', request.params.arguments);
                 // Plugin Management handlers
                 case 'list_plugins':
                     return await this.handleListPlugins(request.params.arguments);
@@ -3051,9 +3227,9 @@ class GodotServer {
                     return await this.handleSearchProject(request.params.arguments);
                 // 2D Tile Tools handlers
                 case 'create_tileset':
-                    return await this.handleCreateTileset(request.params.arguments);
+                    return await this.handleViaBridge('create_tileset', request.params.arguments);
                 case 'set_tilemap_cells':
-                    return await this.handleSetTilemapCells(request.params.arguments);
+                    return await this.handleViaBridge('set_tilemap_cells', request.params.arguments);
                 // Audio System Tools handlers
                 case 'create_audio_bus':
                     return await this.handleCreateAudioBus(request.params.arguments);
@@ -3067,24 +3243,24 @@ class GodotServer {
                 // Physics Tools handlers
                 // Navigation Tools handlers
                 case 'create_navigation_region':
-                    return await this.handleCreateNavigationRegion(request.params.arguments);
+                    return await this.handleViaBridge('create_navigation_region', request.params.arguments);
                 case 'create_navigation_agent':
-                    return await this.handleCreateNavigationAgent(request.params.arguments);
+                    return await this.handleViaBridge('create_navigation_agent', request.params.arguments);
                 // Rendering Tools handlers
                 // Animation Tree Tools handlers
                 case 'create_animation_tree':
-                    return await this.handleCreateAnimationTree(request.params.arguments);
+                    return await this.handleViaBridge('create_animation_tree', request.params.arguments);
                 case 'add_animation_state':
-                    return await this.handleAddAnimationState(request.params.arguments);
+                    return await this.handleViaBridge('add_animation_state', request.params.arguments);
                 case 'connect_animation_states':
-                    return await this.handleConnectAnimationStates(request.params.arguments);
+                    return await this.handleViaBridge('connect_animation_states', request.params.arguments);
                 // UI/Theme Tools handlers
                 case 'set_theme_color':
-                    return await this.handleSetThemeColor(request.params.arguments);
+                    return await this.handleViaBridge('set_theme_color', request.params.arguments);
                 case 'set_theme_font_size':
-                    return await this.handleSetThemeFontSize(request.params.arguments);
+                    return await this.handleViaBridge('set_theme_font_size', request.params.arguments);
                 case 'apply_theme_shader':
-                    return await this.handleApplyThemeShader(request.params.arguments);
+                    return await this.handleViaBridge('apply_theme_shader', request.params.arguments);
                 case 'search_assets':
                     return await this.handleSearchAssets(request.params.arguments);
                 case 'fetch_asset':
@@ -3100,7 +3276,13 @@ class GodotServer {
                     return await this.handleInspectInheritance(request.params.arguments);
                 // Resource Modification Tool
                 case 'modify_resource':
-                    return await this.handleModifyResource(request.params.arguments);
+                    return await this.handleViaBridge('modify_resource', request.params.arguments);
+                // Editor Plugin Bridge Status
+                case 'get_editor_status':
+                    return { content: [{ type: 'text', text: JSON.stringify(this.godotBridge.getStatus(), null, 2) }] };
+                // Project Visualizer Tool
+                case 'map_project':
+                    return await this.handleMapProject(request.params.arguments);
                 case 'capture_screenshot':
                     return await this.handleRuntimeCommand('capture_screenshot', request.params.arguments);
                 case 'capture_viewport':
@@ -3117,7 +3299,7 @@ class GodotServer {
                 case 'lsp_get_completions':
                 case 'lsp_get_hover':
                 case 'lsp_get_symbols':
-                    return await this.handleLSP(request.params.name, request.params.arguments);
+                    return await this.handleLSP(resolvedToolName, request.params.arguments);
                 case 'dap_get_output':
                 case 'dap_set_breakpoint':
                 case 'dap_remove_breakpoint':
@@ -3125,7 +3307,7 @@ class GodotServer {
                 case 'dap_pause':
                 case 'dap_step_over':
                 case 'dap_get_stack_trace':
-                    return await this.handleDAP(request.params.name, request.params.arguments);
+                    return await this.handleDAP(resolvedToolName, request.params.arguments);
                 default:
                     throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
             }
@@ -3271,6 +3453,33 @@ class GodotServer {
             ]);
         }
     }
+    /**
+     * Route a tool call through the Godot Editor Plugin bridge (WebSocket).
+     * Returns an error response if the editor is not connected.
+     */
+    async handleViaBridge(toolName, args) {
+        if (!this.godotBridge.isConnected()) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: 'Godot Editor not connected. Launch Godot Editor and enable the "Godot MCP Editor" plugin to use this tool.',
+                            suggestion: 'Use the launch_editor tool to open the Godot Editor, then enable the plugin in Project > Project Settings > Plugins.',
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await this.godotBridge.invokeTool(toolName, args);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error),
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+    }
     /**
      * Handle the get_debug_output tool
      */
@@ -6315,7 +6524,9 @@ class GodotServer {
             const transport = new StdioServerTransport();
             await this.server.connect(transport);
             console.error('Godot MCP server running on stdio');
-            this.startHealthServer();
+            // Start the Godot Editor Bridge (WebSocket server for editor plugin)
+            await this.godotBridge.start();
+            console.error('[SERVER] Godot Editor Bridge started on port 6505');
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -6323,78 +6534,6 @@ class GodotServer {
             process.exit(1);
         }
     }
-    /**
-     * Start a lightweight HTTP server for health checks from Godot editor plugin.
-     * Supports GET /health and POST / (MCP initialize handshake).
-     */
-    startHealthServer() {
-        const httpServer = createServer((req, res) => {
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept');
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204);
-                res.end();
-                return;
-            }
-            if (req.method === 'GET' && (req.url === '/health' || req.url === '/')) {
-                const payload = {
-                    status: 'ok',
-                    serverName: 'godot-mcp',
-                    version: '1.1.0',
-                    godotPath: this.godotPath,
-                    uptime: process.uptime(),
-                    timestamp: new Date().toISOString(),
-                };
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(payload));
-                return;
-            }
-            if (req.method === 'POST' && (req.url === '/' || req.url === '/mcp')) {
-                let body = '';
-                req.on('data', (chunk) => { body += chunk.toString(); });
-                req.on('end', () => {
-                    try {
-                        const parsed = JSON.parse(body);
-                        if (parsed.method === 'initialize') {
-                            const response = {
-                                jsonrpc: '2.0',
-                                id: parsed.id ?? 1,
-                                result: {
-                                    protocolVersion: parsed.params?.protocolVersion || '2025-06-18',
-                                    capabilities: {},
-                                    serverInfo: { name: 'godot-mcp', version: '1.1.0' },
-                                },
-                            };
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify(response));
-                            return;
-                        }
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Unsupported method' }));
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON' }));
-                    }
-                });
-                return;
-            }
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Not found' }));
-        });
-        httpServer.listen(HEALTH_PORT, () => {
-            console.error(`[SERVER] Health endpoint: http://localhost:${HEALTH_PORT}/health`);
-        });
-        httpServer.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                console.error(`[SERVER] Port ${HEALTH_PORT} in use — health endpoint disabled`);
-            }
-            else {
-                console.error(`[SERVER] Health endpoint error: ${err.message}`);
-            }
-        });
-    }
     // ============================================
     // 2D Tile Tools Handlers
     // ============================================
@@ -7183,6 +7322,40 @@ uniform float dissolve_amount : hint_range(0.0, 1.0) = 0.0;
         }
         return await this.executeOperation('modify_resource', params, projectPath);
     }
+    async handleMapProject(args) {
+        const projectPath = args?.projectPath || args?.project_path;
+        if (!projectPath) {
+            throw new McpError(ErrorCode.InvalidParams, 'projectPath is required');
+        }
+        const root = args?.root || 'res://';
+        const includeAddons = args?.include_addons || false;
+        const result = mapProject(projectPath, root, includeAddons);
+        if (!result.ok || !result.project_map) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ ok: false, error: result.error || 'Failed to map project' }) }],
+                isError: true,
+            };
+        }
+        setProjectPath(projectPath);
+        try {
+            const url = await serveVisualization(result.project_map, this.godotBridge);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({
+                            ok: true,
+                            url,
+                            total_scripts: result.project_map.total_scripts,
+                            total_connections: result.project_map.total_connections,
+                            message: `Interactive project map opened at ${url} — ${result.project_map.total_scripts} scripts, ${result.project_map.total_connections} connections`,
+                        }, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ ok: false, error: `Failed to start visualizer: ${errMsg}`, project_map: result.project_map }) }],
+            };
+        }
+    }
 }
 // Create and run the server
 const server = new GodotServer();