Tighten codex session manager quality gates

.github/workflows/codecov-analytics.yml

@@ -16,13 +16,13 @@ jobs:
     permissions:
       contents: read
       id-token: write
-    uses: Prekzursil/quality-zero-platform/.github/workflows/reusable-codecov-analytics.yml@ab80e05c2acee987ad17d98e960c59966a4393eb
+    uses: Prekzursil/quality-zero-platform/.github/workflows/reusable-codecov-analytics.yml@59db814dcb893c79a522913783ec0dde81d34f07
     with:
       repo_slug: ${{ github.repository }}
       event_name: ${{ github.event_name }}
       sha: ${{ github.event.pull_request.head.sha || github.sha }}
       runner: windows-latest
       platform_repository: Prekzursil/quality-zero-platform
-      platform_ref: ab80e05c2acee987ad17d98e960c59966a4393eb
+      platform_ref: 59db814dcb893c79a522913783ec0dde81d34f07
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/quality-zero-gate.yml

@@ -14,10 +14,10 @@ jobs:
   aggregate-gate:
     permissions:
       contents: read
-    uses: Prekzursil/quality-zero-platform/.github/workflows/reusable-quality-zero-gate.yml@ab80e05c2acee987ad17d98e960c59966a4393eb
+    uses: Prekzursil/quality-zero-platform/.github/workflows/reusable-quality-zero-gate.yml@59db814dcb893c79a522913783ec0dde81d34f07
     with:
       repo_slug: ${{ github.repository }}
       event_name: ${{ github.event_name }}
       sha: ${{ github.event.pull_request.head.sha || github.sha }}
       platform_repository: Prekzursil/quality-zero-platform
-      platform_ref: ab80e05c2acee987ad17d98e960c59966a4393eb
+      platform_ref: 59db814dcb893c79a522913783ec0dde81d34f07

.github/workflows/quality-zero-platform.yml

@@ -18,7 +18,7 @@ jobs:
       contents: read
       id-token: write
       pull-requests: write
-    uses: Prekzursil/quality-zero-platform/.github/workflows/reusable-scanner-matrix.yml@ab80e05c2acee987ad17d98e960c59966a4393eb
+    uses: Prekzursil/quality-zero-platform/.github/workflows/reusable-scanner-matrix.yml@59db814dcb893c79a522913783ec0dde81d34f07
     with:
       repo_slug: ${{ github.repository }}
       event_name: ${{ github.event_name }}
@@ -29,7 +29,7 @@ jobs:
       sha: ${{ github.event.pull_request.head.sha || github.sha }}
       coverage_runner: windows-latest
       platform_repository: Prekzursil/quality-zero-platform
-      platform_ref: ab80e05c2acee987ad17d98e960c59966a4393eb
+      platform_ref: 59db814dcb893c79a522913783ec0dde81d34f07
     secrets:
       SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
       CODACY_API_TOKEN: ${{ secrets.CODACY_API_TOKEN }}

src/CodexSessionManager.App/App.xaml.cs

@@ -1,8 +1,10 @@
+#pragma warning disable S3990 // Codacy false positive: the assembly already declares CLSCompliant(true).
 using System.Diagnostics.CodeAnalysis;
 using System.Windows;
 
 namespace CodexSessionManager.App;
 
+[SuppressMessage("Compatibility", "S3990", Justification = "The assembly already declares CLSCompliant(true); this file-level report is a persistent analyzer false positive.")]
 [SuppressMessage("Code Smell", "S2333", Justification = "The application entry point is paired with XAML-generated partial members.")]
 [ExcludeFromCodeCoverage]
 public partial class App : Application

src/CodexSessionManager.App/MainWindow.Infrastructure.cs

