unreal-engine-mcp-server 0.4.7 → 0.5.1

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "unreal-engine-mcp-server",
-  "version": "0.4.7",
+  "version": "0.5.1",
   "mcpName": "io.github.ChiR24/unreal-engine-mcp",
-  "description": "A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal Engine via Remote Control API. Built with TypeScript and designed for game development automation.",
+  "description": "A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal Engine via native automation bridge. Built with TypeScript and designed for game development automation.",
   "type": "module",
   "module": "src/index.ts",
   "main": "dist/index.js",
@@ -11,20 +11,56 @@
     "unreal-engine-mcp-server": "dist/cli.js"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build:core": "tsc -p tsconfig.json",
+    "build": "npm run build:core && (npm run build:wasm || echo \"WASM build failed or wasm-pack missing; continuing with TypeScript-only build. To enable WASM, install wasm-pack and re-run npm run build.\")",
     "build:watch": "tsc -p tsconfig.json --watch",
-  "start": "node dist/cli.js",
-    "smithery:dev": "npx @smithery/cli dev",
-    "smithery:build": "npx @smithery/cli build",
-  "smithery:ci": "npm run build && npx @smithery/cli build",
-  "dev": "ts-node-esm src/cli.ts",
-    "lint": "eslint . --ext .ts",
+    "start": "node dist/cli.js",
+    "dev": "ts-node-esm src/cli.ts",
+    "lint": "echo \"Lint: typescript/javascript, C, C++, C#\" && eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
+    "lint:cpp": "echo \"Running C/C++ lint (cpplint)\" && (python -m cpplint --recursive plugins || echo 'cpplint not found; skipping C/C++ lint')",
+    "lint:c": "echo \"Running C lint (cpplint)\" && (python -m cpplint --recursive plugins || echo 'cpplint not found; skipping C lint')",
+    "lint:csharp": "echo \"Running C# lint (dotnet format)\" && (dotnet tool run dotnet-format --verify-no-changes || echo 'dotnet-format not available or formatting required; skipping C# lint')",
     "clean": "rimraf dist",
     "prepare": "npm run build",
-    "test:tools": "node tests/run-unreal-tool-tests.mjs",
+    "automation:sync": "node scripts/sync-mcp-plugin.js",
+    "clean:tmp": "node scripts/clean-tmp.js",
+    "test": "node scripts/run-all-tests.mjs",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "test:unit:coverage": "vitest run --coverage",
+    "test:all": "node scripts/run-all-tests.mjs",
+    "test:manage_asset": "node tests/test-manage-asset.mjs",
+    "test:plugin-handshake": "node tests/test-plugin-handshake.mjs",
+    "test:control_actor": "node tests/test-control-actor.mjs",
+    "test:control_editor": "node tests/test-control-editor.mjs",
+    "test:manage_level": "node tests/test-manage-level.mjs",
+    "test:animation": "node tests/test-animation.mjs",
+    "test:blueprint": "node tests/test-blueprint.mjs",
+    "test:blueprint_graph": "node tests/test-blueprint-graph.mjs",
+    "test:materials": "node tests/test-materials.mjs",
+    "test:niagara": "node tests/test-niagara.mjs",
+    "test:landscape": "node tests/test-landscape.mjs",
+    "test:sequence": "node tests/test-sequence.mjs",
+    "test:system": "node tests/test-system.mjs",
+    "test:console_command": "node tests/test-console-command.mjs",
+    "test:inspect": "node tests/test-inspect.mjs",
+    "test:asset_advanced": "node tests/test-asset-advanced.mjs",
+    "test:world_partition": "node tests/test-world-partition.mjs",
+    "test:no-inline-python": "node tests/test-no-inline-python.mjs",
+    "test:graphql": "node tests/test-graphql.mjs",
+    "test:audio": "node tests/test-audio.mjs",
+    "test:behavior_tree": "node tests/test-behavior-tree.mjs",
+    "test:lighting": "node tests/test-lighting.mjs",
+    "test:performance": "node tests/test-performance.mjs",
+    "test:input": "node tests/test-input.mjs",
+    "test:asset_graph": "node tests/test-asset-graph.mjs",
+    "test:wasm": "node tests/test-wasm.mjs",
+    "build:wasm": "echo 'Building WebAssembly module...' && cd wasm && wasm-pack build --target web --out-dir ../src/wasm/pkg && cd .. && node scripts/patch-wasm.js",
+    "test:wasm:all": "npm run build:core && npm run build:wasm && node tests/test-wasm.mjs",
+    "test:smoke": "node --loader ts-node/esm scripts/smoke-test.ts",
     "type-check": "tsc --noEmit",
