unreal-engine-mcp-server 0.3.0 → 0.3.1

package/dist/unreal-bridge.js

@@ -12,6 +12,7 @@ export class UnrealBridge {
     reconnectAttempts = 0;
     MAX_RECONNECT_ATTEMPTS = 5;
     BASE_RECONNECT_DELAY = 1000;
+    autoReconnectEnabled = false; // disabled by default to prevent looping retries
     // Command queue for throttling
     commandQueue = [];
     isProcessing = false;
@@ -151,53 +152,112 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
      * @param retryDelayMs Delay between retry attempts in milliseconds
      * @returns Promise that resolves when connected or rejects after all attempts fail
      */
+    connectPromise;
     async tryConnect(maxAttempts = 3, timeoutMs = 5000, retryDelayMs = 2000) {
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (this.connected)
+            return true;
+        if (this.connectPromise) {
             try {
-                this.log.info(`Connection attempt ${attempt}/${maxAttempts}`);
-                await this.connect(timeoutMs);
-                return true; // Successfully connected
+                await this.connectPromise;
             }
-            catch (err) {
-                this.log.warn(`Connection attempt ${attempt} failed:`, err);
-                if (attempt < maxAttempts) {
-                    this.log.info(`Retrying in ${retryDelayMs}ms...`);
-                    await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+            catch {
+                // swallow, we'll return connected flag
+            }
+            return this.connected;
+        }
+        this.connectPromise = (async () => {
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                // Early exit if another concurrent attempt already connected
+                if (this.connected) {
+                    this.log.debug('Already connected; skipping remaining retry attempts');
+                    return;
                 }
-                else {
-                    this.log.error(`All ${maxAttempts} connection attempts failed`);
-                    return false; // All attempts failed
+                try {
+                    this.log.debug(`Connection attempt ${attempt}/${maxAttempts}`);
+                    await this.connect(timeoutMs);
+                    return; // Successfully connected
+                }
+                catch (err) {
+                    const msg = (err?.message || String(err));
+                    this.log.debug(`Connection attempt ${attempt} failed: ${msg}`);
+                    if (attempt < maxAttempts) {
+                        this.log.debug(`Retrying in ${retryDelayMs}ms...`);
+                        // Sleep, but allow early break if we became connected during the wait
+                        const start = Date.now();
+                        while (Date.now() - start < retryDelayMs) {
+                            if (this.connected)
+                                return; // someone else connected
+                            await new Promise(r => setTimeout(r, 50));
+                        }
+                    }
+                    else {
+                        // Keep this at warn (not error) and avoid stack spam
+                        this.log.warn(`All ${maxAttempts} connection attempts failed`);
+                        return; // exit, connected remains false
+                    }
                 }
             }
+        })();
+        try {
+            await this.connectPromise;
         }
-        return false;
+        finally {
+            this.connectPromise = undefined;
+        }
+        return this.connected;
     }
     async connect(timeoutMs = 5000) {
+        // If already connected and socket is open, do nothing
+        if (this.connected && this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.log.debug('connect() called but already connected; skipping');
+            return;
+        }
         const wsUrl = `ws://${this.env.UE_HOST}:${this.env.UE_RC_WS_PORT}`;
         const httpBase = `http://${this.env.UE_HOST}:${this.env.UE_RC_HTTP_PORT}`;
         this.http = createHttpClient(httpBase);
-        this.log.info(`Connecting to UE Remote Control: ${wsUrl}`);
+        this.log.debug(`Connecting to UE Remote Control: ${wsUrl}`);
         this.ws = new WebSocket(wsUrl);
         await new Promise((resolve, reject) => {
             if (!this.ws)
                 return reject(new Error('WS not created'));
+            // Guard against double-resolution/rejection
+            let settled = false;
+            const safeResolve = () => { if (!settled) {
+                settled = true;
+                resolve();
+            } };
+            const safeReject = (err) => { if (!settled) {
+                settled = true;
+                reject(err);
+            } };
             // Setup timeout
             const timeout = setTimeout(() => {
                 this.log.warn(`Connection timeout after ${timeoutMs}ms`);
                 if (this.ws) {
-                    this.ws.removeAllListeners();
-                    // Only close if the websocket is in CONNECTING state
-                    if (this.ws.readyState === WebSocket.CONNECTING) {
-                        try {
-                            this.ws.terminate(); // Use terminate instead of close for immediate cleanup
+                    try {
+                        // Attach a temporary error handler to avoid unhandled 'error' events on abort
+                        this.ws.on('error', () => { });
+                        // Prefer graceful close; terminate as a fallback
+                        if (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN) {
+                            try {
+                                this.ws.close();
+                            }
+                            catch { }
+                            try {
+                                this.ws.terminate();
+                            }
+                            catch { }
                         }
-                        catch (_e) {
-                            // Ignore close errors
+                    }
+                    finally {
+                        try {
+                            this.ws.removeAllListeners();
                         }
+                        catch { }
+                        this.ws = undefined;
                     }
-                    this.ws = undefined;
                 }
-                reject(new Error('Connection timeout: Unreal Engine may not be running or Remote Control is not enabled'));
+                safeReject(new Error('Connection timeout: Unreal Engine may not be running or Remote Control is not enabled'));
             }, timeoutMs);
             // Success handler
             const onOpen = () => {
@@ -205,37 +265,52 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                 this.connected = true;
                 this.log.info('Connected to Unreal Remote Control');
                 this.startCommandProcessor(); // Start command processor on connect
-                resolve();
+                safeResolve();
             };
             // Error handler
             const onError = (err) => {
                 clearTimeout(timeout);
-                this.log.error('WebSocket error', err);
+                // Keep error logs concise to avoid stack spam when UE is not running
+                this.log.debug(`WebSocket error during connect: ${(err && err.code) || ''} ${err.message}`);
                 if (this.ws) {
-                    this.ws.removeAllListeners();
                     try {
+                        // Attach a temporary error handler to avoid unhandled 'error' events while aborting
+                        this.ws.on('error', () => { });
                         if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-                            this.ws.terminate();
+                            try {
+                                this.ws.close();
+                            }
+                            catch { }
+                            try {
+                                this.ws.terminate();
+                            }
+                            catch { }
                         }
                     }
-                    catch (_e) {
-                        // Ignore close errors
+                    finally {
+                        try {
+                            this.ws.removeAllListeners();
+                        }
+                        catch { }
+                        this.ws = undefined;
                     }
-                    this.ws = undefined;
                 }
-                reject(new Error(`Failed to connect: ${err.message}`));
+                safeReject(new Error(`Failed to connect: ${err.message}`));
             };
             // Close handler (if closed before open)
             const onClose = () => {
                 if (!this.connected) {
                     clearTimeout(timeout);
-                    reject(new Error('Connection closed before establishing'));
+                    safeReject(new Error('Connection closed before establishing'));
                 }
                 else {
                     // Normal close after connection was established
                     this.connected = false;
+                    this.ws = undefined;
                     this.log.warn('WebSocket closed');
-                    this.scheduleReconnect();
+                    if (this.autoReconnectEnabled) {
+                        this.scheduleReconnect();
+                    }
                 }
             };
             // Message handler (currently best-effort logging)
@@ -244,8 +319,8 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                     const msg = JSON.parse(String(raw));
                     this.log.debug('WS message', msg);
                 }
-                catch (e) {
-                    this.log.error('Failed parsing WS message', e);
+                catch (_e) {
+                    // Noise reduction: keep at debug and do nothing on parse errors
                 }
             };
             // Attach listeners
@@ -256,6 +331,10 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
         });
     }
     async httpCall(path, method = 'POST', body) {
+        // Guard: if not connected, do not attempt HTTP
+        if (!this.connected) {
+            throw new Error('Not connected to Unreal Engine');
+        }
         const url = path.startsWith('/') ? path : `/${path}`;
         const started = Date.now();
         // Fix Content-Length header issue - ensure body is properly handled
@@ -329,14 +408,16 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                 const delay = Math.min(1000 * Math.pow(2, attempt), 5000); // Exponential backoff with 5s max
                 // Log timeout errors specifically
                 if (error.message?.includes('timeout')) {
-                    this.log.warn(`HTTP request timed out (attempt ${attempt + 1}/3): ${url}`);
+                    this.log.debug(`HTTP request timed out (attempt ${attempt + 1}/3): ${url}`);
                 }
                 if (attempt < 2) {
-                    this.log.warn(`HTTP request failed (attempt ${attempt + 1}/3), retrying in ${delay}ms...`);
+                    this.log.debug(`HTTP request failed (attempt ${attempt + 1}/3), retrying in ${delay}ms...`);
                     await new Promise(resolve => setTimeout(resolve, delay));
                     // If connection error, try to reconnect
                     if (error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT' || error.message?.includes('timeout')) {
-                        this.scheduleReconnect();
+                        if (this.autoReconnectEnabled) {
+                            this.scheduleReconnect();
+                        }
                     }
                 }
             }
@@ -345,6 +426,8 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
     }
     // Generic function call via Remote Control HTTP API
     async call(body) {
+        if (!this.connected)
+            throw new Error('Not connected to Unreal Engine');
         // Using HTTP endpoint /remote/object/call
         const result = await this.httpCall('/remote/object/call', 'PUT', {
             generateTransaction: false,
@@ -353,10 +436,15 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
         return result;
     }
     async getExposed() {
+        if (!this.connected)
+            throw new Error('Not connected to Unreal Engine');
         return this.httpCall('/remote/preset', 'GET');
     }
     // Execute a console command safely with validation and throttling
     async executeConsoleCommand(command) {
+        if (!this.connected) {
+            throw new Error('Not connected to Unreal Engine');
+        }
         // Validate command is not empty
         if (!command || typeof command !== 'string') {
             throw new Error('Invalid command: must be a non-empty string');
@@ -420,6 +508,9 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
     }
     // Try to execute a Python command via the PythonScriptPlugin, fallback to `py` console command.
     async executePython(command) {
+        if (!this.connected) {
+            throw new Error('Not connected to Unreal Engine');
+        }
         const isMultiLine = /[\r\n]/.test(command) || command.includes(';');
         try {
             // Use ExecutePythonCommandEx with appropriate mode based on content
@@ -511,8 +602,16 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
             }
         }
     }
+    // Allow callers to enable/disable auto-reconnect behavior
+    setAutoReconnectEnabled(enabled) {
+        this.autoReconnectEnabled = enabled;
+    }
     // Connection recovery
     scheduleReconnect() {
+        if (!this.autoReconnectEnabled) {
+            this.log.info('Auto-reconnect disabled; not scheduling reconnection');
+            return;
+        }
         if (this.reconnectTimer || this.connected) {
             return;
         }
@@ -523,7 +622,7 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
         // Exponential backoff with jitter
         const delay = Math.min(this.BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts) + Math.random() * 1000, 30000 // Max 30 seconds
         );
-        this.log.info(`Scheduling reconnection attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS} in ${Math.round(delay)}ms`);
+        this.log.debug(`Scheduling reconnection attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS} in ${Math.round(delay)}ms`);
         this.reconnectTimer = setTimeout(async () => {
             this.reconnectTimer = undefined;
             this.reconnectAttempts++;
@@ -533,7 +632,7 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
                 this.log.info('Successfully reconnected to Unreal Engine');
             }
             catch (err) {
-                this.log.error('Reconnection attempt failed:', err);
+                this.log.warn('Reconnection attempt failed:', err);
                 this.scheduleReconnect();
             }
         }, delay);
@@ -545,8 +644,25 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
             this.reconnectTimer = undefined;
         }
         if (this.ws) {
-            this.ws.close();
-            this.ws = undefined;
+            try {
+                // Avoid unhandled error during shutdown
+                this.ws.on('error', () => { });
+                try {
+                    this.ws.close();
+                }
+                catch { }
+                try {
+                    this.ws.terminate();
+                }
+                catch { }
+            }
+            finally {
+                try {
+                    this.ws.removeAllListeners();
+                }
+                catch { }
+                this.ws = undefined;
+            }
         }
         this.connected = false;
     }
@@ -581,6 +697,7 @@ print(f"RESULT:{{'success': {saved}, 'message': 'All dirty packages saved'}}")
     /**
      * Execute Python script and parse the result
      */
+    // Expose for internal consumers (resources) that want parsed RESULT blocks
     async executePythonWithResult(script) {
         try {
             // Wrap script to capture output so we can parse RESULT: lines reliably
@@ -606,7 +723,6 @@ finally:
                     out = response;
                 }
                 else if (response && typeof response === 'object') {
-                    // Common RC Python response contains LogOutput array entries with .Output strings
                     if (Array.isArray(response.LogOutput)) {
                         out = response.LogOutput.map((l) => l.Output || '').join('');
                     }
@@ -617,7 +733,6 @@ finally:
                         out = response.result;
                     }
                     else {
-                        // Fallback to stringifying object (may still include RESULT in nested fields)
                         out = JSON.stringify(response);
                     }
                 }
@@ -625,17 +740,58 @@ finally:
             catch {
                 out = String(response || '');
             }
-            // Find the last RESULT: JSON block in the output for robustness
-            const matches = Array.from(out.matchAll(/RESULT:({[\s\S]*?})/g));
+            // Robust RESULT parsing with bracket matching (handles nested objects)
+            const marker = 'RESULT:';
+            const idx = out.lastIndexOf(marker);
+            if (idx !== -1) {
+                // Find first '{' after the marker
+                let i = idx + marker.length;
+                while (i < out.length && out[i] !== '{')
+                    i++;
+                if (i < out.length && out[i] === '{') {
+                    let depth = 0;
+                    let inStr = false;
+                    let esc = false;
+                    let j = i;
+                    for (; j < out.length; j++) {
+                        const ch = out[j];
+                        if (esc) {
+                            esc = false;
+                            continue;
+                        }
+                        if (ch === '\\') {
+                            esc = true;
+                            continue;
+                        }
+                        if (ch === '"') {
+                            inStr = !inStr;
+                            continue;
+                        }
+                        if (!inStr) {
+                            if (ch === '{')
+                                depth++;
+                            else if (ch === '}') {
+                                depth--;
+                                if (depth === 0) {
+                                    j++;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    const jsonStr = out.slice(i, j);
+                    try {
+                        return JSON.parse(jsonStr);
+                    }
+                    catch { }
+                }
+            }
+            // Fallback to previous regex approach (best-effort)
+            const matches = Array.from(out.matchAll(/RESULT:({[\s\S]*})/g));
             if (matches.length > 0) {
                 const last = matches[matches.length - 1][1];
                 try {
-                    // Accept single quotes and True/False from Python repr if present
-                    const normalized = last
-                        .replace(/'/g, '"')
-                        .replace(/\bTrue\b/g, 'true')
-                        .replace(/\bFalse\b/g, 'false');
-                    return JSON.parse(normalized);
+                    return JSON.parse(last);
                 }
                 catch {
                     return { raw: last };
@@ -835,10 +991,12 @@ print('RESULT:' + json.dumps(flags))
             }
             catch (error) {
                 // Retry logic for transient failures
+                const msg = (error?.message || String(error)).toLowerCase();
+                const notConnected = msg.includes('not connected to unreal');
                 if (item.retryCount === undefined) {
                     item.retryCount = 0;
                 }
-                if (item.retryCount < 3) {
+                if (!notConnected && item.retryCount < 3) {
                     item.retryCount++;
                     this.log.warn(`Command failed, retrying (${item.retryCount}/3)`);
                     // Re-add to queue with increased priority

package/dist/utils/http.js

@@ -1,6 +1,7 @@
 import axios from 'axios';
 import http from 'http';
 import https from 'https';
+import { Logger } from './logger.js';
 // Connection pooling configuration for better performance
 const httpAgent = new http.Agent({
     keepAlive: true,
@@ -16,6 +17,7 @@ const httpsAgent = new https.Agent({
     maxFreeSockets: 5,
     timeout: 30000
 });
+const log = new Logger('HTTP');
 const defaultRetryConfig = {
     maxRetries: 3,
     initialDelay: 1000,
@@ -75,7 +77,7 @@ export function createHttpClient(baseURL) {
     client.interceptors.response.use((response) => {
         const duration = Date.now() - (response.config.metadata?.startTime || 0);
         if (duration > 5000) {
-            console.warn(`[HTTP] Slow request: ${response.config.url} took ${duration}ms`);
+            log.warn(`[HTTP] Slow request: ${response.config.url} took ${duration}ms`);
         }
         return response;
     }, (error) => {
@@ -109,7 +111,7 @@ export async function requestWithRetry(client, config, retryConfig = {}) {
             }
             // Calculate delay and wait
             const delay = calculateBackoff(attempt, retry);
-            console.error(`[HTTP] Retry attempt ${attempt}/${retry.maxRetries} after ${Math.round(delay)}ms`);
+            log.debug(`[HTTP] Retry attempt ${attempt}/${retry.maxRetries} after ${Math.round(delay)}ms`);
             await new Promise(resolve => setTimeout(resolve, delay));
         }
     }

package/dist/utils/response-validator.js

@@ -27,7 +27,8 @@ export class ResponseValidator {
         try {
             const validator = this.ajv.compile(outputSchema);
             this.validators.set(toolName, validator);
-            log.info(`Registered output schema for tool: ${toolName}`);
+            // Demote per-tool schema registration to debug to reduce log noise
+            log.debug(`Registered output schema for tool: ${toolName}`);
         }
         catch (_error) {
             log.error(`Failed to compile output schema for ${toolName}:`, _error);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "unreal-engine-mcp-server",
-"version": "0.3.0",
+  "version": "0.3.1",
   "description": "Production-ready MCP server for Unreal Engine integration with consolidated and individual tool modes",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "unreal-mcp-server": "dist/cli.js"
+    "unreal-engine-mcp-server": "dist/cli.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/server.json

@@ -2,13 +2,13 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-07-09/server.schema.json",
   "name": "io.github.ChiR24/unreal-engine-mcp",
   "description": "Production-ready MCP server for Unreal Engine with comprehensive game development tools",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "packages": [
     {
       "registry_type": "npm",
       "registry_base_url": "https://registry.npmjs.org",
       "identifier": "unreal-engine-mcp-server",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "transport": {
         "type": "stdio"
       },