@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Infrastructure/UnityCliLiveRefreshCoordinator.cs

@@ -0,0 +1,164 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityCli.Protocol;
+
+namespace UnityCli
+{
+    public static partial class UnityCliBridge
+    {
+        /// <summary>editor.refresh 的单 scope 进行中操作协调器（统一骨架收编）。</summary>
+        internal static class UnityCliLiveRefreshCoordinator
+        {
+            private static readonly Coordinator Instance = new Coordinator();
+            internal const string Command = "internal.editor.refresh.start";
+            internal static bool IsCommand(string command) { return Instance.IsCommand(command); }
+            internal static void Register(BridgeCommandRegistry registry) { Instance.Register(registry); }
+            internal static Task<string> Execute(BridgeRequest request, byte[] raw, Func<bool> accept, CancellationToken ct) { return Instance.Execute(request, raw, accept, ct); }
+            internal static void Initialize() { }
+            internal static void Shutdown() { }
+            internal static void BeforeReload() { Instance.Update(x => x["reloadObserved"] = true); }
+            internal static void Tick() { Instance.Tick(); }
+
+            private sealed class Coordinator : UnityCliReloadOperation
+            {
+                protected override string Scope { get { return "refresh"; } }
+                protected override string StartCommand { get { return Command; } }
+                protected override string StatusCommand { get { return "internal.editor.refresh.status"; } }
+                protected override string OperationDisplayName { get { return "Refresh"; } }
+                protected override bool IncludeAcceptedInStatus { get { return true; } }
+                protected override string SessionChangedMessage { get { return "Refresh result cannot be confirmed after the Editor session changed; check the business state."; } }
+                protected override string DeadlineMessage { get { return "Refresh did not reach a confirmed terminal state before the deadline; check the business state."; } }
+                protected override object DeserializeStartArgs(BridgeRequest request) { return request.DeserializeArgs<Args>(); }
+                protected override void ValidateStart(object value)
+                {
+                    var args = (Args)value;
+                    if (args == null || string.IsNullOrWhiteSpace(args.ExpectedEditorSessionId)) throw new BridgeCommandException("E_SCHEMA_INVALID", "expectedEditorSessionId is required.");
+                    if (!string.Equals(args.ExpectedEditorSessionId, EditorSessionId(), StringComparison.Ordinal)) throw new BridgeCommandException("E_EDITOR_SESSION_REPLACED", "The selected Editor session changed before refresh execution.");
+                    if (EditorApplication.isPlaying || IsPlayModeChanging()) throw new BridgeCommandException("E_TOOL_PLAYMODE_UNAVAILABLE", "editor.refresh is editor-only and requires stable Edit Mode.");
+                }
+                protected override void ValidateLoadedRoot(Dictionary<string, object> root)
+                {
+                    ValidateRootContract(root, new[] { "compile", "compilationRequested", "compilationObserved", "compilePhase", "compileDispatchSequence", "compileStartedSequence", "compileFinishedSequence", "compileStartedCycle", "compileDiagnostics", "compileErrorCount", "compileWarningCount", "compileInfoCount", "compileDiagnosticsTruncated", "stableFrames", "beforeSourceFingerprint", "beforeDependencyVersion", "reloadObserved", "rootContractDigest" },
+                        "queued", "prepared", "dispatching", "refresh_returned", "waiting_stable");
+                    object compile; object requested; object observed; object diagnostics; object errorCount; object warningCount; object infoCount; object truncated; object stableFrames;
+                    if (!root.TryGetValue("compile", out compile) || !(compile is bool)
+                        || !root.TryGetValue("compilationRequested", out requested) || !(requested is bool)
+                        || !root.TryGetValue("compilationObserved", out observed) || !(observed is bool)
+                        || !root.TryGetValue("compileDiagnostics", out diagnostics) || !(diagnostics is List<object>)
+                        || !root.TryGetValue("compileErrorCount", out errorCount) || !(errorCount is long) || (long)errorCount < 0 || (long)errorCount > 1000000
+                        || !root.TryGetValue("compileWarningCount", out warningCount) || !(warningCount is long) || (long)warningCount < 0 || (long)warningCount > 1000000
+                        || !root.TryGetValue("compileInfoCount", out infoCount) || !(infoCount is long) || (long)infoCount < 0 || (long)infoCount > 1000000
+                        || !root.TryGetValue("compileDiagnosticsTruncated", out truncated) || !(truncated is long) || (long)truncated < 0 || (long)truncated > 1000000
+                        || !root.TryGetValue("stableFrames", out stableFrames) || !(stableFrames is long) || (long)stableFrames < 0
+                        || !IsSha256(Text(root, "beforeSourceFingerprint")) || !IsSha256(Text(root, "beforeDependencyVersion")))
+                        throw new InvalidDataException("Refresh active root fields are invalid.");
+                    if (!string.Equals(Text(root, "rootContractDigest"), RefreshRootContractDigest(root), StringComparison.Ordinal))
+                        throw new InvalidDataException("Refresh immutable root contract changed.");
+                    UnityCliCompileCoordinator.ValidateBoundedDiagnostics(root, "compileDiagnostics", "compileErrorCount", "compileWarningCount", "compileInfoCount", "compileDiagnosticsTruncated", true);
+                    var compilePhase = Text(root, "compilePhase");
+                    if (Array.IndexOf(new[] { "idle", "dispatching", "awaiting_started", "compiling", "cycle_finished" }, compilePhase) < 0)
+                        throw new InvalidDataException("Refresh compile phase is invalid.");
+                    var refreshFenced = HasExactEffectFence("refresh", root, "refresh-dispatch");
+                    var phase = Text(root, "phase");
+                    if ((phase == "queued" || phase == "prepared") == refreshFenced)
+                        throw new InvalidDataException("Refresh effect fence is inconsistent with phase.");
+                    var compileFenced = HasExactEffectFence("refresh", root, "compile-dispatch");
+                    if ((compilePhase == "idle") == compileFenced)
+                        throw new InvalidDataException("Refresh compile fence is inconsistent with phase.");
+                    if (Bool(root, "compilationObserved")
+                        && (Long(root, "compileStartedCycle") <= 0 || Long(root, "compileStartedSequence") <= Long(root, "compileDispatchSequence")))
+                        throw new InvalidDataException("Refresh compile attribution is invalid.");
+                }
+
+                private static string RefreshRootContractDigest(Dictionary<string, object> root)
+                {
+                    return UnityCliSerializer.Sha256Canonical(new Dictionary<string, object>
+                    {
+                        { "compile", root["compile"] }, { "beforeSourceFingerprint", root["beforeSourceFingerprint"] }, { "beforeDependencyVersion", root["beforeDependencyVersion"] }
+                    });
+                }
+
+                protected override object Planned(object value)
+                {
+                    var args = (Args)value;
+                    var effects = new List<object> { new Dictionary<string, object> { { "type", "asset-refresh" } } };
+                    if (args.Compile) effects.Add(new Dictionary<string, object> { { "type", "script-compile" } });
+                    return new Dictionary<string, object> { { "dryRun", true }, { "plannedEffects", effects } };
+                }
+                protected override Dictionary<string, object> CreateRoot(BridgeRequest request, string digest, object value)
+                {
+                    var args = (Args)value;
+                    var before = CaptureProof();
+                    var root = new Dictionary<string, object> { { "requestId", request.RequestId }, { "editorSessionId", EditorSessionId() }, { "requestDigest", digest }, { "deadline", request.Execution.AbsoluteDeadlineUtc }, { "phase", "queued" }, { "compile", args.Compile }, { "compilationRequested", false }, { "compilationObserved", false }, { "compilePhase", "idle" }, { "compileDispatchSequence", 0L }, { "compileStartedSequence", 0L }, { "compileFinishedSequence", 0L }, { "compileStartedCycle", 0L }, { "compileDiagnostics", new List<object>() }, { "compileErrorCount", 0L }, { "compileWarningCount", 0L }, { "compileInfoCount", 0L }, { "compileDiagnosticsTruncated", 0L }, { "stableFrames", 0L }, { "beforeSourceFingerprint", before.SourceFingerprint }, { "beforeDependencyVersion", before.DependencyVersion } };
+                    root["rootContractDigest"] = RefreshRootContractDigest(root);
+                    return root;
+                }
+                protected override void OnTick(Dictionary<string, object> root)
+                {
+                    if (UnityCliCompilationEventBroker.SequenceCorrupt && Bool(root, "compile")) { Fail(root, "E_EXECUTION_TIMEOUT", "Refresh compilation event sequence is corrupt; attributed outcome is unknown."); return; }
+                    var phase = Text(root, "phase");
+                    if (phase == "queued") { if (BusyEditor()) return; Update(x => x["phase"] = "prepared"); return; }
+                    if (phase == "prepared") { root = CrossEffectFence(root, "refresh-dispatch", "dispatching"); try { AssetDatabase.Refresh(); Update(x => x["phase"] = "refresh_returned"); } catch (Exception e) { Fail(root, "E_EXECUTION_TIMEOUT", "Refresh result cannot be confirmed: " + e.Message + "; check the business state."); } return; }
+                    if (phase == "refresh_returned")
+                    {
+                        if (Bool(root, "compile") && !Bool(root, "compilationObserved") && !Bool(root, "compilationRequested")) { if (BusyEditor()) return; UnityCliCompileCoordinator.RequestRefreshCompilation(Text(root, "requestId"), Text(root, "requestDigest")); return; }
+                        Update(x => x["phase"] = "waiting_stable"); return;
+                    }
+                    if (phase != "waiting_stable" || BusyEditor()) return;
+                    if (Bool(root, "compile") && (!Bool(root, "compilationObserved") || Text(root, "compilePhase") != "cycle_finished")) { Fail(root, "E_EXECUTION_TIMEOUT", "Refresh compilation result cannot be confirmed; check the business state."); return; }
+                    if (Long(root, "compileErrorCount") > 0)
+                    {
+                        var details = new Dictionary<string, object>
+                        {
+                            { "compile", new Dictionary<string, object> { { "completed", true }, { "errorCount", Long(root, "compileErrorCount") }, { "warningCount", Long(root, "compileWarningCount") }, { "status", "errors" }, { "diagnosticsTruncated", Long(root, "compileDiagnosticsTruncated") } } },
+                            { "diagnostics", root["compileDiagnostics"] }
+                        };
+                        Fail(root, "E_UNITY_COMPILE_FAILED", "Refresh compilation reported compiler errors.", details, new[] { "Fix the listed compiler diagnostics before retrying refresh." }); return;
+                    }
+                    var frames = Long(root, "stableFrames") + 1; Update(x => x["stableFrames"] = frames); if (frames >= 3) Succeed(root);
+                }
+                protected override object BuildSuccessData(Dictionary<string, object> root)
+                {
+                    var after = CaptureProof();
+                    var changed = !Same(Text(root, "beforeSourceFingerprint"), after.SourceFingerprint) || !Same(Text(root, "beforeDependencyVersion"), after.DependencyVersion);
+                    return new Dictionary<string, object>
+                    {
+                        { "changed", changed }, { "compilationTriggered", Bool(root, "compilationObserved") },
+                        { "sourceFileCount", (long)after.Paths.Count }, { "sourceFingerprint", after.SourceFingerprint }, { "dependencyVersion", after.DependencyVersion },
+                        { "editorState", new Dictionary<string, object> { { "status", "ready" }, { "compile", false }, { "import", false } } }
+                    };
+                }
+                private sealed class Proof { internal List<string> Paths; internal string SourceFingerprint; internal string DependencyVersion; }
+                /// <summary>Refresh 的业务证明：Assets 全量文件指纹 + AssetDatabase 依赖哈希版本。</summary>
+                private static Proof CaptureProof()
+                {
+                    var rootPath = Path.Combine(ProjectRoot(), "Assets");
+                    var files = Directory.Exists(rootPath) ? Directory.GetFiles(rootPath, "*", SearchOption.AllDirectories).OrderBy(path => path, StringComparer.Ordinal).ToArray() : new string[0];
+                    var lines = new List<string>(); var paths = new List<string>(); var dependencies = new List<string>();
+                    foreach (var file in files)
+                    {
+                        var relative = "Assets/" + Path.GetRelativePath(rootPath, file).Replace('\\', '/');
+                        var info = new FileInfo(file);
+                        paths.Add(relative);
+                        lines.Add(relative + "\0" + info.Length.ToString(CultureInfo.InvariantCulture) + "\0" + info.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture) + "\0" + HashFile(file));
+                        if (!relative.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)) dependencies.Add(relative + "\0" + AssetDatabase.GetAssetDependencyHash(relative).ToString());
+                    }
+                    return new Proof { Paths = paths, SourceFingerprint = Sha256Hex(Encoding.UTF8.GetBytes(string.Join("\n", lines))), DependencyVersion = Sha256Hex(Encoding.UTF8.GetBytes(string.Join("\n", dependencies))) };
+                }
+                private static string HashFile(string path) { using (var sha = System.Security.Cryptography.SHA256.Create()) using (var stream = File.OpenRead(path)) return BitConverter.ToString(sha.ComputeHash(stream)).Replace("-", "").ToLowerInvariant(); }
+                private static bool BusyEditor() { return EditorApplication.isUpdating || EditorApplication.isCompiling || BuildPipeline.isBuildingPlayer || IsPlayModeChanging(); }
+                private static bool Same(string left, string right) { return !string.IsNullOrEmpty(left) && string.Equals(left, right, StringComparison.Ordinal); }
+                private sealed class Args { public bool Compile { get; set; } public string ExpectedEditorSessionId { get; set; } }
+            }
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Infrastructure/UnityCliLog.cs

@@ -0,0 +1,127 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace UnityCli
+{
+    public static partial class UnityCliBridge
+    {
+        // Bridge 日志位于项目临时根 Library/UnityCli/，超上限滚动一次，只保留当前与上一段，大小有界。
+        private const long BridgeLogMaxBytes = 10L * 1024 * 1024;
+        private const int BridgeLogMaxEntryBytes = 64 * 1024;
+
+        private static string LogPath()
+        {
+            return Path.Combine(UnityCliTempRoot(), "UnityCliBridge.log");
+        }
+
+        private static string RuntimeDiagnosticsPath()
+        {
+            return Path.Combine(UnityCliTempRoot(), "UnityCliBridgeRuntime.json");
+        }
+
+        /// <summary>项目内临时根：Library/UnityCli/（AGENTS.md《临时文件与机制状态》约定的项目临时区）。</summary>
+        internal static string UnityCliTempRoot()
+        {
+            return Path.Combine(ProjectRoot(), "Library", "UnityCli");
+        }
+
+        // current与old始终各不超过10MiB；incoming-aware滚动避免单条追加越过上限。
+        private static void RollBridgeLogIfNeeded(string path, int incomingBytes)
+        {
+            try
+            {
+                var oldPath = path + ".old";
+                TrimBridgeLogSegment(oldPath);
+                TrimBridgeLogSegment(path);
+                if (!File.Exists(path) || new FileInfo(path).Length + incomingBytes <= BridgeLogMaxBytes) return;
+                File.Copy(path, oldPath, true);
+                TrimBridgeLogSegment(oldPath);
+                File.WriteAllText(path, string.Empty, new UTF8Encoding(false));
+            }
+            catch { }
+        }
+
+        // 对升级前或异常单条形成的oversize段保留最新UTF-8后缀，恢复固定绝对上界。
+        private static void TrimBridgeLogSegment(string path)
+        {
+            if (!File.Exists(path) || new FileInfo(path).Length <= BridgeLogMaxBytes) return;
+            var text = File.ReadAllText(path, Encoding.UTF8);
+            var low = 0;
+            var high = text.Length;
+            while (low < high)
+            {
+                var middle = low + (high - low) / 2;
+                if (Encoding.UTF8.GetByteCount(text.Substring(middle)) <= BridgeLogMaxBytes) high = middle;
+                else low = middle + 1;
+            }
+            if (low < text.Length && char.IsLowSurrogate(text[low])) low++;
+            File.WriteAllText(path, text.Substring(low), new UTF8Encoding(false));
+        }
+
+        // 单条日志使用固定UTF-8预算，禁止异常文本或输入派生消息制造无界段。
+        private static string BoundedBridgeLogLine(string value, int maxBytes)
+        {
+            value = value ?? string.Empty;
+            if (Encoding.UTF8.GetByteCount(value) <= maxBytes) return value;
+            var low = 0;
+            var high = Math.Min(value.Length, maxBytes);
+            while (low < high)
+            {
+                var middle = low + (high - low + 1) / 2;
+                if (Encoding.UTF8.GetByteCount(value.Substring(0, middle)) <= maxBytes) low = middle;
+                else high = middle - 1;
+            }
+            if (low > 0 && char.IsHighSurrogate(value[low - 1])) low--;
+            return value.Substring(0, low);
+        }
+
+        private static void WriteRuntimeLoadDiagnostics(string phase)
+        {
+            try
+            {
+                var path = RuntimeDiagnosticsPath();
+                Directory.CreateDirectory(Path.GetDirectoryName(path));
+                // 诊断文件是实际 artifact 边界，因此在此处进行唯一一次序列化。
+                File.WriteAllText(path, UnityCliSerializer.Serialize(RuntimeDiagnosticsData(phase)));
+                WriteLog("bridge_runtime_loaded phase=" + phase + " listenerId=" + ListenerId + " diagnosticsFingerprint=" + BridgeDiagnosticsFingerprint + " assemblyMvid=" + AssemblyMvid() + " packageName=" + BridgePackageName() + " packageAssetPath=" + BridgePackageAssetPath() + " packageResolvedPath=" + BridgePackageResolvedPath());
+            }
+            catch (Exception exception)
+            {
+                WriteLog("bridge_runtime_diagnostics_failed " + exception.GetType().Name + ": " + exception.Message);
+            }
+        }
+
+        private static Dictionary<string, object> RuntimeDiagnosticsData(string phase)
+        {
+            return new Dictionary<string, object>
+            {
+                { "ok", true }, { "phase", phase }, { "diagnosticsFingerprint", BridgeDiagnosticsFingerprint }, { "listenerId", ListenerId },
+                { "loadedAt", BridgeLoadedAtUtc.ToString("O", CultureInfo.InvariantCulture) }, { "bridgeLogPath", LogPath() }, { "port", (long)port },
+                { "assembly", new Dictionary<string, object> { { "fullName", typeof(UnityCliBridge).Assembly.FullName }, { "location", AssemblyLocation(typeof(UnityCliBridge).Assembly) }, { "moduleVersionId", AssemblyMvid() } } },
+                { "package", new Dictionary<string, object> { { "name", BridgePackageName() }, { "assetPath", BridgePackageAssetPath() }, { "resolvedPath", BridgePackageResolvedPath() } } }
+            };
+        }
+
+        private static void WriteLog(string line)
+        {
+            try
+            {
+                var path = LogPath();
+                Directory.CreateDirectory(Path.GetDirectoryName(path));
+                var prefix = DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture) + " ";
+                var suffix = Environment.NewLine;
+                var lineBudget = BridgeLogMaxEntryBytes - Encoding.UTF8.GetByteCount(prefix + suffix);
+                var entry = prefix + BoundedBridgeLogLine(line, lineBudget) + suffix;
+                var incomingBytes = Encoding.UTF8.GetByteCount(entry);
+                RollBridgeLogIfNeeded(path, incomingBytes);
+                File.AppendAllText(path, entry, new UTF8Encoding(false));
+            }
+            catch { }
+        }
+    }
+}
+#endif