Change lightfinder permissions for groups

.gitignore

@@ -350,7 +350,4 @@ MigrationBackup/
 .ionide/
 
 # docker run data
-Docker/run/data/
+Docker/run/data/
-
-#idea files
-*.idea

LightlessSyncServer/LightlessSyncAuthService/LightlessSyncAuthService.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>

LightlessSyncServer/LightlessSyncAuthService/Services/GeoIPService.cs

@@ -44,14 +44,12 @@ public class GeoIPService : IHostedService
             if (_dbReader!.TryCity(ip, out var response))
             {
                 string? continent = response?.Continent.Code;
-                string? countryIso = response?.Country.IsoCode;
 
                 if (!string.IsNullOrEmpty(continent) &&
                     string.Equals(continent, "NA", StringComparison.Ordinal)
                     && response?.Location.Longitude != null)
                 {
-                    if (response.Location.Longitude < -102 &&
+                    if (response.Location.Longitude < -102)
-                        !string.Equals(countryIso, "CA", StringComparison.OrdinalIgnoreCase))
                     {
                         continent = "NA-W";
                     }
@@ -59,8 +57,6 @@ public class GeoIPService : IHostedService
                     {
                         continent = "NA-E";
                     }
-
-                    _logger.LogDebug("Connecting {countryIso} to {continent}", countryIso, continent);
                 }
 
                 return continent ?? "*";

LightlessSyncServer/LightlessSyncServer/Configuration/ChatZoneOverridesOptions.cs

@@ -1,16 +0,0 @@
-using System.Collections.Generic;
-
-namespace LightlessSyncServer.Configuration;
-
-public sealed class ChatZoneOverridesOptions
-{
-    public List<ChatZoneOverride>? Zones { get; set; }
-}
-
-public sealed class ChatZoneOverride
-{
-    public string Key { get; set; } = string.Empty;
-    public string? DisplayName { get; set; }
-    public List<string>? TerritoryNames { get; set; }
-    public List<ushort>? TerritoryIds { get; set; }
-}

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Chat.cs

@@ -1,7 +1,11 @@
+using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
 using System.Text.Json;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Dto.Chat;
+using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Models;
 using LightlessSyncServer.Services;
 using LightlessSyncServer.Utils;
@@ -9,11 +13,12 @@ using LightlessSyncShared.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
+
 namespace LightlessSyncServer.Hubs;
 
 public partial class LightlessHub
 {
-    private const int MaxChatMessageLength = 200;
+    private const int MaxChatMessageLength = 400;
     private const int ChatRateLimitMessages = 7;
     private static readonly TimeSpan ChatRateLimitWindow = TimeSpan.FromMinutes(1);
     private static readonly ConcurrentDictionary<string, ChatRateLimitState> ChatRateLimiters = new(StringComparer.Ordinal);
@@ -41,10 +46,8 @@ public partial class LightlessHub
 
         var groupInfos = await DbContext.Groups
             .AsNoTracking()
-            .Where(g => g.ChatEnabled
+            .Where(g => g.OwnerUID == userUid
-                        && (g.OwnerUID == userUid
                         || DbContext.GroupPairs.Any(p => p.GroupGID == g.GID && p.GroupUserUID == userUid))
-                        )
             .ToListAsync()
             .ConfigureAwait(false);
 
@@ -64,7 +67,7 @@ public partial class LightlessHub
                     descriptor,
                     displayName,
                     g.GID,
-                    string.Equals(g.OwnerUID, userUid, StringComparison.Ordinal));
+                    g.OwnerUID == userUid);
             })
             .OrderBy(info => info.DisplayName, StringComparer.OrdinalIgnoreCase)
             .ToList();
@@ -82,18 +85,14 @@ public partial class LightlessHub
 
         if (userRecord.ChatBanned)
         {
-            TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID), "clearing presence for banned user");
+            _chatChannelService.RemovePresence(UserUID);
             await NotifyChatBanAsync(UserUID).ConfigureAwait(false);
             return;
         }
 
         if (!presence.IsActive)
         {
-            if (!TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID, channel), "removing chat presence", channel))
+            _chatChannelService.RemovePresence(UserUID, channel);
-            {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "We couldn't update your chat presence. Please try again.").ConfigureAwait(false);
-            }
-
             return;
         }
 
@@ -127,22 +126,14 @@ public partial class LightlessHub
                     }
                 }
 
-                if (!TryInvokeChatService(
+                _chatChannelService.UpdateZonePresence(
-                        () => _chatChannelService.UpdateZonePresence(
+                    UserUID,
-                            UserUID,
+                    definition,
-                            definition,
+                    channel.WorldId,
-                            channel.WorldId,
+                    presence.TerritoryId,
-                            presence.TerritoryId,
+                    hashedCid,
-                            hashedCid,
+                    isLightfinder,
-                            isLightfinder,
+                    isActive: true);
-                            isActive: true),
-                        "updating zone chat presence",
-                        channel))
-                {
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Zone chat is temporarily unavailable. Please try again.").ConfigureAwait(false);
-                    return;
-                }
-
                 break;
 
             case ChatChannelType.Group:
@@ -164,13 +155,6 @@ public partial class LightlessHub
                     throw new HubException("Unsupported chat channel.");
                 }
 
-                if (!group.ChatEnabled)
-                {
-                    TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID, channel), "removing chat presence", channel);
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "This Syncshell chat is disabled.").ConfigureAwait(false);
-                    return;
-                }
-
                 var isMember = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal)
                     || await DbContext.GroupPairs
                         .AsNoTracking()
@@ -184,21 +168,13 @@ public partial class LightlessHub
 
                 var displayName = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;
 
-                if (!TryInvokeChatService(
+                _chatChannelService.UpdateGroupPresence(
-                        () => _chatChannelService.UpdateGroupPresence(
+                    UserUID,
-                            UserUID,
+                    group.GID,
-                            group.GID,
+                    displayName,
-                            displayName,
+                    userData,
-                            userData,
+                    IsValidHashedCid(UserCharaIdent) ? UserCharaIdent : null,
-                            IsValidHashedCid(UserCharaIdent) ? UserCharaIdent : null,
+                    isActive: true);
-                            isActive: true),
-                        "updating group chat presence",
-                        channel))
-                {
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Syncshell chat is temporarily unavailable. Please try again.").ConfigureAwait(false);
-                    return;
-                }
-
                 break;
 
             default:
@@ -216,23 +192,6 @@ public partial class LightlessHub
 
         var channel = request.Channel.WithNormalizedCustomKey();
 
-        if (channel.Type == ChatChannelType.Group)
-        {
-            var groupId = channel.CustomKey ?? string.Empty;
-            var chatEnabled = !string.IsNullOrEmpty(groupId) && await DbContext.Groups
-                .AsNoTracking()
-                .Where(g => g.GID == groupId)
-                .Select(g => g.ChatEnabled)
-                .SingleOrDefaultAsync(RequestAbortedToken)
-                .ConfigureAwait(false);
-
-            if (!chatEnabled)
-            {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "This Syncshell chat is disabled.").ConfigureAwait(false);
-                return;
-            }
-        }
-
         if (await HandleIfChatBannedAsync(UserUID).ConfigureAwait(false))
         {
             throw new HubException("Chat access has been revoked.");
@@ -255,101 +214,119 @@ public partial class LightlessHub
             sanitizedMessage = sanitizedMessage[..MaxChatMessageLength];
         }
 
-        if (channel.Type == ChatChannelType.Zone &&
+        var recipients = _chatChannelService.GetMembers(presence.Channel);
-            !ChatMessageFilter.TryValidate(sanitizedMessage, out var rejectionReason))
+        var recipientsList = recipients.ToList();
+        if (recipientsList.Count == 0)
         {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, rejectionReason).ConfigureAwait(false);
             return;
         }
 
-        try
+        var bannedRecipients = recipientsList.Count == 0
+            ? new List<string>()
+            : await DbContext.Users.AsNoTracking()
+                .Where(u => recipientsList.Contains(u.UID) && u.ChatBanned)
+                .Select(u => u.UID)
+                .ToListAsync(RequestAbortedToken)
+                .ConfigureAwait(false);
+
+        HashSet<string>? bannedSet = null;
+        if (bannedRecipients.Count > 0)
         {
-            var recipients = _chatChannelService.GetMembers(presence.Channel);
+            bannedSet = new HashSet<string>(bannedRecipients, StringComparer.Ordinal);
-            var recipientsList = recipients.ToList();
+            foreach (var bannedUid in bannedSet)
-            if (recipientsList.Count == 0)
             {
-                return;
+                _chatChannelService.RemovePresence(bannedUid);
+                await NotifyChatBanAsync(bannedUid).ConfigureAwait(false);
+            }
+        }
+
+        var deliveryTargets = new Dictionary<string, (string Uid, bool IncludeSensitive)>(StringComparer.Ordinal);
+        foreach (var uid in recipientsList)
+        {
+            if (bannedSet != null && bannedSet.Contains(uid))
+            {
+                continue;
             }
 
-            var bannedRecipients = recipientsList.Count == 0
+            if (_userConnections.TryGetValue(uid, out var connectionId))
-                ? new List<string>()
-                : await DbContext.Users.AsNoTracking()
-                    .Where(u => recipientsList.Contains(u.UID) && u.ChatBanned)
-                    .Select(u => u.UID)
-                    .ToListAsync(RequestAbortedToken)
-                    .ConfigureAwait(false);
-
-            HashSet<string>? bannedSet = null;
-            if (bannedRecipients.Count > 0)
             {
-                bannedSet = new HashSet<string>(bannedRecipients, StringComparer.Ordinal);
+                var includeSensitive = await AllowsLightfinderDetailsAsync(presence.Channel, uid).ConfigureAwait(false);
-                foreach (var bannedUid in bannedSet)
+                if (deliveryTargets.TryGetValue(connectionId, out var existing))
                 {
-                    _chatChannelService.RemovePresence(bannedUid);
+                    deliveryTargets[connectionId] = (existing.Uid, existing.IncludeSensitive || includeSensitive);
-                    await NotifyChatBanAsync(bannedUid).ConfigureAwait(false);
-                }
-            }
-
-            var deliveryTargets = new Dictionary<string, (string Uid, bool IncludeSensitive)>(StringComparer.Ordinal);
-            foreach (var uid in recipientsList)
-            {
-                if (bannedSet != null && bannedSet.Contains(uid))
-                {
-                    continue;
-                }
-
-                if (_userConnections.TryGetValue(uid, out var connectionId))
-                {
-                    if (_chatChannelService.IsTokenMuted(uid, presence.Channel, presence.Participant.Token))
-                    {
-                        continue;
-                    }
-
-                    var includeSensitive = await AllowsLightfinderDetailsAsync(presence.Channel, uid).ConfigureAwait(false);
-                    if (deliveryTargets.TryGetValue(connectionId, out var existing))
-                    {
-                        deliveryTargets[connectionId] = (existing.Uid, existing.IncludeSensitive || includeSensitive);
-                    }
-                    else
-                    {
-                        deliveryTargets[connectionId] = (uid, includeSensitive);
-                    }
                 }
                 else
                 {
-                    _chatChannelService.RemovePresence(uid);
+                    deliveryTargets[connectionId] = (uid, includeSensitive);
                 }
             }
-
+            else
-            if (deliveryTargets.Count == 0)
             {
-                return;
+                _chatChannelService.RemovePresence(uid);
             }
-
-            var timestamp = DateTime.UtcNow;
-            var messageId = _chatChannelService.RecordMessage(presence.Channel, presence.Participant, sanitizedMessage, timestamp);
-            var sendTasks = new List<Task>(deliveryTargets.Count);
-
-            foreach (var (connectionId, target) in deliveryTargets)
-            {
-                var sender = BuildSenderDescriptor(presence.Channel, presence.Participant, target.IncludeSensitive);
-                var payload = new ChatMessageDto(
-                    presence.Channel,
-                    sender,
-                    sanitizedMessage,
-                    timestamp,
-                    messageId);
-
-                sendTasks.Add(Clients.Client(connectionId).Client_ChatReceive(payload));
-            }
-
-            await Task.WhenAll(sendTasks).ConfigureAwait(false);
         }
-        catch (Exception ex)
+
+        if (deliveryTargets.Count == 0)
         {
-            _logger.LogError(ex, "Failed to deliver chat message for {User} in {Channel}", UserUID, DescribeChannel(presence.Channel));
+            return;
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Something went wrong while sending your message. Please try again.").ConfigureAwait(false);
         }
