Enhancements for returning gameObject information

CharlieHess · CharlieHess · commit e4218cb12cee · 2025-12-07T21:04:11.000-05:00
diff --git a/Editor/Resources/GetGameObjectResource.cs b/Editor/Resources/GetGameObjectResource.cs
@@ -119,6 +119,39 @@ public static JObject GameObjectToJObject(GameObject gameObject, bool includeDet
             return gameObjectJson;
         }
         
+        /// <summary>
+        /// Namespace prefixes for components with native/C++ code that crash when accessed via reflection.
+        /// These components will only have basic info (type, enabled) serialized, not detailed properties.
+        /// </summary>
+        private static readonly string[] UnsafeNamespacePrefixes = new string[]
+        {
+            "Pathfinding",  // A* Pathfinding Project
+            "FMOD",         // FMOD audio
+            "FMODUnity",    // FMOD Unity integration
+        };
+        
+        /// <summary>
+        /// Check if a component type is from a native plugin that may crash when accessed via reflection
+        /// </summary>
+        private static bool IsUnsafeNativeComponent(Type componentType)
+        {
+            if (componentType == null) return true;
+            
+            string fullName = componentType.FullName ?? "";
+            string namespaceName = componentType.Namespace ?? "";
+            
+            foreach (string prefix in UnsafeNamespacePrefixes)
+            {
+                if (namespaceName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) ||
+                    fullName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+            
+            return false;
+        }
+
         /// <summary>
         /// Get information about the components attached to a GameObject
         /// </summary>
@@ -134,16 +167,29 @@ private static JArray GetComponentsInfo(GameObject gameObject, bool includeDetai
             {
                 if (component == null) continue;
                 
+                Type componentType = component.GetType();
+                bool isUnsafe = IsUnsafeNativeComponent(componentType);
+                
                 JObject componentJson = new JObject
                 {
-                    ["type"] = component.GetType().Name,
+                    ["type"] = componentType.Name,
                     ["enabled"] = IsComponentEnabled(component)
                 };
 
-                // Add detailed information if requested
+                // Add detailed information if requested and component is safe to inspect
                 if (includeDetailedInfo)
                 {
-                    componentJson["properties"] = GetComponentProperties(component);
+                    if (isUnsafe)
+                    {
+                        componentJson["properties"] = new JObject
+                        {
+                            ["_skipped"] = "Native plugin component - serialization skipped for safety"
+                        };
+                    }
+                    else
+                    {
+                        componentJson["properties"] = GetComponentProperties(component);
+                    }
                 }
                     
                 componentsArray.Add(componentJson);
@@ -181,6 +227,16 @@ private static bool IsComponentEnabled(Component component)
             return true;
         }
 
+        /// <summary>
+        /// Maximum depth for serializing nested objects to prevent stack overflow from circular references
+        /// </summary>
+        private const int MaxSerializationDepth = 5;
+        
+        /// <summary>
+        /// Maximum items to serialize in a collection to prevent excessive output
+        /// </summary>
+        private const int MaxCollectionItems = 50;
+
         /// <summary>
         /// Get all serialized fields, public fields and public properties of a component
         /// </summary>
@@ -192,6 +248,9 @@ private static JObject GetComponentProperties(Component component)
 
             JObject propertiesJson = new JObject();
             Type componentType = component.GetType();
+            
+            // Track visited objects to prevent circular reference loops
+            HashSet<object> visited = new HashSet<object>(new ReferenceEqualityComparer());
 
             // Get serialized fields (both public and private with SerializeField attribute)
             FieldInfo[] fields = componentType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
@@ -204,7 +263,7 @@ private static JObject GetComponentProperties(Component component)
                 try
                 {
                     object value = field.GetValue(component);
-                    propertiesJson[field.Name] = SerializeValue(value);
+                    propertiesJson[field.Name] = SerializeValue(value, 0, visited);
                 }
                 catch (Exception)
                 {
@@ -223,7 +282,7 @@ private static JObject GetComponentProperties(Component component)
                 try
                 {
                     object value = property.GetValue(component);
-                    propertiesJson[property.Name] = SerializeValue(value);
+                    propertiesJson[property.Name] = SerializeValue(value, 0, visited);
                 }
                 catch (Exception)
                 {
@@ -234,6 +293,15 @@ private static JObject GetComponentProperties(Component component)
 
             return propertiesJson;
         }
+        
+        /// <summary>
+        /// Reference equality comparer for tracking visited objects (prevents circular reference infinite loops)
+        /// </summary>
+        private class ReferenceEqualityComparer : IEqualityComparer<object>
+        {
+            public new bool Equals(object x, object y) => ReferenceEquals(x, y);
+            public int GetHashCode(object obj) => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+        }
 
         /// <summary>
         /// Determine if a property should be skipped during serialization
@@ -254,14 +322,34 @@ private static bool ShouldSkipProperty(PropertyInfo property)
         }
 
         /// <summary>
-        /// Serialize a value to a JToken
+        /// Serialize a value to a JToken with depth limiting and circular reference protection
         /// </summary>
         /// <param name="value">The value to serialize</param>
+        /// <param name="depth">Current recursion depth</param>
+        /// <param name="visited">Set of already visited reference objects to detect circular references</param>
         /// <returns>A JToken representing the value</returns>
-        private static JToken SerializeValue(object value)
+        private static JToken SerializeValue(object value, int depth = 0, HashSet<object> visited = null)
         {
             if (value == null)
                 return JValue.CreateNull();
+            
+            // Depth limit check to prevent stack overflow
+            if (depth > MaxSerializationDepth)
+                return "[max depth exceeded]";
+            
+            Type valueType = value.GetType();
+            
+            // For reference types (excluding strings), check for circular references
+            if (!valueType.IsValueType && !(value is string))
+            {
+                if (visited == null)
+                    visited = new HashSet<object>(new ReferenceEqualityComparer());
+                    
+                if (visited.Contains(value))
+                    return "[circular reference]";
+                    
+                visited.Add(value);
+            }
 
             // Handle common Unity types
             if (value is Vector2 vector2)
@@ -281,8 +369,8 @@ private static JToken SerializeValue(object value)
 
             if (value is Bounds bounds)
                 return new JObject { 
-                    ["center"] = SerializeValue(bounds.center), 
-                    ["size"] = SerializeValue(bounds.size) 
+                    ["center"] = SerializeValue(bounds.center, depth + 1, visited), 
+                    ["size"] = SerializeValue(bounds.size, depth + 1, visited) 
                 };
 
             if (value is Rect rect)
@@ -291,24 +379,38 @@ private static JToken SerializeValue(object value)
             if (value is UnityEngine.Object unityObject)
                 return unityObject != null ? unityObject.name : null;
 
-            // Handle arrays and lists
+            // Handle arrays and lists with item limit
             if (value is System.Collections.IList list)
             {
                 JArray array = new JArray();
+                int count = 0;
                 foreach (var item in list)
                 {
-                    array.Add(SerializeValue(item));
+                    if (count >= MaxCollectionItems)
+                    {
+                        array.Add($"[... and {list.Count - count} more items]");
+                        break;
+                    }
+                    array.Add(SerializeValue(item, depth + 1, visited));
+                    count++;
                 }
                 return array;
             }
 
-            // Handle dictionaries
+            // Handle dictionaries with item limit
             if (value is System.Collections.IDictionary dict)
             {
                 JObject obj = new JObject();
+                int count = 0;
                 foreach (System.Collections.DictionaryEntry entry in dict)
                 {
-                    obj[entry.Key.ToString()] = SerializeValue(entry.Value);
+                    if (count >= MaxCollectionItems)
+                    {
+                        obj["_truncated"] = $"{dict.Count - count} more entries";
+                        break;
+                    }
+                    obj[entry.Key.ToString()] = SerializeValue(entry.Value, depth + 1, visited);
+                    count++;
                 }
                 return obj;
             }
@@ -317,8 +419,14 @@ private static JToken SerializeValue(object value)
             if (value is Enum enumValue)
                 return enumValue.ToString();
 
-            // Use default serialization for primitive types
-            return JToken.FromObject(value);
+            // Handle primitive types directly
+            if (valueType.IsPrimitive || value is string || value is decimal)
+            {
+                return JToken.FromObject(value);
+            }
+
+            // For complex types we don't recognize, return type name to avoid unsafe deep serialization
+            return $"[{valueType.Name}]";
         }
     }
 }
