fix: better-sqlite3再構築とWASMフォールバック

Author: akiojin

mcp-server/package.json

@@ -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"

mcp-server/scripts/ensure-better-sqlite3.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Ensure better-sqlite3 native binding exists; rebuild if missing (covers npx install where prebuilt not shipped)
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { spawnSync } from 'child_process';
+
+const bindingPath = resolve(
+  'node_modules',
+  'better-sqlite3',
+  'build',
+  'Release',
+  'better_sqlite3.node'
+);
+
+function main() {
+  if (process.env.SKIP_SQLITE_REBUILD) {
+    console.log('[postinstall] SKIP_SQLITE_REBUILD set, skipping better-sqlite3 check');
+    return;
+  }
+
+  if (existsSync(bindingPath)) {
+    return;
+  }
+
+  console.log(
+    '[postinstall] better-sqlite3 binding missing; rebuilding (npm rebuild better-sqlite3 --build-from-source)'
+  );
+  const result = spawnSync('npm', ['rebuild', 'better-sqlite3', '--build-from-source'], {
+    stdio: 'inherit',
+    shell: false
+  });
+  if (result.status !== 0) {
+    throw new Error(`better-sqlite3 rebuild failed with code ${result.status ?? 'null'}`);
+  }
+
+  if (!existsSync(bindingPath)) {
+    throw new Error('better-sqlite3 rebuild completed but binding was still not found');
+  }
+}
+
+try {
+  main();
+} catch (err) {
+  console.warn(`[postinstall] Warning: ${err.message}`);
+  // Do not hard fail install; runtime may still use sql.js fallback in codeIndex
+}

mcp-server/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;
 }

mcp-server/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);

mcp-server/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'

mcp-server/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
+  };
+}

mcp-server/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();

mcp-server/tests/unit/core/codeIndex.test.js

@@ -28,6 +28,34 @@ describe('CodeIndex', () => {
     });
   });
 
+  describe('when native binding is missing', () => {
+    it('disables gracefully and records the reason', async () => {
+      const { CodeIndex, __resetCodeIndexDriverStatusForTest } = await import(
+        '../../../src/core/codeIndex.js'
+      );
+
+      mock.method(CodeIndex.prototype, '_ensureDriver', async function () {
+        this._Database = class {
+          constructor() {
+            throw new Error('Could not locate the bindings file. Tried:');
+          }
+        };
+        return true;
+      });
+
+      const mockConnection = { isConnected: () => false };
+      const index = new CodeIndex(mockConnection);
+      const ready = await index.isReady();
+
+      assert.equal(ready, false);
+      assert.equal(index.disabled, true);
+      assert.match(index.disableReason, /bindings file/i);
+
+      mock.restoreAll();
+      __resetCodeIndexDriverStatusForTest();
+    });
+  });
+
   describe('SPEC compliance', () => {
     it('should provide code index functionality', async () => {
       try {