-    "prebuild": "npm run clean"
+    "prebuild": "npm run lint && npm run clean"
   },
   "engines": {
     "node": ">=18"
@@ -42,25 +78,28 @@
   "author": "Unreal Engine MCP Team",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.19.1",
-    "zod": "^3.22.2",
+    "@graphql-tools/schema": "^10.0.30",
+    "@graphql-tools/utils": "^10.11.0",
+    "@modelcontextprotocol/sdk": "^1.25.0",
     "ajv": "^8.17.1",
-    "axios": "^1.12.2",
-    "dotenv": "^16.4.5",
-    "json5": "^2.2.3",
-    "ws": "^8.18.0",
-    "yargs": "^17.7.2"
+    "dataloader": "^2.2.3",
+    "dotenv": "^17.2.3",
+    "graphql": "^16.12.0",
+    "graphql-yoga": "^5.17.1",
+    "ws": "^8.18.3",
+    "zod": "^4.2.1"
   },
   "devDependencies": {
-    "@types/json5": "^0.0.30",
-    "@types/node": "^20.12.7",
-    "@types/ws": "^8.5.10",
-  "@typescript-eslint/eslint-plugin": "^8.44.1",
-  "@typescript-eslint/parser": "^8.44.1",
-    "eslint": "^9.36.0",
-    "@smithery/cli": "^1.0.0",
-    "rimraf": "^6.0.1",
+    "@types/json5": "^2.2.0",
+    "@types/node": "^25.0.2",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/parser": "^8.49.0",
+    "@vitest/coverage-v8": "^4.0.16",
+    "eslint": "^9.39.2",
+    "rimraf": "^6.1.2",
     "ts-node": "^10.9.2",
-    "typescript": "^5.4.5"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
   }
-}
+}

package/plugins/McpAutomationBridge/Config/FilterPlugin.ini

@@ -0,0 +1,8 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll

package/plugins/McpAutomationBridge/McpAutomationBridge.uplugin

@@ -0,0 +1,64 @@
+{
+  "FileVersion": 3,
+  "Version": 1,
+  "VersionName": "0.1.0",
+  "FriendlyName": "MCP Automation Bridge",
+  "Description": "Editor-side bridge that accepts elevated automation requests from the Unreal MCP server.",
+  "Category": "Automation",
+  "CreatedBy": "unreal-engine-mcp-server",
+  "CreatedByURL": "https://github.com/ChiR24/Unreal_mcp",
+  "DocsURL": "",
+  "MarketplaceURL": "",
+  "SupportURL": "",
+  "CanContainContent": false,
+  "IsBetaVersion": true,
+  "IsExperimentalVersion": true,
+  "EnabledByDefault": true,
+  "SupportsUEBuildSystem": true,
+  "Modules": [
+    {
+      "Name": "McpAutomationBridge",
+      "Type": "Editor",
+      "LoadingPhase": "Default"
+    }
+  ],
+  "BlacklistPlatforms": [],
+  "Plugins": [
+    {
+      "Name": "EditorScriptingUtilities",
+      "Enabled": true
+    },
+    {
+      "Name": "LevelSequenceEditor",
+      "Enabled": true
+    },
+    {
+      "Name": "Niagara",
+      "Enabled": true
+    },
+    {
+      "Name": "ControlRig",
+      "Enabled": true
+    },
+    {
+      "Name": "ProceduralMeshComponent",
+      "Enabled": true
+    },
+    {
+      "Name": "Interchange",
+      "Enabled": true
+    },
+    {
+      "Name": "InterchangeOpenUSD",
+      "Enabled": true
+    },
+    {
+      "Name": "DataValidation",
+      "Enabled": true
+    },
+    {
+      "Name": "EnhancedInput",
+      "Enabled": true
+    }
+  ]
+}

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/McpAutomationBridge.Build.cs

