@akiojin/unity-mcp-server 2.14.14

package/src/handlers/editor/SelectionToolHandler.js

@@ -0,0 +1,141 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handles Unity Editor selection operations
+ */
+export class SelectionToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'manage_selection',
+      'Manage editor selection: get/set/clear and optionally include details.',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['get', 'set', 'clear', 'get_details'],
+            description: 'Operation: get, set, clear, or get_details.'
+          },
+          objectPaths: {
+            type: 'array',
+            items: {
+              type: 'string'
+            },
+            description: 'GameObject paths for set (e.g., ["/Main Camera", "/Player"]). Must start with /.'
+          },
+          includeDetails: {
+            type: 'boolean',
+            description: 'If true, return detailed info with get/get_details.'
+          }
+        },
+        required: ['action']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  /**
+   * Validate the parameters for the selection operation
+   */
+  validate(params) {
+    const { action, objectPaths, includeDetails } = params;
+
+    // Check action is provided
+    if (!action) {
+      throw new Error('action is required');
+    }
+
+    // Validate action is one of the allowed values
+    const allowedActions = ['get', 'set', 'clear', 'get_details'];
+    if (!allowedActions.includes(action)) {
+      throw new Error(`action must be one of: ${allowedActions.join(', ')}`);
+    }
+
+    // Validate based on action
+    if (action === 'set') {
+      if (!objectPaths) {
+        throw new Error('objectPaths is required for set action');
+      }
+      
+      if (!Array.isArray(objectPaths)) {
+        throw new Error('objectPaths must be an array');
+      }
+      
+      if (objectPaths.length === 0) {
+        throw new Error('objectPaths cannot be empty');
+      }
+      
+      // Validate each path
+      for (const path of objectPaths) {
+        if (typeof path !== 'string') {
+          throw new Error('All object paths must be strings');
+        }
+        
+        if (!path.startsWith('/')) {
+          throw new Error('All object paths must start with /');
+        }
+      }
+    }
+
+    // Call parent validation last
+    super.validate(params);
+  }
+
+  /**
+   * Execute the selection command
+   */
+  async execute(params) {
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+    
+    const result = await this.unityConnection.sendCommand('manage_selection', params);
+    
+    if (result.error) {
+      throw new Error(result.error);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get examples of how to use this tool
+   */
+  getExamples() {
+    return {
+      getSelection: {
+        description: 'Get current selection',
+        params: {
+          action: 'get'
+        }
+      },
+      getSelectionWithDetails: {
+        description: 'Get current selection with detailed info',
+        params: {
+          action: 'get',
+          includeDetails: true
+        }
+      },
+      setSelection: {
+        description: 'Set selection to specific objects',
+        params: {
+          action: 'set',
+          objectPaths: ['/Main Camera', '/Directional Light']
+        }
+      },
+      clearSelection: {
+        description: 'Clear current selection',
+        params: {
+          action: 'clear'
+        }
+      },
+      getSelectionDetails: {
+        description: 'Get detailed information about selection',
+        params: {
+          action: 'get_details'
+        }
+      }
+    };
+  }
+}

package/src/handlers/editor/TagManagementToolHandler.js

@@ -0,0 +1,129 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for Unity tag management operations
+ */
+export class TagManagementToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'manage_tags',
+      'Manage project tags: add/remove/list with validation for reserved names.',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['add', 'remove', 'get'],
+            description: 'Operation: add, remove, or get.'
+          },
+          tagName: {
+            type: 'string',
+            description: 'Tag name (required for add/remove). Alphanumeric/underscore only.'
+          }
+        },
+        required: ['action']
+      }
+    );
+    
+    this.unityConnection = unityConnection;
+    
+    // Reserved Unity tags that cannot be removed
+    this.RESERVED_TAGS = ['Untagged', 'Respawn', 'Finish', 'EditorOnly', 'MainCamera', 'Player', 'GameController'];
+  }
+
+  /**
+   * Validates the input parameters
+   * @param {Object} params - The input parameters
+   */
+  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) {
+        throw new Error(`tagName is required for ${action} action`);
+      }
+      if (typeof tagName === 'string' && tagName.trim() === '') {
+        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');
+      }
+      
+      // 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);
+  }
+
+  /**
+   * Executes the tag management operation
+   * @param {Object} params - The validated input parameters
+   * @returns {Promise<Object>} The result of the tag operation
+   */
+  async execute(params) {
+    // Ensure connection to Unity
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    // Send command to Unity
+    const response = await this.unityConnection.sendCommand('manage_tags', params);
+
+    // Handle Unity response
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    return response;
+  }
+
+  /**
+   * Gets example usage for this tool
+   * @returns {Object} Example usage scenarios
+   */
+  getExamples() {
+    return {
+      getTags: {
+        description: 'Get all available tags in the project',
+        params: {
+          action: 'get'
+        }
+      },
+      addTag: {
+        description: 'Add a new tag to the project',
+        params: {
+          action: 'add',
+          tagName: 'Enemy'
+        }
+      },
+      removeTag: {
+        description: 'Remove an existing tag from the project',
+        params: {
+          action: 'remove',
+          tagName: 'OldTag'
+        }
+      }
+    };
+  }
+}

