@akiojin/unity-mcp-server 2.33.0 → 2.37.1

package/src/handlers/input/InputGamepadToolHandler.js

@@ -0,0 +1,162 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+const actionProperties = {
+  action: {
+    type: 'string',
+    enum: ['button', 'stick', 'trigger', 'dpad'],
+    description: 'The gamepad action to perform'
+  },
+  button: {
+    type: 'string',
+    description: 'Button name (a/cross, b/circle, x/square, y/triangle, start, select, etc.)'
+  },
+  buttonAction: {
+    type: 'string',
+    enum: ['press', 'release'],
+    description: 'Button action (press or release)'
+  },
+  stick: {
+    type: 'string',
+    enum: ['left', 'right'],
+    description: 'Which analog stick to control'
+  },
+  x: {
+    type: 'number',
+    minimum: -1,
+    maximum: 1,
+    description: 'Horizontal axis value for stick (-1 to 1)'
+  },
+  y: {
+    type: 'number',
+    minimum: -1,
+    maximum: 1,
+    description: 'Vertical axis value for stick (-1 to 1)'
+  },
+  trigger: {
+    type: 'string',
+    enum: ['left', 'right'],
+    description: 'Which trigger to control'
+  },
+  value: {
+    type: 'number',
+    minimum: 0,
+    maximum: 1,
+    description: 'Trigger pressure value (0 to 1)'
+  },
+  direction: {
+    type: 'string',
+    enum: ['up', 'down', 'left', 'right', 'none'],
+    description: 'D-pad direction'
+  },
+  holdSeconds: {
+    type: 'number',
+    minimum: 0,
+    description: 'Automatically reset stick/button/trigger/dpad after this many seconds'
+  }
+};
+
+function validateGamepadAction(params, context = 'action') {
+  if (!params || typeof params !== 'object') {
+    throw new Error(`${context} must be an object`);
+  }
+
+  const { action, button, x, y, value, direction, holdSeconds } = params;
+
+  if (!action) {
+    throw new Error(`${context}: action is required`);
+  }
+
+  switch (action) {
+    case 'button':
+      if (!button) {
+        throw new Error(`${context}: button is required for button action`);
+      }
+      break;
+    case 'stick':
+      if (x === undefined || y === undefined) {
+        throw new Error(`${context}: x and y values are required for stick action`);
+      }
+      if (x < -1 || x > 1 || y < -1 || y > 1) {
+        throw new Error(`${context}: stick values must be between -1 and 1`);
+      }
+      break;
+    case 'trigger':
+      if (value === undefined) {
+        throw new Error(`${context}: value is required for trigger action`);
+      }
+      if (value < 0 || value > 1) {
+        throw new Error(`${context}: trigger value must be between 0 and 1`);
+      }
+      break;
+    case 'dpad':
+      if (!direction) {
+        throw new Error(`${context}: direction is required for dpad action`);
+      }
+      break;
+    default:
+      throw new Error(`${context}: invalid action ${action}`);
+  }
+
+  if (holdSeconds !== undefined && holdSeconds < 0) {
+    throw new Error(`${context}: holdSeconds must be zero or positive`);
+  }
+}
+
+/**
+ * Handler for the input_gamepad tool
+ */
+export class InputGamepadToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'input_gamepad',
+      'Gamepad input (buttons/sticks/triggers/dpad) with batching and auto-hold.',
+      {
+        type: 'object',
+        properties: {
+          ...actionProperties,
+          actions: {
+            type: 'array',
+            description: 'Batch multiple gamepad actions executed in order',
+            items: {
+              type: 'object',
+              properties: { ...actionProperties },
+              required: ['action']
+            }
+          }
+        },
+        anyOf: [{ required: ['action'] }, { required: ['actions'] }]
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    const { actions } = params;
+
+    if (Array.isArray(actions)) {
+      if (actions.length === 0) {
+        throw new Error('actions must contain at least one entry');
+      }
+      actions.forEach((action, index) => validateGamepadAction(action, `actions[${index}]`));
+      return;
+    }
+
+    if (actions !== undefined && !Array.isArray(actions)) {
+      throw new Error('actions must be an array');
+    }
+
+    validateGamepadAction(params);
+  }
+
+  async execute(params) {
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const hasBatch = Array.isArray(params.actions) && params.actions.length > 0;
+    const payload = hasBatch ? { actions: params.actions } : params;
+
+    const result = await this.unityConnection.sendCommand('input_gamepad', payload);
+    return result;
+  }
+}