@@ -0,0 +1,189 @@
+using UnrealBuildTool;
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+public class McpAutomationBridge : ModuleRules
+{
+    /// <summary>
+    /// Configures build rules, dependencies, and compile-time feature definitions for the McpAutomationBridge module based on the provided build target.
+    /// </summary>
+    /// <param name="Target">Build target settings used to determine platform, configuration, and whether editor-only dependencies and feature flags should be enabled.</param>
+    public McpAutomationBridge(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+
+        PublicDependencyModuleNames.AddRange(new string[]
+        {
+            "Core","CoreUObject","Engine","Json","JsonUtilities",
+            "LevelSequence", "MovieScene", "MovieSceneTracks"
+        });
+
+        if (Target.bBuildEditor)
+        {
+            // Editor-only Public Dependencies
+            PublicDependencyModuleNames.AddRange(new string[] 
+            { 
+                "LevelSequenceEditor", "Sequencer", "MovieSceneTools", "Niagara", "NiagaraEditor", "UnrealEd",
+                "WorldPartitionEditor", "DataLayerEditor", "EnhancedInput", "InputEditor"
+            });
+
+            PrivateDependencyModuleNames.AddRange(new string[]
+            {
+                "ApplicationCore","Slate","SlateCore","Projects","InputCore","DeveloperSettings","Settings","EngineSettings",
+                "Sockets","Networking","EditorSubsystem","EditorScriptingUtilities","BlueprintGraph",
+                "Kismet","KismetCompiler","AssetRegistry","AssetTools","MaterialEditor","SourceControl",
+                "AudioEditor", "DataValidation", "NiagaraEditor"
+            });
+
+            PrivateDependencyModuleNames.AddRange(new string[]
+            {
+                "Landscape","LandscapeEditor","LandscapeEditorUtilities","Foliage","FoliageEdit",
+                "AnimGraph","AnimationBlueprintLibrary","Persona","ToolMenus","EditorWidgets","PropertyEditor","LevelEditor",
+                "ControlRig","ControlRigDeveloper","ControlRigEditor","UMG","UMGEditor","ProceduralMeshComponent","MergeActors",
+                "BehaviorTreeEditor", "RenderCore", "RHI", "AutomationController", "GameplayDebugger", "TraceLog", "TraceAnalysis", "AIModule", "AIGraph",
+                "MeshUtilities", "MaterialUtilities"
+            });
+
+            // Ensure editor builds expose full Blueprint graph editing APIs.
+            PublicDefinitions.Add("MCP_HAS_K2NODE_HEADERS=1");
+            PublicDefinitions.Add("MCP_HAS_EDGRAPH_SCHEMA_K2=1");
+
+            // --- Feature Detection Logic ---
+
+            string EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
+            
+            // 1. SubobjectData Detection
+            // UE 5.7 renamed/moved this to SubobjectDataInterface in Editor/
+            bool bHasSubobjectDataInterface = Directory.Exists(Path.Combine(EngineDir, "Source", "Editor", "SubobjectDataInterface"));
+            
+            if (bHasSubobjectDataInterface)
+            {
+                PrivateDependencyModuleNames.Add("SubobjectDataInterface");
+                PublicDefinitions.Add("MCP_HAS_SUBOBJECT_DATA_SUBSYSTEM=1");
+            }
+            else
+            {
+                // Fallback for older versions
+                if (!PrivateDependencyModuleNames.Contains("SubobjectData"))
+                {
+                    PrivateDependencyModuleNames.Add("SubobjectData");
+                }
+                PublicDefinitions.Add("MCP_HAS_SUBOBJECT_DATA_SUBSYSTEM=1");
+            }
+
+            // 2. WorldPartition Support Detection
+            // Detect whether UWorldPartition supports ForEachDataLayerInstance
+            bool bHasWPForEach = false;
+            try
+            {
+                // In UE 5.7, ForEachDataLayerInstance moved to DataLayerManager.h
+                string WPHeader = Path.Combine(EngineDir, "Source", "Runtime", "Engine", "Public", "WorldPartition", "DataLayer", "DataLayerManager.h");
+                if (!File.Exists(WPHeader))
+                {
+                    // Fallback to old location for older engines
+                    WPHeader = Path.Combine(EngineDir, "Source", "Runtime", "Engine", "Public", "WorldPartition", "WorldPartition.h");
+                }
+
+                if (File.Exists(WPHeader))
+                {
+                    string Content = File.ReadAllText(WPHeader);
+                    if (Content.Contains("ForEachDataLayerInstance("))
+                    {
+                        bHasWPForEach = true;
+                    }
+                }
+            }
+            catch {}
+
+            PublicDefinitions.Add(bHasWPForEach ? "MCP_HAS_WP_FOR_EACH_DATALAYER=1" : "MCP_HAS_WP_FOR_EACH_DATALAYER=0");
+
+            // Ensure Win64 debug builds emit Edit-and-Continue friendly debug info
+            if (Target.Platform == UnrealTargetPlatform.Win64 && Target.Configuration == UnrealTargetConfiguration.Debug)
+            {
+                PublicDefinitions.Add("MCP_ENABLE_EDIT_AND_CONTINUE=1");
+            }
+
+            // Control Rig Factory Support
+            PublicDefinitions.Add("MCP_HAS_CONTROLRIG_FACTORY=1");
+        }
+        else
+        {
+            // Non-editor builds cannot rely on editor-only headers.
+            PublicDefinitions.Add("MCP_HAS_K2NODE_HEADERS=0");
+            PublicDefinitions.Add("MCP_HAS_EDGRAPH_SCHEMA_K2=0");
+            PublicDefinitions.Add("MCP_HAS_SUBOBJECT_DATA_SUBSYSTEM=0");
+            PublicDefinitions.Add("MCP_HAS_WP_FOR_EACH_DATALAYER=0");
+        }
+    }
+
+    /// <summary>
+    /// Determines whether a SubobjectData module or plugin exists under the given engine directory.
+    /// </summary>
+    /// <param name="EngineDir">Absolute path to the engine root directory to inspect.</param>
+    /// <returns>`true` if a SubobjectData directory is found in EngineDir/Source/Runtime/SubobjectData or anywhere under EngineDir/Plugins/Runtime; `false` if not found or if an error occurs.</returns>
+    private bool IsSubobjectDataAvailable(string EngineDir)
+    {
+        try
+        {
+            if (string.IsNullOrEmpty(EngineDir)) return false;
+            
+            // Check Runtime module
+            string RuntimeDir = Path.Combine(EngineDir, "Source", "Runtime", "SubobjectData");
+            if (Directory.Exists(RuntimeDir)) return true;
+
+            // Check Plugins
+            string PluginsDir = Path.Combine(EngineDir, "Plugins");
+            if (Directory.Exists(PluginsDir))
+            {
+                // Simple check for the folder in Runtime plugins
+                // A full recursive search might be slow, but we can check common locations or do a search
+                // The original code did a recursive search in Plugins/Runtime
+                string PluginsRuntime = Path.Combine(PluginsDir, "Runtime");
+                if (Directory.Exists(PluginsRuntime))
+                {
+                     var Found = Directory.GetDirectories(PluginsRuntime, "SubobjectData", SearchOption.AllDirectories);
+                     if (Found.Length > 0) return true;
+                }
+            }
+        }
+        catch {}
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether the current project contains a "SubobjectData" directory inside its Plugins folder by searching upward from the provided module directory for the project root (.uproject).
+    /// </summary>
+    /// <param name="ModuleDir">Path to the module directory used as the starting point to locate the project root.</param>
+    /// <returns>`true` if a "SubobjectData" directory is found under the project's Plugins directory, `false` otherwise.</returns>
+    private bool IsSubobjectDataInProject(string ModuleDir)
+    {
+        try
+        {
+            // Find project root by looking for .uproject
+            string ProjectRoot = null;
+            DirectoryInfo Dir = new DirectoryInfo(ModuleDir);
+            while (Dir != null)
+            {
+                if (Dir.GetFiles("*.uproject").Length > 0) 
+                { 
+                    ProjectRoot = Dir.FullName; 
+                    break; 
+                }
+                Dir = Dir.Parent;
+            }
+
+            if (!string.IsNullOrEmpty(ProjectRoot))
+            {
+                string ProjPlugins = Path.Combine(ProjectRoot, "Plugins");
+                if (Directory.Exists(ProjPlugins))
+                {
+                    var Found = Directory.GetDirectories(ProjPlugins, "SubobjectData", SearchOption.AllDirectories);
+                    if (Found.Length > 0) return true;
+                }
+            }
+        }
+        catch {}
+        return false;
+    }
+}

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Private/McpAutomationBridgeGlobals.cpp

@@ -0,0 +1,22 @@
+#include "McpAutomationBridgeGlobals.h"
+
+TMap<FString, TArray<TPair<FString, TSharedPtr<FMcpBridgeWebSocket>>>>
+    GBlueprintExistsInflight;
+TMap<FString, TArray<TPair<FString, TSharedPtr<FMcpBridgeWebSocket>>>>
+    GBlueprintCreateInflight;
+TMap<FString, double> GBlueprintCreateInflightTs;
+FCriticalSection GBlueprintCreateMutex;
+double GBlueprintCreateStaleTimeoutSec = 60.0;
+TSet<FString> GBlueprintBusySet;
+TMap<FString, TSharedPtr<FJsonObject>> GBlueprintRegistry;
+
+TMap<FString, TSharedPtr<FJsonObject>> GSequenceRegistry;
+FString GCurrentSequencePath;
+
+TMap<FString, TSharedPtr<FJsonObject>> GNiagaraRegistry;
+
+// Recent asset save tracking (throttle across plugin to avoid frequent
+// SavePackage calls)
+TMap<FString, double> GRecentAssetSaveTs;
+FCriticalSection GRecentAssetSaveMutex;
+double GRecentAssetSaveThrottleSeconds = 0.5;

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Private/McpAutomationBridgeGlobals.h

@@ -0,0 +1,30 @@
+// Shared globals for McpAutomationBridge plugin
+#pragma once
+
+#include "CoreMinimal.h"
+#include "HAL/CriticalSection.h"
+
+extern TMap<FString,
+            TArray<TPair<FString, TSharedPtr<class FMcpBridgeWebSocket>>>>
+    GBlueprintExistsInflight;
+extern TMap<FString,
+            TArray<TPair<FString, TSharedPtr<class FMcpBridgeWebSocket>>>>
+    GBlueprintCreateInflight;
+extern TMap<FString, double> GBlueprintCreateInflightTs;
+extern FCriticalSection GBlueprintCreateMutex;
+extern double GBlueprintCreateStaleTimeoutSec;
+extern TSet<FString> GBlueprintBusySet;
+extern TMap<FString, TSharedPtr<FJsonObject>> GBlueprintRegistry;
+
+extern TMap<FString, TSharedPtr<FJsonObject>> GSequenceRegistry;
+extern FString GCurrentSequencePath;
+
+// Lightweight registry used for created Niagara systems when running in
+// fast-mode or when native Niagara factories are not available. Tests and
+// higher-level tooling may rely on a plugin-side record of created
+// Niagara assets even when on-disk creation is not possible.
+extern TMap<FString, TSharedPtr<FJsonObject>> GNiagaraRegistry;
+
+extern TMap<FString, double> GRecentAssetSaveTs;
+extern FCriticalSection GRecentAssetSaveMutex;
+extern double GRecentAssetSaveThrottleSeconds;