unreal-engine-mcp-server 0.5.0 → 0.5.2

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Private/McpConnectionManager.cpp

@@ -7,7 +7,6 @@
 #include "Serialization/JsonReader.h"
 #include "Serialization/JsonSerializer.h"
 
-
 // Reuse the log category from the subsystem for consistency
 // (It is declared extern in McpAutomationBridgeSubsystem.h)
 

package/scripts/run-all-tests.mjs

@@ -2,27 +2,32 @@
 import { spawn } from 'node:child_process';
 
 const tests = [
-  'test:control_actor', // Pass
-  'test:control_editor', // Pass
-  'test:manage_level', // Pass
-  'test:animation', // Pass
-  'test:materials', // Pass
-  'test:niagara', // Pass
-  'test:landscape', // Pass
-  'test:sequence', // Pass
-  'test:system', // Pass
-  'test:console_command', // Pass
-  'test:inspect', // Pass
-  'test:manage_asset', // Pass
-  'test:blueprint', // Pass
-  'test:blueprint_graph', // Pass
-  // 'test:graphql', // Pass
-  'test:wasm:all', // Pass
+  'test:control_actor', // 1
+  'test:control_editor', // 1
+  'test:manage_level', // crashed 1
+  'test:animation',
+  'test:materials',
+  'test:niagara',
+  'test:landscape',
+  'test:sequence', // crashed 1
+  'test:system',
+  'test:console_command',
+  'test:inspect',
+  'test:manage_asset',
+  'test:blueprint',
+  'test:blueprint_graph',
+  'test:audio',
+  'test:behavior_tree',
+  'test:lighting',
+  'test:performance',
+  'test:input',
+  'test:asset_graph',
+  'test:graphql',
+  'test:wasm:all',
   'test:no-inline-python',
-  'test:plugin-handshake', // Pass
-  'test:asset_advanced', // Pass
-  'test:render', // Pass
-  'test:world_partition' // Pass
+  'test:plugin-handshake',
+  'test:asset_advanced',
+  'test:world_partition'
 ];
 
 const isWindows = process.platform === 'win32';

package/server.json

