@akiojin/unity-mcp-server 2.42.4 → 2.43.0

package/bin/unity-mcp-server.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * Unity MCP Server - Single Entry Point
+ *
+ * This file uses ONLY dynamic imports to ensure:
+ * 1. Early stderr output before any module loading
+ * 2. Global exception handlers are registered first
+ * 3. Module load failures are caught and reported
+ *
+ * ESM static imports are hoisted, so we use dynamic import() to
+ * ensure our error handlers are set up before loading any modules.
+ */
+
+// Synchronous stderr write - this MUST appear before any module loading
+process.stderr.write('[unity-mcp-server] Starting...\n');
+
+// Global exception handlers - catch any unhandled errors
+process.on('uncaughtException', err => {
+  process.stderr.write(`[unity-mcp-server] FATAL: Uncaught exception: ${err.message}\n`);
+  process.stderr.write(`${err.stack}\n`);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, _promise) => {
+  const msg = reason instanceof Error ? reason.message : String(reason);
+  const stack = reason instanceof Error ? reason.stack : '';
+  process.stderr.write(`[unity-mcp-server] FATAL: Unhandled rejection: ${msg}\n`);
+  if (stack) process.stderr.write(`${stack}\n`);
+  process.exit(1);
+});
+
+// Parse command line arguments (no static imports required)
+const args = process.argv.slice(2);
+const command = args[0] && !args[0].startsWith('--') ? args[0] : null;
+const rest = command ? args.slice(1) : args;
+
+let httpEnabled = false;
+let httpPort;
+let stdioEnabled = true;
+let telemetryEnabled;
+
+for (let i = 0; i < rest.length; i++) {
+  const arg = rest[i];
+  switch (arg) {
+    case '--http':
+      httpEnabled = true;
+      if (rest[i + 1] && !rest[i + 1].startsWith('--')) {
+        httpPort = parseInt(rest[i + 1], 10);
+        i++;
+      }
+      break;
+    case '--no-http':
+      httpEnabled = false;
+      break;
+    case '--stdio':
+      stdioEnabled = true;
+      break;
+    case '--no-stdio':
+      stdioEnabled = false;
+      break;
+    case '--telemetry':
+      telemetryEnabled = true;
+      break;
+    case '--no-telemetry':
+      telemetryEnabled = false;
+      break;
+    default:
+      break;
+  }
+}
+
+// Main entry point - all imports are dynamic
+async function main() {
+  try {
+    if (command === 'list-instances') {
+      const { listInstances } = await import('../src/cli/commands/listInstances.js');
+      const portsArg = rest.find(a => a.startsWith('--ports='));
+      const ports = portsArg
+        ? portsArg
+            .replace('--ports=', '')
+            .split(',')
+            .map(p => Number(p))
+        : [];
+      const hostArg = rest.find(a => a.startsWith('--host='));
+      const host = hostArg ? hostArg.replace('--host=', '') : 'localhost';
+      const json = rest.includes('--json');
+      const list = await listInstances({ ports, host });
+      if (json) {
+        console.log(JSON.stringify(list, null, 2));
+      } else {
+        for (const e of list) {
+          console.log(`${e.active ? '*' : ' '} ${e.id} ${e.status}`);
+        }
+      }
+      return;
+    }
+
+    if (command === 'set-active') {
+      const { setActive } = await import('../src/cli/commands/setActive.js');
+      const id = rest[0];
+      if (!id) {
+        console.error('Usage: unity-mcp-server set-active <host:port>');
+        process.exit(1);
+      }
+      try {
+        const result = await setActive({ id });
+        console.log(JSON.stringify(result, null, 2));
+      } catch (e) {
+        console.error(e.message);
+        process.exit(1);
+      }
+      return;
+    }
+
+    // Start MCP server (dynamic import)
+    const { startServer } = await import('../src/core/server.js');
+    await startServer({
+      http: {
+        enabled: httpEnabled,
+        port: httpPort
+      },
+      telemetry: telemetryEnabled === undefined ? undefined : { enabled: telemetryEnabled },
+      stdioEnabled
+    });
+  } catch (err) {
+    process.stderr.write(`[unity-mcp-server] Startup failed: ${err.message}\n`);
+    process.stderr.write(`${err.stack}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.42.4",
+  "version": "2.43.0",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",
   "bin": {
-    "unity-mcp-server": "./bin/bootstrap.js"
+    "unity-mcp-server": "./bin/unity-mcp-server.js"
   },
   "scripts": {
     "start": "node src/core/server.js",
@@ -29,7 +29,7 @@
     "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/bootstrap.js bin/unity-mcp-server || true",
+    "postinstall": "node scripts/ensure-better-sqlite3.mjs && chmod +x bin/unity-mcp-server.js || true",
     "test:ci:unity": "timeout 60 node --test tests/unit/core/codeIndex.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",
     "test:nounity": "npm run test:integration",

package/src/core/config.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import * as findUpPkg from 'find-up';
+import { MCPLogger } from './mcpLogger.js';
 
 // Diagnostic log: confirm module loading reached this point
 process.stderr.write('[unity-mcp-server] Config module loading...\n');
@@ -273,30 +274,11 @@ 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.
+ *
+ * MCP SDK-compliant logger with RFC 5424 log levels.
+ * Supports dual output: stderr (developer) + MCP notification (client)
  */
-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);
-    }
-  }
-};
+export const logger = new MCPLogger(config);
 
 // Late log if external config failed to load
 if (config.__configLoadError) {

package/src/core/indexBuildWorkerPool.js

@@ -68,7 +68,7 @@ export class IndexBuildWorkerPool {
               try {
                 cb(message.data);
               } catch (e) {
-                logger.warn(`[worker-pool] Progress callback error: ${e.message}`);
+                logger.warning(`[worker-pool] Progress callback error: ${e.message}`);
               }
             });
 
@@ -102,7 +102,7 @@ export class IndexBuildWorkerPool {
 
         this.worker.on('exit', code => {
           if (code !== 0 && this.worker) {
-            logger.warn(`[worker-pool] Worker exited with code ${code}`);
+            logger.warning(`[worker-pool] Worker exited with code ${code}`);
             this._cleanup();
             reject(new Error(`Worker exited with code ${code}`));
           }

package/src/core/indexWatcher.js

@@ -54,7 +54,7 @@ export class IndexWatcher {
       const driverOk = await probe._ensureDriver();
       if (!driverOk || probe.disabled) {
         const reason = probe.disableReason || 'SQLite native binding not available';
-        logger.warn(`[index] watcher: code index disabled (${reason}); stopping watcher`);
+        logger.warning(`[index] watcher: code index disabled (${reason}); stopping watcher`);
         this.stop();
         return;
       }
@@ -69,7 +69,7 @@ export class IndexWatcher {
       const dbExists = fs.default.existsSync(dbPath);
 
       if (!dbExists) {
-        logger.warn('[index] watcher: code index DB file not found, triggering full rebuild');
+        logger.warning('[index] watcher: code index DB file not found, triggering full rebuild');
         // Force full rebuild when DB file is missing
         const jobId = `watcher-rebuild-${Date.now()}`;
         this.currentWatcherJobId = jobId;
@@ -117,7 +117,7 @@ export class IndexWatcher {
       // (Job result will be logged when it completes/fails)
       this._monitorJob(jobId);
     } catch (e) {
-      logger.warn(`[index] watcher exception: ${e.message}`);
+      logger.warning(`[index] watcher exception: ${e.message}`);
     } finally {
       this.running = false;
     }
@@ -174,7 +174,7 @@ export class IndexWatcher {
         );
         clearInterval(checkInterval);
       } else if (job.status === 'failed') {
-        logger.warn(`[index] watcher: auto-build failed - ${job.error}`);
+        logger.warning(`[index] watcher: auto-build failed - ${job.error}`);
         clearInterval(checkInterval);
       }
     }, 1000);

package/src/core/mcpLogger.js

@@ -0,0 +1,182 @@
+/**
+ * MCP SDK-compliant Logger
+ *
+ * RFC 5424 compliant logging with MCP notification support.
+ * Provides 8 log levels: emergency, alert, critical, error, warning, notice, info, debug
+ *
+ * Features:
+ * - Dual output: stderr (developer) + MCP notification (client)
+ * - Dynamic log level control via setLevel()
+ * - Fire-and-forget MCP notifications (non-blocking)
+ * - Error resilience: continues logging even if MCP notification fails
+ */
+
+/**
+ * RFC 5424 log levels (syslog severity)
+ * Lower numbers = higher severity
+ */
+export const LOG_LEVELS = {
+  emergency: 0, // System is unusable
+  alert: 1, // Action must be taken immediately
+  critical: 2, // Critical conditions
+  error: 3, // Error conditions
+  warning: 4, // Warning conditions
+  notice: 5, // Normal but significant condition
+  info: 6, // Informational messages
+  debug: 7 // Debug-level messages
+};
+
+/**
+ * MCP-compliant Logger class
+ */
+export class MCPLogger {
+  /**
+   * @param {Object} config - Configuration object
+   * @param {Object} [config.logging] - Logging configuration
+   * @param {string} [config.logging.prefix='[unity-mcp-server]'] - Log prefix
+   * @param {string} [config.logging.level='info'] - Minimum log level
+   */
+  constructor(config) {
+    this.prefix = config?.logging?.prefix || '[unity-mcp-server]';
+    this.minLevel = LOG_LEVELS[config?.logging?.level || 'info'];
+    this.server = null;
+    this.transportConnected = false;
+  }
+
+  /**
+   * Set MCP Server instance for sending notifications
+   * Should be called after transport is connected
+   * @param {Object} server - MCP Server instance with sendLoggingMessage method
+   */
+  setServer(server) {
+    this.server = server;
+    this.transportConnected = true;
+  }
+
+  /**
+   * Dynamically change log level
+   * @param {string} level - New log level (RFC 5424 level name)
+   */
+  setLevel(level) {
+    if (LOG_LEVELS[level] !== undefined) {
+      this.minLevel = LOG_LEVELS[level];
+    }
+  }
+
+  /**
+   * Internal log method
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {...any} args - Additional arguments
+   */
+  _log(level, message, ...args) {
+    const levelNum = LOG_LEVELS[level];
+
+    // Filter by minimum level
+    if (levelNum > this.minLevel) return;
+
+    // 1. Always output to stderr (developer-facing)
+    const formatted = this._formatMessage(level, message);
+    console.error(formatted, ...args);
+
+    // 2. Send MCP notification (client-facing, only when connected)
+    if (this.transportConnected && this.server) {
+      this._sendMcpLog(level, message, args);
+    }
+  }
+
+  /**
+   * Send log message via MCP notification
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {any[]} args - Additional arguments
+   */
+  _sendMcpLog(level, message, args) {
+    try {
+      // Concatenate additional arguments into a single string
+      const fullMessage =
+        args.length > 0
+          ? `${message} ${args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ')}`
+          : message;
+
+      this.server.sendLoggingMessage({
+        level,
+        logger: 'unity-mcp-server',
+        data: fullMessage // String only (no structured data)
+      });
+    } catch (e) {
+      // Log failure but continue (error resilience)
+      console.error(`${this.prefix} [MCP notification failed] ${e.message}`);
+    }
+  }
+
+  /**
+   * Format message for stderr output
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @returns {string} Formatted message
+   */
+  _formatMessage(level, message) {
+    // info level doesn't include level label (matches existing behavior)
+    const label = level === 'info' ? '' : ` ${level.toUpperCase()}:`;
+    return `${this.prefix}${label} ${message}`;
+  }
+
+  // Public log methods (RFC 5424 levels)
+
+  /**
+   * Emergency: System is unusable
+   */
+  emergency(message, ...args) {
+    this._log('emergency', message, ...args);
+  }
+
+  /**
+   * Alert: Action must be taken immediately
+   */
+  alert(message, ...args) {
+    this._log('alert', message, ...args);
+  }
+
+  /**
+   * Critical: Critical conditions
+   */
+  critical(message, ...args) {
+    this._log('critical', message, ...args);
+  }
+
+  /**
+   * Error: Error conditions
+   */
+  error(message, ...args) {
+    this._log('error', message, ...args);
+  }
+
+  /**
+   * Warning: Warning conditions
+   */
+  warning(message, ...args) {
+    this._log('warning', message, ...args);
+  }
+
+  /**
+   * Notice: Normal but significant condition
+   */
+  notice(message, ...args) {
+    this._log('notice', message, ...args);
+  }
+
+  /**
+   * Info: Informational messages
+   */
+  info(message, ...args) {
+    this._log('info', message, ...args);
+  }
+
+  /**
+   * Debug: Debug-level messages
+   */
+  debug(message, ...args) {
+    this._log('debug', message, ...args);
+  }
+}

package/src/core/projectInfo.js

@@ -70,7 +70,7 @@ export class ProjectInfoProvider {
           return this.cached;
         }
       } catch (e) {
-        logger.warn(`get_editor_info failed: ${e.message}`);
+        logger.warning(`get_editor_info failed: ${e.message}`);
       }
     }
     if (typeof cfgRootRaw === 'string') {

package/src/core/server.js

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  SetLevelRequestSchema
+} 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';
@@ -24,7 +28,9 @@ const server = new Server(
     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 }