package/src/handlers/editor/ToolManagementToolHandler.js

@@ -0,0 +1,135 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for Unity Editor tool and plugin management operations
+ */
+export class ToolManagementToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'manage_tools',
+      'Manage editor tools/plugins: list, activate/deactivate, refresh cache.',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['get', 'activate', 'deactivate', 'refresh'],
+            description: 'Operation: get, activate, deactivate, or refresh.'
+          },
+          toolName: {
+            type: 'string',
+            description: 'Tool name (required for activate/deactivate).'
+          },
+          category: {
+            type: 'string',
+            description: 'Optional: filter list by category.'
+          }
+        },
+        required: ['action']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    if (!params.action) {
+      throw new Error('action is required');
+    }
+
+    const validActions = ['get', 'activate', 'deactivate', 'refresh'];
+    if (!validActions.includes(params.action)) {
+      throw new Error(`action must be one of: ${validActions.join(', ')}`);
+    }
+
+    // Validate toolName for activate/deactivate actions
+    if (params.action === 'activate' || params.action === 'deactivate') {
+      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');
+      }
+    }
+
+    // Validate category if provided
+    if (params.category !== undefined && params.category !== null && params.category === '') {
+      throw new Error('category cannot be empty');
+    }
+  }
+
+  async execute(params) {
+    this.validate(params);
+    
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const result = await this.unityConnection.sendCommand('manage_tools', params);
+    return result;
+  }
+
+  getExamples() {
+    return [
+      {
+        input: { action: 'get' },
+        output: {
+          success: true,
+          action: 'get',
+          tools: [
+            {
+              name: 'ProBuilder',
+              displayName: 'ProBuilder',
+              version: '5.1.0',
+              category: 'Modeling',
+              isInstalled: true,
+              isActive: true
+            },
+            {
+              name: 'Cinemachine',
+              displayName: 'Cinemachine',
+              version: '2.9.0',
+              category: 'Camera',
+              isInstalled: true,
+              isActive: false
+            }
+          ],
+          installedCount: 2,
+          activeCount: 1
+        }
+      },
+      {
+        input: { action: 'activate', toolName: 'Cinemachine' },
+        output: {
+          success: true,
+          action: 'activate',
+          toolName: 'Cinemachine',
+          previousState: { isActive: false },
+          currentState: { isActive: true },
+          message: 'Tool activated: Cinemachine'
+        }
+      },
+      {
+        input: { action: 'deactivate', toolName: 'ProBuilder' },
+        output: {
+          success: true,
+          action: 'deactivate',
+          toolName: 'ProBuilder',
+          previousState: { isActive: true },
+          currentState: { isActive: false },
+          message: 'Tool deactivated: ProBuilder'
+        }
+      },
+      {
+        input: { action: 'refresh' },
+        output: {
+          success: true,
+          action: 'refresh',
+          message: 'Tool cache refreshed',
+          toolsCount: 15,
+          timestamp: '2024-01-01T12:00:00.000Z'
+        }
+      }
+    ];
+  }
+}

