@alpsckr/unitycli 0.4.0 → 0.4.2

package/unitypkg/Editor/Infrastructure/CodeExecSupport.cs

@@ -11,8 +11,6 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
 using UnityEditor;
 using UnityEditor.SceneManagement;
 using UnityEngine;
@@ -34,9 +32,6 @@ namespace UnityCli
         private const int MaxRoslynOutputBytes = 512 * 1024;
         private const int MaxRoslynDiagnostics = 100;
 
-        // code.exec 编译核心开关：默认 in-process Roslyn（官方方案）；置 false 回退到 csc.exe 子进程。
-        private const bool CodeExecUseInProcessRoslyn = true;
-
         // 注册运行时代码执行命令。
         private static void RegisterCodeExecCommand(BridgeCommandRegistry registry)
         {
@@ -90,9 +85,7 @@ namespace UnityCli
             byte[] assemblyBytes;
             try
             {
-                var compilation = CodeExecUseInProcessRoslyn
-                    ? CompileInProcess(source, references, request.StringArg("defines"), request, cancellationToken)
-                    : CompileWithCscFallback(source, references, request.StringArg("defines"), request, cancellationToken);
+                var compilation = CompileWithUnityCompiler(source, references, request.StringArg("defines"), request, cancellationToken);
                 if (compilation.TimedOut)
                     return CodeExecutionResult.Fail("E_EXECUTION_TIMEOUT", "Runtime Code compilation exceeded the immutable deadline.", new Dictionary<string, object>(), "Inspect the Editor state before submitting a new request.");
                 if (!compilation.Success)
@@ -215,8 +208,8 @@ namespace UnityCli
         }
 
         /// <summary>
-        /// 汇总 in-process Roslyn 所需引用；跟随官方 Editor 模式全包含 AppDomain 已加载程序集，
-        /// 不排除 mscorlib/System*/netstandard，避免针对 mscorlib 编译的项目程序集缺核心库引用。
+        /// 汇总 Unity Editor 编译器所需引用；全包含 AppDomain 已加载程序集，
+        /// 不排除 mscorlib/System*/netstandard，避免项目程序集缺少核心库引用。
         /// </summary>
         private static IEnumerable<string> DefaultCodeReferences(string refsCsv, UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)
         {
@@ -245,7 +238,7 @@ namespace UnityCli
             if (!references.Contains(reference)) references.Add(reference);
         }
 
-        // in-process 与 csc.exe 回退共用的编译结果；成功时携带程序集字节，失败时携带错误诊断。
+        // Unity Editor 编译器结果；成功时携带程序集字节，失败时携带结构化诊断。
         private sealed class CodeCompilationResult
         {
             public bool Success;
@@ -255,71 +248,9 @@ namespace UnityCli
         }
 
         /// <summary>
-        /// 用 in-process Roslyn（Microsoft.CodeAnalysis.CSharp）编译源码。
-        /// 引用集全包含 AppDomain 已加载程序集，与官方 Editor 模式一致；
-        /// 编译无法中途终止，只能在编译前后重验 immutable deadline。
-        /// </summary>
-        private static CodeCompilationResult CompileInProcess(string source, IEnumerable<string> references, string definesCsv, UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)
-        {
-            var result = new CodeCompilationResult();
-            try
-            {
-                EnsureCodePreEffectDeadline(request, cancellationToken);
-                var parseOptions = new CSharpParseOptions(preprocessorSymbols: SplitCsv(definesCsv));
-                var tree = CSharpSyntaxTree.ParseText(WrapCodeSource(source), parseOptions);
-                var metadataReferences = new List<MetadataReference>();
-                foreach (var reference in references)
-                {
-                    if (string.IsNullOrEmpty(reference)) continue;
-                    try { metadataReferences.Add(MetadataReference.CreateFromFile(reference)); }
-                    catch { /* 跳过不可读引用，避免个别文件缺失中断整次编译 */ }
-                }
-                var compilation = CSharpCompilation.Create(
-                    "UnityCli.RuntimeCode",
-                    new[] { tree },
-                    metadataReferences,
-                    new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-                using (var ms = new MemoryStream())
-                {
-                    var emitResult = compilation.Emit(ms);
-                    foreach (var diagnostic in emitResult.Diagnostics)
-                    {
-                        if (diagnostic.Severity != DiagnosticSeverity.Error) continue;
-                        if (result.Diagnostics.Count >= MaxRoslynDiagnostics) continue;
-                        var lineSpan = diagnostic.Location.GetLineSpan();
-                        result.Diagnostics.Add(new Dictionary<string, object>
-                        {
-                            { "severity", "error" }, { "id", BoundedText(diagnostic.Id, 64) },
-                            { "message", BoundedText(diagnostic.GetMessage(), 4096) },
-                            { "file", BoundedText(lineSpan.Path ?? string.Empty, 2048) },
-                            { "line", (long)(lineSpan.StartLinePosition.Line + 1) },
-                            { "column", (long)(lineSpan.StartLinePosition.Character + 1) },
-                            { "span", null }
-                        });
-                    }
-                    result.Success = emitResult.Success;
-                    if (emitResult.Success) result.AssemblyBytes = ms.ToArray();
-                }
-                // in-process 无法中途终止；编译完成后重验 deadline，拒绝超时结果。
-                int remainingMs;
-                if (cancellationToken.IsCancellationRequested || request == null || !request.TryDeadlineRemainingMs(out remainingMs))
-                {
-                    result.TimedOut = true;
-                    result.Success = false;
-                    result.AssemblyBytes = null;
-                }
-            }
-            catch (OperationCanceledException)
-            {
-                result.TimedOut = true;
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// csc.exe 子进程编译回退；保留原临时文件与子进程超时终止逻辑，仅在 in-process 编译不可用时切换回来。
+        /// 使用当前 Unity Editor 自带的 csc.exe 编译源码；子进程受请求 deadline 约束并可终止。
         /// </summary>
-        private static CodeCompilationResult CompileWithCscFallback(string source, IEnumerable<string> references, string definesCsv, UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)
+        private static CodeCompilationResult CompileWithUnityCompiler(string source, IEnumerable<string> references, string definesCsv, UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)
         {
             var result = new CodeCompilationResult();
             var editorDataPath = EditorDataPath();
@@ -339,7 +270,7 @@ namespace UnityCli
             {
                 File.WriteAllText(sourceFilePath, WrapCodeSource(source), new UTF8Encoding(true));
                 WriteReferenceResponseFile(responseFilePath, references);
-                var compilation = CompileWithRoslyn(editorDataPath, sourceFilePath, responseFilePath, assemblyFilePath, definesCsv, request, cancellationToken);
+                var compilation = RunUnityCompiler(editorDataPath, sourceFilePath, responseFilePath, assemblyFilePath, definesCsv, request, cancellationToken);
                 if (compilation.TimedOut)
                 {
                     result.TimedOut = true;
@@ -394,7 +325,7 @@ namespace UnityCli
         /// <summary>
         /// 使用 Unity 内置 Roslyn 编译临时源码；进程最多运行 60 秒，输出仅用于诊断，成功程序集由调用方读取到内存。
         /// </summary>
-        private static RoslynCompilation CompileWithRoslyn(string editorDataPath, string sourceFilePath, string responseFilePath, string assemblyFilePath, string definesCsv, UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)
+        private static RoslynCompilation RunUnityCompiler(string editorDataPath, string sourceFilePath, string responseFilePath, string assemblyFilePath, string definesCsv, UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)
         {
             var monoPath = Path.Combine(editorDataPath, "MonoBleedingEdge", "bin", "mono.exe");
             var cscPath = Path.Combine(editorDataPath, "MonoBleedingEdge", "lib", "mono", "4.5", "csc.exe");

package/unitypkg/Editor/Infrastructure/UnityCliInstanceCleanup.cs

@@ -0,0 +1,295 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace UnityCli
+{
+    public static partial class UnityCliBridge
+    {
+        private const int InstanceCleanupMaxScanned = 2000;
+        private const int InstanceCleanupMaxDeleted = 20;
+        private const int InstanceCleanupRetainedOffline = 100;
+        private const int InstanceCleanupRetainedDamaged = 20;
+        private const int InstanceCleanupRetentionDays = 30;
+        private static bool instanceCleanupAttempted;
+        private static readonly UnityCliToolCompletionContract InstanceCleanupCompletion = new UnityCliToolCompletionContract(
+            "internal.instances.prune", "control-plane", "direct-terminal", "atomic", "bounded-cleanup-summary",
+            "writer-owned-registry-reinspection", "caller-responsibility", "E_EXECUTION_TIMEOUT", "caller-responsibility",
+            "atomic-typed-result-v1", "required", true);
+
+        private sealed class InstanceCleanupCandidate
+        {
+            public string Path;
+            public string InstanceId;
+            public DateTimeOffset LastActivity;
+            public bool Damaged;
+        }
+
+        private sealed class InstanceCleanupSummary
+        {
+            public int Scanned;
+            public int Offline;
+            public int Damaged;
+            public int Preserved;
+            public int Deleted;
+            public int Deferred;
+            public int Remaining;
+            public bool Truncated;
+        }
+
+        /// <summary>每个domain只尝试一次自动清理；其他Unity持有全局锁时直接让其负责。</summary>
+        private static void TryRunAutomaticInstanceCleanup()
+        {
+            if (instanceCleanupAttempted) return;
+            instanceCleanupAttempted = true;
+            try
+            {
+                InstanceCleanupSummary summary;
+                var acquired = TryExecuteInstanceCleanup(null, out summary);
+                if (!acquired)
+                {
+                    WriteLog("instance_cleanup_deferred reason=global-lock");
+                    return;
+                }
+                WriteLog("instance_cleanup_completed scanned=" + summary.Scanned.ToString(CultureInfo.InvariantCulture)
+                    + " offline=" + summary.Offline.ToString(CultureInfo.InvariantCulture)
+                    + " damaged=" + summary.Damaged.ToString(CultureInfo.InvariantCulture)
+                    + " preserved=" + summary.Preserved.ToString(CultureInfo.InvariantCulture)
+                    + " deleted=" + summary.Deleted.ToString(CultureInfo.InvariantCulture)
+                    + " deferred=" + summary.Deferred.ToString(CultureInfo.InvariantCulture)
+                    + " truncated=" + (summary.Truncated ? "true" : "false"));
+            }
+            catch (Exception exception)
+            {
+                WriteLog("instance_cleanup_failed kind=" + exception.GetType().Name);
+            }
+        }
+
+        /// <summary>跨Unity只允许一个清理owner；零等待失败由调用方延期或返回busy。</summary>
+        private static bool TryExecuteInstanceCleanup(Action beginEffect, out InstanceCleanupSummary summary)
+        {
+            InstanceCleanupSummary value = null;
+            var acquired = TryWithCurrentUserMutex("Local\\UnityCli.Registry.Cleanup", 0, delegate
+            {
+                if (beginEffect != null) beginEffect();
+                value = RunInstanceCleanup();
+            });
+            summary = value;
+            return acquired;
+        }
+
+        /// <summary>扫描和删除均有硬上限；活跃、不可确认、链接或锁竞争记录只保留。</summary>
+        private static InstanceCleanupSummary RunInstanceCleanup()
+        {
+            var summary = new InstanceCleanupSummary();
+            var directory = InstancesDir();
+            if (!Directory.Exists(directory)) return summary;
+            var root = Path.GetFullPath(directory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+            var candidates = new List<InstanceCleanupCandidate>();
+            using (var enumerator = Directory.EnumerateFiles(root, "*.json", SearchOption.TopDirectoryOnly).GetEnumerator())
+            {
+                while (summary.Scanned < InstanceCleanupMaxScanned && enumerator.MoveNext())
+                {
+                    var fullPath = Path.GetFullPath(enumerator.Current);
+                    var parent = Path.GetDirectoryName(fullPath).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+                    var fileName = Path.GetFileName(fullPath);
+                    string candidateInstanceId;
+                    if (!string.Equals(parent, root, StringComparison.OrdinalIgnoreCase)
+                        || !TryInstanceIdFromFileName(fileName, out candidateInstanceId)) continue;
+                    summary.Scanned += 1;
+                    if (string.Equals(candidateInstanceId, InstanceId(), StringComparison.Ordinal))
+                    {
+                        summary.Preserved += 1;
+                        continue;
+                    }
+                    InstanceCleanupCandidate candidate;
+                    if (!TryInspectCleanupCandidate(fullPath, candidateInstanceId, out candidate))
+                    {
+                        summary.Preserved += 1;
+                        continue;
+                    }
+                    if (candidate.Damaged) summary.Damaged += 1;
+                    else summary.Offline += 1;
+                    candidates.Add(candidate);
+                }
+                if (enumerator.MoveNext()) summary.Truncated = true;
+            }
+
+            var cutoff = DateTimeOffset.UtcNow.AddDays(-InstanceCleanupRetentionDays);
+            var offline = candidates.Where(value => !value.Damaged).OrderBy(value => value.LastActivity).ThenBy(value => value.InstanceId, StringComparer.Ordinal).ToList();
+            var damaged = candidates.Where(value => value.Damaged).OrderBy(value => value.LastActivity).ThenBy(value => value.InstanceId, StringComparer.Ordinal).ToList();
+            var planned = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            PlanCleanup(offline, InstanceCleanupRetainedOffline, cutoff, planned);
+            PlanCleanup(damaged, InstanceCleanupRetainedDamaged, cutoff, planned);
+            summary.Deferred += Math.Max(0, planned.Count - InstanceCleanupMaxDeleted);
+
+            foreach (var candidate in candidates.Where(value => planned.Contains(value.Path)).OrderBy(value => value.LastActivity).ThenBy(value => value.InstanceId, StringComparer.Ordinal).Take(InstanceCleanupMaxDeleted))
+            {
+                var deleted = false;
+                var locked = false;
+                try
+                {
+                    locked = TryWithCurrentUserMutex("Local\\UnityCli.Registry." + candidate.InstanceId, 0, delegate
+                    {
+                        InstanceCleanupCandidate current;
+                        if (!TryInspectCleanupCandidate(candidate.Path, candidate.InstanceId, out current)) return;
+                        if (current.Damaged != candidate.Damaged || current.LastActivity > candidate.LastActivity) return;
+                        File.Delete(candidate.Path);
+                        deleted = true;
+                    });
+                }
+                catch
+                {
+                    deleted = false;
+                }
+                if (deleted) summary.Deleted += 1;
+                else if (!locked || File.Exists(candidate.Path)) summary.Deferred += 1;
+            }
+            summary.Remaining = Math.Max(0, summary.Scanned - summary.Deleted);
+            return summary;
+        }
+
+        private static void PlanCleanup(List<InstanceCleanupCandidate> ordered, int retained, DateTimeOffset cutoff, HashSet<string> planned)
+        {
+            var excess = Math.Max(0, ordered.Count - retained);
+            for (var index = 0; index < ordered.Count; index++)
+            {
+                if (index < excess || ordered[index].LastActivity <= cutoff) planned.Add(ordered[index].Path);
+            }
+        }
+
+        /// <summary>返回false表示活跃、不可确认、链接、占用或不安全路径，调用方必须保留。</summary>
+        private static bool TryInspectCleanupCandidate(string path, string expectedInstanceId, out InstanceCleanupCandidate candidate)
+        {
+            candidate = null;
+            try
+            {
+                var info = new FileInfo(path);
+                if (!info.Exists || (info.Attributes & FileAttributes.ReparsePoint) != 0) return false;
+                var fallbackActivity = new DateTimeOffset(info.LastWriteTimeUtc, TimeSpan.Zero);
+                if (info.Length > RegistryMaxBytes)
+                {
+                    candidate = CleanupCandidate(path, expectedInstanceId, fallbackActivity, true);
+                    return true;
+                }
+
+                Dictionary<string, object> record;
+                try
+                {
+                    record = UnityCliSerializer.Parse(File.ReadAllText(path, Encoding.UTF8)) as Dictionary<string, object>;
+                }
+                catch (FormatException)
+                {
+                    candidate = CleanupCandidate(path, expectedInstanceId, fallbackActivity, true);
+                    return true;
+                }
+                if (record == null || ReadLong(record, "version") != 3L || ReadLong(record, "canonicalizationVersion") != 1L)
+                {
+                    candidate = CleanupCandidate(path, expectedInstanceId, fallbackActivity, true);
+                    return true;
+                }
+                var identity = ReadDictionary(record, "identity");
+                var canonicalPath = ReadString(identity, "canonicalProjectPath");
+                var actualInstanceId = ReadString(identity, "instanceId");
+                if (string.IsNullOrEmpty(canonicalPath)
+                    || !string.Equals(actualInstanceId, expectedInstanceId, StringComparison.Ordinal)
+                    || !string.Equals("unity-" + Sha256Utf8(canonicalPath), expectedInstanceId, StringComparison.Ordinal))
+                {
+                    candidate = CleanupCandidate(path, expectedInstanceId, fallbackActivity, true);
+                    return true;
+                }
+                object rawSessions;
+                var sessionValues = record.TryGetValue("sessions", out rawSessions) ? rawSessions as List<object> : null;
+                if (sessionValues == null)
+                {
+                    candidate = CleanupCandidate(path, expectedInstanceId, fallbackActivity, true);
+                    return true;
+                }
+                var sessions = sessionValues.OfType<Dictionary<string, object>>().ToList();
+                if (sessions.Count != sessionValues.Count || sessions.Any(IsProcessClaimAliveOrUnverifiable)) return false;
+                DateTimeOffset publishedAt;
+                if (!DateTimeOffset.TryParse(ReadString(record, "publishedAt"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out publishedAt))
+                {
+                    candidate = CleanupCandidate(path, expectedInstanceId, fallbackActivity, true);
+                    return true;
+                }
+                candidate = CleanupCandidate(path, expectedInstanceId, publishedAt, false);
+                return true;
+            }
+            catch (IOException) { return false; }
+            catch (UnauthorizedAccessException) { return false; }
+            catch { return false; }
+        }
+
+        private static InstanceCleanupCandidate CleanupCandidate(string path, string instanceId, DateTimeOffset lastActivity, bool damaged)
+        {
+            return new InstanceCleanupCandidate { Path = path, InstanceId = instanceId, LastActivity = lastActivity, Damaged = damaged };
+        }
+
+        /// <summary>私有Bridge命令让公开instances prune只触发Unity writer，不把删除权交给CLI。</summary>
+        private static void RegisterInstanceCleanupCommand(BridgeCommandRegistry registry)
+        {
+            registry.Register<UnityCli.Protocol.BridgeRequest>(
+                "internal.instances.prune",
+                "internal",
+                true,
+                30000,
+                (request, cancellationToken) =>
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    InstanceCleanupSummary summary;
+                    if (!TryExecuteInstanceCleanup(delegate { BeginDirectEffect(request.RequestId); }, out summary))
+                        throw new BridgeCommandException("E_UNITY_BUSY", "Another Unity instance is cleaning historical instance records.", null, new[] { "Retry unitycli instances prune after the current cleanup finishes." }, true, 100);
+                    var result = new Dictionary<string, object>
+                    {
+                        { "removed", (long)summary.Deleted },
+                        { "remaining", (long)summary.Remaining },
+                        { "deferred", (long)summary.Deferred },
+                        { "scanned", (long)summary.Scanned },
+                        { "truncated", summary.Truncated },
+                        { "retention", new Dictionary<string, object>
+                            {
+                                { "offlineMax", (long)InstanceCleanupRetainedOffline },
+                                { "damagedMax", (long)InstanceCleanupRetainedDamaged },
+                                { "maxAgeDays", (long)InstanceCleanupRetentionDays },
+                                { "scanLimit", (long)InstanceCleanupMaxScanned },
+                                { "deleteLimit", (long)InstanceCleanupMaxDeleted }
+                            }
+                        }
+                    };
+                    RecordDirectCompletionEvidence(request.RequestId, "internal.instances.prune", InstanceCleanupCompletion, result);
+                    return new System.Threading.Tasks.ValueTask<object>(result);
+                });
+        }
+
+        private static bool IsInstanceCleanupCommand(string command)
+        {
+            return string.Equals(command, "internal.instances.prune", StringComparison.Ordinal);
+        }
+
+        private static UnityCliToolCompletionContract InstanceCleanupCompletionContract()
+        {
+            return InstanceCleanupCompletion;
+        }
+
+        private static bool TryInstanceIdFromFileName(string fileName, out string instanceId)
+        {
+            instanceId = null;
+            if (string.IsNullOrEmpty(fileName) || !fileName.EndsWith(".json", StringComparison.OrdinalIgnoreCase)) return false;
+            var value = fileName.Substring(0, fileName.Length - 5);
+            if (!value.StartsWith("unity-", StringComparison.Ordinal) || value.Length != 70) return false;
+            for (var index = 6; index < value.Length; index++)
+            {
+                var ch = value[index];
+                if (!((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f'))) return false;
+            }
+            instanceId = value;
+            return true;
+        }
+    }
+}
+#endif