flockbay 0.10.15

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Private/UnrealMCPBridge.cpp

@@ -0,0 +1,419 @@
+#include "UnrealMCPBridge.h"
+#include "MCPServerRunnable.h"
+#include "Sockets.h"
+#include "SocketSubsystem.h"
+#include "HAL/RunnableThread.h"
+#include "Interfaces/IPv4/IPv4Address.h"
+#include "Interfaces/IPv4/IPv4Endpoint.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+#include "Serialization/JsonSerializer.h"
+#include "Serialization/JsonReader.h"
+#include "Serialization/JsonWriter.h"
+#include "Engine/StaticMeshActor.h"
+#include "Engine/DirectionalLight.h"
+#include "Engine/PointLight.h"
+#include "Engine/SpotLight.h"
+#include "Camera/CameraActor.h"
+#include "EditorAssetLibrary.h"
+#include "AssetRegistry/AssetRegistryModule.h"
+#include "JsonObjectConverter.h"
+#include "GameFramework/Actor.h"
+#include "Engine/Selection.h"
+#include "Kismet/GameplayStatics.h"
+#include "Async/Async.h"
+// Add Blueprint related includes
+#include "Engine/Blueprint.h"
+#include "Engine/BlueprintGeneratedClass.h"
+#include "Factories/BlueprintFactory.h"
+#include "EdGraphSchema_K2.h"
+#include "K2Node_Event.h"
+#include "K2Node_VariableGet.h"
+#include "K2Node_VariableSet.h"
+#include "Components/StaticMeshComponent.h"
+#include "Components/BoxComponent.h"
+#include "Components/SphereComponent.h"
+#include "Kismet2/BlueprintEditorUtils.h"
+#include "Kismet2/KismetEditorUtilities.h"
+// UE5.5 correct includes
+#include "Engine/SimpleConstructionScript.h"
+#include "Engine/SCS_Node.h"
+#include "UObject/Field.h"
+#include "UObject/FieldPath.h"
+// Blueprint Graph specific includes
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "EdGraph/EdGraphPin.h"
+#include "K2Node_CallFunction.h"
+#include "K2Node_InputAction.h"
+#include "K2Node_Self.h"
+#include "GameFramework/InputSettings.h"
+#include "EditorSubsystem.h"
+#include "Subsystems/EditorActorSubsystem.h"
+// Include our new command handler classes
+#include "Commands/UnrealMCPEditorCommands.h"
+#include "Commands/UnrealMCPBlueprintCommands.h"
+#include "Commands/UnrealMCPBlueprintNodeCommands.h"
+#include "Commands/UnrealMCPProjectCommands.h"
+#include "Commands/UnrealMCPCommonUtils.h"
+#include "Commands/UnrealMCPUMGCommands.h"
+#include "Interfaces/IPluginManager.h"
+
+// Default settings
+#define MCP_SERVER_HOST "127.0.0.1"
+#define MCP_SERVER_PORT 55557
+
+UUnrealMCPBridge::UUnrealMCPBridge()
+{
+    EditorCommands = MakeShared<FUnrealMCPEditorCommands>();
+    BlueprintCommands = MakeShared<FUnrealMCPBlueprintCommands>();
+    BlueprintNodeCommands = MakeShared<FUnrealMCPBlueprintNodeCommands>();
+    ProjectCommands = MakeShared<FUnrealMCPProjectCommands>();
+    UMGCommands = MakeShared<FUnrealMCPUMGCommands>();
+}
+
+UUnrealMCPBridge::~UUnrealMCPBridge()
+{
+    EditorCommands.Reset();
+    BlueprintCommands.Reset();
+    BlueprintNodeCommands.Reset();
+    ProjectCommands.Reset();
+    UMGCommands.Reset();
+}
+
+// Initialize subsystem
+void UUnrealMCPBridge::Initialize(FSubsystemCollectionBase& Collection)
+{
+    UE_LOG(LogTemp, Display, TEXT("UnrealMCPBridge: Initializing"));
+    
+    bIsRunning = false;
+    ListenerSocket = nullptr;
+    ConnectionSocket = nullptr;
+    ServerThread = nullptr;
+    Port = MCP_SERVER_PORT;
+    FIPv4Address::Parse(MCP_SERVER_HOST, ServerAddress);
+
+    // Start the server automatically
+    StartServer();
+}
+
+// Clean up resources when subsystem is destroyed
+void UUnrealMCPBridge::Deinitialize()
+{
+    UE_LOG(LogTemp, Display, TEXT("UnrealMCPBridge: Shutting down"));
+    StopServer();
+}
+
+// Start the MCP server
+void UUnrealMCPBridge::StartServer()
+{
+    if (bIsRunning)
+    {
+        UE_LOG(LogTemp, Warning, TEXT("UnrealMCPBridge: Server is already running"));
+        return;
+    }
+
+    // Create socket subsystem
+    ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
+    if (!SocketSubsystem)
+    {
+        UE_LOG(LogTemp, Error, TEXT("UnrealMCPBridge: Failed to get socket subsystem"));
+        return;
+    }
+
+    // Create listener socket
+    TSharedPtr<FSocket> NewListenerSocket = MakeShareable(SocketSubsystem->CreateSocket(NAME_Stream, TEXT("UnrealMCPListener"), false));
+    if (!NewListenerSocket.IsValid())
+    {
+        UE_LOG(LogTemp, Error, TEXT("UnrealMCPBridge: Failed to create listener socket"));
+        return;
+    }
+
+    // Allow address reuse for quick restarts
+    NewListenerSocket->SetReuseAddr(true);
+    NewListenerSocket->SetNonBlocking(true);
+
+    // Bind to address
+    FIPv4Endpoint Endpoint(ServerAddress, Port);
+    if (!NewListenerSocket->Bind(*Endpoint.ToInternetAddr()))
+    {
+        UE_LOG(LogTemp, Error, TEXT("UnrealMCPBridge: Failed to bind listener socket to %s:%d"), *ServerAddress.ToString(), Port);
+        return;
+    }
+
+    // Start listening
+    if (!NewListenerSocket->Listen(5))
+    {
+        UE_LOG(LogTemp, Error, TEXT("UnrealMCPBridge: Failed to start listening"));
+        return;
+    }
+
+    ListenerSocket = NewListenerSocket;
+    bIsRunning = true;
+    UE_LOG(LogTemp, Display, TEXT("UnrealMCPBridge: Server started on %s:%d"), *ServerAddress.ToString(), Port);
+
+    // Start server thread
+    ServerThread = FRunnableThread::Create(
+        new FMCPServerRunnable(this, ListenerSocket),
+        TEXT("UnrealMCPServerThread"),
+        0, TPri_Normal
+    );
+
+    if (!ServerThread)
+    {
+        UE_LOG(LogTemp, Error, TEXT("UnrealMCPBridge: Failed to create server thread"));
+        StopServer();
+        return;
+    }
+}
+
+// Stop the MCP server
+void UUnrealMCPBridge::StopServer()
+{
+    if (!bIsRunning)
+    {
+        return;
+    }
+
+    bIsRunning = false;
+
+    // Clean up thread
+    if (ServerThread)
+    {
+        ServerThread->Kill(true);
+        delete ServerThread;
+        ServerThread = nullptr;
+    }
+
+    // Close sockets
+    if (ConnectionSocket.IsValid())
+    {
+        ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(ConnectionSocket.Get());
+        ConnectionSocket.Reset();
+    }
+
+    if (ListenerSocket.IsValid())
+    {
+        ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(ListenerSocket.Get());
+        ListenerSocket.Reset();
+    }
+
+    UE_LOG(LogTemp, Display, TEXT("UnrealMCPBridge: Server stopped"));
+}
+
+// Execute a command received from a client
+FString UUnrealMCPBridge::ExecuteCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params)
+{
+    UE_LOG(LogTemp, Display, TEXT("UnrealMCPBridge: Executing command: %s"), *CommandType);
+    
+    // Create a promise to wait for the result
+    TPromise<FString> Promise;
+    TFuture<FString> Future = Promise.GetFuture();
+    
+    // Queue execution on Game Thread
+    AsyncTask(ENamedThreads::GameThread, [this, CommandType, Params, Promise = MoveTemp(Promise)]() mutable
+    {
+        TSharedPtr<FJsonObject> ResponseJson = MakeShareable(new FJsonObject);
+        
+        try
+        {
+            TSharedPtr<FJsonObject> ResultJson;
+            
+            if (CommandType == TEXT("ping"))
+            {
+                ResultJson = MakeShareable(new FJsonObject);
+                ResultJson->SetStringField(TEXT("message"), TEXT("pong"));
+            }
+            else if (CommandType == TEXT("get_plugin_info"))
+            {
+                TSharedPtr<IPlugin> Plugin = IPluginManager::Get().FindPlugin(TEXT("UnrealMCP"));
+                if (!Plugin.IsValid())
+                {
+                    ResponseJson->SetStringField(TEXT("status"), TEXT("error"));
+                    ResponseJson->SetStringField(TEXT("error"), TEXT("Plugin not found: UnrealMCP"));
+
+                    FString ResultString;
+                    TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&ResultString);
+                    FJsonSerializer::Serialize(ResponseJson.ToSharedRef(), Writer);
+                    Promise.SetValue(ResultString);
+                    return;
+                }
+
+                const FPluginDescriptor& Descriptor = Plugin->GetDescriptor();
+
+                ResultJson = MakeShareable(new FJsonObject);
+                ResultJson->SetStringField(TEXT("name"), Plugin->GetName());
+                ResultJson->SetStringField(TEXT("baseDir"), Plugin->GetBaseDir());
+                ResultJson->SetStringField(TEXT("friendlyName"), Descriptor.FriendlyName);
+                ResultJson->SetStringField(TEXT("createdBy"), Descriptor.CreatedBy);
+                ResultJson->SetStringField(TEXT("versionName"), Descriptor.VersionName);
+                ResultJson->SetNumberField(TEXT("version"), Descriptor.Version);
+                ResultJson->SetBoolField(TEXT("installed"), Descriptor.bInstalled);
+
+                // Keep this list explicit so it always matches the exact build running in the editor.
+                TArray<TSharedPtr<FJsonValue>> Commands;
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("ping"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("get_plugin_info"))));
+
+                // Editor commands
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("get_actors_in_level"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("find_actors_by_name"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("spawn_actor"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("create_actor"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("delete_actor"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_actor_transform"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("get_actor_properties"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_actor_property"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("spawn_blueprint_actor"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("focus_viewport"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("take_screenshot"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("get_play_in_editor_status"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("play_in_editor"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("play_in_editor_windowed"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("stop_play_in_editor"))));
+
+                // Blueprint commands
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("create_blueprint"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_component_to_blueprint"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_component_property"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_physics_properties"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("compile_blueprint"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_blueprint_property"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_static_mesh_properties"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_pawn_properties"))));
+
+                // Blueprint node commands
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("connect_blueprint_nodes"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_get_self_component_reference"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_self_reference"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("find_blueprint_nodes"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_event_node"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_input_action_node"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_function_node"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_get_component_node"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_blueprint_variable"))));
+
+                // Project commands
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("create_input_mapping"))));
+
+                // UMG commands
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("create_umg_widget_blueprint"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_text_block_to_widget"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_button_to_widget"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("bind_widget_event"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("set_text_block_binding"))));
+                Commands.Add(MakeShareable(new FJsonValueString(TEXT("add_widget_to_viewport"))));
+
+                ResultJson->SetArrayField(TEXT("commands"), Commands);
+            }
+            // Editor Commands (including actor manipulation)
+            else if (CommandType == TEXT("get_actors_in_level") || 
+                     CommandType == TEXT("find_actors_by_name") ||
+                     CommandType == TEXT("spawn_actor") ||
+                     CommandType == TEXT("create_actor") ||
+                     CommandType == TEXT("delete_actor") || 
+                     CommandType == TEXT("set_actor_transform") ||
+                     CommandType == TEXT("get_actor_properties") ||
+                     CommandType == TEXT("set_actor_property") ||
+                     CommandType == TEXT("spawn_blueprint_actor") ||
+                     CommandType == TEXT("focus_viewport") || 
+                     CommandType == TEXT("take_screenshot") ||
+                     CommandType == TEXT("get_play_in_editor_status") ||
+                     CommandType == TEXT("play_in_editor") ||
+                     CommandType == TEXT("play_in_editor_windowed") ||
+                     CommandType == TEXT("stop_play_in_editor"))
+            {
+                ResultJson = EditorCommands->HandleCommand(CommandType, Params);
+            }
+            // Blueprint Commands
+            else if (CommandType == TEXT("create_blueprint") || 
+                     CommandType == TEXT("add_component_to_blueprint") || 
+                     CommandType == TEXT("set_component_property") || 
+                     CommandType == TEXT("set_physics_properties") || 
+                     CommandType == TEXT("compile_blueprint") || 
+                     CommandType == TEXT("set_blueprint_property") || 
+                     CommandType == TEXT("set_static_mesh_properties") ||
+                     CommandType == TEXT("set_pawn_properties"))
+            {
+                ResultJson = BlueprintCommands->HandleCommand(CommandType, Params);
+            }
+            // Blueprint Node Commands
+            else if (CommandType == TEXT("connect_blueprint_nodes") || 
+                     CommandType == TEXT("add_blueprint_get_self_component_reference") ||
+                     CommandType == TEXT("add_blueprint_self_reference") ||
+                     CommandType == TEXT("find_blueprint_nodes") ||
+                     CommandType == TEXT("add_blueprint_event_node") ||
+                     CommandType == TEXT("add_blueprint_input_action_node") ||
+                     CommandType == TEXT("add_blueprint_function_node") ||
+                     CommandType == TEXT("add_blueprint_get_component_node") ||
+                     CommandType == TEXT("add_blueprint_variable"))
+            {
+                ResultJson = BlueprintNodeCommands->HandleCommand(CommandType, Params);
+            }
+            // Project Commands
+            else if (CommandType == TEXT("create_input_mapping"))
+            {
+                ResultJson = ProjectCommands->HandleCommand(CommandType, Params);
+            }
+            // UMG Commands
+            else if (CommandType == TEXT("create_umg_widget_blueprint") ||
+                     CommandType == TEXT("add_text_block_to_widget") ||
+                     CommandType == TEXT("add_button_to_widget") ||
+                     CommandType == TEXT("bind_widget_event") ||
+                     CommandType == TEXT("set_text_block_binding") ||
+                     CommandType == TEXT("add_widget_to_viewport"))
+            {
+                ResultJson = UMGCommands->HandleCommand(CommandType, Params);
+            }
+            else
+            {
+                ResponseJson->SetStringField(TEXT("status"), TEXT("error"));
+                ResponseJson->SetStringField(TEXT("error"), FString::Printf(TEXT("Unknown command: %s"), *CommandType));
+                
+                FString ResultString;
+                TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&ResultString);
+                FJsonSerializer::Serialize(ResponseJson.ToSharedRef(), Writer);
+                Promise.SetValue(ResultString);
+                return;
+            }
+            
+            // Check if the result contains an error
+            bool bSuccess = true;
+            FString ErrorMessage;
+            
+            if (ResultJson->HasField(TEXT("success")))
+            {
+                bSuccess = ResultJson->GetBoolField(TEXT("success"));
+                if (!bSuccess && ResultJson->HasField(TEXT("error")))
+                {
+                    ErrorMessage = ResultJson->GetStringField(TEXT("error"));
+                }
+            }
+            
+            if (bSuccess)
+            {
+                // Set success status and include the result
+                ResponseJson->SetStringField(TEXT("status"), TEXT("success"));
+                ResponseJson->SetObjectField(TEXT("result"), ResultJson);
+            }
+            else
+            {
+                // Set error status and include the error message
+                ResponseJson->SetStringField(TEXT("status"), TEXT("error"));
+                ResponseJson->SetStringField(TEXT("error"), ErrorMessage);
+            }
+        }
+        catch (const std::exception& e)
+        {
+            ResponseJson->SetStringField(TEXT("status"), TEXT("error"));
+            ResponseJson->SetStringField(TEXT("error"), UTF8_TO_TCHAR(e.what()));
+        }
+        
+        FString ResultString;
+        TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&ResultString);
+        FJsonSerializer::Serialize(ResponseJson.ToSharedRef(), Writer);
+        Promise.SetValue(ResultString);
+    });
+    
+    return Future.Get();
+}

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Private/UnrealMCPModule.cpp

