Material tools: support direct shader property keys + add EditMode coverage (#344)

* Add TDD tests for MCP material management issues

- MCPMaterialTests.cs: Tests for material creation, assignment, and data reading
- MCPParameterHandlingTests.cs: Tests for JSON parameter parsing issues
- SphereMaterialWorkflowTests.cs: Tests for complete sphere material workflow

These tests document the current issues with:
- JSON parameter parsing in manage_asset and manage_gameobject tools
- Material creation with properties
- Material assignment to GameObjects
- Material component data reading

All tests currently fail (Red phase of TDD) and serve as specifications
for what needs to be fixed in the MCP system.

* Refine TDD tests to focus on actual MCP tool parameter parsing issues

- Removed redundant tests that verify working functionality (GameObjectSerializer, Unity APIs)
- Kept focused tests that document the real issue: MCP tool parameter validation
- Tests now clearly identify the root cause: JSON string parsing in MCP tools
- Tests specify exactly what needs to be fixed: parameter type flexibility

The issue is NOT in Unity APIs or serialization (which work fine),
but in MCP tool parameter validation being too strict.

* Fix port discovery protocol mismatch

- Update _try_probe_unity_mcp to recognize Unity bridge welcome message
- Unity bridge sends 'WELCOME UNITY-MCP' instead of JSON pong response
- Maintains backward compatibility with JSON pong format
- Fixes MCP server connection to Unity Editor

* Resolve merge: unify manage_gameobject param coercion and schema widening

* Tests: add MaterialParameterToolTests; merge port probe fix; widen tool schemas for JSON-string params

* feat(material): support direct shader property keys and texture paths; add EditMode tests

* chore(tests): track required .meta files; remove ephemeral Assets/Editor test helper

* fix(manage_gameobject): validate parsed component_properties is a dict; return clear error

Author: dsarno

MCPForUnity/Editor/Tools/ManageAsset.cs

@@ -64,7 +64,19 @@ public static object HandleCommand(JObject @params)
             string path = @params["path"]?.ToString();
 
             // Coerce string JSON to JObject for 'properties' if provided as a JSON string
-            JsonUtil.CoerceJsonStringParameter(@params, "properties");
+            var propertiesToken = @params["properties"];
+            if (propertiesToken != null && propertiesToken.Type == JTokenType.String)
+            {
+                try
+                {
+                    var parsed = JObject.Parse(propertiesToken.ToString());
+                    @params["properties"] = parsed;
+                }
+                catch (Exception e)
+                {
+                    Debug.LogWarning($"[ManageAsset] Could not parse 'properties' JSON string: {e.Message}");
+                }
+            }
 
             try
             {
@@ -1002,7 +1014,108 @@ private static bool ApplyMaterialProperties(Material mat, JObject properties)
                 }
             }
 
