unreal-engine-mcp-server 0.5.1 → 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/server.json

@@ -1,14 +1,14 @@
 {
-  "$schema": "https://raw.githubusercontent.com/modelcontextprotocol/registry/main/schema.json",
+  "$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.1",
+  "version": "0.5.2",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "unreal-engine-mcp-server",
-      "version": "0.5.1",
+      "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/server/tool-registry.ts

@@ -210,7 +210,7 @@ export class ToolRegistry {
 
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name } = request.params;
-            let args: any = request.params.arguments || {};
+            let args: Record<string, unknown> = request.params.arguments || {};
             const startTime = Date.now();
 
             const connected = await this.ensureConnected();
@@ -258,13 +258,13 @@ export class ToolRegistry {
                         const props = inputSchema.properties || {};
                         const required: string[] = Array.isArray(inputSchema.required) ? inputSchema.required : [];
                         const missing = required.filter((k: string) => {
-                            const v = (args as any)[k];
+                            const v = (args as Record<string, unknown>)[k];
                             if (v === undefined || v === null) return true;
                             if (typeof v === 'string' && v.trim() === '') return true;
                             return false;
                         });
 
-                        const primitiveProps: any = {};
+                        const primitiveProps: Record<string, unknown> = {};
                         for (const k of missing) {
                             const p = props[k];
                             if (!p || typeof p !== 'object') continue;

package/src/tools/actors.ts

@@ -5,6 +5,20 @@ import { IActorTools, StandardActionResponse } from '../types/tool-interfaces.js
 import { ActorResponse } from '../types/automation-responses.js';
 import { wasmIntegration } from '../wasm/index.js';
 
+/** Extended actor response with spawn-specific fields */
+interface SpawnActorResponse extends ActorResponse {
+  data?: {
+    name?: string;
+    objectPath?: string;
+    [key: string]: unknown;
+  };
+  actorName?: string;
+  actorPath?: string;
+  warnings?: string[];
+  details?: unknown[];
+  componentPaths?: string[];
+}
+
 export class ActorTools extends BaseTool implements IActorTools {
   constructor(bridge: UnrealBridge) {
     super(bridge);
@@ -46,7 +60,7 @@ export class ActorTools extends BaseTool implements IActorTools {
     try {
       const bridge = this.getAutomationBridge();
       const timeoutMs = typeof params.timeoutMs === 'number' && params.timeoutMs > 0 ? params.timeoutMs : undefined;
-      const response = await bridge.sendAutomationRequest<ActorResponse>(
+      const response = await bridge.sendAutomationRequest<SpawnActorResponse>(
         'control_actor',
         {
           action: 'spawn',
@@ -61,37 +75,38 @@ export class ActorTools extends BaseTool implements IActorTools {
 
       if (!response || !response.success) {
         const error = response?.error;
-        const errorMsg = typeof error === 'string' ? error : (error as any)?.message || response?.message || 'Failed to spawn actor';
+        const errorObj = typeof error === 'object' && error !== null ? error as { message?: string } : null;
+        const errorMsg = typeof error === 'string' ? error : errorObj?.message || response?.message || 'Failed to spawn actor';
         throw new Error(errorMsg);
       }
 
-      const data = (response as any).data || {};
+      const data = response.data || {};
       const result: StandardActionResponse = {
         success: true,
         message: response.message || `Spawned actor ${className}`,
-        actorName: data.name || (response as any).actorName,
-        actorPath: data.objectPath || (response as any).actorPath,
+        actorName: data.name || response.actorName,
+        actorPath: data.objectPath || response.actorPath,
         resolvedClass: mappedClassPath,
         requestedClass: className,
         location: { x: locX, y: locY, z: locZ },
         rotation: { pitch: rotPitch, yaw: rotYaw, roll: rotRoll },
         data: data,
         actor: {
-          name: data.name || (response as any).actorName,
-          path: data.objectPath || (response as any).actorPath || mappedClassPath
+          name: data.name || response.actorName,
+          path: data.objectPath || response.actorPath || mappedClassPath
         }
       };
 
-      if ((response as any).warnings?.length) {
-        result.warnings = (response as any).warnings;
+      if (response.warnings?.length) {
+        result.warnings = response.warnings;
       }
 
       // Legacy support for older fields if they exist at top level
-      if ((response as any).details?.length) {
-        result.details = (response as any).details;
+      if (response.details?.length) {
+        result.details = response.details;
       }
-      if ((response as any).componentPaths?.length) {
-        result.componentPaths = (response as any).componentPaths;
+      if (response.componentPaths?.length) {
+        result.componentPaths = response.componentPaths;
       }
 
       return result;
@@ -293,12 +308,22 @@ export class ActorTools extends BaseTool implements IActorTools {
     if (typeof actorName !== 'string' || actorName.trim().length === 0) {
       throw new Error('Invalid actorName');
     }
-    return this.sendRequest<StandardActionResponse>('get_transform', { actorName }, 'control_actor')
-      .then(response => {
-        // If response is standardized, extract data or return as is.
-        // For now, return the full response which includes data.
-        return response;
-      });
+    const response = await this.sendRequest<StandardActionResponse>('get_transform', { actorName }, 'control_actor');
+    if (!response.success) {
+      return { success: false, error: response.error || `Failed to get transform for actor ${actorName}` };
+    }
+
+    // Extract transform data from nested response (data.data or data or result)
+    const rawData: any = response.data ?? response.result ?? response;
+    const data: any = rawData?.data ?? rawData;
+
+    return {
+      success: true,
+      message: 'Transform retrieved',
+      location: data.location ?? data.Location,
+      rotation: data.rotation ?? data.Rotation,
+      scale: data.scale ?? data.Scale
+    };
   }
 
   async setVisibility(params: { actorName: string; visible: boolean }) {

package/src/tools/assets.ts

@@ -230,7 +230,7 @@ export class AssetTools extends BaseTool implements IAssetTools {
     // BaseTool unwraps the result, so 'response' is likely the payload itself.
     // However, if the result was null, 'response' might be the wrapper.
     // We handle both cases to be robust.
-    const resultObj = (response.result || response) as Record<string, any>;
+    const resultObj = (response.result || response) as Record<string, unknown>;
     return {
       success: true,
       message: 'Metadata retrieved',
@@ -310,8 +310,8 @@ export class AssetTools extends BaseTool implements IAssetTools {
         message: 'graph analyzed',
         analysis
       };
-    } catch (e: any) {
-      return { success: false, error: `Analysis failed: ${e.message} ` };
+    } catch (e: unknown) {
+      return { success: false, error: `Analysis failed: ${e instanceof Error ? e.message : String(e)} ` };
     }
   }