ue-mcp 0.4.0-alpha

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+#include "HandlerRegistry.h"
+#include "GameThreadExecutor.h"
+#include "HAL/Runnable.h"
+#include "HAL/RunnableThread.h"
+#include "HAL/ThreadSafeBool.h"
+#include "Containers/Queue.h"
+
+#if PLATFORM_WINDOWS
+#include "Windows/AllowWindowsPlatformTypes.h"
+#include <winsock2.h>
+#include "Windows/HideWindowsPlatformTypes.h"
+#endif
+
+class FMCPBridgeServer : public FRunnable
+{
+public:
+	FMCPBridgeServer(int32 Port = 9877);
+	~FMCPBridgeServer();
+
+	// Start the server
+	bool Start();
+
+	// FRunnable interface
+	virtual bool Init() override;
+	virtual uint32 Run() override;
+	virtual void Stop() override;
+	virtual void Exit() override;
+	
+	// Public stop method (calls FRunnable::Stop)
+	void Shutdown();
+
+	// Get handler registry
+	FMCPHandlerRegistry& GetHandlerRegistry() { return HandlerRegistry; }
+
+	// Process a JSON-RPC message
+	FString ProcessMessage(const FString& Message);
+
+private:
+	// Server port
+	int32 ServerPort;
+
+	// Thread management
+	FRunnableThread* ServerThread;
+	FThreadSafeBool bShouldStop;
+	FThreadSafeBool bIsRunning;
+
+	// Handler registry
+	FMCPHandlerRegistry HandlerRegistry;
+
+	// Game thread executor
+	FMCPGameThreadExecutor GameThreadExecutor;
+
+	// JSON-RPC processing
+	TSharedPtr<FJsonObject> ParseJsonRpcRequest(const FString& Message);
+	FString CreateJsonRpcResponse(const TSharedPtr<FJsonObject>& Request, const TSharedPtr<FJsonValue>& Result);
+	FString CreateJsonRpcError(const TSharedPtr<FJsonObject>& Request, int32 ErrorCode, const FString& ErrorMessage);
+
+	// WebSocket connection handling
+#if PLATFORM_WINDOWS
+	void HandleWebSocketConnection(SOCKET ClientSocketFD);
+	FString PerformWebSocketHandshake(SOCKET ClientSocketFD);
+	void ProcessWebSocketMessages(SOCKET ClientSocketFD);
+	FString ReadHttpRequest(SOCKET SocketFD);
+#else
+	void HandleWebSocketConnection(int32 ClientSocketFD);
+	FString PerformWebSocketHandshake(int32 ClientSocketFD);
+	void ProcessWebSocketMessages(int32 ClientSocketFD);
+	FString ReadHttpRequest(int32 SocketFD);
+#endif
+	FString CreateWebSocketAcceptKey(const FString& ClientKey);
+	TArray<uint8> CreateWebSocketFrame(const FString& Message);
+	FString ParseWebSocketFrame(const TArray<uint8>& Data);
+
+	// Server socket (will use platform-specific implementation)
+	void* ServerSocket;
+};

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

@@ -0,0 +1,49 @@
+#include "GameThreadExecutor.h"
+#include "HAL/PlatformProcess.h"
+#include "Async/Async.h"
+
+FMCPGameThreadExecutor::FMCPGameThreadExecutor()
+{
+}
+
+FMCPGameThreadExecutor::~FMCPGameThreadExecutor()
+{
+}
+
+bool FMCPGameThreadExecutor::IsGameThread()
+{
+	return IsInGameThread();
+}
+
+TSharedPtr<FJsonValue> FMCPGameThreadExecutor::ExecuteOnGameThread(FHandlerFunction Handler, const TSharedPtr<FJsonObject>& Params, float TimeoutSeconds)
+{
+	if (IsGameThread())
+	{
+		// Already on game thread, execute directly
+		return Handler(Params);
+	}
+
+	// Execute on game thread via AsyncTask
+	TSharedPtr<TFuture<TSharedPtr<FJsonValue>>> Future = MakeShared<TFuture<TSharedPtr<FJsonValue>>>(
+		Async(EAsyncExecution::TaskGraphMainThread, [Handler, Params]() -> TSharedPtr<FJsonValue>
+		{
+			return Handler(Params);
+		})
+	);
+
+	// Wait for result with timeout
+	double StartTime = FPlatformTime::Seconds();
+	while (!Future->IsReady())
+	{
+		if (FPlatformTime::Seconds() - StartTime > TimeoutSeconds)
+		{
+			// Timeout
+			TSharedPtr<FJsonObject> ErrorObject = MakeShared<FJsonObject>();
+			ErrorObject->SetStringField(TEXT("error"), TEXT("Handler execution timed out"));
+			return MakeShared<FJsonValueObject>(ErrorObject);
+		}
+		FPlatformProcess::Sleep(0.01f); // 10ms sleep
+	}
+
+	return Future->Get();
+}

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+#include "Async/Async.h"
+#include "HAL/PlatformProcess.h"
+
+class FMCPGameThreadExecutor
+{
+public:
+	// Handler function signature
+	using FHandlerFunction = TFunction<TSharedPtr<FJsonValue>(const TSharedPtr<FJsonObject>& Params)>;
+
+	FMCPGameThreadExecutor();
+	~FMCPGameThreadExecutor();
+
+	// Execute handler on game thread with timeout
+	TSharedPtr<FJsonValue> ExecuteOnGameThread(FHandlerFunction Handler, const TSharedPtr<FJsonObject>& Params, float TimeoutSeconds = 30.0f);
+
+	// Check if we're on game thread
+	static bool IsGameThread();
+
+private:
+	// Pending execution info
+	struct FPendingExecution
+	{
+		FHandlerFunction Handler;
+		TSharedPtr<FJsonObject> Params;
+		TSharedPtr<TFuture<TSharedPtr<FJsonValue>>> Future;
+		double StartTime;
+		float TimeoutSeconds;
+	};
+
+	TArray<FPendingExecution> PendingExecutions;
+	FCriticalSection ExecutionMutex;
+};

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

