@akiojin/unity-mcp-server 2.14.14

package/src/handlers/input/KeyboardSimulationHandler.js

@@ -0,0 +1,79 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handles keyboard input simulation
+ */
+export class KeyboardSimulationHandler extends BaseToolHandler {
+    constructor(unityConnection) {
+        super(
+            'simulate_keyboard',
+            'Simulate keyboard input (press/release/type/combo) with typing speed.',
+            {
+                type: 'object',
+                properties: {
+                    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'
+                    }
+                },
+                required: ['action']
+            }
+        );
+        this.unityConnection = unityConnection;
+    }
+
+    validate(params) {
+        const { action, key, keys, text } = params;
+
+        if (!action) {
+            throw new Error('action is required');
+        }
+
+        switch (action) {
+            case 'press':
+            case 'release':
+                if (!key) {
+                    throw new Error(`key is required for ${action} action`);
+                }
+                break;
+            case 'type':
+                if (!text) {
+                    throw new Error('text is required for type action');
+                }
+                break;
+            case 'combo':
+                if (!keys || !Array.isArray(keys) || keys.length === 0) {
+                    throw new Error('keys array is required for combo action');
+                }
+                break;        }
+    }
+
+    async execute(params) {
+        // Ensure connected
+        if (!this.unityConnection.isConnected()) {
+            await this.unityConnection.connect();
+        }
+
+        const result = await this.unityConnection.sendCommand('simulate_keyboard_input', params);
+        return result;
+    }
+}

package/src/handlers/input/ManageControlSchemesToolHandler.js

@@ -0,0 +1,20 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import {
+    manageControlSchemesToolDefinition,
+    manageControlSchemesHandler
+} from '../../tools/input/inputActionsEditor.js';
+
+export class ManageControlSchemesToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      manageControlSchemesToolDefinition.name,
+      manageControlSchemesToolDefinition.description,
+      manageControlSchemesToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  async execute(args) {
+    return manageControlSchemesHandler(this.unityConnection, args);
+  }
+}

package/src/handlers/input/MouseSimulationHandler.js

@@ -0,0 +1,107 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handles mouse input simulation
+ */
+export class MouseSimulationHandler extends BaseToolHandler {
+    constructor(unityConnection) {
+        super(
+            'simulate_mouse',
+            'Simulate mouse input (move/click/drag/scroll) with absolute/relative coords.',
+            {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['move', 'click', 'drag', 'scroll'],
+                        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 actions'
+                    },
+                    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'
+                    }
+                },
+                required: ['action']
+            }
+        );
+        this.unityConnection = unityConnection;
+    }
+
+    validate(params) {
+        const { action, x, y, startX, startY, endX, endY } = params;
+
+        if (!action) {
+            throw new Error('action is required');
+        }
+
+        switch (action) {
+            case 'move':
+                if (x === undefined || y === undefined) {
+                    throw new Error('x and y coordinates are required for move action');
+                }
+                break;
+            case 'drag':
+                if (startX === undefined || startY === undefined || 
+                    endX === undefined || endY === undefined) {
+                    throw new Error('startX, startY, endX, and endY are required for drag action');
+                }
+                break;
+            case 'click':
+            case 'scroll':
+                // These actions have optional parameters
+                break;        }
+    }
+
+    async execute(params) {
+        // Ensure connected
+        if (!this.unityConnection.isConnected()) {
+            await this.unityConnection.connect();
+        }
+
+        const result = await this.unityConnection.sendCommand('simulate_mouse_input', params);
+        return result;
+    }
+}

package/src/handlers/input/RemoveActionMapToolHandler.js

@@ -0,0 +1,20 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import {
+    removeActionMapToolDefinition,
+    removeActionMapHandler
+} from '../../tools/input/inputActionsEditor.js';
+
+export class RemoveActionMapToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      removeActionMapToolDefinition.name,
+      removeActionMapToolDefinition.description,
+      removeActionMapToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  async execute(args) {
+    return removeActionMapHandler(this.unityConnection, args);
+  }
+}

package/src/handlers/input/RemoveAllBindingsToolHandler.js

@@ -0,0 +1,20 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import {
+    removeAllBindingsToolDefinition,
+    removeAllBindingsHandler
+} from '../../tools/input/inputActionsEditor.js';
+
+export class RemoveAllBindingsToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      removeAllBindingsToolDefinition.name,
+      removeAllBindingsToolDefinition.description,
+      removeAllBindingsToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  async execute(args) {
+    return removeAllBindingsHandler(this.unityConnection, args);
+  }
+}

package/src/handlers/input/RemoveInputActionToolHandler.js

