Notify users when there's a new version (#329)

* feat: add package update service with version check and GitHub integration

* feat: add migration warning banner and dialog for legacy package users

* test: remove redundant cache expiration and clearing tests from PackageUpdateService

* test: add package update service tests for expired cache and asset store installations

Author: msanatan

MCPForUnity/Editor/Services/IPackageUpdateService.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; }
+    }
+}

MCPForUnity/Editor/Services/IPackageUpdateService.cs.meta

@@ -13,13 +13,15 @@ public static class MCPServiceLocator
         private static IPythonToolRegistryService _pythonToolRegistryService;
         private static ITestRunnerService _testRunnerService;
         private static IToolSyncService _toolSyncService;
+        private static IPackageUpdateService _packageUpdateService;
 
         public static IBridgeControlService Bridge => _bridgeService ??= new BridgeControlService();
         public static IClientConfigurationService Client => _clientService ??= new ClientConfigurationService();
         public static IPathResolverService Paths => _pathService ??= new PathResolverService();
         public static IPythonToolRegistryService PythonToolRegistry => _pythonToolRegistryService ??= new PythonToolRegistryService();
         public static ITestRunnerService Tests => _testRunnerService ??= new TestRunnerService();
         public static IToolSyncService ToolSync => _toolSyncService ??= new ToolSyncService();
+        public static IPackageUpdateService Updates => _packageUpdateService ??= new PackageUpdateService();
 
         /// <summary>
         /// Registers a custom implementation for a service (useful for testing)
@@ -40,6 +42,8 @@ public static void Register<T>(T implementation) where T : class
                 _testRunnerService = t;
             else if (implementation is IToolSyncService ts)
                 _toolSyncService = ts;
+            else if (implementation is IPackageUpdateService pu)
+                _packageUpdateService = pu;
         }
 
         /// <summary>
@@ -53,13 +57,15 @@ public static void Reset()
             (_pythonToolRegistryService as IDisposable)?.Dispose();
             (_testRunnerService as IDisposable)?.Dispose();
             (_toolSyncService as IDisposable)?.Dispose();
+            (_packageUpdateService as IDisposable)?.Dispose();
 
             _bridgeService = null;
             _clientService = null;
             _pathService = null;
             _pythonToolRegistryService = null;
             _testRunnerService = null;
             _toolSyncService = null;
+            _packageUpdateService = null;
         }
     }
 }

