Revert "Update for Custom_Tool Fix and Detection"

This reverts commit ae8cfe5.

Author: Scriptwonder

CustomTools/RoslynRuntimeCompilation/ManageRuntimeCompilation.cs

@@ -19,11 +19,9 @@ namespace MCPForUnity.Editor.Tools
 {
     /// <summary>
     /// Runtime compilation tool for MCP Unity.
-    /// Compiles and loads C# code at runtime without triggering domain reload via Roslyn Runtime Compilation, where in traditional Unity workflow it would take seconds to reload assets and reset script states for each script change. 
+    /// Compiles and loads C# code at runtime without triggering domain reload.
     /// </summary>
-    [McpForUnityTool(
-        name:"runtime_compilation",
-        Description = "Enable runtime compilation of C# code within Unity without domain reload via Roslyn.")]
+    [McpForUnityTool("runtime_compilation")]
     public static class ManageRuntimeCompilation
     {
         private static readonly Dictionary<string, LoadedAssemblyInfo> LoadedAssemblies = new Dictionary<string, LoadedAssemblyInfo>();
@@ -44,7 +42,7 @@ public static object HandleCommand(JObject @params)
 
             if (string.IsNullOrEmpty(action))
             {
-                return new ErrorResponse("Action parameter is required. Valid actions: compile_and_load, list_loaded, get_types, execute_with_roslyn, get_history, save_history, clear_history");
+                return Response.Error("Action parameter is required. Valid actions: compile_and_load, list_loaded, get_types, execute_with_roslyn, get_history, save_history, clear_history");
             }
 
             switch (action)
@@ -71,28 +69,31 @@ public static object HandleCommand(JObject @params)
                     return ClearCompilationHistory();
 
                 default:
-                    return new ErrorResponse($"Unknown action '{action}'. Valid actions: compile_and_load, list_loaded, get_types, execute_with_roslyn, get_history, save_history, clear_history");
+                    return Response.Error($"Unknown action '{action}'. Valid actions: compile_and_load, list_loaded, get_types, execute_with_roslyn, get_history, save_history, clear_history");
             }
         }
 
         private static object CompileAndLoad(JObject @params)
         {
 #if !USE_ROSLYN
-            return new ErrorResponse(
+            return Response.Error(
                 "Runtime compilation requires Roslyn. Please install Microsoft.CodeAnalysis.CSharp NuGet package and add USE_ROSLYN to Scripting Define Symbols. " +
                 "See ManageScript.cs header for installation instructions."
             );
 #else
             try
             {
                 string code = @params["code"]?.ToString();
-                string assemblyName = @params["assembly_name"]?.ToString() ?? $"DynamicAssembly_{DateTime.Now.Ticks}";
+                var assemblyToken = @params["assembly_name"];
+                string assemblyName = assemblyToken == null || string.IsNullOrWhiteSpace(assemblyToken.ToString())
+                    ? $"DynamicAssembly_{DateTime.Now.Ticks}"
+                    : assemblyToken.ToString().Trim();
                 string attachTo = @params["attach_to"]?.ToString();
                 bool loadImmediately = @params["load_immediately"]?.ToObject<bool>() ?? true;
 
                 if (string.IsNullOrEmpty(code))
                 {
-                    return new ErrorResponse("'code' parameter is required");
+                    return Response.Error("'code' parameter is required");
                 }
 
                 // Ensure unique assembly name
@@ -103,8 +104,21 @@ private static object CompileAndLoad(JObject @params)
 
                 // Create output directory
                 Directory.CreateDirectory(DynamicAssembliesPath);
-                string dllPath = Path.Combine(DynamicAssembliesPath, $"{assemblyName}.dll");
-                
+                string basePath = Path.GetFullPath(DynamicAssembliesPath);
+                Directory.CreateDirectory(basePath);
+                string safeFileName = SanitizeAssemblyFileName(assemblyName);
+                string dllPath = Path.GetFullPath(Path.Combine(basePath, $"{safeFileName}.dll"));
+
+                if (!dllPath.StartsWith(basePath, StringComparison.Ordinal))
+                {
+                    return Response.Error("Assembly name must resolve inside the dynamic assemblies directory.");
+                }
+
+                if (File.Exists(dllPath))
+                {
+                    dllPath = Path.GetFullPath(Path.Combine(basePath, $"{safeFileName}_{DateTime.Now.Ticks}.dll"));
+                }
+
                 // Parse code
                 var syntaxTree = CSharpSyntaxTree.ParseText(code);
 
@@ -123,7 +137,7 @@ private static object CompileAndLoad(JObject @params)
 
                 // Emit to file
                 EmitResult emitResult;
-                using (var stream = new FileStream(dllPath, FileMode.Create))
+                using (var stream = new FileStream(dllPath, FileMode.Create, FileAccess.Write, FileShare.None))
                 {
                     emitResult = compilation.Emit(stream);
                 }
@@ -142,7 +156,7 @@ private static object CompileAndLoad(JObject @params)
                         })
                         .ToList();
 
-                    return new ErrorResponse("Compilation failed", new
+                    return Response.Error("Compilation failed", new
                     {
                         errors = errors,
                         error_count = errors.Count
@@ -208,7 +222,7 @@ private static object CompileAndLoad(JObject @params)
                     }
                 }
 
-                return new SuccessResponse("Runtime compilation completed successfully", new
+                return Response.Success("Runtime compilation completed successfully", new
                 {
                     assembly_name = assemblyName,
                     dll_path = dllPath,
@@ -221,15 +235,15 @@ private static object CompileAndLoad(JObject @params)
             }
             catch (Exception ex)
             {
-                return new ErrorResponse($"Runtime compilation failed: {ex.Message}", new
+                return Response.Error($"Runtime compilation failed: {ex.Message}", new
                 {
                     exception = ex.GetType().Name,
                     stack_trace = ex.StackTrace
                 });
             }
 #endif
         }
-        
+
         private static object ListLoadedAssemblies()
         {
             var assemblies = LoadedAssemblies.Values.Select(info => new
@@ -240,26 +254,33 @@ private static object ListLoadedAssemblies()
                 type_count = info.TypeNames.Count,
                 types = info.TypeNames
             }).ToList();
-            
-            return new SuccessResponse($"Found {assemblies.Count} loaded dynamic assemblies", new
+
+            return Response.Success($"Found {assemblies.Count} loaded dynamic assemblies", new
             {
                 count = assemblies.Count,
                 assemblies = assemblies
             });
         }
 
+        private static string SanitizeAssemblyFileName(string assemblyName)
+        {
+            var invalidChars = Path.GetInvalidFileNameChars();
+            var sanitized = new string(assemblyName.Where(c => !invalidChars.Contains(c)).ToArray());
+            return string.IsNullOrWhiteSpace(sanitized) ? $"DynamicAssembly_{DateTime.Now.Ticks}" : sanitized;
+        }
+
         private static object GetAssemblyTypes(JObject @params)
         {
             string assemblyName = @params["assembly_name"]?.ToString();
 
             if (string.IsNullOrEmpty(assemblyName))
             {
-                return new ErrorResponse("'assembly_name' parameter is required");
+                return Response.Error("'assembly_name' parameter is required");
             }
 
             if (!LoadedAssemblies.TryGetValue(assemblyName, out var info))
             {
-                return new ErrorResponse($"Assembly '{assemblyName}' not found in loaded assemblies");
+                return Response.Error($"Assembly '{assemblyName}' not found in loaded assemblies");
             }
 
             var types = info.Assembly.GetTypes().Select(t => new
@@ -273,7 +294,7 @@ private static object GetAssemblyTypes(JObject @params)
                 base_type = t.BaseType?.FullName
             }).ToList();
 
-            return new SuccessResponse($"Retrieved {types.Count} types from {assemblyName}", new
+            return Response.Success($"Retrieved {types.Count} types from {assemblyName}", new
             {
                 assembly_name = assemblyName,
                 type_count = types.Count,
@@ -297,7 +318,7 @@ private static object ExecuteWithRoslyn(JObject @params)
 
                 if (string.IsNullOrEmpty(code))
                 {
-                    return new ErrorResponse("'code' parameter is required");
+                    return Response.Error("'code' parameter is required");
                 }
 
                 // Get or create the RoslynRuntimeCompiler instance
@@ -315,7 +336,7 @@ private static object ExecuteWithRoslyn(JObject @params)
 
                     if (targetObject == null)
                     {
-                        return new ErrorResponse($"Target GameObject '{targetObjectName}' not found");
+                        return Response.Error($"Target GameObject '{targetObjectName}' not found");
                     }
                 }
 
@@ -331,7 +352,7 @@ out string errorMessage
 
                 if (success)
                 {
-                    return new SuccessResponse($"Code compiled and executed successfully", new
+                    return Response.Success($"Code compiled and executed successfully", new
                     {
                         class_name = className,
                         method_name = methodName,
@@ -342,15 +363,15 @@ out string errorMessage
                 }
                 else
                 {
-                    return new ErrorResponse($"Execution failed: {errorMessage}", new
+                    return Response.Error($"Execution failed: {errorMessage}", new
                     {
                         diagnostics = compiler.lastCompileDiagnostics
                     });
                 }
             }
             catch (Exception ex)
             {
-                return new ErrorResponse($"Failed to execute with Roslyn: {ex.Message}", new
+                return Response.Error($"Failed to execute with Roslyn: {ex.Message}", new
                 {
                     exception = ex.GetType().Name,
                     stack_trace = ex.StackTrace
@@ -381,15 +402,15 @@ private static object GetCompilationHistory()
                         : entry.sourceCode
                 }).ToList();
 
-                return new SuccessResponse($"Retrieved {historyData.Count} history entries", new
+                return Response.Success($"Retrieved {historyData.Count} history entries", new
                 {
                     count = historyData.Count,
                     history = historyData
                 });
             }
             catch (Exception ex)
             {
-                return new ErrorResponse($"Failed to get history: {ex.Message}");
+                return Response.Error($"Failed to get history: {ex.Message}");
             }
         }
 
@@ -404,20 +425,20 @@ private static object SaveCompilationHistory()
 
                 if (compiler.SaveHistoryToFile(out string savedPath, out string error))
                 {
-                    return new SuccessResponse($"History saved successfully", new
+                    return Response.Success($"History saved successfully", new
                     {
                         path = savedPath,
                         entry_count = compiler.CompilationHistory.Count
                     });
                 }
                 else
                 {
-                    return new ErrorResponse($"Failed to save history: {error}");
+                    return Response.Error($"Failed to save history: {error}");
                 }
             }
             catch (Exception ex)
             {
-                return new ErrorResponse($"Failed to save history: {ex.Message}");
+                return Response.Error($"Failed to save history: {ex.Message}");
             }
         }
 
@@ -432,11 +453,11 @@ private static object ClearCompilationHistory()
                 int count = compiler.CompilationHistory.Count;
                 compiler.ClearHistory();
 
-                return new SuccessResponse($"Cleared {count} history entries");
+                return Response.Success($"Cleared {count} history entries");
             }
             catch (Exception ex)
             {
-                return new ErrorResponse($"Failed to clear history: {ex.Message}");
+                return Response.Error($"Failed to clear history: {ex.Message}");
             }
         }
 

MCPForUnity/Editor/Windows/Components/Tools.meta renamed to CustomTools/RoslynRuntimeCompilation/PythonTools.asset.meta

@@ -0,0 +1,3 @@
+# Roslyn Runtime Compilation Tool
+
+This custom tool uses Roslyn Runtime Compilation to have users run script generation and compilation during Playmode in realtime, where in traditional Unity workflow it would take seconds to reload assets and reset script states for each script change.