@@ -1,13 +1,14 @@
 {
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.ChiR24/unreal-engine-mcp",
   "description": "MCP server for Unreal Engine 5 with 17 tools for game development automation.",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "unreal-engine-mcp-server",
-      "version": "0.5.0",
+      "version": "0.5.2",
       "transport": {
         "type": "stdio"
       },

package/src/automation/bridge.ts

@@ -58,9 +58,9 @@ export class AutomationBridge extends EventEmitter {
     private lastHandshakeFailure?: { reason: string; at: Date };
     private lastDisconnect?: { code: number; reason: string; at: Date };
     private lastError?: { message: string; at: Date };
-    private requestQueue: Array<() => void> = [];
     private queuedRequestItems: Array<{ resolve: (v: any) => void; reject: (e: any) => void; action: string; payload: any; options: any }> = [];
     private connectionPromise?: Promise<void>;
+    private connectionLock = false;
 
     constructor(options: AutomationBridgeOptions = {}) {
         super();
@@ -216,14 +216,15 @@ export class AutomationBridge extends EventEmitter {
                 this.lastHandshakeFailure = undefined;
                 this.connectionManager.updateLastMessageTime();
 
-                // Extract remote address/port
-                const underlying: any = (socket as any)._socket || (socket as any).socket;
+                // Extract remote address/port from underlying TCP socket
+                // Note: WebSocket types don't expose _socket, but it exists at runtime
+                const socketWithInternal = socket as unknown as { _socket?: { remoteAddress?: string; remotePort?: number }; socket?: { remoteAddress?: string; remotePort?: number } };
+                const underlying = socketWithInternal._socket || socketWithInternal.socket;
                 const remoteAddr = underlying?.remoteAddress ?? undefined;
                 const remotePort = underlying?.remotePort ?? undefined;
 
                 this.connectionManager.registerSocket(socket, this.clientPort, metadata, remoteAddr, remotePort);
                 this.connectionManager.startHeartbeat();
-                this.flushQueue();
 
                 this.emitAutomation('connected', {
                     socket,
@@ -340,7 +341,7 @@ export class AutomationBridge extends EventEmitter {
                 ? { message: this.lastError.message, at: this.lastError.at.toISOString() }
                 : null,
             lastMessageAt: this.connectionManager.getLastMessageTime()?.toISOString() ?? null,
-            lastRequestSentAt: null, // TODO: Track this in RequestTracker?
+            lastRequestSentAt: this.requestTracker.getLastRequestSentAt()?.toISOString() ?? null,
             pendingRequests: this.requestTracker.getPendingCount(),
             pendingRequestDetails: this.requestTracker.getPendingDetails(),
             connections: connectionInfos,
@@ -349,8 +350,8 @@ export class AutomationBridge extends EventEmitter {
             serverName: this.serverName,
             serverVersion: this.serverVersion,
             maxConcurrentConnections: this.maxConcurrentConnections,
-            maxPendingRequests: 100, // TODO: Expose from RequestTracker
-            heartbeatIntervalMs: 30000 // TODO: Expose from ConnectionManager
+            maxPendingRequests: this.requestTracker.getMaxPendingRequests(),
+            heartbeatIntervalMs: this.connectionManager.getHeartbeatIntervalMs()
         };
     }
 
@@ -363,8 +364,9 @@ export class AutomationBridge extends EventEmitter {
             if (this.enabled) {
                 this.log.info('Automation bridge not connected, attempting lazy connection...');
 
-                // Avoid multiple simultaneous connection attempts
-                if (!this.connectionPromise) {
+                // Avoid multiple simultaneous connection attempts using lock
+                if (!this.connectionPromise && !this.connectionLock) {
+                    this.connectionLock = true;
                     this.connectionPromise = new Promise<void>((resolve, reject) => {
                         const onConnect = () => {
                             cleanup(); resolve();
@@ -383,8 +385,9 @@ export class AutomationBridge extends EventEmitter {
                             this.off('connected', onConnect);
                             this.off('error', onError);
                             this.off('handshakeFailed', onHandshakeFail);
-                            // If we failed, clear the promise so next attempt can try again
-                            if (this.connectionPromise) this.connectionPromise = undefined;
+                            // Clear lock and promise so next attempt can try again
+                            this.connectionLock = false;
+                            this.connectionPromise = undefined;
                         };
 
                         this.once('connected', onConnect);
@@ -402,10 +405,16 @@ export class AutomationBridge extends EventEmitter {
                 try {
                     // Wait for connection with a short timeout for the connection itself
                     const connectTimeout = 5000;
-                    await Promise.race([
-                        this.connectionPromise,
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('Lazy connection timeout')), connectTimeout))
-                    ]);
+                    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+                    const timeoutPromise = new Promise<never>((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error('Lazy connection timeout')), connectTimeout);
+                    });
+
+                    try {
+                        await Promise.race([this.connectionPromise, timeoutPromise]);
+                    } finally {
+                        if (timeoutId) clearTimeout(timeoutId);
+                    }
                 } catch (err: any) {
                     this.log.error('Lazy connection failed', err);
                     // We don't throw here immediately, we let the isConnected check fail below 
@@ -426,7 +435,7 @@ export class AutomationBridge extends EventEmitter {
         // We use requestTracker directly to check limit as it's the source of truth
         // Note: requestTracker exposes maxPendingRequests via constructor but generic check logic isn't public
         // We assumed getPendingCount() is available
-        if (this.requestTracker.getPendingCount() >= (this as any).requestTracker.maxPendingRequests) {
+        if (this.requestTracker.getPendingCount() >= this.requestTracker.getMaxPendingRequests()) {
             return new Promise<T>((resolve, reject) => {
                 this.queuedRequestItems.push({
                     resolve,
@@ -478,6 +487,7 @@ export class AutomationBridge extends EventEmitter {
         }).catch(() => { }); // catch to prevent unhandled rejection during finally chain? no, finally returns new promise
 
         if (this.send(message)) {
+            this.requestTracker.updateLastRequestSentAt();
             return resultPromise;
         } else {
             this.requestTracker.rejectRequest(requestId, new Error('Failed to send request'));
@@ -491,7 +501,7 @@ export class AutomationBridge extends EventEmitter {
         // while we have capacity and items
         while (
             this.queuedRequestItems.length > 0 &&
-            this.requestTracker.getPendingCount() < (this as any).requestTracker.maxPendingRequests
+            this.requestTracker.getPendingCount() < this.requestTracker.getMaxPendingRequests()
         ) {
             const item = this.queuedRequestItems.shift();
             if (item) {
@@ -541,14 +551,6 @@ export class AutomationBridge extends EventEmitter {
         return sentCount > 0;
     }
 
-    private flushQueue(): void {
-        if (this.requestQueue.length === 0) return;
-        this.log.info(`Flushing ${this.requestQueue.length} queued automation requests`);
-        const queue = [...this.requestQueue];
-        this.requestQueue = [];
-        queue.forEach(fn => fn());
-    }
-
     private emitAutomation<K extends keyof AutomationBridgeEvents>(
         event: K,
         ...args: Parameters<AutomationBridgeEvents[K]>

package/src/automation/connection-manager.ts

@@ -17,6 +17,14 @@ export class ConnectionManager extends EventEmitter {
         super();
     }
 
+    /**
+     * Get the configured heartbeat interval in milliseconds.
+     * @returns The heartbeat interval or 0 if disabled
+     */
+    public getHeartbeatIntervalMs(): number {
+        return this.heartbeatIntervalMs;
+    }
+
     public registerSocket(
         socket: WebSocket,
         port: number,
@@ -47,6 +55,16 @@ export class ConnectionManager extends EventEmitter {
         socket.on('pong', () => {
             this.lastMessageAt = new Date();
         });
+
+        // Auto-cleanup on close or error
+        socket.once('close', () => {
+            this.removeSocket(socket);
+        });
+
+        socket.once('error', (error) => {
+            this.log.error('Socket error in ConnectionManager', error);
+            this.removeSocket(socket);
+        });
     }
 
     public removeSocket(socket: WebSocket): SocketInfo | undefined {

package/src/automation/message-handler.ts

@@ -12,6 +12,30 @@ function FStringSafe(val: unknown): string {
     }
 }
 
+/** Response result with optional saved flag */
+interface ResponseResult {
+    saved?: boolean;
+    action?: string;
+    success?: boolean;
+    message?: string;
+    error?: string;
+    [key: string]: unknown;
+}
+
+/** Event message structure */
+interface EventMessage extends AutomationBridgeMessage {
+    requestId?: string;
+    event?: string;
+    payload?: unknown;
+    result?: ResponseResult;
+    message?: string;
+}
+
+/** Response with optional action field */
+interface ResponseWithAction extends AutomationBridgeResponseMessage {
+    action?: string;
+}
+
 export class MessageHandler {
     private log = new Logger('MessageHandler');
 
@@ -70,7 +94,7 @@ export class MessageHandler {
                 }
 
                 // If the response indicates it's already saved/done, resolve immediately
-                const result = enforcedResponse.result as any;
+                const result = enforcedResponse.result as ResponseResult | undefined;
                 if (result && result.saved === true) {
                     this.requestTracker.resolveRequest(requestId, enforcedResponse);
                     return;
@@ -93,7 +117,7 @@ export class MessageHandler {
     }
 
     private handleAutomationEvent(message: AutomationBridgeMessage): void {
-        const evt: any = message as any;
+        const evt = message as EventMessage;
         const reqId = typeof evt.requestId === 'string' ? evt.requestId : undefined;
 
         if (reqId) {
@@ -106,7 +130,7 @@ export class MessageHandler {
                     const synthetic: AutomationBridgeResponseMessage = {
                         type: 'automation_response',
                         requestId: reqId,
-                        success: evtSuccess !== undefined ? evtSuccess : (baseSuccess !== undefined ? baseSuccess : undefined as any),
+                        success: evtSuccess !== undefined ? evtSuccess : baseSuccess,
                         message: typeof evt.result?.message === 'string' ? evt.result.message : (typeof evt.message === 'string' ? evt.message : FStringSafe(evt.event)),
                         error: typeof evt.result?.error === 'string' ? evt.result.error : undefined,
                         result: evt.result ?? evt.payload ?? undefined
@@ -128,9 +152,10 @@ export class MessageHandler {
         try {
             const expected = (expectedAction || '').toString().toLowerCase();
             const echoed: string | undefined = (() => {
-                const r: any = response as any;
-                const candidate = (typeof r.action === 'string' && r.action) || (typeof r.result?.action === 'string' && r.result.action);
-                return candidate as any;
+                const r = response as ResponseWithAction;
+                const resultObj = response.result as ResponseResult | undefined;
+                const candidate = (typeof r.action === 'string' && r.action) || (typeof resultObj?.action === 'string' && resultObj.action);
+                return candidate || undefined;
             })();
 
             if (expected && echoed && typeof echoed === 'string') {
@@ -151,7 +176,7 @@ export class MessageHandler {
                 const startsEitherWay = got.startsWith(expected) || expected.startsWith(got);
 
                 if (!startsEitherWay) {
-                    const mutated: any = { ...response };
+                    const mutated: ResponseWithAction = { ...response };
                     mutated.success = false;
                     if (!mutated.error) mutated.error = 'ACTION_PREFIX_MISMATCH';
                     const msgBase = typeof mutated.message === 'string' ? mutated.message + ' ' : '';
@@ -160,7 +185,7 @@ export class MessageHandler {
                 }
             }
         } catch (e) {
-            this.log.debug('enforceActionMatch check skipped', e as any);
+            this.log.debug('enforceActionMatch check skipped', e instanceof Error ? e.message : String(e));
         }
         return response;
     }

package/src/automation/request-tracker.ts

@@ -1,21 +1,52 @@
 import { PendingRequest, AutomationBridgeResponseMessage } from './types.js';
 import { randomUUID, createHash } from 'node:crypto';
 
-// Disabled: The two-phase event pattern was causing timeouts because C++ handlers
-// send a single response, not request+event. All actions now use simple request-response.
-const WAIT_FOR_EVENT_ACTIONS = new Set<string>([
-    // Empty - all actions use single response pattern
-]);
+// Note: The two-phase event pattern was disabled because C++ handlers send a single response,
+// not request+event. All actions now use simple request-response. The PendingRequest interface
+// retains waitForEvent/eventTimeout fields for potential future use.
 
 export class RequestTracker {
     private pendingRequests = new Map<string, PendingRequest>();
     private coalescedRequests = new Map<string, Promise<AutomationBridgeResponseMessage>>();
+    private lastRequestSentAt?: Date;
 
 
     constructor(
         private maxPendingRequests: number
     ) { }
 
+    /**
+     * Get the maximum number of pending requests allowed.
+     * @returns The configured maximum pending requests limit
+     */
+    public getMaxPendingRequests(): number {
+        return this.maxPendingRequests;
+    }
+
+    /**
+     * Get the timestamp of when the last request was sent.
+     * @returns The Date of last request or undefined if no requests sent yet
+     */
+    public getLastRequestSentAt(): Date | undefined {
+        return this.lastRequestSentAt;
+    }
+
+    /**
+     * Update the last request sent timestamp.
+     * Called when a new request is dispatched.
+     */
+    public updateLastRequestSentAt(): void {
+        this.lastRequestSentAt = new Date();
+    }
+
+    /**
+     * Create a new pending request with timeout handling.
+     * @param action - The action name being requested
+     * @param payload - The request payload
+     * @param timeoutMs - Timeout in milliseconds before the request fails
+     * @returns Object containing the requestId and a promise that resolves with the response
+     * @throws Error if max pending requests limit is reached
+     */
     public createRequest(
         action: string,
         payload: Record<string, unknown>,
@@ -26,7 +57,6 @@ export class RequestTracker {
         }
 
         const requestId = randomUUID();
-        const waitForEvent = WAIT_FOR_EVENT_ACTIONS.has(action);
 
         const promise = new Promise<AutomationBridgeResponseMessage>((resolve, reject) => {
             const timeout = setTimeout(() => {
@@ -43,7 +73,9 @@ export class RequestTracker {
                 action,
                 payload,
                 requestedAt: new Date(),
-                waitForEvent,
+                // Note: waitForEvent and eventTimeoutMs are preserved for potential future use
+                // but currently all actions use simple request-response pattern
+                waitForEvent: false,
                 eventTimeoutMs: timeoutMs
             });
         });

package/src/config.ts

@@ -40,7 +40,7 @@ export const EnvSchema = z.object({
   // Unreal Settings
   UE_PROJECT_PATH: z.string().optional(),
   UE_EDITOR_EXE: z.string().optional(),
-  UE_SCREENSHOT_DIR: z.string().optional(),
+
 
   // Connection Settings
   MCP_AUTOMATION_PORT: z.preprocess((v) => stringToNumber(v, 8091), z.number().default(8091)),

package/src/constants.ts

@@ -9,4 +9,11 @@ export const DEFAULT_MAX_PENDING_REQUESTS = 25;
 export const DEFAULT_TIME_OF_DAY = 9;
 export const DEFAULT_SUN_INTENSITY = 10000;
 export const DEFAULT_SKYLIGHT_INTENSITY = 1;
+
 export const DEFAULT_SCREENSHOT_RESOLUTION = '1920x1080';
+
+// Operation Timeouts
+export const DEFAULT_OPERATION_TIMEOUT_MS = 30000;
+export const DEFAULT_ASSET_OP_TIMEOUT_MS = 60000;
+export const EXTENDED_ASSET_OP_TIMEOUT_MS = 120000;
+export const LONG_RUNNING_OP_TIMEOUT_MS = 300000;