@akiojin/unity-mcp-server 2.45.4 → 2.46.0

package/src/core/workers/indexBuildWorker.js

@@ -9,11 +9,16 @@
  * Communication with main thread:
  * - Receives: workerData with build options
  * - Sends: progress updates, completion, errors, logs
+ *
+ * IMPORTANT: This worker uses an inline LSP client implementation to avoid
+ * importing main thread modules that may not work correctly in Worker Threads.
  */
 
 import { parentPort, workerData } from 'worker_threads';
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import { fileURLToPath } from 'url';
 
 // fast-sql helper: run SQL statement
@@ -123,6 +128,217 @@ function makeSig(abs) {
   }
 }
 
+// ============================================================================
+// Worker-local LSP Client Implementation
+// ============================================================================
+// This is an inline implementation specifically for Worker Threads.
+// It does NOT share state with main thread and manages its own LSP process.
+
+/**
+ * Detect runtime identifier for csharp-lsp binary
+ */
+function detectRid() {
+  if (process.platform === 'win32') return process.arch === 'arm64' ? 'win-arm64' : 'win-x64';
+  if (process.platform === 'darwin') return process.arch === 'arm64' ? 'osx-arm64' : 'osx-x64';
+  return process.arch === 'arm64' ? 'linux-arm64' : 'linux-x64';
+}
+
+/**
+ * Get csharp-lsp executable name
+ */
+function getExecutableName() {
+  return process.platform === 'win32' ? 'server.exe' : 'server';
+}
+
+/**
+ * Find csharp-lsp binary path
+ */
+function findLspBinary() {
+  const rid = detectRid();
+  const exe = getExecutableName();
+
+  // Single location: ~/.unity/tools/csharp-lsp/<rid>/server
+  const candidates = [path.join(os.homedir(), '.unity', 'tools', 'csharp-lsp', rid, exe)];
+
+  for (const p of candidates) {
+    try {
+      const resolved = path.resolve(p);
+      if (fs.existsSync(resolved)) {
+        return resolved;
+      }
+    } catch {
+      // Ignore
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Worker-local LSP client class
+ * Manages its own csharp-lsp process independently from main thread
+ */
+class WorkerLspClient {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.proc = null;
+    this.seq = 1;
+    this.pending = new Map();
+    this.buf = Buffer.alloc(0);
+    this.initialized = false;
+  }
+
+  async start() {
+    const binPath = findLspBinary();
+    if (!binPath) {
+      throw new Error(
+        `csharp-lsp binary not found. Expected at ~/.unity/tools/csharp-lsp/${detectRid()}/${getExecutableName()}`
+      );
+    }
+
+    log('info', `[worker-lsp] Starting LSP: ${binPath}`);
+
+    this.proc = spawn(binPath, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+    this.proc.on('error', e => {
+      log('error', `[worker-lsp] Process error: ${e.message}`);
+    });
+
+    this.proc.on('close', (code, sig) => {
+      log('info', `[worker-lsp] Process exited: code=${code}, signal=${sig || 'none'}`);
+      // Reject all pending requests
+      for (const [id, p] of this.pending.entries()) {
+        p.reject(new Error('LSP process exited'));
+        this.pending.delete(id);
+      }
+      this.proc = null;
+      this.initialized = false;
+    });
+
+    this.proc.stderr.on('data', d => {
+      const s = String(d || '').trim();
+      if (s) log('debug', `[worker-lsp] stderr: ${s}`);
+    });
+
+    this.proc.stdout.on('data', chunk => this._onData(chunk));
+
+    // Initialize LSP
+    await this._initialize();
+    this.initialized = true;
+    log('info', `[worker-lsp] Initialized successfully`);
+  }
+
+  _onData(chunk) {
+    this.buf = Buffer.concat([this.buf, Buffer.from(chunk)]);
+    while (true) {
+      const headerEnd = this.buf.indexOf('\r\n\r\n');
+      if (headerEnd < 0) break;
+      const header = this.buf.slice(0, headerEnd).toString('utf8');
+      const m = header.match(/Content-Length:\s*(\d+)/i);
+      const len = m ? parseInt(m[1], 10) : 0;
+      const total = headerEnd + 4 + len;
+      if (this.buf.length < total) break;
+      const jsonBuf = this.buf.slice(headerEnd + 4, total);
+      this.buf = this.buf.slice(total);
+      try {
+        const msg = JSON.parse(jsonBuf.toString('utf8'));
+        if (msg.id && this.pending.has(msg.id)) {
+          this.pending.get(msg.id).resolve(msg);
+          this.pending.delete(msg.id);
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+
+  _writeMessage(obj) {
+    if (!this.proc || this.proc.killed) {
+      throw new Error('LSP process not available');
+    }
+    const json = JSON.stringify(obj);
+    const payload = `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`;
+    this.proc.stdin.write(payload, 'utf8');
+  }
+
+  async _initialize() {
+    const id = this.seq++;
+    const req = {
+      jsonrpc: '2.0',
+      id,
+      method: 'initialize',
+      params: {
+        processId: process.pid,
+        rootUri: 'file://' + String(this.projectRoot).replace(/\\/g, '/'),
+        capabilities: {},
+        workspaceFolders: null
+      }
+    };
+
+    const timeoutMs = 60000;
+    const p = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`initialize timed out after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+    });
+
+    this._writeMessage(req);
+    await p;
+
+    // Send initialized notification
+    this._writeMessage({ jsonrpc: '2.0', method: 'initialized', params: {} });
+  }
+
+  async request(method, params) {
+    if (!this.proc || this.proc.killed) {
+      throw new Error('LSP process not available');
+    }
+
+    const id = this.seq++;
+    const timeoutMs = 30000;
+
+    const p = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+    });
+
+    this._writeMessage({ jsonrpc: '2.0', id, method, params });
+    const resp = await p;
+    return resp?.result ?? resp;
+  }
+
+  stop() {
+    if (this.proc && !this.proc.killed) {
+      try {
+        // Send shutdown/exit
+        this._writeMessage({ jsonrpc: '2.0', id: this.seq++, method: 'shutdown', params: {} });
+        this._writeMessage({ jsonrpc: '2.0', method: 'exit' });
+        this.proc.stdin.end();
+      } catch {
+        // Ignore
+      }
+      setTimeout(() => {
+        if (this.proc && !this.proc.killed) {
+          this.proc.kill('SIGTERM');
+        }
+      }, 1000);
+    }
+  }
+}
+
+// ============================================================================
+// End Worker-local LSP Client
+// ============================================================================
+
 /**
  * Convert LSP symbol kind to string
  */
@@ -291,15 +507,23 @@ async function runBuild() {
 
     log('info', `[worker] Changes: ${changed.length} to update, ${removed.length} to remove`);
 
-    // Remove vanished files
-    for (const rel of removed) {
-      const stmt1 = db.prepare('DELETE FROM symbols WHERE path = ?');
-      stmt1.run([rel]);
-      stmt1.free();
-
-      const stmt2 = db.prepare('DELETE FROM files WHERE path = ?');
-      stmt2.run([rel]);
-      stmt2.free();
+    // Remove vanished files - optimized batch delete (Phase 2.2)
+    if (removed.length > 0) {
+      // SQLite has a limit on compound expressions, batch in groups of 500
+      const BATCH_SIZE = 500;
+      for (let i = 0; i < removed.length; i += BATCH_SIZE) {
+        const batch = removed.slice(i, i + BATCH_SIZE);
+        const placeholders = batch.map(() => '?').join(',');
+
+        const stmt1 = db.prepare(`DELETE FROM symbols WHERE path IN (${placeholders})`);
+        stmt1.run(batch);
+        stmt1.free();
+
+        const stmt2 = db.prepare(`DELETE FROM files WHERE path IN (${placeholders})`);
+        stmt2.run(batch);
+        stmt2.free();
+      }
+      log('info', `[worker] Removed ${removed.length} files in batches`);
     }
 
     // Prepare for updates
@@ -309,14 +533,12 @@ async function runBuild() {
     let updated = 0;
     let lastReportedPercentage = 0;
 
-    // Initialize LSP connection
-    // Note: LspRpcClientSingleton is in src/lsp/, not src/core/lsp/
-    let lsp = null;
+    // Initialize Worker-local LSP client
+    // This is independent from main thread's LspRpcClientSingleton
+    const lsp = new WorkerLspClient(projectRoot);
     try {
-      const lspModulePath = path.join(__dirname, '..', '..', 'lsp', 'LspRpcClientSingleton.js');
-      const { LspRpcClientSingleton } = await import(`file://${lspModulePath}`);
-      lsp = await LspRpcClientSingleton.getInstance(projectRoot);
-      log('info', `[worker] LSP initialized`);
+      await lsp.start();
+      log('info', `[worker] Worker-local LSP initialized`);
     } catch (e) {
       throw new Error(`LSP initialization failed: ${e.message}`);
     }
@@ -327,7 +549,7 @@ async function runBuild() {
       for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
           const res = await lsp.request('textDocument/documentSymbol', { textDocument: { uri } });
-          return res?.result ?? res;
+          return res;
         } catch (err) {
           lastErr = err;
           await new Promise(r => setTimeout(r, 200 * (attempt + 1)));
@@ -336,7 +558,57 @@ async function runBuild() {
       throw lastErr || new Error('documentSymbol failed');
     };
 
-    // Process files sequentially (concurrency=1 for non-blocking)
+    // Phase 2.1 & 2.3: Process files with batched transactions
+    // Collect LSP results, then write in batched transactions to reduce overhead
+    const TX_BATCH_SIZE = 100; // Files per transaction
+    let pendingWrites = []; // { rel, rows, sig }
+
+    const flushPendingWrites = () => {
+      if (pendingWrites.length === 0) return;
+
+      runSQL(db, 'BEGIN TRANSACTION');
+      try {
+        // Batch delete old symbols for all pending files
+        const pathsToDelete = pendingWrites.map(w => w.rel);
+        const delPlaceholders = pathsToDelete.map(() => '?').join(',');
+        const delStmt = db.prepare(`DELETE FROM symbols WHERE path IN (${delPlaceholders})`);
+        delStmt.run(pathsToDelete);
+        delStmt.free();
+
+        // Batch insert all symbols
+        const insertStmt = db.prepare(
+          'INSERT INTO symbols(path,name,kind,container,namespace,line,column) VALUES (?,?,?,?,?,?,?)'
+        );
+        for (const { rows } of pendingWrites) {
+          for (const r of rows) {
+            insertStmt.run([r.path, r.name, r.kind, r.container, r.ns, r.line, r.column]);
+          }
+        }
+        insertStmt.free();
+
+        // Batch update file signatures
+        const fileStmt = db.prepare('REPLACE INTO files(path,sig,updatedAt) VALUES (?,?,?)');
+        const now = new Date().toISOString();
+        for (const { rel, sig } of pendingWrites) {
+          fileStmt.run([rel, sig, now]);
+        }
+        fileStmt.free();
+
+        // Update meta once per batch
+        const metaStmt = db.prepare("REPLACE INTO meta(key,value) VALUES ('lastIndexedAt',?)");
+        metaStmt.run([now]);
+        metaStmt.free();
+
+        runSQL(db, 'COMMIT');
+        updated += pendingWrites.length;
+      } catch (txErr) {
+        runSQL(db, 'ROLLBACK');
+        log('error', `[worker] Batch write failed: ${txErr.message}`);
+      }
+      pendingWrites = [];
+    };
+
+    // Process files sequentially (LSP requests), batch DB writes
     for (let i = 0; i < absList.length; i++) {
       const abs = absList[i];
       const rel = toRel(abs, projectRoot);
@@ -346,36 +618,13 @@ async function runBuild() {
         const docSymbols = await requestWithRetry(uri);
         const rows = toRows(uri, docSymbols, projectRoot);
 
-        // Update database in transaction
-        runSQL(db, 'BEGIN TRANSACTION');
-        try {
-          const delStmt = db.prepare('DELETE FROM symbols WHERE path = ?');
-          delStmt.run([rel]);
-          delStmt.free();
-
-          const insertStmt = db.prepare(
-            'INSERT INTO symbols(path,name,kind,container,namespace,line,column) VALUES (?,?,?,?,?,?,?)'
-          );
-          for (const r of rows) {
-            insertStmt.run([r.path, r.name, r.kind, r.container, r.ns, r.line, r.column]);
-          }
-          insertStmt.free();
-
-          const fileStmt = db.prepare('REPLACE INTO files(path,sig,updatedAt) VALUES (?,?,?)');
-          fileStmt.run([rel, wanted.get(rel), new Date().toISOString()]);
-          fileStmt.free();
-
-          const metaStmt = db.prepare("REPLACE INTO meta(key,value) VALUES ('lastIndexedAt',?)");
-          metaStmt.run([new Date().toISOString()]);
-          metaStmt.free();
+        // Queue for batch write
+        pendingWrites.push({ rel, rows, sig: wanted.get(rel) });
 
-          runSQL(db, 'COMMIT');
-        } catch (txErr) {
-          runSQL(db, 'ROLLBACK');
-          throw txErr;
+        // Flush when batch is full
+        if (pendingWrites.length >= TX_BATCH_SIZE) {
+          flushPendingWrites();
         }
-
-        updated++;
       } catch (err) {
         // Log occasionally to avoid spam
         if (processed % 50 === 0) {
@@ -408,6 +657,12 @@ async function runBuild() {
       }
     }
 
+    // Flush remaining pending writes
+    flushPendingWrites();
+
+    // Stop LSP process
+    lsp.stop();
+
     // Save database to file
     saveDatabase(db, dbPath);
 

package/src/handlers/script/CodeIndexBuildToolHandler.js

@@ -8,7 +8,7 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'code_index_build',
-      'Build (or rebuild) the persistent SQLite symbol index by scanning document symbols via the C# LSP. Returns immediately with jobId for background execution. Check progress with code_index_status. Stores DB under .unity/cache/code-index/code-index.db.',
+      '[OFFLINE] No Unity connection required. Build (or rebuild) the persistent SQLite symbol index by scanning document symbols via the C# LSP. Returns immediately with jobId for background execution. Check progress with code_index_status. Stores DB under .unity/cache/code-index/code-index.db.',
       {
         type: 'object',
         properties: {

package/src/handlers/script/CodeIndexStatusToolHandler.js

@@ -6,7 +6,7 @@ export class CodeIndexStatusToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'code_index_status',
-      'Report code index status and readiness for symbol/search operations. BEST PRACTICES: Check before heavy symbol operations. Shows total files indexed and coverage percentage. If coverage is low, some symbol operations may be incomplete. Index is automatically built on first use. No parameters needed - lightweight status check.',
+      '[OFFLINE] No Unity connection required. Report code index status and readiness for symbol/search operations. BEST PRACTICES: Check before heavy symbol operations. Shows total files indexed and coverage percentage. If coverage is low, some symbol operations may be incomplete. Index is automatically built on first use. No parameters needed - lightweight status check.',
       {
         type: 'object',
         properties: {},

package/src/handlers/script/CodeIndexUpdateToolHandler.js

@@ -17,7 +17,7 @@ export class CodeIndexUpdateToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'code_index_update',
-      'Refresh code index entries for specific C# files. Use this after modifying files so script editing tools see the latest symbols.',
+      '[OFFLINE] No Unity connection required. Refresh code index entries for specific C# files. Use this after modifying files so script editing tools see the latest symbols.',
       {
         type: 'object',
         properties: {

package/src/handlers/script/ScriptPackagesListToolHandler.js

@@ -8,7 +8,7 @@ export class ScriptPackagesListToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'script_packages_list',
-      'List Unity packages in the project (optionally include built‑in). BEST PRACTICES: Use to discover available packages and their paths. Set includeBuiltIn=false to see only user packages. Returns package IDs, versions, and resolved paths. Embedded packages can be edited directly. Essential for understanding project dependencies.',
+      '[OFFLINE] No Unity connection required. List Unity packages in the project (optionally include built‑in). BEST PRACTICES: Use to discover available packages and their paths. Set includeBuiltIn=false to see only user packages. Returns package IDs, versions, and resolved paths. Embedded packages can be edited directly. Essential for understanding project dependencies.',
       {
         type: 'object',
         properties: {

package/src/handlers/script/ScriptReadToolHandler.js

@@ -7,7 +7,7 @@ export class ScriptReadToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'script_read',
-      'Read a C# file with optional line range and payload limits. Files must be under Assets/ or Packages/ and have .cs extension. PRIORITY: Read minimally — locate the target with script_symbols_get and read only the signature area (~30–40 lines). For large files, always pass startLine/endLine and (optionally) maxBytes.',
+      '[OFFLINE] No Unity connection required. Read a C# file with optional line range and payload limits. Files must be under Assets/ or Packages/ and have .cs extension. PRIORITY: Read minimally — locate the target with script_symbols_get and read only the signature area (~30–40 lines). For large files, always pass startLine/endLine and (optionally) maxBytes.',
       {
         type: 'object',
         properties: {
@@ -79,7 +79,14 @@ export class ScriptReadToolHandler extends BaseToolHandler {
 
       const abs = info.projectRoot + '/' + norm;
       const stat = await fs.stat(abs).catch(() => null);
-      if (!stat || !stat.isFile()) return { error: 'File not found', path: norm };
+      if (!stat || !stat.isFile()) {
+        return {
+          error: 'File not found',
+          path: norm,
+          resolvedPath: abs,
+          hint: `Verify the file exists at: ${abs}. Path must be relative to Unity project root (e.g., "Assets/Scripts/Foo.cs" or "Packages/com.example/Runtime/Bar.cs").`
+        };
+      }
 
       const data = await fs.readFile(abs, 'utf8');
       const lines = data.split('\n');