+      tools: { listChanged: true },
+      // Enable MCP logging capability for sendLoggingMessage
+      logging: {}
     }
   }
 );
@@ -32,6 +38,14 @@ const server = new Server(
 // Register MCP protocol handlers
 // Note: Do not log here as it breaks MCP protocol initialization
 
+// Handle logging/setLevel request (REQ-6)
+server.setRequestHandler(SetLevelRequestSchema, async request => {
+  const { level } = request.params;
+  logger.setLevel(level);
+  logger.info(`Log level changed to: ${level}`);
+  return {};
+});
+
 // Handle tool listing
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   const tools = Array.from(handlers.values())
@@ -178,6 +192,9 @@ export async function startServer(options = {}) {
       transport = new HybridStdioServerTransport();
       await server.connect(transport);
       console.error(`[unity-mcp-server] MCP transport connected`);
+
+      // Enable MCP logging notifications (REQ-4)
+      logger.setServer(server);
     }
 
     // Now safe to log after connection established
@@ -228,7 +245,7 @@ export async function startServer(options = {}) {
         process.on('SIGINT', shutdown);
         process.on('SIGTERM', shutdown);
       } catch (e) {
-        logger.warn(`[startup] csharp-lsp start failed: ${e.message}`);
+        logger.warning(`[startup] csharp-lsp start failed: ${e.message}`);
       }
     })();
 
