@akiojin/unity-mcp-server 2.14.14

package/src/handlers/asset/AssetDatabaseToolHandler.js

@@ -0,0 +1,221 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for Unity Asset Database operations
+ */
+export class AssetDatabaseToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'manage_asset_database',
+      'Manage Unity Asset Database operations (find, info, create folders, move, copy, delete, refresh). NOTE: The "refresh" action may take 5-120+ seconds for large projects as Unity needs to scan all assets, reimport changed files, and compile scripts. Please wait for the operation to complete.',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['find_assets', 'get_asset_info', 'create_folder', 'delete_asset', 'move_asset', 'copy_asset', 'refresh', 'save'],
+            description: 'The action to perform'
+          },
+          filter: {
+            type: 'string',
+            description: 'Search filter for find_assets (e.g., "t:Texture2D", "l:UI")'
+          },
+          searchInFolders: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Folders to search in for find_assets (optional)'
+          },
+          assetPath: {
+            type: 'string',
+            description: 'Path to the asset (must start with "Assets/")'
+          },
+          folderPath: {
+            type: 'string',
+            description: 'Path for folder creation (must start with "Assets/")'
+          },
+          fromPath: {
+            type: 'string',
+            description: 'Source path for move/copy operations'
+          },
+          toPath: {
+            type: 'string',
+            description: 'Destination path for move/copy operations'
+          }
+        },
+        required: ['action']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    if (!params.action) {
+      throw new Error('action is required');
+    }
+
+    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(', ')}`);
+    }
+
+    // Validate action-specific requirements
+    switch (params.action) {
+      case 'find_assets':
+        if (params.filter === undefined || params.filter === null) {
+          throw new Error('filter is required for find_assets action');
+        }
+        if (params.filter === '') {
+          throw new Error('filter cannot be empty');
+        }
+        break;
+
+      case 'get_asset_info':
+      case 'delete_asset':
+        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');
+        }
+        this.validateAssetPath(params.assetPath);
+        break;
+
+      case 'create_folder':
+        if (params.folderPath === undefined || params.folderPath === null) {
+          throw new Error('folderPath is required for create_folder action');
+        }
+        if (params.folderPath === '') {
+          throw new Error('folderPath cannot be empty');
+        }
+        this.validateAssetPath(params.folderPath);
+        break;
+
+      case 'move_asset':
+      case 'copy_asset':
+        if (params.fromPath === undefined || params.fromPath === null) {
+          throw new Error(`fromPath is required for ${params.action} action`);
+        }
+        if (params.toPath === undefined || params.toPath === null) {
+          throw new Error(`toPath is required for ${params.action} action`);
+        }
+        if (params.fromPath === '') {
+          throw new Error('fromPath cannot be empty');
+        }
+        if (params.toPath === '') {
+          throw new Error('toPath cannot be empty');
+        }
+        this.validateAssetPath(params.fromPath);
+        this.validateAssetPath(params.toPath);
+        break;
+
+      case 'refresh':
+      case 'save':
+        // No additional validation needed
+        break;
+    }
+  }
+
+  validateAssetPath(path) {
+    if (!path.startsWith('Assets/')) {
+      throw new Error('assetPath must start with "Assets/"');
+    }
+  }
+
+  async execute(params) {
+    this.validate(params);
+    
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const result = await this.unityConnection.sendCommand('manage_asset_database', params);
+    return result;
+  }
+
+  getExamples() {
+    return [
+      {
+        input: { action: 'find_assets', filter: 't:Texture2D' },
+        output: {
+          success: true,
+          action: 'find_assets',
+          filter: 't:Texture2D',
+          assets: [
+            {
+              path: 'Assets/Textures/icon.png',
+              name: 'icon',
+              type: 'Texture2D',
+              guid: 'abc123',
+              size: 1024
+            }
+          ],
+          count: 1
+        }
+      },
+      {
+        input: { action: 'get_asset_info', assetPath: 'Assets/Textures/icon.png' },
+        output: {
+          success: true,
+          action: 'get_asset_info',
+          assetPath: 'Assets/Textures/icon.png',
+          info: {
+            name: 'icon',
+            type: 'Texture2D',
+            guid: 'abc123',
+            size: 1024,
+            lastModified: '2024-01-15T10:30:00Z',
+            importSettings: {
+              textureType: 'Sprite',
+              maxTextureSize: 2048
+            },
+            dependencies: ['Assets/Materials/UIMaterial.mat'],
+            isValid: true
+          }
+        }
+      },
+      {
+        input: { action: 'create_folder', folderPath: 'Assets/NewFolder' },
+        output: {
+          success: true,
+          action: 'create_folder',
+          folderPath: 'Assets/NewFolder',
+          guid: 'folder123',
+          message: 'Folder created: Assets/NewFolder'
+        }
+      },
+      {
+        input: { 
+          action: 'move_asset', 
+          fromPath: 'Assets/icon.png',
+          toPath: 'Assets/Textures/icon.png'
+        },
+        output: {
+          success: true,
+          action: 'move_asset',
+          fromPath: 'Assets/icon.png',
+          toPath: 'Assets/Textures/icon.png',
+          message: 'Asset moved from Assets/icon.png to Assets/Textures/icon.png'
+        }
+      },
+      {
+        input: { action: 'delete_asset', assetPath: 'Assets/old_file.png' },
+        output: {
+          success: true,
+          action: 'delete_asset',
+          assetPath: 'Assets/old_file.png',
+          message: 'Asset deleted: Assets/old_file.png'
+        }
+      },
+      {
+        input: { action: 'refresh' },
+        output: {
+          success: true,
+          action: 'refresh',
+          message: 'Asset database refreshed',
+          assetsFound: 1247,
+          duration: 2.34
+        }
+      }
+    ];
+  }
+}

package/src/handlers/asset/AssetDependencyToolHandler.js

@@ -0,0 +1,201 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for Unity asset dependency analysis
+ */
+export class AssetDependencyToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'analyze_asset_dependencies',
+      'Analyze Unity asset dependencies (get dependencies, dependents, circular deps, unused assets, size impact)',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['get_dependencies', 'get_dependents', 'analyze_circular', 'find_unused', 'analyze_size_impact', 'validate_references'],
+            description: 'The analysis action to perform'
+          },
+          assetPath: {
+            type: 'string',
+            description: 'Path to the asset (required for specific asset analysis)'
+          },
+          recursive: {
+            type: 'boolean',
+            description: 'Whether to analyze dependencies recursively (for get_dependencies)'
+          },
+          includeBuiltIn: {
+            type: 'boolean',
+            description: 'Whether to include built-in assets in analysis (for find_unused)'
+          }
+        },
+        required: ['action']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    if (!params.action) {
+      throw new Error('action is required');
+    }
+
+    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(', ')}`);
+    }
+
+    // Actions that require assetPath
+    const assetPathRequiredActions = ['get_dependencies', 'get_dependents', 'analyze_size_impact'];
+    if (assetPathRequiredActions.includes(params.action)) {
+      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/"');
+      }
+    }
+  }
+
+  async execute(params) {
+    this.validate(params);
+    
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const result = await this.unityConnection.sendCommand('analyze_asset_dependencies', params);
+    return result;
+  }
+
+  getExamples() {
+    return [
+      {
+        input: { action: 'get_dependencies', assetPath: 'Assets/Prefabs/Player.prefab' },
+        output: {
+          success: true,
+          action: 'get_dependencies',
+          assetPath: 'Assets/Prefabs/Player.prefab',
+          recursive: false,
+          dependencies: [
+            {
+              path: 'Assets/Materials/PlayerMaterial.mat',
+              type: 'Material',
+              isDirectDependency: true,
+              depth: 1
+            },
+            {
+              path: 'Assets/Scripts/PlayerController.cs',
+              type: 'MonoScript',
+              isDirectDependency: true,
+              depth: 1
+            }
+          ],
+          count: 2,
+          maxDepth: 1
+        }
+      },
+      {
+        input: { action: 'get_dependents', assetPath: 'Assets/Materials/PlayerMaterial.mat' },
+        output: {
+          success: true,
+          action: 'get_dependents',
+          assetPath: 'Assets/Materials/PlayerMaterial.mat',
+          dependents: [
+            {
+              path: 'Assets/Prefabs/Player.prefab',
+              type: 'GameObject',
+              usage: 'Renderer.material'
+            }
+          ],
+          count: 1
+        }
+      },
+      {
+        input: { action: 'analyze_circular' },
+        output: {
+          success: true,
+          action: 'analyze_circular',
+          circularDependencies: [
+            {
+              cycle: [
+                'Assets/Scripts/A.cs',
+                'Assets/Scripts/B.cs',
+                'Assets/Scripts/A.cs'
+              ],
+              length: 3,
+              severity: 'warning'
+            }
+          ],
+          hasCircularDependencies: true,
+          totalCycles: 1
+        }
+      },
+      {
+        input: { action: 'find_unused' },
+        output: {
+          success: true,
+          action: 'find_unused',
+          includeBuiltIn: false,
+          unusedAssets: [
+            {
+              path: 'Assets/Textures/old_icon.png',
+              type: 'Texture2D',
+              size: 512,
+              lastModified: '2023-12-01T10:00:00Z'
+            }
+          ],
+          count: 1,
+          totalSizeKB: 512
+        }
+      },
+      {
+        input: { action: 'analyze_size_impact', assetPath: 'Assets/Textures/large_texture.png' },
+        output: {
+          success: true,
+          action: 'analyze_size_impact',
+          assetPath: 'Assets/Textures/large_texture.png',
+          analysis: {
+            directSize: 2048,
+            totalSize: 3072,
+            dependencyCount: 5,
+            largestDependency: {
+              path: 'Assets/Textures/dependency.png',
+              size: 1024
+            },
+            buildImpact: {
+              estimatedBuildSize: 3072,
+              compressionRatio: 0.75
+            }
+          }
+        }
+      },
+      {
+        input: { action: 'validate_references' },
+        output: {
+          success: true,
+          action: 'validate_references',
+          validation: {
+            totalAssets: 150,
+            validReferences: 145,
+            brokenReferences: [
+              {
+                asset: 'Assets/Prefabs/Broken.prefab',
+                missingReference: 'Assets/Scripts/DeletedScript.cs',
+                referenceType: 'MonoScript'
+              }
+            ],
+            missingReferences: 5,
+            validationTime: 1.25
+          }
+        }
+      }
+    ];
+  }
+}