+
+        var timestamp = DateTime.UtcNow;
+        var messageId = _chatChannelService.RecordMessage(presence.Channel, presence.Participant, sanitizedMessage, timestamp);
+        var sendTasks = new List<Task>(deliveryTargets.Count);
+
+        foreach (var (connectionId, target) in deliveryTargets)
+        {
+            var sender = BuildSenderDescriptor(presence.Channel, presence.Participant, target.IncludeSensitive);
+            var payload = new ChatMessageDto(
+                presence.Channel,
+                sender,
+                sanitizedMessage,
+                timestamp,
+                messageId);
+
+            sendTasks.Add(Clients.Client(connectionId).Client_ChatReceive(payload));
+        }
+
+        await Task.WhenAll(sendTasks).ConfigureAwait(false);
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task<ChatParticipantResolveResultDto?> ResolveChatParticipant(ChatParticipantResolveRequestDto request)
+    {
+        var channel = request.Channel.WithNormalizedCustomKey();
+
+        if (!_chatChannelService.TryGetPresence(UserUID, channel, out _))
+        {
+            throw new HubException("Join the chat channel before resolving participants.");
+        }
+
+        if (!_chatChannelService.TryResolveParticipant(channel, request.Token, out var participant))
+        {
+            return null;
+        }
+
+        var viewerAllowsDetails = await ViewerAllowsLightfinderDetailsAsync(channel).ConfigureAwait(false);
+        var includeSensitiveInfo = channel.Type == ChatChannelType.Group || viewerAllowsDetails;
+
+        var sender = BuildSenderDescriptor(channel, participant, includeSensitiveInfo);
+
+        if (!includeSensitiveInfo)
+        {
+            return new ChatParticipantResolveResultDto(channel, sender, null);
+        }
+
+        UserProfileDto? profile = null;
+        if (channel.Type == ChatChannelType.Group)
+        {
+            profile = await LoadChatParticipantProfileAsync(participant.UserUid).ConfigureAwait(false);
+        }
+        else if (participant.IsLightfinder && !string.IsNullOrEmpty(participant.HashedCid))
+        {
+            profile = await LoadChatParticipantProfileAsync(participant.UserUid).ConfigureAwait(false);
+        }
+
+        return new ChatParticipantResolveResultDto(channel, sender, profile);
     }
 
     [Authorize(Policy = "Identified")]
@@ -357,6 +334,12 @@ public partial class LightlessHub
     {
         var channel = request.Channel.WithNormalizedCustomKey();
 
+        if (!_chatChannelService.TryGetPresence(UserUID, channel, out _))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Join the chat channel before reporting messages.").ConfigureAwait(false);
+            return;
+        }
+
         if (!_chatChannelService.TryGetMessage(request.MessageId, out var messageEntry))
         {
             await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Unable to locate the reported message. It may have already expired.").ConfigureAwait(false);
@@ -423,7 +406,7 @@ public partial class LightlessHub
             return;
         }
 
-        /* if (!string.IsNullOrEmpty(messageEntry.SenderUserUid))
+        if (!string.IsNullOrEmpty(messageEntry.SenderUserUid))
         {
             var targetAlreadyPending = await DbContext.ReportedChatMessages
                 .AsNoTracking()
@@ -435,7 +418,7 @@ public partial class LightlessHub
                 await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "This user already has a report pending review.").ConfigureAwait(false);
                 return;
             }
-        } */
+        }
 
         var snapshotEntries = _chatChannelService.GetRecentMessages(messageEntry.Channel, 25);
         var snapshotItems = snapshotEntries
@@ -463,6 +446,7 @@ public partial class LightlessHub
             MessageId = messageEntry.MessageId,
             MessageSentAtUtc = messageEntry.SentAtUtc,
             MessageContent = messageEntry.Message,
+            SenderToken = messageEntry.SenderToken,
             SenderHashedCid = messageEntry.SenderHashedCid,
             SenderDisplayName = messageEntry.SenderUser?.AliasOrUID,
             SenderWasLightfinder = messageEntry.SenderIsLightfinder,
@@ -477,91 +461,6 @@ public partial class LightlessHub
         await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "Thank you. Your report has been queued for moderator review.").ConfigureAwait(false);
     }
 
-    [Authorize(Policy = "Identified")]
-    public async Task SetChatParticipantMute(ChatParticipantMuteRequestDto request)
-    {
-        var channel = request.Channel.WithNormalizedCustomKey();
-
-        if (!_chatChannelService.TryGetPresence(UserUID, channel, out _))
-        {
-            throw new HubException("Join the chat channel before updating mutes.");
-        }
-
-        if (string.IsNullOrWhiteSpace(request.Token))
-        {
-            throw new HubException("Invalid participant.");
-        }
-
-        if (!_chatChannelService.TryGetActiveParticipant(channel, request.Token, out var participant))
-        {
-            throw new HubException("Unable to locate that participant in this channel.");
-        }
-
-        if (string.Equals(participant.UserUid, UserUID, StringComparison.Ordinal))
-        {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You cannot mute yourself.").ConfigureAwait(false);
-            return;
-        }
-
-        ChatMuteUpdateResult result;
-        try
-        {
-            result = _chatChannelService.SetMutedParticipant(UserUID, channel, participant, request.Mute);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Failed to update mute for {User} in {Channel}", UserUID, DescribeChannel(channel));
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Unable to update mute settings right now. Please try again.").ConfigureAwait(false);
-            return;
-        }
-
-        if (result == ChatMuteUpdateResult.ChannelLimitReached)
-        {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, $"You can mute at most {ChatChannelService.MaxMutedParticipantsPerChannel} participants per channel. Unmute someone before adding another mute.").ConfigureAwait(false);
-            return;
-        }
-
-        if (result != ChatMuteUpdateResult.Changed)
-        {
-            return;
-        }
-
-        if (request.Mute)
-        {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "You will no longer receive this participant's messages in the current channel.").ConfigureAwait(false);
-        }
-        else
-        {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "You will receive this participant's messages again.").ConfigureAwait(false);
-        }
-    }
-
-    private static string DescribeChannel(ChatChannelDescriptor descriptor) =>
-        $"{descriptor.Type}:{descriptor.WorldId}:{descriptor.CustomKey}";
-
-    private bool TryInvokeChatService(Action action, string operationDescription, ChatChannelDescriptor? descriptor = null, string? targetUserUid = null)
-    {
-        try
-        {
-            action();
-            return true;
-        }
-        catch (Exception ex)
-        {
-            var logUser = targetUserUid ?? UserUID;
-            if (descriptor is ChatChannelDescriptor described)
-            {
-                _logger.LogError(ex, "Chat service failed while {Operation} for {User} in {Channel}", operationDescription, logUser, DescribeChannel(described));
-            }
-            else
-            {
-                _logger.LogError(ex, "Chat service failed while {Operation} for {User}", operationDescription, logUser);
-            }
-
-            return false;
-        }
-    }
-
     private ChatSenderDescriptor BuildSenderDescriptor(ChatChannelDescriptor descriptor, ChatParticipantInfo participant, bool includeSensitiveInfo = false)
     {
         var kind = descriptor.Type == ChatChannelType.Group
@@ -588,7 +487,7 @@ public partial class LightlessHub
             ? participant.HashedCid
             : null;
 
-        var canResolveProfile = includeSensitiveInfo && (kind == ChatSenderKind.IdentifiedUser || participant.IsLightfinder);
+        var canResolveProfile = kind == ChatSenderKind.IdentifiedUser || participant.IsLightfinder;
 
         return new ChatSenderDescriptor(
             kind,
@@ -599,6 +498,44 @@ public partial class LightlessHub
             canResolveProfile);
     }
 
+    private async Task<UserProfileDto?> LoadChatParticipantProfileAsync(string userUid)
+    {
+        if (string.IsNullOrEmpty(userUid))
+            return null;
+
+        var targetUser = await DbContext.Users
+            .AsNoTracking()
+            .SingleOrDefaultAsync(u => u.UID == userUid, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (targetUser is null)
+            return null;
+
+        var userData = targetUser.ToUserData();
+
+        var profileData = await DbContext.UserProfileData
+            .AsNoTracking()
+            .SingleOrDefaultAsync(p => p.UserUID == userUid, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (profileData is null)
+        {
+            return new UserProfileDto(userData, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: null, Tags: Array.Empty<int>());
+        }
+
+        if (profileData.FlaggedForReport)
+        {
+            return new UserProfileDto(userData, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile is flagged for report and pending evaluation", Tags: Array.Empty<int>());
+        }
+
+        if (profileData.ProfileDisabled)
+        {
+            return new UserProfileDto(userData, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile was permanently disabled", Tags: Array.Empty<int>());
+        }
+
+        return profileData.ToDTO();
+    }
+
     private async Task<bool> ViewerAllowsLightfinderDetailsAsync(ChatChannelDescriptor descriptor)
     {
         if (descriptor.Type == ChatChannelType.Group)
@@ -633,11 +570,7 @@ public partial class LightlessHub
             var (entry, expiry) = await TryGetBroadcastEntryAsync(presence.Participant.HashedCid!).ConfigureAwait(false);
             if (!IsActiveBroadcastForUser(entry, expiry, userUid))
             {
-                TryInvokeChatService(
+                _chatChannelService.RefreshLightfinderState(userUid, null, isLightfinder: false);
-                    () => _chatChannelService.RefreshLightfinderState(userUid, null, isLightfinder: false),
-                    "refreshing lightfinder state",
-                    descriptor,
-                    userUid);
                 return false;
             }
 
@@ -657,7 +590,7 @@ public partial class LightlessHub
         if (!isBanned)
             return false;
 
-        TryInvokeChatService(() => _chatChannelService.RemovePresence(userUid), "clearing presence for chat-banned user", targetUserUid: userUid);
+        _chatChannelService.RemovePresence(userUid);
         await NotifyChatBanAsync(userUid).ConfigureAwait(false);
         return true;
     }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs

@@ -40,6 +40,5 @@ namespace LightlessSyncServer.Hubs
         public Task Client_GposeLobbyPushPoseData(UserData userData, PoseData poseData) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
         public Task Client_GposeLobbyPushWorldData(UserData userData, WorldData worldData) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
         public Task Client_ChatReceive(ChatMessageDto message) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
-        public Task Client_SendLocationToClient(LocationDto locationDto, DateTimeOffset expireAt) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
     }
 }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs

@@ -152,7 +152,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.ToString()!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue!);
         }
         catch (Exception ex)
         {

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs

@@ -1,7 +1,6 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
-using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.Dto.Group;
 using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Models;
@@ -12,8 +11,10 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json.Linq;
 using SixLabors.ImageSharp;
-using System.Collections.Concurrent;
+using SixLabors.ImageSharp.PixelFormats;
+using System.Reflection;
 using System.Security.Cryptography;
 
 namespace LightlessSyncServer.Hubs;
@@ -28,78 +29,29 @@ public partial class LightlessHub
         var (userHasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
         if (!userHasRights) return;
 
-        var targetUid = dto.User.UID?.Trim();
+        var (userExists, groupPair) = await TryValidateUserInGroup(dto.Group.GID, dto.User.UID).ConfigureAwait(false);
-        if (string.IsNullOrWhiteSpace(targetUid)) return;
+        if (!userExists) return;
 
-        if (string.Equals(group.OwnerUID, targetUid, StringComparison.Ordinal))
+        if (groupPair.IsModerator || string.Equals(group.OwnerUID, dto.User.UID, StringComparison.Ordinal)) return;
-            return;
 
-        var groupPair = await DbContext.GroupPairs
+        var alias = string.IsNullOrEmpty(groupPair.GroupUser.Alias) ? "-" : groupPair.GroupUser.Alias;
-            .Include(p => p.GroupUser)
+        var ban = new GroupBan()
-            .SingleOrDefaultAsync(p => p.GroupGID == dto.Group.GID && p.GroupUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-
-        if (groupPair?.IsModerator == true)
-            return;
-
-        var now = DateTime.UtcNow;
-
-        var existingBan = await DbContext.Set<GroupBan>().SingleOrDefaultAsync(b => b.GroupGID == dto.Group.GID && b.BannedUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var userExists = await DbContext.Users.AsNoTracking().AnyAsync(u => u.UID == targetUid || u.Alias == targetUid, RequestAbortedToken).ConfigureAwait(false);
-
-        if (!userExists && existingBan == null)
-            return;
-
-        const string marker = " (Alias at time of ban:";
-        string suffix;
-
-        if (existingBan?.BannedReason is { } existingReason)
         {
-            var idx = existingReason.IndexOf(marker, StringComparison.Ordinal);
+            BannedByUID = UserUID,
-            suffix = idx >= 0 ? existingReason.Substring(startIndex: idx) : string.Empty;
+            BannedReason = $"{reason} (Alias at time of ban: {alias})",
-        }
+            BannedOn = DateTime.UtcNow,
-        else
+            BannedUserUID = dto.User.UID,
-        {
+            GroupGID = dto.Group.GID,
-            var alias = groupPair?.GroupUser?.Alias;
+        };
-            alias = string.IsNullOrWhiteSpace(alias) ? "-" : alias;
-            suffix = $" (Alias at time of ban: {alias})";
-        }
 
-        var baseReason = (reason ?? string.Empty).Trim();
+        DbContext.Add(ban);
-        var finalReason = string.IsNullOrEmpty(suffix) ? baseReason : (baseReason + suffix);
+        await DbContext.SaveChangesAsync().ConfigureAwait(false);
 
-        if (existingBan != null)
+        await GroupRemoveUser(dto).ConfigureAwait(false);
-        {
-            existingBan.BannedByUID = UserUID;
-            existingBan.BannedReason = finalReason;
-
-            DbContext.Update(existingBan);
-        }
-        else
-        {
-            var ban = new GroupBan
-            {
-                BannedByUID = UserUID,
-                BannedReason = finalReason,
-                BannedOn = now,
-                BannedUserUID = targetUid,
-                GroupGID = dto.Group.GID,
-            };
-
-            DbContext.Add(ban);
-        }
-
-        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
-
-        if (groupPair != null)
-        {
-            await GroupRemoveUser(dto).ConfigureAwait(false);
-        }
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
     }
 
-    private static readonly ConcurrentDictionary<string, DateTime> GroupChatToggleCooldowns = new(StringComparer.Ordinal);
-
     [Authorize(Policy = "Identified")]
     public async Task GroupChangeGroupPermissionState(GroupPermissionDto dto)
     {
@@ -108,73 +60,15 @@ public partial class LightlessHub
         var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
         if (!hasRights) return;
 
-        var permissions = dto.Permissions;
+        group.InvitesEnabled = !dto.Permissions.HasFlag(GroupPermissions.DisableInvites);
-        var isOwner = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal);
+        group.PreferDisableSounds = dto.Permissions.HasFlag(GroupPermissions.PreferDisableSounds);
-        var chatEnabled = group.ChatEnabled;
+        group.PreferDisableAnimations = dto.Permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
-        var chatChanged = false;
+        group.PreferDisableVFX = dto.Permissions.HasFlag(GroupPermissions.PreferDisableVFX);
-
-        if (!isOwner)
-        {
-            permissions.SetDisableChat(!group.ChatEnabled);
-        }
-        else
-        {
-            var requestedChatEnabled = !permissions.IsDisableChat();
-            if (requestedChatEnabled != group.ChatEnabled)
-            {
-                var now = DateTime.UtcNow;
-                if (GroupChatToggleCooldowns.TryGetValue(group.GID, out var lockedUntil) && lockedUntil > now)
-                {
-                    var remaining = lockedUntil - now;
-                    var minutes = Math.Max(1, (int)Math.Ceiling(remaining.TotalMinutes));
-                    await Clients.Caller.Client_ReceiveServerMessage(
-                        MessageSeverity.Warning,
-                        $"Syncshell chat can be toggled again in {minutes} minute{(minutes == 1 ? string.Empty : "s")}."
-                    ).ConfigureAwait(false);
-                    permissions.SetDisableChat(!group.ChatEnabled);
-                }
-                else
-                {
-                    chatEnabled = requestedChatEnabled;
-                    group.ChatEnabled = chatEnabled;
-                    GroupChatToggleCooldowns[group.GID] = now.AddMinutes(5);
-                    chatChanged = true;
-                }
-            }
-        }
-
-        group.InvitesEnabled = !permissions.HasFlag(GroupPermissions.DisableInvites);
-        group.PreferDisableSounds = permissions.HasFlag(GroupPermissions.PreferDisableSounds);
-        group.PreferDisableAnimations = permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
-        group.PreferDisableVFX = permissions.HasFlag(GroupPermissions.PreferDisableVFX);
 
         await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         var groupPairs = DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToList();
-        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, permissions)).ConfigureAwait(false);
+        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, dto.Permissions)).ConfigureAwait(false);
-
-        if (isOwner && chatChanged && !chatEnabled)
-        {
-            var groupDisplayName = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;
-            var descriptor = new ChatChannelDescriptor
-            {
-                Type = ChatChannelType.Group,
-                WorldId = 0,
-                ZoneId = 0,
-                CustomKey = group.GID
-            };
-
-            foreach (var uid in groupPairs)
-            {
-                TryInvokeChatService(() => _chatChannelService.RemovePresence(uid, descriptor), "removing group chat presence", descriptor, uid);
-            }
-
-            await Clients.Users(groupPairs)
-                .Client_ReceiveServerMessage(
-                    MessageSeverity.Information,
-                    $"Syncshell chat for '{groupDisplayName}' has been disabled.")
-                .ConfigureAwait(false);
-        }
     }
 
     [Authorize(Policy = "Identified")]
