ue-mcp 1.1.19 → 1.1.21

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

@@ -0,0 +1,121 @@
+#include "LockRegistry.h"
+#include "HAL/PlatformTime.h"
+#include "HAL/CriticalSection.h"
+#include "Misc/ScopeLock.h"
+
+FMCPLockRegistry& FMCPLockRegistry::Get()
+{
+	static FMCPLockRegistry Instance;
+	return Instance;
+}
+
+FString FMCPLockRegistry::NormalizeKey(const FString& AssetPath)
+{
+	FString Key = AssetPath;
+	Key.TrimStartAndEndInline();
+	Key.ReplaceInline(TEXT("\\"), TEXT("/"));
+
+	// Collapse ObjectPath ("/Game/Foo.Foo") to PackagePath ("/Game/Foo"): if the
+	// last '.' comes after the last '/', drop from that '.' onward so both
+	// spellings key the same lock. Paths without a dotted object suffix are left
+	// as-is.
+	int32 SlashIdx = INDEX_NONE;
+	int32 DotIdx = INDEX_NONE;
+	Key.FindLastChar(TEXT('/'), SlashIdx);
+	Key.FindLastChar(TEXT('.'), DotIdx);
+	if (DotIdx != INDEX_NONE && DotIdx > SlashIdx)
+	{
+		Key = Key.Left(DotIdx);
+	}
+
+	return Key.ToLower();
+}
+
+void FMCPLockRegistry::PurgeExpired(double Now)
+{
+	for (auto It = Locks.CreateIterator(); It; ++It)
+	{
+		if (It->Value.ExpiresMono <= Now)
+		{
+			It.RemoveCurrent();
+		}
+	}
+}
+
+bool FMCPLockRegistry::Acquire(const FString& AssetPath, const FString& SessionId, double TtlSeconds, FMCPAssetLock& OutHolder)
+{
+	FScopeLock ScopeLock(&Mutex);
+	const double Now = FPlatformTime::Seconds();
+	PurgeExpired(Now);
+
+	const FString Key = NormalizeKey(AssetPath);
+	if (FMCPAssetLock* Existing = Locks.Find(Key))
+	{
+		if (Existing->SessionId == SessionId)
+		{
+			// Re-entrant: same session refreshes its own lease rather than
+			// deadlocking on a lock it already holds.
+			Existing->ExpiresMono = Now + TtlSeconds;
+			Existing->TtlSeconds = TtlSeconds;
+			OutHolder = *Existing;
+			return true;
+		}
+		// Held by a different, still-live session.
+		OutHolder = *Existing;
+		return false;
+	}
+
+	FMCPAssetLock New;
+	New.AssetPath = AssetPath;
+	New.SessionId = SessionId;
+	New.AcquiredAtUtc = FDateTime::UtcNow();
+	New.ExpiresMono = Now + TtlSeconds;
+	New.TtlSeconds = TtlSeconds;
+	Locks.Add(Key, New);
+	OutHolder = New;
+	return true;
+}
+
+bool FMCPLockRegistry::Release(const FString& AssetPath, const FString& SessionId, bool bForce, FMCPAssetLock& OutReleased)
+{
+	FScopeLock ScopeLock(&Mutex);
+	const FString Key = NormalizeKey(AssetPath);
+	if (FMCPAssetLock* Existing = Locks.Find(Key))
+	{
+		if (bForce || Existing->SessionId == SessionId)
+		{
+			OutReleased = *Existing;
+			Locks.Remove(Key);
+			return true;
+		}
+	}
+	return false;
+}
+
+int32 FMCPLockRegistry::ReleaseSession(const FString& SessionId)
+{
+	FScopeLock ScopeLock(&Mutex);
+	int32 Count = 0;
+	for (auto It = Locks.CreateIterator(); It; ++It)
+	{
+		if (It->Value.SessionId == SessionId)
+		{
+			It.RemoveCurrent();
+			++Count;
+		}
+	}
+	return Count;
+}
+
+TArray<FMCPAssetLock> FMCPLockRegistry::List()
+{
+	FScopeLock ScopeLock(&Mutex);
+	PurgeExpired(FPlatformTime::Seconds());
+	TArray<FMCPAssetLock> Out;
+	Out.Reserve(Locks.Num());
+	for (const TPair<FString, FMCPAssetLock>& Pair : Locks)
+	{
+		Out.Add(Pair.Value);
+	}
+	return Out;
+}

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

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Misc/DateTime.h"
+#include "HAL/CriticalSection.h"
+
+/**
+ * A single held asset lock. AcquiredAtUtc is for display; ExpiresMono is the
+ * monotonic deadline used for TTL math (wall-clock is unsuitable because it can
+ * jump). TtlSeconds is the lease length the holder requested.
+ */
+struct FMCPAssetLock
+{
+	FString AssetPath;
+	FString SessionId;
+	FDateTime AcquiredAtUtc;
+	double ExpiresMono = 0.0;
+	double TtlSeconds = 0.0;
+};
+
+/**
+ * Per-asset exclusive lock registry, living in the editor bridge — the single
+ * shared resource every agent connects to. A lock registry on the Node side
+ * would only serialize one agent process; because every agent's Node server
+ * talks to this one bridge, the registry has to live here to serialize across
+ * agents (or an agent plus a human).
+ *
+ * Locks carry a session id and a TTL. A crashed or disconnected agent never
+ * wedges an asset: the lease simply expires and the next acquire reclaims it.
+ * Re-acquiring a lock you already hold (same session) just refreshes the lease,
+ * so a single agent never blocks itself across a multi-step operation.
+ *
+ * All handler execution is marshalled onto the game thread, so these operations
+ * are already serialized; the critical section is defence-in-depth for the
+ * List()/expiry paths.
+ */
+class FMCPLockRegistry
+{
+public:
+	static FMCPLockRegistry& Get();
+
+	/** Canonical key: trimmed, forward-slashed, ObjectPath ("/Game/Foo.Foo")
+	 *  collapsed to PackagePath ("/Game/Foo"), lowercased — so every spelling
+	 *  of the same asset contends for one lock. */
+	static FString NormalizeKey(const FString& AssetPath);
+
+	/** Acquire or refresh. Returns true when the caller holds the lock after the
+	 *  call (fresh acquire or same-session refresh). On false the asset is held
+	 *  by another live session; OutHolder describes it. */
+	bool Acquire(const FString& AssetPath, const FString& SessionId, double TtlSeconds, FMCPAssetLock& OutHolder);
+
+	/** Release a lock. Succeeds when held by SessionId, or unconditionally when
+	 *  bForce. OutReleased describes what was removed. */
+	bool Release(const FString& AssetPath, const FString& SessionId, bool bForce, FMCPAssetLock& OutReleased);
+
+	/** Release every lock held by a session (agent shutdown). Returns the count. */
+	int32 ReleaseSession(const FString& SessionId);
+
+	/** Snapshot of all currently-held (non-expired) locks. */
+	TArray<FMCPAssetLock> List();
+
+private:
+	void PurgeExpired(double Now);
+
+	FCriticalSection Mutex;
+	TMap<FString, FMCPAssetLock> Locks; // key = NormalizeKey(AssetPath)
+};

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

