@alpsckr/unitycli 0.4.0 → 0.4.2

package/unitypkg/Editor/Infrastructure/UnityCliInstanceRegistry.cs

@@ -20,6 +20,8 @@ namespace UnityCli
     public static partial class UnityCliBridge
     {
         private const int RegistryMutexTimeoutMs = 5000;
+        private const long RegistryMaxBytes = 1024L * 1024L;
+        private const int RegistryPublicationMaxAttempts = 4;
         private const uint MutexAllAccess = 0x001F0001;
         private const uint WaitObject0 = 0x00000000;
         private const uint WaitAbandoned = 0x00000080;
@@ -34,6 +36,11 @@ namespace UnityCli
         private static string lastRegistrationSignature;
         private static long listenerGeneration;
         private static long publicationSequence;
+        private static bool registryPublicationRetryPending;
+        private static bool registryPublicationRetryExhausted;
+        private static int registryPublicationAttemptCount;
+        private static double nextRegistryPublicationRetryAt;
+        private static string pendingRegistryRequestedState;
 
         /// <summary>当前 listener generation 只用于 transport attestation 与 registry 内部一致性校验。</summary>
         private static long CurrentListenerGeneration()
@@ -182,8 +189,8 @@ namespace UnityCli
             }
         }
 
-        /// <summary>在 native current-user DACL named mutex 内执行临界区；abandoned 表示已取得所有权。</summary>
-        private static void WithCurrentUserMutex(string name, int timeoutMs, Action action)
+        /// <summary>在native current-user DACL named mutex内尝试临界区；timeout不执行action。</summary>
+        private static bool TryWithCurrentUserMutex(string name, int timeoutMs, Action action)
         {
             if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Mutex name is required.", "name");
             if (action == null) throw new ArgumentNullException("action");
@@ -207,12 +214,13 @@ namespace UnityCli
                 if (handle == IntPtr.Zero || handle == new IntPtr(-1))
                     throw new Win32Exception(Marshal.GetLastWin32Error(), "Could not create the current-user mutex.");
 
-                var wait = WaitForSingleObject(handle, (uint)timeoutMs);
-                if (wait == WaitTimeout) throw new TimeoutException("Timed out waiting for current-user mutex.");
+                var wait = WaitForSingleObject(handle, (uint)Math.Max(0, timeoutMs));
+                if (wait == WaitTimeout) return false;
                 if (wait == WaitFailed) throw new Win32Exception(Marshal.GetLastWin32Error(), "Could not wait for current-user mutex.");
                 if (wait != WaitObject0 && wait != WaitAbandoned) throw new InvalidOperationException("Unexpected current-user mutex wait result: " + wait.ToString(CultureInfo.InvariantCulture));
                 acquired = true;
                 action();
+                return true;
             }
             finally
             {
@@ -222,6 +230,12 @@ namespace UnityCli
             }
         }
 
+        /// <summary>需要锁的业务写入保留原超时异常语义。</summary>
+        private static void WithCurrentUserMutex(string name, int timeoutMs, Action action)
+        {
+            if (!TryWithCurrentUserMutex(name, timeoutMs, action)) throw new TimeoutException("Timed out waiting for current-user mutex.");
+        }
+
         /// <summary>保留 registry 原有锁名、超时和调用语义。</summary>
         private static void WithRegistryMutex(Action action)
         {
@@ -263,17 +277,84 @@ namespace UnityCli
             }
         }
 
