ue-mcp 0.4.0-alpha

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/Handlers/WidgetHandlers.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+
+class FWidgetHandlers
+{
+public:
+	static void RegisterHandlers(class FMCPHandlerRegistry& Registry);
+
+private:
+	static TSharedPtr<FJsonValue> ListWidgetBlueprints(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> CreateWidgetBlueprint(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ReadWidgetTree(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> CreateEditorUtilityWidget(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> CreateEditorUtilityBlueprint(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SearchWidgetByName(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> GetWidgetProperties(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> SetWidgetProperty(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> ReadWidgetAnimations(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> RunEditorUtilityWidget(const TSharedPtr<FJsonObject>& Params);
+	static TSharedPtr<FJsonValue> RunEditorUtilityBlueprint(const TSharedPtr<FJsonObject>& Params);
+
+	// Helper: recursively search for a widget by name in the tree
+	static class UWidget* FindWidgetByNameRecursive(class UWidget* Root, const FString& WidgetName);
+};

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/JsonSerializer.cpp

@@ -0,0 +1,181 @@
+#include "JsonSerializer.h"
+#include "UObject/UnrealType.h"
+#include "UObject/PropertyPortFlags.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeValue(const void* Value, FProperty* Property)
+{
+	if (!Property || !Value)
+	{
+		return MakeShared<FJsonValueNull>();
+	}
+
+	return SerializePropertyValue(Value, Property);
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeVector(const FVector& Vector)
+{
+	TSharedPtr<FJsonObject> JsonObject = MakeShared<FJsonObject>();
+	JsonObject->SetNumberField(TEXT("x"), Vector.X);
+	JsonObject->SetNumberField(TEXT("y"), Vector.Y);
+	JsonObject->SetNumberField(TEXT("z"), Vector.Z);
+	return MakeShared<FJsonValueObject>(JsonObject);
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeRotator(const FRotator& Rotator)
+{
+	TSharedPtr<FJsonObject> JsonObject = MakeShared<FJsonObject>();
+	JsonObject->SetNumberField(TEXT("pitch"), Rotator.Pitch);
+	JsonObject->SetNumberField(TEXT("yaw"), Rotator.Yaw);
+	JsonObject->SetNumberField(TEXT("roll"), Rotator.Roll);
+	return MakeShared<FJsonValueObject>(JsonObject);
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeTransform(const FTransform& Transform)
+{
+	TSharedPtr<FJsonObject> JsonObject = MakeShared<FJsonObject>();
+	TSharedPtr<FJsonValue> TranslationValue = SerializeVector(Transform.GetTranslation());
+	TSharedPtr<FJsonValue> RotationValue = SerializeRotator(Transform.GetRotation().Rotator());
+	TSharedPtr<FJsonValue> ScaleValue = SerializeVector(Transform.GetScale3D());
+	JsonObject->SetObjectField(TEXT("translation"), TranslationValue->AsObject());
+	JsonObject->SetObjectField(TEXT("rotation"), RotationValue->AsObject());
+	JsonObject->SetObjectField(TEXT("scale"), ScaleValue->AsObject());
+	return MakeShared<FJsonValueObject>(JsonObject);
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeLinearColor(const FLinearColor& Color)
+{
+	TSharedPtr<FJsonObject> JsonObject = MakeShared<FJsonObject>();
+	JsonObject->SetNumberField(TEXT("r"), Color.R);
+	JsonObject->SetNumberField(TEXT("g"), Color.G);
+	JsonObject->SetNumberField(TEXT("b"), Color.B);
+	JsonObject->SetNumberField(TEXT("a"), Color.A);
+	return MakeShared<FJsonValueObject>(JsonObject);
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeString(const FString& String)
+{
+	return MakeShared<FJsonValueString>(String);
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializeObjectProperty(UObject* Object, FProperty* Property)
+{
+	if (!Object || !Property)
+	{
+		return MakeShared<FJsonValueNull>();
+	}
+
+	const void* ValuePtr = Property->ContainerPtrToValuePtr<void>(Object);
+	return SerializePropertyValue(ValuePtr, Property);
+}
+
+TSharedPtr<FJsonObject> FMCPJsonSerializer::SerializeObject(UObject* Object)
+{
+	if (!Object)
+	{
+		return MakeShared<FJsonObject>();
+	}
+
+	TSharedPtr<FJsonObject> JsonObject = MakeShared<FJsonObject>();
+	
+	// Serialize basic object info
+	JsonObject->SetStringField(TEXT("name"), Object->GetName());
+	JsonObject->SetStringField(TEXT("class"), Object->GetClass()->GetName());
+	JsonObject->SetStringField(TEXT("path"), Object->GetPathName());
+
+	// Serialize properties
+	for (TFieldIterator<FProperty> PropIt(Object->GetClass()); PropIt; ++PropIt)
+	{
+		FProperty* Property = *PropIt;
+		if (Property && Property->HasAnyPropertyFlags(CPF_BlueprintVisible))
+		{
+			TSharedPtr<FJsonValue> PropValue = SerializeObjectProperty(Object, Property);
+			if (PropValue.IsValid())
+			{
+				JsonObject->SetField(Property->GetName(), PropValue);
+			}
+		}
+	}
+
+	return JsonObject;
+}
+
+TSharedPtr<FJsonValue> FMCPJsonSerializer::SerializePropertyValue(const void* Value, FProperty* Property)
+{
+	if (!Property || !Value)
+	{
+		return MakeShared<FJsonValueNull>();
+	}
+
+	if (FStrProperty* StrProp = CastField<FStrProperty>(Property))
+	{
+		return MakeShared<FJsonValueString>(StrProp->GetPropertyValue(Value));
+	}
+	else if (FNameProperty* NameProp = CastField<FNameProperty>(Property))
+	{
+		return MakeShared<FJsonValueString>(NameProp->GetPropertyValue(Value).ToString());
+	}
+	else if (FTextProperty* TextProp = CastField<FTextProperty>(Property))
+	{
+		return MakeShared<FJsonValueString>(TextProp->GetPropertyValue(Value).ToString());
+	}
+	else if (FBoolProperty* BoolProp = CastField<FBoolProperty>(Property))
+	{
+		return MakeShared<FJsonValueBoolean>(BoolProp->GetPropertyValue(Value));
+	}
+	else if (FIntProperty* IntProp = CastField<FIntProperty>(Property))
+	{
+		return MakeShared<FJsonValueNumber>(IntProp->GetPropertyValue(Value));
+	}
+	else if (FInt64Property* Int64Prop = CastField<FInt64Property>(Property))
+	{
+		return MakeShared<FJsonValueNumber>(Int64Prop->GetPropertyValue(Value));
+	}
+	else if (FFloatProperty* FloatProp = CastField<FFloatProperty>(Property))
+	{
+		return MakeShared<FJsonValueNumber>(FloatProp->GetPropertyValue(Value));
+	}
+	else if (FDoubleProperty* DoubleProp = CastField<FDoubleProperty>(Property))
+	{
+		return MakeShared<FJsonValueNumber>(DoubleProp->GetPropertyValue(Value));
+	}
+	else if (FStructProperty* StructProp = CastField<FStructProperty>(Property))
+	{
+		if (StructProp->Struct == TBaseStructure<FVector>::Get())
+		{
+			return SerializeVector(*static_cast<const FVector*>(Value));
+		}
+		else if (StructProp->Struct == TBaseStructure<FRotator>::Get())
+		{
+			return SerializeRotator(*static_cast<const FRotator*>(Value));
+		}
+		else if (StructProp->Struct == TBaseStructure<FTransform>::Get())
+		{
+			return SerializeTransform(*static_cast<const FTransform*>(Value));
+		}
+		else if (StructProp->Struct == TBaseStructure<FLinearColor>::Get())
+		{
+			return SerializeLinearColor(*static_cast<const FLinearColor*>(Value));
+		}
+	}
+	else if (FArrayProperty* ArrayProp = CastField<FArrayProperty>(Property))
+	{
+		TArray<TSharedPtr<FJsonValue>> JsonArray;
+		FScriptArrayHelper ArrayHelper(ArrayProp, Value);
+		for (int32 i = 0; i < ArrayHelper.Num(); ++i)
+		{
+			const void* ItemValue = ArrayHelper.GetRawPtr(i);
+			TSharedPtr<FJsonValue> ItemJson = SerializePropertyValue(ItemValue, ArrayProp->Inner);
+			if (ItemJson.IsValid())
+			{
+				JsonArray.Add(ItemJson);
+			}
+		}
+		return MakeShared<FJsonValueArray>(JsonArray);
+	}
+
+	// Fallback: convert to string - use property name as fallback
+	FString StringValue = FString::Printf(TEXT("(%s)"), *Property->GetName());
+	return MakeShared<FJsonValueString>(StringValue);
+}

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/JsonSerializer.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+#include "UObject/UnrealType.h"
+
+class FMCPJsonSerializer
+{
+public:
+	// Serialize UE type to JSON value
+	static TSharedPtr<FJsonValue> SerializeValue(const void* Value, FProperty* Property);
+
+	// Serialize FVector to JSON
+	static TSharedPtr<FJsonValue> SerializeVector(const FVector& Vector);
+
+	// Serialize FRotator to JSON
+	static TSharedPtr<FJsonValue> SerializeRotator(const FRotator& Rotator);
+
+	// Serialize FTransform to JSON
+	static TSharedPtr<FJsonValue> SerializeTransform(const FTransform& Transform);
+
+	// Serialize FLinearColor to JSON
+	static TSharedPtr<FJsonValue> SerializeLinearColor(const FLinearColor& Color);
+
+	// Serialize FString to JSON
+	static TSharedPtr<FJsonValue> SerializeString(const FString& String);
+
+	// Serialize TArray to JSON
+	template<typename T>
+	static TSharedPtr<FJsonValue> SerializeArray(const TArray<T>& Array);
+
+	// Serialize UObject property to JSON
+	static TSharedPtr<FJsonValue> SerializeObjectProperty(UObject* Object, FProperty* Property);
+
+	// Serialize UObject to JSON (basic properties)
+	static TSharedPtr<FJsonObject> SerializeObject(UObject* Object);
+
+private:
+	// Helper to serialize property value
+	static TSharedPtr<FJsonValue> SerializePropertyValue(const void* Value, FProperty* Property);
+};

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Private/UE_MCP_Bridge.cpp

@@ -0,0 +1,39 @@
+#include "UE_MCP_BridgeModule.h"
+#include "Modules/ModuleManager.h"
+#include "BridgeServer.h"
+#include "Handlers/DialogHandlers.h"
+#include "Misc/ConfigCacheIni.h"
+
+DEFINE_LOG_CATEGORY(LogMCPBridge);
+IMPLEMENT_MODULE(FUE_MCP_BridgeModule, UE_MCP_Bridge)
+
+static TSharedPtr<FMCPBridgeServer> G_BridgeServer;
+
+void FUE_MCP_BridgeModule::StartupModule()
+{
+	// Create and start bridge server
+	G_BridgeServer = MakeShared<FMCPBridgeServer>(9877);
+	FDialogHandlers::InstallDialogHook();
+
+	if (G_BridgeServer->Start())
+	{
+		UE_LOG(LogMCPBridge, Log, TEXT("[UE-MCP] Bridge server started on port 9877"));
+	}
+	else
+	{
+		UE_LOG(LogMCPBridge, Warning, TEXT("[UE-MCP] Failed to start bridge server"));
+	}
+}
+
+void FUE_MCP_BridgeModule::ShutdownModule()
+{
+	// Stop bridge server
+	FDialogHandlers::RemoveDialogHook();
+
+	if (G_BridgeServer.IsValid())
+	{
+		G_BridgeServer->Shutdown();
+		G_BridgeServer.Reset();
+		UE_LOG(LogMCPBridge, Log, TEXT("[UE-MCP] Bridge server stopped"));
+	}
+}

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/Public/UE_MCP_BridgeModule.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(LogMCPBridge, Log, All);
+
+class FUE_MCP_BridgeModule : public IModuleInterface
+{
+public:
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+};

package/plugin/ue_mcp_bridge/Source/UE_MCP_Bridge/UE_MCP_Bridge.Build.cs

@@ -0,0 +1,87 @@
+using UnrealBuildTool;
+
+public class UE_MCP_Bridge : ModuleRules
+{
+	public UE_MCP_Bridge(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PublicIncludePaths.AddRange(
+			new string[] {
+			}
+		);
+
+		PrivateIncludePaths.AddRange(
+			new string[] {
+			}
+		);
+
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"Json",
+				"JsonUtilities",
+				"GameplayTags",
+			}
+		);
+
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"AIModule",
+				"AnimationEditor",
+				"AssetRegistry",
+				"AssetTools",
+				"AudioEditor",
+				"BlueprintGraph",
+				"Blutility",
+				"ContentBrowser",
+				"DataValidation",
+				"EditorScriptingUtilities",
+				"EditorStyle",
+				"EditorSubsystem",
+				"EditorWidgets",
+				"EnhancedInput",
+				"Foliage",
+				"GameplayAbilities",
+				"GameplayTasks",
+				"HTTP",
+				"InputCore",
+				"Kismet",
+				"KismetCompiler",
+				"Landscape",
+				"LevelEditor",
+				"LevelSequence",
+				"LiveCoding",
+				"MaterialEditor",
+				"MovieScene",
+				"MovieSceneTracks",
+				"NavigationSystem",
+				"Niagara",
+				"NiagaraEditor",
+				"PCG",
+				"PropertyEditor",
+				"PythonScriptPlugin",
+				"Sequencer",
+				"Slate",
+				"SlateCore",
+				"SubobjectDataInterface",
+				"ToolMenus",
+				"UMG",
+				"UMGEditor",
+				"UnrealEd",
+				"WebSockets",
+				"WorkspaceMenuStructure",
+			}
+		);
+
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+			}
+		);
+	}
+}

package/plugin/ue_mcp_bridge/UE_MCP_Bridge.uplugin

@@ -0,0 +1,55 @@
+{
+	"FileVersion": 3,
+	"Version": 1,
+	"VersionName": "0.3.0",
+	"FriendlyName": "UE MCP Bridge",
+	"Description": "C++ WebSocket bridge for UE-MCP, providing 185+ editor tools via MCP protocol",
+	"Category": "Developer Tools",
+	"CreatedBy": "UE-MCP",
+	"CreatedByURL": "",
+	"DocsURL": "",
+	"MarketplaceURL": "",
+	"SupportURL": "",
+	"EnabledByDefault": true,
+	"CanContainContent": false,
+	"IsBetaVersion": false,
+	"IsExperimentalVersion": false,
+	"Installed": false,
+	"Modules": [
+		{
+			"Name": "UE_MCP_Bridge",
+			"Type": "Editor",
+			"LoadingPhase": "Default"
+		}
+	],
+	"Plugins": [
+		{
+			"Name": "PythonScriptPlugin",
+			"Enabled": true
+		},
+		{
+			"Name": "DataValidation",
+			"Enabled": true
+		},
+		{
+			"Name": "EditorScriptingUtilities",
+			"Enabled": true
+		},
+		{
+			"Name": "EnhancedInput",
+			"Enabled": true
+		},
+		{
+			"Name": "GameplayAbilities",
+			"Enabled": true
+		},
+		{
+			"Name": "Niagara",
+			"Enabled": true
+		},
+		{
+			"Name": "PCG",
+			"Enabled": true
+		}
+	]
+}