@akiojin/unity-mcp-server 4.1.4 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "4.1.4",
+  "version": "4.2.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/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}`);
     }
   }