-        /// <summary>写入或更新当前 editor session claim；同 identity 的其他存活 claim 必须保留以形成 conflict。</summary>
+        /// <summary>请求当前状态发布；已有失败链只更新最新状态，不创建第二条重试链。</summary>
         private static bool RegisterInstance(string requestedState)
         {
+            if (registryPublicationRetryExhausted) return false;
+            if (registryPublicationRetryPending)
+            {
+                pendingRegistryRequestedState = requestedState;
+                return false;
+            }
+            return AttemptInstancePublication(requestedState);
+        }
+
+        /// <summary>中央update入口推进唯一重试链；达到上限后本次domain不再后台尝试。</summary>
+        private static void TickInstancePublicationRetry()
+        {
+            if (!registryPublicationRetryPending || registryPublicationRetryExhausted || !started || domainReloading) return;
+            if (EditorApplication.timeSinceStartup < nextRegistryPublicationRetryAt) return;
+            var requestedState = pendingRegistryRequestedState;
+            registryPublicationRetryPending = false;
+            pendingRegistryRequestedState = null;
+            AttemptInstancePublication(string.IsNullOrEmpty(requestedState) ? "ready" : requestedState);
+        }
+
+        /// <summary>listener停止或domain结束时清空本次启动的重试状态。</summary>
+        private static void CancelInstancePublicationRetry()
+        {
+            registryPublicationRetryPending = false;
+            registryPublicationRetryExhausted = false;
+            registryPublicationAttemptCount = 0;
+            nextRegistryPublicationRetryAt = 0;
+            pendingRegistryRequestedState = null;
+        }
+
+        /// <summary>执行一次写入；只对文件、权限或锁类短暂失败安排有限重试。</summary>
+        private static bool AttemptInstancePublication(string requestedState)
+        {
+            Exception failure;
+            if (TryRegisterInstance(requestedState, out failure))
+            {
+                var recoveredAttempts = registryPublicationAttemptCount;
+                CancelInstancePublicationRetry();
+                if (recoveredAttempts > 0)
+                    WriteLog("instance_publication_retry_succeeded attempts=" + (recoveredAttempts + 1).ToString(CultureInfo.InvariantCulture));
+                return true;
+            }
+
+            registryPublicationAttemptCount += 1;
+            var failureKind = RegistryPublicationFailureKind(failure);
+            var retryable = IsRetryableRegistryPublicationFailure(failure);
+            WriteLog("instance_register_failed kind=" + failureKind + " retryable=" + (retryable ? "true" : "false") + " attempt=" + registryPublicationAttemptCount.ToString(CultureInfo.InvariantCulture));
+            if (!retryable || registryPublicationAttemptCount >= RegistryPublicationMaxAttempts)
+            {
+                registryPublicationRetryPending = false;
+                registryPublicationRetryExhausted = true;
+                pendingRegistryRequestedState = null;
+                WriteLog("instance_publication_retry_stopped kind=" + failureKind + " attempts=" + registryPublicationAttemptCount.ToString(CultureInfo.InvariantCulture) + " nextAction=restore-data-root-write-access-then-reload-domain");
+                return false;
+            }
+
+            pendingRegistryRequestedState = requestedState;
+            registryPublicationRetryPending = true;
+            nextRegistryPublicationRetryAt = EditorApplication.timeSinceStartup + RegistryPublicationRetryDelaySeconds(registryPublicationAttemptCount);
+            return false;
+        }
+
+        /// <summary>写入或更新当前editor session claim；同identity的其他存活claim必须保留以形成conflict。</summary>
+        private static bool TryRegisterInstance(string requestedState, out Exception failure)
+        {
+            failure = null;
             // AutoStart=false不即时停当前domain，但compile/reload边界开始后不得再把旧listener发布成transitioning。
             if (!UnityCliProjectSettings.Current.BridgeAutoStart
                 && (domainReloading || EditorApplication.isCompiling || EditorApplication.isUpdating)) return true;
             try
             {
+                string recoveryReason = null;
                 WithRegistryMutex(() =>
                 {
-                    var registry = ReadCurrentRegistry();
+                    var registry = ReadCurrentRegistryForPublication(out recoveryReason);
                     var sessions = ReadSessions(registry);
                     var previous = sessions.FirstOrDefault(IsCurrentSession);
                     EnsureListenerGeneration(registry);
@@ -289,6 +370,8 @@ namespace UnityCli
                     var data = RegistryData(revision, sessions);
                     WriteRegistryTextAtomically(InstancePath(), UnityCliSerializer.Serialize(data) + "\n");
                 });
+                if (!string.IsNullOrEmpty(recoveryReason))
+                    WriteLog("instance_registry_recovered reason=" + recoveryReason + " id=" + InstanceId());
                 // Registry是低频publication，不是heartbeat；日志只记录生命周期或listener变化。
                 var registrationSignature = NormalizeSessionLifecycle(requestedState) + "|" + ListenerId + "|" + listenerGeneration.ToString(CultureInfo.InvariantCulture);
                 if (!string.Equals(registrationSignature, lastRegistrationSignature, StringComparison.Ordinal))
@@ -296,15 +379,40 @@ namespace UnityCli
                     lastRegistrationSignature = registrationSignature;
                     WriteLog("instance_registered id=" + InstanceId() + " session=" + EditorSessionId() + " lifecycle=" + NormalizeSessionLifecycle(requestedState) + " listenerId=" + ListenerId + " generation=" + listenerGeneration.ToString(CultureInfo.InvariantCulture));
                 }
+                TryRunAutomaticInstanceCleanup();
                 return true;
             }
             catch (Exception exception)
             {
-                WriteLog("instance_register_failed " + exception);
+                failure = exception;
                 return false;
             }
         }
 
