@akiojin/unity-mcp-server 2.32.0 → 2.37.0

package/src/utils/editorState.js

@@ -0,0 +1,42 @@
+export function extractEditorState(payload) {
+  if (!isObjectLike(payload)) {
+    return null;
+  }
+
+  const queue = [payload];
+  const seen = new Set();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!isObjectLike(current) || seen.has(current)) {
+      continue;
+    }
+
+    seen.add(current);
+
+    if (typeof current.isPlaying === 'boolean') {
+      return current;
+    }
+
+    if (Array.isArray(current)) {
+      for (const value of current) {
+        if (isObjectLike(value)) {
+          queue.push(value);
+        }
+      }
+      continue;
+    }
+
+    for (const value of Object.values(current)) {
+      if (isObjectLike(value)) {
+        queue.push(value);
+      }
+    }
+  }
+
+  return null;
+}
+
+function isObjectLike(value) {
+  return typeof value === 'object' && value !== null;
+}

package/src/utils/testResultsCache.js

@@ -0,0 +1,70 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { WORKSPACE_ROOT, logger } from '../core/config.js';
+
+const UNITY_DIRNAME = '.unity';
+const TEST_RESULTS_FILENAME = 'TestResults.json';
+
+function resolveWorkspaceRoot() {
+  return WORKSPACE_ROOT || process.cwd();
+}
+
+export function getResultsFilePath() {
+  const workspaceRoot = resolveWorkspaceRoot();
+  if (!workspaceRoot) {
+    return null;
+  }
+
+  return path.join(workspaceRoot, UNITY_DIRNAME, TEST_RESULTS_FILENAME);
+}
+
+export async function persistTestResults(result) {
+  const filePath = getResultsFilePath();
+  if (!filePath) {
+    return null;
+  }
+
+  try {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+    return filePath;
+  } catch (error) {
+    logger.warn(`[TestResultsCache] Failed to write test results to ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+export async function loadCachedTestResults(targetPath) {
+  const filePath = targetPath || getResultsFilePath();
+  if (!filePath) {
+    return null;
+  }
+
+  try {
+    const data = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(data);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      logger.warn(
+        `[TestResultsCache] Failed to read test results from ${filePath}: ${error.message}`
+      );
+    }
+    return null;
+  }
+}
+
+export async function resetTestResultsCache() {
+  const filePath = getResultsFilePath();
+  if (!filePath) {
+    return;
+  }
+
+  try {
+    await fs.rm(filePath, { force: true });
+  } catch (error) {
+    logger.warn(
+      `[TestResultsCache] Failed to reset test results cache ${filePath}: ${error.message}`
+    );
+  }
+}

package/src/handlers/input/InputGamepadSimulateToolHandler.js

@@ -1,116 +0,0 @@
-import { BaseToolHandler } from '../base/BaseToolHandler.js';
-
-/**
- * Handler for the input_gamepad_simulate tool
- */
-export class InputGamepadSimulateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'input_gamepad_simulate',
-            'Simulate gamepad input (buttons/sticks/triggers/dpad) with value ranges.',
-            {
-                type: 'object',
-                properties: {
-                    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'
-                    }
-                },
-                required: ['action']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
-
-    validate(params) {
-        const { action, button, x, y, value, direction } = params;
-
-        if (!action) {
-            throw new Error('action is required');
-        }
-
-        switch (action) {
-            case 'button':
-                if (!button) {
-                    throw new Error('button is required for button action');
-                }
-                break;
-            case 'stick':
-                if (x === undefined || y === undefined) {
-                    throw new Error('x and y values are required for stick action');
-                }
-                if (x < -1 || x > 1 || y < -1 || y > 1) {
-                    throw new Error('Stick values must be between -1 and 1');
-                }
-                break;
-            case 'trigger':
-                if (value === undefined) {
-                    throw new Error('value is required for trigger action');
-                }
-                if (value < 0 || value > 1) {
-                    throw new Error('Trigger value must be between 0 and 1');
-                }
-                break;
-            case 'dpad':
-                if (!direction) {
-                    throw new Error('direction is required for dpad action');
-                }
-                break;        }
-    }
-
-    async execute(params) {
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
-
-        const result = await this.unityConnection.sendCommand('simulate_gamepad_input', params);
-        return result;
-    }
-}

package/src/handlers/input/InputKeyboardSimulateToolHandler.js

@@ -1,79 +0,0 @@
-import { BaseToolHandler } from '../base/BaseToolHandler.js';
-
-/**
- * Handler for the input_keyboard_simulate tool
- */
-export class InputKeyboardSimulateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'input_keyboard_simulate',
-            '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/InputMouseSimulateToolHandler.js

@@ -1,107 +0,0 @@
-import { BaseToolHandler } from '../base/BaseToolHandler.js';
-
-/**
- * Handler for the input_mouse_simulate tool
- */
-export class InputMouseSimulateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'input_mouse_simulate',
-            '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/InputTouchSimulateToolHandler.js

@@ -1,142 +0,0 @@
-import { BaseToolHandler } from '../base/BaseToolHandler.js';
-
-/**
- * Handler for the input_touch_simulate tool
- */
-export class InputTouchSimulateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'input_touch_simulate',
-            '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;
-    }
-}