-            // TODO: Add handlers for other property types (Vectors, Ints, Keywords, RenderQueue, etc.)
+			// --- Flexible direct property assignment ---
+			// Allow payloads like: { "_Color": [r,g,b,a] }, { "_Glossiness": 0.5 }, { "_MainTex": "Assets/.." }
+			// while retaining backward compatibility with the structured keys above.
+			// This iterates all top-level keys except the reserved structured ones and applies them
+			// if they match known shader properties.
+			var reservedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "shader", "color", "float", "texture" };
+
+			// Helper resolves common URP/Standard aliasing (e.g., _Color <-> _BaseColor, _MainTex <-> _BaseMap, _Glossiness <-> _Smoothness)
+			string ResolvePropertyName(string name)
+			{
+				if (string.IsNullOrEmpty(name)) return name;
+				string[] candidates;
+				switch (name)
+				{
+					case "_Color": candidates = new[] { "_Color", "_BaseColor" }; break;
+					case "_BaseColor": candidates = new[] { "_BaseColor", "_Color" }; break;
+					case "_MainTex": candidates = new[] { "_MainTex", "_BaseMap" }; break;
+					case "_BaseMap": candidates = new[] { "_BaseMap", "_MainTex" }; break;
+					case "_Glossiness": candidates = new[] { "_Glossiness", "_Smoothness" }; break;
+					case "_Smoothness": candidates = new[] { "_Smoothness", "_Glossiness" }; break;
+					default: candidates = new[] { name }; break;
+				}
+				foreach (var candidate in candidates)
+				{
+					if (mat.HasProperty(candidate)) return candidate;
+				}
+				return name; // fall back to original
+			}
+
+			foreach (var prop in properties.Properties())
+			{
+				if (reservedKeys.Contains(prop.Name)) continue;
+				string shaderProp = ResolvePropertyName(prop.Name);
+				JToken v = prop.Value;
+
+				// Color: numeric array [r,g,b,(a)]
+				if (v is JArray arr && arr.Count >= 3 && arr.All(t => t.Type == JTokenType.Float || t.Type == JTokenType.Integer))
+				{
+					if (mat.HasProperty(shaderProp))
+					{
+						try
+						{
+							var c = new Color(
+								arr[0].ToObject<float>(),
+								arr[1].ToObject<float>(),
+								arr[2].ToObject<float>(),
+								arr.Count > 3 ? arr[3].ToObject<float>() : 1f
+							);
+							if (mat.GetColor(shaderProp) != c)
+							{
+								mat.SetColor(shaderProp, c);
+								modified = true;
+							}
+						}
+						catch (Exception ex)
+						{
+							Debug.LogWarning($"Error setting color '{shaderProp}': {ex.Message}");
+						}
+					}
+					continue;
+				}
+
+				// Float: single number
+				if (v.Type == JTokenType.Float || v.Type == JTokenType.Integer)
+				{
+					if (mat.HasProperty(shaderProp))
+					{
+						try
+						{
+							float f = v.ToObject<float>();
+							if (!Mathf.Approximately(mat.GetFloat(shaderProp), f))
+							{
+								mat.SetFloat(shaderProp, f);
+								modified = true;
+							}
+						}
+						catch (Exception ex)
+						{
+							Debug.LogWarning($"Error setting float '{shaderProp}': {ex.Message}");
+						}
+					}
+					continue;
+				}
+
+				// Texture: string path
+				if (v.Type == JTokenType.String)
+				{
+					string texPath = v.ToString();
+					if (!string.IsNullOrEmpty(texPath) && mat.HasProperty(shaderProp))
+					{
+						var tex = AssetDatabase.LoadAssetAtPath<Texture>(AssetPathUtility.SanitizeAssetPath(texPath));
+						if (tex != null && mat.GetTexture(shaderProp) != tex)
+						{
+							mat.SetTexture(shaderProp, tex);
+							modified = true;
+						}
+					}
+					continue;
+				}
+			}
+
+			// TODO: Add handlers for other property types (Vectors, Ints, Keywords, RenderQueue, etc.)
             return modified;
         }
 

MCPForUnity/Editor/Tools/ManageGameObject.cs

@@ -67,7 +67,19 @@ public static object HandleCommand(JObject @params)
             // --- End add parameter ---
 
             // Coerce string JSON to JObject for 'componentProperties' if provided as a JSON string
-            JsonUtil.CoerceJsonStringParameter(@params, "componentProperties");
+            var componentPropsToken = @params["componentProperties"];
+            if (componentPropsToken != null && componentPropsToken.Type == JTokenType.String)
+            {
+                try
+                {
+                    var parsed = JObject.Parse(componentPropsToken.ToString());
+                    @params["componentProperties"] = parsed;
+                }
+                catch (Exception e)
+                {
+                    Debug.LogWarning($"[ManageGameObject] Could not parse 'componentProperties' JSON string: {e.Message}");
+                }
+            }
 
             // --- Prefab Redirection Check ---
             string targetPath =

MCPForUnity/UnityMcpServer~/src/tools/manage_asset.py