diff --git a/Editor/Tools/GetGameObjectTool.cs b/Editor/Tools/GetGameObjectTool.cs
@@ -0,0 +1,87 @@
+using McpUnity.Resources;
+using McpUnity.Unity;
+using UnityEngine;
+using UnityEditor;
+using Newtonsoft.Json.Linq;
+
+namespace McpUnity.Tools
+{
+    /// <summary>
+    /// Tool for retrieving detailed information about a specific GameObject.
+    /// This tool provides the same functionality as the get_gameobject resource,
+    /// but as a tool that can be invoked directly without URI template parameters.
+    /// </summary>
+    public class GetGameObjectTool : McpToolBase
+    {
+        public GetGameObjectTool()
+        {
+            Name = "get_gameobject";
+            Description = "Retrieves detailed information about a specific GameObject by instance ID, name, or hierarchical path (e.g., \"Parent/Child/MyObject\"). Returns all component properties including Transform position, rotation, scale, and more.";
+        }
+
+        /// <summary>
+        /// Execute the GetGameObject tool with the provided parameters
+        /// </summary>
+        /// <param name="parameters">Tool parameters as a JObject. Should include 'idOrName' which can be an instance ID, name, or path</param>
+        /// <returns>A JObject containing the GameObject data</returns>
+        public override JObject Execute(JObject parameters)
+        {
+            // Validate parameters
+            if (parameters == null || !parameters.ContainsKey("idOrName"))
+            {
+                return McpUnitySocketHandler.CreateErrorResponse(
+                    "Missing required parameter: idOrName",
+                    "validation_error"
+                );
+            }
+
+            string idOrName = parameters["idOrName"]?.ToObject<string>();
+
+            if (string.IsNullOrEmpty(idOrName))
+            {
+                return McpUnitySocketHandler.CreateErrorResponse(
+                    "Parameter 'idOrName' cannot be null or empty",
+                    "validation_error"
+                );
+            }
+
+            GameObject gameObject = null;
+
+            // Try to parse as an instance ID first
+            if (int.TryParse(idOrName, out int instanceId))
+            {
+                // Unity Instance IDs are typically negative, but we'll accept any integer
+                UnityEngine.Object unityObject = EditorUtility.InstanceIDToObject(instanceId);
+                gameObject = unityObject as GameObject;
+            }
+            else
+            {
+                // Otherwise, treat it as a name or hierarchical path
+                gameObject = GameObject.Find(idOrName);
+            }
+
+            // Check if the GameObject was found
+            if (gameObject == null)
+            {
+                return McpUnitySocketHandler.CreateErrorResponse(
+                    $"GameObject with '{idOrName}' reference not found. Make sure the GameObject exists and is loaded in the current scene(s).",
+                    "not_found_error"
+                );
+            }
+
+            // Convert the GameObject to a JObject using the resource's static method
+            JObject gameObjectData = GetGameObjectResource.GameObjectToJObject(gameObject, true);
+
+            // Create the response
+            return new JObject
+            {
+                ["success"] = true,
+                ["message"] = $"Retrieved GameObject data for '{gameObject.name}'",
+                ["gameObject"] = gameObjectData,
+                ["instanceId"] = gameObject.GetInstanceID()
+            };
+        }
+    }
+}
+
+
diff --git a/Editor/Tools/GetGameObjectTool.cs.meta b/Editor/Tools/GetGameObjectTool.cs.meta
diff --git a/Editor/UnityBridge/McpUnityServer.cs b/Editor/UnityBridge/McpUnityServer.cs
@@ -267,6 +267,10 @@ private void RegisterTools()
             // Register RecompileScriptsTool
             RecompileScriptsTool recompileScriptsTool = new RecompileScriptsTool();
             _tools.Add(recompileScriptsTool.Name, recompileScriptsTool);