+        private static bool IsRetryableRegistryPublicationFailure(Exception failure)
+        {
+            return failure is IOException
+                || failure is UnauthorizedAccessException
+                || failure is TimeoutException
+                || failure is Win32Exception;
+        }
+
+        private static string RegistryPublicationFailureKind(Exception failure)
+        {
+            if (failure is UnauthorizedAccessException) return "access";
+            if (failure is TimeoutException) return "lock-timeout";
+            if (failure is Win32Exception) return "windows";
+            if (failure is IOException) return "io";
+            return failure == null ? "unknown" : failure.GetType().Name;
+        }
+
+        private static double RegistryPublicationRetryDelaySeconds(int failedAttempts)
+        {
+            if (failedAttempts <= 1) return 0.25;
+            if (failedAttempts == 2) return 0.5;
+            return 1.0;
+        }
+
         /// <summary>Editor 退出只移除当前 session claim，保留 offline project identity 记录。</summary>
         private static void DeleteInstanceRegistration()
         {
@@ -333,13 +441,61 @@ namespace UnityCli
             if (parsed == null) throw new InvalidDataException("Instance registry is not a JSON object.");
             if (ReadLong(parsed, "version") != 3L) return new Dictionary<string, object>();
             var identity = ReadDictionary(parsed, "identity");
-            if (identity == null
-                || !string.Equals(ReadString(identity, "instanceId"), InstanceId(), StringComparison.Ordinal)
-                || !string.Equals(ReadString(identity, "canonicalProjectPath"), ProjectIdentity().CanonicalProjectPath, StringComparison.Ordinal))
+            if (!RegistryIdentityMatchesCurrentProject(identity))
                 throw new InvalidDataException("Instance registry identity does not match CanonicalPath v1.");
             return parsed;
         }
 
