@akiojin/unity-mcp-server 2.40.2 → 2.40.4

package/README.md

@@ -332,6 +332,27 @@ npm uninstall -g @akiojin/unity-mcp-server
 npm install -g @akiojin/unity-mcp-server
 ```
 
+### MCP Client Shows "Capabilities: none"
+
+If your MCP client (Claude Code, Cursor, etc.) shows "Capabilities: none" despite successful connection:
+
+**Symptom**: Server connects successfully, but no tools are visible to the client.
+
+**Root Cause**: Empty capability objects (`resources: {}`, `prompts: {}`) in MCP SDK v0.6.1 cause capability validation to fail silently.
+
+**Solution**: Update to latest version with the fix:
+
+```bash
+# Update to latest version (2.41.0+)
+npm update -g @akiojin/unity-mcp-server
+
+# Or reinstall
+npm uninstall -g @akiojin/unity-mcp-server
+npm install -g @akiojin/unity-mcp-server
+```
+
+**Verification**: After restart, your MCP client should display 107 available tools.
+
 ## Repository
 
 Full source code and documentation: <https://github.com/akiojin/unity-mcp-server>

package/bin/unity-mcp-server

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { startServer } from '../src/core/server.js';
 
-startServer().catch((error) => {
+startServer().catch(error => {
   console.error('Fatal error:', error);
   console.error('Stack trace:', error?.stack);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.40.2",
+  "version": "2.40.4",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",
@@ -27,7 +27,7 @@
     "test:verbose": "VERBOSE_TEST=true node --test tests/**/*.test.js",
     "prepare": "cd .. && husky || true",
     "prepublishOnly": "npm run test:ci",
-    "postinstall": "chmod +x bin/unity-mcp-server || true",
+    "postinstall": "node scripts/ensure-better-sqlite3.mjs && chmod +x bin/unity-mcp-server || true",
     "test:ci:unity": "timeout 60 node --test tests/unit/core/codeIndex.test.js tests/unit/core/codeIndexDb.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js || exit 0",
     "test:unity": "node tests/run-unity-integration.mjs",
     "test:nounity": "npm run test:integration",
@@ -50,7 +50,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^0.6.1",
     "better-sqlite3": "^9.4.3",
-    "find-up": "^6.3.0"
+    "find-up": "^6.3.0",
+    "sql.js": "^1.13.0"
   },
   "engines": {
     "node": ">=18 <23"

package/src/core/codeIndex.js

@@ -1,6 +1,15 @@
 import fs from 'fs';
 import path from 'path';
 import { ProjectInfoProvider } from './projectInfo.js';
+import { logger } from './config.js';
+import { createSqliteFallback } from './sqliteFallback.js';
+
+// Shared driver availability state across CodeIndex instances
+const driverStatus = {
+  available: null,
+  error: null,
+  logged: false
+};
 
 export class CodeIndex {
   constructor(unityConnection) {
@@ -9,21 +18,42 @@ export class CodeIndex {
     this.db = null;
     this.dbPath = null;
     this.disabled = false; // set true if better-sqlite3 is unavailable
+    this.disableReason = null;
     this._Database = null;
+    this._openFallback = null;
+    this._persistFallback = null;
   }
 
   async _ensureDriver() {
-    if (this.disabled) return false;
+    if (driverStatus.available === false || this.disabled) {
+      this.disabled = true;
+      this.disableReason = this.disableReason || driverStatus.error;
+      return false;
+    }
     if (this._Database) return true;
     try {
       // Dynamic import to avoid hard failure when native binding is missing
       const mod = await import('better-sqlite3');
       this._Database = mod.default || mod;
+      driverStatus.available = true;
+      driverStatus.error = null;
       return true;
     } catch (e) {
-      // Mark as disabled and operate in fallback (index unavailable)
-      this.disabled = true;
-      return false;
+      // Try wasm fallback (sql.js) before giving up
+      try {
+        this._openFallback = createSqliteFallback;
+        driverStatus.available = true;
+        driverStatus.error = null;
+        logger?.info?.('[index] falling back to sql.js (WASM) for code index');
+        return true;
+      } catch (fallbackError) {
+        this.disabled = true;
+        this.disableReason = `better-sqlite3 unavailable: ${e?.message || e}. Fallback failed: ${fallbackError?.message || fallbackError}`;
+        driverStatus.available = false;
+        driverStatus.error = this.disableReason;
+        this._logDisable(this.disableReason);
+        return false;
+      }
     }
   }
 
@@ -36,11 +66,35 @@ export class CodeIndex {
     fs.mkdirSync(dir, { recursive: true });
     const dbPath = path.join(dir, 'code-index.db');
     this.dbPath = dbPath;
-    this.db = new this._Database(dbPath);
+    try {
+      if (this._Database) {
+        this.db = new this._Database(dbPath);
+      } else if (this._openFallback) {
+        this.db = await this._openFallback(dbPath);
+        this._persistFallback = this.db.persist;
+      } else {
+        throw new Error('No database driver available');
+      }
+    } catch (e) {
+      this.disabled = true;
+      this.disableReason = e?.message || 'Failed to open code index database';
+      driverStatus.available = false;
+      driverStatus.error = this.disableReason;
+      this._logDisable(this.disableReason);
+      return null;
+    }
     this._initSchema();
     return this.db;
   }
 
+  _logDisable(reason) {
+    if (driverStatus.logged) return;
+    driverStatus.logged = true;
+    try {
+      logger?.warn?.(`[index] code index disabled: ${reason}`);
+    } catch {}
+  }
+
   _initSchema() {
     if (!this.db) return;
     const db = this.db;
@@ -68,6 +122,7 @@ export class CodeIndex {
       CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);
       CREATE INDEX IF NOT EXISTS idx_symbols_path ON symbols(path);
     `);
