@akiojin/unity-mcp-server 2.40.6 → 2.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.40.6",
+  "version": "2.41.1",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",
@@ -20,13 +20,15 @@
     "test:watch": "node --watch --test tests/unit/**/*.test.js",
     "test:watch:all": "node --watch --test tests/**/*.test.js",
     "test:performance": "node --test tests/performance/*.test.js",
-    "test:ci": "CI=true NODE_ENV=test 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 tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js",
+    "test:ci": "CI=true NODE_ENV=test 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 tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js tests/unit/scripts/ensure-better-sqlite3.test.js",
     "test:ci:coverage": "c8 --reporter=lcov --reporter=text 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 tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js",
     "test:ci:all": "c8 --reporter=lcov node --test tests/unit/**/*.test.js",
     "simulate:code-index": "node scripts/simulate-code-index-status.mjs",
     "test:verbose": "VERBOSE_TEST=true node --test tests/**/*.test.js",
     "prepare": "cd .. && husky || true",
-    "prepublishOnly": "npm run test:ci",
+    "prebuild:better-sqlite3": "node scripts/prebuild-better-sqlite3.mjs",
+    "prebuilt:manifest": "node scripts/generate-prebuilt-manifest.mjs",
+    "prepublishOnly": "npm run test:ci && npm run prebuilt:manifest",
     "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",
@@ -68,6 +70,8 @@
   "files": [
     "src/",
     "bin/",
+    "scripts/ensure-better-sqlite3.mjs",
+    "prebuilt/",
     "README.md",
     "LICENSE"
   ],
@@ -78,11 +82,6 @@
   "devDependencies": {
     "@commitlint/cli": "^18.6.1",
     "@commitlint/config-conventional": "^18.6.3",
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/commit-analyzer": "^11.1.0",
-    "@semantic-release/exec": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/release-notes-generator": "^12.1.0",
     "c8": "^10.1.3",
     "eslint": "^8.57.1",
     "eslint-config-standard": "^17.1.0",
@@ -92,7 +91,6 @@
     "husky": "^9.1.7",
     "markdownlint-cli": "^0.43.0",
     "nodemon": "^3.1.7",
-    "prettier": "^3.4.2",
-    "semantic-release": "^22.0.12"
+    "prettier": "^3.4.2"
   }
 }

package/prebuilt/better-sqlite3/manifest.json

@@ -0,0 +1,11 @@
+{
+  "artifacts": [
+    {
+      "platformKey": "linux-x64-node22",
+      "checksum": null,
+      "node": null,
+      "generatedAt": null,
+      "size": 2066648
+    }
+  ]
+}

