@akiojin/unity-mcp-server 2.14.17 → 2.16.1

package/src/handlers/test/TestGetStatusToolHandler.js

@@ -0,0 +1,79 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for getting Unity test execution status
+ * Works with non-blocking test execution from RunUnityTestsToolHandler
+ */
+export class TestGetStatusToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'test_get_status',
+      'Get current Unity test execution status and results',
+      {
+        type: 'object',
+        properties: {}
+      }
+    );
+
+    this.unityConnection = unityConnection;
+  }
+
+  /**
+   * Gets current test execution status
+   * @param {Object} params - The validated input parameters
+   * @returns {Promise<Object>} Test execution status and results
+   */
+  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('get_test_status', params);
+
+    // Handle Unity response
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    // Return status directly if still running or idle
+    if (response.status === 'running' || response.status === 'idle') {
+      return response;
+    }
+
+    // Format completed results
+    if (response.status === 'completed') {
+      const result = {
+        status: 'completed',
+        success: response.success,
+        totalTests: response.totalTests,
+        passedTests: response.passedTests,
+        failedTests: response.failedTests,
+        skippedTests: response.skippedTests,
+        inconclusiveTests: response.inconclusiveTests,
+        summary: `${response.passedTests}/${response.totalTests} tests passed`,
+        failures: response.failures || [],
+        tests: response.tests || []
+      };
+
+      return result;
+    }
+
+    // Error status
+    return response;
+  }
+
+  /**
+   * Gets example usage for this tool
+   * @returns {Object} Example usage scenarios
+   */
+  getExamples() {
+    return {
+      checkStatus: {
+        description: 'Check current test execution status',
+        params: {}
+      }
+    };
+  }
+}

package/src/handlers/test/TestRunToolHandler.js

@@ -0,0 +1,153 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler for running Unity NUnit tests via Test Runner API
+ * Implements SPEC-e7c9b50c: Unity Test Execution Feature
+ */
+export class TestRunToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'test_run',
+      'Run Unity NUnit tests in the current project',
+      {
+        type: 'object',
+        properties: {
+          testMode: {
+            type: 'string',
+            enum: ['EditMode', 'PlayMode', 'All'],
+            default: 'EditMode',
+            description: 'Test mode to run (EditMode: editor tests, PlayMode: runtime tests, All: both)'
+          },
+          filter: {
+            type: 'string',
+            description: 'Filter tests by class name (e.g., "PlayerControllerTests")'
+          },
+          category: {
+            type: 'string',
+            description: 'Filter tests by category attribute (e.g., "Integration")'
+          },
+          namespace: {
+            type: 'string',
+            description: 'Filter tests by namespace (e.g., "MyGame.Tests.Player")'
+          },
+          includeDetails: {
+            type: 'boolean',
+            default: false,
+            description: 'Include detailed test results for each individual test'
+          },
+          exportPath: {
+            type: 'string',
+            description: 'Export test results to NUnit XML file at specified path'
+          }
+        }
+      }
+    );
+
+    this.unityConnection = unityConnection;
+  }
+
+  /**
+   * Executes Unity tests based on specified parameters
+   * @param {Object} params - The validated input parameters
+   * @returns {Promise<Object>} Test execution results
+   */
+  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('run_tests', params);
+
+    // Handle Unity response
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    // Handle new non-blocking response format (status: "running")
+    if (response.status === 'running') {
+      return {
+        status: 'running',
+        message: response.message || 'Test execution started. Use get_test_status to check progress.'
+      };
+    }
+
+    // Legacy format support (for backwards compatibility)
+    // Format and return result
+    const result = {
+      success: response.success,
+      totalTests: response.totalTests,
+      passedTests: response.passedTests,
+      failedTests: response.failedTests,
+      skippedTests: response.skippedTests,
+      inconclusiveTests: response.inconclusiveTests,
+      duration: response.duration,
+      summary: `${response.passedTests}/${response.totalTests} tests passed in ${response.duration}s`,
+      failures: response.failures || []
+    };
+
+    // Include detailed test results if requested
+    if (params.includeDetails && response.tests) {
+      result.tests = response.tests;
+    }
+
+    return result;
+  }
+
+  /**
+   * Gets example usage for this tool
+   * @returns {Object} Example usage scenarios
+   */
+  getExamples() {
+    return {
+      runAllEditModeTests: {
+        description: 'Run all Edit Mode tests',
+        params: {
+          testMode: 'EditMode'
+        }
+      },
+      runSpecificClass: {
+        description: 'Run tests in a specific class',
+        params: {
+          testMode: 'EditMode',
+          filter: 'PlayerControllerTests'
+        }
+      },
+      runCategoryTests: {
+        description: 'Run tests in a specific category',
+        params: {
+          testMode: 'EditMode',
+          category: 'Integration'
+        }
+      },
+      runWithDetails: {
+        description: 'Run tests with detailed results for each test',
+        params: {
+          testMode: 'EditMode',
+          includeDetails: true
+        }
+      },
+      runAndExport: {
+        description: 'Run tests and export results to XML',
+        params: {
+          testMode: 'EditMode',
+          exportPath: 'TestResults/results.xml'
+        }
+      },
+      runPlayModeTests: {
+        description: 'Run Play Mode tests (requires Play Mode)',
+        params: {
+          testMode: 'PlayMode'
+        }
+      },
+      runAllTests: {
+        description: 'Run both Edit Mode and Play Mode tests',
+        params: {
+          testMode: 'All',
+          includeDetails: true
+        }
+      }
+    };
+  }
+}