@@ -0,0 +1,21 @@
+#include "UnrealMCPModule.h"
+#include "UnrealMCPBridge.h"
+#include "Modules/ModuleManager.h"
+#include "EditorSubsystem.h"
+#include "Editor.h"
+
+#define LOCTEXT_NAMESPACE "FUnrealMCPModule"
+
+void FUnrealMCPModule::StartupModule()
+{
+	UE_LOG(LogTemp, Display, TEXT("Unreal MCP Module has started"));
+}
+
+void FUnrealMCPModule::ShutdownModule()
+{
+	UE_LOG(LogTemp, Display, TEXT("Unreal MCP Module has shut down"));
+}
+
+#undef LOCTEXT_NAMESPACE
+	
+IMPLEMENT_MODULE(FUnrealMCPModule, UnrealMCP) 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/Commands/UnrealMCPBlueprintCommands.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Json.h"
+
+/**
+ * Handler class for Blueprint-related MCP commands
+ */
+class UNREALMCP_API FUnrealMCPBlueprintCommands
+{
+public:
+    FUnrealMCPBlueprintCommands();
+
+    // Handle blueprint commands
+    TSharedPtr<FJsonObject> HandleCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params);
+
+private:
+    // Specific blueprint command handlers
+    TSharedPtr<FJsonObject> HandleCreateBlueprint(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddComponentToBlueprint(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetComponentProperty(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetPhysicsProperties(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleCompileBlueprint(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSpawnBlueprintActor(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetBlueprintProperty(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetStaticMeshProperties(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetPawnProperties(const TSharedPtr<FJsonObject>& Params);
+
+    // Helper functions
+    TSharedPtr<FJsonObject> AddComponentToBlueprint(const FString& BlueprintName, const FString& ComponentType, 
+                                                   const FString& ComponentName, const FString& MeshType,
+                                                   const TArray<float>& Location, const TArray<float>& Rotation,
+                                                   const TArray<float>& Scale, const TSharedPtr<FJsonObject>& ComponentProperties);
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/Commands/UnrealMCPBlueprintNodeCommands.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Json.h"
+
+/**
+ * Handler class for Blueprint Node-related MCP commands
+ */
+class UNREALMCP_API FUnrealMCPBlueprintNodeCommands
+{
+public:
+    FUnrealMCPBlueprintNodeCommands();
+
+    // Handle blueprint node commands
+    TSharedPtr<FJsonObject> HandleCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params);
+
+private:
+    // Specific blueprint node command handlers
+    TSharedPtr<FJsonObject> HandleConnectBlueprintNodes(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddBlueprintGetSelfComponentReference(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddBlueprintEvent(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddBlueprintFunctionCall(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddBlueprintVariable(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddBlueprintInputActionNode(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleAddBlueprintSelfReference(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleFindBlueprintNodes(const TSharedPtr<FJsonObject>& Params);
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/Commands/UnrealMCPCommonUtils.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Json.h"
+
+// Forward declarations
+class AActor;
+class UBlueprint;
+class UEdGraph;
+class UEdGraphNode;
+class UEdGraphPin;
+class UK2Node_Event;
+class UK2Node_CallFunction;
+class UK2Node_VariableGet;
+class UK2Node_VariableSet;
+class UK2Node_InputAction;
+class UK2Node_Self;
+class UFunction;
+
+/**
+ * Common utilities for UnrealMCP commands
+ */
+class UNREALMCP_API FUnrealMCPCommonUtils
+{
+public:
+    // JSON utilities
+    static TSharedPtr<FJsonObject> CreateErrorResponse(const FString& Message);
+    static TSharedPtr<FJsonObject> CreateSuccessResponse(const TSharedPtr<FJsonObject>& Data = nullptr);
+    static void GetIntArrayFromJson(const TSharedPtr<FJsonObject>& JsonObject, const FString& FieldName, TArray<int32>& OutArray);
+    static void GetFloatArrayFromJson(const TSharedPtr<FJsonObject>& JsonObject, const FString& FieldName, TArray<float>& OutArray);
+    static FVector2D GetVector2DFromJson(const TSharedPtr<FJsonObject>& JsonObject, const FString& FieldName);
+    static FVector GetVectorFromJson(const TSharedPtr<FJsonObject>& JsonObject, const FString& FieldName);
+    static FRotator GetRotatorFromJson(const TSharedPtr<FJsonObject>& JsonObject, const FString& FieldName);
+    
+    // Actor utilities
+    static TSharedPtr<FJsonValue> ActorToJson(AActor* Actor);
+    static TSharedPtr<FJsonObject> ActorToJsonObject(AActor* Actor, bool bDetailed = false);
+    
+    // Blueprint utilities
+    static UBlueprint* FindBlueprint(const FString& BlueprintName);
+    static UBlueprint* FindBlueprintByName(const FString& BlueprintName);
+    static UEdGraph* FindOrCreateEventGraph(UBlueprint* Blueprint);
+    
+    // Blueprint node utilities
+    static UK2Node_Event* CreateEventNode(UEdGraph* Graph, const FString& EventName, const FVector2D& Position);
+    static UK2Node_CallFunction* CreateFunctionCallNode(UEdGraph* Graph, UFunction* Function, const FVector2D& Position);
+    static UK2Node_VariableGet* CreateVariableGetNode(UEdGraph* Graph, UBlueprint* Blueprint, const FString& VariableName, const FVector2D& Position);
+    static UK2Node_VariableSet* CreateVariableSetNode(UEdGraph* Graph, UBlueprint* Blueprint, const FString& VariableName, const FVector2D& Position);
+    static UK2Node_InputAction* CreateInputActionNode(UEdGraph* Graph, const FString& ActionName, const FVector2D& Position);
+    static UK2Node_Self* CreateSelfReferenceNode(UEdGraph* Graph, const FVector2D& Position);
+    static bool ConnectGraphNodes(UEdGraph* Graph, UEdGraphNode* SourceNode, const FString& SourcePinName, 
+                                UEdGraphNode* TargetNode, const FString& TargetPinName);
+    static UEdGraphPin* FindPin(UEdGraphNode* Node, const FString& PinName, EEdGraphPinDirection Direction = EGPD_MAX);
+    static UK2Node_Event* FindExistingEventNode(UEdGraph* Graph, const FString& EventName);
+
+    // Property utilities
+    static bool SetObjectProperty(UObject* Object, const FString& PropertyName, 
+                                 const TSharedPtr<FJsonValue>& Value, FString& OutErrorMessage);
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/Commands/UnrealMCPEditorCommands.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Json.h"
+
+/**
+ * Handler class for Editor-related MCP commands
+ * Handles viewport control, actor manipulation, and level management
+ */
+class UNREALMCP_API FUnrealMCPEditorCommands
+{
+public:
+    FUnrealMCPEditorCommands();
+
+    // Handle editor commands
+    TSharedPtr<FJsonObject> HandleCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params);
+
+private:
+    // Actor manipulation commands
+    TSharedPtr<FJsonObject> HandleGetActorsInLevel(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleFindActorsByName(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSpawnActor(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleDeleteActor(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetActorTransform(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleGetActorProperties(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleSetActorProperty(const TSharedPtr<FJsonObject>& Params);
+
+    // Blueprint actor spawning
+    TSharedPtr<FJsonObject> HandleSpawnBlueprintActor(const TSharedPtr<FJsonObject>& Params);
+
+    // Editor viewport commands
+    TSharedPtr<FJsonObject> HandleFocusViewport(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleTakeScreenshot(const TSharedPtr<FJsonObject>& Params);
+
+    // Editor play/preview commands
+    TSharedPtr<FJsonObject> HandleGetPlayInEditorStatus(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandlePlayInEditor(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandlePlayInEditorWindowed(const TSharedPtr<FJsonObject>& Params);
+    TSharedPtr<FJsonObject> HandleStopPlayInEditor(const TSharedPtr<FJsonObject>& Params);
+}; 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Public/Commands/UnrealMCPProjectCommands.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Json.h"
+
+/**
+ * Handler class for Project-wide MCP commands
+ */
+class UNREALMCP_API FUnrealMCPProjectCommands
+{
+public:
+    FUnrealMCPProjectCommands();
+
+    // Handle project commands
+    TSharedPtr<FJsonObject> HandleCommand(const FString& CommandType, const TSharedPtr<FJsonObject>& Params);
+
+private:
+    // Specific project command handlers
+    TSharedPtr<FJsonObject> HandleCreateInputMapping(const TSharedPtr<FJsonObject>& Params);
+};