@@ -0,0 +1,75 @@
+#include "HandlerRegistry.h"
+#include "HAL/PlatformFilemanager.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+
+FMCPHandlerRegistry::FMCPHandlerRegistry()
+{
+}
+
+FMCPHandlerRegistry::~FMCPHandlerRegistry()
+{
+	Clear();
+}
+
+void FMCPHandlerRegistry::RegisterHandler(const FString& MethodName, FHandlerFunction Handler)
+{
+	CppHandlers.Add(MethodName, Handler);
+}
+
+void FMCPHandlerRegistry::RegisterPythonHandler(const FString& MethodName, const FString& PythonScriptPath)
+{
+	FPythonHandlerInfo Info;
+	Info.ScriptPath = PythonScriptPath;
+	Info.HandlerName = MethodName;
+	PythonHandlers.Add(MethodName, Info);
+}
+
+TSharedPtr<FJsonValue> FMCPHandlerRegistry::ExecuteHandler(const FString& MethodName, const TSharedPtr<FJsonObject>& Params)
+{
+	// Try C++ handler first
+	if (CppHandlers.Contains(MethodName))
+	{
+		return CppHandlers[MethodName](Params);
+	}
+
+	// Try Python handler
+	if (PythonHandlers.Contains(MethodName))
+	{
+		return ExecutePythonHandler(MethodName, Params);
+	}
+
+	// Handler not found - return nullptr so BridgeServer sends "Unknown method" error
+	return nullptr;
+}
+
+bool FMCPHandlerRegistry::HasHandler(const FString& MethodName) const
+{
+	return CppHandlers.Contains(MethodName) || PythonHandlers.Contains(MethodName);
+}
+
+TArray<FString> FMCPHandlerRegistry::GetHandlerNames() const
+{
+	TArray<FString> Names;
+	CppHandlers.GetKeys(Names);
+	
+	TArray<FString> PythonNames;
+	PythonHandlers.GetKeys(PythonNames);
+	Names.Append(PythonNames);
+	
+	return Names;
+}
+
+void FMCPHandlerRegistry::Clear()
+{
+	CppHandlers.Empty();
+	PythonHandlers.Empty();
+}
+
+TSharedPtr<FJsonValue> FMCPHandlerRegistry::ExecutePythonHandler(const FString& MethodName, const TSharedPtr<FJsonObject>& Params)
+{
+	// TODO: Implement Python handler execution
+	// For now, return empty result
+	// Will be implemented when Python plugin system is added
+	return MakeShared<FJsonValueObject>(MakeShared<FJsonObject>());
+}

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

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Dom/JsonValue.h"
+#include "Dom/JsonObject.h"
+
+class FMCPHandlerRegistry
+{
+public:
+	// Handler function signature: takes params JSON object, returns result JSON value
+	using FHandlerFunction = TFunction<TSharedPtr<FJsonValue>(const TSharedPtr<FJsonObject>& Params)>;
+
+	// Python handler info
+	struct FPythonHandlerInfo
+	{
+		FString ScriptPath;
+		FString HandlerName;
+	};
+
+	FMCPHandlerRegistry();
+	~FMCPHandlerRegistry();
+
+	// Register a C++ handler
+	void RegisterHandler(const FString& MethodName, FHandlerFunction Handler);
+
+	// Register a Python handler
+	void RegisterPythonHandler(const FString& MethodName, const FString& PythonScriptPath);
+
+	// Execute a handler
+	TSharedPtr<FJsonValue> ExecuteHandler(const FString& MethodName, const TSharedPtr<FJsonObject>& Params);
+
+	// Check if handler exists
+	bool HasHandler(const FString& MethodName) const;
+
+	// Get all registered handler names
+	TArray<FString> GetHandlerNames() const;
+
+	// Clear all handlers
+	void Clear();
+
+private:
+	// C++ handlers
+	TMap<FString, FHandlerFunction> CppHandlers;
+
+	// Python handlers
+	TMap<FString, FPythonHandlerInfo> PythonHandlers;
+
+	// Execute Python handler
+	TSharedPtr<FJsonValue> ExecutePythonHandler(const FString& MethodName, const TSharedPtr<FJsonObject>& Params);
+};