@@ -0,0 +1,258 @@
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using CodexSessionManager.Core.Sessions;
+using CodexSessionManager.Storage.Discovery;
+
+namespace CodexSessionManager.App;
+
+[SuppressMessage("Compatibility", "S3990", Justification = "The assembly already declares CLSCompliant(true); this file-level report is a persistent analyzer false positive.")]
+[SuppressMessage("Code Smell", "S2333", Justification = "The class is split across XAML-generated and hand-authored partial files.")]
+public partial class MainWindow
+{
+    private async Task RunOnUiThreadAsync(Action action)
+    {
+        if (action is null)
+        {
+            throw new ArgumentNullException(nameof(action));
+        }
+
+        var uiAction = action;
+        var dispatcher = Dispatcher;
+
+        if (dispatcher.CheckAccess())
+        {
+            uiAction();
+            return;
+        }
+
+        await dispatcher.InvokeAsync(uiAction);
+    }
+
+    private async Task<T> RunOnUiThreadValueAsync<T>(Func<T> func)
+    {
+        if (func is null)
+        {
+            throw new ArgumentNullException(nameof(func));
+        }
+
+        var uiFunc = func;
+        var dispatcher = Dispatcher;
+
+        if (dispatcher.CheckAccess())
+        {
+            return uiFunc();
+        }
+
+        return await dispatcher.InvokeAsync(uiFunc);
+    }
+
+    private void RunEventTask(Func<Task> action, string failurePrefix)
+    {
+        if (action is null)
+        {
+            throw new ArgumentNullException(nameof(action));
+        }
+
+        var eventAction = action;
+
+        if (string.IsNullOrWhiteSpace(failurePrefix))
+        {
+            throw new ArgumentException("Value cannot be null or whitespace.", nameof(failurePrefix));
+        }
+
+        _ = RunEventTaskCoreAsync();
+
+        async Task RunEventTaskCoreAsync()
+        {
+            try
+            {
+                await eventAction();
+            }
+            catch (Exception ex)
+            {
+                await RunOnUiThreadAsync(() => StatusTextBlock.Text = $"{failurePrefix}: {ex.Message}");
+            }
+        }
+    }
+
+    private static List<KnownSessionStore> BuildKnownStores(bool deepScan)
+    {
+        var codexHome = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+            ".codex");
+        var stores = new List<KnownSessionStore>(KnownStoreLocator.GetKnownStores(codexHome));
+        if (!deepScan)
+        {
+            return stores;
+        }
+
+        var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        foreach (var directory in Directory.EnumerateDirectories(
+                     userProfile,
+                     ".codex*",
+                     SearchOption.TopDirectoryOnly))
+        {
+            foreach (var store in KnownStoreLocator.GetKnownStores(directory)
+                         .Where(store => stores.All(existing =>
+                             !string.Equals(
+                                 existing.SessionsPath,
+                                 store.SessionsPath,
+                                 StringComparison.OrdinalIgnoreCase))))
+            {
+                stores.Add(store);
+            }
+        }
+
+        return stores;
+    }
+
+    private static SessionPhysicalCopy GetRequiredPreferredCopy(IndexedLogicalSession? session)
+    {
+        if (session is null)
+        {
+            throw new ArgumentNullException(nameof(session));
+        }
+
+        var selectedSession = session;
+
+        var preferredCopy = selectedSession.PreferredCopy;
+        if (preferredCopy is null)
+        {
+            throw new InvalidOperationException("Selected session is missing a preferred copy.");
+        }
+
+        return preferredCopy;
+    }
+
+    internal static string? DescribeSqlitePath(string path)
+    {
+        if (path is null)
+        {
+            throw new ArgumentNullException(nameof(path));
+        }
+
+        var sqlitePath = path;
+        return DescribeSqlitePath(sqlitePath, static candidate => new FileInfo(candidate));
+    }
+
+    internal static string? DescribeSqlitePath(
+        string path,
+        Func<string, FileInfo>? fileInfoFactory)
+    {
+        if (path is null)
+        {
+            throw new ArgumentNullException(nameof(path));
+        }
+
+        var sqlitePath = path;
+        var createFileInfo = fileInfoFactory;
+        if (createFileInfo is null)
+        {
+            createFileInfo = static candidate => new FileInfo(candidate);
+        }
+
+        try
+        {
+            var info = createFileInfo(sqlitePath);
+            if (!info.Exists)
+            {
+                return null;
+            }
+
+            return $"{sqlitePath} | {Math.Round(info.Length / 1024.0 / 1024.0, 1)} MB | {info.LastWriteTime}";
+        }
+        catch (IOException)
+        {
+            return null;
+        }
+        catch (UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    private static string GetLiveSqliteStatus()
+    {
+        var codexHome = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+            ".codex");
+        return GetLiveSqliteStatus(
+            [
+                Path.Combine(codexHome, "state_5.sqlite"),
+                Path.Combine(codexHome, "codex-sqlite", "canonical", "state_5.sqlite"),
+            ],
+            DescribeSqlitePath);
+    }
+
+    private static string GetLiveSqliteStatus(
+        IEnumerable<string> sqlitePaths,
+        Func<string, string?> describeSqlitePath)
+    {
+        if (sqlitePaths is null)
+        {
+            throw new ArgumentNullException(nameof(sqlitePaths));
+        }
+
+        if (describeSqlitePath is null)
+        {
+            throw new ArgumentNullException(nameof(describeSqlitePath));
+        }
+
+        var candidatePaths = sqlitePaths;
+        var describePath = describeSqlitePath;
+
+        var details = candidatePaths
+            .Select(describePath)
+            .Where(detail => detail is not null)
+            .Cast<string>()
+            .ToArray();
+
+        return details.Length == 0
+            ? "No live SQLite store detected."
+            : string.Join(Environment.NewLine, details);
+    }
+
+    private static IReadOnlyList<KnownSessionStore> GetKnownStores(
+        Func<bool, IReadOnlyList<KnownSessionStore>> knownStoresProvider,
+        bool deepScan)
+    {
+        if (knownStoresProvider is null)
+        {
+            throw new ArgumentNullException(nameof(knownStoresProvider));
+        }
+
+        var provideKnownStores = knownStoresProvider;
+
+        var knownStores = provideKnownStores(deepScan);
+        if (knownStores is null)
+        {
+            throw new InvalidOperationException("Known stores provider returned no stores.");
+        }
+
+        return knownStores;
+    }
+
+    private sealed class SearchCancellationState : IDisposable
+    {
+        private CancellationTokenSource? _current;
+
+        public CancellationToken Begin()
+        {
+            var replacement = new CancellationTokenSource();
+            var previous = Interlocked.Exchange(ref _current, replacement);
+            previous?.Cancel();
+            previous?.Dispose();
+            return replacement.Token;
+        }
+
+        public CancellationTokenSource? Snapshot() => Volatile.Read(ref _current);
+
+        public void Dispose()
+        {
+            var current = Interlocked.Exchange(ref _current, null);
+            current?.Cancel();
+            current?.Dispose();
+        }
+    }
+}