feat(connections): IAfkState read seam over the AFK tracker

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

Author: HandyS11

src/RustPlusBot.Features.Connections/ConnectionServiceCollectionExtensions.cs

@@ -22,6 +22,7 @@ public static IServiceCollection AddConnections(this IServiceCollection services
         services.AddSingleton<IConnectionSupervisor>(sp => sp.GetRequiredService<ConnectionSupervisor>());
         services.AddSingleton<ITeamChatSender>(sp => sp.GetRequiredService<ConnectionSupervisor>());
         services.AddSingleton<IRustServerQuery>(sp => sp.GetRequiredService<ConnectionSupervisor>());
+        services.AddSingleton<IAfkState>(sp => sp.GetRequiredService<ConnectionSupervisor>());
         services.AddScoped<IServerRemovalService, ServerRemovalService>();
 
         // Contribute this assembly's interaction modules to the Discord layer.

src/RustPlusBot.Features.Connections/Listening/IAfkState.cs

@@ -0,0 +1,18 @@
+namespace RustPlusBot.Features.Connections.Listening;
+
+/// <summary>One currently-AFK team member.</summary>
+/// <param name="SteamId">Steam64 id.</param>
+/// <param name="Name">In-game display name.</param>
+/// <param name="StillFor">How long the member has been continuously still.</param>
+public sealed record AfkMember(ulong SteamId, string Name, TimeSpan StillFor);
+
+/// <summary>Reads the live AFK state computed by the connection poll loop.</summary>
+public interface IAfkState
+{
+    /// <summary>Gets the currently-AFK members, or null when there is no live socket.</summary>
+    /// <param name="guildId">The owning guild snowflake.</param>
+    /// <param name="serverId">The target server id.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The currently-AFK members, or null when there is no live socket.</returns>
+    Task<IReadOnlyList<AfkMember>?> GetAfkMembersAsync(ulong guildId, Guid serverId, CancellationToken cancellationToken);
+}

src/RustPlusBot.Features.Connections/Listening/TeamStateTracker.cs

@@ -115,6 +115,23 @@ private void UpdateAfk(
         }
     }
 
+    /// <summary>The members currently flagged AFK and how long each has been still, as of <paramref name="now"/>.</summary>
+    /// <param name="now">The current wall-clock time used to compute each member's still duration.</param>
+    public IReadOnlyList<AfkMember> CurrentAfk(DateTimeOffset now)
+    {
+        var result = new List<AfkMember>();
+        foreach (var id in _afk)
+        {
+            if (_baseline is not null && _baseline.TryGetValue(id, out var m))
+            {
+                var since = _stillSince.TryGetValue(id, out var s) ? s : now;
+                result.Add(new AfkMember(id, m.Name, now - since));
+            }
+        }
+
+        return result;
+    }
+
     private static (float X, float Y)? ResolveDeathLocation(
         ulong steamId, TeamInfoSnapshot snapshot, TeamMemberSnapshot previous)
     {

src/RustPlusBot.Features.Connections/Supervisor/ConnectionSupervisor.cs

@@ -32,7 +32,7 @@ internal sealed partial class ConnectionSupervisor(
     IEventBus eventBus,
     IClock clock,
     IOptions<ConnectionOptions> options,
-    ILogger<ConnectionSupervisor> logger) : IConnectionSupervisor, ITeamChatSender, IRustServerQuery, IAsyncDisposable
+    ILogger<ConnectionSupervisor> logger) : IConnectionSupervisor, ITeamChatSender, IRustServerQuery, IAfkState, IAsyncDisposable
 {
     private readonly ConcurrentDictionary<(ulong Guild, Guid Server), Handle> _connections = new();
     private readonly SemaphoreSlim _gate = new(1, 1);
@@ -259,6 +259,18 @@ public async Task<TeamChatSendResult> SendAsync(
         }
     }
 
