feat(workspace): refresh #info on ServerCredentialsChangedEvent

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Workspace/Hosting/WorkspaceHostedService.cs

@@ -21,6 +21,7 @@ internal sealed class WorkspaceHostedService(
 {
     private readonly CancellationTokenSource _cts = new();
     private Task? _connectionStatusLoop;
+    private Task? _serverCredentialsLoop;
     private Task? _serverRegisteredLoop;
     private bool _startupDone;
 
@@ -34,6 +35,7 @@ public Task StartAsync(CancellationToken cancellationToken)
         client.ChannelDestroyed += OnChannelDestroyedAsync;
         _serverRegisteredLoop = Task.Run(() => ConsumeServerRegisteredAsync(_cts.Token), CancellationToken.None);
         _connectionStatusLoop = Task.Run(() => ConsumeConnectionStatusAsync(_cts.Token), CancellationToken.None);
+        _serverCredentialsLoop = Task.Run(() => ConsumeServerCredentialsAsync(_cts.Token), CancellationToken.None);
         return Task.CompletedTask;
     }
 
@@ -45,7 +47,7 @@ public async Task StopAsync(CancellationToken cancellationToken)
         await _cts.CancelAsync().ConfigureAwait(false);
         foreach (var loop in new[]
                  {
-                     _serverRegisteredLoop, _connectionStatusLoop
+                     _serverRegisteredLoop, _connectionStatusLoop, _serverCredentialsLoop
                  })
         {
             if (loop is null)
@@ -136,6 +138,32 @@ await reconciler.ReconcileServerAsync(changed.GuildId, changed.ServerId, cancell
         }
     }
 
+    private async Task ConsumeServerCredentialsAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await foreach (var changed in eventBus.SubscribeAsync<ServerCredentialsChangedEvent>(cancellationToken)
+                               .ConfigureAwait(false))
+            {
+                var scope = scopeFactory.CreateAsyncScope();
+                await using (scope.ConfigureAwait(false))
+                {
+                    var reconciler = scope.ServiceProvider.GetRequiredService<IWorkspaceReconciler>();
+                    await reconciler.ReconcileServerAsync(changed.GuildId, changed.ServerId, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // Shutting down.
+        }
+        catch (Exception ex) // Broad catch is intentional: a faulting consumer must not crash the host.
+        {
+            logger.LogError(ex, "ServerCredentialsChanged consumer faulted.");
+        }
+    }
+
     private async Task ConsumeServerRegisteredAsync(CancellationToken cancellationToken)
     {
         // Subscription is registered when this loop first calls SubscribeAsync; the in-process bus does

tests/RustPlusBot.Features.Workspace.Tests/Hosting/WorkspaceConnectionStatusTests.cs

@@ -40,4 +40,34 @@ public async Task ConnectionStatusChanged_ReconcilesThatServer()
 
         await service.StopAsync(default);
     }
+
+    [Fact]
+    public async Task ServerCredentialsChanged_ReconcilesThatServer()
+    {
+        var reconciler = Substitute.For<IWorkspaceReconciler>();
+        var services = new ServiceCollection();
+        services.AddScoped(_ => reconciler);
+        await using var provider = services.BuildServiceProvider();
+
+        var bus = new InMemoryEventBus();
+        var client = new DiscordSocketClient();
+        var service = new WorkspaceHostedService(client, bus,
+            provider.GetRequiredService<IServiceScopeFactory>(),
+            NullLogger<WorkspaceHostedService>.Instance);
+
+        await service.StartAsync(default);
+        var serverId = Guid.NewGuid();
+        var deadline = DateTimeOffset.UtcNow.AddSeconds(20);
+        while (DateTimeOffset.UtcNow < deadline
+               && !reconciler.ReceivedCalls().Any(c =>
+                   c.GetMethodInfo().Name == nameof(IWorkspaceReconciler.ReconcileServerAsync)))
+        {
+            await bus.PublishAsync(new ServerCredentialsChangedEvent(10UL, serverId));
+            await Task.Delay(20);
+        }
+
+        await reconciler.Received().ReconcileServerAsync(10UL, serverId, Arg.Any<CancellationToken>());
+
+        await service.StopAsync(default);
+    }
 }