@alpsckr/unitycli 0.4.2 → 0.4.4

package/unitypkg/Editor/Infrastructure/UnityCliPackageResolveCoordinator.cs

@@ -36,14 +36,14 @@ namespace UnityCli
                 protected override string StartCommand { get { return Command; } }
                 protected override string StatusCommand { get { return UnityCliPackageResolveCoordinator.StatusCommand; } }
                 protected override string OperationDisplayName { get { return "Package root"; } }
-                protected override IEnumerable<(string name, bool destructive)> AdditionalCommands
+                protected override IEnumerable<(string name, bool destructive, UnityCliBridgeQueuePolicy.WorkClass queueClass)> AdditionalCommands
                 {
                     get
                     {
-                        yield return (ClaimFilesCommand, true);
-                        yield return (CommitFilesCommand, true);
-                        yield return (ProveFilesCommand, true);
-                        yield return (FailFilesCommand, true);
+                        yield return (ClaimFilesCommand, true, UnityCliBridgeQueuePolicy.WorkClass.Control);
+                        yield return (CommitFilesCommand, true, UnityCliBridgeQueuePolicy.WorkClass.Control);
+                        yield return (ProveFilesCommand, true, UnityCliBridgeQueuePolicy.WorkClass.Control);
+                        yield return (FailFilesCommand, true, UnityCliBridgeQueuePolicy.WorkClass.Control);
                     }
                 }
                 protected override object DeserializeStartArgs(BridgeRequest request) { return request.DeserializeArgs<StartArgs>(); }
@@ -70,7 +70,7 @@ namespace UnityCli
                     }
                     catch (BridgeCommandException exception) { return SerializeBridgeExceptionEnvelope(request.RequestId, exception); }
                 }
-                internal override void Tick() { TickPackageRoots(); }
+                internal override void Tick() { if (RetryAdmissionOwnerRecoveryMarker()) return; TickPackageRoots(); }
             }
 
             internal static bool IsCommand(string command)