@@ -341,7 +235,6 @@ public partial class LightlessHub
             PreferDisableAnimations = defaultPermissions.DisableGroupAnimations,
             PreferDisableSounds = defaultPermissions.DisableGroupSounds,
             PreferDisableVFX = defaultPermissions.DisableGroupVFX,
-            ChatEnabled = true,
             CreatedDate = currentTime,
         };
 
@@ -371,9 +264,9 @@ public partial class LightlessHub
         var self = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
-            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
+            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal)))
             .ConfigureAwait(false);
-
+        
         _logger.LogCallInfo(LightlessHubLogger.Args(gid));
 
         return new GroupJoinDto(newGroup.ToGroupData(), passwd, initialPrefPermissions.ToEnum());
@@ -447,9 +340,9 @@ public partial class LightlessHub
 
         var banEntries = await DbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
-        List<BannedGroupUserDto> bannedGroupUsers = [.. banEntries.Select(b =>
+        List<BannedGroupUserDto> bannedGroupUsers = banEntries.Select(b =>
             new BannedGroupUserDto(group.ToGroupData(), b.BannedUser.ToUserData(), b.BannedReason, b.BannedOn,
-                b.BannedByUID))];
+                b.BannedByUID)).ToList();
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, bannedGroupUsers.Count));
 
@@ -561,14 +454,9 @@ public partial class LightlessHub
         await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         var groupInfos = await DbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var totalUserCount = await DbContext.GroupPairs
-            .AsNoTracking()
-            .CountAsync(u => u.GroupGID == group.GID, RequestAbortedToken)
-            .ConfigureAwait(false);
-
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(group.ToGroupData(), group.Owner.ToUserData(),
             group.ToEnum(), preferredPermissions.ToEnum(), newPair.ToEnum(),
-            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal), totalUserCount)).ConfigureAwait(false);
+            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal))).ConfigureAwait(false);
 
         var self = DbContext.Users.Single(u => u.UID == UserUID);
 
@@ -790,38 +678,30 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, days, execute));
 
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
-            .ConfigureAwait(false);
         if (!hasRights) return -1;
 
-        if (!execute)
+        var allGroupUsers = await DbContext.GroupPairs.Include(p => p.GroupUser).Include(p => p.Group)
-        {
-            var count = await _pruneService.CountPrunableUsersAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
-            return count;
-        }
-
-        var allGroupUsers = await DbContext.GroupPairs
-            .Include(p => p.GroupUser)
-            .Include(p => p.Group)
             .Where(g => g.GroupGID == dto.Group.GID)
-            .ToListAsync(RequestAbortedToken).ConfigureAwait(false);
+            .ToListAsync().ConfigureAwait(false);
+        var usersToPrune = allGroupUsers.Where(p => !p.IsPinned && !p.IsModerator
+            && !string.Equals(p.GroupUserUID, UserUID, StringComparison.Ordinal)
+            && !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal)
+            && p.GroupUser.LastLoggedIn.AddDays(days) < DateTime.UtcNow);
 
-        var prunedPairs = await _pruneService.ExecutePruneAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+        if (!execute) return usersToPrune.Count();
 
-        var remainingUserIds = allGroupUsers
+        DbContext.GroupPairs.RemoveRange(usersToPrune);
-            .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
-            .Select(p => p.GroupUserUID)
-            .Distinct(StringComparer.Ordinal)
-            .ToList();
 
-        foreach (var pair in prunedPairs)
+        foreach (var pair in usersToPrune)
         {
-            await Clients.Users(remainingUserIds)
+            await Clients.Users(allGroupUsers.Where(p => !usersToPrune.Contains(p)).Select(g => g.GroupUserUID))
-                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData()))
+                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData())).ConfigureAwait(false);
-                .ConfigureAwait(false);
         }
 
-        return prunedPairs.Count;
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        return usersToPrune.Count();
     }
 
     [Authorize(Policy = "Identified")]
@@ -878,7 +758,7 @@ public partial class LightlessHub
         }
 
         var data = await DbContext.GroupProfiles
-            .Include(gp => gp.Group)
+            .Include(gp => gp.Group) 
             .FirstOrDefaultAsync(
                 g => g.Group.GID == dto.Group.GID || g.Group.Alias == dto.Group.AliasOrGID,
                 cancellationToken
@@ -959,9 +839,8 @@ public partial class LightlessHub
             {
                 GroupGID = dto.Group.GID,
                 Group = group,
-                ProfileDisabled = dto.IsDisabled ?? false,
+                ProfileDisabled = false,
                 IsNSFW = dto.IsNsfw ?? false,
-
             };
 
             groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
@@ -971,6 +850,12 @@ public partial class LightlessHub
         {
             groupProfileDb.Group ??= group;
 
+            if (groupProfileDb?.ProfileDisabled ?? false)
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
+                return;
+            }
+
             groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
         }
 
@@ -1025,44 +910,6 @@ public partial class LightlessHub
         await Clients.Users(groupPairs).Client_GroupPairChangeUserInfo(new GroupPairUserInfoDto(dto.Group, dto.User, userPair.ToEnum())).ConfigureAwait(false);
     }
 
-    [Authorize(Policy = "Identified")]
-    public async Task<GroupPruneSettingsDto> GroupGetPruneSettings(GroupDto dto)
-    {
-        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
-
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.GID)
-            .ConfigureAwait(false);
-        if (!hasRights || group == null)
-            return null;
-
-        return new GroupPruneSettingsDto(
-            Group: group.ToGroupData(),
-            AutoPruneEnabled: group.AutoPruneEnabled,
-            AutoPruneDays: group.AutoPruneDays
-        );
-    }
-
-    [Authorize(Policy = "Identified")]
-    public async Task GroupSetPruneSettings(GroupPruneSettingsDto dto)
-    {
-        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
-
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
-            .ConfigureAwait(false);
-        if (!hasRights || group == null)
-            return;
-
-        // if days == 0, auto prune is OFF
-        var days = dto.AutoPruneDays;
-        var enabled = dto.AutoPruneEnabled && days > 0;
-
-        group.AutoPruneEnabled = enabled;
-        group.AutoPruneDays = enabled ? days : 0;
-
-        await DbContext.SaveChangesAsync(RequestAbortedToken)
-            .ConfigureAwait(false);
-    }
-
     [Authorize(Policy = "Identified")]
     public async Task<List<GroupFullInfoDto>> GroupsGetAll()
     {
@@ -1085,8 +932,6 @@ public partial class LightlessHub
                     .Where(x => x.GroupGID == gp.GroupGID && (x.IsPinned || x.IsModerator))
                     .Select(x => new { x.GroupUserUID, EnumValue = x.ToEnum() })
                     .ToList(),
-                UserCount = DbContext.GroupPairs
-                    .Count(x => x.GroupGID == gp.GroupGID),
             })
             .AsNoTracking()
             .ToListAsync()
@@ -1095,21 +940,21 @@ public partial class LightlessHub
         _logger.LogCallInfo(LightlessHubLogger.Args(result));
 
         List<GroupFullInfoDto> List = [.. result.Select(r =>
-            {
+        {
-        var groupInfoDict = r.GroupInfos
+            var groupInfoDict = r.GroupInfos
-            .ToDictionary(x => x.GroupUserUID, x => x.EnumValue, StringComparer.Ordinal);
+                .ToDictionary(x => x.GroupUserUID, x => x.EnumValue, StringComparer.Ordinal);
 
-        _logger.LogCallInfo(LightlessHubLogger.Args(r));
 
-        return new GroupFullInfoDto(
+            _logger.LogCallInfo(LightlessHubLogger.Args(r));
-            r.GroupPair.Group.ToGroupData(),
+
-            r.GroupPair.Group.Owner.ToUserData(),
+            return new GroupFullInfoDto(
-            r.GroupPair.Group.ToEnum(),
+                r.GroupPair.Group.ToGroupData(),
-            r.PreferredPermission.ToEnum(),
+                r.GroupPair.Group.Owner.ToUserData(),
-            r.GroupPair.ToEnum(),
+                r.GroupPair.Group.ToEnum(),
-            groupInfoDict,
+                r.PreferredPermission.ToEnum(),
-            r.UserCount
+                r.GroupPair.ToEnum(),
-        );
+                groupInfoDict
+            );
         }),];
         return List;
     }
@@ -1150,11 +995,11 @@ public partial class LightlessHub
             return false;
         }
 
-        var (isOwner, _) = await TryValidateOwner(dto.GID).ConfigureAwait(false);
+        var (isOwner, _) = await TryValidateGroupModeratorOrOwner(dto.GID).ConfigureAwait(false);
         if (!isOwner)
         {
             _logger.LogCallWarning(LightlessHubLogger.Args("Unauthorized syncshell broadcast change", "User", UserUID, "GID", dto.GID));
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner of the syncshell to broadcast it.");
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner or moderator of the syncshell to broadcast it.");
             return false;
         }
 

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs

@@ -12,6 +12,7 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
+using SixLabors.ImageSharp;
 using StackExchange.Redis;
 using System.Text;
 using System.Text.Json;
@@ -334,7 +335,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.Value.ToString()!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.Value!);
         }
         catch (Exception ex)
         {
@@ -436,7 +437,7 @@ public partial class LightlessHub
             {
                 try
                 {
-                    existingEntry = JsonSerializer.Deserialize<BroadcastRedisEntry>(existingValue.ToString()!);
+                    existingEntry = JsonSerializer.Deserialize<BroadcastRedisEntry>(existingValue!);
                 }
                 catch (Exception ex)
                 {
@@ -462,9 +463,7 @@ public partial class LightlessHub
             await db.StringSetAsync(broadcastKey, json, _broadcastConfiguration.BroadcastEntryTtl).ConfigureAwait(false);
             await db.StringSetAsync(ownershipKey, hashedCid, _broadcastConfiguration.BroadcastEntryTtl).ConfigureAwait(false);
             _logger.LogCallInfo(LightlessHubLogger.Args("broadcast enabled", hashedCid, "GID", gid));
-            TryInvokeChatService(
+            _chatChannelService.RefreshLightfinderState(UserUID, hashedCid, isLightfinder: true);
-                () => _chatChannelService.RefreshLightfinderState(UserUID, hashedCid, isLightfinder: true),
-                "refreshing lightfinder state (enable)");
         }
         else
         {
@@ -475,7 +474,7 @@ public partial class LightlessHub
             BroadcastRedisEntry? entry;
             try
             {
-                entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.ToString()!);
+                entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value!);
             }
             catch (Exception ex)
             {
@@ -505,9 +504,7 @@ public partial class LightlessHub
             }
 
             _logger.LogCallInfo(LightlessHubLogger.Args("broadcast disabled", hashedCid, "GID", entry.GID));
-            TryInvokeChatService(
+            _chatChannelService.RefreshLightfinderState(UserUID, null, isLightfinder: false);
-                () => _chatChannelService.RefreshLightfinderState(UserUID, null, isLightfinder: false),
-                "refreshing lightfinder state (disable)");
         }
     }
 