package/src/handlers/input/InputKeyboardToolHandler.js

@@ -0,0 +1,127 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+const actionProperties = {
+  action: {
+    type: 'string',
+    enum: ['press', 'release', 'type', 'combo'],
+    description: 'The keyboard action to perform'
+  },
+  key: {
+    type: 'string',
+    description: 'The key to press/release (for press/release actions)'
+  },
+  keys: {
+    type: 'array',
+    items: { type: 'string' },
+    description: 'Array of keys for combo action'
+  },
+  text: {
+    type: 'string',
+    description: 'Text to type (for type action)'
+  },
+  typingSpeed: {
+    type: 'number',
+    description: 'Milliseconds per character when typing'
+  },
+  holdSeconds: {
+    type: 'number',
+    minimum: 0,
+    description: 'Automatically release after this many seconds (press/combo)'
+  }
+};
+
+function validateKeyboardAction(params, context = 'action') {
+  if (!params || typeof params !== 'object') {
+    throw new Error(`${context} must be an object`);
+  }
+
+  const { action, key, keys, text, holdSeconds } = params;
+
+  if (!action) {
+    throw new Error(`${context}: action is required`);
+  }
+
+  switch (action) {
+    case 'press':
+    case 'release':
+      if (!key) {
+        throw new Error(`${context}: key is required for ${action} action`);
+      }
+      break;
+    case 'type':
+      if (!text) {
+        throw new Error(`${context}: text is required for type action`);
+      }
+      break;
+    case 'combo':
+      if (!keys || !Array.isArray(keys) || keys.length === 0) {
+        throw new Error(`${context}: keys array is required for combo action`);
+      }
+      break;
+    default:
+      throw new Error(`${context}: invalid action ${action}`);
+  }
+
+  if (holdSeconds !== undefined && holdSeconds < 0) {
+    throw new Error(`${context}: holdSeconds must be zero or positive`);
+  }
+}
+
+/**
+ * Handler for the input_keyboard tool
+ */
+export class InputKeyboardToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'input_keyboard',
+      'Keyboard input (press/release/type/combo) with batching and auto-hold.',
+      {
+        type: 'object',
+        properties: {
+          ...actionProperties,
+          actions: {
+            type: 'array',
+            description: 'Batch multiple keyboard actions executed in order',
+            items: {
+              type: 'object',
+              properties: { ...actionProperties },
+              required: ['action']
+            }
+          }
+        },
+        anyOf: [{ required: ['action'] }, { required: ['actions'] }]
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    const { actions } = params;
+
+    if (Array.isArray(actions)) {
+      if (actions.length === 0) {
+        throw new Error('actions must contain at least one entry');
+      }
+      actions.forEach((action, index) => validateKeyboardAction(action, `actions[${index}]`));
+      return;
+    }
+
+    if (actions !== undefined && !Array.isArray(actions)) {
+      throw new Error('actions must be an array');
+    }
+
+    validateKeyboardAction(params);
+  }
+
+  async execute(params) {
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const hasBatch = Array.isArray(params.actions) && params.actions.length > 0;
+    const payload = hasBatch ? { actions: params.actions } : params;
+
+    const result = await this.unityConnection.sendCommand('input_keyboard', payload);
+    return result;
+  }
+}

package/src/handlers/input/InputMouseToolHandler.js