package/scripts/ensure-better-sqlite3.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// Ensure better-sqlite3 native binding exists. Prefers bundled prebuilt binaries, otherwise
+// optionally attempts a native rebuild (opt-in to avoid first-time npx timeouts).
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const SCRIPT_PATH = fileURLToPath(import.meta.url);
+const PKG_ROOT = path.resolve(path.dirname(SCRIPT_PATH), '..');
+
+const DEFAULT_BINDING_PATH = process.env.UNITY_MCP_BINDING_PATH
+  ? path.resolve(process.env.UNITY_MCP_BINDING_PATH)
+  : path.join(
+      PKG_ROOT,
+      'node_modules',
+      'better-sqlite3',
+      'build',
+      'Release',
+      'better_sqlite3.node'
+    );
+
+const DEFAULT_PREBUILT_ROOT = process.env.UNITY_MCP_PREBUILT_DIR
+  ? path.resolve(process.env.UNITY_MCP_PREBUILT_DIR)
+  : path.join(PKG_ROOT, 'prebuilt', 'better-sqlite3');
+
+export function resolvePlatformKey(
+  nodeVersion = process.versions.node,
+  platform = process.platform,
+  arch = process.arch
+) {
+  const major = String(nodeVersion).split('.')[0];
+  return `${platform}-${arch}-node${major}`;
+}
+
+function copyPrebuiltBinding(prebuiltDir, bindingTarget, log) {
+  const platformKey = resolvePlatformKey();
+  const source = path.join(prebuiltDir, platformKey, 'better_sqlite3.node');
+  if (!fs.existsSync(source)) return false;
+  fs.mkdirSync(path.dirname(bindingTarget), { recursive: true });
+  fs.copyFileSync(source, bindingTarget);
+  if (log) log(`[postinstall] Installed better-sqlite3 prebuilt for ${platformKey}`);
+  return true;
+}
+
+function rebuildNative(bindingTarget, pkgRoot, log) {
+  log(
+    '[postinstall] No prebuilt available. Attempting native rebuild (npm rebuild better-sqlite3 --build-from-source)'
+  );
+  const result = spawnSync('npm', ['rebuild', 'better-sqlite3', '--build-from-source'], {
+    stdio: 'inherit',
+    shell: false,
+    cwd: pkgRoot
+  });
+  if (result.status !== 0) {
+    throw new Error(`better-sqlite3 rebuild failed with code ${result.status ?? 'null'}`);
+  }
+  if (!fs.existsSync(bindingTarget)) {
+    throw new Error('better-sqlite3 rebuild completed but binding was still not found');
+  }
+  return true;
+}
+
+export function ensureBetterSqlite3(options = {}) {
+  const {
+    bindingPath = DEFAULT_BINDING_PATH,
+    prebuiltRoot = DEFAULT_PREBUILT_ROOT,
+    pkgRoot = PKG_ROOT,
+    skipNative = process.env.UNITY_MCP_SKIP_NATIVE_BUILD !== '0',
+    forceNative = process.env.UNITY_MCP_FORCE_NATIVE === '1',
+    skipLegacyFlag = Boolean(process.env.SKIP_SQLITE_REBUILD),
+    log = console.log,
+    warn = console.warn
+  } = options;
+
+  if (skipLegacyFlag && !forceNative) {
+    warn('[postinstall] SKIP_SQLITE_REBUILD set, skipping better-sqlite3 check');
+    return { status: 'skipped' };
+  }
+
+  if (!forceNative && copyPrebuiltBinding(prebuiltRoot, bindingPath, log)) {
+    return { status: 'copied' };
+  }
+
+  if (skipNative && !forceNative) {
+    warn(
+      '[postinstall] UNITY_MCP_SKIP_NATIVE_BUILD=1 -> skipping native rebuild; sql.js fallback will be used'
+    );
+    return { status: 'skipped' };
+  }
+
+  if (forceNative) {
+    log('[postinstall] UNITY_MCP_FORCE_NATIVE=1 -> forcing better-sqlite3 rebuild');
+  } else if (fs.existsSync(bindingPath)) {
+    // Binding already exists and native rebuild not forced.
+    return { status: 'existing' };
+  }
+
+  rebuildNative(bindingPath, pkgRoot, log);
+  return { status: 'rebuilt' };
+}
+
+function isCliExecution() {
+  const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : '';
+  return invokedPath === SCRIPT_PATH;
+}
+
+async function main() {
+  try {
+    await ensureBetterSqlite3();
+  } catch (err) {
+    console.warn(`[postinstall] Warning: ${err.message}`);
+    // Do not hard fail install; runtime may still use sql.js fallback in codeIndex
+  }
+}
+
+if (isCliExecution()) {
+  main();
+}

package/src/core/sqliteFallback.js

