feat: Prefab Feature Updates

MCPForUnity/Editor/Helpers/AssetPathUtility.cs

@@ -27,6 +27,7 @@ public static string NormalizeSeparators(string path)
 
         /// <summary>
         /// Normalizes a Unity asset path by ensuring forward slashes are used and that it is rooted under "Assets/".
+        /// Also protects against path traversal attacks using "../" sequences.
         /// </summary>
         public static string SanitizeAssetPath(string path)
         {
@@ -36,6 +37,15 @@ public static string SanitizeAssetPath(string path)
             }
 
             path = NormalizeSeparators(path);
+
+            // Check for path traversal sequences
+            if (path.Contains(".."))
+            {
+                McpLog.Warn($"[AssetPathUtility] Path contains potential traversal sequence: '{path}'");
+                return null;
+            }
+
+            // Ensure path starts with Assets/
             if (!path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
             {
                 return "Assets/" + path.TrimStart('/');
@@ -44,6 +54,45 @@ public static string SanitizeAssetPath(string path)
             return path;
         }
 
+        /// <summary>
+        /// Checks if a given asset path is valid and safe (no traversal, within Assets folder).
+        /// </summary>
+        /// <returns>True if the path is valid, false otherwise.</returns>
+        public static bool IsValidAssetPath(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return false;
+            }
+
+            // Normalize for comparison
+            string normalized = NormalizeSeparators(path);
+
+            // Must start with Assets/
+            if (!normalized.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            // Must not contain traversal sequences
+            if (normalized.Contains(".."))
+            {
+                return false;
+            }
+
+            // Must not contain invalid path characters
+            char[] invalidChars = { ':', '*', '?', '"', '<', '>', '|' };
+            foreach (char c in invalidChars)
+            {
+                if (normalized.IndexOf(c) >= 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// Gets the MCP for Unity package root path.
         /// Works for registry Package Manager, local Package Manager, and Asset Store installations.

MCPForUnity/Editor/Helpers/PrefabUtilityHelper.cs

@@ -0,0 +1,228 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Helpers
+{
+    /// <summary>
+    /// Provides common utility methods for working with Unity Prefab assets.
+    /// </summary>
+    public static class PrefabUtilityHelper
+    {
+        /// <summary>
+        /// Gets the GUID for a prefab asset path.
+        /// </summary>
+        /// <param name="assetPath">The Unity asset path (e.g., "Assets/Prefabs/MyPrefab.prefab")</param>
+        /// <returns>The GUID string, or null if the path is invalid.</returns>
+        public static string GetPrefabGUID(string assetPath)
+        {
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                return null;
+            }
+
+            try
+            {
+                return AssetDatabase.AssetPathToGUID(assetPath);
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to get GUID for asset path '{assetPath}': {ex.Message}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets variant information if the prefab is a variant.
+        /// </summary>
+        /// <param name="prefabAsset">The prefab GameObject to check.</param>
+        /// <returns>A tuple containing (isVariant, parentPath, parentGuid).</returns>
+        public static (bool isVariant, string parentPath, string parentGuid) GetVariantInfo(GameObject prefabAsset)
+        {
+            if (prefabAsset == null)
+            {
+                return (false, null, null);
+            }
+
+            try
+            {
+                PrefabAssetType assetType = PrefabUtility.GetPrefabAssetType(prefabAsset);
+                if (assetType != PrefabAssetType.Variant)
+                {
+                    return (false, null, null);
+                }
+
+                GameObject parentAsset = PrefabUtility.GetCorrespondingObjectFromSource(prefabAsset);
+                if (parentAsset == null)
+                {
+                    return (true, null, null);
+                }
+
+                string parentPath = AssetDatabase.GetAssetPath(parentAsset);
+                string parentGuid = GetPrefabGUID(parentPath);
+
+                return (true, parentPath, parentGuid);
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to get variant info for '{prefabAsset.name}': {ex.Message}");
+                return (false, null, null);
+            }
+        }
+
+        /// <summary>
+        /// Gets the list of component type names on a GameObject.
+        /// </summary>
+        /// <param name="obj">The GameObject to inspect.</param>
+        /// <returns>A list of component type full names.</returns>
+        public static List<string> GetComponentTypeNames(GameObject obj)
+        {
+            var typeNames = new List<string>();
+
+            if (obj == null)
+            {
+                return typeNames;
+            }
+
+            try
+            {
+                var components = obj.GetComponents<Component>();
+                foreach (var component in components)
+                {
+                    if (component != null)
+                    {
+                        typeNames.Add(component.GetType().FullName);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to get component types for '{obj.name}': {ex.Message}");
+            }
+
+            return typeNames;
+        }
+
+        /// <summary>
+        /// Recursively counts all children in the hierarchy.
+        /// </summary>
+        /// <param name="transform">The root transform to count from.</param>
+        /// <returns>Total number of children in the hierarchy.</returns>
+        public static int CountChildrenRecursive(Transform transform)
+        {
+            if (transform == null)
+            {
+                return 0;
+            }
+
+            int count = transform.childCount;
+            for (int i = 0; i < transform.childCount; i++)
+            {
+                count += CountChildrenRecursive(transform.GetChild(i));
+            }
+            return count;
+        }
+
+        /// <summary>
+        /// Gets the source prefab path for a nested prefab instance.
+        /// </summary>
+        /// <param name="gameObject">The GameObject to check.</param>
+        /// <returns>The asset path of the source prefab, or null if not a nested prefab.</returns>
+        public static string GetNestedPrefabPath(GameObject gameObject)
+        {
+            if (gameObject == null || !PrefabUtility.IsAnyPrefabInstanceRoot(gameObject))
+            {
+                return null;
+            }
+
+            try
+            {
+                var sourcePrefab = PrefabUtility.GetCorrespondingObjectFromSource(gameObject);
+                if (sourcePrefab != null)
+                {
+                    return AssetDatabase.GetAssetPath(sourcePrefab);
+                }
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to get nested prefab path for '{gameObject.name}': {ex.Message}");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the nesting depth of a prefab instance within the prefab hierarchy.
+        /// Returns 0 for main prefab root, 1 for first-level nested, 2 for second-level, etc.
+        /// Returns -1 for non-prefab-root objects.
+        /// </summary>
+        /// <param name="gameObject">The GameObject to analyze.</param>
+        /// <param name="mainPrefabRoot">The root transform of the main prefab asset.</param>
+        /// <returns>Nesting depth (0=main root, 1+=nested), or -1 if not a prefab root.</returns>
+        public static int GetPrefabNestingDepth(GameObject gameObject, Transform mainPrefabRoot)
+        {
+            if (gameObject == null)
+                return -1;
+
+            // Main prefab root
+            if (gameObject.transform == mainPrefabRoot)
+                return 0;
+
+            // Not a prefab instance root
+            if (!PrefabUtility.IsAnyPrefabInstanceRoot(gameObject))
+                return -1;
+
+            // Calculate depth by walking up the hierarchy
+            int depth = 0;
+            Transform current = gameObject.transform;
+
+            while (current != null && current != mainPrefabRoot)
+            {
+                if (PrefabUtility.IsAnyPrefabInstanceRoot(current.gameObject))
+                {
+                    depth++;
+                }
+                current = current.parent;
+            }
+
+            return depth;
+        }
+
+        /// <summary>
+        /// Gets the parent prefab path for a nested prefab instance.
+        /// Returns null for main prefab root or non-prefab objects.
+        /// </summary>
+        /// <param name="gameObject">The GameObject to analyze.</param>
+        /// <param name="mainPrefabRoot">The root transform of the main prefab asset.</param>
+        /// <returns>The asset path of the parent prefab, or null if none.</returns>
+        public static string GetParentPrefabPath(GameObject gameObject, Transform mainPrefabRoot)
+        {
+            if (gameObject == null || gameObject.transform == mainPrefabRoot)
+                return null;
+
+            if (!PrefabUtility.IsAnyPrefabInstanceRoot(gameObject))
+                return null;
+
+            // Walk up the hierarchy to find the parent prefab instance
+            Transform current = gameObject.transform.parent;
+
+            while (current != null && current != mainPrefabRoot)
+            {
+                if (PrefabUtility.IsAnyPrefabInstanceRoot(current.gameObject))
+                {
+                    return GetNestedPrefabPath(current.gameObject);
+                }
+                current = current.parent;
+            }
+
+            // Parent is the main prefab root - get its asset path
+            if (mainPrefabRoot != null)
+            {
+                return AssetDatabase.GetAssetPath(mainPrefabRoot.gameObject);
+            }
+
+            return null;
+        }
+    }
+}

MCPForUnity/Editor/Tools/GameObjects/GameObjectModify.cs

@@ -5,6 +5,7 @@
 using MCPForUnity.Editor.Helpers;
 using Newtonsoft.Json.Linq;
 using UnityEditor;
+using UnityEditor.SceneManagement;
 using UnityEditorInternal;
 using UnityEngine;
 
@@ -239,6 +240,18 @@ internal static object Handle(JObject @params, JToken targetToken, string search
             }
 
             EditorUtility.SetDirty(targetGo);
+
+            // Mark the appropriate scene as dirty (handles both regular scenes and prefab stages)
+            var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
+            if (prefabStage != null)
+            {
+                EditorSceneManager.MarkSceneDirty(prefabStage.scene);
+            }
+            else
+            {
+                EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+            }
+
             return new SuccessResponse(
                 $"GameObject '{targetGo.name}' modified successfully.",
                 Helpers.GameObjectSerializer.GetGameObjectData(targetGo)