Add new console log cache to persist log data

Unity-MCP-Plugin/Assets/root/Editor/Scripts/API/Tool/Console.GetLogs.cs

@@ -54,14 +54,14 @@ public string GetLogs
                     {
                         var cutoffTime = DateTime.Now.AddMinutes(-lastMinutes);
                         allLogs = allLogs
-                            .Where(log => log.timestamp >= cutoffTime);
+                            .Where(log => log.Timestamp >= cutoffTime);
                     }
 
                     // Apply log type filter
                     if (logTypeFilter.HasValue)
                     {
                         allLogs = allLogs
-                            .Where(log => log.logType == logTypeFilter.Value);
+                            .Where(log => log.LogType == logTypeFilter.Value);
                     }
 
                     // Take the most recent entries (up to maxEntries)
@@ -92,4 +92,4 @@ public string GetLogs
             });
         }
     }
-}
+}

Unity-MCP-Plugin/Assets/root/Editor/Scripts/Startup.Editor.cs

@@ -35,6 +35,7 @@ static void OnApplicationUnloading()
                 UnityMcpPlugin.Instance.LogInfo("{method} triggered", typeof(Startup), nameof(OnApplicationUnloading));
                 UnityMcpPlugin.Instance.DisconnectImmediate();
             }
+            LogUtils.SaveToFile();
         }
         static void OnApplicationQuitting()
         {
@@ -43,6 +44,7 @@ static void OnApplicationQuitting()
                 UnityMcpPlugin.Instance.LogInfo("{method} triggered", typeof(Startup), nameof(OnApplicationQuitting));
                 UnityMcpPlugin.Instance.DisconnectImmediate();
             }
+            LogUtils.HandleQuit();
         }
         static void OnBeforeAssemblyReload()
         {
@@ -51,6 +53,7 @@ static void OnBeforeAssemblyReload()
                 UnityMcpPlugin.Instance.LogInfo("{method} triggered", typeof(Startup), nameof(OnBeforeAssemblyReload));
                 UnityMcpPlugin.Instance.DisconnectImmediate();
             }
+            LogUtils.SaveToFile();
         }
         static void OnAfterAssemblyReload()
         {
@@ -63,6 +66,8 @@ static void OnAfterAssemblyReload()
 
             if (connectionAllowed)
                 UnityMcpPlugin.ConnectIfNeeded();
+
+            LogUtils.LoadFromFile();
         }
 
         static void OnPlayModeStateChanged(PlayModeStateChange state)

Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/LogCache.cs