@@ -534,7 +531,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.Value.ToString()!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.Value!);
         }
         catch (Exception ex)
         {
@@ -588,7 +585,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(result.Value.ToString()!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(result.Value!);
         }
         catch
         {
@@ -643,7 +640,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.ToString()!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value!);
         }
         catch
         {
@@ -726,7 +723,7 @@ public partial class LightlessHub
 
                 try
                 {
-                    entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(raw.ToString()!);
+                    entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(raw!);
                     if (entry is not null && !string.Equals(entry.HashedCID, cid, StringComparison.Ordinal))
                     {
                         _logger.LogCallWarning(LightlessHubLogger.Args("mismatched broadcast cid in batch", "Requested", cid, "EntryCID", entry.HashedCID));
@@ -1169,6 +1166,12 @@ public partial class LightlessHub
                 return;
             }
 
+            if (profileData.ProfileDisabled)
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
+                return;
+            }
+
             profileData.UpdateProfileFromDto(dto, profileResult.Base64Image, bannerResult.Base64Image);
         }
         else
@@ -1230,120 +1233,6 @@ public partial class LightlessHub
         errorMessage = string.Empty;
         return true;
     }
-    
-    [Authorize(Policy = "Identified")]
-    public async Task UpdateLocation(LocationDto dto, bool offline = false)
-    {
-        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
-        if (string.IsNullOrEmpty(dto.User.UID))
-        {
-            _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with no userinfo :",UserUID, dto));
-            return;
-        }
-
-        if (!string.Equals(UserUID, dto.User.UID, StringComparison.Ordinal))
-        {
-            _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with another UID :",UserUID, dto));
-            return;
-        }
-        var key = $"Location:{UserUID}";
-        
-        if (offline)
-        {
-            var allUsers = await GetSharingUsers().ConfigureAwait(false);   
-            await _redis.RemoveAsync(key, CommandFlags.FireAndForget).ConfigureAwait(false);
-            await Clients.Users(allUsers.Keys).Client_SendLocationToClient(dto, DateTimeOffset.MinValue).ConfigureAwait(false);
-        }
-        else
-        {
-            var currentLocation = await _redis.GetAsync<LocationDto>(key).ConfigureAwait(false);
-            if (currentLocation != dto)
-            {
-                var allUsers = await GetSharingUsers().ConfigureAwait(false);   
-                await _redis.AddAsync(key, dto).ConfigureAwait(false);
-                var sendTasks = allUsers.Select(pair => Clients.User(pair.Key).Client_SendLocationToClient(dto, pair.Value));
-                await Task.WhenAll(sendTasks).ConfigureAwait(false);
-            }
-        }
-    }
-    
-    private async Task<Dictionary<string, DateTimeOffset>> GetSharingUsers()
-    {
-        return await DbContext.Permissions.AsNoTracking()
-            .Where(x => x.UserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
-            .ToDictionaryAsync(x => x.OtherUserUID, x => x.ShareLocationUntil, RequestAbortedToken)
-            .ConfigureAwait(false);
-    }
-
-    [Authorize(Policy = "Identified")]
-    public async Task<(List<LocationWithTimeDto>, List<SharingStatusDto>)> RequestAllLocationInfo()
-    {
-        _logger.LogCallInfo();
-        var locationWithTime = await GetLocationWithTime().ConfigureAwait(false);
-        var sharingStatus = await GetSharingStatus().ConfigureAwait(false);
-        return (locationWithTime, sharingStatus);
-    }
-
-    private async Task<List<LocationWithTimeDto>> GetLocationWithTime()
-    {
-        var dictionary = await DbContext.Permissions.AsNoTracking()
-            .Where(x => x.OtherUserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
-            .ToDictionaryAsync(x => x.UserUID, x => x.ShareLocationUntil, cancellationToken: RequestAbortedToken)
-            .ConfigureAwait(false);
-        if (dictionary.Count == 0)
-        {
-            return [];
-        }
-
-        var redisKeys = dictionary.Keys.Select(uid => $"Location:{uid}").ToHashSet(StringComparer.Ordinal);
-        var data = await _redis.GetAllAsync<LocationDto>(redisKeys).ConfigureAwait(false);
-        var result = new List<LocationWithTimeDto>();
-
-        foreach (var (userUid, expireAt) in dictionary)
-        {
-            var redisKey = $"Location:{userUid}";
-
-            if (data.TryGetValue(redisKey, out var locationDto) && locationDto is not null)
-            {
-                result.Add(new LocationWithTimeDto(locationDto, expireAt));
-            }
-        }
-        return result;
-    }
-
-    private async Task<List<SharingStatusDto>> GetSharingStatus()
-    {
-        return await DbContext.Permissions.AsNoTracking()
-            .Where(x => x.UserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
-            .Select(x => new SharingStatusDto(new UserData(x.OtherUserUID), x.ShareLocationUntil))
-            .ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-    }
-
-
-
-    [Authorize(Policy = "Identified")]
-    public async Task<bool> ToggleLocationSharing(LocationSharingToggleDto dto)
-    {
-        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
-        try
-        {
-            await DbContext.Permissions.Where(x => x.UserUID == UserUID && dto.users.Contains(x.OtherUserUID))
-                .ExecuteUpdateAsync(setter =>
-                        setter.SetProperty(x => x.ShareLocationUntil, dto.duration.ToUniversalTime()),
-                    cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-
-            //update user's location for target users
-            var currentLocation = await _redis.GetAsync<LocationDto>($"Location:{UserUID}").ConfigureAwait(false);
-            await Clients.Users(dto.users).Client_SendLocationToClient(currentLocation, dto.duration.ToUniversalTime())
-                .ConfigureAwait(false);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "ToggleLocationSharing error:");
-            return false;
-        }
-        return true;
-    }
 
     [GeneratedRegex(@"^([a-z0-9_ '+&,\.\-\{\}]+\/)+([a-z0-9_ '+&,\.\-\{\}]+\.[a-z]{3,4})$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ECMAScript)]
     private static partial Regex GamePathRegex();

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs

@@ -1,6 +1,7 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Dto;
+using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.SignalR;
 using LightlessSyncServer.Services;
 using LightlessSyncServer.Configuration;
@@ -16,9 +17,8 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
-using LightlessSync.API.Dto.CharaData;
+using System.Collections.Generic;
-using LightlessSync.API.Dto.User;
+using System.Linq;
-using LightlessSyncServer.Services.Interfaces;
 
 namespace LightlessSyncServer.Hubs;
 
@@ -29,7 +29,6 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
     private readonly LightlessMetrics _lightlessMetrics;
     private readonly SystemInfoService _systemInfoService;
     private readonly PairService _pairService;
-    private readonly IPruneService _pruneService;
     private readonly IHttpContextAccessor _contextAccessor;
     private readonly LightlessHubLogger _logger;
     private readonly string _shardName;
@@ -56,7 +55,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         IConfigurationService<ServerConfiguration> configuration, IHttpContextAccessor contextAccessor,
         IRedisDatabase redisDb, OnlineSyncedPairCacheService onlineSyncedPairCacheService, LightlessCensus lightlessCensus,
         GPoseLobbyDistributionService gPoseLobbyDistributionService, IBroadcastConfiguration broadcastConfiguration, PairService pairService,
-        ChatChannelService chatChannelService, IPruneService pruneService)
+        ChatChannelService chatChannelService)
     {
         _lightlessMetrics = lightlessMetrics;
         _systemInfoService = systemInfoService;
@@ -78,7 +77,6 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         _broadcastConfiguration = broadcastConfiguration;
         _pairService = pairService;
         _chatChannelService = chatChannelService;
-        _pruneService = pruneService;
     }
 
     protected override void Dispose(bool disposing)
@@ -219,8 +217,6 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
                 await RemoveUserFromRedis().ConfigureAwait(false);
 
                 _lightlessCensus.ClearStatistics(UserUID);
-                
-                await UpdateLocation(new LocationDto(new UserData(UserUID), new LocationInfo()), offline: true).ConfigureAwait(false);
 
                 await SendOfflineToAllPairedUsers().ConfigureAwait(false);
 
@@ -231,7 +227,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
             catch { }
             finally
             {
-                TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID), "removing chat presence on disconnect");
+                _chatChannelService.RemovePresence(UserUID);
                 _userConnections.Remove(UserUID, out _);
             }
         }

LightlessSyncServer/LightlessSyncServer/LightlessSyncServer.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <UserSecretsId>aspnet-LightlessSyncServer-BA82A12A-0B30-463C-801D-B7E81318CD50</UserSecretsId>
     <AssemblyVersion>1.1.0.0</AssemblyVersion>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -21,6 +21,7 @@
 
   <ItemGroup>
     <PackageReference Include="AspNetCoreRateLimit" Version="5.0.0" />
+    <PackageReference Include="Blake3" Version="2.0.0" />
     <PackageReference Include="IDisposableAnalyzers" Version="4.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

LightlessSyncServer/LightlessSyncServer/Models/ChatModels.cs

@@ -1,4 +1,6 @@
-using LightlessSync.API.Data;
+using System;
+using System.Collections.Generic;
+using LightlessSync.API.Data;
 using LightlessSync.API.Dto.Chat;
 
 namespace LightlessSyncServer.Models;
@@ -30,6 +32,7 @@ public readonly record struct ChatMessageLogEntry(
     string MessageId,
     ChatChannelDescriptor Channel,
     DateTime SentAtUtc,
+    string SenderToken,
     string SenderUserUid,
     UserData? SenderUser,
     bool SenderIsLightfinder,

LightlessSyncServer/LightlessSyncServer/Models/ChatZoneDefinitions.cs

@@ -1,4 +1,5 @@
-using LightlessSync.API.Dto.Chat;
+using System.Collections.Generic;
+using LightlessSync.API.Dto.Chat;
 
 namespace LightlessSyncServer.Models;
 
@@ -60,6 +61,7 @@ internal static class ChatZoneDefinitions
                 },
                 TerritoryIds: TerritoryRegistry.GetIds(
                     "Ul'dah - Steps of Nald",
-                    "Ul'dah - Steps of Thal")),
+                    "Ul'dah - Steps of Thal"))
         };
+
 }

LightlessSyncServer/LightlessSyncServer/Services/ChatChannelService.cs

@@ -1,13 +1,15 @@
-using System.Security.Cryptography;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
 using LightlessSync.API.Data;
 using LightlessSync.API.Dto.Chat;
-using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Models;
-using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Logging;
 
 namespace LightlessSyncServer.Services;
 
