@akiojin/unity-mcp-server 2.41.7 → 2.42.0

package/src/handlers/script/ScriptSymbolFindToolHandler.js

@@ -1,7 +1,6 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import { CodeIndex } from '../../core/codeIndex.js';
-import { LspRpcClient } from '../../lsp/LspRpcClient.js';
-import { ProjectInfoProvider } from '../../core/projectInfo.js';
+import { JobManager } from '../../core/jobManager.js';
 
 export class ScriptSymbolFindToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
@@ -36,8 +35,7 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
     );
     this.unityConnection = unityConnection;
     this.index = new CodeIndex(unityConnection);
-    this.projectInfo = new ProjectInfoProvider(unityConnection);
-    this.lsp = null;
+    this.jobManager = JobManager.getInstance();
   }
 
   validate(params) {
@@ -52,52 +50,72 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
 
   async execute(params) {
     const { name, kind, scope = 'assets', exact = false } = params;
-    // Prefer persistent index if available
-    let results = [];
-    if (await this.index.isReady()) {
-      const rows = await this.index.querySymbols({ name, kind, scope, exact });
-      results = rows.map(r => ({
-        // Index returns project-relative paths already
-        path: (r.path || '').replace(/\\\\/g, '/'),
-        symbol: {
-          name: r.name,
-          kind: r.kind,
-          namespace: r.ns,
-          container: r.container,
-          startLine: r.line,
-          startColumn: r.column,
-          endLine: r.line,
-          endColumn: r.column
-        }
-      }));
-    } else {
-      const info = await this.projectInfo.get();
-      if (!this.lsp) this.lsp = new LspRpcClient(info.projectRoot);
-      const resp = await this.lsp.request('workspace/symbol', { query: String(name) });
-      const arr = resp?.result || [];
-      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;
+
+    // Check if code index is ready - no fallback to LSP
+    const ready = await this.index.isReady();
+    if (this.index.disabled) {
+      return {
+        success: false,
+        error: 'code_index_unavailable',
+        message:
+          this.index.disableReason ||
+          'Code index is disabled because the SQLite driver could not be loaded.',
+        remediation:
+          'Install native build tools and run "npm rebuild better-sqlite3 --build-from-source", then restart the server.'
+      };
+    }
+
+    if (!ready) {
+      // Check if a build job is currently running
+      const allJobs = this.jobManager.getAllJobs();
+      const buildJob = allJobs.find(
+        job =>
+          (job.id.startsWith('build-') || job.id.startsWith('watcher-')) && job.status === 'running'
+      );
+
+      if (buildJob) {
+        const progress = buildJob.progress || {};
+        const pct =
+          progress.total > 0 ? Math.round((progress.processed / progress.total) * 100) : 0;
         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
+          success: false,
+          error: 'index_building',
+          message: `Code index is currently being built. Please wait and retry. Progress: ${pct}% (${progress.processed || 0}/${progress.total || 0})`,
+          jobId: buildJob.id,
+          progress: {
+            processed: progress.processed || 0,
+            total: progress.total || 0,
+            percentage: pct
           }
         };
-      });
+      }
+
+      // No build job running - index not available
+      return {
+        success: false,
+        error: 'index_not_ready',
+        message:
+          'Code index is not built. Run code_index_build first, or wait for auto-build to complete on server startup.',
+        hint: 'Use code_index_status to check index state, or code_index_build to start a build manually.'
+      };
     }
+
+    // DB index is ready - use it
+    const rows = await this.index.querySymbols({ name, kind, scope, exact });
+    let results = rows.map(r => ({
+      // Index returns project-relative paths already
+      path: (r.path || '').replace(/\\\\/g, '/'),
+      symbol: {
+        name: r.name,
+        kind: r.kind,
+        namespace: r.ns,
+        container: r.container,
+        startLine: r.line,
+        startColumn: r.column,
+        endLine: r.line,
+        endColumn: r.column
+      }
+    }));
     // Optional post-filtering: scope and exact name
     if (scope && scope !== 'all') {
       results = results.filter(x => {
@@ -120,23 +138,4 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
     }
     return { success: true, results, total: results.length };
   }
-
-  mapKind(k) {
-    switch (k) {
-      case 5:
-        return 'class';
-      case 23:
-        return 'struct';
-      case 11:
-        return 'interface';
-      case 10:
-        return 'enum';
-      case 6:
-        return 'method';
-      case 7:
-        return 'property';
-      case 8:
-        return 'field';
-    }
-  }
 }

package/src/handlers/script/ScriptSymbolsGetToolHandler.js

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 import { ProjectInfoProvider } from '../../core/projectInfo.js';
+import { LspRpcClientSingleton } from '../../lsp/LspRpcClientSingleton.js';
 
 export class ScriptSymbolsGetToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
