gopeak 2.3.3 → 2.3.4

package/README.md

@@ -14,6 +14,8 @@
 
 **GoPeak is an MCP server for Godot that lets AI assistants run, inspect, modify, and debug real projects end-to-end.**
 
+> Discord community chat is temporarily unavailable while the invite link is refreshed. Please use GitHub Discussions in the meantime: https://github.com/HaD0Yun/Gopeak-godot-mcp/discussions
+
 ---
 
 ## Quick Start (3 Minutes)

package/build/cli/setup.js

@@ -5,7 +5,7 @@
  * with a precheck function that displays cached GoPeak update notifications.
  */
 import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
-import { getShellRcFile, getShellName, getLocalVersion, ensureGopeakDir, ONBOARDING_SHOWN_FILE, STAR_PROMPTED_FILE, } from './utils.js';
+import { getShellRcFile, getShellName, getLocalVersion, ensureGopeakDir, ONBOARDING_SHOWN_FILE, STAR_PROMPTED_FILE, supportsShellHooks, } from './utils.js';
 const MARKER_START = '# >>> GoPeak shell hooks >>>';
 const MARKER_END = '# <<< GoPeak shell hooks <<<';
 /** The shell hook block that gets appended to the RC file. */
@@ -55,6 +55,13 @@ function generateHookBlock() {
 }
 export async function setupShellHooks(args = []) {
     const silent = args.includes('--silent');
+    if (!supportsShellHooks()) {
+        if (!silent) {
+            console.log('ℹ️  GoPeak shell hooks are only installed for bash/zsh on Unix-like systems.');
+            console.log('   Skipping shell hook setup on this platform/shell.');
+        }
+        return;
+    }
     const rcFile = getShellRcFile();
     const shellName = getShellName();
     const log = silent ? (..._args) => { } : console.log.bind(console);

package/build/cli/utils.js

@@ -122,6 +122,11 @@ export function getShellName() {
         return 'zsh';
     return 'bash';
 }
+export function supportsShellHooks(platform = process.platform, shell = process.env.SHELL ?? '') {
+    if (platform === 'win32')
+        return false;
+    return shell.includes('bash') || shell.includes('zsh');
+}
 /* ------------------------------------------------------------------ */
 /*  Command helpers                                                    */
 /* ------------------------------------------------------------------ */

package/build/index.js

@@ -694,7 +694,7 @@ class GodotServer {
                     resolve({
                         content: [
                             { type: 'text', text: `Screenshot captured: ${parsed.width}x${parsed.height} ${parsed.format}` },
-                            { type: 'image', text: parsed.data },
+                            { type: 'image', data: parsed.data, mimeType: 'image/png' },
                         ],
                     });
                     return;
@@ -793,8 +793,41 @@ class GodotServer {
         }
         return handleDAPTool(this.dapClient, toolName, args);
     }
+    sanitizeExportedToolName(toolName) {
+        const sanitized = toolName
+            .normalize('NFKD')
+            .replace(/[^\x00-\x7F]/g, '')
+            .replace(/[^a-zA-Z0-9-]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .slice(0, 128);
+        return sanitized.length > 0 ? sanitized : 'tool';
+    }
+    buildToolNameResolutionMap(allTools) {
+        const resolutionMap = new Map();
+        const register = (candidateName, resolvedName) => {
+            const existing = resolutionMap.get(candidateName);
+            if (existing && existing !== resolvedName) {
+                throw new Error(`Sanitized tool name collision: "${candidateName}" maps to both "${existing}" and "${resolvedName}"`);
+            }
+            resolutionMap.set(candidateName, resolvedName);
+        };
+        for (const tool of allTools) {
+            register(tool.name, tool.name);
+            register(this.sanitizeExportedToolName(tool.name), tool.name);
+        }
+        for (const [compactName, legacyName] of Object.entries(this.compactAliasToLegacy)) {
+            register(compactName, legacyName);
+            register(this.sanitizeExportedToolName(compactName), legacyName);
+        }
+        return resolutionMap;
+    }
     resolveToolAlias(requestedToolName) {
-        return this.compactAliasToLegacy[requestedToolName] || requestedToolName;
+        const allTools = this.getAllToolDefinitions();
+        const resolutionMap = this.buildToolNameResolutionMap(allTools);
+        return resolutionMap.get(requestedToolName)
+            || resolutionMap.get(this.sanitizeExportedToolName(requestedToolName))
+            || requestedToolName;
     }
     buildCompactTools(allTools) {
         const compactTools = [];
@@ -811,6 +844,26 @@ class GodotServer {
         }
         return compactTools;
     }
+    sanitizeToolsForList(tools) {
+        const seenNames = new Map();
+        return tools.map((tool) => {
+            const sanitizedName = this.sanitizeExportedToolName(tool.name);
+            const existing = seenNames.get(sanitizedName);
+            if (existing && existing !== tool.name) {
+                throw new Error(`Sanitized tool name collision in tools/list: "${sanitizedName}" from "${existing}" and "${tool.name}"`);
+            }
+            seenNames.set(sanitizedName, tool.name);
+            if (sanitizedName !== tool.name) {
+                this.logDebug(`Exporting tool "${tool.name}" as "${sanitizedName}" for OpenAI-compatible clients`);
+            }
+            return sanitizedName === tool.name
+                ? tool
+                : {
+                    ...tool,
+                    name: sanitizedName,
+                };
+        });
+    }
     getExposedTools(allTools) {
         if (this.toolExposureProfile === 'full' || this.toolExposureProfile === 'legacy') {
             return allTools;
@@ -3626,7 +3679,7 @@ class GodotServer {
         this.server.setRequestHandler(ListToolsRequestSchema, async (request) => {
             const allTools = buildToolDefinitions();
             this.cachedToolDefinitions = allTools;
-            const exposedTools = this.getExposedTools(allTools);
+            const exposedTools = this.sanitizeToolsForList(this.getExposedTools(allTools));
             return this.paginateToolsForList(exposedTools, request.params?.cursor);
         });
         // Handle tool calls
@@ -6433,27 +6486,14 @@ class GodotServer {
             return this.createErrorResponse('Project path is required', ['Provide a valid path to a Godot project directory']);
         }
         try {
-            // Runtime inspection requires a running Godot instance
-            if (!this.activeProcess) {
-                return this.createErrorResponse('No active Godot process', ['Use run_project to start a Godot instance first']);
-            }
-            // Return information about the running process
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'running',
-                            nodePath: args.nodePath || '/',
-                            depth: args.depth || 3,
-                            note: 'Runtime tree inspection requires the godot_mcp_runtime addon. Current output shows debug logs.',
-                            recentOutput: this.activeProcess.output.slice(-20),
-                            recentErrors: this.activeProcess.errors.slice(-10),
-                        }, null, 2),
-                    }],
-            };
+            return await this.handleRuntimeCommand('get_tree', {
+                root: args.nodePath || '/root',
+                depth: args.depth || 3,
+                include_properties: Boolean(args.includeProperties),
+            });
         }
         catch (error) {
-            return this.createErrorResponse(`Failed to inspect runtime tree: ${error?.message || 'Unknown error'}`, ['Ensure a Godot process is running']);
+            return this.createErrorResponse(`Failed to inspect runtime tree: ${error?.message || 'Unknown error'}`, ['Ensure a Godot process is running with the runtime addon enabled']);
         }
     }
     /**
@@ -6465,24 +6505,11 @@ class GodotServer {
             return this.createErrorResponse('Missing required parameters', ['Provide projectPath, nodePath, property, and value']);
         }
         try {
-            if (!this.activeProcess) {
-                return this.createErrorResponse('No active Godot process', ['Use run_project to start a Godot instance first']);
-            }
-            // Runtime property modification requires the addon
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'not_implemented',
-                            note: 'Runtime property modification requires the godot_mcp_runtime addon installed in the running project.',
-                            requested: {
-                                nodePath: args.nodePath,
-                                property: args.property,
-                                value: args.value,
-                            },
-                        }, null, 2),
-                    }],
-            };
+            return await this.handleRuntimeCommand('set_property', {
+                path: args.nodePath,
+                property: args.property,
+                value: args.value,
+            });
         }
         catch (error) {
             return this.createErrorResponse(`Failed to set runtime property: ${error?.message || 'Unknown error'}`, ['Ensure a Godot process is running with the runtime addon']);
@@ -6497,24 +6524,11 @@ class GodotServer {
             return this.createErrorResponse('Missing required parameters', ['Provide projectPath, nodePath, and method']);
         }
         try {
-            if (!this.activeProcess) {
-                return this.createErrorResponse('No active Godot process', ['Use run_project to start a Godot instance first']);
-            }
-            // Runtime method calling requires the addon
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'not_implemented',
-                            note: 'Runtime method calling requires the godot_mcp_runtime addon installed in the running project.',
-                            requested: {
-                                nodePath: args.nodePath,
-                                method: args.method,
-                                args: args.args || [],
-                            },
-                        }, null, 2),
-                    }],
-            };
+            return await this.handleRuntimeCommand('call_method', {
+                path: args.nodePath,
+                method: args.method,
+                args: Array.isArray(args.args) ? args.args : [],
+            });
         }
         catch (error) {
             return this.createErrorResponse(`Failed to call runtime method: ${error?.message || 'Unknown error'}`, ['Ensure a Godot process is running with the runtime addon']);
@@ -6529,24 +6543,9 @@ class GodotServer {
             return this.createErrorResponse('Project path is required', ['Provide a valid path to a Godot project directory']);
         }
         try {
-            if (!this.activeProcess) {
-                return this.createErrorResponse('No active Godot process', ['Use run_project to start a Godot instance first']);
-            }
-            // Basic metrics from process output
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            status: 'running',
-                            metrics: {
-                                outputLines: this.activeProcess.output.length,
-                                errorLines: this.activeProcess.errors.length,
-                                note: 'Detailed metrics require the godot_mcp_runtime addon.',
-                            },
-                            requestedMetrics: args.metrics || 'all',
-                        }, null, 2),
-                    }],
-            };
+            return await this.handleRuntimeCommand('get_metrics', {
+                metrics: Array.isArray(args.metrics) ? args.metrics : [],
+            });
         }
         catch (error) {
             return this.createErrorResponse(`Failed to get runtime metrics: ${error?.message || 'Unknown error'}`, ['Ensure a Godot process is running']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gopeak",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "mcpName": "io.github.HaD0Yun/gopeak",
   "description": "GoPeak — The most comprehensive MCP server for Godot Engine. 95+ tools: scene management, GDScript LSP diagnostics, DAP debugger, screenshot capture, input injection, ClassDB introspection, CC0 asset library. AI-assisted game development with Claude, Cursor, Cline, OpenCode.",
   "type": "module",
@@ -29,7 +29,8 @@
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector build/index.js",
     "pack": "npm pack --dry-run",
-    "version:bump": "node scripts/bump-version.mjs"
+    "version:bump": "node scripts/bump-version.mjs",
+    "test:setup": "npm run build && node test-setup-hooks.mjs"
   },
   "engines": {
     "node": ">=18"
@@ -48,7 +49,7 @@
   },
   "overrides": {
     "@hono/node-server": "^1.19.11",
-    "hono": "^4.12.5"
+    "hono": "4.12.7"
   },
   "license": "MIT",
   "repository": {