feat: add manage_profiler tool with session control, counters, memory snapshots, and Frame Debugger

MCPForUnity/Editor/Tools/Profiler/ManageProfiler.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Threading.Tasks;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+
+namespace MCPForUnity.Editor.Tools.Profiler
+{
+    [McpForUnityTool("manage_profiler", AutoRegister = false, Group = "profiling")]
+    public static class ManageProfiler
+    {
+        public static async Task<object> HandleCommand(JObject @params)
+        {
+            if (@params == null)
+                return new ErrorResponse("Parameters cannot be null.");
+
+            var p = new ToolParams(@params);
+            string action = p.Get("action")?.ToLowerInvariant();
+
+            if (string.IsNullOrEmpty(action))
+                return new ErrorResponse("'action' parameter is required.");
+
+            try
+            {
+                switch (action)
+                {
+                    // Session
+                    case "profiler_start":
+                        return SessionOps.Start(@params);
+                    case "profiler_stop":
+                        return SessionOps.Stop(@params);
+                    case "profiler_status":
+                        return SessionOps.Status(@params);
+                    case "profiler_set_areas":
+                        return SessionOps.SetAreas(@params);
+
+                    // Counters
+                    case "get_frame_timing":
+                        return FrameTimingOps.GetFrameTiming(@params);
+                    case "get_counters":
+                        return await CounterOps.GetCountersAsync(@params);
+                    case "get_object_memory":
+                        return ObjectMemoryOps.GetObjectMemory(@params);
+
+                    // Memory Snapshot
+                    case "memory_take_snapshot":
+                        return await MemorySnapshotOps.TakeSnapshotAsync(@params);
+                    case "memory_list_snapshots":
+                        return MemorySnapshotOps.ListSnapshots(@params);
+                    case "memory_compare_snapshots":
+                        return MemorySnapshotOps.CompareSnapshots(@params);
+
+                    // Frame Debugger
+                    case "frame_debugger_enable":
+                        return FrameDebuggerOps.Enable(@params);
+                    case "frame_debugger_disable":
+                        return FrameDebuggerOps.Disable(@params);
+                    case "frame_debugger_get_events":
+                        return FrameDebuggerOps.GetEvents(@params);
+
+                    // Utility
+                    case "ping":
+                        return new SuccessResponse("manage_profiler is available.", new
+                        {
+                            tool = "manage_profiler",
+                            group = "profiling"
+                        });
+
+                    default:
+                        return new ErrorResponse(
+                            $"Unknown action: '{action}'. Valid actions: "
+                            + "profiler_start, profiler_stop, profiler_status, profiler_set_areas, "
+                            + "get_frame_timing, get_counters, get_object_memory, "
+                            + "memory_take_snapshot, memory_list_snapshots, memory_compare_snapshots, "
+                            + "frame_debugger_enable, frame_debugger_disable, frame_debugger_get_events, "
+                            + "ping.");
+                }
+            }
+            catch (Exception ex)
+            {
+                McpLog.Error($"[ManageProfiler] Action '{action}' failed: {ex}");
+                return new ErrorResponse($"Error in action '{action}': {ex.Message}");
+            }
+        }
+    }
+}