@@ -136,29 +136,28 @@ namespace UnityCli
 
             private static async Task<string> ExecuteStart(BridgeRequest request, byte[] raw, Func<bool> accept, CancellationToken cancellationToken)
             {
+                var leaseHeld = false;
                 var newlyAcquiredLease = false;
                 var requestDigest = UnityCliRequestDigest.Compute(raw, request.InstanceId);
                 try
                 {
                     var args = request.DeserializeArgs<StartArgs>();
                     ValidateStart(args);
+                    UnityCliToolCompletionContract contract;
+                    if (!UnityCliToolCompletionRegistry.TryGetPackageRoot(args.Operation, out contract))
+                        throw new BridgeCommandException("E_SCHEMA_INVALID", "Unsupported package root operation.");
                     object cachedTerminal;
                     if (UnityCliActiveOperation.TryGetTerminal(ActiveScope, request.RequestId, requestDigest, out cachedTerminal))
                     {
-                        try { UnityCliActiveOperation.BeginExactTerminalCleanup(ActiveScope, request.RequestId, requestDigest); } catch { }
+                        try { UnityCliActiveOperation.BeginExactTerminalCleanup(ActiveScope, request.RequestId, requestDigest, ProductionQueueState); } catch { }
                         return StartTerminal(request.RequestId, cachedTerminal);
                     }
                     if (!UnityCliSessionMutationLease.TryAcquire(request.RequestId, requestDigest, out newlyAcquiredLease)) return BusyEnvelope(request.RequestId);
+                    leaseHeld = true;
                     PackageActiveDecision decision;
-                    try
-                    {
-                        UnityCliToolCompletionContract contract;
-                        if (!UnityCliToolCompletionRegistry.TryGetPackageRoot(args.Operation, out contract)) throw new BridgeCommandException("E_SCHEMA_INVALID", "Unsupported package root operation.");
-                        decision = AcceptPackageActiveOperation(request, raw, contract, newlyAcquiredLease,
-                            () => { if (accept == null || !accept()) throw new OperationCanceledException(); },
-                            () => ValidateStart(args), root => InitializeRoot(root, args));
-                    }
-                    catch { if (newlyAcquiredLease) UnityCliSessionMutationLease.Release(request.RequestId, requestDigest); throw; }
+                    decision = AcceptPackageActiveOperation(request, raw, contract, newlyAcquiredLease,
+                        () => { if (accept == null || !accept()) throw new OperationCanceledException(); },
+                        () => ValidateStart(args), root => InitializeRoot(root, args));
                     if (decision.TerminalEnvelope != null)
                     {
                         UnityCliSessionMutationLease.Release(request.RequestId, requestDigest);
@@ -172,7 +171,108 @@ namespace UnityCli
                     await Task.FromResult(0);
                     return UnityCliSerializer.Serialize(StartState(request.RequestId));
                 }
-                catch (BridgeCommandException exception) { return SerializeBridgeExceptionEnvelope(request.RequestId, exception); }
+                catch (BridgeCommandException exception) { return FinishStartFault(ProductionQueueState, request, requestDigest, leaseHeld, newlyAcquiredLease, exception); }
+                catch (Exception exception) { return FinishStartFault(ProductionQueueState, request, requestDigest, leaseHeld, newlyAcquiredLease, exception); }
+            }
+
+            private static string FinishStartFault(BridgeQueueState state, BridgeRequest request, string requestDigest, bool leaseHeld, bool newlyAcquiredLease, Exception exception)
+            {
+                var normalized = NormalizePackageStartFault(exception);
+                if (!leaseHeld) return SerializeBridgeExceptionEnvelope(request.RequestId, normalized);
+                ActivePackageOperationRecord root;
+                try { root = LoadPackageActiveOperation(); }
+                catch
+                {
+                    if (!RetainPackageAdmissionRecovery(state, request.RequestId, requestDigest))
+                        return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package recovery owner could not be frozen after an unreadable root."));
+                    try
+                    {
+                        var unknown = ProtocolEnvelopeFactory.Error(request.RequestId, "E_EXECUTION_TIMEOUT", "Package active state is unreadable after root publication; outcome is unknown.", null, new[] { "Inspect Package Manager and package files before submitting another mutation." });
+                        var first = UnityCliActiveOperation.StoreTerminalFirst(ActiveScope, request.RequestId, requestDigest, unknown);
+                        UnityCliActiveOperation.BeginExactTerminalCleanup(ActiveScope, request.RequestId, requestDigest, state);
+                        return StartTerminal(request.RequestId, first);
+                    }
+                    catch
+                    {
+                        return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package root fault cleanup remains pending because the exact active state is unreadable."));
+                    }
+                }
+                if (root != null)
+                {
+                    if (!string.Equals(root.RequestId, request.RequestId, StringComparison.Ordinal)
+                        || !string.Equals(root.RequestDigest, requestDigest, StringComparison.Ordinal))
+                        return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package root fault conflicts with another exact active identity; cleanup is blocked."));
+                    if (!RetainPackageAdmissionRecovery(state, request.RequestId, requestDigest))
+                        return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package recovery owner could not be frozen after root publication."));
+                    try
+                    {
+                        object first;
+                        if (IsTerminal(root)) first = root.TerminalEnvelope;
+                        else if (root.StartedAt.HasValue || root.Phase == "effect_started" || root.Phase == "effect_proven")
+                        {
+                            TerminalTimeout(root, "Package operation failed after its effect barrier: " + exception.GetType().Name + ".");
+                            first = RequiredRoot(request.RequestId).TerminalEnvelope;
+                        }
+                        else
+                        {
+                            var terminal = PackageStartFaultTerminal(request.RequestId, exception);
+                            first = PersistPackageTerminal(request.RequestId, terminal, "failed");
+                        }
+                        return StartTerminal(request.RequestId, first);
+                    }
+                    catch
+                    {
+                        return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package first-terminal cleanup remains pending after a root-created fault."));
+                    }
+                }
+                if (!newlyAcquiredLease)
+                {
+                    if (!RetainPackageAdmissionRecovery(state, request.RequestId, requestDigest))
+                        return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package pre-existing lease owner could not be frozen for recovery."));
+                    return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package has an exact pre-existing lease without a readable root; cleanup is blocked."));
+                }
+                try { UnityCliSessionMutationLease.Release(request.RequestId, requestDigest); } catch { }
+                bool isOwned;
+                if (UnityCliSessionMutationLease.TryIsOwnedBy(request.RequestId, requestDigest, out isOwned) && !isOwned)
+                    return SerializeBridgeExceptionEnvelope(request.RequestId, normalized);
+                try { UnityCliActiveOperation.BeginExactTerminalCleanup(ActiveScope, request.RequestId, requestDigest); } catch { }
+                return SerializeBridgeExceptionEnvelope(request.RequestId, new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package was rejected before its durable root, but exact lease cleanup remains pending."));
+            }
+
+            private static bool RetainPackageAdmissionRecovery(BridgeQueueState state, string requestId, string requestDigest)
+            {
+                try
+                {
+                    var owner = CaptureAdmissionOwner(state, requestId, requestDigest);
+                    if (owner.OwnerState == UnityCliAdmissionPool.AdmissionOwnerState.Recovery
+                        || owner.OwnerState == UnityCliAdmissionPool.AdmissionOwnerState.TerminalCleanup) return true;
+                    if (owner.OwnerState != UnityCliAdmissionPool.AdmissionOwnerState.WorkItem) return false;
+                    PersistAdmissionOwnerTransfer(state, ActiveScope + "-admission-owner", new Dictionary<string, object>
+                    {
+                        { "requestId", requestId }, { "requestDigest", requestDigest }, { "editorSessionId", EditorSessionId() }
+                    }, owner, UnityCliAdmissionPool.AdmissionOwnerState.Recovery);
+                    return true;
+                }
+                catch { return false; }
+            }
+
+            private static object PackageStartFaultTerminal(string requestId, Exception exception)
+            {
+                var bridge = exception as BridgeCommandException;
+                if (bridge != null)
+                    return ProtocolEnvelopeFactory.Error(requestId, bridge.Code, bridge.Message, bridge.Details, bridge.NextActions, bridge.Transient, bridge.RetryAfterMs);
+                if (exception is OperationCanceledException)
+                    return ProtocolEnvelopeFactory.Error(requestId, "E_EXECUTION_TIMEOUT", "Package operation did not begin before the request deadline.");
+                return ProtocolEnvelopeFactory.Error(requestId, "E_BRIDGE_COMMAND_FAILED", exception.Message, null, new[] { "Check Unity Console and UnityCliBridge.log." });
+            }
+
+            private static BridgeCommandException NormalizePackageStartFault(Exception exception)
+            {
+                return exception is BridgeCommandException
+                    ? (BridgeCommandException)exception
+                    : exception is OperationCanceledException
+                        ? new BridgeCommandException("E_EXECUTION_TIMEOUT", "Package operation did not begin before the request deadline.")
+                        : new BridgeCommandException("E_BRIDGE_COMMAND_FAILED", exception.Message, "Check Unity Console and UnityCliBridge.log.");
             }
 
             private static string CurrentReloadEpoch()
@@ -215,7 +315,7 @@ namespace UnityCli
                         && root.TerminalEnvelope != null)
                     {
                         var selector = UnityCliSerializer.Sha256Canonical(root.PackageOperation["input"]);
-                        terminal = UnityCliActiveOperation.StoreTerminalFirst(ActiveScope, root.RequestId, root.RequestDigest, selector, root.TerminalEnvelope);
+                        terminal = UnityCliActiveOperation.StoreTerminalFirst(ActiveScope, root.RequestId, root.RequestDigest, selector, Text(root.PackageOperation, "operation"), root.TerminalEnvelope);
                     }
                     if (terminal != null) UnityCliActiveOperation.BeginExactTerminalCleanup(ActiveScope, root.RequestId, root.RequestDigest);
                 }

