feat(connections): swap module, AddConnections wiring, host registration

- Add ConnectionComponentModule handling workspace:info:swap:* select menus
- Add ConnectionServiceCollectionExtensions.AddConnections() DI extension
- Wire ConnectionOptions validation and AddConnections() into Program.cs
- Add project reference for Connections in Host.csproj
- Add ConnectionRegistrationTests verifying IConnectionSupervisor and IConnectionStore resolve

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

Author: HandyS11

src/RustPlusBot.Features.Connections/ConnectionServiceCollectionExtensions.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Discord;
+using RustPlusBot.Features.Connections.Hosting;
+using RustPlusBot.Features.Connections.Listening;
+using RustPlusBot.Features.Connections.Supervisor;
+
+namespace RustPlusBot.Features.Connections;
+
+/// <summary>DI registration for the live-connection feature.</summary>
+public static class ConnectionServiceCollectionExtensions
+{
+    /// <summary>Registers the socket source, supervisor, module seam, and hosted service.</summary>
+    /// <param name="services">The service collection to add to.</param>
+    /// <returns>The same service collection, for chaining.</returns>
+    public static IServiceCollection AddConnections(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.AddSingleton<IRustSocketSource, RustPlusSocketSource>();
+        services.AddSingleton<IConnectionSupervisor, ConnectionSupervisor>();
+
+        // Contribute this assembly's interaction modules to the Discord layer.
+        services.AddSingleton(new InteractionModuleAssembly(typeof(ConnectionServiceCollectionExtensions).Assembly));
+
+        services.AddHostedService<ConnectionHostedService>();
+
+        return services;
+    }
+}

src/RustPlusBot.Features.Connections/Modules/ConnectionComponentModule.cs

