@akiojin/unity-mcp-server 2.37.2 → 2.38.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.37.2",
+  "version": "2.38.1",
   "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

@@ -17,6 +17,32 @@ function merge(a, b) {
   return out;
 }
 
+function resolvePackageVersion() {
+  const candidates = [];
+
+  // Resolve relative to this module (always inside mcp-server/src/core)
+  try {
+    const moduleDir = path.dirname(new URL(import.meta.url).pathname);
+    candidates.push(path.resolve(moduleDir, '../../package.json'));
+  } catch {}
+
+  // When executed from workspace root (monorepo) or inside mcp-server package
+  try {
+    const here = findUpSync('package.json', { cwd: process.cwd() });
+    if (here) candidates.push(here);
+  } catch {}
+
+  for (const candidate of candidates) {
+    try {
+      if (!candidate || !fs.existsSync(candidate)) continue;
+      const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+      if (pkg?.version) return pkg.version;
+    } catch {}
+  }
+
+  return '0.1.0';
+}
+
 /**
  * Base configuration for Unity MCP Server Server
  */
@@ -44,7 +70,7 @@ const baseConfig = {
   // Server settings
   server: {
     name: 'unity-mcp-server',
-    version: '0.1.0',
+    version: resolvePackageVersion(),
     description: 'MCP server for Unity Editor integration'
   },
 

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/lsp/CSharpLspUtils.js

@@ -134,17 +134,38 @@ export class CSharpLspUtils {
     if (!desired) throw new Error('mcp-server version not found; cannot resolve LSP tag');
     const current = this.readLocalVersion(rid);
     if (fs.existsSync(p) && current === desired) return p;
-    await this.autoDownload(rid, desired);
+    const resolved = await this.autoDownload(rid, desired);
     if (!fs.existsSync(p)) throw new Error('csharp-lsp binary not found after download');
-    this.writeLocalVersion(rid, desired);
+    this.writeLocalVersion(rid, resolved || desired);
     return p;
   }
 
   async autoDownload(rid, version) {
     const repo = process.env.GITHUB_REPOSITORY || 'akiojin/unity-mcp-server';
-    const tag = `v${version}`;
-    const manifestUrl = `https://github.com/${repo}/releases/download/${tag}/csharp-lsp-manifest.json`;
-    const manifest = await this.fetchJson(manifestUrl);
+
+    const fetchManifest = async ver => {
+      const tag = `v${ver}`;
+      const manifestUrl = `https://github.com/${repo}/releases/download/${tag}/csharp-lsp-manifest.json`;
+      const manifest = await this.fetchJson(manifestUrl);
+      return { manifest, tag };
+    };
+
+    let targetVersion = version;
+    let manifest;
+    try {
+      ({ manifest } = await fetchManifest(targetVersion));
+    } catch (e) {
+      // Gracefully fall back to the latest release when the requested manifest is missing (404).
+      if (String(e?.message || '').includes('HTTP 404')) {
+        const latest = await this.fetchLatestReleaseVersion(repo);
+        if (!latest) throw e;
+        targetVersion = latest;
+        ({ manifest } = await fetchManifest(targetVersion));
+      } else {
+        throw e;
+      }
+    }
+
     const entry = manifest?.assets?.[rid];
     if (!entry?.url || !entry?.sha256) throw new Error(`manifest missing entry for ${rid}`);
 
@@ -154,17 +175,35 @@ export class CSharpLspUtils {
     await this.downloadTo(entry.url, tmp);
     const actual = await this.sha256File(tmp);
     if (String(actual).toLowerCase() !== String(entry.sha256).toLowerCase()) {
-      try { fs.unlinkSync(tmp); } catch {}
+      try {
+        fs.unlinkSync(tmp);
+      } catch {}
       throw new Error('checksum mismatch for csharp-lsp asset');
     }
     // atomic replace
-    try { fs.renameSync(tmp, dest); } catch (e) {
+    try {
+      fs.renameSync(tmp, dest);
+    } catch (e) {
       // Windows may need removal before rename
-      try { fs.unlinkSync(dest); } catch {}
+      try {
+        fs.unlinkSync(dest);
+      } catch {}
       fs.renameSync(tmp, dest);
     }
-    try { if (process.platform !== 'win32') fs.chmodSync(dest, 0o755); } catch {}
+    try {
+      if (process.platform !== 'win32') fs.chmodSync(dest, 0o755);
+    } catch {}
     logger.info(`[csharp-lsp] downloaded: ${path.basename(dest)} @ ${path.dirname(dest)}`);
+    return targetVersion;
+  }
+
+  async fetchLatestReleaseVersion(repo) {
+    const url = `https://api.github.com/repos/${repo}/releases/latest`;
+    const json = await this.fetchJson(url);
+    const tag = json?.tag_name || '';
+    const version = tag.replace(/^v/, '');
+    if (!version) throw new Error('latest release version not found');
+    return version;
   }
 
   async fetchJson(url) {

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}`);
+  }
+}