@akiojin/unity-mcp-server 2.40.2 → 2.40.4

package/src/handlers/analysis/GetInputActionsStateToolHandler.js

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { 
-    getInputActionsStateToolDefinition,
-    analyzeInputActionsAssetToolDefinition,
-    getInputActionsStateHandler,
-    analyzeInputActionsAssetHandler
+import {
+  getInputActionsStateToolDefinition,
+  analyzeInputActionsAssetToolDefinition,
+  getInputActionsStateHandler,
+  analyzeInputActionsAssetHandler
 } from '../../tools/analysis/getInputActionsState.js';
 
 export class GetInputActionsStateToolHandler extends BaseToolHandler {

package/src/handlers/analysis/GetObjectReferencesToolHandler.js

@@ -1,5 +1,8 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { getObjectReferencesToolDefinition, getObjectReferencesHandler } from '../../tools/analysis/getObjectReferences.js';
+import {
+  getObjectReferencesToolDefinition,
+  getObjectReferencesHandler
+} from '../../tools/analysis/getObjectReferences.js';
 
 /**
  * Handler for the analysis_object_references_get tool

package/src/handlers/asset/AssetDatabaseManageToolHandler.js

@@ -13,7 +13,16 @@ export class AssetDatabaseManageToolHandler extends BaseToolHandler {
         properties: {
           action: {
             type: 'string',
-            enum: ['find_assets', 'get_asset_info', 'create_folder', 'delete_asset', 'move_asset', 'copy_asset', 'refresh', 'save'],
+            enum: [
+              'find_assets',
+              'get_asset_info',
+              'create_folder',
+              'delete_asset',
+              'move_asset',
+              'copy_asset',
+              'refresh',
+              'save'
+            ],
             description: 'The action to perform'
           },
           filter: {
@@ -53,7 +62,16 @@ export class AssetDatabaseManageToolHandler extends BaseToolHandler {
       throw new Error('action is required');
     }
 
-    const validActions = ['find_assets', 'get_asset_info', 'create_folder', 'delete_asset', 'move_asset', 'copy_asset', 'refresh', 'save'];
+    const validActions = [
+      'find_assets',
+      'get_asset_info',
+      'create_folder',
+      'delete_asset',
+      'move_asset',
+      'copy_asset',
+      'refresh',
+      'save'
+    ];
     if (!validActions.includes(params.action)) {
       throw new Error(`action must be one of: ${validActions.join(', ')}`);
     }
@@ -123,7 +141,7 @@ export class AssetDatabaseManageToolHandler extends BaseToolHandler {
 
   async execute(params) {
     this.validate(params);
-    
+
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
@@ -184,8 +202,8 @@ export class AssetDatabaseManageToolHandler extends BaseToolHandler {
         }
       },
       {
-        input: { 
-          action: 'move_asset', 
+        input: {
+          action: 'move_asset',
           fromPath: 'Assets/icon.png',
           toPath: 'Assets/Textures/icon.png'
         },
@@ -218,4 +236,4 @@ export class AssetDatabaseManageToolHandler extends BaseToolHandler {
       }
     ];
   }
-}
+}

package/src/handlers/asset/AssetDependencyAnalyzeToolHandler.js

@@ -13,7 +13,14 @@ export class AssetDependencyAnalyzeToolHandler extends BaseToolHandler {
         properties: {
           action: {
             type: 'string',
-            enum: ['get_dependencies', 'get_dependents', 'analyze_circular', 'find_unused', 'analyze_size_impact', 'validate_references'],
+            enum: [
+              'get_dependencies',
+              'get_dependents',
+              'analyze_circular',
+              'find_unused',
+              'analyze_size_impact',
+              'validate_references'
+            ],
             description: 'The analysis action to perform'
           },
           assetPath: {
@@ -40,7 +47,14 @@ export class AssetDependencyAnalyzeToolHandler extends BaseToolHandler {
       throw new Error('action is required');
     }
 
-    const validActions = ['get_dependencies', 'get_dependents', 'analyze_circular', 'find_unused', 'analyze_size_impact', 'validate_references'];
+    const validActions = [
+      'get_dependencies',
+      'get_dependents',
+      'analyze_circular',
+      'find_unused',
+      'analyze_size_impact',
+      'validate_references'
+    ];
     if (!validActions.includes(params.action)) {
       throw new Error(`action must be one of: ${validActions.join(', ')}`);
     }
@@ -51,11 +65,11 @@ export class AssetDependencyAnalyzeToolHandler extends BaseToolHandler {
       if (params.assetPath === undefined || params.assetPath === null) {
         throw new Error(`assetPath is required for ${params.action} action`);
       }
-      
+
       if (params.assetPath === '') {
         throw new Error('assetPath cannot be empty');
       }
-      
+
       // Validate assetPath starts with "Assets/"
       if (!params.assetPath.startsWith('Assets/')) {
         throw new Error('assetPath must start with "Assets/"');
@@ -65,7 +79,7 @@ export class AssetDependencyAnalyzeToolHandler extends BaseToolHandler {
 
   async execute(params) {
     this.validate(params);
-    
+
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
@@ -124,11 +138,7 @@ export class AssetDependencyAnalyzeToolHandler extends BaseToolHandler {
           action: 'analyze_circular',
           circularDependencies: [
             {
-              cycle: [
-                'Assets/Scripts/A.cs',
-                'Assets/Scripts/B.cs',
-                'Assets/Scripts/A.cs'
-              ],
+              cycle: ['Assets/Scripts/A.cs', 'Assets/Scripts/B.cs', 'Assets/Scripts/A.cs'],
               length: 3,
               severity: 'warning'
             }
@@ -198,4 +208,4 @@ export class AssetDependencyAnalyzeToolHandler extends BaseToolHandler {
       }
     ];
   }
-}
+}

package/src/handlers/asset/AssetImportSettingsManageToolHandler.js

@@ -71,7 +71,7 @@ export class AssetImportSettingsManageToolHandler extends BaseToolHandler {
       if (params.preset === undefined || params.preset === null) {
         throw new Error('preset is required for apply_preset action');
       }
-      
+
       if (params.preset === '') {
         throw new Error('preset cannot be empty');
       }
@@ -80,7 +80,7 @@ export class AssetImportSettingsManageToolHandler extends BaseToolHandler {
 
   async execute(params) {
     this.validate(params);
-    
+
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
@@ -112,8 +112,8 @@ export class AssetImportSettingsManageToolHandler extends BaseToolHandler {
         }
       },
       {
-        input: { 
-          action: 'modify', 
+        input: {
+          action: 'modify',
           assetPath: 'Assets/Textures/icon.png',
           settings: {
             maxTextureSize: 1024,
@@ -136,8 +136,8 @@ export class AssetImportSettingsManageToolHandler extends BaseToolHandler {
         }
       },
       {
-        input: { 
-          action: 'apply_preset', 
+        input: {
+          action: 'apply_preset',
           assetPath: 'Assets/Textures/icon.png',
           preset: 'UI_Sprite'
         },
@@ -167,4 +167,4 @@ export class AssetImportSettingsManageToolHandler extends BaseToolHandler {
       }
     ];
   }
-}
+}

package/src/handlers/asset/AssetMaterialCreateToolHandler.js

@@ -1,96 +1,93 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class AssetMaterialCreateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'asset_material_create',
-            'Create a material asset with a shader and property overrides (optional copyFrom).',
-            {
-                type: 'object',
-                properties: {
-                    materialPath: {
-                        type: 'string',
-                        description: 'Asset path for the material. Must start with Assets/ and end with .mat.'
-                    },
-                    shader: {
-                        type: 'string',
-                        description: 'Shader to use (e.g., Standard, Unlit/Color, Universal Render Pipeline/Lit).'
-                    },
-                    properties: {
-                        type: 'object',
-                        description: 'Material property overrides (e.g., {"_Color":[1,0,0,1], "_Metallic":0.5}).'
-                    },
-                    copyFrom: {
-                        type: 'string',
-                        description: 'Optional: path to an existing material to clone before applying overrides.'
-                    },
-                    overwrite: {
-                        type: 'boolean',
-                        description: 'If true, overwrite existing material at the path.'
-                    }
-                },
-                required: ['materialPath']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
+  constructor(unityConnection) {
+    super(
+      'asset_material_create',
+      'Create a material asset with a shader and property overrides (optional copyFrom).',
+      {
+        type: 'object',
+        properties: {
+          materialPath: {
+            type: 'string',
+            description: 'Asset path for the material. Must start with Assets/ and end with .mat.'
+          },
+          shader: {
+            type: 'string',
+            description:
+              'Shader to use (e.g., Standard, Unlit/Color, Universal Render Pipeline/Lit).'
+          },
+          properties: {
+            type: 'object',
+            description:
+              'Material property overrides (e.g., {"_Color":[1,0,0,1], "_Metallic":0.5}).'
+          },
+          copyFrom: {
+            type: 'string',
+            description:
+              'Optional: path to an existing material to clone before applying overrides.'
+          },
+          overwrite: {
+            type: 'boolean',
+            description: 'If true, overwrite existing material at the path.'
+          }
+        },
+        required: ['materialPath']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
 
-    validate(params) {
-        // Call parent validation for required fields
-        super.validate(params);
+  validate(params) {
+    // Call parent validation for required fields
+    super.validate(params);
 
-        const { materialPath, shader, properties, copyFrom } = params;
+    const { materialPath, shader, properties, copyFrom } = params;
 
-        // Validate materialPath format
-        if (!materialPath.startsWith('Assets/') || !materialPath.endsWith('.mat')) {
-            throw new Error('materialPath must start with Assets/ and end with .mat');
-        }
+    // Validate materialPath format
+    if (!materialPath.startsWith('Assets/') || !materialPath.endsWith('.mat')) {
+      throw new Error('materialPath must start with Assets/ and end with .mat');
+    }
 
-        // Validate shader when provided
-        if (shader !== undefined && shader === '') {
-            throw new Error('shader cannot be empty when provided');
-        }
+    // Validate shader when provided
+    if (shader !== undefined && shader === '') {
+      throw new Error('shader cannot be empty when provided');
+    }
 
-        // Validate properties when provided
-        if (properties !== undefined) {
-            if (typeof properties !== 'object' || properties === null) {
-                throw new Error('properties must be an object');
-            }
-        }
+    // Validate properties when provided
+    if (properties !== undefined) {
+      if (typeof properties !== 'object' || properties === null) {
+        throw new Error('properties must be an object');
+      }
+    }
 
-        // Validate copyFrom when provided
-        if (copyFrom !== undefined) {
-            if (copyFrom === '') {
-                throw new Error('copyFrom cannot be empty when provided');
-            }
-            if (!copyFrom.startsWith('Assets/') || !copyFrom.endsWith('.mat')) {
-                throw new Error('copyFrom must be a valid material path (Assets/.../.mat)');
-            }
-        }
+    // Validate copyFrom when provided
+    if (copyFrom !== undefined) {
+      if (copyFrom === '') {
+        throw new Error('copyFrom cannot be empty when provided');
+      }
+      if (!copyFrom.startsWith('Assets/') || !copyFrom.endsWith('.mat')) {
+        throw new Error('copyFrom must be a valid material path (Assets/.../.mat)');
+      }
     }
+  }
 
-    async execute(params) {
-        const {
-            materialPath,
-            shader,
-            properties,
-            copyFrom,
-            overwrite
-        } = params;
+  async execute(params) {
+    const { materialPath, shader, properties, copyFrom, overwrite } = params;
 
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
 
-        const result = await this.unityConnection.sendCommand('create_material', {
-            materialPath,
-            shader,
-            properties,
-            copyFrom,
-            overwrite
-        });
+    const result = await this.unityConnection.sendCommand('create_material', {
+      materialPath,
+      shader,
+      properties,
+      copyFrom,
+      overwrite
+    });
 
-        return result;
-    }
+    return result;
+  }
 }

package/src/handlers/asset/AssetMaterialModifyToolHandler.js

@@ -1,76 +1,72 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class AssetMaterialModifyToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'asset_material_modify',
-            'Modify a material by updating property values and/or changing the shader.',
-            {
-                type: 'object',
-                properties: {
-                    materialPath: {
-                        type: 'string',
-                        description: 'Asset path to the material. Must start with Assets/ and end with .mat.'
-                    },
-                    properties: {
-                        type: 'object',
-                        description: 'Property updates (e.g., {"_Color":[1,0,0,1], "_Metallic":0.5}).'
-                    },
-                    shader: {
-                        type: 'string',
-                        description: 'Optional: change the shader (e.g., Standard, Unlit/Color).'
-                    }
-                },
-                required: ['materialPath', 'properties']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
+  constructor(unityConnection) {
+    super(
+      'asset_material_modify',
+      'Modify a material by updating property values and/or changing the shader.',
+      {
+        type: 'object',
+        properties: {
+          materialPath: {
+            type: 'string',
+            description: 'Asset path to the material. Must start with Assets/ and end with .mat.'
+          },
+          properties: {
+            type: 'object',
+            description: 'Property updates (e.g., {"_Color":[1,0,0,1], "_Metallic":0.5}).'
+          },
+          shader: {
+            type: 'string',
+            description: 'Optional: change the shader (e.g., Standard, Unlit/Color).'
+          }
+        },
+        required: ['materialPath', 'properties']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
 
-    validate(params) {
-        // Call parent validation for required fields
-        super.validate(params);
+  validate(params) {
+    // Call parent validation for required fields
+    super.validate(params);
 
-        const { materialPath, properties, shader } = params;
+    const { materialPath, properties, shader } = params;
 
-        // Validate materialPath format
-        if (!materialPath.startsWith('Assets/') || !materialPath.endsWith('.mat')) {
-            throw new Error('materialPath must start with Assets/ and end with .mat');
-        }
+    // Validate materialPath format
+    if (!materialPath.startsWith('Assets/') || !materialPath.endsWith('.mat')) {
+      throw new Error('materialPath must start with Assets/ and end with .mat');
+    }
 
-        // Validate properties
-        if (typeof properties !== 'object' || properties === null || Array.isArray(properties)) {
-            throw new Error('properties must be an object');
-        }
+    // Validate properties
+    if (typeof properties !== 'object' || properties === null || Array.isArray(properties)) {
+      throw new Error('properties must be an object');
+    }
 
-        if (Object.keys(properties).length === 0) {
-            throw new Error('properties cannot be empty');
-        }
+    if (Object.keys(properties).length === 0) {
+      throw new Error('properties cannot be empty');
+    }
 
-        // Validate shader when provided
-        if (shader !== undefined && shader === '') {
-            throw new Error('shader cannot be empty when provided');
-        }
+    // Validate shader when provided
+    if (shader !== undefined && shader === '') {
+      throw new Error('shader cannot be empty when provided');
     }
+  }
 
-    async execute(params) {
-        const {
-            materialPath,
-            properties,
-            shader
-        } = params;
+  async execute(params) {
+    const { materialPath, properties, shader } = params;
 
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
 
-        const result = await this.unityConnection.sendCommand('modify_material', {
-            materialPath,
-            properties,
-            shader
-        });
+    const result = await this.unityConnection.sendCommand('modify_material', {
+      materialPath,
+      properties,
+      shader
+    });
 
-        return result;
-    }
+    return result;
+  }
 }

package/src/handlers/asset/AssetPrefabCreateToolHandler.js

@@ -1,78 +1,75 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class AssetPrefabCreateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'asset_prefab_create',
-            'Create a prefab from a GameObject path or create an empty prefab at a target asset path.',
-            {
-                type: 'object',
-                properties: {
-                    gameObjectPath: {
-                        type: 'string',
-                        description: 'Scene path to convert (e.g., "/Root/Player"). Mutually exclusive with createFromTemplate.'
-                    },
-                    prefabPath: {
-                        type: 'string',
-                        description: 'Asset path for the prefab. Must start with Assets/ and end with .prefab.'
-                    },
-                    createFromTemplate: {
-                        type: 'boolean',
-                        description: 'If true, create an empty prefab (no source GameObject) (default: false).'
-                    },
-                    overwrite: {
-                        type: 'boolean',
-                        description: 'If true, overwrite existing prefab at the destination path (default: false).'
-                    }
-                },
-                required: ['prefabPath']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
+  constructor(unityConnection) {
+    super(
+      'asset_prefab_create',
+      'Create a prefab from a GameObject path or create an empty prefab at a target asset path.',
+      {
+        type: 'object',
+        properties: {
+          gameObjectPath: {
+            type: 'string',
+            description:
+              'Scene path to convert (e.g., "/Root/Player"). Mutually exclusive with createFromTemplate.'
+          },
+          prefabPath: {
+            type: 'string',
+            description: 'Asset path for the prefab. Must start with Assets/ and end with .prefab.'
+          },
+          createFromTemplate: {
+            type: 'boolean',
+            description: 'If true, create an empty prefab (no source GameObject) (default: false).'
+          },
+          overwrite: {
+            type: 'boolean',
+            description:
+              'If true, overwrite existing prefab at the destination path (default: false).'
+          }
+        },
+        required: ['prefabPath']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
 
-    validate(params) {
-        // Call parent validation for required fields
-        super.validate(params);
+  validate(params) {
+    // Call parent validation for required fields
+    super.validate(params);
 
-        const { prefabPath, gameObjectPath, createFromTemplate } = params;
+    const { prefabPath, gameObjectPath, createFromTemplate } = params;
 
-        // Validate prefabPath format
-        if (!prefabPath.startsWith('Assets/') || !prefabPath.endsWith('.prefab')) {
-            throw new Error('prefabPath must start with Assets/ and end with .prefab');
-        }
+    // Validate prefabPath format
+    if (!prefabPath.startsWith('Assets/') || !prefabPath.endsWith('.prefab')) {
+      throw new Error('prefabPath must start with Assets/ and end with .prefab');
+    }
 
-        // Validate gameObjectPath when provided
-        if (gameObjectPath !== undefined && gameObjectPath === '') {
-            throw new Error('gameObjectPath cannot be empty when provided');
-        }
+    // Validate gameObjectPath when provided
+    if (gameObjectPath !== undefined && gameObjectPath === '') {
+      throw new Error('gameObjectPath cannot be empty when provided');
+    }
 
-        // Validate mutually exclusive options
-        if (gameObjectPath && createFromTemplate) {
-            throw new Error('Cannot specify both gameObjectPath and createFromTemplate');
-        }
+    // Validate mutually exclusive options
+    if (gameObjectPath && createFromTemplate) {
+      throw new Error('Cannot specify both gameObjectPath and createFromTemplate');
     }
+  }
 
-    async execute(params) {
-        const {
-            gameObjectPath,
-            prefabPath,
-            createFromTemplate = false,
-            overwrite = false
-        } = params;
+  async execute(params) {
+    const { gameObjectPath, prefabPath, createFromTemplate = false, overwrite = false } = params;
 
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
 
-        const result = await this.unityConnection.sendCommand('create_prefab', {
-            gameObjectPath,
-            prefabPath,
-            createFromTemplate,
-            overwrite
-        });
+    const result = await this.unityConnection.sendCommand('create_prefab', {
+      gameObjectPath,
+      prefabPath,
+      createFromTemplate,
+      overwrite
+    });
 
-        return result;
-    }
+    return result;
+  }
 }