@akiojin/unity-mcp-server 2.14.15 → 2.14.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.14.15",
+  "version": "2.14.17",
   "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/base/BaseToolHandler.js

@@ -4,11 +4,81 @@
  */
 import { logger } from '../../core/config.js';
 
+function cloneSchema(schema) {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (typeof structuredClone === 'function') {
+    return structuredClone(schema);
+  }
+
+  try {
+    return JSON.parse(JSON.stringify(schema));
+  } catch {
+    return schema;
+  }
+}
+
+function sanitizeSchema(schema) {
+  if (!schema) {
+    return schema;
+  }
+
+  if (Array.isArray(schema)) {
+    schema.forEach(item => sanitizeSchema(item));
+    return schema;
+  }
+
+  if (typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (Array.isArray(schema.required) && schema.required.length === 0) {
+    delete schema.required;
+  }
+
+  if (schema.properties && typeof schema.properties === 'object') {
+    Object.values(schema.properties).forEach(value => sanitizeSchema(value));
+  }
+
+  if (schema.items) {
+    sanitizeSchema(schema.items);
+  }
+
+  if (Array.isArray(schema.anyOf)) {
+    schema.anyOf.forEach(branch => sanitizeSchema(branch));
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    schema.oneOf.forEach(branch => sanitizeSchema(branch));
+  }
+
+  if (Array.isArray(schema.allOf)) {
+    schema.allOf.forEach(branch => sanitizeSchema(branch));
+  }
+
+  if (schema.then) {
+    sanitizeSchema(schema.then);
+  }
+
+  if (schema.else) {
+    sanitizeSchema(schema.else);
+  }
+
+  if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+    sanitizeSchema(schema.additionalProperties);
+  }
+
+  return schema;
+}
+
 export class BaseToolHandler {
   constructor(name, description, inputSchema = {}) {
     this.name = name;
     this.description = description;
-    this.inputSchema = inputSchema;
+    const clonedSchema = cloneSchema(inputSchema) || {};
+    this.inputSchema = sanitizeSchema(clonedSchema);
   }
 
   /**

package/src/handlers/script/ScriptSymbolFindToolHandler.js

@@ -56,7 +56,8 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
         if (await this.index.isReady()) {
             const rows = await this.index.querySymbols({ name, kind, scope, exact });
             results = rows.map(r => ({
-                path: r.path,
+                // Index returns project-relative paths already
+                path: (r.path || '').replace(/\\\\/g, '/'),
                 symbol: {
                     name: r.name,
                     kind: r.kind,
@@ -73,19 +74,28 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
             if (!this.lsp) this.lsp = new LspRpcClient(info.projectRoot);
             const resp = await this.lsp.request('workspace/symbol', { query: String(name) });
             const arr = resp?.result || [];
-            results = arr.map(s => ({
-                path: (s.location?.uri || '').replace('file://',''),
-                symbol: {
-                    name: s.name,
-                    kind: this.mapKind(s.kind),
-                    namespace: null,
-                    container: null,
-                    startLine: (s.location?.range?.start?.line ?? 0) + 1,
-                    startColumn: (s.location?.range?.start?.character ?? 0) + 1,
-                    endLine: (s.location?.range?.end?.line ?? 0) + 1,
-                    endColumn: (s.location?.range?.end?.character ?? 0) + 1,
-                }
-            }));
+            const root = String(info.projectRoot || '').replace(/\\\\/g, '/');
+            const rootWithSlash = root.endsWith('/') ? root : (root + '/');
+            results = arr.map(s => {
+                const uri = String(s.location?.uri || '');
+                // Normalize to absolute path without scheme
+                const abs = uri.replace('file://', '').replace(/\\\\/g, '/');
+                // Convert to project-relative if under project root
+                const rel = abs.startsWith(rootWithSlash) ? abs.slice(rootWithSlash.length) : abs;
+                return {
+                    path: rel,
+                    symbol: {
+                        name: s.name,
+                        kind: this.mapKind(s.kind),
+                        namespace: null,
+                        container: null,
+                        startLine: (s.location?.range?.start?.line ?? 0) + 1,
+                        startColumn: (s.location?.range?.start?.character ?? 0) + 1,
+                        endLine: (s.location?.range?.end?.line ?? 0) + 1,
+                        endColumn: (s.location?.range?.end?.character ?? 0) + 1,
+                    }
+                };
+            });
         }
         // Optional post-filtering: scope and exact name
         if (scope && scope !== 'all') {
@@ -94,7 +104,9 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
                 switch (scope) {
                     case 'assets': return p.startsWith('Assets/');
                     case 'packages': return p.startsWith('Packages/') || p.startsWith('Library/PackageCache/');
-                    case 'embedded': return p.startsWith('Packages/');                }
+                    case 'embedded': return p.startsWith('Packages/');
+                    default: return true;
+                }
             });
         }
         if (exact) {

package/src/handlers/ui/SetUIElementValueToolHandler.js

@@ -13,7 +13,15 @@ export class SetUIElementValueToolHandler extends BaseToolHandler {
                         description: 'Full hierarchy path to the UI element'
                     },
                     value: {
-                        description: 'New value to set (type depends on element type)'
+                        anyOf: [
+                            { type: 'string' },
+                            { type: 'number' },
+                            { type: 'boolean' },
+                            { type: 'object' },
+                            { type: 'array' },
+                            { type: 'null' }
+                        ],
+                        description: 'New value to set. Supports string, number, boolean, object, array, or null depending on the UI element type.'
                     },
                     triggerEvents: {
                         type: 'boolean',
@@ -46,4 +54,4 @@ export class SetUIElementValueToolHandler extends BaseToolHandler {
 
         return result;
     }
-}
+}

package/src/lsp/CSharpLspUtils.js

@@ -93,32 +93,38 @@ export class CSharpLspUtils {
   }
 
   async downloadTo(url, dest) {
-    const res = await fetch(url, { headers: { 'User-Agent': 'unity-mcp-server' } });
-    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
-    const file = fs.createWriteStream(dest);
+    const headers = { 'User-Agent': 'unity-mcp-server' };
+    const fetchOnce = async () => {
+      const r = await fetch(url, { headers });
+      if (!r.ok) throw new Error(`HTTP ${r.status} for ${url}`);
+      return r;
+    };
+
+    const res = await fetchOnce();
     const body = res.body;
-    if (body && typeof body.pipe === 'function') {
-      await new Promise((resolve, reject) => {
-        body.pipe(file);
-        body.on('error', reject);
-        file.on('finish', resolve);
-        file.on('error', reject);
-      });
-      return;
-    }
-    try {
-      const { Readable } = await import('node:stream');
-      const nodeStream = Readable.fromWeb(body);
-      await new Promise((resolve, reject) => {
-        nodeStream.pipe(file);
-        nodeStream.on('error', reject);
-        file.on('finish', resolve);
-        file.on('error', reject);
-      });
-    } catch (e) {
-      const ab = await res.arrayBuffer();
-      await fs.promises.writeFile(dest, Buffer.from(ab));
+
+    // Prefer WebStream -> Node stream piping
+    if (body) {
+      try {
+        const file = fs.createWriteStream(dest);
+        const { Readable } = await import('node:stream');
+        const nodeStream = Readable.fromWeb(body);
+        await new Promise((resolve, reject) => {
+          nodeStream.pipe(file);
+          nodeStream.on('error', reject);
+          file.on('finish', resolve);
+          file.on('error', reject);
+        });
+        return;
+      } catch (e) {
+        // If streaming failed or body was already consumed, re-fetch and fall back to arrayBuffer
+      }
     }
+
+    // Fallback: re-fetch fresh response and write full buffer
+    const res2 = await fetchOnce();
+    const ab = await res2.arrayBuffer();
+    await fs.promises.writeFile(dest, Buffer.from(ab));
   }
 
   async sha256File(file) {