@akiojin/unity-mcp-server 2.14.14

package/src/core/config.js

@@ -0,0 +1,165 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Shallow merge utility (simple objects only)
+ */
+function merge(a, b) {
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b || {})) {
+    if (v && typeof v === 'object' && !Array.isArray(v) && a[k] && typeof a[k] === 'object') {
+      out[k] = { ...a[k], ...v };
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+/**
+ * Base configuration for Unity Editor MCP Server
+ */
+const baseConfig = {
+  // Unity connection settings
+  unity: {
+    host: process.env.UNITY_HOST || 'localhost',
+    port: parseInt(process.env.UNITY_PORT || '', 10) || 6400,
+    reconnectDelay: 1000,
+    maxReconnectDelay: 30000,
+    reconnectBackoffMultiplier: 2,
+    commandTimeout: 30000,
+  },
+
+  // Server settings
+  server: {
+    name: 'unity-mcp-server',
+    version: '0.1.0',
+    description: 'MCP server for Unity Editor integration',
+  },
+
+  // Logging settings
+  logging: {
+    level: process.env.LOG_LEVEL || 'info',
+    prefix: '[Unity Editor MCP]',
+  },
+
+  // Write queue removed: all edits go through structured Roslyn tools.
+
+  // Search-related defaults and engine selection
+  search: {
+    // detail alias: 'compact' maps to returnMode 'snippets'
+    defaultDetail: (process.env.SEARCH_DEFAULT_DETAIL || 'compact').toLowerCase(), // compact|metadata|snippets|full
+    engine: (process.env.SEARCH_ENGINE || 'naive').toLowerCase(), // naive|treesitter (future)
+  },
+
+  // LSP client defaults
+  lsp: {
+    requestTimeoutMs: Number(process.env.LSP_REQUEST_TIMEOUT_MS || 60000),
+  },
+
+  // Indexing (code index) settings
+  indexing: {
+    // Enable periodic incremental index updates (polling watcher)
+    watch: (process.env.INDEX_WATCH || 'false').toLowerCase() === 'true',
+    // Polling interval (ms)
+    intervalMs: Number(process.env.INDEX_WATCH_INTERVAL_MS || 15000),
+    // Build options
+    concurrency: Number(process.env.INDEX_CONCURRENCY || 8),
+    retry: Number(process.env.INDEX_RETRY || 2),
+    reportEvery: Number(process.env.INDEX_REPORT_EVERY || 500),
+  },
+};
+
+/**
+ * External config resolution (no legacy compatibility):
+ * Priority:
+ * 1) UNITY_MCP_CONFIG (explicit file path)
+ * 2) ./.unity/config.json (project-local)
+ * 3) ~/.unity/config.json (user-global)
+ * If none found, return {} and rely on env/defaults.
+ */
+function loadExternalConfig() {
+  const explicitPath = process.env.UNITY_MCP_CONFIG;
+
+  // Find nearest <workspace>/.unity/config.json by walking up from process.cwd()
+  const findProjectConfigUp = () => {
+    let dir = process.cwd();
+    let prev = '';
+    for (let i = 0; i < 3 && dir && dir !== prev; i++) {
+      const p = path.resolve(dir, '.unity', 'config.json');
+      if (fs.existsSync(p)) return p;
+      prev = dir;
+      dir = path.dirname(dir);
+    }
+    return null;
+  };
+
+  const projectPath = findProjectConfigUp();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  const userPath = homeDir ? path.resolve(homeDir, '.unity', 'config.json') : null;
+
+  const candidates = [explicitPath, projectPath, userPath].filter(Boolean);
+  for (const p of candidates) {
+    try {
+      if (p && fs.existsSync(p)) {
+        const raw = fs.readFileSync(p, 'utf8');
+        const json = JSON.parse(raw);
+        const out = json && typeof json === 'object' ? json : {};
+        out.__configPath = p;
+        return out;
+      }
+    } catch (e) {
+      return { __configLoadError: `${p}: ${e.message}` };
+    }
+  }
+  return {};
+}
+
+const external = loadExternalConfig();
+export const config = merge(baseConfig, external);
+
+// Workspace root detection: directory that contains .unity/config.json used
+const initialCwd = process.cwd();
+let workspaceRoot = initialCwd;
+try {
+  if (config.__configPath) {
+    const cfgDir = path.dirname(config.__configPath); // <workspace>/.unity
+    workspaceRoot = path.dirname(cfgDir);            // <workspace>
+  }
+} catch {}
+export const WORKSPACE_ROOT = workspaceRoot;
+
+/**
+ * Logger utility
+ * IMPORTANT: In MCP servers, all stdout output must be JSON-RPC protocol messages.
+ * Logging must go to stderr to avoid breaking the protocol.
+ */
+export const logger = {
+  info: (message, ...args) => {
+    if (['info', 'debug'].includes(config.logging.level)) {
+      console.error(`${config.logging.prefix} ${message}`, ...args);
+    }
+  },
+  
+  warn: (message, ...args) => {
+    if (['info', 'debug', 'warn'].includes(config.logging.level)) {
+      console.error(`${config.logging.prefix} WARN: ${message}`, ...args);
+    }
+  },
+  
+  error: (message, ...args) => {
+    console.error(`${config.logging.prefix} ERROR: ${message}`, ...args);
+  },
+  
+  debug: (message, ...args) => {
+    if (config.logging.level === 'debug') {
+      console.error(`${config.logging.prefix} DEBUG: ${message}`, ...args);
+    }
+  }
+};
+
+// Late log if external config failed to load
+if (config.__configLoadError) {
+  console.error(`${baseConfig.logging.prefix} WARN: Failed to load external config: ${config.__configLoadError}`);
+  delete config.__configLoadError;
+}

package/src/core/indexWatcher.js

@@ -0,0 +1,52 @@
+import { logger, config } from './config.js';
+
+export class IndexWatcher {
+  constructor(unityConnection) {
+    this.unityConnection = unityConnection;
+    this.timer = null;
+    this.running = false;
+  }
+
+  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);
+    // Initial kick
+    this.tick();
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async tick() {
+    if (this.running) return;
+    this.running = true;
+    try {
+      const { BuildCodeIndexToolHandler } = await import('../handlers/script/BuildCodeIndexToolHandler.js');
+      const handler = new BuildCodeIndexToolHandler(this.unityConnection);
+      const params = {
+        concurrency: config.indexing.concurrency || 8,
+        retry: config.indexing.retry || 2,
+        reportEvery: config.indexing.reportEvery || 500,
+      };
+      const res = await handler.handle(params);
+      const ok = res?.result?.success;
+      if (ok) {
+        logger.info(`[index] updated=${res.result.updatedFiles || 0} removed=${res.result.removedFiles || 0} total=${res.result.totalIndexedSymbols || 0}`);
+      } else if (res?.result?.error) {
+        logger.warn(`[index] update failed: ${res.result.error}`);
+      }
+    } catch (e) {
+      logger.warn(`[index] update exception: ${e.message}`);
+    } finally {
+      this.running = false;
+    }
+  }
+}
+

package/src/core/projectInfo.js

@@ -0,0 +1,111 @@
+import fs from 'fs';
+import path from 'path';
+import { logger, config } from './config.js';
+
+// Lazy project info resolver. Prefers Unity via get_editor_info, otherwise infers by walking up for Assets/Packages.
+export class ProjectInfoProvider {
+  constructor(unityConnection) {
+    this.unityConnection = unityConnection;
+    this.cached = null;
+    this.lastTried = 0;
+  }
+
+  async get() {
+    if (this.cached) return this.cached;
+    // Config-driven project root (no env fallback)
+    const cfgRoot = config?.project?.root;
+    if (cfgRoot) {
+      const projectRoot = cfgRoot.replace(/\\/g, '/');
+      const codeIndexRoot = (config?.project?.codeIndexRoot
+        || path.join(projectRoot, 'Library/UnityMCP/CodeIndex')).replace(/\\/g, '/');
+      this.cached = {
+        projectRoot,
+        assetsPath: path.join(projectRoot, 'Assets').replace(/\\/g, '/'),
+        packagesPath: path.join(projectRoot, 'Packages').replace(/\\/g, '/'),
+        codeIndexRoot,
+      };
+      return this.cached;
+    }
+    // Try Unity if connected (rate-limit attempts)
+    const now = Date.now();
+    if (this.unityConnection && this.unityConnection.isConnected() && (now - this.lastTried > 1000)) {
+      this.lastTried = now;
+      try {
+        const info = await this.unityConnection.sendCommand('get_editor_info', {});
+        if (info && info.projectRoot && info.assetsPath) {
+          this.cached = {
+            projectRoot: info.projectRoot,
+            assetsPath: info.assetsPath,
+            packagesPath: info.packagesPath || path.join(info.projectRoot, 'Packages').replace(/\\/g, '/'),
+            codeIndexRoot: info.codeIndexRoot || path.join(info.projectRoot, 'Library/UnityMCP/CodeIndex').replace(/\\/g, '/'),
+          };
+          return this.cached;
+        }
+      } catch (e) {
+        logger.warn(`get_editor_info failed: ${e.message}`);
+      }
+    }
+    // Fallback: infer by walking up from CWD to find Assets/
+    const inferred = this.inferFromCwd();
+    if (inferred) {
+      this.cached = inferred;
+      return this.cached;
+    }
+    throw new Error('Unable to resolve Unity project root (no connection and no Assets/ found)');
+  }
+
+  inferFromCwd() {
+    // First, check for Docker environment default path
+    const dockerDefaultPath = '/unity-mcp-server/UnityMCPServer';
+    const dockerAssets = path.join(dockerDefaultPath, 'Assets');
+    if (fs.existsSync(dockerAssets)) {
+      const projectRoot = dockerDefaultPath.replace(/\\/g, '/');
+      logger.info(`Found Unity project at Docker default path: ${projectRoot}`);
+      return {
+        projectRoot,
+        assetsPath: dockerAssets.replace(/\\/g, '/'),
+        packagesPath: path.join(dockerDefaultPath, 'Packages').replace(/\\/g, '/'),
+        codeIndexRoot: path.join(dockerDefaultPath, 'Library/UnityMCP/CodeIndex').replace(/\\/g, '/'),
+      };
+    }
+
+    let dir = process.cwd();
+    // Walk up max 5 levels (look for Assets directly under a directory)
+    for (let i = 0; i < 5; i++) {
+      const assets = path.join(dir, 'Assets');
+      if (fs.existsSync(assets)) {
+        const projectRoot = dir.replace(/\\/g, '/');
+        return {
+          projectRoot,
+          assetsPath: assets.replace(/\\/g, '/'),
+          packagesPath: path.join(dir, 'Packages').replace(/\\/g, '/'),
+          codeIndexRoot: path.join(dir, 'Library/UnityMCP/CodeIndex').replace(/\\/g, '/'),
+        };
+      }
+      dir = path.dirname(dir);
+    }
+
+    // Fallback: search shallow subdirectories for Unity projects (depth 2)
+    const rootsToCheck = [process.cwd(), path.dirname(process.cwd())];
+    for (const root of rootsToCheck) {
+      try {
+        const entries = fs.readdirSync(root, { withFileTypes: true });
+        for (const e of entries) {
+          if (!e.isDirectory()) continue;
+          const candidate = path.join(root, e.name);
+          const assets = path.join(candidate, 'Assets');
+          if (fs.existsSync(assets)) {
+            const projectRoot = candidate.replace(/\\/g, '/');
+            return {
+              projectRoot,
+              assetsPath: assets.replace(/\\/g, '/'),
+              packagesPath: path.join(candidate, 'Packages').replace(/\\/g, '/'),
+              codeIndexRoot: path.join(candidate, 'Library/UnityMCP/CodeIndex').replace(/\\/g, '/'),
+            };
+          }
+        }
+      } catch {}
+    }
+    return null;
+  }
+}

package/src/core/server.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { 
+  ListToolsRequestSchema, 
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListPromptsRequestSchema
+} from '@modelcontextprotocol/sdk/types.js';
+// Note: filename is lowercase on disk; use exact casing for POSIX filesystems
+import { UnityConnection } from './unityConnection.js';
+import { createHandlers } from '../handlers/index.js';
+import { config, logger } from './config.js';
+import { IndexWatcher } from './indexWatcher.js';
+
+// Create Unity connection
+const unityConnection = new UnityConnection();
+
+// Create tool handlers
+const handlers = createHandlers(unityConnection);
+
+// Create MCP server
+const server = new Server(
+  {
+    name: config.server.name,
+    version: config.server.version,
+  },
+  {
+    capabilities: {
+      // Explicitly advertise tool support; some MCP clients expect a non-empty object
+      // Setting listChanged enables future push updates if we emit notifications
+      tools: { listChanged: true },
+      resources: {},
+      prompts: {}
+    }
+  }
+);
+
+// Register MCP protocol handlers
+// Note: Do not log here as it breaks MCP protocol initialization
+
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  const tools = Array.from(handlers.values()).map((handler, index) => {
+    try {
+      const definition = handler.getDefinition();
+      // Validate inputSchema
+      if (definition.inputSchema && definition.inputSchema.type !== 'object') {
+        logger.error(`[MCP] Tool ${handler.name} (index ${index}) has invalid inputSchema type: ${definition.inputSchema.type}`);
+      }
+      return definition;
+    } catch (error) {
+      logger.error(`[MCP] Failed to get definition for handler ${handler.name}:`, error);
+      return null;
+    }
+  }).filter(tool => tool !== null);
+  
+  logger.info(`[MCP] Returning ${tools.length} tool definitions`);
+  return { tools };
+});
+
+// Handle resources listing
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  logger.debug('[MCP] Received resources/list request');
+  // Unity MCP server doesn't provide resources
+  return { resources: [] };
+});
+
+// Handle prompts listing
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  logger.debug('[MCP] Received prompts/list request');
+  // Unity MCP server doesn't provide prompts
+  return { prompts: [] };
+});
+
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const requestTime = Date.now();
+  
+  logger.info(`[MCP] Received tool call request: ${name} at ${new Date(requestTime).toISOString()}`, { args });
+  
+  const handler = handlers.get(name);
+  if (!handler) {
+    logger.error(`[MCP] Tool not found: ${name}`);
+    throw new Error(`Tool not found: ${name}`);
+  }
+  
+  try {
+    logger.info(`[MCP] Starting handler execution for: ${name} at ${new Date().toISOString()}`);
+    const startTime = Date.now();
+    
+    // Handler returns response in our format
+    const result = await handler.handle(args);
+    
+    const duration = Date.now() - startTime;
+    const totalDuration = Date.now() - requestTime;
+    logger.info(`[MCP] Handler completed at ${new Date().toISOString()}: ${name}`, { 
+      handlerDuration: `${duration}ms`,
+      totalDuration: `${totalDuration}ms`,
+      status: result.status 
+    });
+    
+    // Convert to MCP format
+    if (result.status === 'error') {
+      logger.error(`[MCP] Handler returned error: ${name}`, { error: result.error, code: result.code });
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Error: ${result.error}\nCode: ${result.code || 'UNKNOWN_ERROR'}${result.details ? '\nDetails: ' + JSON.stringify(result.details, null, 2) : ''}`
+          }
+        ]
+      };
+    }
+    
+    // Success response
+    logger.info(`[MCP] Returning success response for: ${name} at ${new Date().toISOString()}`);
+    
+    // Handle undefined or null results from handlers
+    let responseText;
+    if (result.result === undefined || result.result === null) {
+      responseText = JSON.stringify({
+        status: 'success',
+        message: 'Operation completed successfully but no details were returned',
+        tool: name
+      }, null, 2);
+    } else {
+      responseText = JSON.stringify(result.result, null, 2);
+    }
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: responseText
+        }
+      ]
+    };
+  } catch (error) {
+    const errorTime = Date.now();
+    logger.error(`[MCP] Handler threw exception at ${new Date(errorTime).toISOString()}: ${name}`, { 
+      error: error.message, 
+      stack: error.stack,
+      duration: `${errorTime - requestTime}ms`
+    });
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${error.message}`
+        }
+      ]
+    };
+  }
+});
+
+// Handle connection events
+unityConnection.on('connected', () => {
+  logger.info('Unity connection established');
+});
+
+unityConnection.on('disconnected', () => {
+  logger.info('Unity connection lost');
+});
+
+unityConnection.on('error', (error) => {
+  logger.error('Unity connection error:', error.message);
+});
+
+// Initialize server
+async function main() {
+  try {
+    // Create transport - no logging before connection
+    const transport = new StdioServerTransport();
+    
+    // Connect to transport
+    await server.connect(transport);
+    
+    // Now safe to log after connection established
+    logger.info('MCP server started successfully');
+    
+    // Attempt to connect to Unity
+    try {
+      await unityConnection.connect();
+    } catch (error) {
+      logger.error('Initial Unity connection failed:', error.message);
+      logger.info('Unity connection will retry automatically');
+    }
+
+    // Best-effort: prepare and start persistent C# LSP process (non-blocking)
+    ;(async () => {
+      try {
+        const { LspProcessManager } = await import('../lsp/LspProcessManager.js');
+        const mgr = new LspProcessManager();
+        await mgr.ensureStarted();
+        // Attach graceful shutdown
+        const shutdown = async () => { try { await mgr.stop(3000); } catch {} };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+      } catch (e) {
+        logger.warn(`[startup] csharp-lsp start failed: ${e.message}`);
+      }
+    })();
+
+    // Start periodic index watcher (incremental)
+    const watcher = new IndexWatcher(unityConnection);
+    watcher.start();
+    const stopWatch = () => { try { watcher.stop(); } catch {} };
+    process.on('SIGINT', stopWatch);
+    process.on('SIGTERM', stopWatch);
+    
+    // Handle shutdown
+    process.on('SIGINT', async () => {
+      logger.info('Shutting down...');
+      unityConnection.disconnect();
+      await server.close();
+      process.exit(0);
+    });
+    
+    process.on('SIGTERM', async () => {
+      logger.info('Shutting down...');
+      unityConnection.disconnect();
+      await server.close();
+      process.exit(0);
+    });
+    
+  } catch (error) {
+    console.error('Failed to start server:', error);
+    console.error('Stack trace:', error.stack);
+    process.exit(1);
+  }
+}
+
+// Export for testing
+export async function createServer(customConfig = config) {
+  const testUnityConnection = new UnityConnection();
+  const testHandlers = createHandlers(testUnityConnection);
+  
+  const testServer = new Server(
+    {
+      name: customConfig.server.name,
+      version: customConfig.server.version,
+    },
+    {
+      capabilities: {
+        tools: { listChanged: true },
+        resources: {},
+        prompts: {}
+      }
+    }
+  );
+  
+  // Register handlers for test server
+  testServer.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = Array.from(testHandlers.values()).map(handler => handler.getDefinition());
+    return { tools };
+  });
+  
+  testServer.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return { resources: [] };
+  });
+  
+  testServer.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return { prompts: [] };
+  });
+  
+  testServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    
+    const handler = testHandlers.get(name);
+    if (!handler) {
+      return {
+        status: 'error',
+        error: `Tool not found: ${name}`,
+        code: 'TOOL_NOT_FOUND'
+      };
+    }
+    
+    return await handler.handle(args);
+  });
+  
+  return {
+    server: testServer,
+    unityConnection: testUnityConnection
+  };
+}
+
+// Start the server
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  console.error('Stack trace:', error.stack);
+  process.exit(1);
+});