feat(gameprofiles): enable runtime content hot-swapping for active game sessions

GenHub/GenHub.Core/Constants/GitHubConstants.cs

@@ -14,6 +14,12 @@ public static class GitHubConstants
     /// <summary>Default rate limit reset period in hours.</summary>
     public const int DefaultRateLimitResetHours = 1;
 
+    /// <summary>Environment variable name for standard GitHub token.</summary>
+    public const string GitHubTokenEnvVar = "GITHUB_TOKEN";
+
+    /// <summary>Environment variable name for GenHub-specific GitHub token.</summary>
+    public const string GenHubTokenEnvVar = "GENHUB_GITHUB_TOKEN";
+
     // Build parsing constants
 
     /// <summary>String identifier for Zero Hour game variant.</summary>

GenHub/GenHub.Core/Interfaces/Github/IGitHubApiClient.cs

@@ -13,6 +13,11 @@ public interface IGitHubApiClient
     /// </summary>
     bool IsAuthenticated { get; }
 
+    /// <summary>
+    /// Gets a value indicating whether the GitHub API rate limit is reached.
+    /// </summary>
+    bool IsRateLimited { get; }
+
     /// <summary>
     /// Gets the latest release from the specified repository.
     /// </summary>
@@ -121,6 +126,11 @@ Task DownloadArtifactAsync(
     /// <param name="token">The GitHub token.</param>
     void SetAuthenticationToken(SecureString token);
 
+    /// <summary>
+    /// Clears any configured authentication token.
+    /// </summary>
+    void ClearAuthenticationToken();
+
     /// <summary>
     /// Gets the currently authenticated user.
     /// </summary>

GenHub/GenHub.Core/Interfaces/UserData/IProfileContentLinker.cs

@@ -79,6 +79,13 @@ Task<OperationResult<bool>> UpdateProfileUserDataAsync(
     /// <returns>The active profile ID, or null if no profile is active.</returns>
     string? GetActiveProfileId();
 
+    /// <summary>
+    /// Gets the currently active profile ID for the specified game type (if any).
+    /// </summary>
+    /// <param name="targetGame">The target game type.</param>
+    /// <returns>The active profile ID for the specified game, or null if none is active.</returns>
+    string? GetActiveProfileId(GameType targetGame);
+
     /// <summary>
     /// Checks if a profile has its user data currently active.
     /// </summary>

GenHub/GenHub.Core/Models/Workspace/ContentHotswapClassification.cs

@@ -0,0 +1,75 @@
+using System.Linq;
+using GenHub.Core.Models.Enums;
+using GenHub.Core.Models.Manifest;
+
+namespace GenHub.Core.Models.Workspace;
+
+/// <summary>
+/// Classifies content types based on whether they can be safely hot-swapped during an active game session.
+/// Hotswappable content is deployed to the user Documents directory and read dynamically by the game engine.
+/// Locked content modifies game process executables, BIG archives in the workspace, or memory-sensitive assets.
+/// </summary>
+public static class ContentHotswapClassification
+{
+    /// <summary>
+    /// Determines whether the specified content type can be hot-swapped while the game is running.
+    /// </summary>
+    /// <param name="contentType">The content type to evaluate.</param>
+    /// <returns><c>true</c> if the content type is hotswappable; otherwise, <c>false</c>.</returns>
+    public static bool IsHotswappable(ContentType contentType)
+    {
+        return contentType switch
+        {
+            ContentType.Map => true,
+            ContentType.MapPack => true,
+            ContentType.Replay => true,
+            _ => false,
+        };
+    }
+
+    /// <summary>
+    /// Determines whether the specified manifest can be hot-swapped while the game is running.
+    /// </summary>
+    /// <param name="manifest">The manifest to evaluate.</param>
+    /// <returns><c>true</c> if the manifest is hotswappable; otherwise, <c>false</c>.</returns>
+    public static bool IsHotswappable(ContentManifest manifest)
+    {
+        ArgumentNullException.ThrowIfNull(manifest);
+
+        if (!IsHotswappable(manifest.ContentType))
+        {
+            return false;
+        }
+
+        var files = ManifestVariantResolver.ResolveFiles(manifest);
+        if (files.Count == 0 && (manifest.Variants.Count > 0 || manifest.Files.Count > 0))
+        {
+            return false;
+        }
+
+        return files.All(f =>
+            f.InstallTarget != ContentInstallTarget.Workspace &&
+            f.InstallTarget != ContentInstallTarget.System);
+    }
+
+    /// <summary>
+    /// Determines whether the specified content type is locked and cannot be modified during an active game session.
+    /// </summary>
+    /// <param name="contentType">The content type to evaluate.</param>
+    /// <returns><c>true</c> if the content type is locked during active sessions; otherwise, <c>false</c>.</returns>
+    public static bool IsLocked(ContentType contentType)
+    {
+        return !IsHotswappable(contentType);
+    }
+
+    /// <summary>
+    /// Determines whether the specified manifest is locked and cannot be modified during an active game session.
+    /// </summary>
+    /// <param name="manifest">The manifest to evaluate.</param>
+    /// <returns><c>true</c> if the manifest is locked during active sessions; otherwise, <c>false</c>.</returns>
+    public static bool IsLocked(ContentManifest manifest)
+    {
+        ArgumentNullException.ThrowIfNull(manifest);
+        return !IsHotswappable(manifest);
+    }
+}

GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/Services/OctokitGitHubApiClientTests.cs

@@ -132,4 +132,118 @@ public void SetAuthenticationToken_ThrowsWithMockClient()
         // Act & Assert
         Assert.Throws<InvalidOperationException>(() => api.SetAuthenticationToken(secureToken));
     }
+
+    /// <summary>
+    /// Verifies that credentials are automatically loaded from IGitHubTokenStorage.
+    /// </summary>
+    [Fact]
+    public void EnsureCredentialsLoaded_LoadsFromTokenStorage()
+    {
+        // Arrange
+        var concreteClient = new GitHubClient(new ProductHeaderValue("test"));
+        var secureToken = new SecureString();
+        foreach (char c in "stored-secret-pat")
+        {
+            secureToken.AppendChar(c);
+        }
+
+        var tokenStorageMock = new Mock<GenHub.Core.Interfaces.GitHub.IGitHubTokenStorage>();
+        tokenStorageMock.Setup(x => x.HasToken()).Returns(true);
+        tokenStorageMock.Setup(x => x.LoadTokenAsync()).ReturnsAsync(secureToken);
+
+        var api = new OctokitGitHubApiClient(
+            concreteClient,
+            Mock.Of<IHttpClientFactory>(),
+            Mock.Of<ILogger<OctokitGitHubApiClient>>(),
+            Mock.Of<IMemoryCache>(),
+            tokenStorageMock.Object);
+
+        // Act & Assert
+        api.IsAuthenticated.Should().BeTrue();
+        concreteClient.Credentials.Should().NotBeNull();
+        concreteClient.Credentials.Password.Should().Be("stored-secret-pat");
+    }
+
+    /// <summary>
+    /// Verifies that ClearAuthenticationToken resets credentials to Anonymous.
+    /// </summary>
+    [Fact]
+    public void ClearAuthenticationToken_ResetsCredentialsToAnonymous()
+    {
+        // Arrange
+        var concreteClient = new GitHubClient(new ProductHeaderValue("test"));
+        var api = new OctokitGitHubApiClient(
+            concreteClient,
+            Mock.Of<IHttpClientFactory>(),
+            Mock.Of<ILogger<OctokitGitHubApiClient>>(),
+            Mock.Of<IMemoryCache>());
+
+        var secureToken = new SecureString();
+        foreach (char c in "test-token")
+        {
+            secureToken.AppendChar(c);
+        }
+
+        api.SetAuthenticationToken(secureToken);
+        api.IsAuthenticated.Should().BeTrue();
+
+        // Act
+        api.ClearAuthenticationToken();
+
+        // Assert
+        api.IsAuthenticated.Should().BeFalse();
+        concreteClient.Credentials.Should().Be(Credentials.Anonymous);
+    }
+
+    /// <summary>
+    /// Verifies that rate limit tracker is updated when RateLimitExceededException occurs.
+    /// </summary>
+    /// <returns>A task representing the asynchronous test operation.</returns>
+    [Fact]
+    public async Task GetLatestReleaseAsync_WhenRateLimitExceeded_UpdatesTrackerAsync()
+    {
+        // Arrange
+        var resetEpoch = ((DateTimeOffset)DateTime.UtcNow.AddMinutes(30)).ToUnixTimeSeconds();
+        var headers = new Dictionary<string, string>
+        {
+            ["X-RateLimit-Reset"] = resetEpoch.ToString(),
+        };
+        var responseMock = new Mock<Octokit.IResponse>();
+        responseMock.SetupGet(x => x.Headers).Returns(headers);
+        var rateLimit = new Octokit.RateLimit(60, 0, resetEpoch);
+        var apiInfo = new Octokit.ApiInfo(new Dictionary<string, Uri>(), new List<string>(), new List<string>(), "etag", rateLimit);
+        responseMock.SetupGet(x => x.ApiInfo).Returns(apiInfo);
+
+        var rateLimitException = new RateLimitExceededException(responseMock.Object);
+
+        var releasesClientMock = new Mock<Octokit.IReleasesClient>();
+        releasesClientMock
+            .Setup(x => x.GetLatest(It.IsAny<string>(), It.IsAny<string>()))
+            .ThrowsAsync(rateLimitException);
+
+        var repositoriesClientMock = new Mock<Octokit.IRepositoriesClient>();
+        repositoriesClientMock
+            .SetupGet(x => x.Release)
+            .Returns(releasesClientMock.Object);
+
+        var gitHubClientMock = new Mock<Octokit.IGitHubClient>();
+        gitHubClientMock.SetupGet(x => x.Repository).Returns(repositoriesClientMock.Object);
+
+        var tracker = new GitHubRateLimitTracker(Mock.Of<ILogger<GitHubRateLimitTracker>>());
+
+        var api = new OctokitGitHubApiClient(
+            gitHubClientMock.Object,
+            Mock.Of<IHttpClientFactory>(),
+            Mock.Of<ILogger<OctokitGitHubApiClient>>(),
+            Mock.Of<IMemoryCache>(),
+            rateLimitTracker: tracker);
+
+        // Act
+        var result = await api.GetLatestReleaseAsync("owner", "repo");
+
+        // Assert
+        result.Should().BeNull();
+        api.IsRateLimited.Should().BeTrue();
+        tracker.IsAtLimit.Should().BeTrue();
+    }
 }

GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/GameProcessManagerTests.cs

@@ -538,7 +538,9 @@ public static LauncherHarness Create(
                 // Batch has no $$. PowerShell's own parent is the batch host, so it can report the
                 // PID the harness needs. If PowerShell is unavailable the loop simply writes
                 // nothing and Dispose falls back to leaving the launcher alone.
-                var recordPid = $"for /f %%p in ('powershell -NoProfile -Command \"(Get-Process -Id $PID).Parent.Id\"') do @echo %%p> \"{Path.Combine(workingDirectory, LauncherPidFileName)}\"\n";
+                var recordPid = exitImmediately
+                    ? string.Empty
+                    : $"for /f %%p in ('powershell -NoProfile -Command \"(Get-Process -Id $PID).Parent.Id\"') do @echo %%p> \"{Path.Combine(workingDirectory, LauncherPidFileName)}\"\n";
 
                 // Leave the working directory afterwards: a batch host holds its current directory
                 // open, which would defeat the cleanup delete for the launcher's whole lifetime.
@@ -554,9 +556,10 @@ public static LauncherHarness Create(
                 var spawn = spawnChild ? $"\"{childPath}\" {LauncherLifetimeSeconds} &\n" : string.Empty;
                 var linger = exitImmediately ? string.Empty : $"sleep {LauncherLifetimeSeconds}\n";
                 var complain = stderrMessage is null ? string.Empty : $"echo \"{stderrMessage}\" >&2\n";
+                var recordPid = exitImmediately ? string.Empty : $"echo $$ > \"{Path.Combine(workingDirectory, LauncherPidFileName)}\"\n";
 
                 // The harness does not start the launcher, so the launcher reports its own PID.
-                script = $"#!/bin/bash\necho $$ > \"{Path.Combine(workingDirectory, LauncherPidFileName)}\"\n{complain}{spawn}{linger}";
+                script = $"#!/bin/bash\n{recordPid}{complain}{spawn}{linger}";
             }
 
             File.WriteAllText(launcherPath, script);