@akiojin/unity-mcp-server 2.40.2 → 2.40.3

package/src/handlers/script/ScriptSymbolsGetToolHandler.js

@@ -4,93 +4,102 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import { ProjectInfoProvider } from '../../core/projectInfo.js';
 
 export class ScriptSymbolsGetToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'script_symbols_get',
-            'FIRST STEP: Identify symbols (classes, methods, fields, properties) with spans before any edit. Path must start with Assets/ or Packages/. Use this to scope changes to a single symbol and avoid line-based edits. Returns line/column positions and container names (helpful to build container namePath like Outer/Nested/Member).',
-            {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'Project-relative .cs path under Assets/ or Packages/ (e.g., Packages/unity-mcp-server/Editor/Foo.cs). Do NOT prefix repository folders (e.g., UnityMCPServer/…).'
-                    }
-                },
-                required: ['path']
-            }
-        );
-        this.unityConnection = unityConnection;
-        this.projectInfo = new ProjectInfoProvider(unityConnection);
-    }
+  constructor(unityConnection) {
+    super(
+      'script_symbols_get',
+      'FIRST STEP: Identify symbols (classes, methods, fields, properties) with spans before any edit. Path must start with Assets/ or Packages/. Use this to scope changes to a single symbol and avoid line-based edits. Returns line/column positions and container names (helpful to build container namePath like Outer/Nested/Member).',
+      {
+        type: 'object',
+        properties: {
+          path: {
+            type: 'string',
+            description:
+              'Project-relative .cs path under Assets/ or Packages/ (e.g., Packages/unity-mcp-server/Editor/Foo.cs). Do NOT prefix repository folders (e.g., UnityMCPServer/…).'
+          }
+        },
+        required: ['path']
+      }
+    );
+    this.unityConnection = unityConnection;
+    this.projectInfo = new ProjectInfoProvider(unityConnection);
+  }
 
