unreal-engine-mcp-server 0.5.2 → 0.5.4

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

@@ -1,6 +1,7 @@
 #include "McpAutomationBridgeGlobals.h"
 #include "McpAutomationBridgeHelpers.h"
 #include "McpAutomationBridgeSubsystem.h"
+#include "UObject/UObjectIterator.h"
 
 #include "Components/ExponentialHeightFogComponent.h"
 #include "Engine/ExponentialHeightFog.h"
@@ -107,71 +108,52 @@ bool UMcpAutomationBridgeSubsystem::HandleLightingAction(
       return true;
     }
 
-    UClass *LightClass = nullptr;
-    if (LightClassStr == TEXT("DirectionalLight"))
-      LightClass = ADirectionalLight::StaticClass();
-    else if (LightClassStr == TEXT("PointLight"))
-      LightClass = APointLight::StaticClass();
-    else if (LightClassStr == TEXT("SpotLight"))
-      LightClass = ASpotLight::StaticClass();
-    else if (LightClassStr == TEXT("RectLight"))
-      LightClass = ARectLight::StaticClass();
-    else {
-      // Dynamic fallback: Try to resolve any light class by name
-      LightClass = ResolveUClass(LightClassStr);
-
-      // Try with "A" prefix for actor classes (e.g., "SkyLight" -> "ASkyLight")
-      if (!LightClass && !LightClassStr.StartsWith(TEXT("A"))) {
-        LightClass =
-            ResolveUClass(FString::Printf(TEXT("A%s"), *LightClassStr));
-      }
+    // Dynamic resolution with heuristics
+    UClass *LightClass = ResolveUClass(LightClassStr);
 
-      // Validate the resolved class is actually a light actor
-      if (!LightClass || !LightClass->IsChildOf(ALight::StaticClass())) {
-        SendAutomationError(
-            RequestingSocket, RequestId,
-            FString::Printf(
-                TEXT("Light class not found or not a light type: %s"),
-                *LightClassStr),
-            TEXT("INVALID_ARGUMENT"));
-        return true;
-      }
+    // Try finding with 'A' prefix (standard Actor prefix)
+    if (!LightClass) {
+      LightClass = ResolveUClass(TEXT("A") + LightClassStr);
+    }
+
+    if (!LightClass || !LightClass->IsChildOf(ALight::StaticClass())) {
+      SendAutomationError(
+          RequestingSocket, RequestId,
+          FString::Printf(TEXT("Invalid light class: %s"), *LightClassStr),
+          TEXT("INVALID_ARGUMENT"));
+      return true;
     }
 
     FVector Location = FVector::ZeroVector;
-    const TSharedPtr<FJsonObject> *LocObj;
-    if (Payload->TryGetObjectField(TEXT("location"), LocObj)) {
-      Location.X = (*LocObj)->GetNumberField(TEXT("x"));
-      Location.Y = (*LocObj)->GetNumberField(TEXT("y"));
-      Location.Z = (*LocObj)->GetNumberField(TEXT("z"));
+    const TSharedPtr<FJsonObject> *LocPtr;
+    if (Payload->TryGetObjectField(TEXT("location"), LocPtr)) {
+      Location.X = (*LocPtr)->GetNumberField(TEXT("x"));
+      Location.Y = (*LocPtr)->GetNumberField(TEXT("y"));
+      Location.Z = (*LocPtr)->GetNumberField(TEXT("z"));
     }
 
     FRotator Rotation = FRotator::ZeroRotator;
-    const TSharedPtr<FJsonObject> *RotObj;
-    if (Payload->TryGetObjectField(TEXT("rotation"), RotObj)) {
-      Rotation.Pitch = (*RotObj)->GetNumberField(TEXT("pitch"));
-      Rotation.Yaw = (*RotObj)->GetNumberField(TEXT("yaw"));
-      Rotation.Roll = (*RotObj)->GetNumberField(TEXT("roll"));
-    }
-
-    AActor *NewLight = nullptr;
-    UWorld *TargetWorld = (GEditor->PlayWorld) ? GEditor->PlayWorld : nullptr;
-
-    if (TargetWorld) {
-      // PIE Path
-      FActorSpawnParameters SpawnParams;
-      SpawnParams.SpawnCollisionHandlingOverride =
-          ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
-      NewLight = TargetWorld->SpawnActor(LightClass, &Location, &Rotation,
-                                         SpawnParams);
-    } else {
-      // Editor Path
-      NewLight = ActorSS->SpawnActorFromClass(LightClass, Location, Rotation);
-      // Explicitly set location/rotation
-      if (NewLight) {
-        NewLight->SetActorLocationAndRotation(
-            Location, Rotation, false, nullptr, ETeleportType::TeleportPhysics);
-      }
+    const TSharedPtr<FJsonObject> *RotPtr;
+    if (Payload->TryGetObjectField(TEXT("rotation"), RotPtr)) {
+      Rotation.Pitch = (*RotPtr)->GetNumberField(TEXT("pitch"));
+      Rotation.Yaw = (*RotPtr)->GetNumberField(TEXT("yaw"));
+      Rotation.Roll = (*RotPtr)->GetNumberField(TEXT("roll"));
+    }
+
+    FActorSpawnParameters SpawnParams;
+    SpawnParams.SpawnCollisionHandlingOverride =
+        ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+
+    // Fix: Declare NewLight before use
+    AActor *NewLight = ActorSS->GetWorld()->SpawnActor(LightClass, &Location,
+                                                       &Rotation, SpawnParams);
+
+    // Explicitly set location/rotation
+    if (NewLight) {
+      // Set label immediately
+      NewLight->SetActorLabel(LightClassStr);
+      NewLight->SetActorLocationAndRotation(Location, Rotation, false, nullptr,
+                                            ETeleportType::TeleportPhysics);
     }
 
     if (!NewLight) {

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

@@ -7,6 +7,7 @@
 #include "MovieSceneSection.h"
 #include "MovieSceneSequence.h"
 #include "MovieSceneTrack.h"
+#include "UObject/UObjectIterator.h"
 
 #if WITH_EDITOR
 #include "Editor.h"
@@ -2484,59 +2485,39 @@ bool UMcpAutomationBridgeSubsystem::HandleSequenceAction(
 
     // Add the track
     UMovieSceneTrack *NewTrack = nullptr;
-    FString TrackTypeLower = TrackType.ToLower();
 
-#if __has_include("Tracks/MovieScene3DTransformTrack.h")
-    if (TrackTypeLower == TEXT("transform") ||
-        TrackTypeLower == TEXT("3dtransform")) {
-      if (BindingGuid.IsValid()) {
-        NewTrack = MovieScene->AddTrack(
-            UMovieScene3DTransformTrack::StaticClass(), BindingGuid);
-      }
-    }
-#endif
+    // Dynamic resolution with heuristics
+    UClass *TrackClass = ResolveUClass(TrackType);
 
-    if (TrackTypeLower == TEXT("audio")) {
-      if (BindingGuid.IsValid()) {
-        NewTrack = MovieScene->AddTrack(UMovieSceneAudioTrack::StaticClass(),
-                                        BindingGuid);
-      } else {
-        NewTrack = MovieScene->AddTrack(UMovieSceneAudioTrack::StaticClass());
-      }
+    // Try with common prefixes
+    if (!TrackClass) {
+      TrackClass = ResolveUClass(
+          FString::Printf(TEXT("UMovieScene%sTrack"), *TrackType));
+    }
+    if (!TrackClass) {
+      TrackClass =
+          ResolveUClass(FString::Printf(TEXT("MovieScene%sTrack"), *TrackType));
+    }
+    // Try simple "U" prefix
+    if (!TrackClass) {
+      TrackClass = ResolveUClass(FString::Printf(TEXT("U%s"), *TrackType));
     }
 
-    if (TrackTypeLower == TEXT("event")) {
+    // Validate it's actually a track class
+    if (TrackClass && TrackClass->IsChildOf(UMovieSceneTrack::StaticClass())) {
       if (BindingGuid.IsValid()) {
-        NewTrack = MovieScene->AddTrack(UMovieSceneEventTrack::StaticClass(),
-                                        BindingGuid);
+        NewTrack = MovieScene->AddTrack(TrackClass, BindingGuid);
       } else {
-        NewTrack = MovieScene->AddTrack(UMovieSceneEventTrack::StaticClass());
-      }
-    }
-
-    // Dynamic fallback: Try to resolve any track class by name
-    if (!NewTrack) {
-      UClass *TrackClass = ResolveUClass(TrackType);
-
-      // Try with common prefixes
-      if (!TrackClass) {
-        TrackClass = ResolveUClass(
-            FString::Printf(TEXT("UMovieScene%sTrack"), *TrackType));
-      }
-      if (!TrackClass) {
-        TrackClass = ResolveUClass(
-            FString::Printf(TEXT("MovieScene%sTrack"), *TrackType));
-      }
-
-      // Validate it's actually a track class
-      if (TrackClass &&
-          TrackClass->IsChildOf(UMovieSceneTrack::StaticClass())) {
-        if (BindingGuid.IsValid()) {
-          NewTrack = MovieScene->AddTrack(TrackClass, BindingGuid);
-        } else {
-          NewTrack = MovieScene->AddTrack(TrackClass);
-        }
+        NewTrack = MovieScene->AddTrack(TrackClass);
       }
+    } else if (TrackClass) {
+      // Found a class but it's not a track
+      SendAutomationError(
+          RequestingSocket, RequestId,
+          FString::Printf(TEXT("Class '%s' is not a UMovieSceneTrack"),
+                          *TrackClass->GetName()),
+          TEXT("INVALID_CLASS_TYPE"));
+      return true;
     }
 
     if (NewTrack) {

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

@@ -446,6 +446,8 @@ uint32 FMcpBridgeWebSocket::RunServer() {
   TSharedRef<FInternetAddr> ListenAddr = SocketSubsystem->CreateInternetAddr();
 
   bool bResolvedHost = false;
+  bool bExplicitBindAll = false;
+
   if (!ListenHost.IsEmpty()) {
     FString HostToBind = ListenHost;
     if (HostToBind.Equals(TEXT("localhost"), ESearchCase::IgnoreCase)) {
@@ -457,10 +459,23 @@ uint32 FMcpBridgeWebSocket::RunServer() {
     if (bIsValidIp) {
       bResolvedHost = true;
     }
+
+    bExplicitBindAll = HostToBind.Equals(TEXT("0.0.0.0"), ESearchCase::IgnoreCase) ||
+                       HostToBind.Equals(TEXT("::"), ESearchCase::IgnoreCase);
   }
 
   if (!bResolvedHost) {
-    ListenAddr->SetAnyAddress();
+    if (!bExplicitBindAll) {
+      UE_LOG(LogMcpAutomationBridgeSubsystem, Warning,
+             TEXT("Invalid ListenHost '%s'. Falling back to 127.0.0.1 for safety. To bind all interfaces, explicitly set ListenHost=0.0.0.0."),
+             *ListenHost);
+
+      bool bFallbackIsValidIp = false;
+      ListenAddr->SetIp(TEXT("127.0.0.1"), bFallbackIsValidIp);
+      bResolvedHost = bFallbackIsValidIp;
+    } else {
+      ListenAddr->SetAnyAddress();
+    }
   }
 
   ListenAddr->SetPort(Port);

package/server.json

@@ -2,13 +2,13 @@
   "$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.2",
+  "version": "0.5.4",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "unreal-engine-mcp-server",
-      "version": "0.5.2",
+      "version": "0.5.4",
       "transport": {
         "type": "stdio"
       },

package/src/automation/bridge.ts

@@ -6,7 +6,9 @@ import {
     DEFAULT_AUTOMATION_PORT,
     DEFAULT_NEGOTIATED_PROTOCOLS,
     DEFAULT_HEARTBEAT_INTERVAL_MS,
-    DEFAULT_MAX_PENDING_REQUESTS
+    DEFAULT_MAX_PENDING_REQUESTS,
+    DEFAULT_MAX_QUEUED_REQUESTS,
+    MAX_WS_MESSAGE_SIZE_BYTES
 } from '../constants.js';
 import { createRequire } from 'node:module';
 import {
@@ -45,6 +47,7 @@ export class AutomationBridge extends EventEmitter {
     private readonly clientPort: number;
     private readonly serverLegacyEnabled: boolean;
     private readonly maxConcurrentConnections: number;
+    private readonly maxQueuedRequests: number;
 
     private connectionManager: ConnectionManager;
     private requestTracker: RequestTracker;
@@ -131,6 +134,7 @@ export class AutomationBridge extends EventEmitter {
 
         const maxPendingRequests = Math.max(1, options.maxPendingRequests ?? DEFAULT_MAX_PENDING_REQUESTS);
         const maxConcurrentConnections = Math.max(1, options.maxConcurrentConnections ?? 10);
+        this.maxQueuedRequests = Math.max(0, options.maxQueuedRequests ?? DEFAULT_MAX_QUEUED_REQUESTS);
 
         this.clientHost = options.clientHost ?? process.env.MCP_AUTOMATION_CLIENT_HOST ?? DEFAULT_AUTOMATION_HOST;
         this.clientPort = options.clientPort ?? sanitizePort(process.env.MCP_AUTOMATION_CLIENT_PORT) ?? DEFAULT_AUTOMATION_PORT;
@@ -185,13 +189,21 @@ export class AutomationBridge extends EventEmitter {
 
             this.log.debug(`Negotiated protocols: ${JSON.stringify(this.negotiatedProtocols)}`);
 
-            // Compatibility fix: If only one protocol, pass as string to ensure ws/plugin compatibility
-            const protocols = 'mcp-automation';
+            const protocols = this.negotiatedProtocols.length === 1
+                ? this.negotiatedProtocols[0]
+                : this.negotiatedProtocols;
 
             this.log.debug(`Using WebSocket protocols arg: ${JSON.stringify(protocols)}`);
 
+            const headers: Record<string, string> | undefined = this.capabilityToken
+                ? {
+                    'X-MCP-Capability': this.capabilityToken,
+                    'X-MCP-Capability-Token': this.capabilityToken
+                  }
+                : undefined;
+
             const socket = new WebSocket(url, protocols, {
-                headers: this.capabilityToken ? { 'X-MCP-Capability': this.capabilityToken } : undefined,
+                headers,
                 perMessageDeflate: false
             });
 
@@ -233,10 +245,69 @@ export class AutomationBridge extends EventEmitter {
                     protocol: socket.protocol || null
                 });
 
-                // Set up message handling for the authenticated socket
+                const getRawDataByteLength = (data: unknown): number => {
+                    if (typeof data === 'string') {
+                        return Buffer.byteLength(data, 'utf8');
+                    }
+
+                    if (Buffer.isBuffer(data)) {
+                        return data.length;
+                    }
+
+                    if (Array.isArray(data)) {
+                        return data.reduce((total, item) => total + (Buffer.isBuffer(item) ? item.length : 0), 0);
+                    }
+
+                    if (data instanceof ArrayBuffer) {
+                        return data.byteLength;
+                    }
+
+                    if (ArrayBuffer.isView(data)) {
+                        return data.byteLength;
+                    }
+
+                    return 0;
+                };
+
+                const rawDataToUtf8String = (data: unknown, byteLengthHint?: number): string => {
+                    if (typeof data === 'string') {
+                        return data;
+                    }
+
+                    if (Buffer.isBuffer(data)) {
+                        return data.toString('utf8');
+                    }
+
+                    if (Array.isArray(data)) {
+                        const buffers = data.filter((item): item is Buffer => Buffer.isBuffer(item));
+                        const totalLength = typeof byteLengthHint === 'number'
+                            ? byteLengthHint
+                            : buffers.reduce((total, item) => total + item.length, 0);
+                        return Buffer.concat(buffers, totalLength).toString('utf8');
+                    }
+
+                    if (data instanceof ArrayBuffer) {
+                        return Buffer.from(data).toString('utf8');
+                    }
+
+                    if (ArrayBuffer.isView(data)) {
+                        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString('utf8');
+                    }
+
+                    return '';
+                };
+
                 socket.on('message', (data) => {
                     try {
-                        const text = typeof data === 'string' ? data : data.toString('utf8');
+                        const byteLength = getRawDataByteLength(data);
+                        if (byteLength > MAX_WS_MESSAGE_SIZE_BYTES) {
+                            this.log.error(
+                                `Received oversized message (${byteLength} bytes, max: ${MAX_WS_MESSAGE_SIZE_BYTES}). Dropping.`
+                            );
+                            return;
+                        }
+
+                        const text = rawDataToUtf8String(data, byteLength);
                         this.log.debug(`[AutomationBridge Client] Received message: ${text.substring(0, 1000)}`);
                         const parsed = JSON.parse(text) as AutomationBridgeMessage;
                         this.connectionManager.updateLastMessageTime();
@@ -431,11 +502,10 @@ export class AutomationBridge extends EventEmitter {
             throw new Error('Automation bridge not connected');
         }
 
-        // Check if we need to queue (unless it's a priority request which standard ones are not)
-        // 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.requestTracker.getMaxPendingRequests()) {
+            if (this.queuedRequestItems.length >= this.maxQueuedRequests) {
+                throw new Error(`Automation bridge request queue is full (max: ${this.maxQueuedRequests}). Please retry later.`);
+            }
             return new Promise<T>((resolve, reject) => {
                 this.queuedRequestItems.push({
                     resolve,

package/src/automation/types.ts

@@ -12,6 +12,7 @@ export interface AutomationBridgeOptions {
     heartbeatIntervalMs?: number;
     maxPendingRequests?: number;
     maxConcurrentConnections?: number;
+    maxQueuedRequests?: number;
     clientMode?: boolean;
     clientHost?: string;
     clientPort?: number;

package/src/config/class-aliases.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared configuration for Unreal Engine class names and aliases.
+ * Centralizes class mappings to avoid duplication across handlers.
+ */
+
+/**
+ * User-friendly class name aliases to full Unreal class paths.
+ * These allow users to specify simpler names like 'PointLight' instead of '/Script/Engine.PointLight'.
+ */
+export const ACTOR_CLASS_ALIASES: Record<string, string> = {
+    // Special cases that need component addition
+    'SplineActor': '/Script/Engine.Actor',
+    'Spline': '/Script/Engine.Actor',
+
+    // Light actors
+    'PointLight': '/Script/Engine.PointLight',
+    'SpotLight': '/Script/Engine.SpotLight',
+    'DirectionalLight': '/Script/Engine.DirectionalLight',
+    'RectLight': '/Script/Engine.RectLight',
+
+    // Camera actors
+    'Camera': '/Script/Engine.CameraActor',
+    'CameraActor': '/Script/Engine.CameraActor',
+
+    // Mesh actors
+    'StaticMeshActor': '/Script/Engine.StaticMeshActor',
+    'SkeletalMeshActor': '/Script/Engine.SkeletalMeshActor',
+
+    // Gameplay actors
+    'PlayerStart': '/Script/Engine.PlayerStart',
+    'Pawn': '/Script/Engine.Pawn',
+    'Character': '/Script/Engine.Character',
+    'Actor': '/Script/Engine.Actor',
+
+    // Trigger volumes
+    'TriggerBox': '/Script/Engine.TriggerBox',
+    'TriggerSphere': '/Script/Engine.TriggerSphere',
+    'BlockingVolume': '/Script/Engine.BlockingVolume',
+};
+
+/**
+ * Class aliases that require a component to be auto-added after spawning.
+ */
+export const CLASSES_REQUIRING_COMPONENT: Record<string, string> = {
+    'SplineActor': 'SplineComponent',
+    'Spline': 'SplineComponent',
+};
+
+/**
+ * Resolve a class name alias to its full Unreal class path.
+ * @param classNameOrPath - The class name or alias to resolve
+ * @returns The full class path, or the original if not an alias
+ */
+export function resolveClassAlias(classNameOrPath: string): string {
+    return ACTOR_CLASS_ALIASES[classNameOrPath] || classNameOrPath;
+}
+
+/**
+ * Check if a class alias requires an auto-added component.
+ * @param className - The original class name or alias
+ * @returns The component name to add, or undefined
+ */
+export function getRequiredComponent(className: string): string | undefined {
+    return CLASSES_REQUIRING_COMPONENT[className];
+}

package/src/constants.ts

@@ -6,6 +6,7 @@ export const DEFAULT_NEGOTIATED_PROTOCOLS = ['mcp-automation'];
 export const DEFAULT_HEARTBEAT_INTERVAL_MS = 10000;
 export const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5000;
 export const DEFAULT_MAX_PENDING_REQUESTS = 25;
+export const DEFAULT_MAX_QUEUED_REQUESTS = 100;
 export const DEFAULT_TIME_OF_DAY = 9;
 export const DEFAULT_SUN_INTENSITY = 10000;
 export const DEFAULT_SKYLIGHT_INTENSITY = 1;
@@ -17,3 +18,12 @@ 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;
+
+// Command-specific timeouts
+export const CONSOLE_COMMAND_TIMEOUT_MS = 30000;
+export const ENGINE_QUERY_TIMEOUT_MS = 15000;
+export const CONNECTION_TIMEOUT_MS = 15000;
+
+// Message size limits
+export const MAX_WS_MESSAGE_SIZE_BYTES = 5 * 1024 * 1024;
+

package/src/graphql/server.ts

@@ -50,11 +50,32 @@ export class GraphQLServer {
       return;
     }
 
+    const isLoopback = this.config.host === '127.0.0.1' ||
+                        this.config.host === '::1' ||
+                        this.config.host.toLowerCase() === 'localhost';
+
+    const allowRemote = process.env.GRAPHQL_ALLOW_REMOTE === 'true';
+
+    if (!isLoopback && !allowRemote) {
+      this.log.warn(
+        `GraphQL server is configured to bind to non-loopback host '${this.config.host}'. GraphQL is for local debugging only. ` +
+          'To allow remote binding, set GRAPHQL_ALLOW_REMOTE=true. Aborting start.'
+      );
+      return;
+    }
+
+    if (!isLoopback && allowRemote) {
+      if (this.config.cors.origin === '*') {
+        this.log.warn(
+          "GraphQL server is binding to a remote host with permissive CORS origin '*'. " +
+            'Set GRAPHQL_CORS_ORIGIN to specific origins for production. Using permissive CORS for now.'
+        );
+      }
+    }
+
     try {
-      // Create GraphQL schema
       const schema = createGraphQLSchema(this.bridge, this.automationBridge);
 
-      // Create Yoga server
       const yoga = createYoga({
         schema,
         graphqlEndpoint: this.config.path,
@@ -77,12 +98,10 @@ export class GraphQLServer {
         }
       });
 
-      // Create HTTP server with Yoga's request handler
       this.server = createServer(
         yoga as any
       );
 
-      // Start server
       await new Promise<void>((resolve, reject) => {
         if (!this.server) {
           reject(new Error('Server not initialized'));
@@ -102,9 +121,6 @@ export class GraphQLServer {
           resolve();
         });
       });
-
-      // Setup graceful shutdown
-      this.setupShutdown();
     } catch (error) {
       this.log.error('Failed to start GraphQL server:', error);
       throw error;
@@ -130,22 +146,6 @@ export class GraphQLServer {
     });
   }
 
-  private setupShutdown(): void {
-    const gracefulShutdown = async (signal: string) => {
-      this.log.info(`Received ${signal}, shutting down GraphQL server...`);
-      try {
-        await this.stop();
-        process.exit(0);
-      } catch (error) {
-        this.log.error('Error during GraphQL server shutdown:', error);
-        process.exit(1);
-      }
-    };
-
-    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-  }
-
   getConfig() {
     return this.config;
   }

package/src/index.ts

@@ -30,7 +30,7 @@ const DEFAULT_SERVER_NAME = typeof packageInfo.name === 'string' && packageInfo.
   : 'unreal-engine-mcp';
 const DEFAULT_SERVER_VERSION = typeof packageInfo.version === 'string' && packageInfo.version.trim().length > 0
   ? packageInfo.version
-  : '0.0.0';
+  : '0.5.4';
 
 function routeStdoutLogsToStderr(): void {
   if (!config.MCP_ROUTE_STDOUT_LOGS) {