+    /// <inheritdoc />
+    public Task<IReadOnlyList<AfkMember>?> GetAfkMembersAsync(
+        ulong guildId, Guid serverId, CancellationToken cancellationToken)
+    {
+        if (_liveSockets.TryGetValue((guildId, serverId), out var live))
+        {
+            return Task.FromResult<IReadOnlyList<AfkMember>?>(live.Tracker.CurrentAfk(clock.UtcNow));
+        }
+
+        return Task.FromResult<IReadOnlyList<AfkMember>?>(null);
+    }
+
     [LoggerMessage(Level = LogLevel.Error, Message = "Connection loop for server {ServerId} faulted.")]
     private static partial void LogLoopFaulted(ILogger logger, Exception exception, Guid serverId);
 
@@ -398,10 +410,11 @@ void OnTeamMessage(object? sender, TeamChatLine line)
         var dims = await connection.GetMapDimensionsAsync(_options.HeartbeatTimeout, ct).ConfigureAwait(false);
         var rigs = await GetRigPositionsAsync(key.Server, connection, ct).ConfigureAwait(false);
 
+        var tracker = new TeamStateTracker();
         connection.TeamMessageReceived += OnTeamMessage;
-        _liveSockets[key] = new LiveSocket(connection, activeSteamId);
+        _liveSockets[key] = new LiveSocket(connection, activeSteamId, tracker);
         using var pollCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
-        var markerPoll = Task.Run(() => PollMarkersAsync(key, connection, dims, rigs, pollCts.Token),
+        var markerPoll = Task.Run(() => PollMarkersAsync(key, connection, dims, rigs, tracker, pollCts.Token),
             CancellationToken.None);
         try
         {
@@ -448,11 +461,11 @@ private async Task PollMarkersAsync(
         IRustServerConnection connection,
         MapDimensions? dims,
         IReadOnlyList<RigPosition> rigs,
+        TeamStateTracker tracker,
         CancellationToken ct)
     {
         IReadOnlyList<MapMarkerSnapshot>? previous = null;
         var rigsInRadius = new HashSet<RigKind>();
-        var tracker = new TeamStateTracker();
         while (!ct.IsCancellationRequested)
         {
             var anyCh47 = false;
@@ -755,7 +768,7 @@ private readonly record struct Prepared(
         ulong SteamId,
         string PlayerToken);
 
-    private sealed record LiveSocket(IRustServerConnection Connection, ulong ActiveSteamId);
+    private sealed record LiveSocket(IRustServerConnection Connection, ulong ActiveSteamId, TeamStateTracker Tracker);
 
     private sealed class Handle(CancellationTokenSource cts, Task runTask) : IAsyncDisposable
     {

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

@@ -0,0 +1,31 @@
+using RustPlusBot.Features.Connections.Listening;
+
+namespace RustPlusBot.Features.Connections.Tests;
+
+public sealed class AfkStateTests
+{
+    [Fact]
+    public void CurrentAfk_lists_member_with_still_duration()
+    {
+        var t = new TeamStateTracker();
+        var t0 = DateTimeOffset.UnixEpoch;
+        var m = new TeamMemberSnapshot(1, "Bob", 0, 0, true, true, t0, t0);
+        t.Diff(new TeamInfoSnapshot(1, [m]), t0, TimeSpan.FromMinutes(5), 1f);
+        t.Diff(new TeamInfoSnapshot(1, [m]), t0.AddMinutes(6), TimeSpan.FromMinutes(5), 1f); // BecameAfk
+
+        var afk = t.CurrentAfk(t0.AddMinutes(6));
+        var bob = Assert.Single(afk);
+        Assert.Equal(1UL, bob.SteamId);
+        Assert.Equal(TimeSpan.FromMinutes(6), bob.StillFor);
+    }
+
+    [Fact]
+    public void CurrentAfk_empty_when_nobody_afk()
+    {
+        var t = new TeamStateTracker();
+        var t0 = DateTimeOffset.UnixEpoch;
+        var m = new TeamMemberSnapshot(1, "Bob", 0, 0, true, true, t0, t0);
+        t.Diff(new TeamInfoSnapshot(1, [m]), t0, TimeSpan.FromMinutes(5), 1f);
+        Assert.Empty(t.CurrentAfk(t0.AddMinutes(1)));
+    }
+}