@akiojin/unity-mcp-server 2.40.3 → 2.40.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.40.3",
+  "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() {
@@ -103,6 +158,7 @@ export class CodeIndex {
       );
     });
     tx(symbols || []);
+    await this._flushFallback();
     return { total: symbols?.length || 0 };
   }
 
@@ -124,6 +180,7 @@ export class CodeIndex {
       sig || '',
       new Date().toISOString()
     );
+    await this._flushFallback();
   }
 
   async removeFile(pathStr) {
@@ -134,6 +191,7 @@ export class CodeIndex {
       db.prepare('DELETE FROM files WHERE path = ?').run(p);
     });
     tx(pathStr);
+    await this._flushFallback();
   }
 
   async replaceSymbolsForPath(pathStr, rows) {
@@ -160,6 +218,7 @@ export class CodeIndex {
       );
     });
     tx(pathStr, rows || []);
+    await this._flushFallback();
   }
 
   async querySymbols({ name, kind, scope = 'all', exact = false }) {
@@ -209,4 +268,19 @@ export class CodeIndex {
       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

@@ -219,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'

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/script/CodeIndexBuildToolHandler.js

@@ -77,6 +77,13 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
    */
   async _executeBuild(params, job) {
     try {
+      // Fail fast when native SQLite binding is unavailable
+      const db = await this.index.open();
+      if (!db) {
+        const reason = this.index.disableReason || 'Code index unavailable (SQLite driver missing)';
+        throw new Error(reason);
+      }
+
       const throttleMs = Math.max(0, Number(params?.throttleMs ?? 0));
       const delayStartMs = Math.max(0, Number(params?.delayStartMs ?? 0));
       const info = await this.projectInfo.get();