@akiojin/unity-mcp-server 2.40.2 → 2.40.3

package/src/handlers/console/ConsoleClearToolHandler.js

@@ -5,37 +5,36 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export class ConsoleClearToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super(
-      'console_clear',
-      'Clear Console logs (optionally set auto-clear and preserve levels).',
-      {
-        type: 'object',
-        properties: {
-          clearOnPlay: {
-            type: 'boolean',
-            description: 'Clear console when entering play mode. Unity default: false. Set to true for cleaner testing sessions'
-          },
-          clearOnRecompile: {
-            type: 'boolean',
-            description: 'Clear console on script recompilation. Unity default: false. Set to true to focus on current compilation errors'
-          },
-          clearOnBuild: {
-            type: 'boolean',
-            description: 'Clear console when building. Unity default: false. Set to true for clean build logs'
-          },
-          preserveWarnings: {
-            type: 'boolean',
-            description: 'Preserve warning messages when clearing (default: false)'
-          },
-          preserveErrors: {
-            type: 'boolean',
-            description: 'Preserve error messages when clearing (default: false)'
-          }
+    super('console_clear', 'Clear Console logs (optionally set auto-clear and preserve levels).', {
+      type: 'object',
+      properties: {
+        clearOnPlay: {
+          type: 'boolean',
+          description:
+            'Clear console when entering play mode. Unity default: false. Set to true for cleaner testing sessions'
         },
-        required: []
-      }
-    );
-    
+        clearOnRecompile: {
+          type: 'boolean',
+          description:
+            'Clear console on script recompilation. Unity default: false. Set to true to focus on current compilation errors'
+        },
+        clearOnBuild: {
+          type: 'boolean',
+          description:
+            'Clear console when building. Unity default: false. Set to true for clean build logs'
+        },
+        preserveWarnings: {
+          type: 'boolean',
+          description: 'Preserve warning messages when clearing (default: false)'
+        },
+        preserveErrors: {
+          type: 'boolean',
+          description: 'Preserve error messages when clearing (default: false)'
+        }
+      },
+      required: []
+    });
+
     this.unityConnection = unityConnection;
   }
 
