New UI and work without MCP server embedded

.github/workflows/bump-version.yml

@@ -108,3 +108,30 @@ jobs:
 
           git tag -a "$TAG" -m "Version ${NEW_VERSION}"
           git push origin "$TAG"
+
+      - name: Package server for release
+        env:
+          NEW_VERSION: ${{ steps.compute.outputs.new_version }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          cd MCPForUnity/UnityMcpServer~
+          zip -r ../../mcp-for-unity-server-v${NEW_VERSION}.zip .
+          cd ../..
+          ls -lh mcp-for-unity-server-v${NEW_VERSION}.zip
+          echo "Server package created: mcp-for-unity-server-v${NEW_VERSION}.zip"
+
+      - name: Create GitHub release with server artifact
+        env:
+          NEW_VERSION: ${{ steps.compute.outputs.new_version }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="v${NEW_VERSION}"
+
+          # Create release
+          gh release create "$TAG" \
+            --title "v${NEW_VERSION}" \
+            --notes "Release v${NEW_VERSION}" \
+            "mcp-for-unity-server-v${NEW_VERSION}.zip#MCP Server v${NEW_VERSION}"

MCPForUnity/Editor/Helpers/AssetPathUtility.cs

@@ -1,4 +1,9 @@
 using System;
+using System.IO;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+using PackageInfo = UnityEditor.PackageManager.PackageInfo;
 
 namespace MCPForUnity.Editor.Helpers
 {
@@ -25,5 +30,133 @@ public static string SanitizeAssetPath(string path)
 
             return path;
         }
+
+        /// <summary>
+        /// Gets the MCP for Unity package root path.
+        /// Works for registry Package Manager, local Package Manager, and Asset Store installations.
+        /// </summary>
+        /// <returns>The package root path (virtual for PM, absolute for Asset Store), or null if not found</returns>
+        public static string GetMcpPackageRootPath()
+        {
+            try
+            {
+                // Try Package Manager first (registry and local installs)
+                var packageInfo = PackageInfo.FindForAssembly(typeof(AssetPathUtility).Assembly);
+                if (packageInfo != null && !string.IsNullOrEmpty(packageInfo.assetPath))
+                {
+                    return packageInfo.assetPath;
+                }
+
+                // Fallback to AssetDatabase for Asset Store installs (Assets/MCPForUnity)
+                string[] guids = AssetDatabase.FindAssets($"t:Script {nameof(AssetPathUtility)}");
+
+                if (guids.Length == 0)
+                {
+                    McpLog.Warn("Could not find AssetPathUtility script in AssetDatabase");
+                    return null;
+                }
+
+                string scriptPath = AssetDatabase.GUIDToAssetPath(guids[0]);
+
+                // Script is at: {packageRoot}/Editor/Helpers/AssetPathUtility.cs
+                // Extract {packageRoot}
+                int editorIndex = scriptPath.IndexOf("/Editor/", StringComparison.Ordinal);
+
+                if (editorIndex >= 0)
+                {
+                    return scriptPath.Substring(0, editorIndex);
+                }
+
+                McpLog.Warn($"Could not determine package root from script path: {scriptPath}");
+                return null;
+            }
+            catch (Exception ex)
+            {
+                McpLog.Error($"Failed to get package root path: {ex.Message}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Reads and parses the package.json file for MCP for Unity.
+        /// Handles both Package Manager (registry/local) and Asset Store installations.
+        /// </summary>
+        /// <returns>JObject containing package.json data, or null if not found or parse failed</returns>
+        public static JObject GetPackageJson()
+        {
+            try
+            {
+                string packageRoot = GetMcpPackageRootPath();
+                if (string.IsNullOrEmpty(packageRoot))
+                {
+                    return null;
+                }
+
+                string packageJsonPath = Path.Combine(packageRoot, "package.json");
+
+                // Convert virtual asset path to file system path
+                if (packageRoot.StartsWith("Packages/", StringComparison.OrdinalIgnoreCase))
+                {
+                    // Package Manager install - must use PackageInfo.resolvedPath
+                    // Virtual paths like "Packages/..." don't work with File.Exists()
+                    // Registry packages live in Library/PackageCache/package@version/
+                    var packageInfo = PackageInfo.FindForAssembly(typeof(AssetPathUtility).Assembly);
+                    if (packageInfo != null && !string.IsNullOrEmpty(packageInfo.resolvedPath))
+                    {
+                        packageJsonPath = Path.Combine(packageInfo.resolvedPath, "package.json");
+                    }
+                    else
+                    {
+                        McpLog.Warn("Could not resolve Package Manager path for package.json");
+                        return null;
+                    }
+                }
+                else if (packageRoot.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
+                {
+                    // Asset Store install - convert to absolute file system path
+                    // Application.dataPath is the absolute path to the Assets folder
+                    string relativePath = packageRoot.Substring("Assets/".Length);
+                    packageJsonPath = Path.Combine(Application.dataPath, relativePath, "package.json");
+                }
+
+                if (!File.Exists(packageJsonPath))
+                {
+                    McpLog.Warn($"package.json not found at: {packageJsonPath}");
+                    return null;
+                }
+
+                string json = File.ReadAllText(packageJsonPath);
+                return JObject.Parse(json);
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to read or parse package.json: {ex.Message}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the version string from the package.json file.
+        /// </summary>
+        /// <returns>Version string, or "unknown" if not found</returns>
+        public static string GetPackageVersion()
+        {
+            try
+            {
+                var packageJson = GetPackageJson();
+                if (packageJson == null)
+                {
+                    return "unknown";
+                }
+
+                string version = packageJson["version"]?.ToString();
+                return string.IsNullOrEmpty(version) ? "unknown" : version;
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"Failed to get package version: {ex.Message}");
+                return "unknown";
+            }
+        }
     }
 }

MCPForUnity/Editor/Helpers/McpPathResolver.cs

@@ -7,15 +7,15 @@
 namespace MCPForUnity.Editor.Helpers
 {
     /// <summary>
-    /// Shared helper for resolving Python server directory paths with support for
+    /// Shared helper for resolving MCP server directory paths with support for
     /// development mode, embedded servers, and installed packages
     /// </summary>
     public static class McpPathResolver
     {
         private const string USE_EMBEDDED_SERVER_KEY = "MCPForUnity.UseEmbeddedServer";
 
         /// <summary>
-        /// Resolves the Python server directory path with comprehensive logic
+        /// Resolves the MCP server directory path with comprehensive logic
         /// including development mode support and fallback mechanisms
         /// </summary>
         public static string FindPackagePythonDirectory(bool debugLogsEnabled = false)

MCPForUnity/Editor/Helpers/PackageDetector.cs

@@ -49,8 +49,7 @@ static PackageDetector()
 
                         if (!string.IsNullOrEmpty(error))
                         {
-                            Debug.LogWarning($"MCP for Unity: Auto-detect on load failed: {capturedEx}");
-                            // Alternatively: Debug.LogException(capturedEx);
+                            McpLog.Info($"Server check: {error}. Download via Window > MCP For Unity if needed.", always: false);
                         }
                     };
                 }

MCPForUnity/Editor/Helpers/PackageInstaller.cs

@@ -4,7 +4,7 @@
 namespace MCPForUnity.Editor.Helpers
 {
     /// <summary>
-    /// Handles automatic installation of the Python server when the package is first installed.
+    /// Handles automatic installation of the MCP server when the package is first installed.
     /// </summary>
     [InitializeOnLoad]
     public static class PackageInstaller
@@ -25,18 +25,21 @@ private static void InstallServerOnFirstLoad()
         {
             try
             {
-                Debug.Log("<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Installing Python server...");
                 ServerInstaller.EnsureServerInstalled();
 
-                // Mark as installed
+                // Mark as installed/checked
                 EditorPrefs.SetBool(InstallationFlagKey, true);
 
-                Debug.Log("<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Python server installation completed successfully.");
+                // Only log success if server was actually embedded and copied
+                if (ServerInstaller.HasEmbeddedServer())
+                {
+                    McpLog.Info("MCP server installation completed successfully.");
+                }
             }
-            catch (System.Exception ex)
+            catch (System.Exception)
             {
-                Debug.LogError($"<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: Failed to install Python server: {ex.Message}");
-                Debug.LogWarning("<b><color=#2EA3FF>MCP-FOR-UNITY</color></b>: You may need to manually install the Python server. Check the MCP For Unity Window for instructions.");
+                EditorPrefs.SetBool(InstallationFlagKey, true); // Mark as handled
+                McpLog.Info("Server installation pending. Open Window > MCP For Unity to download the server.");
             }
         }
     }