feat: installer cleanup, auto-migration of legacy server location to canonical, server logging normalization

UnityMcpBridge/Editor/Data/McpClients.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.InteropServices;
 using MCPForUnity.Editor.Models;
 
 namespace MCPForUnity.Editor.Data
@@ -69,32 +70,54 @@ public class McpClients
                     "Claude",
                     "claude_desktop_config.json"
                 ),
-                linuxConfigPath = Path.Combine(
-                    Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
-                    ".config",
-                    "Claude",
-                    "claude_desktop_config.json"
-                ),
+                // For macOS, Claude Desktop stores config under ~/Library/Application Support/Claude
+                // For Linux, it remains under ~/.config/Claude
+                linuxConfigPath = RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+                    ? Path.Combine(
+                        Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                        "Library",
+                        "Application Support",
+                        "Claude",
+                        "claude_desktop_config.json"
+                    )
+                    : Path.Combine(
+                        Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                        ".config",
+                        "Claude",
+                        "claude_desktop_config.json"
+                    ),
                 mcpType = McpTypes.ClaudeDesktop,
                 configStatus = "Not Configured",
             },
             // 5) VSCode GitHub Copilot
             new()
             {
                 name = "VSCode GitHub Copilot",
+                // Windows path is canonical under %AppData%\Code\User
                 windowsConfigPath = Path.Combine(
                     Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                     "Code",
                     "User",
                     "mcp.json"
                 ),
-                linuxConfigPath = Path.Combine(
-                    Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
-                    ".config",
-                    "Code",
-                    "User",
-                    "mcp.json"
-                ),
+                // For macOS, VSCode stores user config under ~/Library/Application Support/Code/User
+                // For Linux, it remains under ~/.config/Code/User
+                linuxConfigPath = RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+                    ? Path.Combine(
+                        Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                        "Library",
+                        "Application Support",
+                        "Code",
+                        "User",
+                        "mcp.json"
+                    )
+                    : Path.Combine(
+                        Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                        ".config",
+                        "Code",
+                        "User",
+                        "mcp.json"
+                    ),
                 mcpType = McpTypes.VSCode,
                 configStatus = "Not Configured",
             },

UnityMcpBridge/Editor/Helpers/ConfigJsonBuilder.cs