-public sealed class ChatChannelService : IDisposable
+public sealed class ChatChannelService
 {
     private readonly ILogger<ChatChannelService> _logger;
     private readonly Dictionary<string, ZoneChannelDefinition> _zoneDefinitions;
@@ -16,137 +18,16 @@ public sealed class ChatChannelService : IDisposable
     private readonly Dictionary<ChannelKey, Dictionary<string, ChatParticipantInfo>> _participantsByChannel = new();
     private readonly Dictionary<ChannelKey, LinkedList<ChatMessageLogEntry>> _messagesByChannel = new();
     private readonly Dictionary<string, (ChannelKey Channel, LinkedListNode<ChatMessageLogEntry> Node)> _messageIndex = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, Dictionary<ChannelKey, HashSet<string>>> _mutedTokensByUser = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, Dictionary<ChannelKey, HashSet<string>>> _mutedUidsByUser = new(StringComparer.Ordinal);
     private readonly object _syncRoot = new();
     private const int MaxMessagesPerChannel = 200;
-    internal const int MaxMutedParticipantsPerChannel = 8;
 
-    public ChatChannelService(ILogger<ChatChannelService> logger, IOptions<ChatZoneOverridesOptions>? zoneOverrides = null)
+    public ChatChannelService(ILogger<ChatChannelService> logger)
     {
         _logger = logger;
-        _zoneDefinitions = BuildZoneDefinitions(zoneOverrides?.Value);
+        _zoneDefinitions = ChatZoneDefinitions.Defaults
-    }
-
-    private Dictionary<string, ZoneChannelDefinition> BuildZoneDefinitions(ChatZoneOverridesOptions? overrides)
-    {
-        var definitions = ChatZoneDefinitions.Defaults
             .ToDictionary(definition => definition.Key, StringComparer.OrdinalIgnoreCase);
-
-        if (overrides?.Zones is null || overrides.Zones.Count == 0)
-        {
-            return definitions;
-        }
-
-        foreach (var entry in overrides.Zones)
-        {
-            if (entry is null)
-            {
-                continue;
-            }
-
-            if (!TryCreateZoneDefinition(entry, out var definition))
-            {
-                continue;
-            }
-
-            definitions[definition.Key] = definition;
-        }
-
-        return definitions;
     }
 
-    private bool TryCreateZoneDefinition(ChatZoneOverride entry, out ZoneChannelDefinition definition)
-    {
-        definition = default;
-
-        var key = NormalizeZoneKey(entry.Key);
-        if (string.IsNullOrEmpty(key))
-        {
-            _logger.LogWarning("Skipped chat zone override with missing key.");
-            return false;
-        }
-
-        var territoryIds = new HashSet<ushort>();
-        if (entry.TerritoryIds is not null)
-        {
-            foreach (var candidate in entry.TerritoryIds)
-            {
-                if (candidate > 0)
-                {
-                    territoryIds.Add(candidate);
-                }
-            }
-        }
-
-        var territoryNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        if (entry.TerritoryNames is not null)
-        {
-            foreach (var name in entry.TerritoryNames)
-            {
-                if (string.IsNullOrWhiteSpace(name))
-                    continue;
-
-                var trimmed = name.Trim();
-                territoryNames.Add(trimmed);
-                if (TerritoryRegistry.TryGetIds(trimmed, out var ids))
-                {
-                    territoryIds.UnionWith(ids);
-                }
-                else
-                {
-                    _logger.LogWarning("Chat zone override {Zone} references unknown territory '{Territory}'.", key, trimmed);
-                }
-            }
-        }
-
-        if (territoryIds.Count == 0)
-        {
-            _logger.LogWarning("Skipped chat zone override for {Zone}: no territory IDs resolved.", key);
-            return false;
-        }
-
-        if (territoryNames.Count == 0)
-        {
-            foreach (var territoryId in territoryIds)
-            {
-                if (TerritoryRegistry.ById.TryGetValue(territoryId, out var territory))
-                {
-                    territoryNames.Add(territory.Name);
-                }
-            }
-        }
-
-        if (territoryNames.Count == 0)
-        {
-            territoryNames.Add("Territory");
-        }
-
-        var descriptor = new ChatChannelDescriptor
-        {
-            Type = ChatChannelType.Zone,
-            WorldId = 0,
-            ZoneId = 0,
-            CustomKey = key
-        };
-
-        var displayName = string.IsNullOrWhiteSpace(entry.DisplayName)
-            ? key
-            : entry.DisplayName.Trim();
-
-        definition = new ZoneChannelDefinition(
-            key,
-            displayName,
-            descriptor,
-            territoryNames.ToArray(),
-            territoryIds);
-
-        return true;
-    }
-
-    private static string NormalizeZoneKey(string? value) =>
-        string.IsNullOrWhiteSpace(value) ? string.Empty : value.Trim();
-
     public IReadOnlyList<ZoneChatChannelInfoDto> GetZoneChannelInfos() =>
         _zoneDefinitions.Values
             .Select(definition => new ZoneChatChannelInfoDto(
@@ -273,6 +154,7 @@ public sealed class ChatChannelService : IDisposable
             messageId,
             channel,
             sentAtUtc,
+            participant.Token,
             participant.UserUid,
             participant.User,
             participant.IsLightfinder,
@@ -378,6 +260,23 @@ public sealed class ChatChannelService : IDisposable
         }
     }
 
+    public bool TryResolveParticipant(ChatChannelDescriptor channel, string token, out ChatParticipantInfo participant)
+    {
+        var key = ChannelKey.FromDescriptor(channel);
+
+        lock (_syncRoot)
+        {
+            if (_participantsByChannel.TryGetValue(key, out var participants) &&
+                participants.TryGetValue(token, out participant))
+            {
+                return true;
+            }
+        }
+
+        participant = default;
+        return false;
+    }
+
     public void RefreshLightfinderState(string userUid, string? hashedCid, bool isLightfinder)
     {
         ArgumentException.ThrowIfNullOrEmpty(userUid);
@@ -514,8 +413,6 @@ public sealed class ChatChannelService : IDisposable
 
             participantsByToken[token] = finalParticipant;
 
-            ApplyUIDMuteIfPresent(normalizedDescriptor, finalParticipant);
-
             _logger.LogDebug("Chat presence updated for {User} in {Channel}", userUid, Describe(key));
             return entryToStore;
         }
@@ -549,113 +446,9 @@ public sealed class ChatChannelService : IDisposable
             }
         }
 
-        ClearMutesForChannel(userUid, key);
         return true;
     }
 
-    internal bool TryGetActiveParticipant(ChatChannelDescriptor channel, string token, out ChatParticipantInfo participant)
-    {
-        var key = ChannelKey.FromDescriptor(channel.WithNormalizedCustomKey());
-
-        lock (_syncRoot)
-        {
-            if (_participantsByChannel.TryGetValue(key, out var participants) &&
-                participants.TryGetValue(token, out participant))
-            {
-                return true;
-            }
-        }
-
-        participant = default;
-        return false;
-    }
-
-    internal bool IsTokenMuted(string userUid, ChatChannelDescriptor channel, string token)
-    {
-        var key = ChannelKey.FromDescriptor(channel.WithNormalizedCustomKey());
-
-        lock (_syncRoot)
-        {
-            if (!_mutedTokensByUser.TryGetValue(userUid, out var channels) ||
-                !channels.TryGetValue(key, out var tokens))
-            {
-                return false;
-            }
-
-            if (tokens.Contains(token))
-            {
-                return true;
-            }
-
-            if (_participantsByChannel.TryGetValue(key, out var participants) &&
-                participants.TryGetValue(token, out var participant))
-            {
-                return IsUIDMutedLocked(userUid, key, participant.UserUid);
-            }
-
-            return false;
-        }
-    }
-
-    public ChatMuteUpdateResult SetMutedParticipant(string userUid, ChatChannelDescriptor channel, ChatParticipantInfo participant, bool mute)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(userUid);
-        ArgumentException.ThrowIfNullOrEmpty(participant.Token);
-        ArgumentException.ThrowIfNullOrEmpty(participant.UserUid);
-
-        var key = ChannelKey.FromDescriptor(channel.WithNormalizedCustomKey());
-
-        lock (_syncRoot)
-        {
-            if (!_mutedTokensByUser.TryGetValue(userUid, out var channels))
-            {
-                if (!mute)
-                {
-                    return ChatMuteUpdateResult.NoChange;
-                }
-
-                channels = new Dictionary<ChannelKey, HashSet<string>>();
-                _mutedTokensByUser[userUid] = channels;
-            }
-
-            if (!channels.TryGetValue(key, out var tokens))
-            {
-                if (!mute)
-                {
-                    return ChatMuteUpdateResult.NoChange;
-                }
-
-                tokens = new HashSet<string>(StringComparer.Ordinal);
-                channels[key] = tokens;
-            }
-
-            if (mute)
-            {
-                if (!tokens.Contains(participant.Token) && tokens.Count >= MaxMutedParticipantsPerChannel)
-                {
-                    return ChatMuteUpdateResult.ChannelLimitReached;
-                }
-
-                var added = tokens.Add(participant.Token);
-                EnsureUIDMuteLocked(userUid, key, participant.UserUid);
-                return added ? ChatMuteUpdateResult.Changed : ChatMuteUpdateResult.NoChange;
-            }
-
-            var removed = tokens.Remove(participant.Token);
-            if (tokens.Count == 0)
-            {
-                channels.Remove(key);
-                if (channels.Count == 0)
-                {
-                    _mutedTokensByUser.Remove(userUid);
-                }
-            }
-
-            RemoveUIDMuteLocked(userUid, key, participant.UserUid);
-            return removed ? ChatMuteUpdateResult.Changed : ChatMuteUpdateResult.NoChange;
-        }
-    }
-
     private static string GenerateToken()
     {
         Span<byte> buffer = stackalloc byte[8];
@@ -665,103 +458,4 @@ public sealed class ChatChannelService : IDisposable
 
     private static string Describe(ChannelKey key)
         => $"{key.Type}:{key.WorldId}:{key.CustomKey}";
-
-    private void ClearMutesForChannel(string userUid, ChannelKey key)
-    {
-        if (_mutedTokensByUser.TryGetValue(userUid, out var tokenChannels) &&
-            tokenChannels.Remove(key) &&
-            tokenChannels.Count == 0)
-        {
-            _mutedTokensByUser.Remove(userUid);
-        }
-
-        if (_mutedUidsByUser.TryGetValue(userUid, out var uidChannels) &&
-            uidChannels.Remove(key) &&
-            uidChannels.Count == 0)
-        {
-            _mutedUidsByUser.Remove(userUid);
-        }
-    }
-
-    private void ApplyUIDMuteIfPresent(ChatChannelDescriptor descriptor, ChatParticipantInfo participant)
-    {
-        var key = ChannelKey.FromDescriptor(descriptor);
-        foreach (var kvp in _mutedUidsByUser)
-        {
-            var muter = kvp.Key;
-            var channels = kvp.Value;
-            if (!channels.TryGetValue(key, out var mutedUids) || !mutedUids.Contains(participant.UserUid))
-            {
-                continue;
-            }
-
-            if (!_mutedTokensByUser.TryGetValue(muter, out var tokenChannels))
-            {
-                tokenChannels = new Dictionary<ChannelKey, HashSet<string>>();
-                _mutedTokensByUser[muter] = tokenChannels;
-            }
-
-            if (!tokenChannels.TryGetValue(key, out var tokens))
-            {
-                tokens = new HashSet<string>(StringComparer.Ordinal);
-                tokenChannels[key] = tokens;
-            }
-
-            tokens.Add(participant.Token);
-        }
-    }
-
-    private void EnsureUIDMuteLocked(string userUid, ChannelKey key, string targetUid)
-    {
-        if (!_mutedUidsByUser.TryGetValue(userUid, out var channels))
-        {
-            channels = new Dictionary<ChannelKey, HashSet<string>>();
-            _mutedUidsByUser[userUid] = channels;
-        }
-
-        if (!channels.TryGetValue(key, out var set))
-        {
-            set = new HashSet<string>(StringComparer.Ordinal);
-            channels[key] = set;
-        }
-
-        set.Add(targetUid);
-    }
-
-    private void RemoveUIDMuteLocked(string userUid, ChannelKey key, string targetUid)
-    {
-        if (!_mutedUidsByUser.TryGetValue(userUid, out var channels) ||
-            !channels.TryGetValue(key, out var set))
-        {
-            return;
-        }
-
-        set.Remove(targetUid);
-        if (set.Count == 0)
-        {
-            channels.Remove(key);
-            if (channels.Count == 0)
-            {
-                _mutedUidsByUser.Remove(userUid);
-            }
-        }
-    }
-
-    private bool IsUIDMutedLocked(string userUid, ChannelKey key, string targetUid)
-    {
-        return _mutedUidsByUser.TryGetValue(userUid, out var channels) &&
-               channels.TryGetValue(key, out var set) &&
-               set.Contains(targetUid);
-    }
-
-    public void Dispose()
-    {
-    }
-}
-
-public enum ChatMuteUpdateResult
-{
-    NoChange,
-    Changed,
-    ChannelLimitReached
 }

LightlessSyncServer/LightlessSyncServer/Services/Interfaces/IPruneService.cs

@@ -1,10 +0,0 @@
-using LightlessSyncShared.Models;
-
-namespace LightlessSyncServer.Services.Interfaces
-{
-    public interface IPruneService
-    {
-        Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct);
-        Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct);
-    }
-}

LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs

@@ -1,60 +0,0 @@
-using LightlessSyncServer.Services.Interfaces;
-using LightlessSyncShared.Data;
-using LightlessSyncShared.Models;
-using Microsoft.EntityFrameworkCore;
-
-namespace LightlessSyncServer.Services
-{
-    public class PruneService(LightlessDbContext dbContext) : IPruneService
-    {
-        private readonly LightlessDbContext _dbContext = dbContext;
-
-        public async Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct)
-        {
-            var allGroupUsers = await _dbContext.GroupPairs
-                .Include(p => p.GroupUser)
-                .Include(p => p.Group)
-                .Where(g => g.GroupGID == groupGid)
-                .ToListAsync(ct).ConfigureAwait(false);
-
-            var inactivitySpan = GetInactivitySpan(days);
-            var now = DateTime.UtcNow;
-
-            var usersToPrune = allGroupUsers.Where(p =>
-                !p.IsPinned &&
-                !p.IsModerator &&
-                !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
-                p.GroupUser.LastLoggedIn < now - inactivitySpan);
-
-            return usersToPrune.Count();
-        }
-
-        public async Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct)
-        {
-            var allGroupUsers = await _dbContext.GroupPairs
-                .Include(p => p.GroupUser)
-                .Include(p => p.Group)
-                .Where(g => g.GroupGID == groupGid)
-                .ToListAsync(ct).ConfigureAwait(false);
-
-            var inactivitySpan = GetInactivitySpan(days);
-            var now = DateTime.UtcNow;
-
-            var usersToPrune = allGroupUsers.Where(p =>
-                !p.IsPinned &&
-                !p.IsModerator &&
-                !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
-                p.GroupUser.LastLoggedIn < now - inactivitySpan)
-                .ToList();
-
-            _dbContext.GroupPairs.RemoveRange(usersToPrune);
-            await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
-
-            return usersToPrune;
-        }
-
-        private static TimeSpan GetInactivitySpan(int days) => days == 0
-                ? TimeSpan.FromMinutes(15)
-                : TimeSpan.FromDays(days);
-    }
-}

LightlessSyncServer/LightlessSyncServer/Services/SystemInfoService.cs

