@akiojin/unity-mcp-server 2.14.16 → 2.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.14.16",
+  "version": "2.16.0",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",

package/src/core/config.js

@@ -19,10 +19,26 @@ function merge(a, b) {
 /**
  * Base configuration for Unity Editor MCP Server
  */
+const envUnityHost =
+  process.env.UNITY_UNITY_HOST ||
+  process.env.UNITY_BIND_HOST ||
+  process.env.UNITY_HOST ||
+  null;
+
+const envMcpHost =
+  process.env.UNITY_MCP_HOST ||
+  process.env.UNITY_CLIENT_HOST ||
+  process.env.UNITY_HOST ||
+  null;
+
+const envBindHost = process.env.UNITY_BIND_HOST || null;
+
 const baseConfig = {
   // Unity connection settings
   unity: {
-    host: process.env.UNITY_HOST || 'localhost',
+    unityHost: envUnityHost,
+    mcpHost: envMcpHost,
+    bindHost: envBindHost,
     port: parseInt(process.env.UNITY_PORT || '', 10) || 6400,
     reconnectDelay: 1000,
     maxReconnectDelay: 30000,
@@ -118,6 +134,34 @@ function loadExternalConfig() {
 const external = loadExternalConfig();
 export const config = merge(baseConfig, external);
 
+const normalizeUnityConfig = () => {
+  const unityConfig = config.unity || (config.unity = {});
+
+  // Legacy aliases coming from config files or env vars
+  const legacyHost = unityConfig.host;
+  const legacyClientHost = unityConfig.clientHost;
+  const legacyBindHost = unityConfig.bindHost;
+
+  if (!unityConfig.unityHost) {
+    unityConfig.unityHost = legacyBindHost || legacyHost || envUnityHost || 'localhost';
+  }
+
+  if (!unityConfig.mcpHost) {
+    unityConfig.mcpHost = legacyClientHost || envMcpHost || legacyHost || unityConfig.unityHost;
+  }
+
+  // Keep bindHost for backwards compatibility with legacy code paths
+  if (!unityConfig.bindHost) {
+    unityConfig.bindHost = legacyBindHost || envBindHost || unityConfig.unityHost;
+  }
+
+  // Maintain legacy properties so older handlers keep working
+  unityConfig.host = unityConfig.unityHost;
+  unityConfig.clientHost = unityConfig.mcpHost;
+};
+
+normalizeUnityConfig();
+
 // Workspace root detection: directory that contains .unity/config.json used
 const initialCwd = process.cwd();
 let workspaceRoot = initialCwd;

package/src/core/unityConnection.js

@@ -40,7 +40,8 @@ export class UnityConnection extends EventEmitter {
         return;
       }
 
-      logger.info(`Connecting to Unity at ${config.unity.host}:${config.unity.port}...`);
+      const targetHost = config.unity.mcpHost || config.unity.unityHost;
+      logger.info(`Connecting to Unity at ${targetHost}:${config.unity.port}...`);
       
       this.socket = new net.Socket();
       let connectionTimeout = null;
@@ -118,7 +119,7 @@ export class UnityConnection extends EventEmitter {
       });
 
       // Attempt connection
-      this.socket.connect(config.unity.port, config.unity.host);
+      this.socket.connect(config.unity.port, targetHost);
       
       // Set timeout for initial connection
       connectionTimeout = setTimeout(() => {

package/src/handlers/base/BaseToolHandler.js

@@ -4,11 +4,81 @@
  */
 import { logger } from '../../core/config.js';
 
+function cloneSchema(schema) {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (typeof structuredClone === 'function') {
+    return structuredClone(schema);
+  }
+
+  try {
+    return JSON.parse(JSON.stringify(schema));
+  } catch {
+    return schema;
+  }
+}
+
+function sanitizeSchema(schema) {
+  if (!schema) {
+    return schema;
+  }
+
+  if (Array.isArray(schema)) {
+    schema.forEach(item => sanitizeSchema(item));
+    return schema;
+  }
+
+  if (typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (Array.isArray(schema.required) && schema.required.length === 0) {
+    delete schema.required;
+  }
+
+  if (schema.properties && typeof schema.properties === 'object') {
+    Object.values(schema.properties).forEach(value => sanitizeSchema(value));
+  }
+
+  if (schema.items) {
+    sanitizeSchema(schema.items);
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    schema.anyOf.forEach(branch => sanitizeSchema(branch));
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    schema.oneOf.forEach(branch => sanitizeSchema(branch));
+  }
+
+  if (Array.isArray(schema.allOf)) {
+    schema.allOf.forEach(branch => sanitizeSchema(branch));
+  }
+
+  if (schema.then) {
+    sanitizeSchema(schema.then);
+  }
+
+  if (schema.else) {
+    sanitizeSchema(schema.else);
+  }
+
+  if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+    sanitizeSchema(schema.additionalProperties);
+  }
+
+  return schema;
+}
+
 export class BaseToolHandler {
   constructor(name, description, inputSchema = {}) {
     this.name = name;
     this.description = description;
-    this.inputSchema = inputSchema;
+    const clonedSchema = cloneSchema(inputSchema) || {};
+    this.inputSchema = sanitizeSchema(clonedSchema);
   }
 
   /**

package/src/handlers/index.js

@@ -103,6 +103,10 @@ export { GetComponentTypesToolHandler } from './component/GetComponentTypesToolH
 // Compilation handlers
 export { GetCompilationStateToolHandler } from './compilation/GetCompilationStateToolHandler.js';
 
+// Test handlers
+export { RunTestsToolHandler } from './test/RunTestsToolHandler.js';
+export { GetTestStatusToolHandler } from './test/GetTestStatusToolHandler.js';
+
 // Editor control handlers
 export { TagManagementToolHandler } from './editor/TagManagementToolHandler.js';
 export { LayerManagementToolHandler } from './editor/LayerManagementToolHandler.js';
@@ -204,6 +208,8 @@ import { ModifyComponentToolHandler } from './component/ModifyComponentToolHandl
 import { ListComponentsToolHandler } from './component/ListComponentsToolHandler.js';
 import { GetComponentTypesToolHandler } from './component/GetComponentTypesToolHandler.js';
 import { GetCompilationStateToolHandler } from './compilation/GetCompilationStateToolHandler.js';
+import { RunTestsToolHandler } from './test/RunTestsToolHandler.js';
+import { GetTestStatusToolHandler } from './test/GetTestStatusToolHandler.js';
 import { TagManagementToolHandler } from './editor/TagManagementToolHandler.js';
 import { LayerManagementToolHandler } from './editor/LayerManagementToolHandler.js';
 import { SelectionToolHandler } from './editor/SelectionToolHandler.js';
@@ -341,7 +347,11 @@ const HANDLER_CLASSES = [
   
   // Compilation handlers
   GetCompilationStateToolHandler,
-  
+
+  // Test handlers
+  RunTestsToolHandler,
+  GetTestStatusToolHandler,
+
   // Editor control handlers
   TagManagementToolHandler,
   LayerManagementToolHandler,

package/src/handlers/test/GetTestStatusToolHandler.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 GetTestStatusToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'get_test_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/RunTestsToolHandler.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 RunTestsToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'run_tests',
+      '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/SetUIElementValueToolHandler.js

@@ -13,7 +13,15 @@ export class SetUIElementValueToolHandler extends BaseToolHandler {
                         description: 'Full hierarchy path to the UI element'
                     },
                     value: {
-                        description: 'New value to set (type depends on element type)'
+                        anyOf: [
+                            { type: 'string' },
+                            { type: 'number' },
+                            { type: 'boolean' },
+                            { type: 'object' },
+                            { type: 'array' },
+                            { type: 'null' }
+                        ],
+                        description: 'New value to set. Supports string, number, boolean, object, array, or null depending on the UI element type.'
                     },
                     triggerEvents: {
                         type: 'boolean',
@@ -46,4 +54,4 @@ export class SetUIElementValueToolHandler extends BaseToolHandler {
 
         return result;
     }
-}
+}