@akiojin/unity-mcp-server 2.33.0 → 2.37.1

package/src/handlers/input/InputTouchToolHandler.js

@@ -0,0 +1,178 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+const actionProperties = {
+  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',
+    description: 'Array of touch points for multi-touch',
+    items: {
+      type: 'object',
+      properties: {
+        x: { type: 'number' },
+        y: { type: 'number' },
+        phase: {
+          type: 'string',
+          enum: ['began', 'moved', 'stationary', 'ended']
+        }
+      },
+      required: ['x', 'y']
+    }
+  }
+};
+
+function validateTouchAction(params, context = 'action') {
+  if (!params || typeof params !== 'object') {
+    throw new Error(`${context} must be an object`);
+  }
+
+  const { action, x, y, startX, startY, endX, endY, touches } = params;
+
+  if (!action) {
+    throw new Error(`${context}: action is required`);
+  }
+
+  switch (action) {
+    case 'tap':
+      if (x === undefined || y === undefined) {
+        throw new Error(`${context}: x and y coordinates are required for tap action`);
+      }
+      break;
+    case 'swipe':
+      if (
+        startX === undefined ||
+        startY === undefined ||
+        endX === undefined ||
+        endY === undefined
+      ) {
+        throw new Error(`${context}: startX, startY, endX, and endY are required for swipe action`);
+      }
+      break;
+    case 'pinch':
+      // Optional parameters with defaults handled downstream
+      break;
+    case 'multi':
+      if (!touches || !Array.isArray(touches) || touches.length === 0) {
+        throw new Error(`${context}: touches array is required for multi action`);
+      }
+      if (touches.length > 10) {
+        throw new Error(`${context}: maximum 10 simultaneous touches supported`);
+      }
+      touches.forEach((touch, i) => {
+        if (touch.x === undefined || touch.y === undefined) {
+          throw new Error(`${context}: touches[${i}] must include x and y`);
+        }
+      });
+      break;
+    default:
+      throw new Error(`${context}: invalid action ${action}`);
+  }
+}
+
+/**
+ * Handler for the input_touch tool
+ */
+export class InputTouchToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super('input_touch', 'Touch input (tap/swipe/pinch/multi) with batching.', {
+      type: 'object',
+      properties: {
+        ...actionProperties,
+        actions: {
+          type: 'array',
+          description: 'Batch multiple touch 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) => validateTouchAction(action, `actions[${index}]`));
+      return;
+    }
+
+    if (actions !== undefined && !Array.isArray(actions)) {
+      throw new Error('actions must be an array');
+    }
+
+    validateTouchAction(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_touch', payload);
+    return result;
+  }
+}

package/src/handlers/playmode/PlaymodePlayToolHandler.js

@@ -1,19 +1,16 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import { extractEditorState } from '../../utils/editorState.js';
 
 /**
  * Handler for the playmode_play tool
  */
 export class PlaymodePlayToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super(
-      'playmode_play',
-      'Enter Play Mode.',
-      {
-        type: 'object',
-        properties: {},
-        required: []
-      }
-    );
+    super('playmode_play', 'Enter Play Mode.', {
+      type: 'object',
+      properties: {},
+      required: []
+    });
     this.unityConnection = unityConnection;
   }
 
@@ -23,11 +20,14 @@ export class PlaymodePlayToolHandler extends BaseToolHandler {
    * @returns {Promise<object>} Play mode state
    */
   async execute(params) {
-    const initialDelayMs = typeof params?.initialDelayMs === 'number' ? params.initialDelayMs : 3000;
-    const reconnectIntervalMs = typeof params?.reconnectIntervalMs === 'number' ? params.reconnectIntervalMs : 500;
+    const initialDelayMs =
+      typeof params?.initialDelayMs === 'number' ? params.initialDelayMs : 3000;
+    const reconnectIntervalMs =
+      typeof params?.reconnectIntervalMs === 'number' ? params.reconnectIntervalMs : 500;
     const pollIntervalMs = typeof params?.pollIntervalMs === 'number' ? params.pollIntervalMs : 800;
     const maxWaitMs = typeof params?.maxWaitMs === 'number' ? params.maxWaitMs : null; // null = unlimited
 
+    let lastPlayMessage = 'Entered play mode';
     try {
       if (!this.unityConnection.isConnected()) {
         await this.unityConnection.connect();
@@ -38,31 +38,37 @@ export class PlaymodePlayToolHandler extends BaseToolHandler {
         error.code = 'UNITY_ERROR';
         throw error;
       }
+      lastPlayMessage = result?.message || lastPlayMessage;
       const startOk = Date.now();
       for (;;) {
         try {
-          const state = await this.unityConnection.sendCommand('playmode_get_state', {});
-          if (state && state.isPlaying) {
-            return { status: 'success', message: 'Entered play mode', state };
+          const state = await this.unityConnection.sendCommand('get_editor_state', {});
+          const editorState = extractEditorState(state);
+          if (editorState?.isPlaying) {
+            return { status: 'success', message: lastPlayMessage, state: editorState };
           }
         } catch {}
-        await sleep(pollIntervalMs);
+        await sleep(Math.max(0, pollIntervalMs));
         if (maxWaitMs != null && Date.now() - startOk > maxWaitMs) {
           return result;
         }
       }
     } catch (err) {
       const msg = err?.message || '';
-      const transient = /(Connection closed|timeout|ECONNRESET|EPIPE|socket|Not connected)/i.test(msg);
+      const transient = /(Connection closed|timeout|ECONNRESET|EPIPE|socket|Not connected)/i.test(
+        msg
+      );
       if (!transient) throw err;
 
       const start = Date.now();
-      await sleep(initialDelayMs);
+      await sleep(Math.max(0, initialDelayMs));
       // Reconnect until connected (unlimited unless maxWaitMs specified)
       for (;;) {
         if (this.unityConnection.isConnected()) break;
-        try { await this.unityConnection.connect(); } catch {}
-        await sleep(reconnectIntervalMs);
+        try {
+          await this.unityConnection.connect();
+        } catch {}
+        await sleep(Math.max(0, reconnectIntervalMs));
         if (maxWaitMs != null && Date.now() - start > maxWaitMs) {
           const e = new Error('Timed out waiting to reconnect after Play start');
           e.code = 'RECONNECT_TIMEOUT';
@@ -73,11 +79,16 @@ export class PlaymodePlayToolHandler extends BaseToolHandler {
       for (;;) {
         try {
           const state = await this.unityConnection.sendCommand('get_editor_state', {});
-          if (state && state.isPlaying) {
-            return { status: 'success', message: 'Entered play mode (reconnected after reload)', state };
+          const editorState = extractEditorState(state);
+          if (editorState?.isPlaying) {
+            return {
+              status: 'success',
+              message: `${lastPlayMessage} (reconnected after reload)`,
+              state: editorState
+            };
           }
         } catch {}
-        await sleep(pollIntervalMs);
+        await sleep(Math.max(0, pollIntervalMs));
         if (maxWaitMs != null && Date.now() - start > maxWaitMs) {
           const e = new Error('Timed out waiting for Play mode after reconnect');
           e.code = 'PLAY_WAIT_TIMEOUT';
@@ -88,4 +99,6 @@ export class PlaymodePlayToolHandler extends BaseToolHandler {
   }
 }
 
-function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, Math.max(0, ms || 0)));
+}

package/src/handlers/playmode/PlaymodeStopToolHandler.js

@@ -1,19 +1,16 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import { extractEditorState } from '../../utils/editorState.js';
 
 /**
  * Handler for the playmode_stop tool
  */
 export class PlaymodeStopToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super(
-      'playmode_stop',
-      'Exit Play Mode and return to Edit Mode.',
-      {
-        type: 'object',
-        properties: {},
-        required: []
-      }
-    );
+    super('playmode_stop', 'Exit Play Mode and return to Edit Mode.', {
+      type: 'object',
+      properties: {},
+      required: []
+    });
     this.unityConnection = unityConnection;
   }
 
@@ -23,7 +20,8 @@ export class PlaymodeStopToolHandler extends BaseToolHandler {
    * @returns {Promise<object>} Play mode state
    */
   async execute(params) {
-    const reconnectIntervalMs = typeof params?.reconnectIntervalMs === 'number' ? params.reconnectIntervalMs : 500;
+    const reconnectIntervalMs =
+      typeof params?.reconnectIntervalMs === 'number' ? params.reconnectIntervalMs : 500;
     const pollIntervalMs = typeof params?.pollIntervalMs === 'number' ? params.pollIntervalMs : 500;
     const maxWaitMs = typeof params?.maxWaitMs === 'number' ? params.maxWaitMs : null; // null = unlimited
 
@@ -37,33 +35,44 @@ export class PlaymodeStopToolHandler extends BaseToolHandler {
         error.code = 'UNITY_ERROR';
         throw error;
       }
+      const message = result?.message || 'Exited play mode';
       const startOk = Date.now();
       for (;;) {
         try {
-          const state = await this.unityConnection.sendCommand('playmode_get_state', {});
-          if (state && !state.isPlaying) {
-            return { status: 'success', message: 'Exited play mode', state };
+          const state = await this.unityConnection.sendCommand('get_editor_state', {});
+          const editorState = extractEditorState(state);
+          if (editorState && !editorState.isPlaying) {
+            return { status: 'success', message, state: editorState };
           }
         } catch {}
-        await sleep(pollIntervalMs);
+        await sleep(Math.max(0, pollIntervalMs));
         if (maxWaitMs != null && Date.now() - startOk > maxWaitMs) return result;
       }
     } catch (err) {
-      const transient = /(Connection closed|timeout|ECONNRESET|EPIPE|socket|Not connected)/i.test(err?.message || '');
+      const transient = /(Connection closed|timeout|ECONNRESET|EPIPE|socket|Not connected)/i.test(
+        err?.message || ''
+      );
       if (!transient) throw err;
       const start = Date.now();
       for (;;) {
         if (!this.unityConnection.isConnected()) {
-          try { await this.unityConnection.connect(); } catch {}
-          await sleep(reconnectIntervalMs);
+          try {
+            await this.unityConnection.connect();
+          } catch {}
+          await sleep(Math.max(0, reconnectIntervalMs));
         }
         try {
           const state = await this.unityConnection.sendCommand('get_editor_state', {});
-          if (state && !state.isPlaying) {
-            return { status: 'success', message: 'Exited play mode (reconnected after reload)', state };
+          const editorState = extractEditorState(state);
+          if (editorState && !editorState.isPlaying) {
+            return {
+              status: 'success',
+              message: 'Exited play mode (reconnected after reload)',
+              state: editorState
+            };
           }
         } catch {}
-        await sleep(pollIntervalMs);
+        await sleep(Math.max(0, pollIntervalMs));
         if (maxWaitMs != null && Date.now() - start > maxWaitMs) {
           const e = new Error('Timed out waiting for stop');
           e.code = 'PLAY_WAIT_TIMEOUT';
@@ -74,4 +83,6 @@ export class PlaymodeStopToolHandler extends BaseToolHandler {
   }
 }
 
-function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, Math.max(0, ms || 0)));
+}

package/src/handlers/test/TestGetStatusToolHandler.js

@@ -1,4 +1,5 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import * as testResultsCache from '../../utils/testResultsCache.js';
 
 /**
  * Handler for getting Unity test execution status
@@ -6,16 +7,24 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export class TestGetStatusToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super(
-      'test_get_status',
-      'Get current Unity test execution status and results',
-      {
-        type: 'object',
-        properties: {}
+    super('test_get_status', 'Get current Unity test execution status and results', {
+      type: 'object',
+      properties: {
+        includeTestResults: {
+          type: 'boolean',
+          default: false,
+          description: 'Include the summary of the latest exported test results'
+        },
+        includeFileContent: {
+          type: 'boolean',
+          default: false,
+          description: 'When includeTestResults is true, also include the JSON file contents'
+        }
       }
-    );
+    });
 
     this.unityConnection = unityConnection;
+    this.testResultsCache = testResultsCache;
   }
 
   /**
@@ -30,7 +39,7 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
     }
 
     // Send command to Unity
-    const response = await this.unityConnection.sendCommand('get_test_status', params);
+    const response = await this.unityConnection.sendCommand('get_test_status', params || {});
 
     // Handle Unity response
     if (response.error) {
@@ -38,10 +47,15 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
     }
 
     // Return status directly if still running or idle
-    if (response.status === 'running' || response.status === 'idle') {
+    if (response.status === 'running') {
       return response;
     }
 
+    if (response.status === 'idle') {
+      const cached = await this.testResultsCache.loadCachedTestResults();
+      return cached || response;
+    }
+
     // Format completed results
     if (response.status === 'completed') {
       const result = {
@@ -57,7 +71,14 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
         tests: response.tests || []
       };
 
-      return result;
+      if (response.latestResult) {
+        result.latestResult = response.latestResult;
+      }
+
+      const artifactPath = await this.testResultsCache.persistTestResults(result);
+      const cachedResult = await this.testResultsCache.loadCachedTestResults(artifactPath);
+
+      return cachedResult || result;
     }
 
     // Error status
@@ -73,6 +94,12 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
       checkStatus: {
         description: 'Check current test execution status',
         params: {}
+      },
+      checkWithResults: {
+        description: 'Check status and include last exported test results summary',
+        params: {
+          includeTestResults: true
+        }
       }
     };
   }

package/src/handlers/test/TestRunToolHandler.js

@@ -1,4 +1,5 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
+import { resetTestResultsCache } from '../../utils/testResultsCache.js';
 
 /**
  * Handler for running Unity NUnit tests via Test Runner API
@@ -6,42 +7,39 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 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'
-          }
+    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;
   }
@@ -57,6 +55,8 @@ export class TestRunToolHandler extends BaseToolHandler {
       await this.unityConnection.connect();
     }
 
+    await resetTestResultsCache();
+
     // Send command to Unity
     const response = await this.unityConnection.sendCommand('run_tests', params);
 
@@ -69,7 +69,8 @@ export class TestRunToolHandler extends BaseToolHandler {
     if (response.status === 'running') {
       return {
         status: 'running',
-        message: response.message || 'Test execution started. Use get_test_status to check progress.'
+        message:
+          response.message || 'Test execution started. Use get_test_status to check progress.'
       };
     }
 

package/src/lsp/LspProcessManager.js

@@ -2,44 +2,50 @@ import { spawn } from 'child_process';
 import { logger } from '../core/config.js';
 import { CSharpLspUtils } from './CSharpLspUtils.js';
 
+const sharedState = {
+  proc: null,
+  starting: null
+};
+
 export class LspProcessManager {
   constructor() {
-    this.proc = null;
-    this.starting = null;
+    this.state = sharedState;
     this.utils = new CSharpLspUtils();
   }
 
   async ensureStarted() {
-    if (this.proc && !this.proc.killed) return this.proc;
-    if (this.starting) return this.starting;
-    this.starting = (async () => {
+    if (this.state.proc && !this.state.proc.killed) return this.state.proc;
+    if (this.state.starting) return this.state.starting;
+    this.state.starting = (async () => {
       const rid = this.utils.detectRid();
       const bin = await this.utils.ensureLocal(rid);
       const proc = spawn(bin, { stdio: ['pipe', 'pipe', 'pipe'] });
       proc.on('error', e => logger.error(`[csharp-lsp] process error: ${e.message}`));
       proc.on('close', (code, sig) => {
         logger.warn(`[csharp-lsp] exited code=${code} signal=${sig || ''}`);
-        this.proc = null;
+        if (this.state.proc === proc) {
+          this.state.proc = null;
+        }
       });
       proc.stderr.on('data', d => {
         const s = String(d || '').trim();
         if (s) logger.debug(`[csharp-lsp] ${s}`);
       });
-      this.proc = proc;
+      this.state.proc = proc;
       logger.info(`[csharp-lsp] started (pid=${proc.pid})`);
       return proc;
     })();
     try {
-      return await this.starting;
+      return await this.state.starting;
     } finally {
-      this.starting = null;
+      this.state.starting = null;
     }
   }
 
   async stop(graceMs = 3000) {
-    if (!this.proc || this.proc.killed) return;
-    const p = this.proc;
-    this.proc = null;
+    if (!this.state.proc || this.state.proc.killed) return;
+    const p = this.state.proc;
+    this.state.proc = null;
     try {
       // Send LSP shutdown/exit if possible
       const shutdown = obj => {