@@ -55,8 +56,7 @@ export class ScriptSymbolsGetToolHandler extends BaseToolHandler {
       const abs = path.join(info.projectRoot, relPath);
       const st = await fs.stat(abs).catch(() => null);
       if (!st || !st.isFile()) return { error: 'File not found', path: relPath };
-      const { LspRpcClient } = await import('../../lsp/LspRpcClient.js');
-      const lsp = new LspRpcClient(info.projectRoot);
+      const lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
       const uri = 'file://' + abs.replace(/\\\\/g, '/');
       const res = await lsp.request('textDocument/documentSymbol', { textDocument: { uri } });
       const docSymbols = res?.result ?? res ?? [];

package/src/lsp/LspProcessManager.js

@@ -51,6 +51,15 @@ export class LspProcessManager {
     if (!this.state.proc || this.state.proc.killed) return;
     const p = this.state.proc;
     this.state.proc = null;
+
+    // Remove all listeners to prevent memory leaks
+    try {
+      if (p.stdout) p.stdout.removeAllListeners();
+      if (p.stderr) p.stderr.removeAllListeners();
+      p.removeAllListeners('error');
+      p.removeAllListeners('close');
+    } catch {}
+
     try {
       // Send LSP shutdown/exit if possible
       const shutdown = obj => {

package/src/lsp/LspRpcClient.js

@@ -67,12 +67,19 @@ export class LspRpcClient {
     if (!this.proc || this.proc.killed) {
       throw new Error('LSP process not available');
     }
+    // Check if stdin is still writable
+    if (!this.proc.stdin || this.proc.stdin.destroyed || this.proc.stdin.writableEnded) {
+      throw new Error('LSP stdin not writable');
+    }
     const json = JSON.stringify(obj);
     const payload = `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`;
     try {
       this.proc.stdin.write(payload, 'utf8');
     } catch (e) {
       logger.error(`[csharp-lsp] writeMessage failed: ${e.message}`);
+      // Mark process as unavailable to prevent further writes
+      this.proc = null;
+      this.initialized = false;
       throw e;
     }
   }

package/src/lsp/LspRpcClientSingleton.js

@@ -0,0 +1,98 @@
+import { LspRpcClient } from './LspRpcClient.js';
+import { logger } from '../core/config.js';
+
+/**
+ * Singleton manager for LspRpcClient instances.
+ * Maintains one client per projectRoot to enable process reuse and improve performance.
+ */
+
+let instance = null;
+let currentProjectRoot = null;
+let heartbeatTimer = null;
+
+export class LspRpcClientSingleton {
+  /**
+   * Get or create a shared LspRpcClient instance.
+   * @param {string} projectRoot - Project root path
+   * @returns {Promise<LspRpcClient>} Shared client instance
+   */
+  static async getInstance(projectRoot) {
+    // If projectRoot changed, reset the instance
+    if (instance && currentProjectRoot !== projectRoot) {
+      logger.info('[LspRpcClientSingleton] projectRoot changed, resetting instance');
+      await LspRpcClientSingleton.reset();
+    }
+
+    if (!instance) {
+      instance = new LspRpcClient(projectRoot);
+      currentProjectRoot = projectRoot;
+      logger.info(`[LspRpcClientSingleton] created new instance for ${projectRoot}`);
+      LspRpcClientSingleton.#startHeartbeat();
+    }
+
+    return instance;
+  }
+
+  /**
+   * Reset the singleton instance and stop the process.
+   */
+  static async reset() {
+    LspRpcClientSingleton.#stopHeartbeat();
+    if (instance) {
+      try {
+        await instance.mgr.stop();
+      } catch (e) {
+        logger.warn(`[LspRpcClientSingleton] error stopping: ${e.message}`);
+      }
+      instance = null;
+      currentProjectRoot = null;
+      logger.info('[LspRpcClientSingleton] instance reset');
+    }
+  }
+
+  /**
+   * Start heartbeat monitoring to detect dead processes.
+   */
+  static #startHeartbeat() {
+    if (heartbeatTimer) return;
+    heartbeatTimer = setInterval(async () => {
+      if (!instance) return;
+      // Check if process is still alive before attempting heartbeat
+      if (!instance.proc || instance.proc.killed) {
+        logger.warn('[LspRpcClientSingleton] process dead, resetting...');
+        instance = null;
+        currentProjectRoot = null;
+        LspRpcClientSingleton.#stopHeartbeat();
+        return;
+      }
+      try {
+        // Use workspace/symbol with empty query as a lightweight ping
+        await instance.request('workspace/symbol', { query: '' });
+      } catch (e) {
+        logger.warn(`[LspRpcClientSingleton] heartbeat failed: ${e.message}, resetting...`);
+        // Process is dead, reset instance for next request
+        instance = null;
+        currentProjectRoot = null;
+        LspRpcClientSingleton.#stopHeartbeat();
+      }
+    }, 30000); // 30 seconds
+  }
+
+  /**
+   * Stop heartbeat monitoring.
+   */
+  static #stopHeartbeat() {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+
+  /**
+   * Check if an instance exists.
+   * @returns {boolean}
+   */
+  static hasInstance() {
+    return instance !== null;
+  }
+}

package/src/core/codeIndexDb.js

@@ -1,112 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import Database from 'better-sqlite3';
-let dbCache = new Map();
-
-function getDbPath(projectRoot) {
-  const dir = path.join(projectRoot, 'Library', 'UnityMCP', 'CodeIndex');
-  fs.mkdirSync(dir, { recursive: true });
-  return path.join(dir, 'index.db');
-}
-
-export function openDb(projectRoot) {
-  const key = path.resolve(projectRoot);
-  if (dbCache.has(key)) return dbCache.get(key);
-  const dbPath = getDbPath(projectRoot);
-  const db = new Database(dbPath);
-  db.pragma('journal_mode = WAL');
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS files (
-      path TEXT PRIMARY KEY,
-      mtime INTEGER NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS symbols (
-      path TEXT NOT NULL,
-      name TEXT NOT NULL,
-      kind TEXT,
-      container TEXT,
-      ns TEXT,
-      line INTEGER,
-      column INTEGER,
-      FOREIGN KEY(path) REFERENCES files(path)
-    );
-    CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
-    CREATE TABLE IF NOT EXISTS refs (
-      path TEXT NOT NULL,
-      name TEXT NOT NULL,
-      line INTEGER,
-      snippet TEXT,
-      FOREIGN KEY(path) REFERENCES files(path)
-    );
-    CREATE INDEX IF NOT EXISTS idx_refs_name ON refs(name);
-  `);
-  dbCache.set(key, db);
-  return db;
-}
-
-export function upsertFile(db, filePath, mtimeMs) {
-  const stmt = db.prepare(
-    'INSERT INTO files(path, mtime) VALUES(?, ?) ON CONFLICT(path) DO UPDATE SET mtime=excluded.mtime'
-  );
-  stmt.run(filePath, Math.floor(mtimeMs));
-}
-
-export function replaceSymbols(db, filePath, symbols) {
-  const del = db.prepare('DELETE FROM symbols WHERE path = ?');
-  del.run(filePath);
-  const ins = db.prepare(
-    'INSERT INTO symbols(path, name, kind, container, ns, line, column) VALUES(?,?,?,?,?,?,?)'
-  );
-  const tr = db.transaction(rows => {
-    for (const s of rows)
-      ins.run(
-        filePath,
-        s.name || '',
-        s.kind || '',
-        s.container || null,
-        s.ns || null,
-        s.line || 0,
-        s.column || 0
-      );
-  });
-  tr(symbols || []);
-}
-
-export function replaceReferences(db, filePath, refs) {
-  const del = db.prepare('DELETE FROM refs WHERE path = ?');
-  del.run(filePath);
-  const ins = db.prepare('INSERT INTO refs(path, name, line, snippet) VALUES(?,?,?,?)');
-  const tr = db.transaction(rows => {
-    for (const r of rows) ins.run(filePath, r.name || '', r.line || 0, r.snippet || null);
-  });
-  tr(refs || []);
-}
-
-export function querySymbolsByName(db, name, kind = null) {
-  if (kind) {
-    return db
-      .prepare(
-        'SELECT path,name,kind,container,ns,line,column FROM symbols WHERE name = ? AND kind = ? LIMIT 500'
-      )
-      .all(name, kind);
-  }
-  return db
-    .prepare('SELECT path,name,kind,container,ns,line,column FROM symbols WHERE name = ? LIMIT 500')
-    .all(name);
-}
-
-export function queryRefsByName(db, name) {
-  return db.prepare('SELECT path,name,line,snippet FROM refs WHERE name = ? LIMIT 1000').all(name);
-}
-
-export function isFresh(projectRoot, filePath, db) {
-  try {
-    const row = db.prepare('SELECT mtime FROM files WHERE path = ?').get(filePath);
-    if (!row) return false;
-    const abs = path.join(projectRoot, filePath);
-    const st = fs.statSync(abs);
-    return Math.floor(st.mtimeMs) === row.mtime;
-  } catch {
-    return false;
-  }
-}

package/src/core/sqliteFallback.js

@@ -1,82 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-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) {
-  // Use Node's module resolution to find sql.js regardless of package manager (npm, pnpm, yarn)
-  // require.resolve('sql.js') returns the main entry point (dist/sql-wasm.js)
-  // so we just need sql-wasm.wasm in the same directory
-  const require = createRequire(import.meta.url);
-  const sqlJsPath = require.resolve('sql.js');
-  const sqlJsDir = path.dirname(sqlJsPath);
-  const wasmPath = path.resolve(sqlJsDir, '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
-  };
-}