@@ -0,0 +1,188 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+const actionProperties = {
+  action: {
+    type: 'string',
+    enum: ['move', 'click', 'drag', 'scroll', 'button'],
+    description: 'The mouse action to perform'
+  },
+  x: {
+    type: 'number',
+    description: 'X coordinate for move action'
+  },
+  y: {
+    type: 'number',
+    description: 'Y coordinate for move action'
+  },
+  absolute: {
+    type: 'boolean',
+    description: 'Whether coordinates are absolute or relative (default: true)'
+  },
+  button: {
+    type: 'string',
+    enum: ['left', 'right', 'middle'],
+    description: 'Mouse button for click/drag/button actions'
+  },
+  buttonAction: {
+    type: 'string',
+    enum: ['press', 'release'],
+    description: 'Button action for button presses'
+  },
+  clickCount: {
+    type: 'number',
+    description: 'Number of clicks (for double/triple click)'
+  },
+  startX: {
+    type: 'number',
+    description: 'Start X for drag action'
+  },
+  startY: {
+    type: 'number',
+    description: 'Start Y for drag action'
+  },
+  endX: {
+    type: 'number',
+    description: 'End X for drag action'
+  },
+  endY: {
+    type: 'number',
+    description: 'End Y for drag action'
+  },
+  deltaX: {
+    type: 'number',
+    description: 'Horizontal scroll delta'
+  },
+  deltaY: {
+    type: 'number',
+    description: 'Vertical scroll delta'
+  },
+  holdSeconds: {
+    type: 'number',
+    minimum: 0,
+    description: 'Automatically release button after this many seconds'
+  }
+};
+
+function validateMouseAction(params, context = 'action') {
+  if (!params || typeof params !== 'object') {
+    throw new Error(`${context} must be an object`);
+  }
+
+  const {
+    action,
+    x,
+    y,
+    startX,
+    startY,
+    endX,
+    endY,
+    button,
+    buttonAction,
+    holdSeconds,
+    deltaX,
+    deltaY
+  } = params;
+
+  if (!action) {
+    throw new Error(`${context}: action is required`);
+  }
+
+  switch (action) {
+    case 'move':
+      if (x === undefined || y === undefined) {
+        throw new Error(`${context}: x and y coordinates are required for move action`);
+      }
+      break;
+    case 'drag':
+      if (
+        startX === undefined ||
+        startY === undefined ||
+        endX === undefined ||
+        endY === undefined
+      ) {
+        throw new Error(`${context}: startX, startY, endX, and endY are required for drag action`);
+      }
+      break;
+    case 'click':
+      // button optional (defaults to left)
+      break;
+    case 'scroll':
+      if (deltaX === undefined && deltaY === undefined) {
+        throw new Error(`${context}: deltaX or deltaY is required for scroll action`);
+      }
+      break;
+    case 'button':
+      if (!button) {
+        throw new Error(`${context}: button is required for button action`);
+      }
+      if (!buttonAction) {
+        throw new Error(`${context}: buttonAction is required for button action`);
+      }
+      break;
+    default:
+      throw new Error(`${context}: invalid action ${action}`);
+  }
+
+  if (holdSeconds !== undefined && holdSeconds < 0) {
+    throw new Error(`${context}: holdSeconds must be zero or positive`);
+  }
+}
+
+/**
+ * Handler for the input_mouse tool
+ */
+export class InputMouseToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'input_mouse',
+      'Mouse input (move/click/drag/scroll/button) with batching and auto-hold.',
+      {
+        type: 'object',
+        properties: {
+          ...actionProperties,
+          actions: {
+            type: 'array',
+            description: 'Batch multiple mouse actions executed in order',
+            items: {
+              type: 'object',
+              properties: { ...actionProperties },
+              required: ['action']
+            }
+          }
+        },
+        anyOf: [{ required: ['action'] }, { required: ['actions'] }]
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    const { actions } = params;
+
+    if (Array.isArray(actions)) {
+      if (actions.length === 0) {
+        throw new Error('actions must contain at least one entry');
+      }
+      actions.forEach((action, index) => validateMouseAction(action, `actions[${index}]`));
+      return;
+    }
+
+    if (actions !== undefined && !Array.isArray(actions)) {
+      throw new Error('actions must be an array');
+    }
+
+    validateMouseAction(params);
+  }
+
+  async execute(params) {
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+
+    const hasBatch = Array.isArray(params.actions) && params.actions.length > 0;
+    const payload = hasBatch ? { actions: params.actions } : params;
+
+    const result = await this.unityConnection.sendCommand('input_mouse', payload);
+    return result;
+  }
+}

