@akiojin/unity-mcp-server 2.41.7 → 2.42.0

package/src/core/indexWatcher.js

@@ -1,5 +1,6 @@
 import { logger, config } from './config.js';
 import { JobManager } from './jobManager.js';
+import { getWorkerPool } from './indexBuildWorkerPool.js';
 
 export class IndexWatcher {
   constructor(unityConnection) {
@@ -8,19 +9,32 @@ export class IndexWatcher {
     this.running = false;
     this.jobManager = JobManager.getInstance();
     this.currentWatcherJobId = null;
+    this.workerPool = getWorkerPool();
+    // FR-061: Use Worker Thread for watcher builds
+    this.useWorkerThread = true;
   }
 
   start() {
     if (!config.indexing?.watch) return;
     if (this.timer) return;
     const interval = Math.max(2000, Number(config.indexing.intervalMs || 15000));
-    logger.info(`[index] watcher enabled (interval=${interval}ms)`);
-    this.timer = setInterval(() => this.tick(), interval);
-    if (typeof this.timer.unref === 'function') {
-      this.timer.unref();
+    // Initial delay: wait longer to allow MCP server to fully initialize
+    // and first tool calls to complete before starting background indexing
+    const initialDelay = Math.max(30000, Number(config.indexing.initialDelayMs || 30000));
+    logger.info(`[index] watcher enabled (interval=${interval}ms, initialDelay=${initialDelay}ms)`);
+
+    // Delay initial tick significantly to avoid blocking MCP server initialization
+    const delayedStart = setTimeout(() => {
+      this.tick();
+      // Start periodic timer only after first tick
+      this.timer = setInterval(() => this.tick(), interval);
+      if (typeof this.timer.unref === 'function') {
+        this.timer.unref();
+      }
+    }, initialDelay);
+    if (typeof delayedStart.unref === 'function') {
+      delayedStart.unref();
     }
-    // Initial kick
-    this.tick();
   }
 
   stop() {
@@ -60,21 +74,10 @@ export class IndexWatcher {
         const jobId = `watcher-rebuild-${Date.now()}`;
         this.currentWatcherJobId = jobId;
 
-        const { CodeIndexBuildToolHandler } = await import(
-          '../handlers/script/CodeIndexBuildToolHandler.js'
-        );
-        const handler = new CodeIndexBuildToolHandler(this.unityConnection);
-
-        this.jobManager.create(jobId, async job => {
-          const params = {
-            concurrency: config.indexing.concurrency || 8,
-            retry: config.indexing.retry || 2,
-            reportPercentage: 10
-          };
-          return await handler._executeBuild(params, job);
-        });
-
-        logger.info(`[index] watcher: started DB rebuild job ${jobId}`);
+        // FR-061: Use Worker Thread for non-blocking builds
+        await this._startWorkerBuild(jobId, info, dbPath);
+
+        logger.info(`[index] watcher: started DB rebuild job ${jobId} (Worker Thread)`);
         this._monitorJob(jobId);
         return;
       }
@@ -105,22 +108,10 @@ export class IndexWatcher {
       const jobId = `watcher-${Date.now()}`;
       this.currentWatcherJobId = jobId;
 
-      const { CodeIndexBuildToolHandler } = await import(
-        '../handlers/script/CodeIndexBuildToolHandler.js'
-      );
-      const handler = new CodeIndexBuildToolHandler(this.unityConnection);
-
-      // Create the build job through JobManager
-      this.jobManager.create(jobId, async job => {
-        const params = {
-          concurrency: config.indexing.concurrency || 8,
-          retry: config.indexing.retry || 2,
-          reportEvery: config.indexing.reportEvery || 500
-        };
-        return await handler._executeBuild(params, job);
-      });
+      // FR-061: Use Worker Thread for non-blocking builds
+      await this._startWorkerBuild(jobId, info, dbPath);
 
-      logger.info(`[index] watcher: started auto-build job ${jobId}`);
+      logger.info(`[index] watcher: started auto-build job ${jobId} (Worker Thread)`);
 
       // Monitor job completion in background
       // (Job result will be logged when it completes/fails)
@@ -132,6 +123,37 @@ export class IndexWatcher {
     }
   }
 
+  /**
+   * Start a build using Worker Thread pool
+   * @param {string} jobId - Job ID for tracking
+   * @param {Object} info - Project info
+   * @param {string} dbPath - Database file path
+   * @private
+   */
+  async _startWorkerBuild(jobId, info, dbPath) {
+    // Create job in JobManager
+    this.jobManager.create(jobId, async job => {
+      // Initialize progress
+      job.progress = { processed: 0, total: 0, rate: 0 };
+
+      // Subscribe to progress updates from Worker
+      this.workerPool.onProgress(progress => {
+        job.progress = progress;
+      });
+
+      // Execute build in Worker Thread (non-blocking)
+      const result = await this.workerPool.executeBuild({
+        projectRoot: info.projectRoot,
+        dbPath: dbPath,
+        concurrency: config.indexing?.watcherConcurrency || 1,
+        retry: config.indexing?.retry || 2,
+        reportPercentage: 10
+      });
+
+      return result;
+    });
+  }
+
   /**
    * Monitor job completion for logging
    * @private

package/src/core/transports/HybridStdioServerTransport.js

@@ -124,7 +124,19 @@ export class HybridStdioServerTransport {
   }
 
   _readContentLengthMessage() {
-    const headerEndIndex = this._buffer.indexOf(HEADER_END);
+    const { headerEndIndex, separatorLength } = (() => {
+      const crlfIndex = this._buffer.indexOf('\r\n\r\n');
+      const lfIndex = this._buffer.indexOf('\n\n');
+
+      if (crlfIndex === -1 && lfIndex === -1) return { headerEndIndex: -1, separatorLength: 0 };
+      if (crlfIndex === -1) return { headerEndIndex: lfIndex, separatorLength: 2 };
+      if (lfIndex === -1) return { headerEndIndex: crlfIndex, separatorLength: 4 };
+
+      return crlfIndex < lfIndex
+        ? { headerEndIndex: crlfIndex, separatorLength: 4 }
+        : { headerEndIndex: lfIndex, separatorLength: 2 };
+    })();
+
     if (headerEndIndex === -1) {
       return null;
     }
@@ -132,20 +144,20 @@ export class HybridStdioServerTransport {
     const header = this._buffer.toString('utf8', 0, headerEndIndex);
     const match = header.match(HEADER_RE);
     if (!match) {
-      this._buffer = this._buffer.subarray(headerEndIndex + HEADER_END.length);
+      this._buffer = this._buffer.subarray(headerEndIndex + separatorLength);
       this.onerror?.(new Error('Invalid Content-Length header'));
       return null;
     }
 
     const length = Number(match[1]);
-    const totalMessageLength = headerEndIndex + HEADER_END.length + length;
+    const totalMessageLength = headerEndIndex + separatorLength + length;
     if (this._buffer.length < totalMessageLength) {
       return null;
     }
 
     const json = this._buffer.toString(
       'utf8',
-      headerEndIndex + HEADER_END.length,
+      headerEndIndex + separatorLength,
       totalMessageLength
     );
     this._buffer = this._buffer.subarray(totalMessageLength);

package/src/core/unityConnection.js

@@ -40,7 +40,8 @@ export class UnityConnection extends EventEmitter {
       }
 
       // Skip connection in CI/test environments
-      if (process.env.NODE_ENV === 'test' || process.env.CI === 'true') {
+      const isTestEnv = process.env.NODE_ENV === 'test' || process.env.CI === 'true';
+      if (isTestEnv && process.env.UNITY_MCP_ALLOW_TEST_CONNECT !== '1') {
         logger.info('Skipping Unity connection in test/CI environment');
         reject(new Error('Unity connection disabled in test environment'));
         return;
@@ -50,6 +51,9 @@ export class UnityConnection extends EventEmitter {
       logger.info(`Connecting to Unity at ${targetHost}:${config.unity.port}...`);
 
       this.socket = new net.Socket();
+      try {
+        this.socket.setKeepAlive(true, 5000);
+      } catch {}
       let connectionTimeout = null;
       let resolved = false;
       const settle = (fn, value) => {
@@ -79,6 +83,11 @@ export class UnityConnection extends EventEmitter {
         settle(resolve);
       });
 
+      this.socket.on('end', () => {
+        // Treat end as close to trigger reconnection
+        this.socket.destroy();
+      });
+
       this.socket.on('data', data => {
         this.handleData(data);
       });
@@ -97,6 +106,11 @@ export class UnityConnection extends EventEmitter {
           this.socket.destroy();
           this.isDisconnecting = false;
           reject(error);
+        } else if (this.connected) {
+          // Force close to trigger reconnect logic
+          try {
+            this.socket.destroy();
+          } catch {}
         }
       });
 
@@ -210,6 +224,19 @@ export class UnityConnection extends EventEmitter {
    * @param {Buffer} data
    */
   handleData(data) {
+    // Fast-path: accept single unframed JSON message (NDJSON style) from tests/clients
+    if (!this.messageBuffer.length) {
+      const asString = data.toString('utf8').trim();
+      if (asString.startsWith('{')) {
+        try {
+          const obj = JSON.parse(asString);
+          this._processResponseObject(obj);
+          return;
+        } catch {
+          // fall through to framed parsing
+        }
+      }
+    }
     // Check if this is an unframed Unity debug log
     if (data.length > 0 && !this.messageBuffer.length) {
       const dataStr = data.toString('utf8');
@@ -281,56 +308,7 @@ export class UnityConnection extends EventEmitter {
           logger.debug(`[Unity] Received framed message (length=${message.length})`);
 
           const response = JSON.parse(message);
-          logger.debug(
-            `[Unity] Parsed response id=${response.id || 'n/a'} status=${response.status || (response.success === false ? 'error' : 'success')}`
-          );
-
-          // Check if this is a response to a pending command
-          if (response.id && this.pendingCommands.has(response.id)) {
-            logger.info(`[Unity] Found pending command for ID ${response.id}`);
-            const pending = this.pendingCommands.get(response.id);
-            this.pendingCommands.delete(response.id);
-
-            // Handle both old and new response formats
-            if (response.status === 'success' || response.success === true) {
-              logger.info(`[Unity] Command ${response.id} succeeded`);
-
-              let result = response.result || response.data || {};
-
-              // If result is a string, try to parse it as JSON
-              if (typeof result === 'string') {
-                try {
-                  result = JSON.parse(result);
-                  logger.info(`[Unity] Parsed string result as JSON:`, result);
-                } catch (parseError) {
-                  logger.warn(`[Unity] Failed to parse result as JSON: ${parseError.message}`);
-                  // Keep the original string value
-                }
-              }
-
-              // Include version and editorState information if available
-              if (response.version) {
-                result._version = response.version;
-              }
-              if (response.editorState) {
-                result._editorState = response.editorState;
-              }
-
-              logger.info(`[Unity] Command ${response.id} resolved successfully`);
-              pending.resolve(result);
-            } else if (response.status === 'error' || response.success === false) {
-              logger.error(`[Unity] Command ${response.id} failed:`, response.error);
-              pending.reject(new Error(response.error || 'Command failed'));
-            } else {
-              // Unknown format
-              logger.warn(`[Unity] Command ${response.id} has unknown response format`);
-              pending.resolve(response);
-            }
-          } else {
-            // Handle unsolicited messages
-            logger.debug(`[Unity] Received unsolicited message id=${response.id || 'n/a'}`);
-            this.emit('message', response);
-          }
+          this._processResponseObject(response);
         } catch (error) {
           logger.error('[Unity] Failed to parse response:', error.message);
           logger.debug(`[Unity] Raw message: ${messageData.toString().substring(0, 200)}...`);
@@ -438,6 +416,55 @@ export class UnityConnection extends EventEmitter {
     });
   }
 
+  _processResponseObject(response) {
+    logger.debug(
+      `[Unity] Parsed response id=${response?.id || 'n/a'} status=${response?.status || (response?.success === false ? 'error' : 'success')}`
+    );
+
+    const id = response?.id != null ? String(response.id) : null;
+
+    const hasExplicitPending = id && this.pendingCommands.has(id);
+    const fallbackPendingId =
+      !hasExplicitPending && this.pendingCommands.size > 0
+        ? this.pendingCommands.keys().next().value
+        : null;
+
+    if (hasExplicitPending || fallbackPendingId) {
+      const targetId = hasExplicitPending ? id : fallbackPendingId;
+      const pending = this.pendingCommands.get(targetId);
+      this.pendingCommands.delete(targetId);
+
+      if (response.status === 'success' || response.success === true) {
+        let result = response.result || response.data || {};
+        if (typeof result === 'string') {
+          try {
+            result = JSON.parse(result);
+            logger.info(`[Unity] Parsed string result as JSON:`, result);
+          } catch (parseError) {
+            logger.warn(`[Unity] Failed to parse result as JSON: ${parseError.message}`);
+          }
+        }
+        if (response.version) result._version = response.version;
+        if (response.editorState) result._editorState = response.editorState;
+        logger.info(`[Unity] Command ${targetId} resolved successfully`);
+        pending.resolve(result);
+      } else if (response.status === 'error' || response.success === false) {
+        logger.error(`[Unity] Command ${targetId} failed:`, response.error);
+        const err = new Error(response.error || 'Command failed');
+        err.code = response.code;
+        pending.reject(err);
+      } else {
+        logger.warn(`[Unity] Command ${targetId} has unknown response format`);
+        pending.resolve(response);
+      }
+      return;
+    }
+
+    // Unsolicited message
+    logger.debug(`[Unity] Received unsolicited message id=${response?.id || 'n/a'}`);
+    this.emit('message', response);
+  }
+
   /**
    * Sends a ping command to Unity
    * @returns {Promise<any>}