unity-mcp/Editor/Commands/EditorControlHandler.cs

using UnityEngine;
using UnityEditor;
using UnityEditor.Build.Reporting;
using Newtonsoft.Json.Linq;
using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;

namespace UnityMCP.Editor.Commands
{
    /// <summary>
    /// Handles editor control commands like undo, redo, play, pause, stop, and build operations.
    /// </summary>
    public static class EditorControlHandler
    {
        /// <summary>
        /// Handles editor control commands
        /// </summary>
        public static object HandleEditorControl(JObject @params)
        {
            string command = (string)@params["command"];
            JObject commandParams = (JObject)@params["params"];

            return command.ToUpper() switch
            {
                "UNDO" => HandleUndo(),
                "REDO" => HandleRedo(),
                "PLAY" => HandlePlay(),
                "PAUSE" => HandlePause(),
                "STOP" => HandleStop(),
                "BUILD" => HandleBuild(commandParams),
                "EXECUTE_COMMAND" => HandleExecuteCommand(commandParams),
                "READ_CONSOLE" => ReadConsole(commandParams),
                "GET_AVAILABLE_COMMANDS" => GetAvailableCommands(),
                _ => new { error = $"Unknown editor control command: {command}" },
            };
        }

        private static object HandleUndo()
        {
            Undo.PerformUndo();
            return new { message = "Undo performed successfully" };
        }

        private static object HandleRedo()
        {
            Undo.PerformRedo();
            return new { message = "Redo performed successfully" };
        }

        private static object HandlePlay()
        {
            if (!EditorApplication.isPlaying)
            {
                EditorApplication.isPlaying = true;
                return new { message = "Entered play mode" };
            }
            return new { message = "Already in play mode" };
        }

        private static object HandlePause()
        {
            if (EditorApplication.isPlaying)
            {
                EditorApplication.isPaused = !EditorApplication.isPaused;
                return new { message = EditorApplication.isPaused ? "Game paused" : "Game resumed" };
            }
            return new { message = "Not in play mode" };
        }

        private static object HandleStop()
        {
            if (EditorApplication.isPlaying)
            {
                EditorApplication.isPlaying = false;
                return new { message = "Exited play mode" };
            }
            return new { message = "Not in play mode" };
        }

        private static object HandleBuild(JObject @params)
        {
            string platform = (string)@params["platform"];
            string buildPath = (string)@params["buildPath"];

            try
            {
                BuildTarget target = GetBuildTarget(platform);
                if ((int)target == -1)
                {
                    return new { error = $"Unsupported platform: {platform}" };
                }

                BuildPlayerOptions buildPlayerOptions = new()
                {
                    scenes = GetEnabledScenes(),
                    target = target,
                    locationPathName = buildPath
                };

                BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
                return new
                {
                    message = "Build completed successfully",
                    report.summary
                };
            }
            catch (Exception e)
            {
                return new { error = $"Build failed: {e.Message}" };
            }
        }

        private static object HandleExecuteCommand(JObject @params)
        {
            string commandName = (string)@params["commandName"];
            try
            {
                EditorApplication.ExecuteMenuItem(commandName);
                return new { message = $"Executed command: {commandName}" };
            }
            catch (Exception e)
            {
                return new { error = $"Failed to execute command: {e.Message}" };
            }
        }

        /// <summary>
        /// Reads log messages from the Unity Console
        /// </summary>
        /// <param name="params">Parameters containing filtering options</param>
        /// <returns>Object containing console messages filtered by type</returns>
        public static object ReadConsole(JObject @params)
        {
            // Default values for show flags
            bool showLogs = true;
            bool showWarnings = true;
            bool showErrors = true;
            string searchTerm = string.Empty;

            // Get filter parameters if provided
            if (@params != null)
            {
                if (@params["show_logs"] != null) showLogs = (bool)@params["show_logs"];
                if (@params["show_warnings"] != null) showWarnings = (bool)@params["show_warnings"];
                if (@params["show_errors"] != null) showErrors = (bool)@params["show_errors"];
                if (@params["search_term"] != null) searchTerm = (string)@params["search_term"];
            }