@@ -39,7 +39,7 @@ async def manage_asset(
         try:
             properties = json.loads(properties)
             ctx.info("manage_asset: coerced properties from JSON string to dict")
-        except json.JSONDecodeError as e:
+        except Exception as e:
             ctx.warn(f"manage_asset: failed to parse properties JSON string: {e}")
             # Leave properties as-is; Unity side may handle defaults
     # Ensure properties is a dict if None

MCPForUnity/UnityMcpServer~/src/tools/manage_gameobject.py

@@ -45,7 +45,6 @@ def manage_gameobject(
                                     "List of component names to remove"] | None = None,
     component_properties: Annotated[dict[str, dict[str, Any]] | str,
                                     """Dictionary of component names to their properties to set. For example:
-                                    Can also be provided as a JSON string representation of the dict.
                                     `{"MyScript": {"otherObject": {"find": "Player", "method": "by_name"}}}` assigns GameObject
                                     `{"MyScript": {"playerHealth": {"find": "Player", "component": "HealthComponent"}}}` assigns Component
                                     Example set nested property:
@@ -122,6 +121,9 @@ def _to_vec3(parts):
             ctx.info("manage_gameobject: coerced component_properties from JSON string to dict")
         except json.JSONDecodeError as e:
             return {"success": False, "message": f"Invalid JSON in component_properties: {e}"}
+    # Ensure final type is a dict (object) if provided
+    if component_properties is not None and not isinstance(component_properties, dict):
+        return {"success": False, "message": "component_properties must be a JSON object (dict)."}
     try:
         # Map tag to search_term when search_method is by_tag for backward compatibility
         if action == "find" and search_method == "by_tag" and tag is not None and search_term is None:

TestProjects/UnityMCPTests/Assets/Temp/LiveTests.meta

@@ -18,24 +18,21 @@ namespace Tests.EditMode
     /// </summary>
     public class MCPToolParameterTests
     {
-        private const string TempDir = "Assets/Temp/MCPToolParameterTests";
-
-        [SetUp]
-        public void SetUp()
+        [Test]
+        public void Test_ManageAsset_ShouldAcceptJSONProperties()
         {
+            // Arrange: create temp folder
+            const string tempDir = "Assets/Temp/MCPToolParameterTests";
             if (!AssetDatabase.IsValidFolder("Assets/Temp"))
             {
                 AssetDatabase.CreateFolder("Assets", "Temp");
             }
-            if (!AssetDatabase.IsValidFolder(TempDir))
+            if (!AssetDatabase.IsValidFolder(tempDir))
             {
                 AssetDatabase.CreateFolder("Assets/Temp", "MCPToolParameterTests");
             }
-        }
-        [Test]
-        public void Test_ManageAsset_ShouldAcceptJSONProperties()
-        {
-            var matPath = $"{TempDir}/JsonMat_{Guid.NewGuid().ToString("N")}.mat";
+
+            var matPath = $"{tempDir}/JsonMat_{Guid.NewGuid().ToString("N")}.mat";
 
             // Build params with properties as a JSON string (to be coerced)
             var p = new JObject
@@ -73,7 +70,10 @@ public void Test_ManageAsset_ShouldAcceptJSONProperties()
         [Test]
         public void Test_ManageGameObject_ShouldAcceptJSONComponentProperties()
         {
-            var matPath = $"{TempDir}/JsonMat_{Guid.NewGuid().ToString("N")}.mat";
+            const string tempDir = "Assets/Temp/MCPToolParameterTests";
+            if (!AssetDatabase.IsValidFolder("Assets/Temp")) AssetDatabase.CreateFolder("Assets", "Temp");
+            if (!AssetDatabase.IsValidFolder(tempDir)) AssetDatabase.CreateFolder("Assets/Temp", "MCPToolParameterTests");
+            var matPath = $"{tempDir}/JsonMat_{Guid.NewGuid().ToString("N")}.mat";
 
             // Create a material first (object-typed properties)
             var createMat = new JObject
@@ -121,7 +121,10 @@ public void Test_ManageGameObject_ShouldAcceptJSONComponentProperties()
         [Test]
         public void Test_JSONParsing_ShouldWorkInMCPTools()
         {
-            var matPath = $"{TempDir}/JsonMat_{Guid.NewGuid().ToString("N")}.mat";
+            const string tempDir = "Assets/Temp/MCPToolParameterTests";
+            if (!AssetDatabase.IsValidFolder("Assets/Temp")) AssetDatabase.CreateFolder("Assets", "Temp");
+            if (!AssetDatabase.IsValidFolder(tempDir)) AssetDatabase.CreateFolder("Assets/Temp", "MCPToolParameterTests");
+            var matPath = $"{tempDir}/JsonMat_{Guid.NewGuid().ToString("N")}.mat";
 
             // manage_asset with JSON string properties (coercion path)
             var createMat = new JObject