-    validate(params) {
-        super.validate(params);
+  validate(params) {
+    super.validate(params);
 
-        const { path } = params;
+    const { path } = params;
 
-        if (!path || path.trim() === '') {
-            throw new Error('path cannot be empty');
-        }
+    if (!path || path.trim() === '') {
+      throw new Error('path cannot be empty');
+    }
 
-        // Check for .cs extension
-        if (!path.endsWith('.cs')) {
-            throw new Error('Only .cs files are supported');
-        }
+    // Check for .cs extension
+    if (!path.endsWith('.cs')) {
+      throw new Error('Only .cs files are supported');
     }
+  }
 
-    async execute(params) {
-        // Normalize to project-relative path (strip repo-root prefixes if provided)
-        const rawPath = String(params.path || '').replace(/\\/g, '/');
-        const ai = rawPath.indexOf('Assets/');
-        const pi = rawPath.indexOf('Packages/');
-        const cut = (ai >= 0 && pi >= 0) ? Math.min(ai, pi) : (ai >= 0 ? ai : pi);
-        const relPath = cut >= 0 ? rawPath.substring(cut) : rawPath;
+  async execute(params) {
+    // Normalize to project-relative path (strip repo-root prefixes if provided)
+    const rawPath = String(params.path || '').replace(/\\/g, '/');
+    const ai = rawPath.indexOf('Assets/');
+    const pi = rawPath.indexOf('Packages/');
+    const cut = ai >= 0 && pi >= 0 ? Math.min(ai, pi) : ai >= 0 ? ai : pi;
+    const relPath = cut >= 0 ? rawPath.substring(cut) : rawPath;
 
-        try {
-            const info = await this.projectInfo.get();
-            if (!relPath.startsWith('Assets/') && !relPath.startsWith('Packages/')) {
-                return { error: 'Path must be under Assets/ or Packages/' };
-            }
-            const abs = path.join(info.projectRoot, relPath);
-            const st = await fs.stat(abs).catch(() => null);
-            if (!st || !st.isFile()) return { error: 'File not found', path: relPath };
-            const { LspRpcClient } = await import('../../lsp/LspRpcClient.js');
-            const lsp = new LspRpcClient(info.projectRoot);
-            const uri = 'file://' + abs.replace(/\\\\/g, '/');
-            const res = await lsp.request('textDocument/documentSymbol', { textDocument: { uri } });
-            const docSymbols = res?.result ?? res ?? [];
-            const list = [];
-            const visit = (s, container) => {
-                const start = s.range?.start || s.selectionRange?.start || {};
-                list.push({
-                    name: s.name || '',
-                    kind: this.mapKind(s.kind),
-                    container: container || null,
-                    namespace: null,
-                    startLine: (start.line ?? 0) + 1,
-                    startColumn: (start.character ?? 0) + 1,
-                    endLine: (start.line ?? 0) + 1,
-                    endColumn: (start.character ?? 0) + 1
-                });
-                if (Array.isArray(s.children)) for (const c of s.children) visit(c, s.name || container);
-            };
-            if (Array.isArray(docSymbols)) for (const s of docSymbols) visit(s, null);
-            return { success: true, path: relPath, symbols: list };
-        } catch (e) {
-            return { error: e.message || 'Failed to get symbols' };
-        }
+    try {
+      const info = await this.projectInfo.get();
+      if (!relPath.startsWith('Assets/') && !relPath.startsWith('Packages/')) {
+        return { error: 'Path must be under Assets/ or Packages/' };
+      }
+      const abs = path.join(info.projectRoot, relPath);
+      const st = await fs.stat(abs).catch(() => null);
+      if (!st || !st.isFile()) return { error: 'File not found', path: relPath };
+      const { LspRpcClient } = await import('../../lsp/LspRpcClient.js');
+      const lsp = new LspRpcClient(info.projectRoot);
+      const uri = 'file://' + abs.replace(/\\\\/g, '/');
+      const res = await lsp.request('textDocument/documentSymbol', { textDocument: { uri } });
+      const docSymbols = res?.result ?? res ?? [];
+      const list = [];
+      const visit = (s, container) => {
+        const start = s.range?.start || s.selectionRange?.start || {};
+        list.push({
+          name: s.name || '',
+          kind: this.mapKind(s.kind),
+          container: container || null,
+          namespace: null,
+          startLine: (start.line ?? 0) + 1,
+          startColumn: (start.character ?? 0) + 1,
+          endLine: (start.line ?? 0) + 1,
+          endColumn: (start.character ?? 0) + 1
+        });
+        if (Array.isArray(s.children)) for (const c of s.children) visit(c, s.name || container);
+      };
+      if (Array.isArray(docSymbols)) for (const s of docSymbols) visit(s, null);
+      return { success: true, path: relPath, symbols: list };
+    } catch (e) {
+      return { error: e.message || 'Failed to get symbols' };
     }
+  }
 
-    mapKind(k) {
-        switch (k) {
-            case 5: return 'class';
-            case 23: return 'struct';
-            case 11: return 'interface';
-            case 10: return 'enum';
-            case 6: return 'method';
-            case 7: return 'property';
-            case 8: return 'field';
-            default: return undefined;
-        }
+  mapKind(k) {
+    switch (k) {
+      case 5:
+        return 'class';
+      case 23:
+        return 'struct';
+      case 11:
+        return 'interface';
+      case 10:
+        return 'enum';
+      case 6:
+        return 'method';
+      case 7:
+        return 'property';
+      case 8:
+        return 'field';
+      default:
+        return undefined;
     }
+  }
 }

package/src/handlers/settings/SettingsGetToolHandler.js

@@ -13,19 +13,23 @@ export class SettingsGetToolHandler extends BaseToolHandler {
         properties: {
           includePlayer: {
             type: 'boolean',
-            description: 'Include player settings (company/product name, version, etc.) (default: true).'
+            description:
+              'Include player settings (company/product name, version, etc.) (default: true).'
           },
           includeGraphics: {
             type: 'boolean',
-            description: 'Include graphics settings (color space, render pipeline, etc.) (default: false).'
+            description:
+              'Include graphics settings (color space, render pipeline, etc.) (default: false).'
           },
           includeQuality: {
             type: 'boolean',
-            description: 'Include quality settings (levels, anti-aliasing, shadows, etc.) (default: false).'
+            description:
+              'Include quality settings (levels, anti-aliasing, shadows, etc.) (default: false).'
           },
           includePhysics: {
             type: 'boolean',
-            description: 'Include 3D physics settings (gravity, solver iterations, etc.) (default: false).'
+            description:
+              'Include 3D physics settings (gravity, solver iterations, etc.) (default: false).'
           },
           includePhysics2D: {
             type: 'boolean',
@@ -33,11 +37,13 @@ export class SettingsGetToolHandler extends BaseToolHandler {
           },
           includeAudio: {
             type: 'boolean',
-            description: 'Include audio settings (speaker mode, DSP buffer, volume, etc.) (default: false).'
+            description:
+              'Include audio settings (speaker mode, DSP buffer, volume, etc.) (default: false).'
           },
           includeTime: {
             type: 'boolean',
-            description: 'Include time settings (fixed timestep, time scale, etc.) (default: false).'
+            description:
+              'Include time settings (fixed timestep, time scale, etc.) (default: false).'
           },
           includeInputManager: {
             type: 'boolean',
@@ -45,11 +51,13 @@ export class SettingsGetToolHandler extends BaseToolHandler {
           },
           includeEditor: {
             type: 'boolean',
-            description: 'Include editor settings (Unity Remote, serialization mode, etc.) (default: false).'
+            description:
+              'Include editor settings (Unity Remote, serialization mode, etc.) (default: false).'
           },
           includeBuild: {
             type: 'boolean',
-            description: 'Include build settings (scenes in build, build target, etc.) (default: false).'
+            description:
+              'Include build settings (scenes in build, build target, etc.) (default: false).'
           },
           includeTags: {
             type: 'boolean',
@@ -59,7 +67,7 @@ export class SettingsGetToolHandler extends BaseToolHandler {
         required: []
       }
     );
-    
+
     this.unityConnection = unityConnection;
   }
 
@@ -71,10 +79,17 @@ export class SettingsGetToolHandler extends BaseToolHandler {
   validate(params) {
     // All parameters are optional booleans with defaults, no special validation needed
     const booleanParams = [
-      'includePlayer', 'includeGraphics', 'includeQuality',
-      'includePhysics', 'includePhysics2D', 'includeAudio',
-      'includeTime', 'includeInputManager', 'includeEditor',
-      'includeBuild', 'includeTags'
+      'includePlayer',
+      'includeGraphics',
+      'includeQuality',
+      'includePhysics',
+      'includePhysics2D',
+      'includeAudio',
+      'includeTime',
+      'includeInputManager',
+      'includeEditor',
+      'includeBuild',
+      'includeTags'
     ];
 
     for (const param of booleanParams) {

package/src/handlers/settings/SettingsUpdateToolHandler.js

@@ -110,14 +110,18 @@ export class SettingsUpdateToolHandler extends BaseToolHandler {
                 enum: [0, 2, 4, 8],
                 description: 'Anti-aliasing samples'
               },
-              shadowDistance: { type: 'number', minimum: 0, description: 'Shadow rendering distance' }
+              shadowDistance: {
+                type: 'number',
+                minimum: 0,
+                description: 'Shadow rendering distance'
+              }
             }
           }
         },
         required: ['confirmChanges']
       }
     );
-    
+
     this.unityConnection = unityConnection;
   }
 
@@ -129,13 +133,23 @@ export class SettingsUpdateToolHandler extends BaseToolHandler {
   validate(params) {
     // Require explicit confirmation
     if (!params.confirmChanges) {
-      throw new Error('confirmChanges must be set to true to update settings. This is a safety measure to prevent accidental changes.');
+      throw new Error(
+        'confirmChanges must be set to true to update settings. This is a safety measure to prevent accidental changes.'
+      );
     }
 
     // Check that at least one settings category is provided
-    const settingsCategories = ['player', 'graphics', 'physics', 'physics2D', 'audio', 'time', 'quality'];
+    const settingsCategories = [
+      'player',
+      'graphics',
+      'physics',
+      'physics2D',
+      'audio',
+      'time',
+      'quality'
+    ];
     const hasSettings = settingsCategories.some(cat => params[cat] !== undefined);
-    
+
     if (!hasSettings) {
       throw new Error('At least one settings category must be provided to update');
     }
@@ -261,7 +275,7 @@ export class SettingsUpdateToolHandler extends BaseToolHandler {
       safetyCheckExample: {
         description: 'Example showing safety check (will fail)',
         params: {
-          confirmChanges: false,  // This will trigger safety check
+          confirmChanges: false, // This will trigger safety check
           player: {
             productName: 'Accidental Change'
           }

package/src/handlers/ui/UIClickElementToolHandler.js

@@ -1,110 +1,101 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class UIClickElementToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'ui_click_element',
-            'Simulate clicking on UI elements',
-            {
-                type: 'object',
-                properties: {
-                    elementPath: {
-                        type: 'string',
-                        description: 'Full hierarchy path to the UI element'
-                    },
-                    clickType: {
-                        type: 'string',
-                        enum: ['left', 'right', 'middle'],
-                        
-                        description: 'Type of click (left, right, middle)'
-                    },
-                    holdDuration: {
-                        type: 'number',
-                        
-                        minimum: 0,
-                        maximum: 10000,
-                        description: 'Duration to hold click in milliseconds'
-                    },
-                    position: {
-                        type: 'object',
-                        properties: {
-                            x: {
-                                type: 'number',
-                                minimum: 0,
-                                maximum: 1,
-                                description: 'X position within element (0-1)'
-                            },
-                            y: {
-                                type: 'number',
-                                minimum: 0,
-                                maximum: 1,
-                                description: 'Y position within element (0-1)'
-                            }
-                        },
-                        description: 'Specific position within element to click'
-                    }
-                },
-                required: ['elementPath']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
+  constructor(unityConnection) {
+    super('ui_click_element', 'Simulate clicking on UI elements', {
+      type: 'object',
+      properties: {
+        elementPath: {
+          type: 'string',
+          description: 'Full hierarchy path to the UI element'
+        },
+        clickType: {
+          type: 'string',
+          enum: ['left', 'right', 'middle'],
 
-    validate(params) {
-        // Call parent validation for required fields
-        super.validate(params);
-
-        // Validate clickType enum
-        if (params.clickType && !['left', 'right', 'middle'].includes(params.clickType)) {
-            throw new Error('clickType must be one of: left, right, middle');
-        }
+          description: 'Type of click (left, right, middle)'
+        },
+        holdDuration: {
+          type: 'number',
 
-        // Validate holdDuration range
-        if (params.holdDuration !== undefined) {
-            const duration = params.holdDuration;
-            if (typeof duration !== 'number' || duration < 0 || duration > 10000) {
-                throw new Error('holdDuration must be between 0 and 10000 milliseconds');
+          minimum: 0,
+          maximum: 10000,
+          description: 'Duration to hold click in milliseconds'
+        },
+        position: {
+          type: 'object',
+          properties: {
+            x: {
+              type: 'number',
+              minimum: 0,
+              maximum: 1,
+              description: 'X position within element (0-1)'
+            },
+            y: {
+              type: 'number',
+              minimum: 0,
+              maximum: 1,
+              description: 'Y position within element (0-1)'
             }
+          },
+          description: 'Specific position within element to click'
         }
+      },
+      required: ['elementPath']
+    });
+    this.unityConnection = unityConnection;
+  }
 
-        // Validate position object
-        if (params.position) {
-            const pos = params.position;
-            if (pos.x !== undefined && typeof pos.x !== 'number') {
-                throw new Error('position.x must be a number');
-            }
-            if (pos.y !== undefined && typeof pos.y !== 'number') {
-                throw new Error('position.y must be a number');
-            }
-            if (pos.x !== undefined && (pos.x < 0 || pos.x > 1)) {
-                throw new Error('position.x must be between 0 and 1');
-            }
-            if (pos.y !== undefined && (pos.y < 0 || pos.y > 1)) {
-                throw new Error('position.y must be between 0 and 1');
-            }
-        }
+  validate(params) {
+    // Call parent validation for required fields
+    super.validate(params);
+
+    // Validate clickType enum
+    if (params.clickType && !['left', 'right', 'middle'].includes(params.clickType)) {
+      throw new Error('clickType must be one of: left, right, middle');
     }
 
-    async execute(params) {
-        const {
-            elementPath,
-            clickType = 'left',
-            holdDuration = 0,
-            position
-        } = params;
+    // Validate holdDuration range
+    if (params.holdDuration !== undefined) {
+      const duration = params.holdDuration;
+      if (typeof duration !== 'number' || duration < 0 || duration > 10000) {
+        throw new Error('holdDuration must be between 0 and 10000 milliseconds');
+      }
+    }
 
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
+    // Validate position object
+    if (params.position) {
+      const pos = params.position;
+      if (pos.x !== undefined && typeof pos.x !== 'number') {
+        throw new Error('position.x must be a number');
+      }
+      if (pos.y !== undefined && typeof pos.y !== 'number') {
+        throw new Error('position.y must be a number');
+      }
+      if (pos.x !== undefined && (pos.x < 0 || pos.x > 1)) {
+        throw new Error('position.x must be between 0 and 1');
+      }
+      if (pos.y !== undefined && (pos.y < 0 || pos.y > 1)) {
+        throw new Error('position.y must be between 0 and 1');
+      }
+    }
+  }
 
-        const result = await this.unityConnection.sendCommand('click_ui_element', {
-            elementPath,
-            clickType,
-            holdDuration,
-            position
-        });
+  async execute(params) {
+    const { elementPath, clickType = 'left', holdDuration = 0, position } = params;
 
-        return result;
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
     }
-}
+
+    const result = await this.unityConnection.sendCommand('click_ui_element', {
+      elementPath,
+      clickType,
+      holdDuration,
+      position
+    });
+
+    return result;
+  }
+}

package/src/handlers/ui/UIFindElementsToolHandler.js

@@ -1,63 +1,53 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class UIFindElementsToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'ui_find_elements',
-            'Find UI elements by component type, tag, or name pattern.',
-            {
-                type: 'object',
-                properties: {
-                    elementType: {
-                        type: 'string',
-                        description: 'UI component type (e.g., Button, Toggle, Slider).'
-                    },
-                    tagFilter: {
-                        type: 'string',
-                        description: 'Filter by GameObject tag.'
-                    },
-                    namePattern: {
-                        type: 'string',
-                        description: 'Search by name substring or regex.'
-                    },
-                    includeInactive: {
-                        type: 'boolean',
-                        description: 'If true, include inactive UI elements.'
-                    },
-                    canvasFilter: {
-                        type: 'string',
-                        description: 'Filter by parent Canvas name.'
-                    }
-                },
-                required: []
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
-
-    async execute(params = {}) {
-        const {
-            elementType,
-            tagFilter,
-            namePattern,
-            includeInactive = false,
-            canvasFilter
-        } = params;
-
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
+  constructor(unityConnection) {
+    super('ui_find_elements', 'Find UI elements by component type, tag, or name pattern.', {
+      type: 'object',
+      properties: {
+        elementType: {
+          type: 'string',
+          description: 'UI component type (e.g., Button, Toggle, Slider).'
+        },
+        tagFilter: {
+          type: 'string',
+          description: 'Filter by GameObject tag.'
+        },
+        namePattern: {
+          type: 'string',
+          description: 'Search by name substring or regex.'
+        },
+        includeInactive: {
+          type: 'boolean',
+          description: 'If true, include inactive UI elements.'
+        },
+        canvasFilter: {
+          type: 'string',
+          description: 'Filter by parent Canvas name.'
         }
+      },
+      required: []
+    });
+    this.unityConnection = unityConnection;
+  }
 
-        const result = await this.unityConnection.sendCommand('find_ui_elements', {
-            elementType,
-            tagFilter,
-            namePattern,
-            includeInactive,
-            canvasFilter
-        });
+  async execute(params = {}) {
+    const { elementType, tagFilter, namePattern, includeInactive = false, canvasFilter } = params;
 
-        // Return the result for the BaseToolHandler to format
-        return result;
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
     }
+
+    const result = await this.unityConnection.sendCommand('find_ui_elements', {
+      elementType,
+      tagFilter,
+      namePattern,
+      includeInactive,
+      canvasFilter
+    });
+
+    // Return the result for the BaseToolHandler to format
+    return result;
+  }
 }