+        /// <summary>当前Unity发布时不继承不可验证的旧状态；文件IO失败仍由外层有界重试处理。</summary>
+        private static Dictionary<string, object> ReadCurrentRegistryForPublication(out string recoveryReason)
+        {
+            recoveryReason = null;
+            var path = InstancePath();
+            if (!File.Exists(path)) return new Dictionary<string, object>();
+            if (new FileInfo(path).Length > RegistryMaxBytes)
+            {
+                recoveryReason = "oversized";
+                return new Dictionary<string, object>();
+            }
+
+            object root;
+            try
+            {
+                root = UnityCliSerializer.Parse(File.ReadAllText(path, Encoding.UTF8));
+            }
+            catch (FormatException)
+            {
+                recoveryReason = "malformed-json";
+                return new Dictionary<string, object>();
+            }
+
+            var parsed = root as Dictionary<string, object>;
+            if (parsed == null)
+            {
+                recoveryReason = "non-object-root";
+                return new Dictionary<string, object>();
+            }
+            if (ReadLong(parsed, "version") != 3L)
+            {
+                recoveryReason = "unsupported-version";
+                return new Dictionary<string, object>();
+            }
+            if (!RegistryIdentityMatchesCurrentProject(ReadDictionary(parsed, "identity")))
+            {
+                recoveryReason = "identity-mismatch";
+                return new Dictionary<string, object>();
+            }
+            return parsed;
+        }
+
+        /// <summary>只信任与当前确定性文件名对应的CanonicalPath v1身份。</summary>
+        private static bool RegistryIdentityMatchesCurrentProject(Dictionary<string, object> identity)
+        {
+            return identity != null
+                && string.Equals(ReadString(identity, "instanceId"), InstanceId(), StringComparison.Ordinal)
+                && string.Equals(ReadString(identity, "canonicalProjectPath"), ProjectIdentity().CanonicalProjectPath, StringComparison.Ordinal);
+        }
+
         /// <summary>读取当前 session 上一次 listener 代次；domain reload 后严格递增。</summary>
         private static void EnsureListenerGeneration(Dictionary<string, object> registry)
         {

package/unitypkg/Editor/Infrastructure/UnityCliOperationCoordinator.cs

@@ -591,6 +591,7 @@ namespace UnityCli
         private static UnityCliToolCompletionContract ResolveRequestCompletionContract(BridgeRequest request)
         {
             var toolName = RequestToolName(request);
+            if (IsInstanceCleanupCommand(toolName)) return InstanceCleanupCompletionContract();
             UnityCliToolCompletionContract contract;
             if (UnityCliToolCompletionRegistry.TryGet(toolName, out contract)) return contract;
             if (string.Equals(toolName, "code.exec", StringComparison.Ordinal))

package/unitypkg/Editor/UnityCliBridge.cs

@@ -67,6 +67,7 @@ namespace UnityCli
         private const double RegistryRefreshSeconds = 30.0;
         private static int port;
         private static double nextRegistryRefreshAt;
+        private static bool readyPublicationPending;
         private static readonly CancellationTokenSource BridgeLifetime = new CancellationTokenSource();
         private static CancellationTokenSource runtimeSession = new CancellationTokenSource();
 
@@ -194,7 +195,8 @@ namespace UnityCli
                 port = StartHttpListener(listener);
                 started = true;
                 Task.Run(ListenLoop);
-                if (!RegisterInstance("ready")) throw new InvalidOperationException("Initial instance registry publication failed.");
+                RegisterInstance("transitioning");
+                readyPublicationPending = true;
                 nextRegistryRefreshAt = EditorApplication.timeSinceStartup + RegistryRefreshSeconds;
                 WriteRuntimeLoadDiagnostics("listener_started");
                 WriteLog("bridge_started port=" + port + " listenerId=" + ListenerId + " diagnosticsFingerprint=" + BridgeDiagnosticsFingerprint + " assemblyMvid=" + AssemblyMvid() + " packageName=" + BridgePackageName() + " packageAssetPath=" + BridgePackageAssetPath() + " packageResolvedPath=" + BridgePackageResolvedPath());
@@ -338,6 +340,8 @@ namespace UnityCli
                 WriteLog("bridge_stop_failed " + exception.GetType().Name + ": " + exception.Message);
             }
             started = false;
+            readyPublicationPending = false;
+            CancelInstancePublicationRetry();
         }
 
         private static async ValueTask<string> Execute(UnityCli.Protocol.BridgeRequest request, CancellationToken cancellationToken)

package/unitypkg/Tests/Editor/UnityCliInstanceCleanupTests.cs