package/unitypkg/Editor/Infrastructure/UnityCliPackageResolveState.cs

@@ -374,6 +374,25 @@ namespace UnityCli
                 if (root == null || !string.Equals(root.RequestId, requestId, StringComparison.Ordinal)) throw new BridgeCommandException("E_REQUEST_NOT_FOUND", "Package active operation was not found.");
                 return root;
             }
+
+            /// <summary>域status按公开root requestId读取active或terminal，并拒绝活跃请求的跨operation查询。</summary>
+            internal static object ReadPublicStatus(string requestId, string expectedOperation)
+            {
+                string requestDigest;
+                object terminal;
+                string statusDomain;
+                if (UnityCliActiveOperation.TryGetTerminalByRequestId(ActiveScope, requestId, out requestDigest, out statusDomain, out terminal))
+                {
+                    if (!string.IsNullOrEmpty(statusDomain) && !string.Equals(statusDomain, expectedOperation, StringComparison.Ordinal))
+                        throw new BridgeCommandException("E_REQUEST_NOT_FOUND", "The requested Package operation was not found in this status domain.");
+                    return UnityCliDurableStatusCoordinator.Terminal(requestId, terminal);
+                }
+                var root = RequiredRoot(requestId);
+                var operation = Text(root.PackageOperation, "operation");
+                if (!string.Equals(operation, expectedOperation, StringComparison.Ordinal))
+                    throw new BridgeCommandException("E_REQUEST_NOT_FOUND", "The requested Package operation was not found in this status domain.");
+                return UnityCliDurableStatusCoordinator.Running(requestId, Text(root.PackageOperation, "phase"));
+            }
             private static List<ActivePackageOperationRecord> OpenRoots()
             {
                 var root = LoadPackageActiveOperation();
@@ -455,7 +474,7 @@ namespace UnityCli
                 root.State = state; root.Phase = "result_persisted"; root.TerminalEnvelope = envelope;
                 SavePackageActiveOperation(root);
                 var selectorDigest = UnityCliSerializer.Sha256Canonical(root.PackageOperation["input"]);
-                var first = UnityCliActiveOperation.StoreTerminalFirst(ActiveScope, root.RequestId, root.RequestDigest, selectorDigest, envelope);
+                var first = UnityCliActiveOperation.StoreTerminalFirst(ActiveScope, root.RequestId, root.RequestDigest, selectorDigest, Text(root.PackageOperation, "operation"), envelope);
                 root.TerminalEnvelope = first;
                 TerminalRoots[requestId] = root;
                 UnityCliActiveOperation.BeginExactTerminalCleanup(ActiveScope, root.RequestId, root.RequestDigest);

package/unitypkg/Editor/Infrastructure/UnityCliReadGeneration.cs

@@ -0,0 +1,97 @@
+#if UNITY_EDITOR
+using System;
+using System.Globalization;
+using System.Threading;
+using ReflectionAssembly = System.Reflection.Assembly;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    public static partial class UnityCliBridge
+    {
+        /// <summary>listener id 每次 domain reload 都变化，确保旧 domain 的只读游标不能碰撞复用。</summary>
+        internal static string ReadGenerationIdentity()
+        {
+            return EditorSessionId() + "\0" + ListenerId + "\0" + CurrentListenerGeneration().ToString(CultureInfo.InvariantCulture);
+        }
+    }
+
+    /// <summary>为只读 continuation 提供 Unity-owned generation；层级或程序集变化立即使旧游标失效。</summary>
+    [InitializeOnLoad]
+    internal static class UnityCliReadGeneration
+    {
+        private static long hierarchyGeneration = 1L;
+        private static long reflectionGeneration = 1L;
+
+        static UnityCliReadGeneration()
+        {
+            EditorApplication.hierarchyChanged += InvalidateHierarchy;
+            EditorApplication.projectChanged += InvalidateHierarchy;
+            EditorApplication.playModeStateChanged += delegate { InvalidateHierarchy(); };
+            CompilationPipeline.compilationFinished += delegate { InvalidateReflection(); };
+            AssemblyReloadEvents.beforeAssemblyReload += InvalidateReflection;
+            AppDomain.CurrentDomain.AssemblyLoad += delegate { InvalidateReflection(); };
+        }
+
+        internal static string Hierarchy(Scene scene)
+        {
+            return UnityCliContinuationToken.Fingerprint(
+                UnityCliBridge.ReadGenerationIdentity() + "\0" + scene.handle.ToString(CultureInfo.InvariantCulture) + "\0" + Interlocked.Read(ref hierarchyGeneration).ToString(CultureInfo.InvariantCulture));
+        }
+
+        internal static string Reflection()
+        {
+            return UnityCliContinuationToken.Fingerprint(
+                UnityCliBridge.ReadGenerationIdentity() + "\0" + Interlocked.Read(ref reflectionGeneration).ToString(CultureInfo.InvariantCulture));
+        }
+
+        internal static string Session(string scope)
+        {
+            return UnityCliContinuationToken.Fingerprint(UnityCliBridge.ReadGenerationIdentity() + "\0" + (scope ?? string.Empty));
+        }
+
+        internal static void InvalidateHierarchy()
+        {
+            Interlocked.Increment(ref hierarchyGeneration);
+        }
+
+        internal static void InvalidateReflection()
+        {
+            Interlocked.Increment(ref reflectionGeneration);
+        }
+    }
+
+    /// <summary>AppDomain没有逐项程序集API；每个reflection generation仅创建一次有1024项硬上限的snapshot。</summary>
+    internal static class UnityCliAssemblySnapshot
+    {
+        private const int MaximumAssemblies = 1024;
+        private static readonly object SnapshotLock = new object();
+        private static string generation;
+        private static ReflectionAssembly[] assemblies;
+
+        internal static ReflectionAssembly[] Get(UnityCliRequestBudget budget)
+        {
+            if (budget == null) throw new ArgumentNullException("budget");
+            var currentGeneration = UnityCliReadGeneration.Reflection();
+            ReflectionAssembly[] snapshot;
+            lock (SnapshotLock)
+            {
+                if (assemblies == null || !string.Equals(generation, currentGeneration, StringComparison.Ordinal))
+                {
+                    if (!budget.TryConsumeReflectionCall()) throw new UnityCliRequestBudgetExceededException(budget.ExhaustedDimension);
+                    snapshot = AppDomain.CurrentDomain.GetAssemblies();
+                    if (snapshot.Length > MaximumAssemblies)
+                        throw new UnityCliBridge.BridgeCommandException("E_REFLECTION_LIMIT_EXCEEDED", "Loaded assembly count exceeds the 1024-item reflection snapshot bound.", "Reduce loaded assemblies before retrying the bounded reflection request.");
+                    assemblies = snapshot;
+                    generation = currentGeneration;
+                }
+                snapshot = assemblies;
+            }
+            if (!budget.TryConsumeScannedRecords(snapshot.Length)) throw new UnityCliRequestBudgetExceededException(budget.ExhaustedDimension);
+            return snapshot;
+        }
+    }
+}
+#endif