+    if (this._persistFallback) this._persistFallback();
   }
 
   async isReady() {
@@ -80,16 +135,30 @@ export class CodeIndex {
   async clearAndLoad(symbols) {
     const db = await this.open();
     if (!db) throw new Error('CodeIndex is unavailable (better-sqlite3 not installed)');
-    const insert = db.prepare('INSERT INTO symbols(path,name,kind,container,namespace,line,column) VALUES (?,?,?,?,?,?,?)');
-    const tx = db.transaction((rows) => {
+    const insert = db.prepare(
+      'INSERT INTO symbols(path,name,kind,container,namespace,line,column) VALUES (?,?,?,?,?,?,?)'
+    );
+    const tx = db.transaction(rows => {
       db.exec('DELETE FROM symbols');
       db.exec('DELETE FROM files');
       for (const r of rows) {
-        insert.run(r.path, r.name, r.kind, r.container || null, r.ns || r.namespace || null, r.line || null, r.column || null);
+        insert.run(
+          r.path,
+          r.name,
+          r.kind,
+          r.container || null,
+          r.ns || r.namespace || null,
+          r.line || null,
+          r.column || null
+        );
       }
-      db.prepare('REPLACE INTO meta(key,value) VALUES (?,?)').run('lastIndexedAt', new Date().toISOString());
+      db.prepare('REPLACE INTO meta(key,value) VALUES (?,?)').run(
+        'lastIndexedAt',
+        new Date().toISOString()
+      );
     });
     tx(symbols || []);
+    await this._flushFallback();
     return { total: symbols?.length || 0 };
   }
 
@@ -106,17 +175,23 @@ export class CodeIndex {
   async upsertFile(pathStr, sig) {
     const db = await this.open();
     if (!db) return;
-    db.prepare('REPLACE INTO files(path,sig,updatedAt) VALUES (?,?,?)').run(pathStr, sig || '', new Date().toISOString());
+    db.prepare('REPLACE INTO files(path,sig,updatedAt) VALUES (?,?,?)').run(
+      pathStr,
+      sig || '',
+      new Date().toISOString()
+    );
+    await this._flushFallback();
   }
 
   async removeFile(pathStr) {
     const db = await this.open();
     if (!db) return;
-    const tx = db.transaction((p) => {
+    const tx = db.transaction(p => {
       db.prepare('DELETE FROM symbols WHERE path = ?').run(p);
       db.prepare('DELETE FROM files WHERE path = ?').run(p);
     });
     tx(pathStr);
+    await this._flushFallback();
   }
 
   async replaceSymbolsForPath(pathStr, rows) {
@@ -124,11 +199,26 @@ export class CodeIndex {
     if (!db) return;
     const tx = db.transaction((p, list) => {
       db.prepare('DELETE FROM symbols WHERE path = ?').run(p);
-      const insert = db.prepare('INSERT INTO symbols(path,name,kind,container,namespace,line,column) VALUES (?,?,?,?,?,?,?)');
-      for (const r of list) insert.run(p, r.name, r.kind, r.container || null, r.ns || r.namespace || null, r.line || null, r.column || null);
-      db.prepare('REPLACE INTO meta(key,value) VALUES (?,?)').run('lastIndexedAt', new Date().toISOString());
+      const insert = db.prepare(
+        'INSERT INTO symbols(path,name,kind,container,namespace,line,column) VALUES (?,?,?,?,?,?,?)'
+      );
+      for (const r of list)
+        insert.run(
+          p,
+          r.name,
+          r.kind,
+          r.container || null,
+          r.ns || r.namespace || null,
+          r.line || null,
+          r.column || null
+        );
+      db.prepare('REPLACE INTO meta(key,value) VALUES (?,?)').run(
+        'lastIndexedAt',
+        new Date().toISOString()
+      );
     });
     tx(pathStr, rows || []);
+    await this._flushFallback();
   }
 
   async querySymbols({ name, kind, scope = 'all', exact = false }) {
@@ -137,27 +227,60 @@ export class CodeIndex {
     let sql = 'SELECT path,name,kind,container,namespace,line,column FROM symbols WHERE 1=1';
     const params = {};
     if (name) {
-      if (exact) { sql += ' AND name = @name'; params.name = name; }
-      else { sql += ' AND name LIKE @name'; params.name = `%${name}%`; }
+      if (exact) {
+        sql += ' AND name = @name';
+        params.name = name;
+      } else {
+        sql += ' AND name LIKE @name';
+        params.name = `%${name}%`;
+      }
+    }
+    if (kind) {
+      sql += ' AND kind = @kind';
+      params.kind = kind;
     }
-    if (kind) { sql += ' AND kind = @kind'; params.kind = kind; }
     const rows = db.prepare(sql).all(params);
     // Apply path-based scope filter in JS (simpler than CASE in SQL)
     const filtered = rows.filter(r => {
       const p = String(r.path || '').replace(/\\\\/g, '/');
       if (scope === 'assets') return p.startsWith('Assets/');
-      if (scope === 'packages') return p.startsWith('Packages/') || p.includes('Library/PackageCache/');
+      if (scope === 'packages')
+        return p.startsWith('Packages/') || p.includes('Library/PackageCache/');
       if (scope === 'embedded') return p.startsWith('Packages/');
       return true;
     });
-    return filtered.map(r => ({ path: r.path, name: r.name, kind: r.kind, container: r.container, ns: r.namespace, line: r.line, column: r.column }));
+    return filtered.map(r => ({
+      path: r.path,
+      name: r.name,
+      kind: r.kind,
+      container: r.container,
+      ns: r.namespace,
+      line: r.line,
+      column: r.column
+    }));
   }
 
   async getStats() {
     const db = await this.open();
     if (!db) return { total: 0, lastIndexedAt: null };
     const total = db.prepare('SELECT COUNT(*) AS c FROM symbols').get().c || 0;
-    const last = db.prepare("SELECT value AS v FROM meta WHERE key = 'lastIndexedAt'").get()?.v || null;
+    const last =
+      db.prepare("SELECT value AS v FROM meta WHERE key = 'lastIndexedAt'").get()?.v || null;
     return { total, lastIndexedAt: last };
   }
+
+  async _flushFallback() {
+    if (typeof this._persistFallback === 'function') {
+      try {
+        await this._persistFallback();
+      } catch {}
+    }
+  }
+}
+
+// Test-only helper to reset cached driver status between runs
+export function __resetCodeIndexDriverStatusForTest() {
+  driverStatus.available = null;
+  driverStatus.error = null;
+  driverStatus.logged = false;
 }

package/src/core/indexWatcher.js

@@ -34,6 +34,17 @@ export class IndexWatcher {
     if (this.running) return;
     this.running = true;
     try {
+      // Skip watcher entirely when the native SQLite binding is unavailable
+      const { CodeIndex } = await import('./codeIndex.js');
+      const probe = new CodeIndex(this.unityConnection);
+      const driverOk = await probe._ensureDriver();
+      if (!driverOk || probe.disabled) {
+        const reason = probe.disableReason || 'SQLite native binding not available';
+        logger.warn(`[index] watcher: code index disabled (${reason}); stopping watcher`);
+        this.stop();
+        return;
+      }
+
       // Check if code index DB file exists (before opening DB)
       const { ProjectInfoProvider } = await import('./projectInfo.js');
       const projectInfo = new ProjectInfoProvider(this.unityConnection);

package/src/core/server.js

@@ -1,11 +1,6 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ListPromptsRequestSchema
-} from '@modelcontextprotocol/sdk/types.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 // Note: filename is lowercase on disk; use exact casing for POSIX filesystems
 import { UnityConnection } from './unityConnection.js';
 import { createHandlers } from '../handlers/index.js';
@@ -29,9 +24,7 @@ const server = new Server(
     capabilities: {
       // Explicitly advertise tool support; some MCP clients expect a non-empty object
       // Setting listChanged enables future push updates if we emit notifications
-      tools: { listChanged: true },
-      resources: {},
-      prompts: {}
+      tools: { listChanged: true }
     }
   }
 );
@@ -63,20 +56,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
   return { tools };
 });
 
-// Handle resources listing
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  logger.debug('[MCP] Received resources/list request');
-  // Unity MCP server doesn't provide resources
-  return { resources: [] };
-});
-
-// Handle prompts listing
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-  logger.debug('[MCP] Received prompts/list request');
-  // Unity MCP server doesn't provide prompts
-  return { prompts: [] };
-});
-
 // Handle tool execution
 server.setRequestHandler(CallToolRequestSchema, async request => {
   const { name, arguments: args } = request.params;
@@ -240,6 +219,12 @@ export async function startServer() {
         const ready = await index.isReady();
 
         if (!ready) {
+          if (index.disabled) {
+            logger.warn(
+              `[startup] Code index disabled: ${index.disableReason || 'SQLite native binding missing'}. Skipping auto-build.`
+            );
+            return;
+          }
           logger.info('[startup] Code index DB not ready. Starting auto-build...');
           const { CodeIndexBuildToolHandler } = await import(
             '../handlers/script/CodeIndexBuildToolHandler.js'
@@ -298,9 +283,7 @@ export async function createServer(customConfig = config) {
     },
     {
       capabilities: {
-        tools: { listChanged: true },
-        resources: {},
-        prompts: {}
+        tools: { listChanged: true }
       }
     }
   );
@@ -311,14 +294,6 @@ export async function createServer(customConfig = config) {
     return { tools };
   });
 
-  testServer.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return { resources: [] };
-  });
-
-  testServer.setRequestHandler(ListPromptsRequestSchema, async () => {
-    return { prompts: [] };
-  });
-
   testServer.setRequestHandler(CallToolRequestSchema, async request => {
     const { name, arguments: args } = request.params;
 

package/src/core/sqliteFallback.js

@@ -0,0 +1,75 @@
+import fs from 'fs';
+import path from 'path';
+import initSqlJs from 'sql.js';
+
+// Create a lightweight better-sqlite3 compatible surface using sql.js (WASM)
+export async function createSqliteFallback(dbPath) {
+  const wasmPath = path.resolve('node_modules/sql.js/dist/sql-wasm.wasm');
+  const SQL = await initSqlJs({ locateFile: () => wasmPath });
+
+  const loadDb = () => {
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    if (fs.existsSync(dbPath)) {
+      const data = fs.readFileSync(dbPath);
+      return new SQL.Database(new Uint8Array(data));
+    }
+    return new SQL.Database();
+  };
+
+  const db = loadDb();
+
+  const persist = () => {
+    const data = db.export();
+    fs.writeFileSync(dbPath, Buffer.from(data));
+  };
+
+  // Wrap sql.js Statement to look like better-sqlite3's
+  const wrapStatement = stmt => ({
+    run(...params) {
+      stmt.bind(params);
+      // sql.js run via stepping through the statement
+      while (stmt.step()) {
+        /* consume rows for statements that return data */
+      }
+      stmt.reset();
+      persist();
+      return this;
+    },
+    get(...params) {
+      stmt.bind(params);
+      const has = stmt.step();
+      const row = has ? stmt.getAsObject() : undefined;
+      stmt.reset();
+      return row;
+    },
+    all(...params) {
+      stmt.bind(params);
+      const rows = [];
+      while (stmt.step()) rows.push(stmt.getAsObject());
+      stmt.reset();
+      return rows;
+    }
+  });
+
+  const prepare = sql => wrapStatement(db.prepare(sql));
+
+  // Mimic better-sqlite3 transaction(fn)
+  const transaction =
+    fn =>
+    (...args) => {
+      const result = fn(...args);
+      persist();
+      return result;
+    };
+
+  // Minimal surface used by CodeIndex
+  return {
+    exec: sql => {
+      db.exec(sql);
+      persist();
+    },
+    prepare,
+    transaction,
+    persist
+  };
+}

package/src/handlers/analysis/AnalyzeSceneContentsToolHandler.js

@@ -1,35 +1,38 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { analyzeSceneContentsToolDefinition, analyzeSceneContentsHandler } from '../../tools/analysis/analyzeSceneContents.js';
+import {
+  analyzeSceneContentsToolDefinition,
+  analyzeSceneContentsHandler
+} from '../../tools/analysis/analyzeSceneContents.js';
 
 /**
  * Handler for analyze_scene_contents tool
  */
 export class AnalyzeSceneContentsToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            analyzeSceneContentsToolDefinition.name,
-            analyzeSceneContentsToolDefinition.description,
-            analyzeSceneContentsToolDefinition.inputSchema
-        );
-        this.unityConnection = unityConnection;
-        this.handler = analyzeSceneContentsHandler;
+  constructor(unityConnection) {
+    super(
+      analyzeSceneContentsToolDefinition.name,
+      analyzeSceneContentsToolDefinition.description,
+      analyzeSceneContentsToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+    this.handler = analyzeSceneContentsHandler;
+  }
+
+  async execute(args) {
+    // Check connection
+    if (!this.unityConnection.isConnected()) {
+      throw new Error('Unity connection not available');
     }
 
-    async execute(args) {
-        // Check connection
-        if (!this.unityConnection.isConnected()) {
-            throw new Error('Unity connection not available');
-        }
+    // Use the handler function
+    const result = await this.handler(this.unityConnection, args);
 
-        // Use the handler function
-        const result = await this.handler(this.unityConnection, args);
-        
-        // If the handler returns an error response, throw it
-        if (result.isError) {
-            throw new Error(result.content[0].text);
-        }
-        
-        // Return the content
-        return result;
+    // If the handler returns an error response, throw it
+    if (result.isError) {
+      throw new Error(result.content[0].text);
     }
+
+    // Return the content
+    return result;
+  }
 }

package/src/handlers/analysis/FindByComponentToolHandler.js

@@ -1,5 +1,8 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { findByComponentToolDefinition, findByComponentHandler } from '../../tools/analysis/findByComponent.js';
+import {
+  findByComponentToolDefinition,
+  findByComponentHandler
+} from '../../tools/analysis/findByComponent.js';
 
 /**
  * Handler for the analysis_component_find tool

package/src/handlers/analysis/GetAnimatorStateToolHandler.js

@@ -1,9 +1,9 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { 
-    getAnimatorStateToolDefinition,
-    getAnimatorRuntimeInfoToolDefinition,
-    getAnimatorStateHandler,
-    getAnimatorRuntimeInfoHandler
+import {
+  getAnimatorStateToolDefinition,
+  getAnimatorRuntimeInfoToolDefinition,
+  getAnimatorStateHandler,
+  getAnimatorRuntimeInfoHandler
 } from '../../tools/analysis/getAnimatorState.js';
 
 export class GetAnimatorStateToolHandler extends BaseToolHandler {

package/src/handlers/analysis/GetComponentValuesToolHandler.js

@@ -1,5 +1,8 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { getComponentValuesToolDefinition, getComponentValuesHandler } from '../../tools/analysis/getComponentValues.js';
+import {
+  getComponentValuesToolDefinition,
+  getComponentValuesHandler
+} from '../../tools/analysis/getComponentValues.js';
 
 /**
  * Handler for the analysis_component_values_get tool

package/src/handlers/analysis/GetGameObjectDetailsToolHandler.js

@@ -1,35 +1,38 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
-import { getGameObjectDetailsToolDefinition, getGameObjectDetailsHandler } from '../../tools/analysis/getGameObjectDetails.js';
+import {
+  getGameObjectDetailsToolDefinition,
+  getGameObjectDetailsHandler
+} from '../../tools/analysis/getGameObjectDetails.js';
 
 /**
  * Handler for get_gameobject_details tool
  */
 export class GetGameObjectDetailsToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            getGameObjectDetailsToolDefinition.name,
-            getGameObjectDetailsToolDefinition.description,
-            getGameObjectDetailsToolDefinition.inputSchema
-        );
-        this.unityConnection = unityConnection;
-        this.handler = getGameObjectDetailsHandler;
+  constructor(unityConnection) {
+    super(
+      getGameObjectDetailsToolDefinition.name,
+      getGameObjectDetailsToolDefinition.description,
+      getGameObjectDetailsToolDefinition.inputSchema
+    );
+    this.unityConnection = unityConnection;
+    this.handler = getGameObjectDetailsHandler;
+  }
+
+  async execute(args) {
+    // Check connection
+    if (!this.unityConnection.isConnected()) {
+      throw new Error('Unity connection not available');
     }
 
-    async execute(args) {
-        // Check connection
-        if (!this.unityConnection.isConnected()) {
-            throw new Error('Unity connection not available');
-        }
+    // Use the handler function
+    const result = await this.handler(this.unityConnection, args);
 
-        // Use the handler function
-        const result = await this.handler(this.unityConnection, args);
-        
-        // If the handler returns an error response, throw it
-        if (result.isError) {
-            throw new Error(result.content[0].text);
-        }
-        
-        // Return the content
-        return result;
+    // If the handler returns an error response, throw it
+    if (result.isError) {
+      throw new Error(result.content[0].text);
     }
+
+    // Return the content
+    return result;
+  }
 }