package/src/handlers/ui/{ClickUIElementToolHandler.js → UIClickElementToolHandler.js}

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class ClickUIElementToolHandler extends BaseToolHandler {
+export class UIClickElementToolHandler extends BaseToolHandler {
     constructor(unityConnection) {
         super(
-            'click_ui_element',
+            'ui_click_element',
             'Simulate clicking on UI elements',
             {
                 type: 'object',

package/src/handlers/ui/{FindUIElementsToolHandler.js → UIFindElementsToolHandler.js}

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class FindUIElementsToolHandler extends BaseToolHandler {
+export class UIFindElementsToolHandler extends BaseToolHandler {
     constructor(unityConnection) {
         super(
-            'find_ui_elements',
+            'ui_find_elements',
             'Find UI elements by component type, tag, or name pattern.',
             {
                 type: 'object',

package/src/handlers/ui/{GetUIElementStateToolHandler.js → UIGetElementStateToolHandler.js}

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class GetUIElementStateToolHandler extends BaseToolHandler {
+export class UIGetElementStateToolHandler extends BaseToolHandler {
     constructor(unityConnection) {
         super(
-            'get_ui_element_state',
+            'ui_get_element_state',
             'Get detailed state information about UI elements',
             {
                 type: 'object',

package/src/handlers/ui/{SetUIElementValueToolHandler.js → UISetElementValueToolHandler.js}

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class SetUIElementValueToolHandler extends BaseToolHandler {
+export class UISetElementValueToolHandler extends BaseToolHandler {
     constructor(unityConnection) {
         super(
-            'set_ui_element_value',
+            'ui_set_element_value',
             'Set values for UI input elements',
             {
                 type: 'object',

package/src/handlers/ui/{SimulateUIInputToolHandler.js → UISimulateInputToolHandler.js}

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class SimulateUIInputToolHandler extends BaseToolHandler {
+export class UISimulateInputToolHandler extends BaseToolHandler {
     constructor(unityConnection) {
         super(
-            'simulate_ui_input',
+            'ui_simulate_input',
             'Simulate complex UI interactions and input sequences',
             {
                 type: 'object',

package/src/handlers/video/{CaptureVideoForToolHandler.js → VideoCaptureForToolHandler.js}

@@ -4,10 +4,10 @@
  */
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class CaptureVideoForToolHandler extends BaseToolHandler {
+export class VideoCaptureForToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'capture_video_for',
+      'video_capture_for',
       'Record video for a fixed duration (auto-stop). Optionally enters Play Mode first.',
       {
         type: 'object',
@@ -34,12 +34,12 @@ export class CaptureVideoForToolHandler extends BaseToolHandler {
       let needPlay = !!params.play;
       if (params.play === undefined) {
         try {
-          const s0 = await this.unityConnection.sendCommand('get_editor_state', {});
+          const s0 = await this.unityConnection.sendCommand('playmode_get_state', {});
           needPlay = !(s0 && s0.isPlaying);
         } catch { needPlay = true; }
       }
       if (needPlay) {
-        await this.unityConnection.sendCommand('play_game', {});
+        await this.unityConnection.sendCommand('playmode_play', {});
         for (let i = 0; i < 60; i++) {
           const s = await this.unityConnection.sendCommand('get_editor_state', {});
           if (s && s.isPlaying) { enteredPlay = true; break; }
@@ -49,7 +49,7 @@ export class CaptureVideoForToolHandler extends BaseToolHandler {
 
       // Start with auto-stop
       const { WORKSPACE_ROOT } = await import('../../core/config.js');
-      const startResp = await this.unityConnection.sendCommand('capture_video_start', {
+      const startResp = await this.unityConnection.sendCommand('video_capture_start', {
         captureMode: params.captureMode || 'game',
         width: params.width ?? 1280,
         height: params.height ?? 720,
@@ -65,14 +65,14 @@ export class CaptureVideoForToolHandler extends BaseToolHandler {
       const deadline = Date.now() + Math.max(0, Math.floor((params.durationSec || 0) * 1000)) + 1500; // small buffer
       let lastStatus = null;
       while (Date.now() < deadline) {
-        lastStatus = await this.unityConnection.sendCommand('capture_video_status', {});
+        lastStatus = await this.unityConnection.sendCommand('video_capture_status', {});
         if (lastStatus && lastStatus.isRecording === false) break;
         await sleep(250);
       }
 
       // Safety stop if still recording after deadline
       if (lastStatus && lastStatus.isRecording) {
-        await this.unityConnection.sendCommand('capture_video_stop', {});
+        await this.unityConnection.sendCommand('video_capture_stop', {});
       }
 
       // Final stop result
@@ -88,7 +88,7 @@ export class CaptureVideoForToolHandler extends BaseToolHandler {
       return { error: e.message, code: 'CLIENT_ERROR' };
     } finally {
       // If we entered play, attempt to leave play (best-effort)
-      try { if (enteredPlay) await this.unityConnection.sendCommand('stop_game', {}); } catch {}
+      try { if (enteredPlay) await this.unityConnection.sendCommand('playmode_stop', {}); } catch {}
     }
   }
 }

package/src/handlers/video/{CaptureVideoStartToolHandler.js → VideoCaptureStartToolHandler.js}

@@ -3,10 +3,10 @@
  */
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class CaptureVideoStartToolHandler extends BaseToolHandler {
+export class VideoCaptureStartToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'capture_video_start',
+      'video_capture_start',
       'Start video recording (Game view). Requires com.unity.recorder.',
       {
         type: 'object',

package/src/handlers/video/{CaptureVideoStatusToolHandler.js → VideoCaptureStatusToolHandler.js}

@@ -3,10 +3,10 @@
  */
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class CaptureVideoStatusToolHandler extends BaseToolHandler {
+export class VideoCaptureStatusToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'capture_video_status',
+      'video_capture_status',
       'Get current video recording status.',
       {
         type: 'object',

package/src/handlers/video/{CaptureVideoStopToolHandler.js → VideoCaptureStopToolHandler.js}

@@ -1,12 +1,12 @@
 /**
- * Handler for stopping video capture in Unity Editor (via MCP)
+ * Handler for the video_capture_stop tool
  */
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
-export class CaptureVideoStopToolHandler extends BaseToolHandler {
+export class VideoCaptureStopToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'capture_video_stop',
+      'video_capture_stop',
       'Stop current video recording and finalize the file.',
       {
         type: 'object',

package/src/lsp/CSharpLspUtils.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import { logger } from '../core/config.js';
 import { WORKSPACE_ROOT } from '../core/config.js';
 
@@ -21,29 +22,86 @@ export class CSharpLspUtils {
     }
   }
 
-  getLocalPath(rid) {
+  getExecutableName() {
+    return process.platform === 'win32' ? 'server.exe' : 'server';
+  }
+
+  getPrimaryToolRoot() {
+    const envRoot = process.env.UNITY_MCP_TOOLS_ROOT;
+    if (envRoot && envRoot.trim().length > 0) {
+      return path.resolve(envRoot.trim());
+    }
+    return path.join(os.homedir(), '.unity', 'tools');
+  }
+
+  getLegacyToolRoot() {
     const root = WORKSPACE_ROOT || process.cwd();
-    const exe = process.platform === 'win32' ? 'server.exe' : 'server';
-    return path.resolve(root, '.unity', 'tools', 'csharp-lsp', rid, exe);
+    return path.resolve(root, '.unity', 'tools');
+  }
+
+  resolveToolPaths(rid) {
+    const exe = this.getExecutableName();
+    const primary = path.resolve(this.getPrimaryToolRoot(), 'csharp-lsp', rid, exe);
+    const legacy = path.resolve(this.getLegacyToolRoot(), 'csharp-lsp', rid, exe);
+    return { primary, legacy };
+  }
+
+  resolveVersionPaths(rid) {
+    const { primary, legacy } = this.resolveToolPaths(rid);
+    return {
+      primary: path.resolve(path.dirname(primary), 'VERSION'),
+      legacy: path.resolve(path.dirname(legacy), 'VERSION')
+    };
+  }
+
+  migrateLegacyIfNeeded(rid) {
+    const { primary, legacy } = this.resolveToolPaths(rid);
+    if (!fs.existsSync(legacy)) return;
+    if (fs.existsSync(primary)) return;
+    try {
+      fs.mkdirSync(path.dirname(primary), { recursive: true });
+      fs.copyFileSync(legacy, primary);
+      const { primary: primaryVersion, legacy: legacyVersion } = this.resolveVersionPaths(rid);
+      if (fs.existsSync(legacyVersion) && !fs.existsSync(primaryVersion)) {
+        try {
+          fs.copyFileSync(legacyVersion, primaryVersion);
+        } catch {}
+      }
+      logger.info(`[csharp-lsp] migrated legacy binary to ${path.dirname(primary)}`);
+    } catch (e) {
+      logger.warn(`[csharp-lsp] legacy migration failed: ${e.message}`);
+    }
+  }
+
+  getLocalPath(rid) {
+    const { primary, legacy } = this.resolveToolPaths(rid);
+    this.migrateLegacyIfNeeded(rid);
+    if (fs.existsSync(primary)) return primary;
+    if (fs.existsSync(legacy)) return legacy;
+    return primary;
   }
 
   getVersionMarkerPath(rid) {
-    const bin = this.getLocalPath(rid);
-    return path.resolve(path.dirname(bin), 'VERSION');
+    const { primary, legacy } = this.resolveVersionPaths(rid);
+    if (fs.existsSync(primary)) return primary;
+    if (fs.existsSync(legacy)) return legacy;
+    return primary;
   }
 
   readLocalVersion(rid) {
     try {
-      const m = this.getVersionMarkerPath(rid);
-      if (fs.existsSync(m)) return fs.readFileSync(m, 'utf8').trim();
+      const { primary, legacy } = this.resolveVersionPaths(rid);
+      if (fs.existsSync(primary)) return fs.readFileSync(primary, 'utf8').trim();
+      if (fs.existsSync(legacy)) return fs.readFileSync(legacy, 'utf8').trim();
     } catch {}
     return null;
   }
 
   writeLocalVersion(rid, version) {
     try {
-      const m = this.getVersionMarkerPath(rid);
-      fs.writeFileSync(m, String(version || '').trim() + '\n', 'utf8');
+      const marker = this.getVersionMarkerPath(rid);
+      fs.mkdirSync(path.dirname(marker), { recursive: true });
+      fs.writeFileSync(marker, String(version || '').trim() + '\n', 'utf8');
     } catch {}
   }
 
@@ -67,7 +125,7 @@ export class CSharpLspUtils {
     const entry = manifest?.assets?.[rid];
     if (!entry?.url || !entry?.sha256) throw new Error(`manifest missing entry for ${rid}`);
 
-    const dest = this.getLocalPath(rid);
+    const { primary: dest } = this.resolveToolPaths(rid);
     fs.mkdirSync(path.dirname(dest), { recursive: true });
     const tmp = dest + '.download';
     await this.downloadTo(entry.url, tmp);

package/src/lsp/LspRpcClient.js

@@ -99,6 +99,20 @@ export class LspRpcClient {
     return await this.#requestWithRetry(method, params, 1);
   }
 
+  async validateText(relative, newText) {
+    const resp = await this.request('mcp/validateTextEdits', { relative, newText });
+    if (!resp) return [];
+    const payload = resp.result ?? resp;
+    const diagnostics = Array.isArray(payload?.diagnostics) ? payload.diagnostics : [];
+    return diagnostics.map((d) => ({
+      severity: d?.severity,
+      message: d?.message,
+      id: d?.id,
+      line: d?.line,
+      column: d?.column,
+    }));
+  }
+
   async #requestWithRetry(method, params, attempt) {
     await this.ensure();
     const id = this.seq++;

package/src/tools/analysis/analyzeSceneContents.js

@@ -1,8 +1,8 @@
 /**
- * Tool definition for analyze_scene_contents
+ * Tool definition for analysis_scene_contents_analyze
  */
 export const analyzeSceneContentsToolDefinition = {
-    name: 'analyze_scene_contents',
+    name: 'analysis_scene_contents_analyze',
     description: 'Analyze current scene: object counts, types, prefabs, and memory stats.',
     inputSchema: {
         type: 'object',
@@ -47,7 +47,7 @@ export async function analyzeSceneContentsHandler(unityConnection, args) {
         }
 
         // Send command to Unity with provided parameters
-        const result = await unityConnection.sendCommand('analyze_scene_contents', args);
+        const result = await unityConnection.sendCommand('analysis_scene_contents_analyze', args);
 
         // The unityConnection.sendCommand already extracts the result field
         // from the response, so we access properties directly on result

package/src/tools/analysis/findByComponent.js

@@ -1,8 +1,8 @@
 /**
- * Tool definition for find_by_component
+ * Tool definition for analysis_component_find
  */
 export const findByComponentToolDefinition = {
-    name: 'find_by_component',
+    name: 'analysis_component_find',
     description: 'Find GameObjects that have a specific component type (scene/prefabs/all).',
     inputSchema: {
         type: 'object',
@@ -48,7 +48,7 @@ export async function findByComponentHandler(unityConnection, args) {
         }
 
         // Send command to Unity
-        const result = await unityConnection.sendCommand('find_by_component', args);
+        const result = await unityConnection.sendCommand('analysis_component_find', args);
 
         // Handle Unity response
         if (result.status === 'error') {

package/src/tools/analysis/getAnimatorState.js

@@ -1,6 +1,6 @@
-// Tool definition for get_animator_state
+// Tool definition for analysis_animator_state_get
 export const getAnimatorStateToolDefinition = {
-    name: 'get_animator_state',
+    name: 'analysis_animator_state_get',
     description: 'Get Animator state: layers, transitions, and parameter values for a GameObject.',
     inputSchema: {
         type: 'object',
@@ -39,9 +39,9 @@ export const getAnimatorStateToolDefinition = {
     }
 };
 
-// Tool definition for get_animator_runtime_info
+// Tool definition for analysis_animator_runtime_info_get
 export const getAnimatorRuntimeInfoToolDefinition = {
-    name: 'get_animator_runtime_info',
+    name: 'analysis_animator_runtime_info_get',
     description: 'Get Animator runtime info (IK, root motion, performance) — Play mode only.',
     inputSchema: {
         type: 'object',
@@ -100,7 +100,7 @@ export async function getAnimatorStateHandler(unityConnection, args) {
         }
 
         // Send command to Unity
-        const result = await unityConnection.sendCommand('get_animator_state', args);
+        const result = await unityConnection.sendCommand('analysis_animator_state_get', args);
 
         // Check for errors
         if (!result || typeof result === 'string') {
@@ -222,7 +222,7 @@ export async function getAnimatorRuntimeInfoHandler(unityConnection, args) {
         }
 
         // Send command to Unity
-        const result = await unityConnection.sendCommand('get_animator_runtime_info', args);
+        const result = await unityConnection.sendCommand('analysis_animator_runtime_info_get', args);
 
         // Check for errors
         if (!result || typeof result === 'string') {

package/src/tools/analysis/getComponentValues.js

@@ -1,8 +1,8 @@
 /**
- * Tool definition for get_component_values
+ * Tool definition for analysis_component_values_get
  */
 export const getComponentValuesToolDefinition = {
-    name: 'get_component_values',
+    name: 'analysis_component_values_get',
     description: 'Get properties/values from a component on a GameObject (scene or prefab mode).',
     inputSchema: {
         type: 'object',
@@ -77,7 +77,7 @@ export async function getComponentValuesHandler(unityConnection, args) {
         }
 
         // Send command to Unity
-        const result = await unityConnection.sendCommand('get_component_values', args);
+        const result = await unityConnection.sendCommand('analysis_component_values_get', args);
 
         // The unityConnection.sendCommand already extracts the result field
         // from the response, so we access properties directly on result

package/src/tools/analysis/getGameObjectDetails.js

@@ -1,8 +1,8 @@
 /**
- * Tool definition for get_gameobject_details
+ * Tool definition for analysis_gameobject_details_get
  */
 export const getGameObjectDetailsToolDefinition = {
-    name: 'get_gameobject_details',
+    name: 'analysis_gameobject_details_get',
     description: 'Get details for a GameObject by name or path (children/components/materials).',
     inputSchema: {
         type: 'object',
@@ -106,7 +106,7 @@ export async function getGameObjectDetailsHandler(unityConnection, args) {
         if (args.maxDepth !== undefined) params.maxDepth = args.maxDepth;
 
         // Send command to Unity
-        const result = await unityConnection.sendCommand('get_gameobject_details', args);
+        const result = await unityConnection.sendCommand('analysis_gameobject_details_get', args);
 
         // The unityConnection.sendCommand already extracts the result field
         // from the response, so we access properties directly on result