@@ -0,0 +1,232 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using NUnit.Framework;
+
+namespace UnityCli.Tests
+{
+    public sealed class UnityCliInstanceCleanupTests
+    {
+        private Type bridgeType;
+        private MethodInfo cleanup;
+        private MethodInfo boundedLogLine;
+        private MethodInfo rollLog;
+        private string originalDataRoot;
+        private string root;
+        private string instances;
+
+        [SetUp]
+        public void SetUp()
+        {
+            bridgeType = Type.GetType("UnityCli.UnityCliBridge, UnityCli.Editor", true);
+            cleanup = bridgeType.GetMethod("RunInstanceCleanup", BindingFlags.NonPublic | BindingFlags.Static) ?? throw new MissingMethodException("RunInstanceCleanup");
+            boundedLogLine = bridgeType.GetMethod("BoundedBridgeLogLine", BindingFlags.NonPublic | BindingFlags.Static) ?? throw new MissingMethodException("BoundedBridgeLogLine");
+            rollLog = bridgeType.GetMethod("RollBridgeLogIfNeeded", BindingFlags.NonPublic | BindingFlags.Static) ?? throw new MissingMethodException("RollBridgeLogIfNeeded");
+            originalDataRoot = Environment.GetEnvironmentVariable("UNITYCLI_DATA_DIR");
+            root = Path.Combine(Directory.GetCurrentDirectory(), "Library", "UnityCli", "instance-cleanup-tests");
+            instances = Path.Combine(root, "instances");
+            if (Directory.Exists(root)) Directory.Delete(root, true);
+            Directory.CreateDirectory(instances);
+            Environment.SetEnvironmentVariable("UNITYCLI_DATA_DIR", root);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Environment.SetEnvironmentVariable("UNITYCLI_DATA_DIR", originalDataRoot);
+            if (Directory.Exists(root)) Directory.Delete(root, true);
+        }
+
+        [Test]
+        public void TwoBoundedPassesReachOfflineAndDamagedRetentionCaps()
+        {
+            var now = DateTimeOffset.UtcNow;
+            for (var index = 0; index < 115; index++)
+                WriteOffline("offline", index, index < 5 ? now.AddDays(-40 - index) : now.AddHours(-index - 1));
+            for (var index = 0; index < 30; index++)
+                WriteDamaged(index, index < 5 ? now.AddDays(-45 - index) : now.AddHours(-index - 1));
+            WriteClaim("active", 0, Process.GetCurrentProcess().Id, Process.GetCurrentProcess().StartTime.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture), "editor");
+            WriteClaim("unverifiable", 0, 0, string.Empty, "editor");
+            WriteMixedClaims("mixed", 0);
+
+            var first = cleanup.Invoke(null, null);
+            Assert.That(Value(first, "Scanned"), Is.EqualTo(148));
+            Assert.That(Value(first, "Offline"), Is.EqualTo(115));
+            Assert.That(Value(first, "Damaged"), Is.EqualTo(30));
+            Assert.That(Value(first, "Preserved"), Is.EqualTo(3));
+            Assert.That(Value(first, "Deleted"), Is.EqualTo(20));
+            Assert.That(Value(first, "Deferred"), Is.EqualTo(5));
+            Assert.That((bool)Field(first, "Truncated"), Is.False);
+            Assert.That(File.Exists(PathFor("damaged", 4)), Is.False, "oldest damaged record must be deleted first");
+            Assert.That(File.Exists(PathFor("offline", 4)), Is.False, "oldest offline record must be deleted first");
+            Assert.That(File.Exists(PathFor("offline", 114)), Is.False, "oldest over-cap recent offline record must be deleted");
+            Assert.That(File.Exists(PathFor("offline", 5)), Is.True, "newer retained offline record must remain");
+            Assert.That(File.Exists(PathFor("damaged", 29)), Is.True, "delete budget must defer remaining planned records");
+
+            var second = cleanup.Invoke(null, null);
+            Assert.That(Value(second, "Deleted"), Is.EqualTo(5));
+            Assert.That(Value(second, "Deferred"), Is.EqualTo(0));
+            Assert.That(CountOffline(), Is.EqualTo(100));
+            Assert.That(CountDamaged(), Is.EqualTo(20));
+            Assert.That(File.Exists(PathFor("active", 0)), Is.True);
+            Assert.That(File.Exists(PathFor("unverifiable", 0)), Is.True);
+            Assert.That(File.Exists(PathFor("mixed", 0)), Is.True);
+            Assert.That(Directory.GetFiles(instances, "*.tmp").Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void ScanLimitSetsTruncatedAndStillCapsDeletion()
+        {
+            var now = DateTimeOffset.UtcNow.AddDays(-40);
+            for (var index = 0; index < 2001; index++) WriteOffline("scan", index, now.AddMinutes(-index));
+            var result = cleanup.Invoke(null, null);
+            Assert.That(Value(result, "Scanned"), Is.EqualTo(2000));
+            Assert.That((bool)Field(result, "Truncated"), Is.True);
+            Assert.That(Value(result, "Deleted"), Is.EqualTo(20));
+            Assert.That(Directory.GetFiles(instances, "*.json").Length, Is.EqualTo(1981));
+            Assert.That(Directory.GetFiles(instances, "*.tmp").Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void RepeatedLogEntriesKeepTwoBoundedSegments()
+        {
+            var logPath = Path.Combine(root, "bounded.log");
+            var oversized = new string('x', 96 * 1024);
+            for (var index = 0; index < 400; index++)
+            {
+                var line = (string)boundedLogLine.Invoke(null, new object[] { oversized, 64 * 1024 });
+                var entry = line + Environment.NewLine;
+                rollLog.Invoke(null, new object[] { logPath, Encoding.UTF8.GetByteCount(entry) });
+                File.AppendAllText(logPath, entry, new UTF8Encoding(false));
+            }
+            var segments = Directory.GetFiles(root, "bounded.log*");
+            Assert.That(segments.Length, Is.EqualTo(2));
+            foreach (var segment in segments) Assert.That(new FileInfo(segment).Length, Is.LessThanOrEqualTo(10L * 1024 * 1024));
+            Assert.That(Encoding.UTF8.GetByteCount((string)boundedLogLine.Invoke(null, new object[] { oversized, 64 * 1024 })), Is.LessThanOrEqualTo(64 * 1024));
+        }
+
+        [Test]
+        public void PerInstanceLockDefersThenAllowsTheSameOldRecord()
+        {
+            var candidate = WriteOffline("locked", 0, DateTimeOffset.UtcNow.AddDays(-40));
+            var instanceId = Path.GetFileNameWithoutExtension(candidate);
+            using (var held = new ManualResetEventSlim(false))
+            using (var release = new ManualResetEventSlim(false))
+            {
+                var thread = new Thread(delegate()
+                {
+                    using (var mutex = new Mutex(false, "Local\\UnityCli.Registry." + instanceId))
+                    {
+                        mutex.WaitOne();
+                        held.Set();
+                        release.Wait();
+                        mutex.ReleaseMutex();
+                    }
+                });
+                thread.IsBackground = true;
+                thread.Start();
+                Assert.That(held.Wait(5000), Is.True);
+                var deferred = cleanup.Invoke(null, null);
+                Assert.That(Value(deferred, "Deleted"), Is.EqualTo(0));
+                Assert.That(Value(deferred, "Deferred"), Is.EqualTo(1));
+                Assert.That(File.Exists(candidate), Is.True);
+                release.Set();
+                Assert.That(thread.Join(5000), Is.True);
+            }
+
+            var deleted = cleanup.Invoke(null, null);
+            Assert.That(Value(deleted, "Deleted"), Is.EqualTo(1));
+            Assert.That(File.Exists(candidate), Is.False);
+            Assert.That(Directory.GetFiles(instances, "*.tmp").Length, Is.EqualTo(0));
+        }
+
+        private string WriteOffline(string kind, int index, DateTimeOffset publishedAt)
+        {
+            var identity = Identity(kind, index);
+            var path = Path.Combine(instances, identity.Item1 + ".json");
+            var json = "{\"version\":3,\"revision\":1,\"canonicalizationVersion\":1,\"identity\":{\"instanceId\":\"" + identity.Item1 + "\",\"canonicalProjectPath\":\"" + Json(identity.Item2) + "\",\"displayProjectPath\":\"" + Json(identity.Item3) + "\"},\"sessions\":[],\"publishedAt\":\"" + publishedAt.ToString("O", CultureInfo.InvariantCulture) + "\"}\n";
+            File.WriteAllText(path, json, new UTF8Encoding(false));
+            File.SetLastWriteTimeUtc(path, publishedAt.UtcDateTime);
+            return path;
+        }
+
+        private void WriteDamaged(int index, DateTimeOffset writtenAt)
+        {
+            var path = PathFor("damaged", index);
+            File.WriteAllText(path, "{\"version\":3,", new UTF8Encoding(false));
+            File.SetLastWriteTimeUtc(path, writtenAt.UtcDateTime);
+        }
+
+        private void WriteClaim(string kind, int index, int processId, string processStartedAt, string target)
+        {
+            var identity = Identity(kind, index);
+            var path = Path.Combine(instances, identity.Item1 + ".json");
+            var sessionId = "session-" + new string(kind == "active" ? 'a' : 'b', 64);
+            var json = "{\"version\":3,\"revision\":1,\"canonicalizationVersion\":1,\"identity\":{\"instanceId\":\"" + identity.Item1 + "\",\"canonicalProjectPath\":\"" + Json(identity.Item2) + "\",\"displayProjectPath\":\"" + Json(identity.Item3) + "\"},\"sessions\":[{\"target\":\"" + target + "\",\"sessionId\":\"" + sessionId + "\",\"processId\":" + processId.ToString(CultureInfo.InvariantCulture) + ",\"processStartedAt\":\"" + processStartedAt + "\"}],\"publishedAt\":\"" + DateTimeOffset.UtcNow.ToString("O", CultureInfo.InvariantCulture) + "\"}\n";
+            File.WriteAllText(path, json, new UTF8Encoding(false));
+        }
+
+        private void WriteMixedClaims(string kind, int index)
+        {
+            var identity = Identity(kind, index);
+            var process = Process.GetCurrentProcess();
+            var started = process.StartTime.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture);
+            var path = Path.Combine(instances, identity.Item1 + ".json");
+            var json = "{\"version\":3,\"revision\":1,\"canonicalizationVersion\":1,\"identity\":{\"instanceId\":\"" + identity.Item1 + "\",\"canonicalProjectPath\":\"" + Json(identity.Item2) + "\",\"displayProjectPath\":\"" + Json(identity.Item3) + "\"},\"sessions\":[{\"target\":\"editor\",\"processId\":" + process.Id.ToString(CultureInfo.InvariantCulture) + ",\"processStartedAt\":\"" + started + "\"},{\"target\":\"runtime\",\"processId\":" + process.Id.ToString(CultureInfo.InvariantCulture) + ",\"processStartedAt\":\"" + started + "\"}],\"publishedAt\":\"" + DateTimeOffset.UtcNow.ToString("O", CultureInfo.InvariantCulture) + "\"}\n";
+            File.WriteAllText(path, json, new UTF8Encoding(false));
+        }
+
+        private int CountOffline()
+        {
+            var count = 0;
+            foreach (var path in Directory.GetFiles(instances, "*.json"))
+            {
+                var text = File.ReadAllText(path, Encoding.UTF8);
+                if (text.Contains("\"sessions\":[]")) count++;
+            }
+            return count;
+        }
+
+        private int CountDamaged()
+        {
+            var count = 0;
+            foreach (var path in Directory.GetFiles(instances, "*.json"))
+                if (File.ReadAllText(path, Encoding.UTF8) == "{\"version\":3,") count++;
+            return count;
+        }
+
+        private string PathFor(string kind, int index)
+        {
+            return Path.Combine(instances, Identity(kind, index).Item1 + ".json");
+        }
+
+        private Tuple<string, string, string> Identity(string kind, int index)
+        {
+            var canonical = "d:\\unitycli-cleanup-tests\\" + kind + "-" + index.ToString("D3", CultureInfo.InvariantCulture);
+            return Tuple.Create("unity-" + Sha256(canonical), canonical, "D:\\UnityCli-Cleanup-Tests\\" + kind + "-" + index.ToString("D3", CultureInfo.InvariantCulture));
+        }
+
+        private static string Sha256(string value)
+        {
+            using (var sha = SHA256.Create())
+            {
+                var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(value));
+                var result = new StringBuilder(64);
+                foreach (var item in bytes) result.Append(item.ToString("x2", CultureInfo.InvariantCulture));
+                return result.ToString();
+            }
+        }
+
+        private static string Json(string value) { return value.Replace("\\", "\\\\").Replace("\"", "\\\""); }
+        private static int Value(object owner, string name) { return Convert.ToInt32(Field(owner, name), CultureInfo.InvariantCulture); }
+        private static object Field(object owner, string name) { return owner.GetType().GetField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).GetValue(owner); }
+    }
+}
+#endif