MCPForUnity/Editor/Tools/Profiler/Operations/CounterOps.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using Unity.Profiling;
+using Unity.Profiling.LowLevel.Unsafe;
+using UnityEditor;
+
+namespace MCPForUnity.Editor.Tools.Profiler
+{
+    internal static class CounterOps
+    {
+        internal static async Task<object> GetCountersAsync(JObject @params)
+        {
+            var p = new ToolParams(@params);
+            var categoryResult = p.GetRequired("category");
+            if (!categoryResult.IsSuccess)
+                return new ErrorResponse(categoryResult.ErrorMessage);
+
+            string categoryName = categoryResult.Value;
+            var resolved = ResolveCategory(categoryName, out string categoryError);
+            if (resolved == null)
+                return new ErrorResponse(categoryError);
+            ProfilerCategory category = resolved.Value;
+
+            // Get counter names: explicit list or discover all in category
+            var counterNames = GetRequestedCounters(p, category);
+            if (counterNames.Count == 0)
+                return new SuccessResponse($"No counters found in category '{categoryName}'.", new
+                {
+                    category = categoryName,
+                    counters = new Dictionary<string, object>()
+                });
+
+            // Start recorders
+            var recorders = new List<ProfilerRecorder>();
+            foreach (string name in counterNames)
+            {
+                recorders.Add(ProfilerRecorder.StartNew(category, name));
+            }
+
+            var data = new Dictionary<string, object>();
+            try
+            {
+                // Wait 1 frame for recorders to accumulate data
+                await WaitOneFrameAsync();
+
+                // Read values
+                for (int i = 0; i < recorders.Count; i++)
+                {
+                    var recorder = recorders[i];
+                    string name = counterNames[i];
+                    data[name] = recorder.Valid ? recorder.CurrentValueAsDouble : 0.0;
+                    data[name + "_valid"] = recorder.Valid;
+                    data[name + "_unit"] = recorder.Valid ? recorder.UnitType.ToString() : "Unknown";
+                }
+            }
+            finally
+            {
+                foreach (var recorder in recorders)
+                    recorder.Dispose();
+            }
+
+            return new SuccessResponse($"Captured {counterNames.Count} counter(s) from '{categoryName}'.", new
+            {
+                category = categoryName,
+                counters = data,
+            });
+        }
+
+        private static List<string> GetRequestedCounters(ToolParams p, ProfilerCategory category)
+        {
+            var explicitCounters = p.GetStringArray("counters");
+            if (explicitCounters != null && explicitCounters.Length > 0)
+                return explicitCounters.ToList();
+
+            var allHandles = new List<ProfilerRecorderHandle>();
+            ProfilerRecorderHandle.GetAvailable(allHandles);
+            return allHandles
+                .Select(h => ProfilerRecorderHandle.GetDescription(h))
+                .Where(d => string.Equals(d.Category.Name, category.Name, StringComparison.OrdinalIgnoreCase))
+                .Select(d => d.Name)
+                .OrderBy(n => n)
+                .ToList();
+        }
+
+        private static Task WaitOneFrameAsync()
+        {
+            var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            void Tick()
+            {
+                EditorApplication.update -= Tick;
+                tcs.TrySetResult(true);
+            }
+
+            EditorApplication.update += Tick;
+            try { EditorApplication.QueuePlayerLoopUpdate(); } catch { /* throttled editor */ }
+            return tcs.Task;
+        }
+
+        private static readonly string[] ValidCategories = new[]
+        {
+            "Render", "Scripts", "Memory", "Physics", "Physics2D", "Animation",
+            "Audio", "Lighting", "Network", "Gui", "UI", "Ai", "Video",
+            "Loading", "Input", "Vr", "Internal", "Particles", "FileIO", "VirtualTexturing"
+        };
+
+        internal static ProfilerCategory? ResolveCategory(string name, out string error)
+        {
+            error = null;
+            switch (name.ToLowerInvariant())
+            {
+                case "render": return ProfilerCategory.Render;
+                case "scripts": return ProfilerCategory.Scripts;
+                case "memory": return ProfilerCategory.Memory;
+                case "physics": return ProfilerCategory.Physics;
+                case "physics2d": return ProfilerCategory.Physics2D;
+                case "animation": return ProfilerCategory.Animation;
+                case "audio": return ProfilerCategory.Audio;
+                case "lighting": return ProfilerCategory.Lighting;
+                case "network": return ProfilerCategory.Network;
+                case "gui": case "ui": return ProfilerCategory.Gui;
+                case "ai": return ProfilerCategory.Ai;
+                case "video": return ProfilerCategory.Video;
+                case "loading": return ProfilerCategory.Loading;
+                case "input": return ProfilerCategory.Input;
+                case "vr": return ProfilerCategory.Vr;
+                case "internal": return ProfilerCategory.Internal;
+                case "particles": return ProfilerCategory.Particles;
+                case "fileio": return ProfilerCategory.FileIO;
+                case "virtualtexturing": return ProfilerCategory.VirtualTexturing;
+                default:
+                    error = $"Unknown category '{name}'. Valid: {string.Join(", ", ValidCategories)}";
+                    return null;
+            }
+        }
+    }
+}