Merge branch 'CoplayDev:main' into main

Author: dsarno

.gitignore

@@ -39,3 +39,5 @@ TestProjects/UnityMCPTests/Packages/packages-lock.json
 # Backup artifacts
 *.backup
 *.backup.meta
+
+.wt-origin-main/

MCPForUnity/Editor/Dependencies/PlatformDetectors.meta

@@ -2,10 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
 using MCPForUnity.External.Tommy;
-using Newtonsoft.Json;
 
 namespace MCPForUnity.Editor.Helpers
 {
@@ -42,108 +39,107 @@ public static bool IsCodexConfigured(string pythonDir)
 
         public static string BuildCodexServerBlock(string uvPath, string serverSrc)
         {
-            string argsArray = FormatTomlStringArray(new[] { "run", "--directory", serverSrc, "server.py" });
-            return $"[mcp_servers.unityMCP]{Environment.NewLine}" +
-                   $"command = \"{EscapeTomlString(uvPath)}\"{Environment.NewLine}" +
-                   $"args = {argsArray}";
+            var table = new TomlTable();
+            var mcpServers = new TomlTable();
+
+            mcpServers["unityMCP"] = CreateUnityMcpTable(uvPath, serverSrc);
+            table["mcp_servers"] = mcpServers;
+
+            using var writer = new StringWriter();
+            table.WriteTo(writer);
+            return writer.ToString();
         }
 
-        public static string UpsertCodexServerBlock(string existingToml, string newBlock)
+        public static string UpsertCodexServerBlock(string existingToml, string uvPath, string serverSrc)
         {
-            if (string.IsNullOrWhiteSpace(existingToml))
+            // Parse existing TOML or create new root table
+            var root = TryParseToml(existingToml) ?? new TomlTable();
+
+            // Ensure mcp_servers table exists
+            if (!root.TryGetNode("mcp_servers", out var mcpServersNode) || !(mcpServersNode is TomlTable))
             {
-                return newBlock.TrimEnd() + Environment.NewLine;
+                root["mcp_servers"] = new TomlTable();
             }
+            var mcpServers = root["mcp_servers"] as TomlTable;
 
-            StringBuilder sb = new StringBuilder();
-            using StringReader reader = new StringReader(existingToml);
-            string line;
-            bool inTarget = false;
-            bool replaced = false;
-            while ((line = reader.ReadLine()) != null)
-            {
-                string trimmed = line.Trim();
-                bool isSection = trimmed.StartsWith("[") && trimmed.EndsWith("]") && !trimmed.StartsWith("[[");
-                if (isSection)
-                {
-                    bool isTarget = string.Equals(trimmed, "[mcp_servers.unityMCP]", StringComparison.OrdinalIgnoreCase);
-                    if (isTarget)
-                    {
-                        if (!replaced)
-                        {
-                            if (sb.Length > 0 && sb[^1] != '\n') sb.AppendLine();
-                            sb.AppendLine(newBlock.TrimEnd());
-                            replaced = true;
-                        }
-                        inTarget = true;
-                        continue;
-                    }
+            // Create or update unityMCP table
+            mcpServers["unityMCP"] = CreateUnityMcpTable(uvPath, serverSrc);
 
-                    if (inTarget)
-                    {
-                        inTarget = false;
-                    }
-                }
+            // Serialize back to TOML
+            using var writer = new StringWriter();
+            root.WriteTo(writer);
+            return writer.ToString();
+        }
 
-                if (inTarget)
-                {
-                    continue;
-                }
+        public static bool TryParseCodexServer(string toml, out string command, out string[] args)
+        {
+            command = null;
+            args = null;
 
-                sb.AppendLine(line);
+            var root = TryParseToml(toml);
+            if (root == null) return false;
+
+            if (!TryGetTable(root, "mcp_servers", out var servers)
+                && !TryGetTable(root, "mcpServers", out servers))
+            {
+                return false;
             }
 
-            if (!replaced)
+            if (!TryGetTable(servers, "unityMCP", out var unity))
             {
-                if (sb.Length > 0 && sb[^1] != '\n') sb.AppendLine();
-                sb.AppendLine(newBlock.TrimEnd());
+                return false;
             }
 
-            return sb.ToString().TrimEnd() + Environment.NewLine;
+            command = GetTomlString(unity, "command");
+            args = GetTomlStringArray(unity, "args");
+
+            return !string.IsNullOrEmpty(command) && args != null;
         }
 
-        public static bool TryParseCodexServer(string toml, out string command, out string[] args)
+        /// <summary>
+        /// Safely parses TOML string, returning null on failure
+        /// </summary>
+        private static TomlTable TryParseToml(string toml)
         {
-            command = null;
-            args = null;
-            if (string.IsNullOrWhiteSpace(toml)) return false;
+            if (string.IsNullOrWhiteSpace(toml)) return null;
 
             try
             {
                 using var reader = new StringReader(toml);
-                TomlTable root = TOML.Parse(reader);
-                if (root == null) return false;
-
-                if (!TryGetTable(root, "mcp_servers", out var servers)
-                    && !TryGetTable(root, "mcpServers", out servers))
-                {
-                    return false;
-                }
-
-                if (!TryGetTable(servers, "unityMCP", out var unity))
-                {
-                    return false;
-                }
-
-                command = GetTomlString(unity, "command");
-                args = GetTomlStringArray(unity, "args");
-
-                return !string.IsNullOrEmpty(command) && args != null;
+                return TOML.Parse(reader);
             }
             catch (TomlParseException)
             {
-                return false;
+                return null;
             }
             catch (TomlSyntaxException)
             {
-                return false;
+                return null;
             }
             catch (FormatException)
             {
-                return false;
+                return null;
             }
         }
 
+        /// <summary>
+        /// Creates a TomlTable for the unityMCP server configuration
+        /// </summary>
+        private static TomlTable CreateUnityMcpTable(string uvPath, string serverSrc)
+        {
+            var unityMCP = new TomlTable();
+            unityMCP["command"] = new TomlString { Value = uvPath };
+
+            var argsArray = new TomlArray();
+            argsArray.Add(new TomlString { Value = "run" });
+            argsArray.Add(new TomlString { Value = "--directory" });
+            argsArray.Add(new TomlString { Value = serverSrc });
+            argsArray.Add(new TomlString { Value = "server.py" });
+            unityMCP["args"] = argsArray;
+
+            return unityMCP;
+        }
+
         private static bool TryGetTable(TomlTable parent, string key, out TomlTable table)
         {
             table = null;
@@ -211,33 +207,5 @@ private static string[] GetTomlStringArray(TomlTable table, string key)
 
             return null;
         }
-
-        private static string FormatTomlStringArray(IEnumerable<string> values)
-        {
-            if (values == null) return "[]";
-            StringBuilder sb = new StringBuilder();
-            sb.Append('[');
-            bool first = true;
-            foreach (string value in values)
-            {
-                if (!first)
-                {
-                    sb.Append(", ");
-                }
-                sb.Append('"').Append(EscapeTomlString(value ?? string.Empty)).Append('"');
-                first = false;
-            }
-            sb.Append(']');
-            return sb.ToString();
-        }
-
-        private static string EscapeTomlString(string value)
-        {
-            if (string.IsNullOrEmpty(value)) return string.Empty;
-            return value
-                .Replace("\\", "\\\\")
-                .Replace("\"", "\\\"");
-        }
-
     }
 }