@@ -72,11 +72,9 @@ public sealed class SystemInfoService : BackgroundService
                     await _hubContext.Clients.All.Client_UpdateSystemInfo(SystemInfoDto).ConfigureAwait(false);
 
                     using var db = await _dbContextFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-                    var groupsWithAutoPrune = db.Groups.AsNoTracking().Count(g => g.AutoPruneEnabled && g.AutoPruneDays > 0);
 
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeAuthorizedConnections, onlineUsers);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeLightFinderConnections, countLightFinderUsers);
-                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroupAutoPrunesEnabled, groupsWithAutoPrune);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairs, db.ClientPairs.AsNoTracking().Count());
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairsPaused, db.Permissions.AsNoTracking().Count(p => p.IsPaused));
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroups, db.Groups.AsNoTracking().Count());

LightlessSyncServer/LightlessSyncServer/Startup.cs

@@ -1,13 +1,9 @@
 using AspNetCoreRateLimit;
-using LightlessSync.API.Data;
-using LightlessSync.API.Dto.Group;
 using LightlessSync.API.SignalR;
-using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Controllers;
+using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Hubs;
 using LightlessSyncServer.Services;
-using LightlessSyncServer.Services.Interfaces;
-using LightlessSyncServer.Worker;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.RequirementHandlers;
@@ -22,7 +18,6 @@ using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.IdentityModel.Tokens;
 using Prometheus;
 using StackExchange.Redis;
@@ -93,7 +88,6 @@ public class Startup
         services.Configure<ServerConfiguration>(Configuration.GetRequiredSection("LightlessSync"));
         services.Configure<LightlessConfigurationBase>(Configuration.GetRequiredSection("LightlessSync"));
         services.Configure<BroadcastOptions>(Configuration.GetSection("Broadcast"));
-        services.Configure<ChatZoneOverridesOptions>(Configuration.GetSection("ChatZoneOverrides"));
 
         services.AddSingleton<IBroadcastConfiguration, BroadcastConfiguration>();
         services.AddSingleton<ServerTokenGenerator>();
@@ -115,12 +109,9 @@ public class Startup
             services.AddHostedService(provider => provider.GetService<CharaDataCleanupService>());
             services.AddHostedService<ClientPairPermissionsCleanupService>();
             services.AddScoped<PairService>();
-            services.AddScoped<IPruneService, PruneService>();
         }
 
         services.AddSingleton<GPoseLobbyDistributionService>();
-
-        services.AddHostedService<AutoPruneWorker>();
         services.AddHostedService(provider => provider.GetService<GPoseLobbyDistributionService>());
     }
 
@@ -129,8 +120,6 @@ public class Startup
         services.AddSingleton<IUserIdProvider, IdBasedUserIdProvider>();
         services.AddSingleton<ConcurrencyFilter>();
 
-        var msgpackOptions = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4Block).WithResolver(ContractlessStandardResolver.Instance);
-
         var signalRServiceBuilder = services.AddSignalR(hubOptions =>
         {
             hubOptions.MaximumReceiveMessageSize = long.MaxValue;
@@ -142,10 +131,21 @@ public class Startup
             hubOptions.AddFilter<ConcurrencyFilter>();
         }).AddMessagePackProtocol(opt =>
         {
-            opt.SerializerOptions = msgpackOptions;
+            var resolver = CompositeResolver.Create(StandardResolverAllowPrivate.Instance,
+                BuiltinResolver.Instance,
+                AttributeFormatterResolver.Instance,
+                // replace enum resolver
+                DynamicEnumAsStringResolver.Instance,
+                DynamicGenericResolver.Instance,
+                DynamicUnionResolver.Instance,
+                DynamicObjectResolver.Instance,
+                PrimitiveObjectResolver.Instance,
+                // final fallback(last priority)
+                StandardResolver.Instance);
 
-            var dummy = new GroupPruneSettingsDto(new GroupData("TEST-GID", null), true, 14);
+            opt.SerializerOptions = MessagePackSerializerOptions.Standard
-            MessagePackSerializer.Serialize(dummy, msgpackOptions);
+                .WithCompression(MessagePackCompression.Lz4Block)
+                .WithResolver(resolver);
         });
 
 
@@ -166,7 +166,7 @@ public class Startup
             KeyPrefix = "",
             Hosts = new RedisHost[]
             {
-                new(){ Host = address, Port = port },
+                new RedisHost(){ Host = address, Port = port },
             },
             AllowAdmin = true,
             ConnectTimeout = options.ConnectTimeout,
@@ -292,12 +292,11 @@ public class Startup
             MetricsAPI.CounterUserPairCacheMiss,
             MetricsAPI.CounterUserPairCacheNewEntries,
             MetricsAPI.CounterUserPairCacheUpdatedEntries,
-        },
+        }, new List<string>
-        [
+        {
             MetricsAPI.GaugeAuthorizedConnections,
             MetricsAPI.GaugeLightFinderConnections,
             MetricsAPI.GaugeLightFinderGroups,
-            MetricsAPI.GaugeGroupAutoPrunesEnabled,
             MetricsAPI.GaugeConnections,
             MetricsAPI.GaugePairs,
             MetricsAPI.GaugePairsPaused,
@@ -313,7 +312,7 @@ public class Startup
             MetricsAPI.GaugeGposeLobbyUsers,
             MetricsAPI.GaugeHubConcurrency,
             MetricsAPI.GaugeHubQueuedConcurrency,
-        ]));
+        }));
     }
 
     private static void ConfigureServicesBasedOnShardType(IServiceCollection services, IConfigurationSection lightlessConfig, bool isMainServer)

LightlessSyncServer/LightlessSyncServer/Utils/ChatMessageFilter.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Text.RegularExpressions;
-
-namespace LightlessSyncServer.Utils;
-
-internal static class ChatMessageFilter
-{
-    private static readonly Regex UrlRegex = new(@"\b(?:https?://|www\.)\S+", RegexOptions.IgnoreCase | RegexOptions.Compiled);
-
-    public static bool TryValidate(string? message, out string rejectionReason)
-    {
-        rejectionReason = string.Empty;
-        if (string.IsNullOrWhiteSpace(message))
-        {
-            return true;
-        }
-
-        if (UrlRegex.IsMatch(message))
-        {
-            rejectionReason = "Links are not permitted in chat.";
-            return false;
-        }
-
-        return true;
-    }
-}

LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs

@@ -22,7 +22,6 @@ public static class Extensions
         if (dto.Tags != null) profile.Tags = dto.Tags;
         if (dto.Description != null) profile.Description = dto.Description;
         if (dto.IsNsfw.HasValue) profile.IsNSFW = dto.IsNsfw.Value;
-        if (dto.IsDisabled.HasValue) profile.ProfileDisabled = dto.IsDisabled.Value;
     }
 
     public static void UpdateProfileFromDto(this UserProfileData profile, UserProfileDto dto, string? base64PictureString = null, string? base64BannerString = null)
@@ -118,7 +117,6 @@ public static class Extensions
         permissions.SetPreferDisableSounds(group.PreferDisableSounds);
         permissions.SetPreferDisableVFX(group.PreferDisableVFX);
         permissions.SetDisableInvites(!group.InvitesEnabled);
-        permissions.SetDisableChat(!group.ChatEnabled);
         return permissions;
     }
 

LightlessSyncServer/LightlessSyncServer/Utils/LightlessHubLogger.cs

@@ -30,14 +30,4 @@ public class LightlessHubLogger
         string formattedArgs = args != null && args.Length != 0 ? "|" + string.Join(":", args) : string.Empty;
         _logger.LogWarning("{uid}:{method}{args}", _hub.UserUID, methodName, formattedArgs);
     }
-
-    public void LogError(Exception exception, string message, params object[] args)
-    {
-        _logger.LogError(exception, message, args);
-    }
-
-    public void LogError(string message, params object[] args)
-    {
-        _logger.LogError(message, args);
-    }
 }

LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs

@@ -1,68 +0,0 @@
-using LightlessSync.API.Dto.Group;
-using LightlessSyncServer.Hubs;
-using LightlessSyncServer.Services.Interfaces;
-using LightlessSyncServer.Utils;
-using LightlessSyncShared.Data;
-using Microsoft.AspNetCore.SignalR;
-using Microsoft.EntityFrameworkCore;
-
-namespace LightlessSyncServer.Worker
-{
-    public class AutoPruneWorker(IServiceProvider services, ILogger<AutoPruneWorker> logger) : BackgroundService
-    {
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            while (!stoppingToken.IsCancellationRequested)
-            {
-                try
-                {
-                    var scope = services.CreateAsyncScope();
-                    await using (scope.ConfigureAwait(false))
-                    {
-                        var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
-                        var pruneService = scope.ServiceProvider.GetRequiredService<IPruneService>();
-                        var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<LightlessHub>>();
-
-                        var groups = await db.Groups
-                            .Where(g => g.AutoPruneEnabled && g.AutoPruneDays > 0)
-                            .ToListAsync(stoppingToken).ConfigureAwait(false);
-
-                        foreach (var group in groups)
-                        {
-                            var allGroupUsers = await db.GroupPairs
-                                .Include(p => p.GroupUser)
-                                .Include(p => p.Group)
-                                .Where(p => p.GroupGID == group.GID)
-                                .ToListAsync(stoppingToken).ConfigureAwait(false);
-
-                            var prunedPairs = await pruneService.ExecutePruneAsync(group.GID, group.AutoPruneDays, stoppingToken).ConfigureAwait(false);
-
-                            if (prunedPairs.Count == 0)
-                                continue;
-
-                            var remainingUserIds = allGroupUsers
-                                .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
-                                .Select(p => p.GroupUserUID)
-                                .Distinct(StringComparer.Ordinal)
-                                .ToList();
-
-                            foreach (var pair in prunedPairs)
-                            {
-                                await hubContext.Clients.Users(remainingUserIds).SendAsync("Client_GroupPairLeft", new GroupPairDto(group.ToGroupData(), pair.GroupUser.ToUserData()), stoppingToken).ConfigureAwait(false);
-                            }
-
-                            logger.LogInformation("Auto-pruned {Count} users from group {GroupId}", prunedPairs.Count, group.GID);
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    logger.LogError(ex, "Error in auto-prune worker");
-                }
-
-                //Run task each hour to check for pruning
-                await Task.Delay(TimeSpan.FromHours(1), stoppingToken).ConfigureAwait(false);
-            }
-        }
-    }
-}

LightlessSyncServer/LightlessSyncServer/appsettings.json

@@ -7,7 +7,6 @@
       "Default": "Information",
       "Microsoft": "Warning",
       "Microsoft.Hosting.Lifetime": "Information",
-      "Microsoft.EntityFrameworkCore.Database.Command": "Warning",
       "LightlessSyncServer.Authentication": "Warning",
       "System.IO.IOException": "Warning"
     },
@@ -41,9 +40,6 @@
     "PairRequestRateLimit": 5,
     "PairRequestRateWindow": 60
   },