@@ -0,0 +1,54 @@
+using Discord;
+using Discord.Interactions;
+using Microsoft.Extensions.DependencyInjection;
+using RustPlusBot.Features.Connections.Supervisor;
+using RustPlusBot.Features.Workspace;
+using RustPlusBot.Persistence.Connections;
+
+namespace RustPlusBot.Features.Connections.Modules;
+
+/// <summary>Handles the #info "switch active player" select (ManageGuild).</summary>
+/// <param name="scopeFactory">Creates a short-lived DI scope per interaction.</param>
+public sealed class ConnectionComponentModule(IServiceScopeFactory scopeFactory)
+    : InteractionModuleBase<SocketInteractionContext>
+{
+    /// <summary>Promotes the chosen pooled credential to active and restarts the socket on it.</summary>
+    /// <param name="serverIdRaw">The server id captured from the custom id.</param>
+    /// <param name="selectedValues">The selected credential id (expects exactly one).</param>
+    // Custom id: WorkspaceComponentIds.ServerInfoSwapPrefix + "*" = "workspace:info:swap:*"
+    [ComponentInteraction(WorkspaceComponentIds.ServerInfoSwapPrefix + "*")]
+    [RequireUserPermission(GuildPermission.ManageGuild)]
+    public async Task SwapAsync(string serverIdRaw, string[] selectedValues)
+    {
+        ArgumentNullException.ThrowIfNull(selectedValues);
+        if (Context.Guild is null)
+        {
+            await RespondAsync("This control must be used in a server.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        if (!Guid.TryParse(serverIdRaw, out var serverId)
+            || selectedValues.Length == 0
+            || !Guid.TryParse(selectedValues[0], out var credentialId))
+        {
+            await RespondAsync("That selection wasn't valid.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        await DeferAsync(ephemeral: true).ConfigureAwait(false);
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
+        {
+            var store = scope.ServiceProvider.GetRequiredService<IConnectionStore>();
+            if (!await store.PromoteAsync(Context.Guild.Id, serverId, credentialId).ConfigureAwait(false))
+            {
+                await FollowupAsync("That player isn't available to activate.", ephemeral: true).ConfigureAwait(false);
+                return;
+            }
+
+            var supervisor = scope.ServiceProvider.GetRequiredService<IConnectionSupervisor>();
+            await supervisor.EnsureConnectionAsync(Context.Guild.Id, serverId).ConfigureAwait(false);
+            await FollowupAsync("Switching active player…", ephemeral: true).ConfigureAwait(false);
+        }
+    }
+}

src/RustPlusBot.Host/Program.cs

@@ -6,6 +6,7 @@
 using RustPlusBot.Abstractions.Events;
 using RustPlusBot.Abstractions.Time;
 using RustPlusBot.Discord;
+using RustPlusBot.Features.Connections;
 using RustPlusBot.Features.Pairing;
 using RustPlusBot.Features.Workspace;
 using RustPlusBot.Host.Credentials;
@@ -37,6 +38,16 @@
         "Pairing:MaxRetryDelay must be at least InitialRetryDelay.")
     .ValidateOnStart();
 builder.Services.AddPairing();
+builder.Services.AddOptions<ConnectionOptions>()
+    .Bind(builder.Configuration.GetSection("Connections"))
+    .Validate(static o => o.ConnectTimeout > TimeSpan.Zero, "Connections:ConnectTimeout must be positive.")
+    .Validate(static o => o.InitialRetryDelay > TimeSpan.Zero, "Connections:InitialRetryDelay must be positive.")
+    .Validate(static o => o.MaxRetryDelay >= o.InitialRetryDelay,
+        "Connections:MaxRetryDelay must be at least InitialRetryDelay.")
+    .Validate(static o => o.HeartbeatInterval > TimeSpan.Zero, "Connections:HeartbeatInterval must be positive.")
+    .Validate(static o => o.HeartbeatTimeout > TimeSpan.Zero, "Connections:HeartbeatTimeout must be positive.")
+    .ValidateOnStart();
+builder.Services.AddConnections();
 
 var host = builder.Build();
 

src/RustPlusBot.Host/RustPlusBot.Host.csproj

@@ -20,5 +20,6 @@
     <ProjectReference Include="..\RustPlusBot.Abstractions\RustPlusBot.Abstractions.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Workspace\RustPlusBot.Features.Workspace.csproj" />
     <ProjectReference Include="..\RustPlusBot.Features.Pairing\RustPlusBot.Features.Pairing.csproj" />
+    <ProjectReference Include="..\RustPlusBot.Features.Connections\RustPlusBot.Features.Connections.csproj" />
   </ItemGroup>
 </Project>

tests/RustPlusBot.Features.Connections.Tests/ConnectionRegistrationTests.cs

@@ -0,0 +1,37 @@
+using Discord.WebSocket;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using RustPlusBot.Abstractions.Credentials;
+using RustPlusBot.Abstractions.Events;
+using RustPlusBot.Abstractions.Time;
+using RustPlusBot.Discord.Notifications;
+using RustPlusBot.Features.Connections;
+using RustPlusBot.Features.Connections.Supervisor;
+using RustPlusBot.Persistence;
+using RustPlusBot.Persistence.Connections;
+
+namespace RustPlusBot.Features.Connections.Tests;
+
+public sealed class ConnectionRegistrationTests
+{
+    [Fact]
+    public async Task Services_Resolve()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton(new DiscordSocketClient());
+        services.AddSingleton<IClock, SystemClock>();
+        services.AddSingleton<IEventBus, InMemoryEventBus>();
+        services.AddSingleton(Substitute.For<ICredentialProtector>());
+        services.AddSingleton(Substitute.For<IUserDmSender>());
+        services.AddLogging();
+        services.AddBotPersistence("DataSource=:memory:");
+        services.AddOptions<ConnectionOptions>();
+        services.AddConnections();
+
+        await using var provider = services.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true });
+
+        Assert.NotNull(provider.GetRequiredService<IConnectionSupervisor>());
+        await using var scope = provider.CreateAsyncScope();
+        Assert.NotNull(scope.ServiceProvider.GetRequiredService<IConnectionStore>());
+    }
+}