package/src/handlers/input/InputSystemControlToolHandler.js

@@ -4,77 +4,76 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  * Handler for the input_system_control tool
  */
 export class InputSystemControlToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'input_system_control',
-            'Main handler for Input System operations',
-            {
-                type: 'object',
-                properties: {
-                    operation: {
-                        type: 'string',
-                        enum: ['keyboard', 'mouse', 'gamepad', 'touch', 'sequence', 'get_state'],
-                        description: 'The input operation to perform'
-                    },
-                    parameters: {
-                        type: 'object',
-                        description: 'Parameters for the specific operation'
-                    }
-                },
-                required: ['operation']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
-
-    validate(params) {
-        const { operation, parameters } = params;
-
-        if (!operation) {
-            throw new Error('operation is required');
+  constructor(unityConnection) {
+    super('input_system_control', 'Main handler for Input System operations', {
+      type: 'object',
+      properties: {
+        operation: {
+          type: 'string',
+          enum: ['keyboard', 'mouse', 'gamepad', 'touch', 'sequence', 'get_state'],
+          description: 'The input operation to perform'
+        },
+        parameters: {
+          type: 'object',
+          description: 'Parameters for the specific operation'
         }
+      },
+      required: ['operation']
+    });
+    this.unityConnection = unityConnection;
+  }
 
-        const validOperations = ['keyboard', 'mouse', 'gamepad', 'touch', 'sequence', 'get_state'];
-        if (!validOperations.includes(operation)) {
-            throw new Error(`Invalid operation: ${operation}. Must be one of: ${validOperations.join(', ')}`);
-        }
+  validate(params) {
+    const { operation, parameters } = params;
 
-        // Operation-specific validation
-        if (operation !== 'get_state' && !parameters) {
-            throw new Error(`parameters are required for operation: ${operation}`);
-        }
+    if (!operation) {
+      throw new Error('operation is required');
     }
 
-    async execute(params) {
-        const { operation, parameters = {} } = params;
+    const validOperations = ['keyboard', 'mouse', 'gamepad', 'touch', 'sequence', 'get_state'];
+    if (!validOperations.includes(operation)) {
+      throw new Error(
+        `Invalid operation: ${operation}. Must be one of: ${validOperations.join(', ')}`
+      );
+    }
 
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
+    // Operation-specific validation
+    if (operation !== 'get_state' && !parameters) {
+      throw new Error(`parameters are required for operation: ${operation}`);
+    }
+  }
 
-        let command;
-        switch (operation) {
-            case 'keyboard':
-                command = 'simulate_keyboard_input';
-                break;
-            case 'mouse':
-                command = 'simulate_mouse_input';
-                break;
-            case 'gamepad':
-                command = 'simulate_gamepad_input';
-                break;
-            case 'touch':
-                command = 'simulate_touch_input';
-                break;
-            case 'sequence':
-                command = 'create_input_sequence';
-                break;
-            case 'get_state':
-                command = 'get_current_input_state';
-                break;        }
+  async execute(params) {
+    const { operation, parameters = {} } = params;
 
-        const result = await this.unityConnection.sendCommand(command, parameters);
-        return result;
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
     }
+
+    let command;
+    switch (operation) {
+      case 'keyboard':
+        command = 'input_keyboard';
+        break;
+      case 'mouse':
+        command = 'input_mouse';
+        break;
+      case 'gamepad':
+        command = 'input_gamepad';
+        break;
+      case 'touch':
+        command = 'input_touch';
+        break;
+      case 'sequence':
+        command = 'create_input_sequence';
+        break;
+      case 'get_state':
+        command = 'get_current_input_state';
+        break;
+    }
+
+    const result = await this.unityConnection.sendCommand(command, parameters);
+    return result;
+  }
 }