+            
+            // Register GetGameObjectTool
+            GetGameObjectTool getGameObjectTool = new GetGameObjectTool();
+            _tools.Add(getGameObjectTool.Name, getGameObjectTool);
         }
         
         /// <summary>
diff --git a/Server~/src/index.ts b/Server~/src/index.ts
@@ -17,6 +17,7 @@ import { registerCreatePrefabTool } from './tools/createPrefabTool.js';
 import { registerDeleteSceneTool } from './tools/deleteSceneTool.js';
 import { registerLoadSceneTool } from './tools/loadSceneTool.js';
 import { registerRecompileScriptsTool } from './tools/recompileScriptsTool.js';
+import { registerGetGameObjectTool } from './tools/getGameObjectTool.js';
 import { registerGetMenuItemsResource } from './resources/getMenuItemResource.js';
 import { registerGetConsoleLogsResource } from './resources/getConsoleLogsResource.js';
 import { registerGetHierarchyResource } from './resources/getScenesHierarchyResource.js';
@@ -65,6 +66,7 @@ registerCreateSceneTool(server, mcpUnity, toolLogger);
 registerDeleteSceneTool(server, mcpUnity, toolLogger);
 registerLoadSceneTool(server, mcpUnity, toolLogger);
 registerRecompileScriptsTool(server, mcpUnity, toolLogger);
+registerGetGameObjectTool(server, mcpUnity, toolLogger);
 
 // Register all resources into the MCP server
 registerGetTestsResource(server, mcpUnity, resourceLogger);
diff --git a/Server~/src/tools/getGameObjectTool.ts b/Server~/src/tools/getGameObjectTool.ts