@@ -0,0 +1,147 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System;
+using System.IO;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using com.IvanMurzak.ReflectorNet.Utils;
+using R3;
+using UnityEngine;
+
+namespace com.IvanMurzak.Unity.MCP
+{
+    internal class LogCache : IDisposable
+    {
+        readonly string _cacheFilePath;
+        readonly string _cacheFileName;
+        readonly string _cacheFile;
+        readonly JsonSerializerOptions _jsonOptions;
+        readonly SemaphoreSlim _fileLock = new(1, 1);
+        readonly CancellationTokenSource _shutdownCts = new();
+
+        IDisposable? timerSubscription;
+
+        internal LogCache(string? cacheFilePath = null, string? cacheFileName = null, JsonSerializerOptions? jsonOptions = null)
+        {
+            if (!MainThread.Instance.IsMainThread)
+                throw new System.Exception($"{nameof(LogUtils)} must be initialized on the main thread.");
+
+            _cacheFilePath = cacheFilePath ?? (Application.isEditor
+                ? $"{Path.GetDirectoryName(Application.dataPath)}/Temp/mcp-server"
+                : $"{Application.persistentDataPath}/Temp/mcp-server");
+
+            _cacheFileName = cacheFileName ?? (Application.isEditor
+                ? "editor-logs.txt"
+                : "player-logs.txt");
+
+            _cacheFile = $"{Path.Combine(_cacheFilePath, _cacheFileName)}";
+            _jsonOptions = jsonOptions ?? new JsonSerializerOptions
+            {
+                PropertyNameCaseInsensitive = true,
+                WriteIndented = false,
+            };
+
+            timerSubscription = Observable.Timer(
+                    TimeSpan.FromSeconds(1),
+                    TimeSpan.FromSeconds(1)
+                )
+                .Subscribe(x =>
+                {
+                    if (!_shutdownCts.IsCancellationRequested)
+                        Task.Run(HandleLogCache, _shutdownCts.Token);
+                });
+        }
+
+        public async Task HandleQuit()
+        {
+            if (!_shutdownCts.IsCancellationRequested)
+                _shutdownCts.Cancel();
+            timerSubscription?.Dispose();
+            await HandleLogCache();
+        }
+
+        public async Task HandleLogCache()
+        {
+            if (LogUtils.LogEntries > 0)
+            {
+                var logs = LogUtils.GetAllLogs();
+                await CacheLogEntriesAsync(logs);
+            }
+        }
+
+        public Task CacheLogEntriesAsync(LogEntry[] entries)
+        {
+            return Task.Run(async () =>
+            {
+                await _fileLock.WaitAsync();
+                try
+                {
+                    var data = new LogWrapper { Entries = entries };
+
+                    if (!Directory.Exists(_cacheFilePath))
+                        Directory.CreateDirectory(_cacheFilePath);
+
+                    // Stream JSON directly to file without creating entire JSON string in memory
+                    var tempFile = _cacheFile + ".tmp";
+                    using (var fileStream = new FileStream(tempFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true))
+                    {
+                        await System.Text.Json.JsonSerializer.SerializeAsync(fileStream, data, _jsonOptions);
+                        await fileStream.FlushAsync();
+                    }
+
+                    // Atomic file replacement
+                    if (File.Exists(_cacheFile))
+                        File.Delete(_cacheFile);
+                    File.Move(tempFile, _cacheFile);
+                }
+                finally
+                {
+                    _fileLock.Release();
+                }
+            });
+        }
+        public Task<LogWrapper?> GetCachedLogEntriesAsync()
+        {
+            return Task.Run(async () =>
+            {
+                await _fileLock.WaitAsync();
+                try
+                {
+                    if (!File.Exists(_cacheFile))
+                        return null;
+
+                    using var fileStream = File.OpenRead(_cacheFile);
+                    return await System.Text.Json.JsonSerializer.DeserializeAsync<LogWrapper>(fileStream, _jsonOptions);
+                }
+                finally
+                {
+                    _fileLock.Release();
+                }
+            });
+        }
+
+        public void Dispose()
+        {
+            timerSubscription?.Dispose();
+            timerSubscription = null;
+
+            if (!_shutdownCts.IsCancellationRequested)
+                _shutdownCts.Cancel();
+            _shutdownCts.Dispose();
+
+            _fileLock.Dispose();
+        }
+
+        ~LogCache() => Dispose();
+    }
+}

Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/LogEntry.cs

@@ -14,32 +14,48 @@
 
 namespace com.IvanMurzak.Unity.MCP
 {
-    [Serializable]
     public class LogEntry
     {
-        public string message;
-        public string stackTrace;
-        public LogType logType;
-        public DateTime timestamp;
-        public string logTypeString;
+        public LogType LogType { get; set; }
+        public string Message { get; set; }
+        public DateTime Timestamp { get; set; }
+        public string? StackTrace { get; set; }
 
-        public LogEntry(string message, string stackTrace, LogType logType)
+        public LogEntry()
         {
-            this.message = message;
-            this.stackTrace = stackTrace;
-            this.logType = logType;
-            this.timestamp = DateTime.Now;
-            this.logTypeString = logType.ToString();
+            LogType = LogType.Log;
+            Message = string.Empty;
+            Timestamp = DateTime.Now;
+            StackTrace = null;
+        }
+        public LogEntry(LogType logType, string message)
+        {
+            LogType = logType;
+            Message = message;
+            Timestamp = DateTime.Now;
+        }
+        public LogEntry(LogType logType, string message, string? stackTrace = null)
+        {
+            LogType = logType;
+            Message = message;
+            Timestamp = DateTime.Now;
+            StackTrace = stackTrace;
+        }
+        public LogEntry(LogType logType, string message, DateTime timestamp, string? stackTrace = null)
+        {
+            LogType = logType;
+            Message = message;
+            Timestamp = timestamp;
+            StackTrace = stackTrace;
         }
 
         public override string ToString() => ToString(includeStackTrace: false);
 
         public string ToString(bool includeStackTrace)
         {
-            if (includeStackTrace && !string.IsNullOrEmpty(stackTrace))
-                return $"{timestamp:yyyy-MM-dd HH:mm:ss.fff} [{logTypeString}] {message}\nStack Trace:\n{stackTrace}";
-            else
-                return $"{timestamp:yyyy-MM-dd HH:mm:ss.fff} [{logTypeString}] {message}";
+            return includeStackTrace && !string.IsNullOrEmpty(StackTrace)
+                ? $"{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{LogType}] {Message}\nStack Trace:\n{StackTrace}"
+                : $"{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{LogType}] {Message}";
         }
     }
 }