@@ -0,0 +1,20 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import {
+    removeInputActionToolDefinition,
+    removeInputActionHandler
+} from '../../tools/input/inputActionsEditor.js';
+
+export class RemoveInputActionToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      removeInputActionToolDefinition.name,
+      removeInputActionToolDefinition.description,
+      removeInputActionToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  async execute(args) {
+    return removeInputActionHandler(this.unityConnection, args);
+  }
+}

package/src/handlers/input/RemoveInputBindingToolHandler.js

@@ -0,0 +1,20 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import {
+    removeInputBindingToolDefinition,
+    removeInputBindingHandler
+} from '../../tools/input/inputActionsEditor.js';
+
+export class RemoveInputBindingToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      removeInputBindingToolDefinition.name,
+      removeInputBindingToolDefinition.description,
+      removeInputBindingToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  async execute(args) {
+    return removeInputBindingHandler(this.unityConnection, args);
+  }
+}

package/src/handlers/input/TouchSimulationHandler.js

@@ -0,0 +1,142 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handles touch input simulation
+ */
+export class TouchSimulationHandler extends BaseToolHandler {
+    constructor(unityConnection) {
+        super(
+            'simulate_touch',
+            'Simulate touch input (tap/swipe/pinch/multi) with coordinates and timing.',
+            {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['tap', 'swipe', 'pinch', 'multi'],
+                        description: 'The touch action to perform'
+                    },
+                    x: {
+                        type: 'number',
+                        description: 'X coordinate for tap action'
+                    },
+                    y: {
+                        type: 'number',
+                        description: 'Y coordinate for tap action'
+                    },
+                    touchId: {
+                        type: 'number',
+                        
+                        minimum: 0,
+                        maximum: 9,
+                        description: 'Touch ID (0-9)'
+                    },
+                    startX: {
+                        type: 'number',
+                        description: 'Start X for swipe action'
+                    },
+                    startY: {
+                        type: 'number',
+                        description: 'Start Y for swipe action'
+                    },
+                    endX: {
+                        type: 'number',
+                        description: 'End X for swipe action'
+                    },
+                    endY: {
+                        type: 'number',
+                        description: 'End Y for swipe action'
+                    },
+                    duration: {
+                        type: 'number',
+                        
+                        description: 'Swipe duration in milliseconds'
+                    },
+                    centerX: {
+                        type: 'number',
+                        description: 'Center X for pinch gesture'
+                    },
+                    centerY: {
+                        type: 'number',
+                        description: 'Center Y for pinch gesture'
+                    },
+                    startDistance: {
+                        type: 'number',
+                        
+                        description: 'Start distance between fingers for pinch'
+                    },
+                    endDistance: {
+                        type: 'number',
+                        
+                        description: 'End distance between fingers for pinch'
+                    },
+                    touches: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                x: { type: 'number' },
+                                y: { type: 'number' },
+                                phase: { 
+                                    type: 'string',
+                                    enum: ['began', 'moved', 'stationary', 'ended']
+                                }
+                            },
+                            required: ['x', 'y']
+                        },
+                        description: 'Array of touch points for multi-touch'
+                    }
+                },
+                required: ['action']
+            }
+        );
+        this.unityConnection = unityConnection;
+    }
+
+    validate(params) {
+        const { action, x, y, startX, startY, endX, endY, touches } = params;
+
+        if (!action) {
+            throw new Error('action is required');
+        }
+
+        switch (action) {
+            case 'tap':
+                if (x === undefined || y === undefined) {
+                    throw new Error('x and y coordinates are required for tap action');
+                }
+                break;
+            case 'swipe':
+                if (startX === undefined || startY === undefined || 
+                    endX === undefined || endY === undefined) {
+                    throw new Error('startX, startY, endX, and endY are required for swipe action');
+                }
+                break;
+            case 'pinch':
+                // Optional parameters with defaults
+                break;
+            case 'multi':
+                if (!touches || !Array.isArray(touches) || touches.length === 0) {
+                    throw new Error('touches array is required for multi-touch action');
+                }
+                if (touches.length > 10) {
+                    throw new Error('Maximum 10 simultaneous touches supported');
+                }
+                for (const touch of touches) {
+                    if (touch.x === undefined || touch.y === undefined) {
+                        throw new Error('Each touch must have x and y coordinates');
+                    }
+                }
+                break;        }
+    }
+
+    async execute(params) {
+        // Ensure connected
+        if (!this.unityConnection.isConnected()) {
+            await this.unityConnection.connect();
+        }
+
+        const result = await this.unityConnection.sendCommand('simulate_touch_input', params);
+        return result;
+    }
+}