@akiojin/unity-mcp-server 2.37.2 → 2.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.37.2",
+  "version": "2.38.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/handlers/console/ConsoleReadToolHandler.js

@@ -11,6 +11,11 @@ export class ConsoleReadToolHandler extends BaseToolHandler {
       {
         type: 'object',
         properties: {
+          raw: {
+            type: 'boolean',
+            description:
+              'When true, do not expand/validate logTypes and pass them directly to Unity. Use with caution.'
+          },
           count: {
             type: 'number',
             description: 'Number of logs to retrieve (1-1000, default: 100)',
@@ -19,10 +24,11 @@ export class ConsoleReadToolHandler extends BaseToolHandler {
           },
           logTypes: {
             type: 'array',
-            description: 'Filter by log types (default: ["All"])',
+            description:
+              'Filter by log types. Allowed: Log, Warning, Error. Error expands to include Exception/Assert internally. Default: all three.',
             items: {
               type: 'string',
-              enum: ['Info', 'Warning', 'Error', 'All']
+              enum: ['Log', 'Warning', 'Error']
             }
           },
           filterText: {
@@ -88,11 +94,10 @@ export class ConsoleReadToolHandler extends BaseToolHandler {
         throw new Error('logTypes must be an array');
       }
 
-      const validTypes = ['Info', 'Warning', 'Error', 'All'];
+      const validTypes = ['Log', 'Warning', 'Error'];
       for (const type of logTypes) {
         if (!validTypes.includes(type)) {
-          // Invalid types are treated as 'All' later, so just log a warning
-          console.warn(`Invalid log type: ${type}. Will be treated as 'All'.`);
+          throw new Error(`logTypes must be one of: ${validTypes.join(', ')}`);
         }
       }
     }
@@ -177,34 +182,31 @@ export class ConsoleReadToolHandler extends BaseToolHandler {
       groupBy
     } = params;
 
-    // Convert simplified log types to Unity log types
+    // Allowed: Log / Warning / Error. Error expands to include Exception/Assert.
     let expandedLogTypes = [];
-
-    if (!logTypes || logTypes.length === 0 || logTypes.includes('All')) {
-      // Default to all types
+    if (!logTypes || logTypes.length === 0) {
       expandedLogTypes = ['Log', 'Warning', 'Error', 'Exception', 'Assert'];
     } else {
-      // Expand each simplified type to Unity types
       logTypes.forEach(type => {
         switch (type) {
-          case 'Info':
+          case 'Log':
             expandedLogTypes.push('Log');
             break;
           case 'Warning':
             expandedLogTypes.push('Warning');
             break;
           case 'Error':
-            // Error includes all error-related types
             expandedLogTypes.push('Error', 'Exception', 'Assert');
             break;
-          case 'All':
-            expandedLogTypes.push('Log', 'Warning', 'Error', 'Exception', 'Assert');
+          default:
+            // ignore (validate already enforces)
             break;
         }
       });
-
-      // Remove duplicates
       expandedLogTypes = [...new Set(expandedLogTypes)];
+      if (expandedLogTypes.length === 0) {
+        expandedLogTypes = ['Log', 'Warning', 'Error', 'Exception', 'Assert'];
+      }
     }
 
     // Ensure connection to Unity

package/src/handlers/editor/EditorQuitToolHandler.js

@@ -0,0 +1,26 @@
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+/**
+ * Handler to quit Unity Editor safely.
+ */
+export class EditorQuitToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super('editor_quit', 'Quit Unity Editor', {
+      type: 'object',
+      properties: {}
+    });
+
+    this.unityConnection = unityConnection;
+  }
+
+  async execute() {
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
+    }
+    const response = await this.unityConnection.sendCommand('quit_editor', {});
+    if (response.error) {
+      throw new Error(response.error);
+    }
+    return response;
+  }
+}

package/src/handlers/index.js

@@ -94,6 +94,7 @@ import { EditorLayersManageToolHandler } from './editor/EditorLayersManageToolHa
 import { EditorSelectionManageToolHandler } from './editor/EditorSelectionManageToolHandler.js';
 import { EditorWindowsManageToolHandler } from './editor/EditorWindowsManageToolHandler.js';
 import { EditorToolsManageToolHandler } from './editor/EditorToolsManageToolHandler.js';
+import { EditorQuitToolHandler } from './editor/EditorQuitToolHandler.js';
 import { SettingsGetToolHandler } from './settings/SettingsGetToolHandler.js';
 import { SettingsUpdateToolHandler } from './settings/SettingsUpdateToolHandler.js';
 import PackageManagerToolHandler from './package/PackageManagerToolHandler.js';
@@ -392,6 +393,7 @@ const HANDLER_CLASSES = [
   EditorSelectionManageToolHandler,
   EditorWindowsManageToolHandler,
   EditorToolsManageToolHandler,
+  EditorQuitToolHandler,
 
   // Settings handlers
   SettingsGetToolHandler,

package/src/handlers/test/TestGetStatusToolHandler.js

@@ -1,5 +1,6 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import * as testResultsCache from '../../utils/testResultsCache.js';
+import * as testRunState from '../../utils/testRunState.js';
 
 /**
  * Handler for getting Unity test execution status
@@ -33,13 +34,32 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
    * @returns {Promise<Object>} Test execution status and results
    */
   async execute(params) {
-    // Ensure connection to Unity
-    if (!this.unityConnection.isConnected()) {
-      await this.unityConnection.connect();
-    }
+    let response;
+    try {
+      // 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 || {});
+      // Send command to Unity
+      response = await this.unityConnection.sendCommand('get_test_status', params || {});
+    } catch (error) {
+      // 一度リトライしてみる（ドメインリロード直後を考慮）
+      try {
+        await this.unityConnection.connect();
+        response = await this.unityConnection.sendCommand('get_test_status', params || {});
+      } catch (retryError) {
+        // Connection or transport error persists: fall back to cached run state so callers
+        // can still distinguish "テスト起因のPlayMode" かどうか。
+        const cached = testRunState.getState();
+        return {
+          ...cached,
+          status: cached.status || 'error',
+          error: retryError.message,
+          connectionState: 'disconnected'
+        };
+      }
+    }
 
     // Handle Unity response
     if (response.error) {
@@ -48,12 +68,14 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
 
     // Return status directly if still running or idle
     if (response.status === 'running') {
-      return response;
+      const merged = { ...testRunState.updateFromStatus(response), ...response };
+      return merged;
     }
 
     if (response.status === 'idle') {
+      testRunState.markIdle();
       const cached = await this.testResultsCache.loadCachedTestResults();
-      return cached || response;
+      return cached || testRunState.getState() || response;
     }
 
     // Format completed results
@@ -68,13 +90,16 @@ export class TestGetStatusToolHandler extends BaseToolHandler {
         inconclusiveTests: response.inconclusiveTests,
         summary: `${response.passedTests}/${response.totalTests} tests passed`,
         failures: response.failures || [],
-        tests: response.tests || []
+        tests: response.tests || [],
+        testMode: response.testMode || testRunState.getState().testMode,
+        runId: testRunState.getState().runId
       };
 
       if (response.latestResult) {
         result.latestResult = response.latestResult;
       }
 
+      testRunState.updateFromStatus({ ...result, status: 'completed' });
       const artifactPath = await this.testResultsCache.persistTestResults(result);
       const cachedResult = await this.testResultsCache.loadCachedTestResults(artifactPath);
 

package/src/handlers/test/TestRunToolHandler.js

@@ -1,5 +1,6 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import { resetTestResultsCache } from '../../utils/testResultsCache.js';
+import * as testRunState from '../../utils/testRunState.js';
 
 /**
  * Handler for running Unity NUnit tests via Test Runner API
@@ -67,10 +68,14 @@ export class TestRunToolHandler extends BaseToolHandler {
 
     // Handle new non-blocking response format (status: "running")
     if (response.status === 'running') {
+      const runState = testRunState.startRun(response.testMode || params.testMode, response.runId);
       return {
         status: 'running',
         message:
-          response.message || 'Test execution started. Use get_test_status to check progress.'
+          response.message || 'Test execution started. Use get_test_status to check progress.',
+        testMode: runState.testMode || response.testMode,
+        runId: runState.runId || response.runId,
+        startedAt: runState.startedAt
       };
     }
 

package/src/utils/testRunState.js

@@ -0,0 +1,90 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { WORKSPACE_ROOT, logger } from '../core/config.js';
+
+// Simple in-memory state for the latest test run.
+// Persisting is unnecessary for the current use case because the Node process
+// stays alive across Unity domain reloads, which is where we lose connection.
+const state = {
+  status: 'idle', // idle | running | completed | error
+  runId: null,
+  testMode: null,
+  startedAt: null,
+  completedAt: null,
+  lastUpdate: null
+};
+
+const workspaceUnityRoot = path.join(WORKSPACE_ROOT || process.cwd(), '.unity');
+const runStatePath = path.join(workspaceUnityRoot, 'tests', 'test-run-state.json');
+
+// Load persisted state once at module load
+await (async () => {
+  try {
+    const data = await fs.readFile(runStatePath, 'utf8');
+    const parsed = JSON.parse(data);
+    Object.assign(state, parsed);
+    logger.info(`[testRunState] Loaded persisted state from ${runStatePath}`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      logger.warn(`[testRunState] Failed to load state from ${runStatePath}: ${error.message}`);
+    }
+  }
+})();
+
+export function startRun(testMode, runId) {
+  const now = new Date().toISOString();
+  state.status = 'running';
+  state.runId = runId || crypto.randomUUID();
+  state.testMode = testMode || state.testMode;
+  state.startedAt = now;
+  state.completedAt = null;
+  state.lastUpdate = now;
+  persist();
+  return { ...state };
+}
+
+export function updateFromStatus(response) {
+  const now = new Date().toISOString();
+  if (response?.status) {
+    state.status = response.status;
+  }
+  if (response?.testMode) {
+    state.testMode = response.testMode;
+  }
+  if (response?.runId) {
+    state.runId = response.runId;
+  }
+  state.lastUpdate = now;
+
+  if (response?.status === 'completed') {
+    state.completedAt = now;
+  }
+  if (response?.status === 'idle') {
+    state.runId = null;
+    state.testMode = null;
+    state.startedAt = null;
+    state.completedAt = null;
+  }
+  persist();
+  return { ...state };
+}
+
+export function markIdle() {
+  const res = updateFromStatus({ status: 'idle' });
+  return res;
+}
+
+export function getState() {
+  return { ...state };
+}
+
+async function persist() {
+  try {
+    const dir = path.dirname(runStatePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(runStatePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  } catch (error) {
+    logger.warn(`[testRunState] Failed to persist state to ${runStatePath}: ${error.message}`);
+  }
+}