package/src/handlers/editor/WindowManagementToolHandler.js

@@ -0,0 +1,125 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handles Unity Editor window management operations
+ */
+export class WindowManagementToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'manage_windows',
+      'Manage editor windows: list/focus/get_state including hidden windows.',
+      {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            enum: ['get', 'focus', 'get_state'],
+            description: 'Operation: get (list), focus, or get_state.'
+          },
+          windowType: {
+            type: 'string',
+            description: 'Window type (e.g., SceneView, GameView, InspectorWindow). Required for focus/get_state.'
+          },
+          includeHidden: {
+            type: 'boolean',
+            description: 'If true, includes hidden/minimized windows for get.'
+          }
+        },
+        required: ['action']
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  /**
+   * Validate the parameters for the window management operation
+   */
+  validate(params) {
+    const { action, windowType } = params;
+
+    // Check action is provided
+    if (!action) {
+      throw new Error('action is required');
+    }
+
+    // Validate action is one of the allowed values
+    const allowedActions = ['get', 'focus', 'get_state'];
+    if (!allowedActions.includes(action)) {
+      throw new Error(`action must be one of: ${allowedActions.join(', ')}`);
+    }
+
+    // Validate based on action
+    if (action === 'focus' || action === 'get_state') {
+      if (windowType === undefined || windowType === null) {
+        throw new Error(`windowType is required for ${action} action`);
+      }
+      
+      if (windowType === '') {
+        throw new Error('windowType cannot be empty');
+      }
+    }
+
+    // Call parent validation last
+    super.validate(params);
+  }
+
+  /**
+   * Execute the window management command
+   */
+  async execute(params) {
+    // Ensure connected
+    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;
+  }
+
+  /**
+   * Get examples of how to use this tool
+   */
+  getExamples() {
+    return {
+      getAllWindows: {
+        description: 'Get all open editor windows',
+        params: {
+          action: 'get'
+        }
+      },
+      getAllWindowsIncludingHidden: {
+        description: 'Get all windows including hidden ones',
+        params: {
+          action: 'get',
+          includeHidden: true
+        }
+      },
+      focusSceneView: {
+        description: 'Focus the Scene view window',
+        params: {
+          action: 'focus',
+          windowType: 'SceneView'
+        }
+      },
+      focusGameView: {
+        description: 'Focus the Game view window',
+        params: {
+          action: 'focus',
+          windowType: 'GameView'
+        }
+      },
+      getWindowState: {
+        description: 'Get detailed state of a specific window',
+        params: {
+          action: 'get_state',
+          windowType: 'InspectorWindow'
+        }
+      }
+    };
+  }
+}

package/src/handlers/gameobject/CreateGameObjectToolHandler.js

@@ -0,0 +1,131 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import { validateVector3, validateLayer } from '../../utils/validators.js';
+
+/**
+ * Handler for the create_gameobject tool
+ * Creates GameObjects in Unity scene
+ */
+export class CreateGameObjectToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'create_gameobject',
+      '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
+          }
+        },
+        required: []
+      }
+    );
+    
+    this.unityConnection = unityConnection;
+  }
+
+  /**
+   * Validates the input parameters
+   * @param {object} params - Input parameters
+   * @throws {Error} If validation fails
+   */
+  validate(params) {
+    super.validate(params);
+    
+    // Validate primitive type if provided
+    if (params.primitiveType) {
+      const validTypes = ['cube', 'sphere', 'cylinder', 'capsule', 'plane', 'quad'];
+      if (!validTypes.includes(params.primitiveType.toLowerCase())) {
+        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));
+    }
+  }
+
+  /**
+   * Executes the create_gameobject command
+   * @param {object} params - Input parameters
+   * @returns {Promise<object>} Created GameObject info
+   */
+  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...');
+      await this.unityConnection.connect();
+      console.error('[CreateGameObject] Connected to Unity');
+    } 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;
+  }
+}