ultimate-unreal-engine-mcp 0.1.0

package/unreal-plugin/MCPBridge/Source/MCPBridgeEditor/Private/MCPNetworkingCommands.cpp

@@ -0,0 +1,482 @@
+// MCPNetworkingCommands.cpp
+// Implements four networking and replication command handlers for the MCP bridge:
+//   net.replication  -- inspect actor replication settings (NET-01)
+//   net.properties   -- list replicated properties with conditions (NET-02)
+//   net.driver       -- read NetDriver config and connection info (NET-03)
+//   net.session      -- inspect online subsystem session and players (NET-04)
+//
+// All handlers run on the game thread via FMCPCommandRouter::Dispatch.
+// All operations are read-only -- no Modify() calls needed.
+// actor_label is validated to exist in the editor world before property access (T-30-01).
+
+#include "MCPNetworkingCommands.h"
+
+#include "Editor.h"
+#include "Engine/World.h"
+#include "GameFramework/Actor.h"
+#include "EngineUtils.h"
+
+// Networking headers
+#include "Engine/NetDriver.h"
+#include "Engine/NetConnection.h"
+#include "Net/UnrealNetwork.h"
+
+// Online Subsystem headers
+#include "OnlineSubsystem.h"
+#include "OnlineSessionSettings.h"
+#include "Interfaces/OnlineSessionInterface.h"
+
+// JSON
+#include "Serialization/JsonSerializer.h"
+#include "Serialization/JsonWriter.h"
+#include "Dom/JsonObject.h"
+#include "Dom/JsonValue.h"
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/** Returns a JSON success response string (without trailing newline). */
+static FString BuildNetSuccessResponse(const FString& CorrId, TSharedPtr<FJsonObject> Data)
+{
+	TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+	Obj->SetBoolField(TEXT("success"), true);
+	Obj->SetStringField(TEXT("correlationId"), CorrId);
+	if (Data.IsValid())
+	{
+		Obj->SetObjectField(TEXT("data"), Data);
+	}
+
+	FString Output;
+	TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&Output);
+	FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
+	return Output;
+}
+
+/** Returns a JSON error response string (without trailing newline). */
+static FString BuildNetErrorResponse(const FString& CorrId, const FString& Error)
+{
+	TSharedPtr<FJsonObject> Obj = MakeShared<FJsonObject>();
+	Obj->SetBoolField(TEXT("success"), false);
+	Obj->SetStringField(TEXT("correlationId"), CorrId);
+	Obj->SetStringField(TEXT("error"), Error);
+
+	FString Output;
+	TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&Output);
+	FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
+	return Output;
+}
+
+/** Map ENetDormancy to a human-readable string. */
+static FString NetDormancyToString(ENetDormancy Dormancy)
+{
+	switch (Dormancy)
+	{
+		case DORM_Never:           return TEXT("DORM_Never");
+		case DORM_Awake:           return TEXT("DORM_Awake");
+		case DORM_DormantAll:      return TEXT("DORM_DormantAll");
+		case DORM_DormantPartial:  return TEXT("DORM_DormantPartial");
+		case DORM_Initial:         return TEXT("DORM_Initial");
+		default:                   return TEXT("DORM_Unknown");
+	}
+}
+
+/** Map ELifetimeCondition to a human-readable string. */
+static FString LifetimeConditionToString(ELifetimeCondition Condition)
+{
+	switch (Condition)
+	{
+		case COND_None:                        return TEXT("COND_None");
+		case COND_InitialOnly:                 return TEXT("COND_InitialOnly");
+		case COND_OwnerOnly:                   return TEXT("COND_OwnerOnly");
+		case COND_SkipOwner:                   return TEXT("COND_SkipOwner");
+		case COND_SimulatedOnly:               return TEXT("COND_SimulatedOnly");
+		case COND_AutonomousOnly:              return TEXT("COND_AutonomousOnly");
+		case COND_SimulatedOrPhysics:          return TEXT("COND_SimulatedOrPhysics");
+		case COND_InitialOrOwner:              return TEXT("COND_InitialOrOwner");
+		case COND_Custom:                      return TEXT("COND_Custom");
+		case COND_ReplayOrOwner:               return TEXT("COND_ReplayOrOwner");
+		case COND_ReplayOnly:                  return TEXT("COND_ReplayOnly");
+		case COND_SimulatedOnlyNoReplay:       return TEXT("COND_SimulatedOnlyNoReplay");
+		case COND_SimulatedOrPhysicsNoReplay:  return TEXT("COND_SimulatedOrPhysicsNoReplay");
+		case COND_SkipReplay:                  return TEXT("COND_SkipReplay");
+		case COND_Dynamic:                     return TEXT("COND_Dynamic");
+		case COND_Never:                       return TEXT("COND_Never");
+		default:                               return TEXT("COND_Unknown");
+	}
+}
+
+/** Map ENetMode to a human-readable string. */
+static FString NetModeToString(ENetMode NetMode)
+{
+	switch (NetMode)
+	{
+		case NM_Standalone:     return TEXT("NM_Standalone");
+		case NM_DedicatedServer: return TEXT("NM_DedicatedServer");
+		case NM_ListenServer:   return TEXT("NM_ListenServer");
+		case NM_Client:         return TEXT("NM_Client");
+		default:                return TEXT("NM_Unknown");
+	}
+}
+
+// ---------------------------------------------------------------------------
+// RegisterNetworkingCommands
+// ---------------------------------------------------------------------------
+
+void RegisterNetworkingCommands(FMCPCommandRouter& Router)
+{
+	// -----------------------------------------------------------------------
+	// net.replication (NET-01)
+	// Returns actor replication settings: bReplicates, bAlwaysRelevant,
+	// NetUpdateFrequency, MinNetUpdateFrequency, NetPriority, NetDormancy, etc.
+	// Required payload: actor_label (string)
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("net.replication"), [](TSharedPtr<FJsonObject> Cmd, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Cmd->GetStringField(TEXT("correlationId"));
+
+		// Extract payload.
+		TSharedPtr<FJsonObject> Payload;
+		const TSharedPtr<FJsonValue>* PayloadVal = Cmd->Values.Find(TEXT("payload"));
+		if (PayloadVal && (*PayloadVal)->Type == EJson::Object)
+		{
+			Payload = (*PayloadVal)->AsObject();
+		}
+
+		FString ActorLabel;
+		if (!Payload.IsValid() || !Payload->TryGetStringField(TEXT("actor_label"), ActorLabel) || ActorLabel.IsEmpty())
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("missing_actor_label")) + TEXT("\n"));
+			return;
+		}
+
+		// Get the editor world.
+		if (!GEditor)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("no_editor")) + TEXT("\n"));
+			return;
+		}
+
+		UWorld* World = GEditor->GetEditorWorldContext().World();
+		if (!World)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("no_world_open")) + TEXT("\n"));
+			return;
+		}
+
+		// Find actor by label (T-30-01: validate actor exists before property access).
+		AActor* TargetActor = nullptr;
+		for (TActorIterator<AActor> It(World); It; ++It)
+		{
+			if ((*It)->GetActorLabel() == ActorLabel)
+			{
+				TargetActor = *It;
+				break;
+			}
+		}
+
+		if (!TargetActor)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("actor_not_found")) + TEXT("\n"));
+			return;
+		}
+
+		// Build response with replication settings.
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("actor_label"),           ActorLabel);
+		Data->SetStringField(TEXT("actor_class"),           TargetActor->GetClass()->GetName());
+		Data->SetBoolField(TEXT("bReplicates"),             TargetActor->GetIsReplicated());
+		Data->SetBoolField(TEXT("bAlwaysRelevant"),         TargetActor->bAlwaysRelevant);
+		Data->SetBoolField(TEXT("bNetUseOwnerRelevancy"),   TargetActor->bNetUseOwnerRelevancy);
+		Data->SetBoolField(TEXT("bReplicateMovement"),      TargetActor->IsReplicatingMovement());
+		Data->SetBoolField(TEXT("bOnlyRelevantToOwner"),    TargetActor->bOnlyRelevantToOwner);
+		Data->SetNumberField(TEXT("NetUpdateFrequency"),    static_cast<double>(TargetActor->NetUpdateFrequency));
+		Data->SetNumberField(TEXT("MinNetUpdateFrequency"), static_cast<double>(TargetActor->MinNetUpdateFrequency));
+		Data->SetNumberField(TEXT("NetPriority"),           static_cast<double>(TargetActor->NetPriority));
+		Data->SetNumberField(TEXT("NetDormancy"),           static_cast<double>(static_cast<int32>(TargetActor->NetDormancy)));
+		Data->SetStringField(TEXT("NetDormancyName"),       NetDormancyToString(TargetActor->NetDormancy));
+
+		SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+	});
+
+	// -----------------------------------------------------------------------
+	// net.properties (NET-02)
+	// Returns all replicated properties on an actor with their replication
+	// conditions and rep notify status.
+	// Required payload: actor_label (string)
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("net.properties"), [](TSharedPtr<FJsonObject> Cmd, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Cmd->GetStringField(TEXT("correlationId"));
+
+		// Extract payload.
+		TSharedPtr<FJsonObject> Payload;
+		const TSharedPtr<FJsonValue>* PayloadVal = Cmd->Values.Find(TEXT("payload"));
+		if (PayloadVal && (*PayloadVal)->Type == EJson::Object)
+		{
+			Payload = (*PayloadVal)->AsObject();
+		}
+
+		FString ActorLabel;
+		if (!Payload.IsValid() || !Payload->TryGetStringField(TEXT("actor_label"), ActorLabel) || ActorLabel.IsEmpty())
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("missing_actor_label")) + TEXT("\n"));
+			return;
+		}
+
+		// Get the editor world.
+		if (!GEditor)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("no_editor")) + TEXT("\n"));
+			return;
+		}
+
+		UWorld* World = GEditor->GetEditorWorldContext().World();
+		if (!World)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("no_world_open")) + TEXT("\n"));
+			return;
+		}
+
+		// Find actor by label (T-30-01: validate actor exists before property access).
+		AActor* TargetActor = nullptr;
+		for (TActorIterator<AActor> It(World); It; ++It)
+		{
+			if ((*It)->GetActorLabel() == ActorLabel)
+			{
+				TargetActor = *It;
+				break;
+			}
+		}
+
+		if (!TargetActor)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("actor_not_found")) + TEXT("\n"));
+			return;
+		}
+
+		// Get lifetime replicated props to resolve conditions.
+		TArray<FLifetimeProperty> LifetimeProps;
+		TargetActor->GetLifetimeReplicatedProps(LifetimeProps);
+
+		// Build a map from RepIndex -> condition for fast lookup.
+		TMap<uint16, ELifetimeCondition> ConditionByRepIndex;
+		for (const FLifetimeProperty& LifeProp : LifetimeProps)
+		{
+			ConditionByRepIndex.Add(LifeProp.RepIndex, LifeProp.Condition);
+		}
+
+		// Iterate properties on the actor's class and its parent classes.
+		TArray<TSharedPtr<FJsonValue>> PropsArray;
+		UClass* ActorClass = TargetActor->GetClass();
+
+		for (TFieldIterator<FProperty> PropIt(ActorClass); PropIt; ++PropIt)
+		{
+			FProperty* Property = *PropIt;
+			if (!Property)
+			{
+				continue;
+			}
+
+			// Check if this property is replicated.
+			if (!Property->HasAnyPropertyFlags(CPF_Net))
+			{
+				continue;
+			}
+
+			const FString PropertyName = Property->GetName();
+			const FString PropertyType = Property->GetCPPType();
+			const bool bHasRepNotify   = Property->HasAnyPropertyFlags(CPF_RepNotify);
+
+			// Resolve condition from lifetime props by RepIndex.
+			FString ConditionStr = TEXT("COND_None");
+			const ELifetimeCondition* FoundCondition = ConditionByRepIndex.Find(Property->RepIndex);
+			if (FoundCondition)
+			{
+				ConditionStr = LifetimeConditionToString(*FoundCondition);
+			}
+
+			TSharedPtr<FJsonObject> PropObj = MakeShared<FJsonObject>();
+			PropObj->SetStringField(TEXT("name"),            PropertyName);
+			PropObj->SetStringField(TEXT("type"),            PropertyType);
+			PropObj->SetStringField(TEXT("condition"),       ConditionStr);
+			PropObj->SetBoolField(TEXT("has_rep_notify"),    bHasRepNotify);
+
+			PropsArray.Add(MakeShared<FJsonValueObject>(PropObj));
+		}
+
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("actor_label"),   ActorLabel);
+		Data->SetStringField(TEXT("actor_class"),   ActorClass->GetName());
+		Data->SetNumberField(TEXT("property_count"), static_cast<double>(PropsArray.Num()));
+		Data->SetArrayField(TEXT("properties"),      PropsArray);
+
+		SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+	});
+
+	// -----------------------------------------------------------------------
+	// net.driver (NET-03)
+	// Returns NetDriver configuration and connection information.
+	// No required parameters. Returns informative message when no NetDriver
+	// is active (editor without PIE or no networked session).
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("net.driver"), [](TSharedPtr<FJsonObject> Cmd, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Cmd->GetStringField(TEXT("correlationId"));
+
+		if (!GEditor)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("no_editor")) + TEXT("\n"));
+			return;
+		}
+
+		UWorld* World = GEditor->GetEditorWorldContext().World();
+		if (!World)
+		{
+			SendResponse(BuildNetErrorResponse(CorrId, TEXT("no_world_open")) + TEXT("\n"));
+			return;
+		}
+
+		UNetDriver* NetDriver = World->GetNetDriver();
+		if (!NetDriver)
+		{
+			// No NetDriver is active. Return graceful status (not an error — this is expected in editor).
+			TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+			Data->SetStringField(TEXT("status"),  TEXT("no_net_driver"));
+			Data->SetStringField(TEXT("message"), TEXT("No NetDriver is active. Start a PIE session in server or listen-server mode to activate a NetDriver."));
+			SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+			return;
+		}
+
+		// Read NetDriver properties.
+		const FString DriverName  = NetDriver->GetName();
+		const ENetMode NetMode    = NetDriver->GetNetMode();
+		const bool bIsServer      = (NetMode == NM_DedicatedServer || NetMode == NM_ListenServer);
+		const int32 ConnCount     = NetDriver->ClientConnections.Num();
+		const int32 MaxChannels   = NetDriver->MaxChannelsOverride > 0 ? NetDriver->MaxChannelsOverride : NetDriver->MaxChannels;
+
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("driver_name"),      DriverName);
+		Data->SetStringField(TEXT("net_mode"),         NetModeToString(NetMode));
+		Data->SetBoolField(TEXT("is_server"),          bIsServer);
+		Data->SetNumberField(TEXT("connection_count"), static_cast<double>(ConnCount));
+		Data->SetNumberField(TEXT("max_channels"),     static_cast<double>(MaxChannels));
+		Data->SetNumberField(TEXT("in_total_bytes"),   static_cast<double>(NetDriver->InTotalBytes));
+		Data->SetNumberField(TEXT("out_total_bytes"),  static_cast<double>(NetDriver->OutTotalBytes));
+
+		// Build connections array (first 10).
+		TArray<TSharedPtr<FJsonValue>> ConnsArray;
+		const int32 MaxConns = FMath::Min(ConnCount, 10);
+		for (int32 i = 0; i < MaxConns; ++i)
+		{
+			UNetConnection* Conn = NetDriver->ClientConnections[i];
+			if (!Conn)
+			{
+				continue;
+			}
+
+			TSharedPtr<FJsonObject> ConnObj = MakeShared<FJsonObject>();
+			ConnObj->SetStringField(TEXT("address"),          Conn->RemoteAddressToString());
+			ConnObj->SetNumberField(TEXT("avg_latency"),      static_cast<double>(Conn->AvgLag));
+			ConnObj->SetNumberField(TEXT("in_bytes_per_sec"), static_cast<double>(Conn->InBytesPerSecond));
+			ConnObj->SetNumberField(TEXT("out_bytes_per_sec"), static_cast<double>(Conn->OutBytesPerSecond));
+			ConnsArray.Add(MakeShared<FJsonValueObject>(ConnObj));
+		}
+		Data->SetArrayField(TEXT("connections"), ConnsArray);
+
+		SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+	});
+
+	// -----------------------------------------------------------------------
+	// net.session (NET-04)
+	// Returns online subsystem session information and player list.
+	// No required parameters. Returns informative status when no online
+	// subsystem is configured or no active session exists.
+	// -----------------------------------------------------------------------
+	Router.RegisterHandler(TEXT("net.session"), [](TSharedPtr<FJsonObject> Cmd, FMCPResponseSender SendResponse)
+	{
+		const FString CorrId = Cmd->GetStringField(TEXT("correlationId"));
+
+		// Try to get the online subsystem.
+		IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
+		if (!OnlineSub)
+		{
+			TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+			Data->SetStringField(TEXT("status"),  TEXT("no_online_subsystem"));
+			Data->SetStringField(TEXT("message"), TEXT("No online subsystem is configured. Enable an online subsystem plugin (e.g. OnlineSubsystemNull for LAN testing) to use this command."));
+			SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+			return;
+		}
+
+		const FString SubsystemName = OnlineSub->GetSubsystemName().ToString();
+
+		// Get session interface.
+		IOnlineSessionPtr SessionInterface = OnlineSub->GetSessionInterface();
+		if (!SessionInterface.IsValid())
+		{
+			TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+			Data->SetStringField(TEXT("status"),         TEXT("no_session_interface"));
+			Data->SetStringField(TEXT("subsystem_name"), SubsystemName);
+			Data->SetStringField(TEXT("message"),        TEXT("Online subsystem is configured but no session interface is available."));
+			SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+			return;
+		}
+
+		// Check for a named session (game session).
+		FNamedOnlineSession* NamedSession = SessionInterface->GetNamedSession(NAME_GameSession);
+		if (!NamedSession)
+		{
+			TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+			Data->SetStringField(TEXT("status"),         TEXT("no_active_session"));
+			Data->SetStringField(TEXT("subsystem_name"), SubsystemName);
+			Data->SetStringField(TEXT("message"),        TEXT("No active game session found. Start or join a session to inspect it."));
+			SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+			return;
+		}
+
+		// Read session settings.
+		const FOnlineSessionSettings& Settings = NamedSession->SessionSettings;
+		const int32 MaxPublic   = Settings.NumPublicConnections;
+		const int32 MaxPrivate  = Settings.NumPrivateConnections;
+		const int32 MaxPlayers  = MaxPublic + MaxPrivate;
+		const int32 NumPlayers  = NamedSession->RegisteredPlayers.Num();
+		const bool bIsLAN       = Settings.bIsLANMatch;
+		const bool bIsDedicated = Settings.bIsDedicated;
+
+		// Map session state to string.
+		FString StateStr;
+		switch (NamedSession->SessionState)
+		{
+			case EOnlineSessionState::NoSession:   StateStr = TEXT("NoSession");   break;
+			case EOnlineSessionState::Creating:    StateStr = TEXT("Creating");    break;
+			case EOnlineSessionState::Pending:     StateStr = TEXT("Pending");     break;
+			case EOnlineSessionState::Starting:    StateStr = TEXT("Starting");    break;
+			case EOnlineSessionState::InProgress:  StateStr = TEXT("InProgress");  break;
+			case EOnlineSessionState::Ending:      StateStr = TEXT("Ending");      break;
+			case EOnlineSessionState::Ended:       StateStr = TEXT("Ended");       break;
+			case EOnlineSessionState::Destroying:  StateStr = TEXT("Destroying");  break;
+			default:                               StateStr = TEXT("Unknown");     break;
+		}
+
+		// Build players array.
+		TArray<TSharedPtr<FJsonValue>> PlayersArray;
+		for (const FUniqueNetIdRef& PlayerId : NamedSession->RegisteredPlayers)
+		{
+			TSharedPtr<FJsonObject> PlayerObj = MakeShared<FJsonObject>();
+			PlayerObj->SetStringField(TEXT("player_id"), PlayerId->ToString());
+			PlayersArray.Add(MakeShared<FJsonValueObject>(PlayerObj));
+		}
+
+		TSharedPtr<FJsonObject> Data = MakeShared<FJsonObject>();
+		Data->SetStringField(TEXT("subsystem_name"), SubsystemName);
+		Data->SetStringField(TEXT("session_name"),   NAME_GameSession.ToString());
+		Data->SetStringField(TEXT("session_state"),  StateStr);
+		Data->SetNumberField(TEXT("max_players"),    static_cast<double>(MaxPlayers));
+		Data->SetNumberField(TEXT("current_players"), static_cast<double>(NumPlayers));
+		Data->SetBoolField(TEXT("is_lan"),           bIsLAN);
+		Data->SetBoolField(TEXT("is_dedicated"),     bIsDedicated);
+		Data->SetArrayField(TEXT("players"),         PlayersArray);
+
+		SendResponse(BuildNetSuccessResponse(CorrId, Data) + TEXT("\n"));
+	});
+}

package/unreal-plugin/MCPBridge/Source/MCPBridgeEditor/Private/MCPNetworkingCommands.h

@@ -0,0 +1,16 @@
+// MCPNetworkingCommands.h
+// Declares the registration function for all networking and replication MCP command handlers.
+// Handlers: net.replication, net.properties, net.driver, net.session
+//
+// Call RegisterNetworkingCommands(*Router) in MCPBridgeSubsystem::Initialize()
+// BEFORE the TCP server starts accepting connections.
+
+#pragma once
+
+#include "MCPCommandRouter.h"
+
+/**
+ * Register all four networking command handlers into the given router.
+ * Must be called on the game thread before connections arrive.
+ */
+void RegisterNetworkingCommands(FMCPCommandRouter& Router);