            try
            {
                // Get required types and methods via reflection
                Type logEntriesType = Type.GetType("UnityEditor.LogEntries,UnityEditor");
                Type logEntryType = Type.GetType("UnityEditor.LogEntry,UnityEditor");

                if (logEntriesType == null || logEntryType == null)
                    return new { error = "Could not find required Unity logging types", entries = new List<object>() };

                // Get essential methods
                MethodInfo getCountMethod = logEntriesType.GetMethod("GetCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                MethodInfo getEntryMethod = logEntriesType.GetMethod("GetEntryAt", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) ??
                                            logEntriesType.GetMethod("GetEntryInternal", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

                if (getCountMethod == null || getEntryMethod == null)
                    return new { error = "Could not find required Unity logging methods", entries = new List<object>() };

                // Get stack trace method if available
                MethodInfo getStackTraceMethod = logEntriesType.GetMethod("GetEntryStackTrace", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic,
                    null, new[] { typeof(int) }, null) ?? logEntriesType.GetMethod("GetStackTrace", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic,
                    null, new[] { typeof(int) }, null);

                // Get entry count and prepare result list
                int count = (int)getCountMethod.Invoke(null, null);
                var entries = new List<object>();

                // Create LogEntry instance to populate
                object logEntryInstance = Activator.CreateInstance(logEntryType);

                // Find properties on LogEntry type
                PropertyInfo modeProperty = logEntryType.GetProperty("mode") ?? logEntryType.GetProperty("Mode");
                PropertyInfo messageProperty = logEntryType.GetProperty("message") ?? logEntryType.GetProperty("Message");

                // Parse search terms if provided
                string[] searchWords = !string.IsNullOrWhiteSpace(searchTerm) ?
                    searchTerm.ToLower().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries) : null;

                // Process each log entry
                for (int i = 0; i < count; i++)
                {
                    try
                    {
                        // Get log entry at index i
                        var methodParams = getEntryMethod.GetParameters();
                        if (methodParams.Length == 2 && methodParams[1].ParameterType == logEntryType)
                        {
                            getEntryMethod.Invoke(null, new object[] { i, logEntryInstance });
                        }
                        else if (methodParams.Length >= 1 && methodParams[0].ParameterType == typeof(int))
                        {
                            var parameters = new object[methodParams.Length];
                            parameters[0] = i;
                            for (int p = 1; p < parameters.Length; p++)
                            {
                                parameters[p] = methodParams[p].ParameterType.IsValueType ?
                                    Activator.CreateInstance(methodParams[p].ParameterType) : null;
                            }
                            getEntryMethod.Invoke(null, parameters);
                        }
                        else continue;

                        // Extract log data
                        int logType = modeProperty != null ?
                            Convert.ToInt32(modeProperty.GetValue(logEntryInstance) ?? 0) : 0;

                        string message = messageProperty != null ?
                            (messageProperty.GetValue(logEntryInstance)?.ToString() ?? "") : "";

                        // If message is empty, try to get it via a field
                        if (string.IsNullOrEmpty(message))
                        {
                            var msgField = logEntryType.GetField("message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                            if (msgField != null)
                            {
                                object msgValue = msgField.GetValue(logEntryInstance);
                                message = msgValue != null ? msgValue.ToString() : "";
                            }

                            // If still empty, try alternate approach with Console window
                            if (string.IsNullOrEmpty(message))
                            {
                                // Access ConsoleWindow and its data
                                Type consoleWindowType = Type.GetType("UnityEditor.ConsoleWindow,UnityEditor");
                                if (consoleWindowType != null)
                                {
                                    try
                                    {
                                        // Get Console window instance
                                        var getWindowMethod = consoleWindowType.GetMethod("GetWindow",
                                            BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic,
                                            null, new[] { typeof(bool) }, null) ??
                                            consoleWindowType.GetMethod("GetConsoleWindow",
                                            BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

                                        if (getWindowMethod != null)
                                        {
                                            object consoleWindow = getWindowMethod.Invoke(null,
                                                getWindowMethod.GetParameters().Length > 0 ? new object[] { false } : null);

                                            if (consoleWindow != null)
                                            {
                                                // Try to find log entries collection
                                                foreach (var prop in consoleWindowType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
                                                {
                                                    if (prop.PropertyType.IsArray ||
                                                       (prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(List<>)))
                                                    {
                                                        try
                                                        {
                                                            var logItems = prop.GetValue(consoleWindow);
                                                            if (logItems != null)
                                                            {
                                                                if (logItems.GetType().IsArray && i < ((Array)logItems).Length)
                                                                {
                                                                    var entry = ((Array)logItems).GetValue(i);
                                                                    if (entry != null)
                                                                    {
                                                                        var entryType = entry.GetType();
                                                                        var entryMessageProp = entryType.GetProperty("message") ??
                                                                                             entryType.GetProperty("Message");
                                                                        if (entryMessageProp != null)
                                                                        {
                                                                            object value = entryMessageProp.GetValue(entry);
                                                                            if (value != null)
                                                                            {
                                                                                message = value.ToString();
                                                                                break;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        catch
                                                        {
                                                            // Ignore errors in this fallback approach
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    catch
                                    {
                                        // Ignore errors in this fallback approach
                                    }
                                }
                            }

                            // If still empty, try one more approach with log files
                            if (string.IsNullOrEmpty(message))
                            {
                                // This is our last resort - try to get log messages from the most recent Unity log file
                                try
                                {
                                    string logPath = string.Empty;

                                    // Determine the log file path based on the platform
                                    if (Application.platform == RuntimePlatform.WindowsEditor)
                                    {
                                        logPath = System.IO.Path.Combine(
                                            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
                                            "Unity", "Editor", "Editor.log");
                                    }
                                    else if (Application.platform == RuntimePlatform.OSXEditor)
                                    {
                                        logPath = System.IO.Path.Combine(
                                            Environment.GetFolderPath(Environment.SpecialFolder.Personal),
                                            "Library", "Logs", "Unity", "Editor.log");
                                    }
                                    else if (Application.platform == RuntimePlatform.LinuxEditor)
                                    {
                                        logPath = System.IO.Path.Combine(
                                            Environment.GetFolderPath(Environment.SpecialFolder.Personal),
                                            ".config", "unity3d", "logs", "Editor.log");
                                    }

                                    if (!string.IsNullOrEmpty(logPath) && System.IO.File.Exists(logPath))
                                    {
                                        // Read last few lines from the log file
                                        var logLines = ReadLastLines(logPath, 100);
                                        if (logLines.Count > i)
                                        {
                                            message = logLines[logLines.Count - 1 - i];
                                        }
                                    }
                                }
                                catch
                                {
                                    // Ignore errors in this fallback approach
                                }
                            }
                        }

                        // Get stack trace if method available
                        string stackTrace = "";
                        if (getStackTraceMethod != null)
                        {
                            stackTrace = getStackTraceMethod.Invoke(null, new object[] { i })?.ToString() ?? "";
                        }

                        // Filter by type
                        bool typeMatch = (logType == 0 && showLogs) ||
                                        (logType == 1 && showWarnings) ||
                                        (logType == 2 && showErrors);
                        if (!typeMatch) continue;

                        // Filter by search term
                        bool searchMatch = true;
                        if (searchWords != null && searchWords.Length > 0)
                        {
                            string lowerMessage = message.ToLower();
                            string lowerStackTrace = stackTrace.ToLower();

                            foreach (string word in searchWords)
                            {
                                if (!lowerMessage.Contains(word) && !lowerStackTrace.Contains(word))
                                {
                                    searchMatch = false;
                                    break;
                                }
                            }
                        }
                        if (!searchMatch) continue;

                        // Add matching entry to results
                        string typeStr = logType == 0 ? "Log" : logType == 1 ? "Warning" : "Error";
                        entries.Add(new
                        {
                            type = typeStr,
                            message,
                            stackTrace
                        });
                    }
                    catch (Exception)
                    {
                        // Skip entries that cause errors
                        continue;
                    }
                }

                // Return filtered results
                return new
                {
                    message = "Console logs retrieved successfully",
                    entries,
                    total_entries = count,
                    filtered_count = entries.Count,
                    show_logs = showLogs,
                    show_warnings = showWarnings,
                    show_errors = showErrors
                };
            }
            catch (Exception e)
            {
                return new
                {
                    error = $"Failed to read console logs: {e.Message}",
                    entries = new List<object>()
                };
            }
        }

        private static MethodInfo FindMethod(Type type, string[] methodNames)
        {
            foreach (var methodName in methodNames)
            {
                var method = type.GetMethod(methodName,
                    BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                if (method != null)
                    return method;
            }
            return null;
        }

        private static BuildTarget GetBuildTarget(string platform)
        {
            BuildTarget target;
            switch (platform.ToLower())
            {
                case "windows": target = BuildTarget.StandaloneWindows64; break;
                case "mac": target = BuildTarget.StandaloneOSX; break;
                case "linux": target = BuildTarget.StandaloneLinux64; break;
                case "android": target = BuildTarget.Android; break;
                case "ios": target = BuildTarget.iOS; break;
                case "webgl": target = BuildTarget.WebGL; break;
                default: target = (BuildTarget)(-1); break; // Invalid target
            }
            return target;
        }

        private static string[] GetEnabledScenes()
        {
            var scenes = new List<string>();
            for (int i = 0; i < EditorBuildSettings.scenes.Length; i++)
            {
                if (EditorBuildSettings.scenes[i].enabled)
                {
                    scenes.Add(EditorBuildSettings.scenes[i].path);
                }
            }
            return scenes.ToArray();
        }

        /// <summary>
        /// Helper method to get information about available properties and fields in a type
        /// </summary>
        private static Dictionary<string, object> GetTypeInfo(Type type)
        {
            var result = new Dictionary<string, object>();

            // Get all public and non-public properties
            var properties = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic |
                                               BindingFlags.Static | BindingFlags.Instance);
            var propList = new List<string>();
            foreach (var prop in properties)
            {
                propList.Add($"{prop.PropertyType.Name} {prop.Name}");
            }
            result["Properties"] = propList;

            // Get all public and non-public fields
            var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic |
                                       BindingFlags.Static | BindingFlags.Instance);
            var fieldList = new List<string>();
            foreach (var field in fields)
            {
                fieldList.Add($"{field.FieldType.Name} {field.Name}");
            }
            result["Fields"] = fieldList;

            // Get all public and non-public methods
            var methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic |
                                         BindingFlags.Static | BindingFlags.Instance);
            var methodList = new List<string>();
            foreach (var method in methods)
            {
                if (!method.Name.StartsWith("get_") && !method.Name.StartsWith("set_"))
                {
                    var parameters = string.Join(", ", method.GetParameters()
                        .Select(p => $"{p.ParameterType.Name} {p.Name}"));
                    methodList.Add($"{method.ReturnType.Name} {method.Name}({parameters})");
                }
            }
            result["Methods"] = methodList;

            return result;
        }

        /// <summary>
        /// Helper method to get all property and field values from an object
        /// </summary>
        private static Dictionary<string, string> GetObjectValues(object obj)
        {
            if (obj == null) return new Dictionary<string, string>();

            var result = new Dictionary<string, string>();
            var type = obj.GetType();

            // Get all property values
            var properties = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (var prop in properties)
            {
                try
                {
                    var value = prop.GetValue(obj);
                    result[$"Property:{prop.Name}"] = value?.ToString() ?? "null";
                }
                catch (Exception)
                {
                    result[$"Property:{prop.Name}"] = "ERROR";
                }
            }

            // Get all field values
            var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (var field in fields)
            {
                try
                {
                    var value = field.GetValue(obj);
                    result[$"Field:{field.Name}"] = value?.ToString() ?? "null";
                }
                catch (Exception)
                {
                    result[$"Field:{field.Name}"] = "ERROR";
                }
            }

            return result;
        }

        /// <summary>
        /// Reads the last N lines from a file
        /// </summary>
        private static List<string> ReadLastLines(string filePath, int lineCount)
        {
            var result = new List<string>();

            using (var stream = new System.IO.FileStream(filePath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite))
            using (var reader = new System.IO.StreamReader(stream))
            {
                string line;
                var circularBuffer = new List<string>(lineCount);
                int currentIndex = 0;

                // Read all lines keeping only the last N in a circular buffer
                while ((line = reader.ReadLine()) != null)
                {
                    if (circularBuffer.Count < lineCount)
                    {
                        circularBuffer.Add(line);
                    }
                    else
                    {
                        circularBuffer[currentIndex] = line;
                        currentIndex = (currentIndex + 1) % lineCount;
                    }
                }

                // Reorder the circular buffer so that lines are returned in order
                if (circularBuffer.Count == lineCount)
                {
                    for (int i = 0; i < lineCount; i++)
                    {
                        result.Add(circularBuffer[(currentIndex + i) % lineCount]);
                    }
                }
                else
                {
                    result.AddRange(circularBuffer);
                }
            }

            return result;
        }

        /// <summary>
        /// Gets a comprehensive list of available Unity commands, including editor menu items,
        /// internal commands, utility methods, and other actionable operations that can be executed.
        /// </summary>
        /// <returns>Object containing categorized lists of available command paths</returns>
        private static object GetAvailableCommands()
        {
            var menuCommands = new HashSet<string>();
            var utilityCommands = new HashSet<string>();
            var assetCommands = new HashSet<string>();
            var sceneCommands = new HashSet<string>();
            var gameObjectCommands = new HashSet<string>();
            var prefabCommands = new HashSet<string>();
            var shortcutCommands = new HashSet<string>();
            var otherCommands = new HashSet<string>();

            // Add a simple command that we know will work for testing
            menuCommands.Add("Window/Unity MCP");

            Debug.Log("Starting command collection...");

            try
            {
                // Add all EditorApplication static methods - these are guaranteed to work
                Debug.Log("Adding EditorApplication methods...");
                foreach (MethodInfo method in typeof(EditorApplication).GetMethods(BindingFlags.Public | BindingFlags.Static))
                {
                    utilityCommands.Add($"EditorApplication.{method.Name}");
                }
                Debug.Log($"Added {utilityCommands.Count} EditorApplication methods");

                // Add built-in menu commands directly - these are common ones that should always be available
                Debug.Log("Adding built-in menu commands...");
                string[] builtInMenus = new[] {
                    "File/New Scene",
                    "File/Open Scene",
                    "File/Save",
                    "File/Save As...",
                    "Edit/Undo",
                    "Edit/Redo",
                    "Edit/Cut",
                    "Edit/Copy",
                    "Edit/Paste",
                    "Edit/Duplicate",
                    "Edit/Delete",
                    "GameObject/Create Empty",
                    "GameObject/3D Object/Cube",
                    "GameObject/3D Object/Sphere",
                    "GameObject/3D Object/Capsule",
                    "GameObject/3D Object/Cylinder",
                    "GameObject/3D Object/Plane",
                    "GameObject/Light/Directional Light",
                    "GameObject/Light/Point Light",
                    "GameObject/Light/Spotlight",
                    "GameObject/Light/Area Light",
                    "Component/Mesh/Mesh Filter",
                    "Component/Mesh/Mesh Renderer",
                    "Component/Physics/Rigidbody",
                    "Component/Physics/Box Collider",
                    "Component/Physics/Sphere Collider",
                    "Component/Physics/Capsule Collider",
                    "Component/Audio/Audio Source",
                    "Component/Audio/Audio Listener",
                    "Window/General/Scene",
                    "Window/General/Game",
                    "Window/General/Inspector",
                    "Window/General/Hierarchy",
                    "Window/General/Project",
                    "Window/General/Console",
                    "Window/Analysis/Profiler",
                    "Window/Package Manager",
                    "Assets/Create/Material",
                    "Assets/Create/C# Script",
                    "Assets/Create/Prefab",
                    "Assets/Create/Scene",
                    "Assets/Create/Folder",
                };

                foreach (string menuItem in builtInMenus)
                {
                    menuCommands.Add(menuItem);
                }
                Debug.Log($"Added {builtInMenus.Length} built-in menu commands");

                // Get menu commands from MenuItem attributes - wrapped in separate try block
                Debug.Log("Searching for MenuItem attributes...");
                try
                {
                    int itemCount = 0;
                    foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
                    {
                        if (assembly.IsDynamic) continue;

                        try
                        {
                            foreach (Type type in assembly.GetExportedTypes())
                            {
                                try
                                {
                                    foreach (MethodInfo method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
                                    {
                                        try
                                        {
                                            object[] attributes = method.GetCustomAttributes(typeof(UnityEditor.MenuItem), false);
                                            if (attributes != null && attributes.Length > 0)
                                            {
                                                foreach (var attr in attributes)
                                                {
                                                    var menuItem = attr as UnityEditor.MenuItem;
                                                    if (menuItem != null && !string.IsNullOrEmpty(menuItem.menuItem))
                                                    {
                                                        menuCommands.Add(menuItem.menuItem);
                                                        itemCount++;
                                                    }
                                                }
                                            }
                                        }
                                        catch (Exception methodEx)
                                        {
                                            Debug.LogWarning($"Error getting menu items for method {method.Name}: {methodEx.Message}");
                                            continue;
                                        }
                                    }
                                }
                                catch (Exception typeEx)
                                {
                                    Debug.LogWarning($"Error processing type: {typeEx.Message}");
                                    continue;
                                }
                            }
                        }
                        catch (Exception assemblyEx)
                        {
                            Debug.LogWarning($"Error examining assembly {assembly.GetName().Name}: {assemblyEx.Message}");
                            continue;
                        }
                    }
                    Debug.Log($"Found {itemCount} menu items from attributes");
                }
                catch (Exception menuItemEx)
                {
                    Debug.LogError($"Failed to get menu items: {menuItemEx.Message}");
                }

                // Add EditorUtility methods as commands
                Debug.Log("Adding EditorUtility methods...");
                foreach (MethodInfo method in typeof(EditorUtility).GetMethods(BindingFlags.Public | BindingFlags.Static))
                {
                    utilityCommands.Add($"EditorUtility.{method.Name}");
                }
                Debug.Log($"Added {typeof(EditorUtility).GetMethods(BindingFlags.Public | BindingFlags.Static).Length} EditorUtility methods");

                // Add AssetDatabase methods as commands
                Debug.Log("Adding AssetDatabase methods...");
                foreach (MethodInfo method in typeof(AssetDatabase).GetMethods(BindingFlags.Public | BindingFlags.Static))
                {
                    assetCommands.Add($"AssetDatabase.{method.Name}");
                }
                Debug.Log($"Added {typeof(AssetDatabase).GetMethods(BindingFlags.Public | BindingFlags.Static).Length} AssetDatabase methods");

                // Add EditorSceneManager methods as commands
                Debug.Log("Adding EditorSceneManager methods...");
                Type sceneManagerType = typeof(UnityEditor.SceneManagement.EditorSceneManager);
                if (sceneManagerType != null)
                {
                    foreach (MethodInfo method in sceneManagerType.GetMethods(BindingFlags.Public | BindingFlags.Static))
                    {
                        sceneCommands.Add($"EditorSceneManager.{method.Name}");
                    }
                    Debug.Log($"Added {sceneManagerType.GetMethods(BindingFlags.Public | BindingFlags.Static).Length} EditorSceneManager methods");
                }

                // Add GameObject manipulation commands
                Debug.Log("Adding GameObject methods...");
                foreach (MethodInfo method in typeof(GameObject).GetMethods(BindingFlags.Public | BindingFlags.Static))
                {
                    gameObjectCommands.Add($"GameObject.{method.Name}");
                }
                Debug.Log($"Added {typeof(GameObject).GetMethods(BindingFlags.Public | BindingFlags.Static).Length} GameObject methods");

                // Add Selection-related commands
                Debug.Log("Adding Selection methods...");
                foreach (MethodInfo method in typeof(Selection).GetMethods(BindingFlags.Public | BindingFlags.Static))
                {
                    gameObjectCommands.Add($"Selection.{method.Name}");
                }
                Debug.Log($"Added {typeof(Selection).GetMethods(BindingFlags.Public | BindingFlags.Static).Length} Selection methods");

                // Add PrefabUtility methods as commands
                Debug.Log("Adding PrefabUtility methods...");
                Type prefabUtilityType = typeof(UnityEditor.PrefabUtility);
                if (prefabUtilityType != null)
                {
                    foreach (MethodInfo method in prefabUtilityType.GetMethods(BindingFlags.Public | BindingFlags.Static))
                    {
                        prefabCommands.Add($"PrefabUtility.{method.Name}");
                    }
                    Debug.Log($"Added {prefabUtilityType.GetMethods(BindingFlags.Public | BindingFlags.Static).Length} PrefabUtility methods");
                }

                // Add Undo related methods
                Debug.Log("Adding Undo methods...");
                foreach (MethodInfo method in typeof(Undo).GetMethods(BindingFlags.Public | BindingFlags.Static))
                {
                    utilityCommands.Add($"Undo.{method.Name}");
                }
                Debug.Log($"Added {typeof(Undo).GetMethods(BindingFlags.Public | BindingFlags.Static).Length} Undo methods");

                // The rest of the command gathering can be attempted but might not be critical
                try
                {
                    // Get commands from Unity's internal command system
                    Debug.Log("Trying to get internal CommandService commands...");
                    Type commandServiceType = typeof(UnityEditor.EditorWindow).Assembly.GetType("UnityEditor.CommandService");
                    if (commandServiceType != null)
                    {
                        Debug.Log("Found CommandService type");
                        PropertyInfo instanceProperty = commandServiceType.GetProperty("Instance",
                            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);

                        if (instanceProperty != null)
                        {
                            Debug.Log("Found Instance property");
                            object commandService = instanceProperty.GetValue(null);
                            if (commandService != null)
                            {
                                Debug.Log("Got CommandService instance");
                                MethodInfo findAllCommandsMethod = commandServiceType.GetMethod("FindAllCommands",
                                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

                                if (findAllCommandsMethod != null)
                                {
                                    Debug.Log("Found FindAllCommands method");
                                    var commandsResult = findAllCommandsMethod.Invoke(commandService, null);
                                    if (commandsResult != null)
                                    {
                                        Debug.Log("Got commands result");
                                        var commandsList = commandsResult as System.Collections.IEnumerable;
                                        if (commandsList != null)
                                        {
                                            int commandCount = 0;
                                            foreach (var cmd in commandsList)
                                            {
                                                try
                                                {
                                                    PropertyInfo nameProperty = cmd.GetType().GetProperty("name") ??
                                                                             cmd.GetType().GetProperty("path") ??
                                                                             cmd.GetType().GetProperty("commandName");
                                                    if (nameProperty != null)
                                                    {
                                                        string commandName = nameProperty.GetValue(cmd)?.ToString();
                                                        if (!string.IsNullOrEmpty(commandName))
                                                        {
                                                            otherCommands.Add(commandName);
                                                            commandCount++;
                                                        }
                                                    }
                                                }
                                                catch (Exception cmdEx)
                                                {
                                                    Debug.LogWarning($"Error processing command: {cmdEx.Message}");
                                                    continue;
                                                }
                                            }
                                            Debug.Log($"Added {commandCount} internal commands");
                                        }
                                    }
                                    else
                                    {
                                        Debug.LogWarning("FindAllCommands returned null");
                                    }
                                }
                                else
                                {
                                    Debug.LogWarning("FindAllCommands method not found");
                                }
                            }
                            else
                            {
                                Debug.LogWarning("CommandService instance is null");
                            }
                        }
                        else
                        {
                            Debug.LogWarning("Instance property not found on CommandService");
                        }
                    }
                    else
                    {
                        Debug.LogWarning("CommandService type not found");
                    }
                }
                catch (Exception e)
                {
                    Debug.LogWarning($"Failed to get internal Unity commands: {e.Message}");
                }

                // Other additional command sources can be tried
                // ... other commands ...
            }
            catch (Exception e)
            {
                Debug.LogError($"Error getting Unity commands: {e.Message}\n{e.StackTrace}");
            }

            // Create command categories dictionary for the result
            var commandCategories = new Dictionary<string, List<string>>
            {
                { "MenuCommands", menuCommands.OrderBy(x => x).ToList() },
                { "UtilityCommands", utilityCommands.OrderBy(x => x).ToList() },
                { "AssetCommands", assetCommands.OrderBy(x => x).ToList() },
                { "SceneCommands", sceneCommands.OrderBy(x => x).ToList() },
                { "GameObjectCommands", gameObjectCommands.OrderBy(x => x).ToList() },
                { "PrefabCommands", prefabCommands.OrderBy(x => x).ToList() },
                { "ShortcutCommands", shortcutCommands.OrderBy(x => x).ToList() },
                { "OtherCommands", otherCommands.OrderBy(x => x).ToList() }
            };

            // Calculate total command count
            int totalCount = commandCategories.Values.Sum(list => list.Count);

            Debug.Log($"Command retrieval complete. Found {totalCount} total commands.");

            // Create a simplified response with just the essential data
            // The complex object structure might be causing serialization issues
            var allCommandsList = commandCategories.Values.SelectMany(x => x).OrderBy(x => x).ToList();

            // Use simple string array instead of JArray for better serialization
            string[] commandsArray = allCommandsList.ToArray();

            // Log the array size for verification
            Debug.Log($"Final commands array contains {commandsArray.Length} items");

            try
            {
                // Return a simple object with just the commands array and count
                var result = new
                {
                    commands = commandsArray,
                    count = commandsArray.Length
                };

                // Verify the result can be serialized properly
                var jsonTest = JsonUtility.ToJson(new { test = "This is a test" });
                Debug.Log($"JSON serialization test successful: {jsonTest}");

                return result;
            }
            catch (Exception ex)
            {
                Debug.LogError($"Error creating response: {ex.Message}");

                // Ultimate fallback - don't use any JObject/JArray
                return new
                {
                    message = $"Found {commandsArray.Length} commands",
                    firstTen = commandsArray.Take(10).ToArray(),
                    count = commandsArray.Length
                };
            }
        }
    }
}