@akiojin/unity-mcp-server 4.1.5 → 4.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "4.1.5",
+  "version": "4.2.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/handlers/addressables/AddressablesAnalyzeToolHandler.js

@@ -7,7 +7,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 export default class AddressablesAnalyzeToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'addressables_analyze',
+      'analyze_addressables',
       'Analyze Unity Addressables for duplicates, dependencies, and unused assets',
       {
         type: 'object',
@@ -68,7 +68,7 @@ export default class AddressablesAnalyzeToolHandler extends BaseToolHandler {
       await this.unityConnection.connect();
     }
 
-    const result = await this.unityConnection.sendCommand('addressables_analyze', {
+    const result = await this.unityConnection.sendCommand('analyze_addressables', {
       action,
       ...parameters
     });

package/src/handlers/addressables/AddressablesBuildToolHandler.js

@@ -6,7 +6,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export default class AddressablesBuildToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('addressables_build', 'Build Unity Addressables content or clean build cache', {
+    super('build_addressables', 'Build Unity Addressables content or clean build cache', {
       type: 'object',
       properties: {
         action: {
@@ -75,7 +75,7 @@ export default class AddressablesBuildToolHandler extends BaseToolHandler {
     const timeout = 300000; // 5 minutes
 
     const result = await this.unityConnection.sendCommand(
-      'addressables_build',
+      'build_addressables',
       {
         action,
         ...parameters

package/src/handlers/addressables/AddressablesManageToolHandler.js

@@ -7,7 +7,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 export default class AddressablesManageToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'addressables_manage',
+      'manage_addressables',
       'Manage Unity Addressables assets and groups - add, remove, organize entries and groups',
       {
         type: 'object',
@@ -141,7 +141,7 @@ export default class AddressablesManageToolHandler extends BaseToolHandler {
       await this.unityConnection.connect();
     }
 
-    const result = await this.unityConnection.sendCommand('addressables_manage', {
+    const result = await this.unityConnection.sendCommand('manage_addressables', {
       action,
       ...parameters
     });

package/src/handlers/input/InputSystemControlToolHandler.js

@@ -5,7 +5,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export class InputSystemControlToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('input_system_control', 'Main handler for Input System operations', {
+    super('control_input_system', 'Main handler for Input System operations', {
       type: 'object',
       properties: {
         operation: {

package/src/handlers/input/InputTouchToolHandler.js

@@ -127,7 +127,7 @@ function validateTouchAction(params, context = 'action') {
  */
 export class InputTouchToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('input_touch', 'Touch input (tap/swipe/pinch/multi) with batching.', {
+    super('simulate_touch', 'Touch input (tap/swipe/pinch/multi) with batching.', {
       type: 'object',
       properties: {
         ...actionProperties,
@@ -181,7 +181,7 @@ export class InputTouchToolHandler extends BaseToolHandler {
     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);
+    const result = await this.unityConnection.sendCommand('simulate_touch', payload);
     return result;
   }
 }

package/src/handlers/package/PackageManagerToolHandler.js

@@ -7,7 +7,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export default class PackageManagerToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('package_manager', 'Manage Unity packages - search, install, remove, and list packages', {
+    super('manage_packages', 'Manage Unity packages - search, install, remove, and list packages', {
       type: 'object',
       properties: {
         action: {
@@ -84,7 +84,7 @@ export default class PackageManagerToolHandler extends BaseToolHandler {
       await this.unityConnection.connect();
     }
 
-    const result = await this.unityConnection.sendCommand('package_managerr', {
+    const result = await this.unityConnection.sendCommand('manage_packages', {
       action,
       ...parameters
     });

package/src/handlers/script/ScriptEditSnippetToolHandler.js

@@ -4,6 +4,7 @@ import crypto from 'crypto';
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import { ProjectInfoProvider } from '../../core/projectInfo.js';
 import { LspRpcClientSingleton } from '../../lsp/LspRpcClientSingleton.js';
+import { preSyntaxCheck } from './csharpSyntaxCheck.js';
 
 const MAX_INSTRUCTIONS = 10;
 const MAX_DIFF_CHARS = 80;
@@ -125,6 +126,12 @@ export class ScriptEditSnippetToolHandler extends BaseToolHandler {
       throw e;
     }
 
+    // Pre-syntax check: fail fast if file has obvious syntax errors
+    const syntaxCheck = preSyntaxCheck(original, relative);
+    if (!syntaxCheck.valid) {
+      throw new Error(`${syntaxCheck.error}. ${syntaxCheck.recoveryHint || ''}`);
+    }
+
     let working = original;
     const results = [];
     for (let i = 0; i < instructions.length; i++) {
@@ -138,6 +145,15 @@ export class ScriptEditSnippetToolHandler extends BaseToolHandler {
       return this.#buildResponse({ preview, results, original, updated: working });
     }
 
+    // Pre-syntax check on edited content before LSP validation
+    const editedSyntaxCheck = preSyntaxCheck(working, relative);
+    if (!editedSyntaxCheck.valid) {
+      throw new Error(
+        `Edit would introduce syntax error: ${editedSyntaxCheck.error}. ` +
+          'Check your edit instructions for balanced braces/brackets.'
+      );
+    }
+
     const diagnostics = await this.#validateWithLsp(info, relative, working);
     const hasErrors = diagnostics.some(d => this.#severityIsError(d.severity));
     if (hasErrors) {

package/src/handlers/script/ScriptEditStructuredToolHandler.js

@@ -1,6 +1,9 @@
+import fs from 'fs/promises';
+import path from 'path';
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import { LspRpcClientSingleton } from '../../lsp/LspRpcClientSingleton.js';
 import { ProjectInfoProvider } from '../../core/projectInfo.js';
+import { preSyntaxCheck } from './csharpSyntaxCheck.js';
 
 export class ScriptEditStructuredToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
@@ -91,6 +94,22 @@ export class ScriptEditStructuredToolHandler extends BaseToolHandler {
 
     // Map operations to LSP extensions
     const info = await this.projectInfo.get();
+
+    // Pre-syntax check: fail fast if file has obvious syntax errors
+    const absolutePath = path.join(info.projectRoot, relative.replace(/\//g, path.sep));
+    try {
+      const content = await fs.readFile(absolutePath, 'utf8');
+      const syntaxCheck = preSyntaxCheck(content, relative);
+      if (!syntaxCheck.valid) {
+        throw new Error(`${syntaxCheck.error}. ${syntaxCheck.recoveryHint || ''}`);
+      }
+    } catch (e) {
+      // Re-throw syntax errors, let LSP handle file-not-found
+      if (e && e.code !== 'ENOENT') {
+        throw e;
+      }
+    }
+
     if (!this.lsp) this.lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
 
     if (operation === 'replace_body') {

package/src/handlers/script/csharpSyntaxCheck.js

@@ -0,0 +1,177 @@
+/**
+ * Lightweight C# syntax pre-check to detect obvious errors before LSP processing.
+ * This helps fail fast instead of waiting for 60s LSP timeout on malformed files.
+ */
+
+/**
+ * Check for balanced braces, brackets, and parentheses.
+ * @param {string} content - C# source code
+ * @returns {{ valid: boolean, error?: string, details?: object }}
+ */
+export function checkBraceBalance(content) {
+  const stack = [];
+  const pairs = { '{': '}', '[': ']', '(': ')' };
+  const openings = new Set(Object.keys(pairs));
+  const closings = new Set(Object.values(pairs));
+
+  let inString = false;
+  let inChar = false;
+  let inSingleLineComment = false;
+  let inMultiLineComment = false;
+  let lineNumber = 1;
+  let columnNumber = 1;
+
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    const next = content[i + 1];
+    const prev = content[i - 1];
+
+    // Track line numbers
+    if (ch === '\n') {
+      lineNumber++;
+      columnNumber = 1;
+      inSingleLineComment = false;
+      continue;
+    }
+    columnNumber++;
+
+    // Skip comments
+    if (!inString && !inChar) {
+      if (inMultiLineComment) {
+        if (ch === '*' && next === '/') {
+          inMultiLineComment = false;
+          i++;
+          columnNumber++;
+        }
+        continue;
+      }
+      if (inSingleLineComment) {
+        continue;
+      }
+      if (ch === '/' && next === '/') {
+        inSingleLineComment = true;
+        continue;
+      }
+      if (ch === '/' && next === '*') {
+        inMultiLineComment = true;
+        i++;
+        columnNumber++;
+        continue;
+      }
+    }
+
+    // Handle strings (skip escaped quotes)
+    if (!inChar && !inSingleLineComment && !inMultiLineComment) {
+      if (ch === '"' && prev !== '\\') {
+        // Check for verbatim string @""
+        if (!inString && prev === '@') {
+          // Verbatim string - skip until unescaped closing "
+          i++;
+          while (i < content.length) {
+            if (content[i] === '"') {
+              if (content[i + 1] === '"') {
+                i++; // escaped quote in verbatim
+              } else {
+                break;
+              }
+            }
+            if (content[i] === '\n') {
+              lineNumber++;
+              columnNumber = 0;
+            }
+            i++;
+            columnNumber++;
+          }
+          continue;
+        }
+        inString = !inString;
+        continue;
+      }
+    }
+
+    // Handle char literals
+    if (!inString && !inSingleLineComment && !inMultiLineComment) {
+      if (ch === "'" && prev !== '\\') {
+        inChar = !inChar;
+        continue;
+      }
+    }
+
+    // Skip if inside string or char
+    if (inString || inChar) continue;
+
+    // Track braces
+    if (openings.has(ch)) {
+      stack.push({ char: ch, line: lineNumber, column: columnNumber });
+    } else if (closings.has(ch)) {
+      if (stack.length === 0) {
+        return {
+          valid: false,
+          error: `Unexpected closing '${ch}' at line ${lineNumber}, column ${columnNumber}`,
+          details: { line: lineNumber, column: columnNumber, char: ch }
+        };
+      }
+      const top = stack.pop();
+      if (pairs[top.char] !== ch) {
+        return {
+          valid: false,
+          error: `Mismatched '${top.char}' (line ${top.line}) and '${ch}' (line ${lineNumber})`,
+          details: {
+            opening: { char: top.char, line: top.line, column: top.column },
+            closing: { char: ch, line: lineNumber, column: columnNumber }
+          }
+        };
+      }
+    }
+  }
+
+  if (stack.length > 0) {
+    const unclosed = stack.map(s => `'${s.char}' at line ${s.line}`).join(', ');
+    return {
+      valid: false,
+      error: `Unclosed brackets: ${unclosed}`,
+      details: { unclosed: stack }
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Perform lightweight pre-validation on C# source code.
+ * Returns early with actionable error if basic syntax is broken.
+ *
+ * @param {string} content - C# source code
+ * @param {string} [filePath] - Optional file path for error messages
+ * @returns {{ valid: boolean, error?: string, recoveryHint?: string }}
+ */
+export function preSyntaxCheck(content, filePath = 'file') {
+  // Check 1: Brace balance
+  const braceResult = checkBraceBalance(content);
+  if (!braceResult.valid) {
+    return {
+      valid: false,
+      error: `Syntax error in ${filePath}: ${braceResult.error}`,
+      recoveryHint:
+        'The file has unbalanced braces/brackets. ' +
+        'Use Bash tool with "cat > file << EOF" to rewrite the file, ' +
+        'or fix manually in Unity Editor.'
+    };
+  }
+
+  // Check 2: Basic structure validation (namespace/class/method patterns)
+  // Lightweight check - just ensure there's at least one class/struct/interface
+  const hasTypeDeclaration = /\b(class|struct|interface|enum|record)\s+\w+/.test(content);
+  if (!hasTypeDeclaration && content.trim().length > 100) {
+    // File has content but no type declaration - likely corrupted
+    return {
+      valid: false,
+      error: `No type declaration found in ${filePath}`,
+      recoveryHint:
+        'The file appears to be missing class/struct/interface declarations. ' +
+        'This may indicate file corruption. Check the file content.'
+    };
+  }
+
+  return { valid: true };
+}

package/src/lsp/LspRpcClient.js

@@ -166,10 +166,17 @@ export class LspRpcClient {
         );
         return await this.#requestWithRetry(method, params, attempt + 1);
       }
-      // Standardize error message
-      const hint = recoverable
-        ? 'The server was restarted. Try again if the issue persists.'
-        : 'Check request parameters or increase lsp.requestTimeoutMs.';
+      // Standardize error message with actionable recovery instructions
+      let hint;
+      if (recoverable) {
+        hint =
+          'LSP failed to parse the file (likely syntax errors). ' +
+          'Recovery options: (1) Use Bash tool with "cat > file << EOF" to rewrite the file, ' +
+          '(2) Fix syntax errors manually in Unity Editor, ' +
+          '(3) Check for unbalanced braces/brackets in the target file.';
+      } else {
+        hint = 'Check request parameters or increase lsp.requestTimeoutMs.';
+      }
       throw new Error(`[${method}] failed: ${msg}. ${hint}`);
     }
   }