@@ -252,7 +269,7 @@ export async function startServer(options = {}) {
 
         if (!ready) {
           if (index.disabled) {
-            logger.warn(
+            logger.warning(
               `[startup] Code index disabled: ${index.disableReason || 'SQLite native binding missing'}. Skipping auto-build.`
             );
             return;
@@ -269,13 +286,13 @@ export async function startServer(options = {}) {
               `[startup] Code index auto-build started: jobId=${result.jobId}. Use code_index_status to check progress.`
             );
           } else {
-            logger.warn(`[startup] Code index auto-build failed: ${result.message}`);
+            logger.warning(`[startup] Code index auto-build failed: ${result.message}`);
           }
         } else {
           logger.info('[startup] Code index DB already exists. Skipping auto-build.');
         }
       } catch (e) {
-        logger.warn(`[startup] Code index auto-init failed: ${e.message}`);
+        logger.warning(`[startup] Code index auto-init failed: ${e.message}`);
       }
     })();
 

package/src/core/unityConnection.js

@@ -300,7 +300,7 @@ export class UnityConnection extends EventEmitter {
         }
 
         if (recoveryIndex > 0) {
-          logger.warn(`[Unity] Discarding ${recoveryIndex} bytes of invalid data`);
+          logger.warning(`[Unity] Discarding ${recoveryIndex} bytes of invalid data`);
           this.messageBuffer = this.messageBuffer.slice(recoveryIndex);
           continue;
         } else {
@@ -323,7 +323,7 @@ export class UnityConnection extends EventEmitter {
 
           // Skip non-JSON messages (like debug logs)
           if (!message.trim().startsWith('{')) {
-            logger.warn(`[Unity] Skipping non-JSON message: ${message.substring(0, 50)}...`);
+            logger.warning(`[Unity] Skipping non-JSON message: ${message.substring(0, 50)}...`);
             continue;
           }
 
@@ -359,7 +359,7 @@ export class UnityConnection extends EventEmitter {
     logger.info(`[Unity] enqueue sendCommand: ${type}`, { connected: this.connected });
 
     if (!this.connected) {
-      logger.warn('[Unity] Not connected; waiting for reconnection before sending command');
+      logger.warning('[Unity] Not connected; waiting for reconnection before sending command');
       await this.ensureConnected({
         timeoutMs: config.unity.commandTimeout
       });
@@ -463,7 +463,7 @@ export class UnityConnection extends EventEmitter {
             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}`);
+            logger.warning(`[Unity] Failed to parse result as JSON: ${parseError.message}`);
           }
         }
         if (response.version) result._version = response.version;
@@ -476,7 +476,7 @@ export class UnityConnection extends EventEmitter {
         err.code = response.code;
         pending.reject(err);
       } else {
-        logger.warn(`[Unity] Command ${targetId} has unknown response format`);
+        logger.warning(`[Unity] Command ${targetId} has unknown response format`);
         pending.resolve(response);
       }
       return;

package/src/handlers/script/CodeIndexBuildToolHandler.js

@@ -210,7 +210,9 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
             // This allows build to continue even if some files fail
             if (processed % 50 === 0) {
               // Log occasionally to avoid spam
-              logger.warn(`[index][${job.id}] Skipped file due to error: ${rel} - ${err.message}`);
+              logger.warning(
+                `[index][${job.id}] Skipped file due to error: ${rel} - ${err.message}`
+              );
             }
           } finally {
             processed += 1;

package/src/lsp/CSharpLspUtils.js

@@ -92,7 +92,7 @@ export class CSharpLspUtils {
       }
       logger.info(`[csharp-lsp] migrated legacy binary to ${path.dirname(primary)}`);
     } catch (e) {
-      logger.warn(`[csharp-lsp] legacy migration failed: ${e.message}`);
+      logger.warning(`[csharp-lsp] legacy migration failed: ${e.message}`);
     }
   }
 
@@ -135,7 +135,7 @@ export class CSharpLspUtils {
     // バージョン取得失敗時もバイナリが存在すれば使用
     if (!desired) {
       if (fs.existsSync(p)) {
-        logger.warn('[csharp-lsp] version not found, using existing binary');
+        logger.warning('[csharp-lsp] version not found, using existing binary');
         return p;
       }
       throw new Error('mcp-server version not found; cannot resolve LSP tag');
@@ -152,7 +152,7 @@ export class CSharpLspUtils {
       return p;
     } catch (e) {
       if (fs.existsSync(p)) {
-        logger.warn(`[csharp-lsp] download failed, using existing binary: ${e.message}`);
+        logger.warning(`[csharp-lsp] download failed, using existing binary: ${e.message}`);
         return p;
       }
       throw e;

package/src/lsp/LspProcessManager.js

@@ -23,7 +23,7 @@ export class LspProcessManager {
         const proc = spawn(bin, { stdio: ['pipe', 'pipe', 'pipe'] });
         proc.on('error', e => logger.error(`[csharp-lsp] process error: ${e.message}`));
         proc.on('close', (code, sig) => {
-          logger.warn(`[csharp-lsp] exited code=${code} signal=${sig || ''}`);
+          logger.warning(`[csharp-lsp] exited code=${code} signal=${sig || ''}`);
           if (this.state.proc === proc) {
             this.state.proc = null;
           }

package/src/lsp/LspRpcClient.js

@@ -161,7 +161,7 @@ export class LspRpcClient {
         this.proc = null;
         this.initialized = false;
         this.buf = Buffer.alloc(0);
-        logger.warn(`[csharp-lsp] recoverable error on ${method}: ${msg}. Retrying once...`);
+        logger.warning(`[csharp-lsp] recoverable error on ${method}: ${msg}. Retrying once...`);
         return await this.#requestWithRetry(method, params, attempt + 1);
       }
       // Standardize error message

package/src/lsp/LspRpcClientSingleton.js

@@ -42,7 +42,7 @@ export class LspRpcClientSingleton {
       try {
         await instance.mgr.stop();
       } catch (e) {
-        logger.warn(`[LspRpcClientSingleton] error stopping: ${e.message}`);
+        logger.warning(`[LspRpcClientSingleton] error stopping: ${e.message}`);
       }
       instance = null;
       currentProjectRoot = null;
@@ -59,7 +59,7 @@ export class LspRpcClientSingleton {
       if (!instance) return;
       // Check if process is still alive before attempting heartbeat
       if (!instance.proc || instance.proc.killed) {
-        logger.warn('[LspRpcClientSingleton] process dead, resetting...');
+        logger.warning('[LspRpcClientSingleton] process dead, resetting...');
         instance = null;
         currentProjectRoot = null;
         LspRpcClientSingleton.#stopHeartbeat();
@@ -69,7 +69,7 @@ export class LspRpcClientSingleton {
         // 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...`);
+        logger.warning(`[LspRpcClientSingleton] heartbeat failed: ${e.message}, resetting...`);
         // Process is dead, reset instance for next request
         instance = null;
         currentProjectRoot = null;

package/src/utils/testResultsCache.js

@@ -30,7 +30,9 @@ export async function persistTestResults(result) {
     await fs.writeFile(filePath, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
     return filePath;
   } catch (error) {
-    logger.warn(`[TestResultsCache] Failed to write test results to ${filePath}: ${error.message}`);
+    logger.warning(
+      `[TestResultsCache] Failed to write test results to ${filePath}: ${error.message}`
+    );
     return null;
   }
 }
@@ -46,7 +48,7 @@ export async function loadCachedTestResults(targetPath) {
     return JSON.parse(data);
   } catch (error) {
     if (error.code !== 'ENOENT') {
-      logger.warn(
+      logger.warning(
         `[TestResultsCache] Failed to read test results from ${filePath}: ${error.message}`
       );
     }
@@ -63,7 +65,7 @@ export async function resetTestResultsCache() {
   try {
     await fs.rm(filePath, { force: true });
   } catch (error) {
-    logger.warn(
+    logger.warning(
       `[TestResultsCache] Failed to reset test results cache ${filePath}: ${error.message}`
     );
   }

package/src/utils/testRunState.js

@@ -27,7 +27,7 @@ await (async () => {
     logger.info(`[testRunState] Loaded persisted state from ${runStatePath}`);
   } catch (error) {
     if (error.code !== 'ENOENT') {
-      logger.warn(`[testRunState] Failed to load state from ${runStatePath}: ${error.message}`);
+      logger.warning(`[testRunState] Failed to load state from ${runStatePath}: ${error.message}`);
     }
   }
 })();
@@ -85,6 +85,6 @@ async function persist() {
     await fs.mkdir(dir, { recursive: true });
     await fs.writeFile(runStatePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
   } catch (error) {
-    logger.warn(`[testRunState] Failed to persist state to ${runStatePath}: ${error.message}`);
+    logger.warning(`[testRunState] Failed to persist state to ${runStatePath}: ${error.message}`);
   }
 }

package/bin/bootstrap.js

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-/**
- * Bootstrap wrapper for unity-mcp-server
- *
- * This wrapper ensures:
- * 1. Early stderr output before any module loading
- * 2. Global exception handlers are registered first
- * 3. Module load failures are caught and reported
- *
- * ESM static imports are hoisted, so we use dynamic import() to
- * ensure our error handlers are set up before loading the main module.
- */
-
-// Synchronous stderr write - this MUST appear before any module loading
-process.stderr.write('[unity-mcp-server] Bootstrap starting...\n');
-
-// Global exception handlers - catch any unhandled errors
-process.on('uncaughtException', err => {
-  process.stderr.write(`[unity-mcp-server] FATAL: Uncaught exception: ${err.message}\n`);
-  process.stderr.write(`${err.stack}\n`);
-  process.exit(1);
-});
-
-process.on('unhandledRejection', (reason, _promise) => {
-  const msg = reason instanceof Error ? reason.message : String(reason);
-  const stack = reason instanceof Error ? reason.stack : '';
-  process.stderr.write(`[unity-mcp-server] FATAL: Unhandled rejection: ${msg}\n`);
-  if (stack) process.stderr.write(`${stack}\n`);
-  process.exit(1);
-});
-
-// Dynamic import to load the main module AFTER error handlers are set up
-// This allows us to catch module load failures
-import('./unity-mcp-server').catch(err => {
-  process.stderr.write(`[unity-mcp-server] FATAL: Module load failed: ${err.message}\n`);
-  process.stderr.write(`${err.stack}\n`);
-  process.exit(1);
-});

package/bin/unity-mcp-server

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-import { startServer } from '../src/core/server.js';
-import { listInstances } from '../src/cli/commands/listInstances.js';
-import { setActive } from '../src/cli/commands/setActive.js';
-
-const args = process.argv.slice(2);
-const command = args[0] && !args[0].startsWith('--') ? args[0] : null;
-const rest = command ? args.slice(1) : args;
-let httpEnabled = false;
-let httpPort;
-let stdioEnabled = true;
-let telemetryEnabled;
-
-for (let i = 0; i < rest.length; i++) {
-  const arg = rest[i];
-  switch (arg) {
-    case '--http':
-      httpEnabled = true;
-      if (args[i + 1] && !args[i + 1].startsWith('--')) {
-        httpPort = parseInt(args[i + 1], 10);
-        i++;
-      }
-      break;
-    case '--no-http':
-      httpEnabled = false;
-      break;
-    case '--stdio':
-      stdioEnabled = true;
-      break;
-    case '--no-stdio':
-      stdioEnabled = false;
-      break;
-    case '--telemetry':
-      telemetryEnabled = true;
-      break;
-    case '--no-telemetry':
-      telemetryEnabled = false;
-      break;
-    default:
-      break;
-  }
-}
-
-async function main() {
-  if (command === 'list-instances') {
-    const portsArg = rest.find(a => a.startsWith('--ports='));
-    const ports = portsArg ? portsArg.replace('--ports=', '').split(',').map(p => Number(p)) : [];
-    const hostArg = rest.find(a => a.startsWith('--host='));
-    const host = hostArg ? hostArg.replace('--host=', '') : 'localhost';
-    const json = rest.includes('--json');
-    const list = await listInstances({ ports, host });
-    if (json) {
-      console.log(JSON.stringify(list, null, 2));
-    } else {
-      for (const e of list) {
-        console.log(`${e.active ? '*' : ' '} ${e.id} ${e.status}`);
-      }
-    }
-    return;
-  }
-
-  if (command === 'set-active') {
-    const id = rest[0];
-    if (!id) {
-      console.error('Usage: unity-mcp-server set-active <host:port>');
-      process.exit(1);
-    }
-    try {
-      const result = await setActive({ id });
-      console.log(JSON.stringify(result, null, 2));
-    } catch (e) {
-      console.error(e.message);
-      process.exit(1);
-    }
-    return;
-  }
-
-  startServer({
-    http: {
-      enabled: httpEnabled,
-      port: httpPort
-    },
-    telemetry: telemetryEnabled === undefined ? undefined : { enabled: telemetryEnabled },
-    stdioEnabled
-  }).catch(error => {
-    console.error('Fatal error:', error);
-    console.error('Stack trace:', error?.stack);
-    process.exit(1);
-  });
-}
-
-main();