MCPForUnity/Editor/Services/MCPServiceLocator.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Net;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+
+namespace MCPForUnity.Editor.Services
+{
+    /// <summary>
+    /// Service for checking package updates from GitHub
+    /// </summary>
+    public class PackageUpdateService : IPackageUpdateService
+    {
+        private const string LastCheckDateKey = "MCPForUnity.LastUpdateCheck";
+        private const string CachedVersionKey = "MCPForUnity.LatestKnownVersion";
+        private const string PackageJsonUrl = "https://raw.githubusercontent.com/CoplayDev/unity-mcp/main/MCPForUnity/package.json";
+
+        /// <inheritdoc/>
+        public UpdateCheckResult CheckForUpdate(string currentVersion)
+        {
+            // Check cache first - only check once per day
+            string lastCheckDate = EditorPrefs.GetString(LastCheckDateKey, "");
+            string cachedLatestVersion = EditorPrefs.GetString(CachedVersionKey, "");
+
+            if (lastCheckDate == DateTime.Now.ToString("yyyy-MM-dd") && !string.IsNullOrEmpty(cachedLatestVersion))
+            {
+                return new UpdateCheckResult
+                {
+                    CheckSucceeded = true,
+                    LatestVersion = cachedLatestVersion,
+                    UpdateAvailable = IsNewerVersion(cachedLatestVersion, currentVersion),
+                    Message = "Using cached version check"
+                };
+            }
+
+            // Don't check for Asset Store installations
+            if (!IsGitInstallation())
+            {
+                return new UpdateCheckResult
+                {
+                    CheckSucceeded = false,
+                    UpdateAvailable = false,
+                    Message = "Asset Store installations are updated via Unity Asset Store"
+                };
+            }
+
+            // Fetch latest version from GitHub
+            string latestVersion = FetchLatestVersionFromGitHub();
+
+            if (!string.IsNullOrEmpty(latestVersion))
+            {
+                // Cache the result
+                EditorPrefs.SetString(LastCheckDateKey, DateTime.Now.ToString("yyyy-MM-dd"));
+                EditorPrefs.SetString(CachedVersionKey, latestVersion);
+
+                return new UpdateCheckResult
+                {
+                    CheckSucceeded = true,
+                    LatestVersion = latestVersion,
+                    UpdateAvailable = IsNewerVersion(latestVersion, currentVersion),
+                    Message = "Successfully checked for updates"
+                };
+            }
+
+            return new UpdateCheckResult
+            {
+                CheckSucceeded = false,
+                UpdateAvailable = false,
+                Message = "Failed to check for updates (network issue or offline)"
+            };
+        }
+
+        /// <inheritdoc/>
+        public bool IsNewerVersion(string version1, string version2)
+        {
+            try
+            {
+                // Remove any "v" prefix
+                version1 = version1.TrimStart('v', 'V');
+                version2 = version2.TrimStart('v', 'V');
+
+                var version1Parts = version1.Split('.');
+                var version2Parts = version2.Split('.');
+
+                for (int i = 0; i < Math.Min(version1Parts.Length, version2Parts.Length); i++)
+                {
+                    if (int.TryParse(version1Parts[i], out int v1Num) &&
+                        int.TryParse(version2Parts[i], out int v2Num))
+                    {
+                        if (v1Num > v2Num) return true;
+                        if (v1Num < v2Num) return false;
+                    }
+                }
+                return false;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool IsGitInstallation()
+        {
+            // Git packages are installed via Package Manager and have a package.json in Packages/
+            // Asset Store packages are in Assets/
+            string packageRoot = AssetPathUtility.GetMcpPackageRootPath();
+
+            if (string.IsNullOrEmpty(packageRoot))
+            {
+                return false;
+            }
+
+            // If the package is in Packages/ it's a PM install (likely Git)
+            // If it's in Assets/ it's an Asset Store install
+            return packageRoot.StartsWith("Packages/", StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <inheritdoc/>
+        public void ClearCache()
+        {
+            EditorPrefs.DeleteKey(LastCheckDateKey);
+            EditorPrefs.DeleteKey(CachedVersionKey);
+        }
+
+        /// <summary>
+        /// Fetches the latest version from GitHub's main branch package.json
+        /// </summary>
+        private string FetchLatestVersionFromGitHub()
+        {
+            try
+            {
+                // GitHub API endpoint (Option 1 - has rate limits):
+                // https://api.github.com/repos/CoplayDev/unity-mcp/releases/latest
+                //
+                // We use Option 2 (package.json directly) because:
+                // - No API rate limits (GitHub serves raw files freely)
+                // - Simpler - just parse JSON for version field
+                // - More reliable - doesn't require releases to be published
+                // - Direct source of truth from the main branch
+
+                using (var client = new WebClient())
+                {
+                    client.Headers.Add("User-Agent", "Unity-MCPForUnity-UpdateChecker");
+                    string jsonContent = client.DownloadString(PackageJsonUrl);
+
+                    var packageJson = JObject.Parse(jsonContent);
+                    string version = packageJson["version"]?.ToString();
+
+                    return string.IsNullOrEmpty(version) ? null : version;
+                }
+            }
+            catch (Exception ex)
+            {
+                // Silent fail - don't interrupt the user if network is unavailable
+                McpLog.Info($"Update check failed (this is normal if offline): {ex.Message}");
+                return null;
+            }
+        }
+    }
+}

MCPForUnity/Editor/Services/PackageUpdateService.cs

@@ -242,7 +242,7 @@ private void CacheUIElements()
         private void InitializeUI()
         {
             // Settings Section
-            versionLabel.text = AssetPathUtility.GetPackageVersion();
+            UpdateVersionLabel();
             debugLogsToggle.value = EditorPrefs.GetBool("MCPForUnity.DebugLogs", false);
 
             validationLevelField.Init(ValidationLevel.Standard);
@@ -833,5 +833,28 @@ private void OnCopyJsonClicked()
             EditorGUIUtility.systemCopyBuffer = configJsonField.value;
             McpLog.Info("Configuration copied to clipboard");
         }
+
+        private void UpdateVersionLabel()
+        {
+            string currentVersion = AssetPathUtility.GetPackageVersion();
+            versionLabel.text = $"v{currentVersion}";
+
+            // Check for updates using the service
+            var updateCheck = MCPServiceLocator.Updates.CheckForUpdate(currentVersion);
+
+            if (updateCheck.UpdateAvailable && !string.IsNullOrEmpty(updateCheck.LatestVersion))
+            {
+                // Update available - enhance the label
+                versionLabel.text = $"\u2191 v{currentVersion} (Update available: v{updateCheck.LatestVersion})";
+                versionLabel.style.color = new Color(1f, 0.7f, 0f); // Orange
+                versionLabel.tooltip = $"Version {updateCheck.LatestVersion} is available. Update via Package Manager.\n\nGit URL: https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity";
+            }
+            else
+            {
+                versionLabel.style.color = StyleKeyword.Null; // Default color
+                versionLabel.tooltip = $"Current version: {currentVersion}";
+            }
+        }
+
     }
 }