Unity-MCP-Plugin/Assets/root/Runtime/Unity/Logs/LogUtils.cs

@@ -10,6 +10,7 @@
 
 #nullable enable
 using System.Collections.Concurrent;
+using System.Threading.Tasks;
 using com.IvanMurzak.ReflectorNet.Utils;
 using UnityEngine;
 
@@ -19,9 +20,17 @@ public static class LogUtils
     {
         public const int MaxLogEntries = 5000; // Default max entries to keep in memory
 
-        static readonly ConcurrentQueue<LogEntry> _logEntries = new();
+        static ConcurrentQueue<LogEntry> _logEntries = new();
+        static readonly LogCache _logCache = new();
         static readonly object _lockObject = new();
-        static bool _isSubscribed = false;
+        static volatile bool _isSubscribed = false;
+
+        static LogUtils()
+        {
+            if (!MainThread.Instance.IsMainThread)
+                throw new System.Exception($"{nameof(LogUtils)} must be initialized on the main thread.");
+            EnsureSubscribed();
+        }
 
         public static int LogEntries
         {
@@ -38,31 +47,59 @@ public static void ClearLogs()
         {
             lock (_lockObject)
             {
-                _logEntries.Clear();
+                _logEntries = new ConcurrentQueue<LogEntry>();
             }
         }
-        public static LogEntry[] GetAllLogs()
+
+        /// <summary>
+        /// Asynchronously saves all current log entries to the cache file.
+        /// </summary>
+        /// <returns>A task that completes when the save operation is finished.</returns>
+        public static Task SaveToFile()
         {
+            var logEntries = GetAllLogs();
+            return _logCache.CacheLogEntriesAsync(logEntries);
+        }
+
+        /// <summary>
+        /// Asynchronously loads log entries from the cache file and replaces the current log entries.
+        /// </summary>
+        /// <returns>A task that completes when the load operation is finished.</returns>
+        public static async Task LoadFromFile()
+        {
+            var logWrapper = await _logCache.GetCachedLogEntriesAsync();
             lock (_lockObject)
             {
-                return _logEntries.ToArray();
+                _logEntries = new ConcurrentQueue<LogEntry>(logWrapper?.Entries ?? new LogEntry[0]);
             }
         }
 
-        static LogUtils()
+        /// <summary>
+        /// Asynchronously handles application quit by saving log entries to file and cleaning up resources.
+        /// </summary>
+        /// <returns>A task that completes when the quit handling is finished.</returns>
+        public static async Task HandleQuit()
         {
-            EnsureSubscribed();
+            await SaveToFile();
+            await _logCache.HandleQuit();
         }
 
-        public static void EnsureSubscribed()
+        public static LogEntry[] GetAllLogs()
         {
-            MainThread.Instance.RunAsync(() =>
+            lock (_lockObject)
+            {
+                return _logEntries.ToArray();
+            }
+        }
+
+        public static Task EnsureSubscribed()
+        {
+            return MainThread.Instance.RunAsync(() =>
             {
                 lock (_lockObject)
                 {
                     if (!_isSubscribed)
                     {
-                        Application.logMessageReceived += OnLogMessageReceived;
                         Application.logMessageReceivedThreaded += OnLogMessageReceived;
                         _isSubscribed = true;
                     }
@@ -74,7 +111,11 @@ static void OnLogMessageReceived(string message, string stackTrace, LogType type
         {
             try
             {
-                var logEntry = new LogEntry(message, stackTrace, type);
+                var logEntry = new LogEntry(
+                    message: message,
+                    stackTrace: stackTrace,
+                    logType: type);
+
                 lock (_lockObject)
                 {
                     _logEntries.Enqueue(logEntry);