@@ -45,13 +44,8 @@ export class ConsoleClearToolHandler extends BaseToolHandler {
    * @throws {Error} If validation fails
    */
   validate(params) {
-    const {
-      clearOnPlay,
-      clearOnRecompile,
-      clearOnBuild,
-      preserveWarnings,
-      preserveErrors
-    } = params;
+    const { clearOnPlay, clearOnRecompile, clearOnBuild, preserveWarnings, preserveErrors } =
+      params;
 
     // Validate boolean parameters
     if (clearOnPlay !== undefined && typeof clearOnPlay !== 'boolean') {
@@ -75,9 +69,10 @@ export class ConsoleClearToolHandler extends BaseToolHandler {
     }
 
     // Validate logical consistency
-    const isClearing = clearOnPlay !== false || clearOnRecompile !== false || clearOnBuild !== false;
+    const isClearing =
+      clearOnPlay !== false || clearOnRecompile !== false || clearOnBuild !== false;
     const isPreserving = preserveWarnings === true || preserveErrors === true;
-    
+
     if (isPreserving && !isClearing) {
       throw new Error('Cannot preserve specific log types when not clearing console');
     }
@@ -89,13 +84,8 @@ export class ConsoleClearToolHandler extends BaseToolHandler {
    * @returns {Promise<Object>} The result of the clear operation
    */
   async execute(params) {
-    const {
-      clearOnPlay,
-      clearOnRecompile,
-      clearOnBuild,
-      preserveWarnings,
-      preserveErrors
-    } = params;
+    const { clearOnPlay, clearOnRecompile, clearOnBuild, preserveWarnings, preserveErrors } =
+      params;
 
     // Ensure connection to Unity
     if (!this.unityConnection.isConnected()) {

package/src/handlers/editor/EditorLayersManageToolHandler.js

@@ -18,7 +18,8 @@ export class EditorLayersManageToolHandler extends BaseToolHandler {
           },
           layerName: {
             type: 'string',
-            description: 'Layer name (required for add/remove/get_by_name). Letters/numbers/space/_ only.'
+            description:
+              'Layer name (required for add/remove/get_by_name). Letters/numbers/space/_ only.'
           },
           layerIndex: {
             type: 'number',
@@ -68,13 +69,13 @@ export class EditorLayersManageToolHandler extends BaseToolHandler {
           throw new Error('layerName is reserved');
         }
         break;
-      
+
       case 'get_by_name':
         if (layerName === undefined || layerName === null) {
           throw new Error('layerName is required for get_by_name action');
         }
         break;
-      
+
       case 'get_by_index':
         if (layerIndex === undefined || layerIndex === null) {
           throw new Error('layerIndex is required for get_by_index action');
@@ -106,13 +107,13 @@ export class EditorLayersManageToolHandler extends BaseToolHandler {
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
-    
+
     const result = await this.unityConnection.sendCommand('manage_layers', params);
-    
+
     if (result.error) {
       throw new Error(result.error);
     }
-    
+
     return result;
   }
 

package/src/handlers/editor/EditorTagsManageToolHandler.js

@@ -24,11 +24,19 @@ export class EditorTagsManageToolHandler extends BaseToolHandler {
         required: ['action']
       }
     );
-    
+
     this.unityConnection = unityConnection;
-    
+
     // Reserved Unity tags that cannot be removed
-    this.RESERVED_TAGS = ['Untagged', 'Respawn', 'Finish', 'EditorOnly', 'MainCamera', 'Player', 'GameController'];
+    this.RESERVED_TAGS = [
+      'Untagged',
+      'Respawn',
+      'Finish',
+      'EditorOnly',
+      'MainCamera',
+      'Player',
+      'GameController'
+    ];
   }
 
   /**
@@ -37,17 +45,17 @@ export class EditorTagsManageToolHandler extends BaseToolHandler {
    */
   validate(params) {
     const { action, tagName } = params;
-    
+
     // Check if action is provided
     if (!action) {
       throw new Error('action is required');
     }
-    
+
     // Check if action is valid
     if (!['add', 'remove', 'get'].includes(action)) {
       throw new Error('action must be one of: add, remove, get');
     }
-    
+
     // For add and remove actions, tagName is required
     if (action === 'add' || action === 'remove') {
       if (tagName === undefined || tagName === null) {
@@ -57,21 +65,22 @@ export class EditorTagsManageToolHandler extends BaseToolHandler {
         throw new Error('tagName cannot be empty');
       }
     }
-    
+
     // Validate tag name if provided
     if (tagName !== undefined && tagName !== '') {
-      
       // Check for invalid characters (Unity tag names should be alphanumeric with no spaces or special characters)
       if (!/^[a-zA-Z0-9_]+$/.test(tagName)) {
-        throw new Error('tagName contains invalid characters. Only letters, numbers, and underscores are allowed');
+        throw new Error(
+          'tagName contains invalid characters. Only letters, numbers, and underscores are allowed'
+        );
       }
-      
+
       // Check for reserved tag names when adding
       if (action === 'add' && this.RESERVED_TAGS.includes(tagName)) {
         throw new Error(`tagName is reserved`);
       }
     }
-    
+
     // Call parent validation last to avoid conflicts
     super.validate(params);
   }

package/src/handlers/editor/EditorToolsManageToolHandler.js

@@ -46,7 +46,7 @@ export class EditorToolsManageToolHandler extends BaseToolHandler {
       if (params.toolName === undefined || params.toolName === null) {
         throw new Error(`toolName is required for ${params.action} action`);
       }
-      
+
       if (params.toolName === '') {
         throw new Error('toolName cannot be empty');
       }
@@ -60,7 +60,7 @@ export class EditorToolsManageToolHandler extends BaseToolHandler {
 
   async execute(params) {
     this.validate(params);
-    
+
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }

package/src/handlers/editor/EditorWindowsManageToolHandler.js

@@ -18,7 +18,8 @@ export class EditorWindowsManageToolHandler extends BaseToolHandler {
           },
           windowType: {
             type: 'string',
-            description: 'Window type (e.g., SceneView, GameView, InspectorWindow). Required for focus/get_state.'
+            description:
+              'Window type (e.g., SceneView, GameView, InspectorWindow). Required for focus/get_state.'
           },
           includeHidden: {
             type: 'boolean',
@@ -53,7 +54,7 @@ export class EditorWindowsManageToolHandler extends BaseToolHandler {
       if (windowType === undefined || windowType === null) {
         throw new Error(`windowType is required for ${action} action`);
       }
-      
+
       if (windowType === '') {
         throw new Error('windowType cannot be empty');
       }
@@ -71,13 +72,13 @@ export class EditorWindowsManageToolHandler extends BaseToolHandler {
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
-    
+
     const result = await this.unityConnection.sendCommand('manage_windows', params);
-    
+
     if (result.error) {
       throw new Error(result.error);
     }
-    
+
     return result;
   }
 

package/src/handlers/gameobject/GameObjectCreateToolHandler.js

@@ -7,67 +7,63 @@ import { validateVector3, validateLayer } from '../../utils/validators.js';
  */
 export class GameObjectCreateToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super(
-      'gameobject_create',
-      'Create a GameObject in Unity scene',
-      {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'Name of the GameObject (default: "GameObject")'
-          },
-          primitiveType: {
-            type: 'string',
-            description: 'Type of primitive to create',
-            enum: ['cube', 'sphere', 'cylinder', 'capsule', 'plane', 'quad']
-          },
-          position: {
-            type: 'object',
-            description: 'World position',
-            properties: {
-              x: { type: 'number' },
-              y: { type: 'number' },
-              z: { type: 'number' }
-            }
-          },
-          rotation: {
-            type: 'object',
-            description: 'Rotation in Euler angles',
-            properties: {
-              x: { type: 'number' },
-              y: { type: 'number' },
-              z: { type: 'number' }
-            }
-          },
-          scale: {
-            type: 'object',
-            description: 'Local scale',
-            properties: {
-              x: { type: 'number' },
-              y: { type: 'number' },
-              z: { type: 'number' }
-            }
-          },
-          parentPath: {
-            type: 'string',
-            description: 'Path to parent GameObject (e.g., "/Parent/Child")'
-          },
-          tag: {
-            type: 'string',
-            description: 'Tag to assign to the GameObject'
-          },
-          layer: {
-            type: 'number',
-            description: 'Layer index (0-31)',
-            minimum: 0,
-            maximum: 31
+    super('gameobject_create', 'Create a GameObject in Unity scene', {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Name of the GameObject (default: "GameObject")'
+        },
+        primitiveType: {
+          type: 'string',
+          description: 'Type of primitive to create',
+          enum: ['cube', 'sphere', 'cylinder', 'capsule', 'plane', 'quad']
+        },
+        position: {
+          type: 'object',
+          description: 'World position',
+          properties: {
+            x: { type: 'number' },
+            y: { type: 'number' },
+            z: { type: 'number' }
           }
         },
-        required: []
-      }
-    );
-    
+        rotation: {
+          type: 'object',
+          description: 'Rotation in Euler angles',
+          properties: {
+            x: { type: 'number' },
+            y: { type: 'number' },
+            z: { type: 'number' }
+          }
+        },
+        scale: {
+          type: 'object',
+          description: 'Local scale',
+          properties: {
+            x: { type: 'number' },
+            y: { type: 'number' },
+            z: { type: 'number' }
+          }
+        },
+        parentPath: {
+          type: 'string',
+          description: 'Path to parent GameObject (e.g., "/Parent/Child")'
+        },
+        tag: {
+          type: 'string',
+          description: 'Tag to assign to the GameObject'
+        },
+        layer: {
+          type: 'number',
+          description: 'Layer index (0-31)',
+          minimum: 0,
+          maximum: 31
+        }
+      },
+      required: []
+    });
+
     this.unityConnection = unityConnection;
   }
 
@@ -78,7 +74,7 @@ export class GameObjectCreateToolHandler extends BaseToolHandler {
    */
   validate(params) {
     super.validate(params);
-    
+
     // Validate primitive type if provided
     if (params.primitiveType) {
       const validTypes = ['cube', 'sphere', 'cylinder', 'capsule', 'plane', 'quad'];
@@ -86,12 +82,12 @@ export class GameObjectCreateToolHandler extends BaseToolHandler {
         throw new Error(`primitiveType must be one of: ${validTypes.join(', ')}`);
       }
     }
-    
+
     // Validate vector3 properties
     if (params.position) validateVector3(params.position, 'position');
     if (params.rotation) validateVector3(params.rotation, 'rotation');
     if (params.scale) validateVector3(params.scale, 'scale');
-    
+
     // Validate layer
     if (params.layer !== undefined) {
       validateLayer(Number(params.layer));
@@ -105,7 +101,7 @@ export class GameObjectCreateToolHandler extends BaseToolHandler {
    */
   async execute(params) {
     console.error('[CreateGameObject] Starting execution with params:', params);
-    
+
     // Ensure connected
     if (!this.unityConnection.isConnected()) {
       console.error('[CreateGameObject] Not connected to Unity, attempting to connect...');
@@ -114,18 +110,18 @@ export class GameObjectCreateToolHandler extends BaseToolHandler {
     } else {
       console.error('[CreateGameObject] Already connected to Unity');
     }
-    
+
     // Send create_gameobject command
     console.error('[CreateGameObject] Sending command to Unity...');
     const result = await this.unityConnection.sendCommand('create_gameobject', params);
     console.error('[CreateGameObject] Received result from Unity:', result);
-    
+
     // Check for errors from Unity
     if (result.error) {
       console.error('[CreateGameObject] Unity returned error:', result.error);
       throw new Error(result.error);
     }
-    
+
     return result;
   }
 }

package/src/handlers/gameobject/GameObjectDeleteToolHandler.js

@@ -31,7 +31,7 @@ export class GameObjectDeleteToolHandler extends BaseToolHandler {
         required: []
       }
     );
-    
+
     this.unityConnection = unityConnection;
   }
 
@@ -42,18 +42,18 @@ export class GameObjectDeleteToolHandler extends BaseToolHandler {
    */
   validate(params) {
     super.validate(params);
-    
+
     // Either path or paths must be provided
     if (!params.path && (!params.paths || params.paths.length === 0)) {
       throw new Error('Either "path" or "paths" parameter must be provided');
     }
-    
+
     // Validate paths array if provided
     if (params.paths) {
       if (!Array.isArray(params.paths)) {
         throw new Error('paths must be an array of strings');
       }
-      
+
       for (const path of params.paths) {
         if (typeof path !== 'string') {
           throw new Error('All paths must be strings');
@@ -72,15 +72,15 @@ export class GameObjectDeleteToolHandler extends BaseToolHandler {
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
-    
+
     // Send delete_gameobject command
     const result = await this.unityConnection.sendCommand('delete_gameobject', params);
-    
+
     // Check for errors from Unity
     if (result.error) {
       throw new Error(result.error);
     }
-    
+
     // Add summary
     if (result.deletedCount !== undefined) {
       if (result.deletedCount === 0) {
@@ -90,12 +90,12 @@ export class GameObjectDeleteToolHandler extends BaseToolHandler {
       } else {
         result.summary = `Deleted ${result.deletedCount} GameObjects`;
       }
-      
+
       if (result.notFoundCount > 0) {
         result.summary += ` (${result.notFoundCount} not found)`;
       }
     }
-    
+
     return result;
   }
 }

package/src/handlers/gameobject/GameObjectFindToolHandler.js

@@ -34,7 +34,7 @@ export class GameObjectFindToolHandler extends BaseToolHandler {
         required: []
       }
     );
-    
+
     this.unityConnection = unityConnection;
   }
 
@@ -45,12 +45,12 @@ export class GameObjectFindToolHandler extends BaseToolHandler {
    */
   validate(params) {
     super.validate(params);
-    
+
     // At least one search criteria must be provided
     if (!params.name && !params.tag && params.layer === undefined) {
       throw new Error('At least one search criteria (name, tag, or layer) must be provided');
     }
-    
+
     // Validate layer
     if (params.layer !== undefined) {
       const layer = Number(params.layer);
@@ -70,20 +70,20 @@ export class GameObjectFindToolHandler extends BaseToolHandler {
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
-    
+
     // Send find_gameobject command
     const result = await this.unityConnection.sendCommand('find_gameobject', params);
-    
+
     // Check for errors from Unity
     if (result.error) {
       throw new Error(result.error);
     }
-    
+
     // Add summary information
     if (result.objects && Array.isArray(result.objects)) {
       result.summary = this.generateSummary(result.objects, params);
     }
-    
+
     return result;
   }
 
@@ -95,9 +95,11 @@ export class GameObjectFindToolHandler extends BaseToolHandler {
    */
   generateSummary(objects, searchParams) {
     const parts = [];
-    
+
     if (searchParams.name) {
-      parts.push(`name${searchParams.exactMatch === false ? ' containing' : ''} "${searchParams.name}"`);
+      parts.push(
+        `name${searchParams.exactMatch === false ? ' containing' : ''} "${searchParams.name}"`
+      );
     }
     if (searchParams.tag) {
       parts.push(`tag "${searchParams.tag}"`);
@@ -105,9 +107,9 @@ export class GameObjectFindToolHandler extends BaseToolHandler {
     if (searchParams.layer !== undefined) {
       parts.push(`layer ${searchParams.layer}`);
     }
-    
+
     const criteria = parts.join(', ');
-    
+
     if (objects.length === 0) {
       return `No GameObjects found matching ${criteria}`;
     } else if (objects.length === 1) {