Merge branch 'CoplayDev:main' into main

Author: dsarno

.github/workflows/python-tests.yml

@@ -0,0 +1,45 @@
+name: Python Tests
+
+on:
+  push:
+    branches: ["**"]
+    paths:
+      - MCPForUnity/UnityMcpServer~/src/**
+      - .github/workflows/python-tests.yml
+  workflow_dispatch: {}
+
+jobs:
+  test:
+    name: Run Python Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python
+        run: uv python install 3.10
+
+      - name: Install dependencies
+        run: |
+          cd MCPForUnity/UnityMcpServer~/src
+          uv sync
+          uv pip install -e ".[dev]"
+
+      - name: Run tests
+        run: |
+          cd MCPForUnity/UnityMcpServer~/src
+          uv run pytest tests/ -v --tb=short
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: pytest-results
+          path: |
+            MCPForUnity/UnityMcpServer~/src/.pytest_cache/
+            MCPForUnity/UnityMcpServer~/src/tests/

.github/workflows/unity-tests.yml

@@ -3,7 +3,7 @@ name: Unity Tests
 on:
   workflow_dispatch: {}
   push:
-    branches: [main]
+    branches: ["**"]
     paths:
       - TestProjects/UnityMCPTests/**
       - MCPForUnity/Editor/**

MCPForUnity/Editor/Helpers/PortManager.cs

@@ -60,14 +60,17 @@ public static int GetPortWithFallback()
                     if (IsDebugEnabled()) Debug.Log($"<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Stored port {storedConfig.unity_port} became available after short wait");
                     return storedConfig.unity_port;
                 }
-                // Prefer sticking to the same port; let the caller handle bind retries/fallbacks
-                return storedConfig.unity_port;
+                // Port is still busy after waiting - find a new available port instead
+                if (IsDebugEnabled()) Debug.Log($"<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Stored port {storedConfig.unity_port} is occupied by another instance, finding alternative...");
+                int newPort = FindAvailablePort();
+                SavePort(newPort);
+                return newPort;
             }
 
             // If no valid stored port, find a new one and save it
-            int newPort = FindAvailablePort();
-            SavePort(newPort);
-            return newPort;
+            int foundPort = FindAvailablePort();
+            SavePort(foundPort);
+            return foundPort;
         }
 
         /// <summary>

MCPForUnity/Editor/MCPForUnityBridge.cs

@@ -362,7 +362,24 @@ public static void Start()
                         }
                         catch (SocketException se) when (se.SocketErrorCode == SocketError.AddressAlreadyInUse && attempt >= maxImmediateRetries)
                         {
+                            // Port is occupied by another instance, get a new available port
+                            int oldPort = currentUnityPort;
                             currentUnityPort = PortManager.GetPortWithFallback();
+
+                            // GetPortWithFallback() may return the same port if it became available during wait
+                            // or a different port if switching to an alternative
+                            if (IsDebugEnabled())
+                            {
+                                if (currentUnityPort == oldPort)
+                                {
+                                    McpLog.Info($"Port {oldPort} became available, proceeding");
+                                }
+                                else
+                                {
+                                    McpLog.Info($"Port {oldPort} occupied, switching to port {currentUnityPort}");
+                                }
+                            }
+
                             listener = new TcpListener(IPAddress.Loopback, currentUnityPort);
                             listener.Server.SetSocketOption(
                                 SocketOptionLevel.Socket,
@@ -474,6 +491,22 @@ public static void Stop()
             try { AssemblyReloadEvents.afterAssemblyReload -= OnAfterAssemblyReload; } catch { }
             try { EditorApplication.quitting -= Stop; } catch { }
 
+            // Clean up status file when Unity stops
+            try
+            {
+                string statusDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".unity-mcp");
+                string statusFile = Path.Combine(statusDir, $"unity-mcp-status-{ComputeProjectHash(Application.dataPath)}.json");
+                if (File.Exists(statusFile))
+                {
+                    File.Delete(statusFile);
+                    if (IsDebugEnabled()) McpLog.Info($"Deleted status file: {statusFile}");
+                }
+            }
+            catch (Exception ex)
+            {
+                if (IsDebugEnabled()) McpLog.Warn($"Failed to delete status file: {ex.Message}");
+            }
+
             if (IsDebugEnabled()) McpLog.Info("MCPForUnityBridge stopped.");
         }
 
@@ -1184,13 +1217,38 @@ private static void WriteHeartbeat(bool reloading, string reason = null)
                 }
                 Directory.CreateDirectory(dir);
                 string filePath = Path.Combine(dir, $"unity-mcp-status-{ComputeProjectHash(Application.dataPath)}.json");
+
+                // Extract project name from path
+                string projectName = "Unknown";
+                try
+                {
+                    string projectPath = Application.dataPath;
+                    if (!string.IsNullOrEmpty(projectPath))
+                    {
+                        // Remove trailing /Assets or \Assets
+                        projectPath = projectPath.TrimEnd('/', '\\');
+                        if (projectPath.EndsWith("Assets", StringComparison.OrdinalIgnoreCase))
+                        {
+                            projectPath = projectPath.Substring(0, projectPath.Length - 6).TrimEnd('/', '\\');
+                        }
+                        projectName = Path.GetFileName(projectPath);
+                        if (string.IsNullOrEmpty(projectName))
+                        {
+                            projectName = "Unknown";
+                        }
+                    }
+                }
+                catch { }
+
                 var payload = new
                 {
                     unity_port = currentUnityPort,
                     reloading,
                     reason = reason ?? (reloading ? "reloading" : "ready"),
                     seq = heartbeatSeq,
                     project_path = Application.dataPath,
+                    project_name = projectName,
+                    unity_version = Application.unityVersion,
                     last_heartbeat = DateTime.UtcNow.ToString("O")
                 };
                 File.WriteAllText(filePath, JsonConvert.SerializeObject(payload), new System.Text.UTF8Encoding(false));

TestProjects/UnityMCPTests/Assets/Materials.meta renamed to MCPForUnity/Editor/Resources/Editor.meta

@@ -0,0 +1,64 @@
+using System;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides information about the currently active editor tool.
+    /// </summary>
+    [McpForUnityResource("get_active_tool")]
+    public static class ActiveTool
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                Tool currentTool = UnityEditor.Tools.current;
+                string toolName = currentTool.ToString();
+                bool customToolActive = UnityEditor.Tools.current == Tool.Custom;
+                string activeToolName = customToolActive ? EditorTools.GetActiveToolName() : toolName;
+
+                var toolInfo = new
+                {
+                    activeTool = activeToolName,
+                    isCustom = customToolActive,
+                    pivotMode = UnityEditor.Tools.pivotMode.ToString(),
+                    pivotRotation = UnityEditor.Tools.pivotRotation.ToString(),
+                    handleRotation = new
+                    {
+                        x = UnityEditor.Tools.handleRotation.eulerAngles.x,
+                        y = UnityEditor.Tools.handleRotation.eulerAngles.y,
+                        z = UnityEditor.Tools.handleRotation.eulerAngles.z
+                    },
+                    handlePosition = new
+                    {
+                        x = UnityEditor.Tools.handlePosition.x,
+                        y = UnityEditor.Tools.handlePosition.y,
+                        z = UnityEditor.Tools.handlePosition.z
+                    }
+                };
+
+                return Response.Success("Retrieved active tool information.", toolInfo);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting active tool: {e.Message}");
+            }
+        }
+    }
+
+    // Helper class for custom tool names
+    internal static class EditorTools
+    {
+        public static string GetActiveToolName()
+        {
+            if (UnityEditor.Tools.current == Tool.Custom)
+            {
+                return "Unknown Custom Tool";
+            }
+            return UnityEditor.Tools.current.ToString();
+        }
+    }
+}

MCPForUnity/Editor/Resources/Editor/ActiveTool.cs

@@ -0,0 +1,40 @@
+using System;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides dynamic editor state information that changes frequently.
+    /// </summary>
+    [McpForUnityResource("get_editor_state")]
+    public static class EditorState
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                var activeScene = EditorSceneManager.GetActiveScene();
+                var state = new
+                {
+                    isPlaying = EditorApplication.isPlaying,
+                    isPaused = EditorApplication.isPaused,
+                    isCompiling = EditorApplication.isCompiling,
+                    isUpdating = EditorApplication.isUpdating,
+                    timeSinceStartup = EditorApplication.timeSinceStartup,
+                    activeSceneName = activeScene.name ?? "",
+                    selectionCount = UnityEditor.Selection.count,
+                    activeObjectName = UnityEditor.Selection.activeObject?.name
+                };
+                
+                return Response.Success("Retrieved editor state.", state);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting editor state: {e.Message}");
+            }
+        }
+    }
+}

MCPForUnity/Editor/Resources/Editor/ActiveTool.cs.meta

@@ -0,0 +1,42 @@
+using System;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor.SceneManagement;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides information about the current prefab editing context.
+    /// </summary>
+    [McpForUnityResource("get_prefab_stage")]
+    public static class PrefabStage
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                var stage = PrefabStageUtility.GetCurrentPrefabStage();
+                
+                if (stage == null)
+                {
+                    return Response.Success("No prefab stage is currently open.", new { isOpen = false });
+                }
+
+                var stageInfo = new
+                {
+                    isOpen = true,
+                    assetPath = stage.assetPath,
+                    prefabRootName = stage.prefabContentsRoot?.name,
+                    mode = stage.mode.ToString(),
+                    isDirty = stage.scene.isDirty
+                };
+
+                return Response.Success("Prefab stage info retrieved.", stageInfo);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting prefab stage info: {e.Message}");
+            }
+        }
+    }
+}