@@ -15,8 +15,13 @@ static TSharedPtr<FMCPBridgeServer> G_BridgeServer;
 
 void FUE_MCP_BridgeModule::StartupModule()
 {
-	// Create and start bridge server
-	G_BridgeServer = MakeShared<FMCPBridgeServer>(9877);
+	// Create and start bridge server. The base port is derived per-worktree
+	// from the project root path (or an explicit -MCPPort / UE_MCP_PORT
+	// override) so multiple checkouts can run side-by-side without colliding;
+	// the probe loop in Run() resolves the rare clash and publishes the actual
+	// bound port to the per-project lockfile.
+	const int32 BasePort = FMCPBridgeServer::ResolveConfiguredPort();
+	G_BridgeServer = MakeShared<FMCPBridgeServer>(BasePort);
 	FDialogHandlers::InstallDialogHook();
 	// Safety net: auto-decline overwrite dialogs to prevent game thread blocking.
 	// Handlers should check for existing assets before creating, but if a dialog
@@ -37,7 +42,7 @@ void FUE_MCP_BridgeModule::StartupModule()
 
 	if (G_BridgeServer->Start())
 	{
-		UE_LOG(LogMCPBridge, Log, TEXT("[UE-MCP] Bridge server started on port 9877"));
+		UE_LOG(LogMCPBridge, Log, TEXT("[UE-MCP] Bridge server starting on base port %d"), BasePort);
 	}
 	else
 	{