-  "ChatZoneOverrides": {
-    "Zones": []
-  },
   "AllowedHosts": "*",
   "Kestrel": {
     "Endpoints": {

LightlessSyncServer/LightlessSyncServices/Discord/DiscordBot.cs

@@ -1,6 +1,9 @@
+using System.Collections.Generic;
+using System;
 using System.Globalization;
 using System.Text;
 using System.Text.Json;
+using System.Linq;
 using Discord;
 using Discord.Interactions;
 using Discord.Rest;
@@ -159,7 +162,7 @@ internal class DiscordBot : IHostedService
 
             try
             {
-                await Task.Delay(TimeSpan.FromMinutes(1), token).ConfigureAwait(false);
+                await Task.Delay(TimeSpan.FromMinutes(10), token).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
@@ -201,7 +204,7 @@ internal class DiscordBot : IHostedService
             var embed = await BuildChatReportEmbedAsync(dbContext, report, token).ConfigureAwait(false);
 
             var components = new ComponentBuilder()
-                .WithButton("Resolve", $"{ChatReportButtonPrefix}-resolve-{report.ReportId}", ButtonStyle.Danger)
+                .WithButton("Actioned", $"{ChatReportButtonPrefix}-resolve-{report.ReportId}", ButtonStyle.Danger)
                 .WithButton("Dismiss", $"{ChatReportButtonPrefix}-dismiss-{report.ReportId}", ButtonStyle.Secondary)
                 .WithButton("Ban From Chat", $"{ChatReportButtonPrefix}-banchat-{report.ReportId}", ButtonStyle.Danger);
 
@@ -392,7 +395,7 @@ internal class DiscordBot : IHostedService
         switch (action)
         {
             case "resolve":
-                resolutionLabel = "Resolved";
+                resolutionLabel = "Actioned";
                 break;
             case "dismiss":
                 resolutionLabel = "Dismissed";
@@ -428,7 +431,7 @@ internal class DiscordBot : IHostedService
 
         string responseText = action switch
         {
-            "resolve" => "resolved",
+            "resolve" => "actioned",
             "dismiss" => "dismissed",
             "banchat" => "chat access revoked",
             _ => "processed"
@@ -470,7 +473,7 @@ internal class DiscordBot : IHostedService
         embedBuilder.Fields.RemoveAll(f => string.Equals(f.Name, "Resolution", StringComparison.OrdinalIgnoreCase));
         var resolutionText = action switch
         {
-            "resolve" => "Resolved",
+            "resolve" => "Actioned",
             "dismiss" => "Dismissed",
             "banchat" => "Chat access revoked",
             _ => "Processed"
@@ -869,17 +872,16 @@ internal class DiscordBot : IHostedService
         string? SenderHashedCid,
         string Message);
 
-    private async Task UpdateStatusAsync(CancellationToken cancellationToken)
+    private async Task UpdateStatusAsync(CancellationToken token)
     {
-        while (!cancellationToken.IsCancellationRequested)
+        while (!token.IsCancellationRequested)
         {
             var endPoint = _connectionMultiplexer.GetEndPoints().First();
-            var keys = _connectionMultiplexer.GetServer(endPoint).KeysAsync(pattern: "UID:*");
+            var onlineUsers = await _connectionMultiplexer.GetServer(endPoint).KeysAsync(pattern: "UID:*").CountAsync().ConfigureAwait(false);
-            var onlineUsers = await keys.CountAsync(cancellationToken).ConfigureAwait(false);
 
-			_logger.LogInformation("Users online: " + onlineUsers);
+            _logger.LogInformation("Users online: " + onlineUsers);
             await _discordClient.SetActivityAsync(new Game("Lightless for " + onlineUsers + " Users")).ConfigureAwait(false);
-            await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken).ConfigureAwait(false);
+            await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
         }
     }
 }

LightlessSyncServer/LightlessSyncServices/Discord/MareModule.cs

@@ -43,54 +43,33 @@ public class LightlessModule : InteractionModuleBase
 
         try
         {
+            EmbedBuilder eb = new();
+
             using var scope = _services.CreateScope();
             var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
             await using (db.ConfigureAwait(false))
             {
-                var (mainEmbed, profileEmbed) = await HandleUserInfo(db, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);
+                eb = await HandleUserInfo(eb, db, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);
 
                 string uidToGet = await GetUserUID(db, secondaryUid, discordUser?.Id ?? null, uid).ConfigureAwait(false);
                 var profileData = await GetUserProfileData(db, uidToGet).ConfigureAwait(false);
-                
-                List<Embed> embeds = new() { mainEmbed };
-                if (profileEmbed != null)
-                {
-                    embeds.Add(profileEmbed);
-                }
-
                 if (profileData != null)
                 {
                     byte[] profileImage = GetProfileImage(profileData);
                     byte[] bannerImage = GetBannerImage(profileData);
                     using MemoryStream profileImgStream = new(profileImage);
                     using MemoryStream bannerImgStream = new(bannerImage);
-                    
+                    eb.WithThumbnailUrl("attachment://profileimage.png");
-                    var mainEmbedData = embeds[0];
+                    eb.WithImageUrl("attachment://bannerimage.png");
-                    var mainEmbedBuilder = new EmbedBuilder()
-                        .WithTitle(mainEmbedData.Title)
-                        .WithDescription(mainEmbedData.Description)
-                        .WithThumbnailUrl("attachment://profileimage.png")
-                        .WithImageUrl("attachment://bannerimage.png");
-                    
-                    if (mainEmbedData.Fields != null)
-                    {
-                        foreach (var field in mainEmbedData.Fields)
-                        {
-                            mainEmbedBuilder.AddField(field.Name, field.Value, field.Inline);
-                        }
-                    }
-                    
-                    embeds[0] = mainEmbedBuilder.Build();
-                    
                     await RespondWithFilesAsync(
                         new[] { new FileAttachment(profileImgStream, "profileimage.png"), new FileAttachment(bannerImgStream, "bannerimage.png") },
-                        embeds: embeds.ToArray(),
+                        embeds: new[] { eb.Build() },
                         ephemeral: true).ConfigureAwait(false);
                 } 
                 else
                 {
                     await RespondAsync(
-                        embeds: embeds.ToArray(),
+                        embeds: new[] { eb.Build() },
                         ephemeral: true).ConfigureAwait(false);
                 }
             }
@@ -470,7 +449,7 @@ public class LightlessModule : InteractionModuleBase
         return embed.Build();
     }
 
-    private async Task<(Embed mainEmbed, Embed? profileEmbed)> HandleUserInfo(LightlessDbContext db, ulong id, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
+    private async Task<EmbedBuilder> HandleUserInfo(EmbedBuilder eb, LightlessDbContext db, ulong id, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
     {
         bool showForSecondaryUser = secondaryUserUid != null;
 
@@ -480,20 +459,18 @@ public class LightlessModule : InteractionModuleBase
 
         if (primaryUser == null)
         {
-            EmbedBuilder eb = new();
             eb.WithTitle("No account");
             eb.WithDescription("No Lightless account was found associated to your Discord user");
-            return (eb.Build(), null);
+            return eb;
         }
 
         bool isAdminCall = primaryUser.User.IsModerator || primaryUser.User.IsAdmin;
 
         if ((optionalUser != null || uid != null) && !isAdminCall)
         {
-            EmbedBuilder eb = new();
             eb.WithTitle("Unauthorized");
             eb.WithDescription("You are not authorized to view another users' information");
-            return (eb.Build(), null);
+            return eb;
         }
         else if ((optionalUser != null || uid != null) && isAdminCall)
         {
@@ -509,10 +486,9 @@ public class LightlessModule : InteractionModuleBase
 
             if (userInDb == null)
             {
-                EmbedBuilder eb = new();
                 eb.WithTitle("No account");
                 eb.WithDescription("The Discord user has no valid Lightless account");
-                return (eb.Build(), null);
+                return eb;
             }
 
             userToCheckForDiscordId = userInDb.DiscordId;
@@ -525,10 +501,9 @@ public class LightlessModule : InteractionModuleBase
             dbUser = (await db.Auth.Include(u => u.User).SingleOrDefaultAsync(u => u.PrimaryUserUID == dbUser.UID && u.UserUID == secondaryUserUid))?.User;
             if (dbUser == null)
             {
-                EmbedBuilder eb = new();
                 eb.WithTitle("No such secondary UID");
                 eb.WithDescription($"A secondary UID {secondaryUserUid} was not found attached to your primary UID {primaryUser.User.UID}.");
-                return (eb.Build(), null);
+                return eb;
             }
         }
 
@@ -538,61 +513,55 @@ public class LightlessModule : InteractionModuleBase
         var profile = await db.UserProfileData.Where(u => u.UserUID == dbUser.UID).SingleOrDefaultAsync().ConfigureAwait(false);
         var identity = await _connectionMultiplexer.GetDatabase().StringGetAsync("UID:" + dbUser.UID).ConfigureAwait(false);
 
-        EmbedBuilder mainEmbed = new();
+        eb.WithTitle("User Information");
-        mainEmbed.WithTitle("User Information");
+        eb.WithDescription("This is the user information for Discord User <@" + userToCheckForDiscordId + ">" + Environment.NewLine + Environment.NewLine
-        mainEmbed.WithDescription("This is the user information for Discord User <@" + userToCheckForDiscordId + ">" + Environment.NewLine + Environment.NewLine
             + "If you want to verify your secret key is valid, go to https://emn178.github.io/online-tools/sha256.html and copy your secret key into there and compare it to the Hashed Secret Key provided below.");
-        mainEmbed.AddField("UID", dbUser.UID);
+        eb.AddField("UID", dbUser.UID);
         if (!string.IsNullOrEmpty(dbUser.Alias))
         {
-            mainEmbed.AddField("Vanity UID", dbUser.Alias);
+            eb.AddField("Vanity UID", dbUser.Alias);
         }
         if (showForSecondaryUser)
         {
-            mainEmbed.AddField("Primary UID for " + dbUser.UID, auth.PrimaryUserUID);
+            eb.AddField("Primary UID for " + dbUser.UID, auth.PrimaryUserUID);
         }
         else
         {
             var secondaryUIDs = await db.Auth.Where(p => p.PrimaryUserUID == dbUser.UID).Select(p => p.UserUID).ToListAsync();
             if (secondaryUIDs.Any())
             {
-                mainEmbed.AddField("Secondary UIDs", string.Join(Environment.NewLine, secondaryUIDs));
+                eb.AddField("Secondary UIDs", string.Join(Environment.NewLine, secondaryUIDs));
             }
         }
-        mainEmbed.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
+        if(profile != null)
-        mainEmbed.AddField("Currently online ", !string.IsNullOrEmpty(identity));
+        {
-        mainEmbed.AddField("Hashed Secret Key", auth.HashedKey);
+            eb.AddField("Profile Description", string.IsNullOrEmpty(profile.UserDescription) ? "(No description set)" : profile.UserDescription);
-        mainEmbed.AddField("Joined Syncshells", groupsJoined.Count);
+            eb.AddField("Profile NSFW", profile.IsNSFW);
-        mainEmbed.AddField("Owned Syncshells", groups.Count);
+            eb.AddField("Profile Disabled", profile.ProfileDisabled);
+            eb.AddField("Profile Flagged for Report", profile.FlaggedForReport);
+            eb.AddField("Profile Tags", profile.Tags != null && profile.Tags.Length > 0 ? string.Join(", ", profile.Tags) : "(No tags set)");
+        }
+        eb.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
+        eb.AddField("Currently online ", !string.IsNullOrEmpty(identity));
+        eb.AddField("Hashed Secret Key", auth.HashedKey);
+        eb.AddField("Joined Syncshells", groupsJoined.Count);
+        eb.AddField("Owned Syncshells", groups.Count);
         foreach (var group in groups)
         {
             var syncShellUserCount = await db.GroupPairs.CountAsync(g => g.GroupGID == group.GID).ConfigureAwait(false);
             if (!string.IsNullOrEmpty(group.Alias))
             {
-                mainEmbed.AddField("Owned Syncshell " + group.GID + " Vanity ID", group.Alias);
+                eb.AddField("Owned Syncshell " + group.GID + " Vanity ID", group.Alias);
             }
-            mainEmbed.AddField("Owned Syncshell " + group.GID + " User Count", syncShellUserCount);
+            eb.AddField("Owned Syncshell " + group.GID + " User Count", syncShellUserCount);
         }
 
         if (isAdminCall && !string.IsNullOrEmpty(identity))
         {
-            mainEmbed.AddField("Character Ident", identity);
+            eb.AddField("Character Ident", identity);
         }
 
-        Embed? profileEmbedResult = null;
+        return eb;
-        if (profile != null)
-        {
-            EmbedBuilder profileEmbedBuilder = new();
-            profileEmbedBuilder.WithTitle("User Profile");
-            profileEmbedBuilder.WithDescription("Profile Description: " + (string.IsNullOrEmpty(profile.UserDescription) ? "(No description set)" : profile.UserDescription));
-            profileEmbedBuilder.AddField("Profile NSFW", profile.IsNSFW);
-            profileEmbedBuilder.AddField("Profile Disabled", profile.ProfileDisabled);
-            profileEmbedBuilder.AddField("Profile Flagged for Report", profile.FlaggedForReport);
-            profileEmbedBuilder.AddField("Profile Tags", profile.Tags != null && profile.Tags.Length > 0 ? string.Join(", ", profile.Tags) : "(No tags set)");
-            profileEmbedResult = profileEmbedBuilder.Build();
-        }
-
-        return (mainEmbed.Build(), profileEmbedResult);
     }
 
     private async Task<string> GetUserUID(LightlessDbContext db, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
@@ -609,7 +578,7 @@ public class LightlessModule : InteractionModuleBase
             }
             else if (uid != null)
             {
-                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid). ConfigureAwait(false);
+                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid).ConfigureAwait(false);
             }
             if (userInDb == null)
             {

LightlessSyncServer/LightlessSyncServices/Discord/MareWizardModule.Vanity.cs

@@ -94,7 +94,7 @@ public partial class LightlessWizardModule
         bool canAddVanityId = !db.Users.Any(u => u.UID == modal.DesiredVanityUID || u.Alias == modal.DesiredVanityUID);
         var forbiddenWords = new[] { "null", "nil" };
 
-        Regex rgx = new(@"^[_\-a-zA-Z0-9\?]{3,15}$", RegexOptions.ECMAScript);
+        Regex rgx = new(@"^[_\-a-zA-Z0-9]{3,15}$", RegexOptions.ECMAScript);
         if (!rgx.Match(desiredVanityUid).Success)
         {
             eb.WithColor(Color.Red);

LightlessSyncServer/LightlessSyncServices/LightlessSyncServices.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
@@ -21,7 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.18.0" />
+    <PackageReference Include="Discord.Net" Version="3.17.0" />
     <PackageReference Include="IDisposableAnalyzers" Version="4.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -32,7 +32,6 @@
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.0" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Systemd" Version="9.0.0" />
-    <PackageReference Include="System.Linq.Async" Version="7.0.0" />
   </ItemGroup>
 
   <ItemGroup>

LightlessSyncServer/LightlessSyncShared/Data/MareDbContext.cs

@@ -80,9 +80,6 @@ public class LightlessDbContext : DbContext
         .WithOne(p => p.Group)
         .HasForeignKey<GroupProfile>(p => p.GroupGID)
         .IsRequired(false);
-        mb.Entity<Group>()
-        .Property(g => g.ChatEnabled)
-        .HasDefaultValue(true);
         mb.Entity<GroupPair>().ToTable("group_pairs");
         mb.Entity<GroupPair>().HasKey(u => new { u.GroupGID, u.GroupUserUID });
         mb.Entity<GroupPair>().HasIndex(c => c.GroupUserUID);

LightlessSyncServer/LightlessSyncShared/LightlessSyncShared.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFramework>net10.0</TargetFramework>
+		<TargetFramework>net9.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 	</PropertyGroup>
 
@@ -47,6 +47,7 @@
 		<PackageReference Include="StackExchange.Redis.Extensions.Core" Version="10.2.0" />
 		<PackageReference Include="StackExchange.Redis.Extensions.System.Text.Json" Version="10.2.0" />
 		<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.3.0" />
+		<PackageReference Include="System.Linq.Async" Version="6.0.1" />
 	</ItemGroup>
 
 	<ItemGroup>

LightlessSyncServer/LightlessSyncShared/Metrics/MetricsAPI.cs

@@ -11,7 +11,6 @@ public class MetricsAPI
     public const string CounterUsersRegisteredDeleted = "lightless_users_registered_deleted";
     public const string GaugeLightFinderConnections = "lightless_lightfinder_connections";
     public const string GaugeLightFinderGroups = "lightless_lightfinder_groups";
-    public const string GaugeGroupAutoPrunesEnabled = "lightless_group_autoprunes_enabled";
     public const string GaugePairs = "lightless_pairs";
     public const string GaugePairsPaused = "lightless_pairs_paused";
     public const string GaugeFilesTotal = "lightless_files";

LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.cs

@@ -1,40 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace LightlessSyncServer.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddAutoPruneInGroup : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "auto_prune_days",
-                table: "groups",
-                type: "integer",
-                nullable: false,
-                defaultValue: 0);
-
-            migrationBuilder.AddColumn<bool>(
-                name: "auto_prune_enabled",
-                table: "groups",
-                type: "boolean",
-                nullable: false,
-                defaultValue: false);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "auto_prune_days",
-                table: "groups");
-
-            migrationBuilder.DropColumn(
-                name: "auto_prune_enabled",
-                table: "groups");
-        }
-    }
-}

LightlessSyncServer/LightlessSyncShared/Migrations/20251219115131_ChatReportFixes.cs

@@ -1,29 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace LightlessSyncServer.Migrations
-{
-    /// <inheritdoc />
-    public partial class ChatReportFixes : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "sender_token",
-                table: "reported_chat_messages");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "sender_token",
-                table: "reported_chat_messages",
-                type: "text",
-                nullable: false,
-                defaultValue: "");
-        }
-    }
-}

LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.cs

@@ -1,29 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace LightlessSyncServer.Migrations
-{
-    /// <inheritdoc />
-    public partial class DisableChatGroups : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<bool>(
-                name: "chat_enabled",
-                table: "groups",
-                type: "boolean",
-                nullable: false,
-                defaultValue: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "chat_enabled",
-                table: "groups");
-        }
-    }
-}

LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.cs

@@ -1,30 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace LightlessSyncServer.Migrations
-{
-    /// <inheritdoc />
-    public partial class ShareLocation : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<DateTimeOffset>(
-                name: "share_location_until",
-                table: "user_permission_sets",
-                type: "timestamp with time zone",
-                nullable: false,
-                defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "share_location_until",
-                table: "user_permission_sets");
-        }
-    }
-}

LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs

@@ -430,20 +430,6 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("character varying(50)")
                         .HasColumnName("alias");
 
-                    b.Property<int>("AutoPruneDays")
-                        .HasColumnType("integer")
-                        .HasColumnName("auto_prune_days");
-
-                    b.Property<bool>("AutoPruneEnabled")
-                        .HasColumnType("boolean")
-                        .HasColumnName("auto_prune_enabled");
-
-                    b.Property<bool>("ChatEnabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(true)
-                        .HasColumnName("chat_enabled");
-
                     b.Property<DateTime>("CreatedDate")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("timestamp with time zone")
@@ -782,6 +768,11 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("text")
                         .HasColumnName("sender_hashed_cid");
 
+                    b.Property<string>("SenderToken")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("sender_token");
+
                     b.Property<bool>("SenderWasLightfinder")
                         .HasColumnType("boolean")
                         .HasColumnName("sender_was_lightfinder");
@@ -941,10 +932,6 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("is_paused");
 
-                    b.Property<DateTimeOffset>("ShareLocationUntil")
-                        .HasColumnType("timestamp with time zone")
-                        .HasColumnName("share_location_until");
-
                     b.Property<bool>("Sticky")
                         .HasColumnType("boolean")
                         .HasColumnName("sticky");

LightlessSyncServer/LightlessSyncShared/Models/Group.cs

@@ -12,13 +12,10 @@ public class Group
     [MaxLength(50)]
     public string Alias { get; set; }
     public GroupProfile? Profile { get; set; }
-    public bool AutoPruneEnabled { get; set; } = false;
-    public int AutoPruneDays { get; set; } = 0;
     public bool InvitesEnabled { get; set; }
     public string HashedPassword { get; set; }
     public bool PreferDisableSounds { get; set; }
     public bool PreferDisableAnimations { get; set; }
     public bool PreferDisableVFX { get; set; }
-    public bool ChatEnabled { get; set; } = true;
     public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
 }

LightlessSyncServer/LightlessSyncShared/Models/ReportedChatMessage.cs

@@ -40,6 +40,9 @@ public class ReportedChatMessage
     [Required]
     public string MessageContent { get; set; } = string.Empty;
 
+    [Required]
+    public string SenderToken { get; set; } = string.Empty;
+
     public string? SenderHashedCid { get; set; }
 
     public string? SenderDisplayName { get; set; }

LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs

@@ -15,5 +15,4 @@ public class UserPermissionSet
     public bool DisableAnimations { get; set; } = false;
     public bool DisableVFX { get; set; } = false;
     public bool DisableSounds { get; set; } = false;
-    public DateTimeOffset ShareLocationUntil { get; set; } = DateTimeOffset.MinValue;
 }

LightlessSyncServer/LightlessSyncStaticFilesServer/Controllers/ServerFilesController.cs

@@ -1,4 +1,5 @@
-using K4os.Compression.LZ4.Legacy;
+using Blake3;
+using K4os.Compression.LZ4.Legacy;
 using LightlessSync.API.Dto.Files;
 using LightlessSync.API.Routes;
 using LightlessSync.API.SignalR;
@@ -208,11 +209,14 @@ public class ServerFilesController : ControllerBase
     [RequestSizeLimit(200 * 1024 * 1024)]
     public async Task<IActionResult> UploadFile(string hash, CancellationToken requestAborted)
     {
-        using var dbContext = await _lightlessDbContext.CreateDbContextAsync();
+        await using var dbContext = await _lightlessDbContext.CreateDbContextAsync();
 
         _logger.LogInformation("{user}|{file}: Uploading", LightlessUser, hash);
+        if (hash.Length == 40)
+        {
+            hash = hash.ToUpperInvariant();
+        }
 
-        hash = hash.ToUpperInvariant();
         var existingFile = await dbContext.Files.SingleOrDefaultAsync(f => f.Hash == hash);
         if (existingFile != null) return Ok();
 
@@ -263,10 +267,14 @@ public class ServerFilesController : ControllerBase
     [RequestSizeLimit(200 * 1024 * 1024)]
     public async Task<IActionResult> UploadFileMunged(string hash, CancellationToken requestAborted)
     {
-        using var dbContext = await _lightlessDbContext.CreateDbContextAsync();
+        await using var dbContext = await _lightlessDbContext.CreateDbContextAsync();
 
         _logger.LogInformation("{user}|{file}: Uploading munged", LightlessUser, hash);
-        hash = hash.ToUpperInvariant();
+        if (hash.Length == 40)
+        {
+            hash = hash.ToUpperInvariant();
+        }
+
         var existingFile = await dbContext.Files.SingleOrDefaultAsync(f => f.Hash == hash);
         if (existingFile != null) return Ok();
 
@@ -319,20 +327,26 @@ public class ServerFilesController : ControllerBase
     private async Task StoreData(string hash, LightlessDbContext dbContext, MemoryStream compressedFileStream)
     {
         var decompressedData = LZ4Wrapper.Unwrap(compressedFileStream.ToArray());
-        // reset streams
         compressedFileStream.Seek(0, SeekOrigin.Begin);
 
-        // compute hash to verify
+        bool valid;
-        var hashString = BitConverter.ToString(SHA1.HashData(decompressedData))
-            .Replace("-", "", StringComparison.Ordinal).ToUpperInvariant();
-        if (!string.Equals(hashString, hash, StringComparison.Ordinal))
-            throw new InvalidOperationException($"{LightlessUser}|{hash}: Hash does not match file, computed: {hashString}, expected: {hash}");
 
-        // save file
+        if (hash.Length == 40)
-        var path = FilePathUtil.GetFilePath(_basePath, hash);
+        {
-        using var fileStream = new FileStream(path, FileMode.Create);
+            var sha1Hex = Convert.ToHexString(SHA1.HashData(decompressedData));
-        await compressedFileStream.CopyToAsync(fileStream).ConfigureAwait(false);
+            valid = string.Equals(sha1Hex, hash, StringComparison.OrdinalIgnoreCase);
-        _logger.LogDebug("{user}|{file}: Uploaded file saved to {path}", LightlessUser, hash, path);
+        }
+        else
+        {
+            var blakeHash = Hasher.Hash(decompressedData);
+            var blakeHex = Convert.ToHexString(blakeHash.AsSpan());
+            valid = string.Equals(blakeHex, hash, StringComparison.OrdinalIgnoreCase);
+        }
+
+        if (!valid)
+            throw new InvalidOperationException(
+                $"{LightlessUser}|{hash}: Hash does not match file, computed mismatch."
+            );
 
         // update on db
         await dbContext.Files.AddAsync(new FileCache()

LightlessSyncServer/LightlessSyncStaticFilesServer/LightlessSyncStaticFilesServer.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
@@ -18,6 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Blake3" Version="2.0.0" />
     <PackageReference Include="IDisposableAnalyzers" Version="4.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs

@@ -102,37 +102,36 @@ public sealed class CachedFileProvider : IDisposable
 
     private bool TryCopyFromColdStorage(string hash, string destinationFilePath)
     {
-		if (!_configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.UseColdStorage), false)) return false;
+        if (!_configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.UseColdStorage), false)) return false;
 
-		string coldStorageDir = _configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.ColdStorageDirectory), string.Empty);
+        string coldStorageDir = _configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.ColdStorageDirectory), string.Empty);
-		if (string.IsNullOrEmpty(coldStorageDir)) return false;
+        if (string.IsNullOrEmpty(coldStorageDir)) return false;
 
-		var coldStorageFilePath = FilePathUtil.GetFileInfoForHash(coldStorageDir, hash);
+        var coldStorageFilePath = FilePathUtil.GetFileInfoForHash(coldStorageDir, hash);
-		if (coldStorageFilePath == null) return false;
+        if (coldStorageFilePath == null) return false;
 
-		try
+        try
-		{
+        {
-			_logger.LogDebug("Copying {hash} from cold storage: {path}", hash, coldStorageFilePath);
+            _logger.LogDebug("Copying {hash} from cold storage: {path}", hash, coldStorageFilePath);
-			var tempFileName = destinationFilePath + ".dl";
+            var tempFileName = destinationFilePath + ".dl";
-			File.Copy(coldStorageFilePath.FullName, tempFileName, true);
+            File.Copy(coldStorageFilePath.FullName, tempFileName, true);
-			File.Move(tempFileName, destinationFilePath, true);
+            File.Move(tempFileName, destinationFilePath, true);
+            coldStorageFilePath.LastAccessTimeUtc = DateTime.UtcNow;
+            var destinationFile = new FileInfo(destinationFilePath);
+            destinationFile.LastAccessTimeUtc = DateTime.UtcNow;
+            destinationFile.CreationTimeUtc = DateTime.UtcNow;
+            destinationFile.LastWriteTimeUtc = DateTime.UtcNow;
+            _metrics.IncGauge(MetricsAPI.GaugeFilesTotal);
+            _metrics.IncGauge(MetricsAPI.GaugeFilesTotalSize, new FileInfo(destinationFilePath).Length);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Could not copy {coldStoragePath} from cold storage", coldStorageFilePath);
+        }
 
-			File.SetLastAccessTimeUtc(coldStorageFilePath.FullName, DateTime.UtcNow);
+        return false;
-			File.SetLastAccessTimeUtc(destinationFilePath, DateTime.UtcNow);
+    }
-			File.SetCreationTimeUtc(destinationFilePath, DateTime.UtcNow);
-			File.SetLastWriteTimeUtc(destinationFilePath, DateTime.UtcNow);
-
-			_metrics.IncGauge(MetricsAPI.GaugeFilesTotal);
-			_metrics.IncGauge(MetricsAPI.GaugeFilesTotalSize, new FileInfo(destinationFilePath).Length);
-			return true;
-		}
-		catch (Exception ex)
-		{
-			_logger.LogWarning(ex, "Could not copy {coldStoragePath} from cold storage", coldStorageFilePath);
-		}
-
-		return false;
-	}
 
     public async Task DownloadFileWhenRequired(string hash)
     {
@@ -171,22 +170,15 @@ public sealed class CachedFileProvider : IDisposable
 
     public FileInfo? GetLocalFilePath(string hash)
     {
-		var fi = FilePathUtil.GetFileInfoForHash(_hotStoragePath, hash);
+        var fi = FilePathUtil.GetFileInfoForHash(_hotStoragePath, hash);
-		if (fi == null) return null;
+        if (fi == null) return null;
 
-		try
+        fi.LastAccessTimeUtc = DateTime.UtcNow;
-		{
-			File.SetLastAccessTimeUtc(fi.FullName, DateTime.UtcNow);
-		}
-		catch (Exception ex)
-		{
-			_logger.LogWarning(ex, "Failed to update LastAccessTimeUtc for file {hash}", hash);
-		}
 
-		_fileStatisticsService.LogFile(hash, fi.Length);
+        _fileStatisticsService.LogFile(hash, fi.Length);
 
-		return new FileInfo(fi.FullName);
+        return new FileInfo(fi.FullName);
-	}
+    }
 
     public async Task<FileInfo?> DownloadAndGetLocalFileInfo(string hash)
     {