@akiojin/unity-mcp-server 2.40.2 → 2.40.3

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;
+  }
 }

package/src/handlers/asset/AssetPrefabExitModeToolHandler.js

@@ -5,20 +5,16 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export class AssetPrefabExitModeToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super(
-      'asset_prefab_exit_mode',
-      'Exit prefab mode and return to the main scene',
-      {
-        type: 'object',
-        properties: {
-          saveChanges: {
-            type: 'boolean',
-            description: 'Save changes before exiting (default: true)'
-          }
+    super('asset_prefab_exit_mode', 'Exit prefab mode and return to the main scene', {
+      type: 'object',
+      properties: {
+        saveChanges: {
+          type: 'boolean',
+          description: 'Save changes before exiting (default: true)'
         }
       }
-    );
-    
+    });
+
     this.unityConnection = unityConnection;
   }
 
@@ -80,4 +76,4 @@ export class AssetPrefabExitModeToolHandler extends BaseToolHandler {
       }
     };
   }
-}
+}