package/src/handlers/asset/AssetImportSettingsToolHandler.js

@@ -0,0 +1,170 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for Unity asset import settings management
+ */
+export class AssetImportSettingsToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'manage_asset_import_settings',
+      'Manage Unity asset import settings (get, modify, apply presets, reimport)',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['get', 'modify', 'apply_preset', 'reimport'],
+            description: 'The action to perform'
+          },
+          assetPath: {
+            type: 'string',
+            description: 'Path to the asset (must start with "Assets/")'
+          },
+          settings: {
+            type: 'object',
+            description: 'Import settings to apply (required for modify action)'
+          },
+          preset: {
+            type: 'string',
+            description: 'Name of the preset to apply (required for apply_preset action)'
+          }
+        },
+        required: ['action', 'assetPath']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    if (!params.action) {
+      throw new Error('action is required');
+    }
+
+    const validActions = ['get', 'modify', 'apply_preset', 'reimport'];
+    if (!validActions.includes(params.action)) {
+      throw new Error(`action must be one of: ${validActions.join(', ')}`);
+    }
+
+    // Validate assetPath
+    if (params.assetPath === undefined || params.assetPath === null) {
+      throw new Error('assetPath is required');
+    }
+
+    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/"');
+    }
+
+    // Validate settings for modify action
+    if (params.action === 'modify') {
+      if (!params.settings) {
+        throw new Error('settings is required for modify action');
+      }
+    }
+
+    // Validate preset for apply_preset action
+    if (params.action === 'apply_preset') {
+      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');
+      }
+    }
+  }
+
+  async execute(params) {
+    this.validate(params);
+    
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const result = await this.unityConnection.sendCommand('manage_asset_import_settings', params);
+    return result;
+  }
+
+  getExamples() {
+    return [
+      {
+        input: { action: 'get', assetPath: 'Assets/Textures/icon.png' },
+        output: {
+          success: true,
+          action: 'get',
+          assetPath: 'Assets/Textures/icon.png',
+          settings: {
+            assetType: 'Texture2D',
+            textureType: 'Sprite',
+            filterMode: 'Bilinear',
+            wrapMode: 'Clamp',
+            maxTextureSize: 2048,
+            compressionQuality: 50,
+            generateMipMaps: false,
+            readable: false,
+            crunchedCompression: false,
+            sRGBTexture: true
+          }
+        }
+      },
+      {
+        input: { 
+          action: 'modify', 
+          assetPath: 'Assets/Textures/icon.png',
+          settings: {
+            maxTextureSize: 1024,
+            compressionQuality: 75
+          }
+        },
+        output: {
+          success: true,
+          action: 'modify',
+          assetPath: 'Assets/Textures/icon.png',
+          previousSettings: {
+            maxTextureSize: 2048,
+            compressionQuality: 50
+          },
+          newSettings: {
+            maxTextureSize: 1024,
+            compressionQuality: 75
+          },
+          message: 'Import settings modified for: Assets/Textures/icon.png'
+        }
+      },
+      {
+        input: { 
+          action: 'apply_preset', 
+          assetPath: 'Assets/Textures/icon.png',
+          preset: 'UI_Sprite'
+        },
+        output: {
+          success: true,
+          action: 'apply_preset',
+          assetPath: 'Assets/Textures/icon.png',
+          preset: 'UI_Sprite',
+          appliedSettings: {
+            textureType: 'Sprite',
+            filterMode: 'Bilinear',
+            maxTextureSize: 2048,
+            generateMipMaps: false
+          },
+          message: 'Preset "UI_Sprite" applied to: Assets/Textures/icon.png'
+        }
+      },
+      {
+        input: { action: 'reimport', assetPath: 'Assets/Textures/icon.png' },
+        output: {
+          success: true,
+          action: 'reimport',
+          assetPath: 'Assets/Textures/icon.png',
+          message: 'Asset reimported: Assets/Textures/icon.png',
+          duration: 0.245
+        }
+      }
+    ];
+  }
+}

package/src/handlers/asset/CreateMaterialToolHandler.js

@@ -0,0 +1,96 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+export class CreateMaterialToolHandler extends BaseToolHandler {
+    constructor(unityConnection) {
+        super(
+            'create_material',
+            '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);
+
+        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 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 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;
+
+        // Ensure connected
+        if (!this.unityConnection.isConnected()) {
+            await this.unityConnection.connect();
+        }
+
+        const result = await this.unityConnection.sendCommand('create_material', {
+            materialPath,
+            shader,
+            properties,
+            copyFrom,
+            overwrite
+        });
+
+        return result;
+    }
+}