MCPForUnity/Editor/Helpers/CodexConfigHelper.cs

@@ -255,24 +255,25 @@ public static object GetComponentData(Component c, bool includeNonPublicSerializ
                     var declaredFields = currentType.GetFields(fieldFlags);
 
                     // Process the declared Fields for caching
-                    foreach (var fieldInfo in declaredFields)
+                foreach (var fieldInfo in declaredFields)
                     {
                         if (fieldInfo.Name.EndsWith("k__BackingField")) continue; // Skip backing fields
 
                         // Add if not already added (handles hiding - keep the most derived version)
                         if (fieldsToCache.Any(f => f.Name == fieldInfo.Name)) continue;
 
-                        bool shouldInclude = false;
-                        if (includeNonPublicSerializedFields)
-                        {
-                            // If TRUE, include Public OR NonPublic with [SerializeField]
-                            shouldInclude = fieldInfo.IsPublic || (fieldInfo.IsPrivate && fieldInfo.IsDefined(typeof(SerializeField), inherit: false));
-                        }
-                        else // includeNonPublicSerializedFields is FALSE
-                        {
-                            // If FALSE, include ONLY if it is explicitly Public.
-                            shouldInclude = fieldInfo.IsPublic;
-                        }
+                    bool shouldInclude = false;
+                    if (includeNonPublicSerializedFields)
+                    {
+                        // If TRUE, include Public OR any NonPublic with [SerializeField] (private/protected/internal)
+                        var hasSerializeField = fieldInfo.IsDefined(typeof(SerializeField), inherit: true);
+                        shouldInclude = fieldInfo.IsPublic || (!fieldInfo.IsPublic && hasSerializeField);
+                    }
+                    else // includeNonPublicSerializedFields is FALSE
+                    {
+                        // If FALSE, include ONLY if it is explicitly Public.
+                        shouldInclude = fieldInfo.IsPublic;
+                    }
 
                         if (shouldInclude)
                         {
@@ -357,7 +358,35 @@ public static object GetComponentData(Component c, bool includeNonPublicSerializ
                     // --- Add detailed logging --- 
                     // Debug.Log($"[GetComponentData] Accessing: {componentType.Name}.{propName}");
                     // --- End detailed logging ---
-                    object value = propInfo.GetValue(c);
+                    
+                    // --- Special handling for material/mesh properties in edit mode ---
+                    object value;
+                    if (!Application.isPlaying && (propName == "material" || propName == "materials" || propName == "mesh"))
+                    {
+                        // In edit mode, use sharedMaterial/sharedMesh to avoid instantiation warnings
+                        if ((propName == "material" || propName == "materials") && c is Renderer renderer)
+                        {
+                            if (propName == "material")
+                                value = renderer.sharedMaterial;
+                            else // materials
+                                value = renderer.sharedMaterials;
+                        }
+                        else if (propName == "mesh" && c is MeshFilter meshFilter)
+                        {
+                            value = meshFilter.sharedMesh;
+                        }
+                        else
+                        {
+                            // Fallback to normal property access if type doesn't match
+                            value = propInfo.GetValue(c);
+                        }
+                    }
+                    else
+                    {
+                        value = propInfo.GetValue(c);
+                    }
+                    // --- End special handling ---
+                    
                     Type propType = propInfo.PropertyType;
                     AddSerializableValue(serializablePropertiesOutput, propName, propType, value);
                 }

MCPForUnity/Editor/Helpers/GameObjectSerializer.cs

@@ -205,8 +205,7 @@ public static string ConfigureCodexClient(string pythonDir, string configPath, M
                 return "Configured successfully";
             }
 
-            string codexBlock = CodexConfigHelper.BuildCodexServerBlock(uvPath, serverSrc);
-            string updatedToml = CodexConfigHelper.UpsertCodexServerBlock(existingToml, codexBlock);
+            string updatedToml = CodexConfigHelper.UpsertCodexServerBlock(existingToml, uvPath, serverSrc);
 
             McpConfigFileHelper.WriteAtomicFile(configPath, updatedToml);
 

MCPForUnity/Editor/Helpers/McpConfigurationHelper.cs

@@ -0,0 +1,60 @@
+namespace MCPForUnity.Editor.Services
+{
+    /// <summary>
+    /// Service for checking package updates and version information
+    /// </summary>
+    public interface IPackageUpdateService
+    {
+        /// <summary>
+        /// Checks if a newer version of the package is available
+        /// </summary>
+        /// <param name="currentVersion">The current package version</param>
+        /// <returns>Update check result containing availability and latest version info</returns>
+        UpdateCheckResult CheckForUpdate(string currentVersion);
+        
+        /// <summary>
+        /// Compares two version strings to determine if the first is newer than the second
+        /// </summary>
+        /// <param name="version1">First version string</param>
+        /// <param name="version2">Second version string</param>
+        /// <returns>True if version1 is newer than version2</returns>
+        bool IsNewerVersion(string version1, string version2);
+        
+        /// <summary>
+        /// Determines if the package was installed via Git or Asset Store
+        /// </summary>
+        /// <returns>True if installed via Git, false if Asset Store or unknown</returns>
+        bool IsGitInstallation();
+        
+        /// <summary>
+        /// Clears the cached update check data, forcing a fresh check on next request
+        /// </summary>
+        void ClearCache();
+    }
+    
+    /// <summary>
+    /// Result of an update check operation
+    /// </summary>
+    public class UpdateCheckResult
+    {
+        /// <summary>
+        /// Whether an update is available
+        /// </summary>
+        public bool UpdateAvailable { get; set; }
+        
+        /// <summary>
+        /// The latest version available (null if check failed or no update)
+        /// </summary>
+        public string LatestVersion { get; set; }
+        
+        /// <summary>
+        /// Whether the check was successful (false if network error, etc.)
+        /// </summary>
+        public bool CheckSucceeded { get; set; }
+        
+        /// <summary>
+        /// Optional message about the check result
+        /// </summary>
+        public string Message { get; set; }
+    }
+}