@@ -1,10 +1,18 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
 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 require = createRequire(import.meta.url);
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+  const pkgRoot = path.resolve(moduleDir, '..', '..');
+  const wasmPath = require.resolve('sql.js/dist/sql-wasm.wasm', {
+    // Resolve from package-local node_modules first, then workspace root
+    paths: [path.join(pkgRoot, 'node_modules'), path.join(pkgRoot, '..', 'node_modules')]
+  });
   const SQL = await initSqlJs({ locateFile: () => wasmPath });
 
   const loadDb = () => {

package/src/core/unityConnection.js

@@ -10,6 +10,7 @@ export class UnityConnection extends EventEmitter {
     super();
     this.socket = null;
     this.connected = false;
+    this.connectPromise = null;
     this.reconnectAttempts = 0;
     this.reconnectTimer = null;
     this.commandId = 0;
@@ -27,7 +28,12 @@ export class UnityConnection extends EventEmitter {
    * @returns {Promise<void>}
    */
   async connect() {
-    return new Promise((resolve, reject) => {
+    // Return the in-flight promise if we're already trying to connect.
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+
+    this.connectPromise = new Promise((resolve, reject) => {
       if (this.connected) {
         resolve();
         return;
@@ -46,6 +52,13 @@ export class UnityConnection extends EventEmitter {
       this.socket = new net.Socket();
       let connectionTimeout = null;
       let resolved = false;
+      const settle = (fn, value) => {
+        if (resolved) return;
+        resolved = true;
+        clearConnectionTimeout();
+        this.connectPromise = null;
+        fn(value);
+      };
 
       // Helper to clean up the connection timeout
       const clearConnectionTimeout = () => {
@@ -60,10 +73,10 @@ export class UnityConnection extends EventEmitter {
         logger.info('Connected to Unity Editor');
         this.connected = true;
         this.reconnectAttempts = 0;
-        resolved = true;
-        clearConnectionTimeout();
+        this.connectPromise = null;
         this.emit('connected');
-        resolve();
+        this._pumpQueue(); // flush any queued commands that arrived during reconnect
+        settle(resolve);
       });
 
       this.socket.on('data', data => {
@@ -72,11 +85,12 @@ export class UnityConnection extends EventEmitter {
 
       this.socket.on('error', error => {
         logger.error('Socket error:', error.message);
-        this.emit('error', error);
+        if (this.listenerCount('error') > 0) {
+          this.emit('error', error);
+        }
 
         if (!this.connected && !resolved) {
-          resolved = true;
-          clearConnectionTimeout();
+          this.connectPromise = null;
           // Mark as disconnecting to prevent reconnection
           this.isDisconnecting = true;
           // Destroy the socket to clean up properly
@@ -89,6 +103,7 @@ export class UnityConnection extends EventEmitter {
       this.socket.on('close', () => {
         // Clear the connection timeout when socket closes
         clearConnectionTimeout();
+        this.connectPromise = null;
 
         // Check if we're already handling disconnection
         if (this.isDisconnecting || !this.socket) {
@@ -123,14 +138,15 @@ export class UnityConnection extends EventEmitter {
       // Set timeout for initial connection
       connectionTimeout = setTimeout(() => {
         if (!this.connected && !resolved && this.socket) {
-          resolved = true;
           // Remove event listeners before destroying to prevent callbacks after timeout
           this.socket.removeAllListeners();
           this.socket.destroy();
-          reject(new Error('Connection timeout'));
+          this.connectPromise = null;
+          settle(reject, new Error('Connection timeout'));
         }
       }, config.unity.commandTimeout);
     });
+    return this.connectPromise;
   }
 
   /**
@@ -166,6 +182,11 @@ export class UnityConnection extends EventEmitter {
     if (this.reconnectTimer) {
       return;
     }
+    // Avoid piling up reconnects if a connection attempt is already in progress
+    if (this.connectPromise) {
+      logger.info('Reconnect skipped; connection attempt already in progress');
+      return;
+    }
 
     const delay = Math.min(
       config.unity.reconnectDelay *
@@ -338,8 +359,10 @@ export class UnityConnection extends EventEmitter {
     logger.info(`[Unity] enqueue sendCommand: ${type}`, { connected: this.connected });
 
     if (!this.connected) {
-      logger.error('[Unity] Cannot send command - not connected');
-      throw new Error('Not connected to Unity');
+      logger.warn('[Unity] Not connected; waiting for reconnection before sending command');
+      await this.ensureConnected({
+        timeoutMs: config.unity.commandTimeout
+      });
     }
 
     // Create an external promise that will resolve when Unity responds
@@ -424,6 +447,43 @@ export class UnityConnection extends EventEmitter {
     return this.sendCommand('ping', {});
   }
 
+  /**
+   * Wait until the connection is available, attempting to reconnect if needed.
+   * @param {object} options
+   * @param {number} options.timeoutMs - Maximum time to wait for reconnection
+   */
+  async ensureConnected({ timeoutMs = config.unity.commandTimeout } = {}) {
+    const start = Date.now();
+    let lastError = null;
+
+    while (!this.connected && Date.now() - start < timeoutMs) {
+      try {
+        await this.connect();
+      } catch (error) {
+        lastError = error;
+        const msg = error?.message || '';
+        if (process.env.NODE_ENV === 'test' || process.env.CI === 'true') {
+          // In test/CI we bail out immediately to avoid long waits
+          throw error;
+        }
+        if (/test environment/i.test(msg)) {
+          throw error;
+        }
+      }
+
+      if (this.connected) return;
+      await sleep(Math.min(500, timeoutMs));
+    }
+
+    if (!this.connected) {
+      const error = new Error(
+        `Failed to reconnect to Unity within ${timeoutMs}ms${lastError ? `: ${lastError.message}` : ''}`
+      );
+      error.code = 'UNITY_RECONNECT_TIMEOUT';
+      throw error;
+    }
+  }
+
   /**
    * Checks if connected to Unity
    * @returns {boolean}
@@ -432,3 +492,7 @@ export class UnityConnection extends EventEmitter {
     return this.connected;
   }
 }
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, Math.max(0, ms || 0)));
+}

package/src/handlers/script/CodeIndexStatusToolHandler.js

@@ -32,6 +32,17 @@ export class CodeIndexStatusToolHandler extends BaseToolHandler {
 
     // Check whether the persistent index already exists or is being built in the background.
     const ready = await this.codeIndex.isReady();
+    if (this.codeIndex.disabled) {
+      return {
+        success: false,
+        error: 'code_index_unavailable',
+        message:
+          this.codeIndex.disableReason ||
+          'Code index is disabled because the SQLite driver could not be loaded. The server will continue without the symbol index.',
+        remediation:
+          'Install native build tools (python3, make, g++) in this environment and run "npm rebuild better-sqlite3 --build-from-source", then restart the server.'
+      };
+    }
     const buildInProgress = latestBuildJob?.status === 'running';
     if (!ready && !buildInProgress) {
       return {