@@ -50,7 +50,41 @@ public static JObject ApplyUnityServerToExistingConfig(JObject root, string uvPa
         private static void PopulateUnityNode(JObject unity, string uvPath, string directory, McpClient client, bool isVSCode)
         {
             unity["command"] = uvPath;
-            unity["args"] = JArray.FromObject(new[] { "run", "--directory", directory, "server.py" });
+
+            // For Cursor (non-VSCode) on macOS, prefer a no-spaces symlink path to avoid arg parsing issues in some runners
+            string effectiveDir = directory;
+#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
+            bool isCursor = !isVSCode && (client == null || client.mcpType != Models.McpTypes.VSCode);
+            if (isCursor && !string.IsNullOrEmpty(directory))
+            {
+                // Replace canonical path segment with the symlink path if present
+                const string canonical = "/Library/Application Support/";
+                const string symlinkSeg = "/Library/AppSupport/";
+                try
+                {
+                    // Normalize to full path style
+                    if (directory.Contains(canonical))
+                    {
+                        effectiveDir = directory.Replace(canonical, symlinkSeg);
+                    }
+                    else
+                    {
+                        // If installer returned XDG-style on macOS, map to canonical symlink
+                        string norm = directory.Replace('\\', '/');
+                        int idx = norm.IndexOf("/.local/share/UnityMCP/", System.StringComparison.Ordinal);
+                        if (idx >= 0)
+                        {
+                            string home = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal) ?? string.Empty;
+                            string suffix = norm.Substring(idx + "/.local/share/".Length); // UnityMCP/...
+                            effectiveDir = System.IO.Path.Combine(home, "Library", "AppSupport", suffix).Replace('\\', '/');
+                        }
+                    }
+                }
+                catch { /* fallback to original directory on any error */ }
+            }
+#endif
+
+            unity["args"] = JArray.FromObject(new[] { "run", "--directory", effectiveDir, "server.py" });
 
             if (isVSCode)
             {

UnityMcpBridge/Editor/Helpers/McpLog.cs

@@ -0,0 +1,33 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Helpers
+{
+    internal static class McpLog
+    {
+        private const string Prefix = "<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>:";
+
+        private static bool IsDebugEnabled()
+        {
+            try { return EditorPrefs.GetBool("MCPForUnity.DebugLogs", false); } catch { return false; }
+        }
+
+        public static void Info(string message, bool always = true)
+        {
+            if (!always && !IsDebugEnabled()) return;
+            Debug.Log($"{Prefix} {message}");
+        }
+
+        public static void Warn(string message)
+        {
+            Debug.LogWarning($"<color=#cc7a00>{Prefix} {message}</color>");
+        }
+
+        public static void Error(string message)
+        {
+            Debug.LogError($"<color=#cc3333>{Prefix} {message}</color>");
+        }
+    }
+}
+
+

UnityMcpBridge/Editor/Helpers/PackageDetector.cs

@@ -0,0 +1,96 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Helpers
+{
+    /// <summary>
+    /// Auto-runs legacy/older install detection on package load/update (log-only).
+    /// Runs once per embedded server version using an EditorPrefs version-scoped key.
+    /// </summary>
+    [InitializeOnLoad]
+    public static class PackageDetector
+    {
+        private const string DetectOnceFlagKeyPrefix = "MCPForUnity.LegacyDetectLogged:";
+
+        static PackageDetector()
+        {
+            try
+            {
+                string pkgVer = ReadPackageVersionOrFallback();
+                string key = DetectOnceFlagKeyPrefix + pkgVer;
+
+                // Always force-run if legacy roots exist or canonical install is missing
+                bool legacyPresent = LegacyRootsExist();
+                bool canonicalMissing = !System.IO.File.Exists(System.IO.Path.Combine(ServerInstaller.GetServerPath(), "server.py"));
+
+                if (!EditorPrefs.GetBool(key, false) || legacyPresent || canonicalMissing)
+                {
+                    EditorApplication.delayCall += () =>
+                    {
+                        try
+                        {
+                            ServerInstaller.EnsureServerInstalled();
+                        }
+                        catch (System.Exception ex)
+                        {
+                            Debug.LogWarning("MCP for Unity: Auto-detect on load failed: " + ex.Message);
+                        }
+                        finally
+                        {
+                            EditorPrefs.SetBool(key, true);
+                        }
+                    };
+                }
+            }
+            catch { /* ignore */ }
+        }
+
+        private static string ReadEmbeddedVersionOrFallback()
+        {
+            try
+            {
+                if (ServerPathResolver.TryFindEmbeddedServerSource(out var embeddedSrc))
+                {
+                    var p = System.IO.Path.Combine(embeddedSrc, "server_version.txt");
+                    if (System.IO.File.Exists(p))
+                        return (System.IO.File.ReadAllText(p)?.Trim() ?? "unknown");
+                }
+            }
+            catch { }
+            return "unknown";
+        }
+
+        private static string ReadPackageVersionOrFallback()
+        {
+            try
+            {
+                var info = UnityEditor.PackageManager.PackageInfo.FindForAssembly(typeof(PackageDetector).Assembly);
+                if (info != null && !string.IsNullOrEmpty(info.version)) return info.version;
+            }
+            catch { }
+            // Fallback to embedded server version if package info unavailable
+            return ReadEmbeddedVersionOrFallback();
+        }
+
+        private static bool LegacyRootsExist()
+        {
+            try
+            {
+                string home = System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile) ?? string.Empty;
+                string[] roots =
+                {
+                    System.IO.Path.Combine(home, ".config", "UnityMCP", "UnityMcpServer", "src"),
+                    System.IO.Path.Combine(home, ".local", "share", "UnityMCP", "UnityMcpServer", "src")
+                };
+                foreach (var r in roots)
+                {
+                    try { if (System.IO.File.Exists(System.IO.Path.Combine(r, "server.py"))) return true; } catch { }
+                }
+            }
+            catch { }
+            return false;
+        }
+    }
+}
+
+