Merge branch 'master' into cache-test-fix

Reviewed-on: #45

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "LightlessAPI"]
 	path = LightlessAPI
 	url = https://git.lightless-sync.org/Lightless-Sync/LightlessAPI
+	branch = main

LightlessSyncServer/LightlessSyncAuthService/Controllers/AuthControllerBase.cs

@@ -100,14 +100,15 @@ public abstract class AuthControllerBase : Controller
 
     protected async Task<IActionResult> CreateJwtFromId(string uid, string charaIdent, string alias)
     {
-        var token = CreateJwt(new List<Claim>()
+        var token = CreateJwt(
-        {
+        [
             new Claim(LightlessClaimTypes.Uid, uid),
             new Claim(LightlessClaimTypes.CharaIdent, charaIdent),
             new Claim(LightlessClaimTypes.Alias, alias),
             new Claim(LightlessClaimTypes.Expires, DateTime.UtcNow.AddHours(6).Ticks.ToString(CultureInfo.InvariantCulture)),
-            new Claim(LightlessClaimTypes.Continent, await _geoIPProvider.GetCountryFromIP(HttpAccessor))
+            new Claim(LightlessClaimTypes.Continent, await _geoIPProvider.GetContinentFromIP(HttpAccessor)),
-        });
+            new Claim(LightlessClaimTypes.Country, await _geoIPProvider.GetCountryFromIP(HttpAccessor)),
+        ]);
 
         return Content(token.RawData);
     }

LightlessSyncServer/LightlessSyncAuthService/Controllers/JwtController.cs

@@ -1,5 +1,6 @@
 using LightlessSync.API.Routes;
 using LightlessSyncAuthService.Services;
+using LightlessSyncAuthService.Utils;
 using LightlessSyncShared;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Services;

LightlessSyncServer/LightlessSyncAuthService/Controllers/OAuthController.cs

@@ -1,5 +1,6 @@
 using LightlessSync.API.Routes;
 using LightlessSyncAuthService.Services;
+using LightlessSyncAuthService.Utils;
 using LightlessSyncShared;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Services;

LightlessSyncServer/LightlessSyncAuthService/LightlessSyncAuthService.csproj

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

LightlessSyncServer/LightlessSyncAuthService/Services/GeoIPService.cs

@@ -1,7 +1,8 @@
-using LightlessSyncShared;
+using LightlessSyncAuthService.Utils;
 using LightlessSyncShared.Services;
 using LightlessSyncShared.Utils.Configuration;
 using MaxMind.GeoIP2;
+using System.Net;
 
 namespace LightlessSyncAuthService.Services;
 
@@ -23,7 +24,7 @@ public class GeoIPService : IHostedService
         _lightlessConfiguration = lightlessConfiguration;
     }
 
-    public async Task<string> GetCountryFromIP(IHttpContextAccessor httpContextAccessor)
+    public async Task<string> GetContinentFromIP(IHttpContextAccessor httpContextAccessor)
     {
         if (!_useGeoIP)
         {
@@ -32,7 +33,9 @@ public class GeoIPService : IHostedService
 
         try
         {
-            var ip = httpContextAccessor.GetIpAddress();
+            var ip = httpContextAccessor.GetClientIpAddress();
+            if (ip is null || IPAddress.IsLoopback(ip))
+                return "*";
 
             using CancellationTokenSource waitCts = new();
             waitCts.CancelAfter(TimeSpan.FromSeconds(5));
@@ -41,11 +44,14 @@ 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";
                     }
@@ -53,6 +59,8 @@ public class GeoIPService : IHostedService
                     {
                         continent = "NA-E";
                     }
+
+                    _logger.LogDebug("Connecting {countryIso} to {continent}", countryIso, continent);
                 }
 
                 return continent ?? "*";
@@ -140,4 +148,34 @@ public class GeoIPService : IHostedService
         _dbReader?.Dispose();
         return Task.CompletedTask;
     }
+
+    internal async Task<string> GetCountryFromIP(IHttpContextAccessor httpContextAccessor)
+    {
+        if (!_useGeoIP)
+            return "*";
+
+        var ip = httpContextAccessor.GetClientIpAddress();
+        if (ip is null || IPAddress.IsLoopback(ip))
+            return "*";
+
+        try
+        {
+            using CancellationTokenSource waitCts = new(TimeSpan.FromSeconds(5));
+            while (_processingReload)
+                await Task.Delay(100, waitCts.Token).ConfigureAwait(false);
+
+            if (_dbReader!.TryCity(ip, out var response))
+            {
+                var country = response?.Country?.IsoCode;
+                return country ?? "*";
+            }
+
+            return "*";
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "GeoIP lookup failed for {Ip}", ip);
+            return "*";
+        }
+    }
 }

LightlessSyncServer/LightlessSyncAuthService/Utils/HttpContextAccessorExtensions.cs

@@ -0,0 +1,26 @@
+using System.Net;
+
+namespace LightlessSyncAuthService.Utils
+{
+    public static class HttpContextAccessorExtensions
+    {
+        public static IPAddress? GetClientIpAddress(this IHttpContextAccessor accessor)
+        {
+            var context = accessor.HttpContext;
+            if (context == null) return null;
+
+            string[] headerKeys = { "CF-Connecting-IP", "X-Forwarded-For", "X-Real-IP" };
+            foreach (var key in headerKeys)
+            {
+                if (context.Request.Headers.TryGetValue(key, out var values))
+                {
+                    var ipCandidate = values.FirstOrDefault()?.Split(',').FirstOrDefault()?.Trim();
+                    if (IPAddress.TryParse(ipCandidate, out var parsed))
+                        return parsed;
+                }
+            }
+
+            return context.Connection?.RemoteIpAddress;
+        }
+    }
+}

LightlessSyncServer/LightlessSyncServer/Configuration/BroadcastConfiguration.cs

@@ -59,6 +59,14 @@ public class BroadcastConfiguration : IBroadcastConfiguration
         return string.Concat(RedisKeyPrefix, hashedCid);
     }
 
+    public string BuildUserOwnershipKey(string userUid)
+    {
+        if (string.IsNullOrWhiteSpace(userUid))
+            throw new ArgumentException("User UID must not be null or empty.", nameof(userUid));
+
+        return string.Concat(RedisKeyPrefix, "owner:", userUid);
+    }
+
     public string BuildPairRequestNotification()
     {
         var template = Options.PairRequestNotificationTemplate;
@@ -69,4 +77,7 @@ public class BroadcastConfiguration : IBroadcastConfiguration
 
         return template;
     }
+
+    public int PairRequestRateLimit => Options.PairRequestRateLimit > 0 ? Options.PairRequestRateLimit : 5;
+    public int PairRequestRateWindow => Options.PairRequestRateWindow > 0 ? Options.PairRequestRateWindow : 60;
 }

LightlessSyncServer/LightlessSyncServer/Configuration/BroadcastOptions.cs

@@ -20,4 +20,10 @@ public class BroadcastOptions
     public bool EnableSyncshellBroadcastPayloads { get; set; } = true;
 
     public string PairRequestNotificationTemplate { get; set; } = "{DisplayName} sent you a pair request. To accept, right-click them, open the context menu, and send a request back.";
+
+    [Range(1, int.MaxValue)]
+    public int PairRequestRateLimit { get; set; } = 5;
+
+    [Range(1, int.MaxValue)]
+    public int PairRequestRateWindow { get; set; } = 60;
 }

LightlessSyncServer/LightlessSyncServer/Configuration/ChatZoneOverridesOptions.cs

@@ -0,0 +1,16 @@
+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/Configuration/IBroadcastConfiguration.cs

@@ -12,5 +12,9 @@ public interface IBroadcastConfiguration
     bool EnableSyncshellBroadcastPayloads { get; }
 
     string BuildRedisKey(string hashedCid);
+    string BuildUserOwnershipKey(string userUid);
     string BuildPairRequestNotification();
+
+    int PairRequestRateLimit { get; }
+    int PairRequestRateWindow { get; }
 }

LightlessSyncServer/LightlessSyncServer/Controllers/GroupController.cs

@@ -0,0 +1,56 @@
+using LightlessSync.API.Dto.Group;
+using LightlessSync.API.Routes;
+using LightlessSyncShared.Data;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace LightlessSyncServer.Controllers;
+
+[Route(LightlessAuth.Group)]
+[Authorize(Policy = "Internal")]
+public class GroupController : Controller
+{
+    protected readonly ILogger Logger;
+    protected readonly IDbContextFactory<LightlessDbContext> LightlessDbContextFactory;
+
+    public GroupController(ILogger<GroupController> logger, IDbContextFactory<LightlessDbContext> lightlessDbContext)
+    {
+        Logger = logger;
+        LightlessDbContextFactory = lightlessDbContext;
+    }
+
+    [Route(LightlessAuth.Disable_Profile)]
+    [HttpPost]
+    public async Task DisableGroupProfile([FromBody] GroupProfileAvailabilityRequest request)
+    {
+        using var dbContext = await LightlessDbContextFactory.CreateDbContextAsync();
+
+        Logger.LogInformation("Disabling profile for group with GID {GID}", request.GID);
+
+        var group = await dbContext.GroupProfiles.FirstOrDefaultAsync(f => f.GroupGID == request.GID);
+        if (group != null)
+        {
+            group.ProfileDisabled = true;
+        }
+
+        await dbContext.SaveChangesAsync();
+    }
+
+    [Route(LightlessAuth.Enable_Profile)]
+    [HttpPost]
+    public async Task EnableGroupProfile([FromBody] GroupProfileAvailabilityRequest request)
+    {
+        using var dbContext = await LightlessDbContextFactory.CreateDbContextAsync();
+
+        Logger.LogInformation("Disabling profile for group with GID {GID}", request.GID);
+
+        var group = await dbContext.GroupProfiles.FirstOrDefaultAsync(f => f.GroupGID == request.GID);
+        if (group != null)
+        {
+            group.ProfileDisabled = false;
+        }
+
+        await dbContext.SaveChangesAsync();
+    }
+}

LightlessSyncServer/LightlessSyncServer/Controllers/UserController.cs

@@ -5,7 +5,7 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 
-namespace LightlessSyncAuthService.Controllers;
+namespace LightlessSyncServer.Controllers;
 
 [Route(LightlessAuth.User)]
 [Authorize(Policy = "Internal")]
@@ -96,4 +96,38 @@ public class UserController : Controller
 
         await dbContext.SaveChangesAsync();
     }
+
+    [Route(LightlessAuth.Disable_Profile)]
+    [HttpPost]
+    public async Task DisableGroupProfile([FromBody] UserProfileAvailabilityRequest request)
+    {
+        using var dbContext = await LightlessDbContextFactory.CreateDbContextAsync();
+
+        Logger.LogInformation("Disabling profile for user with uid {UID}", request.UID);
+
+        var user = await dbContext.UserProfileData.FirstOrDefaultAsync(f => f.UserUID == request.UID);
+        if (user != null)
+        {
+            user.ProfileDisabled = true;
+        }
+
+        await dbContext.SaveChangesAsync();
+    }
+
+    [Route(LightlessAuth.Enable_Profile)]
+    [HttpPost]
+    public async Task EnableGroupProfile([FromBody] UserProfileAvailabilityRequest request)
+    {
+        using var dbContext = await LightlessDbContextFactory.CreateDbContextAsync();
+
+        Logger.LogInformation("Enabling profile for user with uid {UID}", request.UID);
+
+        var user = await dbContext.UserProfileData.FirstOrDefaultAsync(f => f.UserUID == request.UID);
+        if (user != null)
+        {
+            user.ProfileDisabled = false;
+        }
+
+        await dbContext.SaveChangesAsync();
+    }
 }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Chat.cs

@@ -0,0 +1,697 @@
+using System.Collections.Concurrent;
+using System.Text.Json;
+using LightlessSync.API.Data.Enum;
+using LightlessSync.API.Dto.Chat;
+using LightlessSyncServer.Models;
+using LightlessSyncServer.Services;
+using LightlessSyncServer.Utils;
+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 ChatRateLimitMessages = 7;
+    private static readonly TimeSpan ChatRateLimitWindow = TimeSpan.FromMinutes(1);
+    private static readonly ConcurrentDictionary<string, ChatRateLimitState> ChatRateLimiters = new(StringComparer.Ordinal);
+
+    private sealed class ChatRateLimitState
+    {
+        public readonly Queue<DateTime> Events = new();
+        public readonly object SyncRoot = new();
+    }
+    private static readonly JsonSerializerOptions ChatReportSnapshotSerializerOptions = new(JsonSerializerDefaults.General)
+    {
+        WriteIndented = false
+    };
+
+    [Authorize(Policy = "Identified")]
+    public Task<IReadOnlyList<ZoneChatChannelInfoDto>> GetZoneChatChannels()
+    {
+        return Task.FromResult(_chatChannelService.GetZoneChannelInfos());
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task<IReadOnlyList<GroupChatChannelInfoDto>> GetGroupChatChannels()
+    {
+        var userUid = UserUID;
+
+        var groupInfos = await DbContext.Groups
+            .AsNoTracking()
+            .Where(g => g.ChatEnabled
+                        && (g.OwnerUID == userUid
+                        || DbContext.GroupPairs.Any(p => p.GroupGID == g.GID && p.GroupUserUID == userUid))
+                        )
+            .ToListAsync()
+            .ConfigureAwait(false);
+
+        return groupInfos
+            .Select(g =>
+            {
+                var displayName = string.IsNullOrWhiteSpace(g.Alias) ? g.GID : g.Alias!;
+                var descriptor = new ChatChannelDescriptor
+                {
+                    Type = ChatChannelType.Group,
+                    WorldId = 0,
+                    ZoneId = 0,
+                    CustomKey = g.GID
+                };
+
+                return new GroupChatChannelInfoDto(
+                    descriptor,
+                    displayName,
+                    g.GID,
+                    string.Equals(g.OwnerUID, userUid, StringComparison.Ordinal));
+            })
+            .OrderBy(info => info.DisplayName, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task UpdateChatPresence(ChatPresenceUpdateDto presence)
+    {
+        var channel = presence.Channel.WithNormalizedCustomKey();
+
+        var userRecord = await DbContext.Users
+            .AsNoTracking()
+            .SingleAsync(u => u.UID == UserUID, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (userRecord.ChatBanned)
+        {
+            TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID), "clearing presence for banned user");
+            await NotifyChatBanAsync(UserUID).ConfigureAwait(false);
+            return;
+        }
+
+        if (!presence.IsActive)
+        {
+            if (!TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID, channel), "removing chat presence", channel))
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "We couldn't update your chat presence. Please try again.").ConfigureAwait(false);
+            }
+
+            return;
+        }
+
+        switch (channel.Type)
+        {
+            case ChatChannelType.Zone:
+                if (!_chatChannelService.TryResolveZone(channel.CustomKey, out var definition))
+                {
+                    throw new HubException("Unsupported chat channel.");
+                }
+
+                if (channel.WorldId == 0 || !WorldRegistry.IsKnownWorld(channel.WorldId))
+                {
+                    throw new HubException("Unsupported chat channel.");
+                }
+
+                if (presence.TerritoryId == 0 || !definition.TerritoryIds.Contains(presence.TerritoryId))
+                {
+                    throw new HubException("Zone chat is only available in supported territories.");
+                }
+
+                string? hashedCid = null;
+                var isLightfinder = false;
+                if (IsValidHashedCid(UserCharaIdent))
+                {
+                    var (entry, expiry) = await TryGetBroadcastEntryAsync(UserCharaIdent).ConfigureAwait(false);
+                    isLightfinder = HasActiveBroadcast(entry, expiry);
+                    if (isLightfinder)
+                    {
+                        hashedCid = UserCharaIdent;
+                    }
+                }
+
+                if (!TryInvokeChatService(
+                        () => _chatChannelService.UpdateZonePresence(
+                            UserUID,
+                            definition,
+                            channel.WorldId,
+                            presence.TerritoryId,
+                            hashedCid,
+                            isLightfinder,
+                            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:
+                var groupKey = channel.CustomKey ?? string.Empty;
+                if (string.IsNullOrEmpty(groupKey))
+                {
+                    throw new HubException("Unsupported chat channel.");
+                }
+
+                var userData = userRecord.ToUserData();
+
+                var group = await DbContext.Groups
+                    .AsNoTracking()
+                    .SingleOrDefaultAsync(g => g.GID == groupKey, cancellationToken: RequestAbortedToken)
+                    .ConfigureAwait(false);
+
+                if (group is null)
+                {
+                    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()
+                        .AnyAsync(gp => gp.GroupGID == groupKey && gp.GroupUserUID == UserUID, cancellationToken: RequestAbortedToken)
+                        .ConfigureAwait(false);
+
+                if (!isMember)
+                {
+                    throw new HubException("Join the syncshell before using chat.");
+                }
+
+                var displayName = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;
+
+                if (!TryInvokeChatService(
+                        () => _chatChannelService.UpdateGroupPresence(
+                            UserUID,
+                            group.GID,
+                            displayName,
+                            userData,
+                            IsValidHashedCid(UserCharaIdent) ? UserCharaIdent : null,
+                            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:
+                throw new HubException("Unsupported chat channel.");
+        }
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task SendChatMessage(ChatSendRequestDto request)
+    {
+        if (string.IsNullOrWhiteSpace(request.Message))
+        {
+            throw new HubException("Message cannot be empty.");
+        }
+
+        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.");
+        }
+
+        if (!_chatChannelService.TryGetPresence(UserUID, channel, out var presence))
+        {
+            throw new HubException("Join a chat channel before sending messages.");
+        }
+
+        if (!UseChatRateLimit(UserUID))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You can send at most " + ChatRateLimitMessages + " chat messages per minute. Please wait before sending more.").ConfigureAwait(false);
+            return;
+        }
+
+        var sanitizedMessage = request.Message.Trim().ReplaceLineEndings(" ");
+        if (sanitizedMessage.Length > MaxChatMessageLength)
+        {
+            sanitizedMessage = sanitizedMessage[..MaxChatMessageLength];
+        }
+
+        if (channel.Type == ChatChannelType.Zone &&
+            !ChatMessageFilter.TryValidate(sanitizedMessage, out var rejectionReason))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, rejectionReason).ConfigureAwait(false);
+            return;
+        }
+
+        try
+        {
+            var recipients = _chatChannelService.GetMembers(presence.Channel);
+            var recipientsList = recipients.ToList();
+            if (recipientsList.Count == 0)
+            {
+                return;
+            }
+
+            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)
+            {
+                bannedSet = new HashSet<string>(bannedRecipients, StringComparer.Ordinal);
+                foreach (var bannedUid in bannedSet)
+                {
+                    _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;
+                }
+
+                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);
+                }
+            }
+
+            if (deliveryTargets.Count == 0)
+            {
+                return;
+            }
+
+            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)
+        {
+            _logger.LogError(ex, "Failed to deliver chat message for {User} in {Channel}", UserUID, DescribeChannel(presence.Channel));
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Something went wrong while sending your message. Please try again.").ConfigureAwait(false);
+        }
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task ReportChatMessage(ChatReportSubmitDto request)
+    {
+        var channel = request.Channel.WithNormalizedCustomKey();
+
+        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);
+            return;
+        }
+
+        var requestedChannelKey = ChannelKey.FromDescriptor(channel);
+        var messageChannelKey = ChannelKey.FromDescriptor(messageEntry.Channel.WithNormalizedCustomKey());
+        if (!requestedChannelKey.Equals(messageChannelKey))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "The reported message no longer matches this channel.").ConfigureAwait(false);
+            return;
+        }
+
+        if (string.Equals(messageEntry.SenderUserUid, UserUID, StringComparison.Ordinal))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You cannot report your own message.").ConfigureAwait(false);
+            return;
+        }
+
+        var reason = request.Reason?.Trim();
+        if (string.IsNullOrWhiteSpace(reason))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "Please provide a short explanation for the report.").ConfigureAwait(false);
+            return;
+        }
+
+        const int MaxReasonLength = 500;
+        if (reason.Length > MaxReasonLength)
+        {
+            reason = reason[..MaxReasonLength];
+        }
+
+        var additionalContext = string.IsNullOrWhiteSpace(request.AdditionalContext)
+            ? null
+            : request.AdditionalContext.Trim();
+
+        const int MaxContextLength = 1000;
+        if (!string.IsNullOrEmpty(additionalContext) && additionalContext.Length > MaxContextLength)
+        {
+            additionalContext = additionalContext[..MaxContextLength];
+        }
+
+        var alreadyReported = await DbContext.ReportedChatMessages
+            .AsNoTracking()
+            .AnyAsync(r => r.MessageId == request.MessageId && r.ReporterUserUid == UserUID && !r.Resolved, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (alreadyReported)
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You already reported this message and it is pending review.").ConfigureAwait(false);
+            return;
+        }
+
+        var oneHourAgo = DateTime.UtcNow - TimeSpan.FromHours(1);
+        var reportRateLimited = await DbContext.ReportedChatMessages
+            .AsNoTracking()
+            .AnyAsync(r => r.ReporterUserUid == UserUID && r.ReportTimeUtc >= oneHourAgo, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (reportRateLimited)
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You can file at most one chat report per hour.").ConfigureAwait(false);
+            return;
+        }
+
+        /* if (!string.IsNullOrEmpty(messageEntry.SenderUserUid))
+        {
+            var targetAlreadyPending = await DbContext.ReportedChatMessages
+                .AsNoTracking()
+                .AnyAsync(r => r.ReportedUserUid == messageEntry.SenderUserUid && !r.Resolved, cancellationToken: RequestAbortedToken)
+                .ConfigureAwait(false);
+
+            if (targetAlreadyPending)
+            {
+                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
+            .Select(e => new ChatReportSnapshotItem(
+                e.MessageId,
+                e.SentAtUtc,
+                e.SenderUserUid,
+                e.SenderUser?.AliasOrUID,
+                e.SenderIsLightfinder,
+                e.SenderHashedCid,
+                e.Message))
+            .ToArray();
+
+        var snapshotJson = JsonSerializer.Serialize(snapshotItems, ChatReportSnapshotSerializerOptions);
+
+        var report = new ReportedChatMessage
+        {
+            ReportTimeUtc = DateTime.UtcNow,
+            ReporterUserUid = UserUID,
+            ReportedUserUid = messageEntry.SenderUserUid,
+            ChannelType = messageEntry.Channel.Type,
+            WorldId = messageEntry.Channel.WorldId,
+            ZoneId = messageEntry.Channel.ZoneId,
+            ChannelKey = messageEntry.Channel.CustomKey ?? string.Empty,
+            MessageId = messageEntry.MessageId,
+            MessageSentAtUtc = messageEntry.SentAtUtc,
+            MessageContent = messageEntry.Message,
+            SenderHashedCid = messageEntry.SenderHashedCid,
+            SenderDisplayName = messageEntry.SenderUser?.AliasOrUID,
+            SenderWasLightfinder = messageEntry.SenderIsLightfinder,
+            SnapshotJson = snapshotJson,
+            Reason = reason,
+            AdditionalContext = additionalContext
+        };
+
+        DbContext.ReportedChatMessages.Add(report);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        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
+            ? ChatSenderKind.IdentifiedUser
+            : ChatSenderKind.Anonymous;
+
+        string? displayName;
+        if (kind == ChatSenderKind.IdentifiedUser)
+        {
+            displayName = participant.User?.Alias ?? participant.User?.UID ?? participant.UserUid;
+        }
+        else if (includeSensitiveInfo && participant.IsLightfinder && !string.IsNullOrEmpty(participant.HashedCid))
+        {
+            displayName = participant.HashedCid;
+        }
+        else
+        {
+            var source = participant.UserUid ?? string.Empty;
+            var suffix = source.Length >= 4 ? source[^4..] : source;
+            displayName = string.IsNullOrEmpty(suffix) ? "Anonymous" : $"Anon-{suffix}";
+        }
+
+        var hashedCid = includeSensitiveInfo && participant.IsLightfinder
+            ? participant.HashedCid
+            : null;
+
+        var canResolveProfile = includeSensitiveInfo && (kind == ChatSenderKind.IdentifiedUser || participant.IsLightfinder);
+
+        return new ChatSenderDescriptor(
+            kind,
+            participant.Token,
+            displayName,
+            hashedCid,
+            descriptor.Type == ChatChannelType.Group ? participant.User : null,
+            canResolveProfile);
+    }
+
+    private async Task<bool> ViewerAllowsLightfinderDetailsAsync(ChatChannelDescriptor descriptor)
+    {
+        if (descriptor.Type == ChatChannelType.Group)
+        {
+            return true;
+        }
+
+        var viewerCid = UserCharaIdent;
+        if (!IsValidHashedCid(viewerCid))
+        {
+            return false;
+        }
+
+        var (entry, expiry) = await TryGetBroadcastEntryAsync(viewerCid).ConfigureAwait(false);
+        return HasActiveBroadcast(entry, expiry);
+    }
+
+    private async Task<bool> AllowsLightfinderDetailsAsync(ChatChannelDescriptor descriptor, string userUid)
+    {
+        if (descriptor.Type == ChatChannelType.Group)
+        {
+            return true;
+        }
+
+        if (_chatChannelService.TryGetPresence(userUid, descriptor, out var presence))
+        {
+            if (!presence.Participant.IsLightfinder || !IsValidHashedCid(presence.Participant.HashedCid))
+            {
+                return false;
+            }
+
+            var (entry, expiry) = await TryGetBroadcastEntryAsync(presence.Participant.HashedCid!).ConfigureAwait(false);
+            if (!IsActiveBroadcastForUser(entry, expiry, userUid))
+            {
+                TryInvokeChatService(
+                    () => _chatChannelService.RefreshLightfinderState(userUid, null, isLightfinder: false),
+                    "refreshing lightfinder state",
+                    descriptor,
+                    userUid);
+                return false;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    private async Task<bool> HandleIfChatBannedAsync(string userUid)
+    {
+        var isBanned = await DbContext.Users
+            .AsNoTracking()
+            .AnyAsync(u => u.UID == userUid && u.ChatBanned, RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (!isBanned)
+            return false;
+
+        TryInvokeChatService(() => _chatChannelService.RemovePresence(userUid), "clearing presence for chat-banned user", targetUserUid: userUid);
+        await NotifyChatBanAsync(userUid).ConfigureAwait(false);
+        return true;
+    }
+
+    private async Task NotifyChatBanAsync(string userUid)
+    {
+        if (string.Equals(userUid, UserUID, StringComparison.Ordinal))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your chat access has been revoked.").ConfigureAwait(false);
+        }
+        else if (_userConnections.TryGetValue(userUid, out var connectionId))
+        {
+            await Clients.Client(connectionId).Client_ReceiveServerMessage(MessageSeverity.Error, "Your chat access has been revoked.").ConfigureAwait(false);
+        }
+    }
+
+    private static bool UseChatRateLimit(string userUid)
+    {
+        var state = ChatRateLimiters.GetOrAdd(userUid, _ => new ChatRateLimitState());
+        lock (state.SyncRoot)
+        {
+            var now = DateTime.UtcNow;
+            while (state.Events.Count > 0 && now - state.Events.Peek() >= ChatRateLimitWindow)
+            {
+                state.Events.Dequeue();
+            }
+
+            if (state.Events.Count >= ChatRateLimitMessages)
+            {
+                return false;
+            }
+
+            state.Events.Enqueue(now);
+            return true;
+        }
+    }
+}

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.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.Dto.CharaData;
 using LightlessSync.API.Dto.Group;
 using LightlessSync.API.Dto.User;
@@ -38,5 +39,6 @@ namespace LightlessSyncServer.Hubs
         public Task Client_GposeLobbyPushCharacterData(CharaDataDownloadDto charaDownloadDto) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
         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");
     }
 }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs

@@ -1,12 +1,14 @@
-using LightlessSyncShared.Models;
-using Microsoft.EntityFrameworkCore;
-using LightlessSyncServer.Utils;
-using LightlessSyncShared.Utils;
 using LightlessSync.API.Data;
 using LightlessSync.API.Dto.Group;
+using LightlessSyncServer.Models;
+using LightlessSyncServer.Utils;
 using LightlessSyncShared.Metrics;
+using LightlessSyncShared.Models;
+using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.SignalR;
-using System.Threading;
+using Microsoft.EntityFrameworkCore;
+using StackExchange.Redis;
+using System.Text.Json;
 
 namespace LightlessSyncServer.Hubs;
 
@@ -18,6 +20,8 @@ public partial class LightlessHub
 
     public string Continent => Context.User?.Claims?.SingleOrDefault(c => string.Equals(c.Type, LightlessClaimTypes.Continent, StringComparison.Ordinal))?.Value ?? "UNK";
 
+    public string Country => Context.User?.Claims?.SingleOrDefault(c => string.Equals(c.Type, LightlessClaimTypes.Country, StringComparison.Ordinal))?.Value ?? "UNK";
+
     private async Task DeleteUser(User user)
     {
         var ownPairData = await DbContext.ClientPairs.Where(u => u.User.UID == user.UID).ToListAsync().ConfigureAwait(false);
@@ -95,13 +99,18 @@ public partial class LightlessHub
 
     private async Task RemoveUserFromRedis()
     {
+        if (IsValidHashedCid(UserCharaIdent))
+        {
+            await _redis.RemoveAsync("CID:" + UserCharaIdent, StackExchange.Redis.CommandFlags.FireAndForget).ConfigureAwait(false);
+        }
+
         await _redis.RemoveAsync("UID:" + UserUID, StackExchange.Redis.CommandFlags.FireAndForget).ConfigureAwait(false);
     }
 
     private async Task<User?> EnsureUserHasVanity(string uid, CancellationToken cancellationToken = default)
     {
         cancellationToken = cancellationToken == default && _contextAccessor.HttpContext != null
-            ? _contextAccessor.HttpContext.RequestAborted
+            ? RequestAbortedToken
             : cancellationToken;
 
         var user = await DbContext.Users.SingleOrDefaultAsync(u => u.UID == uid, cancellationToken).ConfigureAwait(false);
@@ -120,6 +129,47 @@ public partial class LightlessHub
         return user;
     }
 
+    private async Task ClearOwnedBroadcastLock()
+    {
+        var db = _redis.Database;
+        var ownershipKey = _broadcastConfiguration.BuildUserOwnershipKey(UserUID);
+        var ownedCidValue = await db.StringGetAsync(ownershipKey).ConfigureAwait(false);
+        if (ownedCidValue.IsNullOrEmpty)
+            return;
+
+        var ownedCid = ownedCidValue.ToString();
+
+        await db.KeyDeleteAsync(ownershipKey, CommandFlags.FireAndForget).ConfigureAwait(false);
+
+        if (string.IsNullOrEmpty(ownedCid))
+            return;
+
+        var broadcastKey = _broadcastConfiguration.BuildRedisKey(ownedCid);
+        var broadcastValue = await db.StringGetAsync(broadcastKey).ConfigureAwait(false);
+        if (broadcastValue.IsNullOrEmpty)
+            return;
+
+        BroadcastRedisEntry? entry;
+        try
+        {
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.ToString()!);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("failed to deserialize broadcast during disconnect cleanup", "CID", ownedCid, "Value", broadcastValue, "Error", ex));
+            return;
+        }
+
+        if (entry is null)
+            return;
+
+        if (entry.HasOwner() && !entry.OwnedBy(UserUID))
+            return;
+
+        await db.KeyDeleteAsync(broadcastKey, CommandFlags.FireAndForget).ConfigureAwait(false);
+        _logger.LogCallInfo(LightlessHubLogger.Args("broadcast cleaned on disconnect", UserUID, "CID", entry.HashedCID, "GID", entry.GID));
+    }
+
     private async Task SendGroupDeletedToAll(List<GroupPair> groupUsers)
     {
         foreach (var pair in groupUsers)
@@ -161,7 +211,8 @@ public partial class LightlessHub
 
         if (isOwnerResult.ReferredGroup == null) return (false, null);
 
-        var groupPairSelf = await DbContext.GroupPairs.SingleOrDefaultAsync(g => g.GroupGID == gid && g.GroupUserUID == UserUID).ConfigureAwait(false);
+        var groupPairSelf = await DbContext.GroupPairs.SingleOrDefaultAsync(
+            g => (g.GroupGID == gid || g.Group.Alias == gid) && g.GroupUserUID == UserUID).ConfigureAwait(false);
         if (groupPairSelf == null || !groupPairSelf.IsModerator) return (false, null);
 
         return (true, isOwnerResult.ReferredGroup);
@@ -169,7 +220,7 @@ public partial class LightlessHub
 
     private async Task<(bool isValid, Group ReferredGroup)> TryValidateOwner(string gid)
     {
-        var group = await DbContext.Groups.SingleOrDefaultAsync(g => g.GID == gid).ConfigureAwait(false);
+        var group = await DbContext.Groups.SingleOrDefaultAsync(g => g.GID == gid || g.Alias == gid).ConfigureAwait(false);
         if (group == null) return (false, null);
 
         return (string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal), group);
@@ -188,7 +239,13 @@ public partial class LightlessHub
 
     private async Task UpdateUserOnRedis()
     {
-        await _redis.AddAsync("UID:" + UserUID, UserCharaIdent, TimeSpan.FromSeconds(60), StackExchange.Redis.When.Always, StackExchange.Redis.CommandFlags.FireAndForget).ConfigureAwait(false);
+        var hashedCid = UserCharaIdent;
+        if (IsValidHashedCid(hashedCid))
+        {
+            await _redis.AddAsync("CID:" + hashedCid, UserUID, TimeSpan.FromSeconds(60), StackExchange.Redis.When.Always, StackExchange.Redis.CommandFlags.FireAndForget).ConfigureAwait(false);
+        }
+
+        await _redis.AddAsync("UID:" + UserUID, hashedCid, TimeSpan.FromSeconds(60), StackExchange.Redis.When.Always, StackExchange.Redis.CommandFlags.FireAndForget).ConfigureAwait(false);
     }
 
     private async Task UserGroupLeave(GroupPair groupUserPair, string userIdent, Dictionary<string, UserInfo> allUserPairs, string? uid = null)

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs

@@ -1,14 +1,19 @@
 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;
+using LightlessSyncServer.Services;
 using LightlessSyncServer.Utils;
 using LightlessSyncShared.Models;
 using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
+using SixLabors.ImageSharp;
+using System.Collections.Concurrent;
 using System.Security.Cryptography;
 
 namespace LightlessSyncServer.Hubs;
@@ -46,6 +51,8 @@ public partial class LightlessHub
         _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)
     {
@@ -54,15 +61,73 @@ public partial class LightlessHub
         var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
         if (!hasRights) return;
 
-        group.InvitesEnabled = !dto.Permissions.HasFlag(GroupPermissions.DisableInvites);
+        var permissions = dto.Permissions;
-        group.PreferDisableSounds = dto.Permissions.HasFlag(GroupPermissions.PreferDisableSounds);
+        var isOwner = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal);
-        group.PreferDisableAnimations = dto.Permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
+        var chatEnabled = group.ChatEnabled;
-        group.PreferDisableVFX = dto.Permissions.HasFlag(GroupPermissions.PreferDisableVFX);
+        var chatChanged = false;
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        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, dto.Permissions)).ConfigureAwait(false);
+        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, 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")]
@@ -137,7 +202,7 @@ public partial class LightlessHub
 
             var allUserPairs = await GetAllPairInfo(pair.GroupUserUID).ConfigureAwait(false);
 
-            var sharedData = await DbContext.CharaDataAllowances.Where(u => u.AllowedGroup != null && u.AllowedGroupGID == dto.GID && u.ParentUploaderUID == pair.GroupUserUID).ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            var sharedData = await DbContext.CharaDataAllowances.Where(u => u.AllowedGroup != null && u.AllowedGroupGID == dto.GID && u.ParentUploaderUID == pair.GroupUserUID).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
             DbContext.CharaDataAllowances.RemoveRange(sharedData);
 
             foreach (var groupUserPair in groupPairs.Where(p => !string.Equals(p.GroupUserUID, pair.GroupUserUID, StringComparison.Ordinal)))
@@ -181,7 +246,7 @@ public partial class LightlessHub
 
             var allUserPairs = await GetAllPairInfo(pair.GroupUserUID).ConfigureAwait(false);
 
-            var sharedData = await DbContext.CharaDataAllowances.Where(u => u.AllowedGroup != null && u.AllowedGroupGID == dto.GID && u.ParentUploaderUID == pair.GroupUserUID).ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            var sharedData = await DbContext.CharaDataAllowances.Where(u => u.AllowedGroup != null && u.AllowedGroupGID == dto.GID && u.ParentUploaderUID == pair.GroupUserUID).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
             DbContext.CharaDataAllowances.RemoveRange(sharedData);
 
@@ -199,15 +264,15 @@ public partial class LightlessHub
     public async Task<GroupJoinDto> GroupCreate()
     {
         _logger.LogCallInfo();
-        var existingGroupsByUser = await DbContext.Groups.CountAsync(u => u.OwnerUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var existingGroupsByUser = await DbContext.Groups.CountAsync(u => u.OwnerUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var existingJoinedGroups = await DbContext.GroupPairs.CountAsync(u => u.GroupUserUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var existingJoinedGroups = await DbContext.GroupPairs.CountAsync(u => u.GroupUserUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         if (existingGroupsByUser >= _maxExistingGroupsByUser || existingJoinedGroups >= _maxJoinedGroupsByUser)
         {
             throw new System.Exception($"Max groups for user is {_maxExistingGroupsByUser}, max joined groups is {_maxJoinedGroupsByUser}.");
         }
 
         var gid = StringUtils.GenerateRandomString(12);
-        while (await DbContext.Groups.AnyAsync(g => g.GID == "LLS-" + gid, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false))
+        while (await DbContext.Groups.AnyAsync(g => g.GID == "LLS-" + gid, cancellationToken: RequestAbortedToken).ConfigureAwait(false))
         {
             gid = StringUtils.GenerateRandomString(12);
         }
@@ -218,7 +283,7 @@ public partial class LightlessHub
         var hashedPw = StringUtils.Sha256String(passwd);
         var currentTime = DateTime.UtcNow;
 
-        UserDefaultPreferredPermission defaultPermissions = await DbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        UserDefaultPreferredPermission defaultPermissions = await DbContext.UserDefaultPreferredPermissions.SingleAsync(u => u.UserUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
         Group newGroup = new()
         {
@@ -229,6 +294,7 @@ public partial class LightlessHub
             PreferDisableAnimations = defaultPermissions.DisableGroupAnimations,
             PreferDisableSounds = defaultPermissions.DisableGroupSounds,
             PreferDisableVFX = defaultPermissions.DisableGroupVFX,
+            ChatEnabled = true,
             CreatedDate = currentTime,
         };
 
@@ -250,15 +316,15 @@ public partial class LightlessHub
             DisableVFX = defaultPermissions.DisableGroupAnimations,
         };
 
-        await DbContext.Groups.AddAsync(newGroup, _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.Groups.AddAsync(newGroup, RequestAbortedToken).ConfigureAwait(false);
-        await DbContext.GroupPairs.AddAsync(initialPair, _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.GroupPairs.AddAsync(initialPair, RequestAbortedToken).ConfigureAwait(false);
-        await DbContext.GroupPairPreferredPermissions.AddAsync(initialPrefPermissions, _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.GroupPairPreferredPermissions.AddAsync(initialPrefPermissions, RequestAbortedToken).ConfigureAwait(false);
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
-        var self = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        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)))
+            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
             .ConfigureAwait(false);
         
         _logger.LogCallInfo(LightlessHubLogger.Args(gid));
@@ -314,10 +380,10 @@ public partial class LightlessHub
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
 
-        var groupPairs = await DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var groupPairs = await DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         DbContext.RemoveRange(groupPairs);
         DbContext.Remove(group);
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         await Clients.Users(groupPairs.Select(g => g.GroupUserUID)).Client_GroupDelete(new GroupDto(group.ToGroupData())).ConfigureAwait(false);
 
@@ -332,7 +398,7 @@ public partial class LightlessHub
         var (userHasRights, group) = await TryValidateGroupModeratorOrOwner(dto.GID).ConfigureAwait(false);
         if (!userHasRights) return [];
 
-        var banEntries = await DbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        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 =>
             new BannedGroupUserDto(group.ToGroupData(), b.BannedUser.ToUserData(), b.BannedReason, b.BannedOn,
@@ -350,14 +416,14 @@ public partial class LightlessHub
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
-        var group = await DbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var group = await DbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         var groupGid = group?.GID ?? string.Empty;
-        var existingPair = await DbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var existingPair = await DbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         var hashedPw = StringUtils.Sha256String(dto.Password);
-        var existingUserCount = await DbContext.GroupPairs.AsNoTracking().CountAsync(g => g.GroupGID == groupGid, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var existingUserCount = await DbContext.GroupPairs.AsNoTracking().CountAsync(g => g.GroupGID == groupGid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var joinedGroups = await DbContext.GroupPairs.CountAsync(g => g.GroupUserUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var joinedGroups = await DbContext.GroupPairs.CountAsync(g => g.GroupUserUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var isBanned = await DbContext.GroupBans.AnyAsync(g => g.GroupGID == groupGid && g.BannedUserUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var isBanned = await DbContext.GroupBans.AnyAsync(g => g.GroupGID == groupGid && g.BannedUserUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var oneTimeInvite = await DbContext.GroupTempInvites.SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.Invite == hashedPw, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var oneTimeInvite = await DbContext.GroupTempInvites.SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.Invite == hashedPw, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
         if (group == null
             || (!string.Equals(group.HashedPassword, hashedPw, StringComparison.Ordinal) && oneTimeInvite == null)
@@ -378,7 +444,7 @@ public partial class LightlessHub
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
-        var group = await DbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var group = await DbContext.Groups.Include(g => g.Owner).AsNoTracking().SingleOrDefaultAsync(g => g.GID == aliasOrGid || g.Alias == aliasOrGid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         var groupGid = group?.GID ?? string.Empty;
         var existingPair = await DbContext.GroupPairs.AsNoTracking().SingleOrDefaultAsync(g => g.GroupGID == groupGid && g.GroupUserUID == UserUID).ConfigureAwait(false);
         var isHashedPassword = dto.Password.Length == 64 && dto.Password.All(Uri.IsHexDigit);
@@ -416,7 +482,7 @@ public partial class LightlessHub
             FromFinder = isHashedPassword
         };
 
-        var preferredPermissions = await DbContext.GroupPairPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.GroupGID == group.GID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var preferredPermissions = await DbContext.GroupPairPreferredPermissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.GroupGID == group.GID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         if (preferredPermissions == null)
         {
             GroupPairPreferredPermission newPerms = new()
@@ -441,16 +507,21 @@ public partial class LightlessHub
             DbContext.Update(preferredPermissions);
         }
 
-        await DbContext.GroupPairs.AddAsync(newPair, _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.GroupPairs.AddAsync(newPair, RequestAbortedToken).ConfigureAwait(false);
 
         _logger.LogCallInfo(LightlessHubLogger.Args(aliasOrGid, "Success"));
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        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);
 
-        var groupInfos = await DbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).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))).ConfigureAwait(false);
+            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal), totalUserCount)).ConfigureAwait(false);
 
         var self = DbContext.Users.Single(u => u.UID == UserUID);
 
@@ -575,7 +646,7 @@ public partial class LightlessHub
             }
         }
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         return true;
     }
@@ -672,30 +743,38 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, days, execute));
 
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+            .ConfigureAwait(false);
         if (!hasRights) return -1;
 
-        var allGroupUsers = await DbContext.GroupPairs.Include(p => p.GroupUser).Include(p => p.Group)
+        if (!execute)
-            .Where(g => g.GroupGID == dto.Group.GID)
-            .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);
-
-        if (!execute) return usersToPrune.Count();
-
-        DbContext.GroupPairs.RemoveRange(usersToPrune);
-
-        foreach (var pair in usersToPrune)
         {
-            await Clients.Users(allGroupUsers.Where(p => !usersToPrune.Contains(p)).Select(g => g.GroupUserUID))
+            var count = await _pruneService.CountPrunableUsersAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
-                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData())).ConfigureAwait(false);
+            return count;
         }
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var allGroupUsers = await DbContext.GroupPairs
+            .Include(p => p.GroupUser)
+            .Include(p => p.Group)
+            .Where(g => g.GroupGID == dto.Group.GID)
+            .ToListAsync(RequestAbortedToken).ConfigureAwait(false);
 
-        return usersToPrune.Count();
+        var prunedPairs = await _pruneService.ExecutePruneAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+
+        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 Clients.Users(remainingUserIds)
+                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData()))
+                .ConfigureAwait(false);
+        }
+
+        return prunedPairs.Count;
     }
 
     [Authorize(Policy = "Identified")]
@@ -717,15 +796,15 @@ public partial class LightlessHub
         var groupPairs = DbContext.GroupPairs.Where(p => p.GroupGID == group.GID).AsNoTracking().ToList();
         await Clients.Users(groupPairs.Select(p => p.GroupUserUID)).Client_GroupPairLeft(dto).ConfigureAwait(false);
 
-        var sharedData = await DbContext.CharaDataAllowances.Where(u => u.AllowedGroup != null && u.AllowedGroupGID == dto.GID && u.ParentUploaderUID == dto.UID).ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var sharedData = await DbContext.CharaDataAllowances.Where(u => u.AllowedGroup != null && u.AllowedGroupGID == dto.GID && u.ParentUploaderUID == dto.UID).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         DbContext.CharaDataAllowances.RemoveRange(sharedData);
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         var userIdent = await GetUserIdent(dto.User.UID).ConfigureAwait(false);
         if (userIdent == null)
         {
-            await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
             return;
         }
 
@@ -743,68 +822,125 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
-        var cancellationToken = _contextAccessor.HttpContext.RequestAborted;
+        var cancellationToken = RequestAbortedToken;
 
-        var data = await DbContext.GroupProfiles
+        if (dto?.Group == null)
-            .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID, cancellationToken)
-            .ConfigureAwait(false);
-
-        var profileDto = new GroupProfileDto(dto.Group, Description: null, Tags: null, PictureBase64: null);
-
-        if (data is not null)
         {
-            profileDto = profileDto with
+            _logger.LogCallWarning(LightlessHubLogger.Args("GroupGetProfile: dto.Group is null"));
-            {
+            return new GroupProfileDto(Group: null, Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: false, IsDisabled: false);
-                Description = data.Description,
-                Tags = data.Tags,
-                PictureBase64 = data.Base64GroupProfileImage,
-            };
-
-            await Clients.User(UserUID)
-                .Client_GroupSendProfile(profileDto)
-                .ConfigureAwait(false);
         }
 
-        return profileDto;
+        var data = await DbContext.GroupProfiles
+            .Include(gp => gp.Group) 
+            .FirstOrDefaultAsync(
+                g => g.Group.GID == dto.Group.GID || g.Group.Alias == dto.Group.AliasOrGID,
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+
+        if (data == null)
+        {
+            return new GroupProfileDto(dto.Group, Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: false, IsDisabled: false);
+        }
+
+        if (data.ProfileDisabled)
+        {
+            return new GroupProfileDto(Group: dto.Group, Description: "This profile was permanently disabled", Tags: [], PictureBase64: null, BannerBase64: null, IsNsfw: false, IsDisabled: true);
+        }
+
+        try
+        {
+            return data.ToDTO();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args(ex, "GroupGetProfile: failed to map GroupProfileDto for {Group}", dto.Group.GID ?? dto.Group.AliasOrGID));
+            return new GroupProfileDto(dto.Group, Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: false, IsDisabled: false);
+        }
     }
 
     [Authorize(Policy = "Identified")]
     public async Task GroupSetProfile(GroupProfileDto dto)
     {
-        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+            _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
-        if (dto.Group == null) return;
+            var cancellationToken = RequestAbortedToken;
 
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
+            if (dto.Group == null) return;
-        if (!hasRights) return;
 
-        var groupProfileDb = await DbContext.GroupProfiles
+            var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
-            .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID,
+            if (!hasRights) return;
-                                 _contextAccessor.HttpContext.RequestAborted)
-            .ConfigureAwait(false);
 
-        if (groupProfileDb != null)
+            var groupProfileDb = await DbContext.GroupProfiles
-        {
+                .Include(g => g.Group)
-            groupProfileDb.Description = dto.Description;
+                .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID, cancellationToken)
-            groupProfileDb.Tags = dto.Tags;
-            groupProfileDb.Base64GroupProfileImage = dto.PictureBase64;
-        }
-        else
-        {
-            var groupProfile = new GroupProfile
-            {
-                GroupGID = dto.Group.GID,
-                Description = dto.Description,
-                Tags = dto.Tags,
-                Base64GroupProfileImage = dto.PictureBase64,
-            };
-
-            await DbContext.GroupProfiles.AddAsync(groupProfile,
-                _contextAccessor.HttpContext.RequestAborted)
                 .ConfigureAwait(false);
-        }
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            ImageCheckService.ImageLoadResult profileResult = new();
+            ImageCheckService.ImageLoadResult bannerResult = new();
+
+            //Avatar image validation
+            if (!string.IsNullOrEmpty(dto.PictureBase64))
+            {
+                profileResult = await ImageCheckService.ValidateImageAsync(dto.PictureBase64, banner: false, RequestAbortedToken).ConfigureAwait(false);
+
+                if (!profileResult.Success)
+                {
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, profileResult.ErrorMessage).ConfigureAwait(false);
+                    return;
+                }
+            }
+
+            //Banner image validation
+            if (!string.IsNullOrEmpty(dto.BannerBase64))
+            {
+                bannerResult = await ImageCheckService.ValidateImageAsync(dto.BannerBase64, banner: true, RequestAbortedToken).ConfigureAwait(false);
+
+                if (!bannerResult.Success)
+                {
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, bannerResult.ErrorMessage).ConfigureAwait(false);
+                    return;
+                }
+            }
+
+            var sanitizedProfileImage = profileResult?.Base64Image;
+            var sanitizedBannerImage = bannerResult?.Base64Image;
+
+            if (groupProfileDb == null)
+            {
+                groupProfileDb = new GroupProfile
+                {
+                    GroupGID = dto.Group.GID,
+                    Group = group,
+                    ProfileDisabled = dto.IsDisabled ?? false,
+                    IsNSFW = dto.IsNsfw ?? false,
+                    
+                };
+
+                groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
+                await DbContext.GroupProfiles.AddAsync(groupProfileDb, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                groupProfileDb.Group ??= group;
+
+                groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
+            }
+
+            var userIds = await DbContext.GroupPairs
+                .Where(p => p.GroupGID == groupProfileDb.GroupGID)
+                .Select(p => p.GroupUserUID)
+                .ToListAsync(cancellationToken)
+                .ConfigureAwait(false);
+
+            if (userIds.Count > 0)
+            {
+                var profileDto = groupProfileDb.ToDTO();
+                await Clients.Users(userIds).Client_GroupSendProfile(profileDto)
+                    .ConfigureAwait(false);
+            }
+
+            await DbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
     }
 
     [Authorize(Policy = "Identified")]
@@ -836,18 +972,56 @@ public partial class LightlessHub
             userPair.IsModerator = false;
         }
 
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
-        var groupPairs = await DbContext.GroupPairs.AsNoTracking().Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToListAsync(cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var groupPairs = await DbContext.GroupPairs.AsNoTracking().Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         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()
     {
         _logger.LogCallInfo();
 
-        var ct = _contextAccessor.HttpContext.RequestAborted;
+        var ct = RequestAbortedToken;
 
         var result = await (
             from gp in DbContext.GroupPairs
@@ -864,29 +1038,31 @@ 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(ct)
+            .ToListAsync()
             .ConfigureAwait(false);
 
         _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));
 
-            _logger.LogCallInfo(LightlessHubLogger.Args(r));
+        return new GroupFullInfoDto(
-
+            r.GroupPair.Group.ToGroupData(),
-            return new GroupFullInfoDto(
+            r.GroupPair.Group.Owner.ToUserData(),
-                r.GroupPair.Group.ToGroupData(),
+            r.GroupPair.Group.ToEnum(),
-                r.GroupPair.Group.Owner.ToUserData(),
+            r.PreferredPermission.ToEnum(),
-                r.GroupPair.Group.ToEnum(),
+            r.GroupPair.ToEnum(),
-                r.PreferredPermission.ToEnum(),
+            groupInfoDict,
-                r.GroupPair.ToEnum(),
+            r.UserCount
-                groupInfoDict
+        );
-            );
         }),];
         return List;
     }
@@ -899,11 +1075,11 @@ public partial class LightlessHub
         var (userHasRights, _) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
         if (!userHasRights) return;
 
-        var banEntry = await DbContext.GroupBans.SingleOrDefaultAsync(g => g.GroupGID == dto.Group.GID && g.BannedUserUID == dto.User.UID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var banEntry = await DbContext.GroupBans.SingleOrDefaultAsync(g => g.GroupGID == dto.Group.GID && g.BannedUserUID == dto.User.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         if (banEntry == null) return;
 
         DbContext.Remove(banEntry);
-        await DbContext.SaveChangesAsync(_contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
     }
@@ -990,6 +1166,4 @@ public partial class LightlessHub
 
         return results;
     }
-
-
 }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs

@@ -1,10 +1,11 @@
-using LightlessSync.API.Data;
+using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
 using LightlessSync.API.Dto.Group;
 using LightlessSync.API.Dto.User;
+using LightlessSyncServer.Models;
+using LightlessSyncServer.Services;
 using LightlessSyncServer.Utils;
-using LightlessSyncServer.Configuration;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.Models;
 using LightlessSyncShared.Utils;
@@ -14,7 +15,6 @@ using Microsoft.EntityFrameworkCore;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
 using StackExchange.Redis;
-using System.Linq;
 using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
@@ -35,7 +35,7 @@ public partial class LightlessHub
         if (string.Equals(dto.User.UID, UserUID, StringComparison.Ordinal) || string.IsNullOrWhiteSpace(dto.User.UID)) return;
 
         // grab other user, check if it exists and if a pair already exists
-        var otherUser = await DbContext.Users.SingleOrDefaultAsync(u => u.UID == uid || u.Alias == uid, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var otherUser = await DbContext.Users.SingleOrDefaultAsync(u => u.UID == uid || u.Alias == uid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         if (otherUser == null)
         {
             await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, $"Cannot pair with {dto.User.UID}, UID does not exist").ConfigureAwait(false);
@@ -51,7 +51,7 @@ public partial class LightlessHub
         var existingEntry =
             await DbContext.ClientPairs.AsNoTracking()
                 .FirstOrDefaultAsync(p =>
-                    p.User.UID == UserUID && p.OtherUserUID == otherUser.UID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+                    p.User.UID == UserUID && p.OtherUserUID == otherUser.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
         if (existingEntry != null)
         {
@@ -76,7 +76,7 @@ public partial class LightlessHub
         var permissions = existingData?.OwnPermissions;
         if (permissions == null || !permissions.Sticky)
         {
-            var ownDefaultPermissions = await DbContext.UserDefaultPreferredPermissions.AsNoTracking().SingleOrDefaultAsync(f => f.UserUID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            var ownDefaultPermissions = await DbContext.UserDefaultPreferredPermissions.AsNoTracking().SingleOrDefaultAsync(f => f.UserUID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
             permissions = new UserPermissionSet()
             {
@@ -89,7 +89,7 @@ public partial class LightlessHub
                 Sticky = true
             };
 
-            var existingDbPerms = await DbContext.Permissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.OtherUserUID == otherUser.UID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            var existingDbPerms = await DbContext.Permissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.OtherUserUID == otherUser.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
             if (existingDbPerms == null)
             {
                 await DbContext.Permissions.AddAsync(permissions).ConfigureAwait(false);
@@ -143,17 +143,15 @@ public partial class LightlessHub
     }
 
     [Authorize(Policy = "Identified")]
-    public async Task TryPairWithContentId(string otherCid, string myCid)
+    public async Task TryPairWithContentId(string otherCid)
     {
+        var myCid = UserCharaIdent;
+
         if (string.IsNullOrWhiteSpace(otherCid) || string.IsNullOrWhiteSpace(myCid))
             return;
 
-        bool IsValidCid(string cid) => cid.Length == 64 && cid.All(Uri.IsHexDigit) && !cid.All(c => c == '0');
+        if (!IsValidHashedCid(myCid) || !IsValidHashedCid(otherCid))
-
-        if (!IsValidCid(myCid) || !IsValidCid(otherCid))
-        {
             return;
-        }
 
         if (string.Equals(otherCid, myCid, StringComparison.Ordinal))
         {
@@ -181,14 +179,35 @@ public partial class LightlessHub
             try
             {
                 var payload = JsonSerializer.Deserialize<PairingPayload>(json);
-                if (payload?.UID == null)
+                if (payload?.UID == null || string.IsNullOrWhiteSpace(payload.HashedCid))
                 {
                     _logger.LogCallWarning(LightlessHubLogger.Args("invalid payload", reverseKey));
                     return;
                 }
 
-                var sender = await _pairService.TryAddPairAsync(UserUID, payload.UID);
+                if (!IsValidHashedCid(payload.HashedCid) || !string.Equals(payload.HashedCid, otherCid, StringComparison.Ordinal))
-                var receiver = await _pairService.TryAddPairAsync(payload.UID, UserUID);
+                {
+                    _logger.LogCallWarning(LightlessHubLogger.Args("pairing cid mismatch", reverseKey, payload.HashedCid, otherCid));
+                    return;
+                }
+
+                var expectedRequesterUid = await _redis.GetAsync<string>("CID:" + payload.HashedCid).ConfigureAwait(false);
+                if (!string.Equals(expectedRequesterUid, payload.UID, StringComparison.Ordinal))
+                {
+                    _logger.LogCallWarning(LightlessHubLogger.Args("pairing uid mismatch", reverseKey, payload.HashedCid, payload.UID, expectedRequesterUid ?? "null"));
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "Pair request could not be validated.").ConfigureAwait(false);
+                    return;
+                }
+
+                if (payload.Timestamp == default || DateTime.UtcNow - payload.Timestamp > TimeSpan.FromMinutes(5))
+                {
+                    _logger.LogCallWarning(LightlessHubLogger.Args("stale pairing payload", reverseKey, payload.Timestamp));
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "Pair request expired.").ConfigureAwait(false);
+                    return;
+                }
+
+                var sender = await _pairService.TryAddPairAsync(UserUID, payload.UID).ConfigureAwait(false);
+                var receiver = await _pairService.TryAddPairAsync(payload.UID, UserUID).ConfigureAwait(false);
 
                 var user = await DbContext.Users.SingleAsync(u => u.UID == UserUID).ConfigureAwait(false);
                 var otherUser = await DbContext.Users.SingleAsync(u => u.UID == payload.UID).ConfigureAwait(false);
@@ -251,9 +270,30 @@ public partial class LightlessHub
         }
         else
         {
+            int maxRequests = _broadcastConfiguration.PairRequestRateLimit;
+            int requestWindow = _broadcastConfiguration.PairRequestRateWindow;
+            TimeSpan window = TimeSpan.FromSeconds(requestWindow);
+            var rateKey = $"pairing:limit:{UserUID}";
+            var db = _redis.Database;
+
+            var count = (long)await db.StringIncrementAsync(rateKey).ConfigureAwait(false);
+            if (count == 1)
+            {
+                await db.KeyExpireAsync(rateKey, window).ConfigureAwait(false);
+            }
+
+            if (count > maxRequests)
+            {
+                var ttl = await db.KeyTimeToLiveAsync(rateKey).ConfigureAwait(false);
+                var secondsLeft = ttl?.TotalSeconds > 0 ? (int)ttl.Value.TotalSeconds : requestWindow;
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, $"You have exceeded the pair request limit. Please wait {secondsLeft} seconds before trying again.").ConfigureAwait(false);
+                return;
+            }
+
             var payload = new PairingPayload
             {
                 UID = UserUID,
+                HashedCid = myCid,
                 Timestamp = DateTime.UtcNow
             };
 
@@ -262,14 +302,15 @@ public partial class LightlessHub
             await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, $"Pair request sent. Waiting for the other player to confirm.").ConfigureAwait(false);
 
             _logger.LogCallInfo(LightlessHubLogger.Args("stored pairing request", myCid, otherCid));
-            await NotifyBroadcastOwnerOfPairRequest(myCid, otherCid).ConfigureAwait(false);
+            await NotifyBroadcastOwnerOfPairRequest(otherCid).ConfigureAwait(false);
         }
     }
 
-
+    private async Task NotifyBroadcastOwnerOfPairRequest(string targetHashedCid)
-    private async Task NotifyBroadcastOwnerOfPairRequest(string myHashedCid, string targetHashedCid)
     {
-        if (string.IsNullOrWhiteSpace(targetHashedCid) || string.IsNullOrWhiteSpace(myHashedCid))
+        var myHashedCid = UserCharaIdent;
+
+        if (!IsValidHashedCid(targetHashedCid) || !IsValidHashedCid(myHashedCid))
             return;
 
         if (!_broadcastConfiguration.EnableBroadcasting || !_broadcastConfiguration.NotifyOwnerOnPairRequest)
@@ -295,7 +336,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.Value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.Value.ToString()!);
         }
         catch (Exception ex)
         {
@@ -320,26 +361,12 @@ public partial class LightlessHub
 
         await Clients.User(entry.OwnerUID).Client_ReceiveBroadcastPairRequest(dto).ConfigureAwait(false);
     }
-    private class PairingPayload
-    {
-        public string UID { get; set; } = string.Empty;
-        public DateTime Timestamp { get; set; }
-    }
-
-    public class BroadcastRedisEntry
-    {
-        public string HashedCID { get; set; } = string.Empty;
-        public string OwnerUID { get; set; } = string.Empty;
-        public string? GID { get; set; }
-
-        public bool OwnedBy(string userUid) => !string.IsNullOrEmpty(userUid) && string.Equals(OwnerUID, userUid, StringComparison.Ordinal);
-
-        public bool HasOwner() => !string.IsNullOrEmpty(OwnerUID);
-    }
 
     [Authorize(Policy = "Identified")]
-    public async Task SetBroadcastStatus(string hashedCid, bool enabled, GroupBroadcastRequestDto? groupDto = null)
+    public async Task SetBroadcastStatus(bool enabled, GroupBroadcastRequestDto? groupDto = null)
     {
+        var hashedCid = UserCharaIdent;
+
         if (enabled && !_broadcastConfiguration.EnableBroadcasting)
         {
             _logger.LogCallWarning(LightlessHubLogger.Args("broadcast disabled", UserUID, "CID", hashedCid));
@@ -347,9 +374,9 @@ public partial class LightlessHub
             return;
         }
 
-        if (string.IsNullOrWhiteSpace(hashedCid) || hashedCid.Length != 64 || !hashedCid.All(c => Uri.IsHexDigit(c)))
+        if (!IsValidHashedCid(hashedCid))
         {
-            _logger.LogCallWarning(LightlessHubLogger.Args("invalid cid format", UserUID, "CID", hashedCid));
+            _logger.LogCallWarning(LightlessHubLogger.Args("invalid cid format for user ident", UserUID, "CID", hashedCid));
             await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Invalid CID format.").ConfigureAwait(false);
             return;
         }
@@ -361,11 +388,32 @@ public partial class LightlessHub
 
         var db = _redis.Database;
         var broadcastKey = _broadcastConfiguration.BuildRedisKey(hashedCid);
+        var ownershipKey = _broadcastConfiguration.BuildUserOwnershipKey(UserUID);
+        var ownedCidValue = await db.StringGetAsync(ownershipKey).ConfigureAwait(false);
+        var ownedCid = ownedCidValue.IsNullOrEmpty ? null : ownedCidValue.ToString();
 
         if (enabled)
         {
             string? gid = null;
 
+            if (!string.IsNullOrEmpty(ownedCid) && !string.Equals(ownedCid, hashedCid, StringComparison.Ordinal))
+            {
+                var ownedBroadcastKey = _broadcastConfiguration.BuildRedisKey(ownedCid);
+                var ownedBroadcastValue = await db.StringGetAsync(ownedBroadcastKey).ConfigureAwait(false);
+
+                if (ownedBroadcastValue.IsNullOrEmpty)
+                {
+                    await db.KeyDeleteAsync(ownershipKey, CommandFlags.FireAndForget).ConfigureAwait(false);
+                    ownedCid = null;
+                }
+                else
+                {
+                    _logger.LogCallWarning(LightlessHubLogger.Args("multiple broadcast lock attempt", UserUID, "ExistingCID", ownedCid, "AttemptedCID", hashedCid));
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You already have an active Lightfinder lock. Disable it before enabling another.").ConfigureAwait(false);
+                    return;
+                }
+            }
+
             if (groupDto is not null)
             {
                 if (!_broadcastConfiguration.EnableSyncshellBroadcastPayloads)
@@ -390,7 +438,7 @@ public partial class LightlessHub
             {
                 try
                 {
-                    existingEntry = JsonSerializer.Deserialize<BroadcastRedisEntry>(existingValue!);
+                    existingEntry = JsonSerializer.Deserialize<BroadcastRedisEntry>(existingValue.ToString()!);
                 }
                 catch (Exception ex)
                 {
@@ -400,7 +448,7 @@ public partial class LightlessHub
                 if (existingEntry is not null && existingEntry.HasOwner() && !existingEntry.OwnedBy(UserUID))
                 {
                     _logger.LogCallWarning(LightlessHubLogger.Args("unauthorized attempt to take broadcast ownership", UserUID, "CID", hashedCid, "ExistingOwner", existingEntry.OwnerUID));
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Another user is already broadcasting with that CID.");
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Another user is already broadcasting with that CID.").ConfigureAwait(false);
                     return;
                 }
             }
@@ -414,7 +462,11 @@ public partial class LightlessHub
 
             var json = JsonSerializer.Serialize(entry);
             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),
+                "refreshing lightfinder state (enable)");
         }
         else
         {
@@ -425,7 +477,7 @@ public partial class LightlessHub
             BroadcastRedisEntry? entry;
             try
             {
-                entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value!);
+                entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.ToString()!);
             }
             catch (Exception ex)
             {
@@ -436,22 +488,84 @@ public partial class LightlessHub
             if (entry is null || !string.Equals(entry.HashedCID, hashedCid, StringComparison.Ordinal))
             {
                 _logger.LogCallWarning(LightlessHubLogger.Args("unauthorized attempt to remove broadcast", UserUID, "CID", hashedCid, "Stored", entry?.HashedCID));
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You can only disable your own broadcast. :3");
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You can only disable your own broadcast. :3").ConfigureAwait(false);
                 return;
             }
 
             if (entry.HasOwner() && !entry.OwnedBy(UserUID))
             {
                 _logger.LogCallWarning(LightlessHubLogger.Args("unauthorized attempt to remove broadcast", UserUID, "CID", hashedCid, "Owner", entry.OwnerUID));
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You can only disable your own broadcast. :3");
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You can only disable your own broadcast. :3").ConfigureAwait(false);
                 return;
             }
 
             await db.KeyDeleteAsync(broadcastKey).ConfigureAwait(false);
+
+            if (!string.IsNullOrEmpty(ownedCid) && string.Equals(ownedCid, hashedCid, StringComparison.Ordinal))
+            {
+                await db.KeyDeleteAsync(ownershipKey).ConfigureAwait(false);
+            }
+
             _logger.LogCallInfo(LightlessHubLogger.Args("broadcast disabled", hashedCid, "GID", entry.GID));
+            TryInvokeChatService(
+                () => _chatChannelService.RefreshLightfinderState(UserUID, null, isLightfinder: false),
+                "refreshing lightfinder state (disable)");
         }
     }
 
+    private async Task<(BroadcastRedisEntry? Entry, TimeSpan? Expiry)> TryGetBroadcastEntryAsync(string hashedCid)
+    {
+        var key = _broadcastConfiguration.BuildRedisKey(hashedCid);
+        RedisValueWithExpiry value;
+
+        try
+        {
+            value = await _redis.Database.StringGetWithExpiryAsync(key).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LightfinderProfileLookupFailed", "CID", hashedCid, "Error", ex));
+            return (null, null);
+        }
+
+        if (value.Value.IsNullOrEmpty || value.Expiry is null || value.Expiry <= TimeSpan.Zero)
+        {
+            return (null, value.Expiry);
+        }
+
+        BroadcastRedisEntry? entry;
+        try
+        {
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.Value.ToString()!);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LightfinderProfileDeserializeFailed", "CID", hashedCid, "Raw", value.Value.ToString(), "Error", ex));
+            return (null, value.Expiry);
+        }
+
+        if (entry is null || !string.Equals(entry.HashedCID, hashedCid, StringComparison.Ordinal))
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LightfinderProfileEntryMismatch", "CID", hashedCid, "EntryCID", entry?.HashedCID ?? "null"));
+            return (null, value.Expiry);
+        }
+
+        return (entry, value.Expiry);
+    }
+
+    private static bool HasActiveBroadcast(BroadcastRedisEntry? entry, TimeSpan? expiry) =>
+        entry?.HasOwner() == true && expiry.HasValue && expiry.Value > TimeSpan.Zero;
+
+    private static bool IsActiveBroadcastForUser(BroadcastRedisEntry? entry, TimeSpan? expiry, string userUid) =>
+        HasActiveBroadcast(entry, expiry) && entry!.OwnedBy(userUid);
+
+    private static bool IsValidHashedCid(string? cid)
+    {
+        if (string.IsNullOrWhiteSpace(cid))
+            return false;
+
+        return cid.Length == 64 && cid.All(Uri.IsHexDigit) && !cid.All(c => c == '0');
+    }
 
     [Authorize(Policy = "Identified")]
     public async Task<BroadcastStatusInfoDto?> IsUserBroadcasting(string hashedCid)
@@ -459,18 +573,13 @@ public partial class LightlessHub
         if (!_broadcastConfiguration.EnableBroadcasting)
             return null;
 
-        if (string.IsNullOrWhiteSpace(hashedCid) || hashedCid.Length != 64 || !hashedCid.All(c => Uri.IsHexDigit(c)))
+        if (!IsValidHashedCid(hashedCid))
         {
             _logger.LogCallWarning(LightlessHubLogger.Args("invalid cid format", UserUID, "CID", hashedCid));
             await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Invalid CID format.").ConfigureAwait(false);
             return null;
         }
 
-        if (hashedCid.All(c => c == '0'))
-        {
-            return null;
-        }
-
         var db = _redis.Database;
         var key = _broadcastConfiguration.BuildRedisKey(hashedCid);
 
@@ -481,7 +590,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(result.Value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(result.Value.ToString()!);
         }
         catch
         {
@@ -507,14 +616,16 @@ public partial class LightlessHub
     }
 
     [Authorize(Policy = "Identified")]
-    public async Task<TimeSpan?> GetBroadcastTtl(string hashedCid)
+    public async Task<TimeSpan?> GetBroadcastTtl()
     {
         if (!_broadcastConfiguration.EnableBroadcasting)
             return null;
 
-        if (string.IsNullOrWhiteSpace(hashedCid) || hashedCid.Length != 64 || !hashedCid.All(c => Uri.IsHexDigit(c)))
+        var hashedCid = UserCharaIdent;
+
+        if (!IsValidHashedCid(hashedCid))
         {
-            _logger.LogCallWarning(LightlessHubLogger.Args("invalid cid format", UserUID, "CID", hashedCid));
+            _logger.LogCallWarning(LightlessHubLogger.Args("invalid cid format for user ident", UserUID, "CID", hashedCid));
             await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Invalid CID format.").ConfigureAwait(false);
             return null;
         }
@@ -534,7 +645,7 @@ public partial class LightlessHub
         BroadcastRedisEntry? entry;
         try
         {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.ToString()!);
         }
         catch
         {
@@ -587,9 +698,7 @@ public partial class LightlessHub
         var tasks = new Dictionary<string, Task<RedisValueWithExpiry>>(hashedCids.Count);
         foreach (var cid in hashedCids)
         {
-            bool validHash = !string.IsNullOrWhiteSpace(cid) && cid.Length == 64 && cid.All(Uri.IsHexDigit) && !cid.All(c => c == '0');
+            if (!IsValidHashedCid(cid))
-
-            if (!validHash)
             {
                 tasks[cid] = Task.FromResult(new RedisValueWithExpiry(RedisValue.Null, null));
                 continue;
@@ -619,7 +728,7 @@ public partial class LightlessHub
 
                 try
                 {
-                    entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(raw!);
+                    entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(raw.ToString()!);
                     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));
@@ -657,7 +766,7 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo();
 
-        var userEntry = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var userEntry = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         var secondaryUsers = await DbContext.Auth.Include(u => u.User).Where(u => u.PrimaryUserUID == UserUID).Select(c => c.User).ToListAsync().ConfigureAwait(false);
         foreach (var user in secondaryUsers)
         {
@@ -707,16 +816,107 @@ public partial class LightlessHub
 
         if (!allUserPairs.Contains(user.User.UID, StringComparer.Ordinal) && !string.Equals(user.User.UID, UserUID, StringComparison.Ordinal))
         {
-            return new UserProfileDto(user.User, false, null, null, "Due to the pause status you cannot access this users profile.");
+            return new UserProfileDto(user.User, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "Due to the pause status you cannot access this users profile.", Tags: []);
         }
 
-        var data = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == user.User.UID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var data = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == user.User.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        if (data == null) return new UserProfileDto(user.User, false, null, null, null);
+        if (data == null) return new UserProfileDto(user.User, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: null, Tags: []);
 
-        if (data.FlaggedForReport) return new UserProfileDto(user.User, true, null, null, "This profile is flagged for report and pending evaluation");
+        if (data.FlaggedForReport) return new UserProfileDto(user.User, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile is flagged for report and pending evaluation", Tags: []);
-        if (data.ProfileDisabled) return new UserProfileDto(user.User, true, null, null, "This profile was permanently disabled");
+        if (data.ProfileDisabled) return new UserProfileDto(user.User, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile was permanently disabled", Tags: []);
 
-        return new UserProfileDto(user.User, false, data.IsNSFW, data.Base64ProfileImage, data.UserDescription);
+        return data.ToDTO();
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task<UserProfileDto?> UserGetLightfinderProfile(string hashedCid)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args("LightfinderProfile", hashedCid));
+
+        if (!_broadcastConfiguration.EnableBroadcasting)
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Lightfinder is currently disabled.").ConfigureAwait(false);
+            return null;
+        }
+
+        if (!IsValidHashedCid(hashedCid))
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LightfinderProfileInvalidCid", hashedCid));
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "Invalid Lightfinder target.").ConfigureAwait(false);
+            return null;
+        }
+
+        var viewerCid = UserCharaIdent;
+        if (!IsValidHashedCid(viewerCid))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You must be using Lightfinder to open player profiles.").ConfigureAwait(false);
+            return null;
+        }
+
+        var (viewerEntry, viewerExpiry) = await TryGetBroadcastEntryAsync(viewerCid).ConfigureAwait(false);
+        if (!IsActiveBroadcastForUser(viewerEntry, viewerExpiry, UserUID))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You must be using Lightfinder to open player profiles.").ConfigureAwait(false);
+            return null;
+        }
+
+        var (targetEntry, targetExpiry) = await TryGetBroadcastEntryAsync(hashedCid).ConfigureAwait(false);
+        if (!HasActiveBroadcast(targetEntry, targetExpiry))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "That player is not currently using Lightfinder.").ConfigureAwait(false);
+            return null;
+        }
+
+        if (string.IsNullOrEmpty(targetEntry!.OwnerUID))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "That player is not currently using Lightfinder.").ConfigureAwait(false);
+            return null;
+        }
+
+        var targetUser = await DbContext.Users.AsNoTracking()
+            .SingleOrDefaultAsync(u => u.UID == targetEntry.OwnerUID, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (targetUser == null)
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LightfinderProfileMissingUser", hashedCid, "OwnerUID", targetEntry.OwnerUID));
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "Unable to load the players profile at this time.").ConfigureAwait(false);
+            return null;
+        }
+
+        var displayAlias = string.IsNullOrWhiteSpace(targetUser.Alias)
+            ? "LightfinderUser"
+            : targetUser.Alias;
+
+        var userData = new UserData(
+            UID: hashedCid,
+            Alias: displayAlias,
+            IsAdmin: false,
+            IsModerator: false,
+            HasVanity: false,
+            TextColorHex: targetUser.TextColorHex,
+            TextGlowColorHex: targetUser.TextGlowColorHex);
+
+        var profile = await DbContext.UserProfileData.AsNoTracking()
+            .SingleOrDefaultAsync(u => u.UserUID == targetEntry.OwnerUID, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+
+        if (profile == null)
+        {
+            return new UserProfileDto(userData, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: null, Tags: []);
+        }
+
+        if (profile.FlaggedForReport)
+        {
+            return new UserProfileDto(userData, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile is flagged for report and pending evaluation", Tags: []);
+        }
+
+        if (profile.ProfileDisabled)
+        {
+            return new UserProfileDto(userData, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile was permanently disabled", Tags: []);
+        }
+
+        return profile.ToDTO();
     }
 
     [Authorize(Policy = "Identified")]
@@ -749,22 +949,36 @@ public partial class LightlessHub
         }
 
         bool hadInvalidData = false;
-        List<string> invalidGamePaths = new();
+        List<string> invalidGamePaths = [];
-        List<string> invalidFileSwapPaths = new();
+        List<string> invalidFileSwapPaths = [];
+
+        var gamePathRegex = GamePathRegex();
+        var hashRegex = HashRegex();
+
         foreach (var replacement in dto.CharaData.FileReplacements.SelectMany(p => p.Value))
         {
-            var invalidPaths = replacement.GamePaths.Where(p => !GamePathRegex().IsMatch(p)).ToList();
+            var validGamePaths = replacement.GamePaths
-            invalidPaths.AddRange(replacement.GamePaths.Where(p => !AllowedExtensionsForGamePaths.Any(e => p.EndsWith(e, StringComparison.OrdinalIgnoreCase))));
+                .Where(p => gamePathRegex.IsMatch(p) &&
-            replacement.GamePaths = replacement.GamePaths.Where(p => !invalidPaths.Contains(p, StringComparer.OrdinalIgnoreCase)).ToArray();
+                            AllowedExtensionsForGamePaths.Any(e => p.EndsWith(e, StringComparison.OrdinalIgnoreCase)))
-            bool validGamePaths = replacement.GamePaths.Any();
+                .ToArray();
-            bool validHash = string.IsNullOrEmpty(replacement.Hash) || HashRegex().IsMatch(replacement.Hash);
+
-            bool validFileSwapPath = string.IsNullOrEmpty(replacement.FileSwapPath) || GamePathRegex().IsMatch(replacement.FileSwapPath);
+            var invalidPaths = replacement.GamePaths.Except(validGamePaths, StringComparer.OrdinalIgnoreCase).ToArray();
-            if (!validGamePaths || !validHash || !validFileSwapPath)
+
+            replacement.GamePaths = validGamePaths;
+
+            bool validHash = string.IsNullOrEmpty(replacement.Hash) || hashRegex.IsMatch(replacement.Hash);
+            bool validFileSwapPath = string.IsNullOrEmpty(replacement.FileSwapPath) || gamePathRegex.IsMatch(replacement.FileSwapPath);
+            bool validGamePathsFlag = validGamePaths.Length
+                                      != 0;
+
+            if (!validGamePathsFlag || !validHash || !validFileSwapPath)
             {
-                _logger.LogCallWarning(LightlessHubLogger.Args("Invalid Data", "GamePaths", validGamePaths, string.Join(",", invalidPaths), "Hash", validHash, replacement.Hash, "FileSwap", validFileSwapPath, replacement.FileSwapPath));
+                _logger.LogCallWarning(LightlessHubLogger.Args("Invalid Data", "GamePaths", validGamePathsFlag, string.Join(',', invalidPaths), "Hash", validHash, replacement.Hash, "FileSwap", validFileSwapPath, replacement.FileSwapPath));
+
                 hadInvalidData = true;
+
                 if (!validFileSwapPath) invalidFileSwapPaths.Add(replacement.FileSwapPath);
-                if (!validGamePaths) invalidGamePaths.AddRange(replacement.GamePaths);
+                if (!validGamePathsFlag) invalidGamePaths.AddRange(invalidPaths);
                 if (!validHash) invalidFileSwapPaths.Add(replacement.Hash);
             }
         }
@@ -867,7 +1081,7 @@ public partial class LightlessHub
 
         // check if client pair even exists
         ClientPair callerPair =
-            await DbContext.ClientPairs.SingleOrDefaultAsync(w => w.UserUID == UserUID && w.OtherUserUID == dto.User.UID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+            await DbContext.ClientPairs.SingleOrDefaultAsync(w => w.UserUID == UserUID && w.OtherUserUID == dto.User.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
         if (callerPair == null) return;
 
         var pairData = await GetPairInfo(UserUID, dto.User.UID).ConfigureAwait(false);
@@ -916,76 +1130,64 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
+        var cancellationToken = RequestAbortedToken;
+
         if (!string.Equals(dto.User.UID, UserUID, StringComparison.Ordinal)) throw new HubException("Cannot modify profile data for anyone but yourself");
 
-        var existingData = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == dto.User.UID, cancellationToken: _contextAccessor.HttpContext.RequestAborted).ConfigureAwait(false);
+        var profileData = await DbContext.UserProfileData.SingleOrDefaultAsync(u => u.UserUID == dto.User.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
-        if (existingData?.FlaggedForReport ?? false)
+        ImageCheckService.ImageLoadResult profileResult = new();
-        {
+        ImageCheckService.ImageLoadResult bannerResult = new();
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile is currently flagged for report and cannot be edited").ConfigureAwait(false);
-            return;
-        }
-
-        if (existingData?.ProfileDisabled ?? false)
-        {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
-            return;
-        }
 
+        //Avatar image validation
         if (!string.IsNullOrEmpty(dto.ProfilePictureBase64))
         {
-            byte[] imageData = Convert.FromBase64String(dto.ProfilePictureBase64);
+            profileResult = await ImageCheckService.ValidateImageAsync(dto.ProfilePictureBase64, banner: false, RequestAbortedToken).ConfigureAwait(false);
-            using MemoryStream ms = new(imageData);
-            var format = await Image.DetectFormatAsync(ms).ConfigureAwait(false);
-            if (!format.FileExtensions.Contains("png", StringComparer.OrdinalIgnoreCase))
-            {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your provided image file is not in PNG format").ConfigureAwait(false);
-                return;
-            }
-            using var image = Image.Load<Rgba32>(imageData);
 
-            if (image.Width > 256 || image.Height > 256 || (imageData.Length > 250 * 1024))
+            if (!profileResult.Success)
             {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your provided image file is larger than 256x256 or more than 250KiB.").ConfigureAwait(false);
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, profileResult.ErrorMessage).ConfigureAwait(false);
                 return;
             }
         }
 
-        if (existingData != null)
+        //Banner image validation
+        if (!string.IsNullOrEmpty(dto.BannerPictureBase64))
         {
-            if (string.Equals("", dto.ProfilePictureBase64, StringComparison.OrdinalIgnoreCase))
+            bannerResult = await ImageCheckService.ValidateImageAsync(dto.BannerPictureBase64, banner: true, RequestAbortedToken).ConfigureAwait(false);
+
+            if (!bannerResult.Success)
             {
-                existingData.Base64ProfileImage = null;
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, bannerResult.ErrorMessage).ConfigureAwait(false);
+                return;
             }
-            else if (dto.ProfilePictureBase64 != null)
+        }
+
+        if (profileData != null)
+        {
+            if (profileData.FlaggedForReport)
             {
-                existingData.Base64ProfileImage = dto.ProfilePictureBase64;
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile is currently flagged for report and cannot be edited").ConfigureAwait(false);
+                return;
             }
 
-            if (dto.IsNSFW != null)
+            profileData.UpdateProfileFromDto(dto, profileResult.Base64Image, bannerResult.Base64Image);
-            {
-                existingData.IsNSFW = dto.IsNSFW.Value;
-            }
-
-            if (dto.Description != null)
-            {
-                existingData.UserDescription = dto.Description;
-            }
         }
         else
         {
-            UserProfileData userProfileData = new()
+            profileData = new()
             {
                 UserUID = dto.User.UID,
-                Base64ProfileImage = dto.ProfilePictureBase64 ?? null,
+                IsNSFW = dto.IsNSFW ?? false,
-                UserDescription = dto.Description ?? null,
-                IsNSFW = dto.IsNSFW ?? false
             };
 
-            await DbContext.UserProfileData.AddAsync(userProfileData).ConfigureAwait(false);
+            profileData.UpdateProfileFromDto(dto, profileResult.Base64Image, bannerResult.Base64Image);
+
+            await DbContext.UserProfileData.AddAsync(profileData, cancellationToken).ConfigureAwait(false);
         }
 
-        await DbContext.SaveChangesAsync().ConfigureAwait(false);
+
+        await DbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 
         var allPairedUsers = await GetAllPairedUnpausedUsers().ConfigureAwait(false);
         var pairs = await GetOnlineUsers(allPairedUsers).ConfigureAwait(false);

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs

@@ -16,6 +16,7 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
+using LightlessSyncServer.Services.Interfaces;
 
 namespace LightlessSyncServer.Hubs;
 
@@ -26,6 +27,7 @@ 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;
@@ -43,12 +45,16 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
     private LightlessDbContext DbContext => _dbContextLazy.Value;
     private readonly int _maxCharaDataByUser;
     private readonly int _maxCharaDataByUserVanity;
+    private readonly ChatChannelService _chatChannelService;
+
+    private CancellationToken RequestAbortedToken => _contextAccessor.HttpContext?.RequestAborted ?? Context?.ConnectionAborted ?? CancellationToken.None;
 
     public LightlessHub(LightlessMetrics lightlessMetrics,
         IDbContextFactory<LightlessDbContext> lightlessDbContextFactory, ILogger<LightlessHub> logger, SystemInfoService systemInfoService,
         IConfigurationService<ServerConfiguration> configuration, IHttpContextAccessor contextAccessor,
         IRedisDatabase redisDb, OnlineSyncedPairCacheService onlineSyncedPairCacheService, LightlessCensus lightlessCensus,
-        GPoseLobbyDistributionService gPoseLobbyDistributionService, IBroadcastConfiguration broadcastConfiguration, PairService pairService)
+        GPoseLobbyDistributionService gPoseLobbyDistributionService, IBroadcastConfiguration broadcastConfiguration, PairService pairService,
+        ChatChannelService chatChannelService, IPruneService pruneService)
     {
         _lightlessMetrics = lightlessMetrics;
         _systemInfoService = systemInfoService;
@@ -69,6 +75,8 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         _dbContextLazy = new Lazy<LightlessDbContext>(() => lightlessDbContextFactory.CreateDbContext());
         _broadcastConfiguration = broadcastConfiguration;
         _pairService = pairService;
+        _chatChannelService = chatChannelService;
+        _pruneService = pruneService;
     }
 
     protected override void Dispose(bool disposing)
@@ -158,8 +166,13 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         }
         else
         {
-            _lightlessMetrics.IncGaugeWithLabels(MetricsAPI.GaugeConnections, labels: Continent);
+            var ResultLabels = new List<string>
+            {
+                Continent,
+                Country,
+            };
 
+            _lightlessMetrics.IncGaugeWithLabels(MetricsAPI.GaugeConnections, labels: [.. ResultLabels]);
             try
             {
                 _logger.LogCallInfo(LightlessHubLogger.Args(_contextAccessor.GetIpAddress(), Context.ConnectionId, UserCharaIdent));
@@ -182,7 +195,12 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         if (_userConnections.TryGetValue(UserUID, out var connectionId)
             && string.Equals(connectionId, Context.ConnectionId, StringComparison.Ordinal))
         {
-            _lightlessMetrics.DecGaugeWithLabels(MetricsAPI.GaugeConnections, labels: Continent);
+            var ResultLabels = new List<string>
+            {
+                Continent,
+                Country,
+            };
+            _lightlessMetrics.DecGaugeWithLabels(MetricsAPI.GaugeConnections, labels: [.. ResultLabels]);
 
             try
             {
@@ -194,6 +212,8 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
                 if (exception != null)
                     _logger.LogCallWarning(LightlessHubLogger.Args(_contextAccessor.GetIpAddress(), Context.ConnectionId, exception.Message, exception.StackTrace));
 
+                await ClearOwnedBroadcastLock().ConfigureAwait(false);
+
                 await RemoveUserFromRedis().ConfigureAwait(false);
 
                 _lightlessCensus.ClearStatistics(UserUID);
@@ -207,6 +227,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
             catch { }
             finally
             {
+                TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID), "removing chat presence on disconnect");
                 _userConnections.Remove(UserUID, out _);
             }
         }

LightlessSyncServer/LightlessSyncServer/LightlessSyncServer.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <UserSecretsId>aspnet-LightlessSyncServer-BA82A12A-0B30-463C-801D-B7E81318CD50</UserSecretsId>
     <AssemblyVersion>1.1.0.0</AssemblyVersion>
     <ImplicitUsings>enable</ImplicitUsings>

LightlessSyncServer/LightlessSyncServer/Models/BroadcastRedisEntry.cs

@@ -0,0 +1,12 @@
+namespace LightlessSyncServer.Models;
+
+public class BroadcastRedisEntry()
+{
+    public string? GID { get; set; }
+    public string HashedCID { get; set; } = string.Empty;
+    public string OwnerUID { get; set; } = string.Empty;
+
+    public bool OwnedBy(string userUid) => !string.IsNullOrEmpty(userUid) && string.Equals(OwnerUID, userUid, StringComparison.Ordinal);
+
+    public bool HasOwner() => !string.IsNullOrEmpty(OwnerUID);
+}

LightlessSyncServer/LightlessSyncServer/Models/ChatModels.cs

@@ -0,0 +1,56 @@
+using LightlessSync.API.Data;
+using LightlessSync.API.Dto.Chat;
+
+namespace LightlessSyncServer.Models;
+
+internal readonly record struct ChatReportSnapshotItem(
+    string MessageId,
+    DateTime SentAtUtc,
+    string SenderUserUid,
+    string? SenderAlias,
+    bool SenderIsLightfinder,
+    string? SenderHashedCid,
+    string Message);
+
+public readonly record struct ChatPresenceEntry(
+    ChatChannelDescriptor Channel,
+    ChannelKey ChannelKey,
+    string DisplayName,
+    ChatParticipantInfo Participant,
+    DateTime UpdatedAt);
+
+public readonly record struct ChatParticipantInfo(
+    string Token,
+    string UserUid,
+    UserData? User,
+    string? HashedCid,
+    bool IsLightfinder);
+
+public readonly record struct ChatMessageLogEntry(
+    string MessageId,
+    ChatChannelDescriptor Channel,
+    DateTime SentAtUtc,
+    string SenderUserUid,
+    UserData? SenderUser,
+    bool SenderIsLightfinder,
+    string? SenderHashedCid,
+    string Message);
+
+public readonly record struct ZoneChannelDefinition(
+    string Key,
+    string DisplayName,
+    ChatChannelDescriptor Descriptor,
+    IReadOnlyList<string> TerritoryNames,
+    IReadOnlySet<ushort> TerritoryIds);
+
+public readonly record struct ChannelKey(ChatChannelType Type, ushort WorldId, string CustomKey)
+{
+    public static ChannelKey FromDescriptor(ChatChannelDescriptor descriptor) =>
+        new(
+            descriptor.Type,
+            descriptor.Type == ChatChannelType.Zone ? descriptor.WorldId : (ushort)0,
+            NormalizeKey(descriptor.CustomKey));
+
+    private static string NormalizeKey(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? string.Empty : value.Trim().ToUpperInvariant();
+}

LightlessSyncServer/LightlessSyncServer/Models/ChatZoneDefinitions.cs

@@ -0,0 +1,65 @@
+using LightlessSync.API.Dto.Chat;
+
+namespace LightlessSyncServer.Models;
+
+internal static class ChatZoneDefinitions
+{
+    public static IReadOnlyList<ZoneChannelDefinition> Defaults { get; } =
+        new[]
+        {
+            new ZoneChannelDefinition(
+                Key: "limsa",
+                DisplayName: "Limsa Lominsa",
+                Descriptor: new ChatChannelDescriptor
+                {
+                    Type = ChatChannelType.Zone,
+                    WorldId = 0,
+                    ZoneId = 0,
+                    CustomKey = "limsa"
+                },
+                TerritoryNames: new[]
+                {
+                    "Limsa Lominsa Lower Decks",
+                    "Limsa Lominsa Upper Decks"
+                },
+                TerritoryIds: TerritoryRegistry.GetIds(
+                    "Limsa Lominsa Lower Decks",
+                    "Limsa Lominsa Upper Decks")),
+            new ZoneChannelDefinition(
+                Key: "gridania",
+                DisplayName: "Gridania",
+                Descriptor: new ChatChannelDescriptor
+                {
+                    Type = ChatChannelType.Zone,
+                    WorldId = 0,
+                    ZoneId = 0,
+                    CustomKey = "gridania"
+                },
+                TerritoryNames: new[]
+                {
+                    "New Gridania",
+                    "Old Gridania"
+                },
+                TerritoryIds: TerritoryRegistry.GetIds(
+                    "New Gridania",
+                    "Old Gridania")),
+            new ZoneChannelDefinition(
+                Key: "uldah",
+                DisplayName: "Ul'dah",
+                Descriptor: new ChatChannelDescriptor
+                {
+                    Type = ChatChannelType.Zone,
+                    WorldId = 0,
+                    ZoneId = 0,
+                    CustomKey = "uldah"
+                },
+                TerritoryNames: new[]
+                {
+                    "Ul'dah - Steps of Nald",
+                    "Ul'dah - Steps of Thal"
+                },
+                TerritoryIds: TerritoryRegistry.GetIds(
+                    "Ul'dah - Steps of Nald",
+                    "Ul'dah - Steps of Thal")),
+        };
+}

LightlessSyncServer/LightlessSyncServer/Models/PairingPayload.cs

@@ -0,0 +1,8 @@
+namespace LightlessSyncServer.Models;
+
+public class PairingPayload
+{
+    public string UID { get; set; } = string.Empty;
+    public string HashedCid { get; set; } = string.Empty;
+    public DateTime Timestamp { get; set; }
+}

LightlessSyncServer/LightlessSyncServer/Models/TerritoryDefinition.cs

@@ -0,0 +1,5 @@
+namespace LightlessSyncServer.Models;
+
+internal readonly record struct TerritoryDefinition(
+    ushort TerritoryId,
+    string Name);

LightlessSyncServer/LightlessSyncServer/Models/WorldDefinition.cs

@@ -0,0 +1,7 @@
+namespace LightlessSyncServer.Models;
+
+internal readonly record struct WorldDefinition(
+    ushort WorldId,
+    string Name,
+    string Region,
+    string DataCenter);

LightlessSyncServer/LightlessSyncServer/Models/WorldRegistry.generated.cs

@@ -0,0 +1,117 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+namespace LightlessSyncServer.Models;
+
+internal static class WorldRegistry
+{
+    private static readonly WorldDefinition[] WorldArray = new[]
+    {
+        new WorldDefinition(80, "Cerberus", "Europe", "Chaos"),
+        new WorldDefinition(83, "Louisoix", "Europe", "Chaos"),
+        new WorldDefinition(71, "Moogle", "Europe", "Chaos"),
+        new WorldDefinition(39, "Omega", "Europe", "Chaos"),
+        new WorldDefinition(401, "Phantom", "Europe", "Chaos"),
+        new WorldDefinition(97, "Ragnarok", "Europe", "Chaos"),
+        new WorldDefinition(400, "Sagittarius", "Europe", "Chaos"),
+        new WorldDefinition(85, "Spriggan", "Europe", "Chaos"),
+        new WorldDefinition(402, "Alpha", "Europe", "Light"),
+        new WorldDefinition(36, "Lich", "Europe", "Light"),
+        new WorldDefinition(66, "Odin", "Europe", "Light"),
+        new WorldDefinition(56, "Phoenix", "Europe", "Light"),
+        new WorldDefinition(403, "Raiden", "Europe", "Light"),
+        new WorldDefinition(67, "Shiva", "Europe", "Light"),
+        new WorldDefinition(33, "Twintania", "Europe", "Light"),
+        new WorldDefinition(42, "Zodiark", "Europe", "Light"),
+        new WorldDefinition(90, "Aegis", "Japan", "Elemental"),
+        new WorldDefinition(68, "Atomos", "Japan", "Elemental"),
+        new WorldDefinition(45, "Carbuncle", "Japan", "Elemental"),
+        new WorldDefinition(58, "Garuda", "Japan", "Elemental"),
+        new WorldDefinition(94, "Gungnir", "Japan", "Elemental"),
+        new WorldDefinition(49, "Kujata", "Japan", "Elemental"),
+        new WorldDefinition(72, "Tonberry", "Japan", "Elemental"),
+        new WorldDefinition(50, "Typhon", "Japan", "Elemental"),
+        new WorldDefinition(43, "Alexander", "Japan", "Gaia"),
+        new WorldDefinition(69, "Bahamut", "Japan", "Gaia"),
+        new WorldDefinition(92, "Durandal", "Japan", "Gaia"),
+        new WorldDefinition(46, "Fenrir", "Japan", "Gaia"),
+        new WorldDefinition(59, "Ifrit", "Japan", "Gaia"),
+        new WorldDefinition(98, "Ridill", "Japan", "Gaia"),
+        new WorldDefinition(76, "Tiamat", "Japan", "Gaia"),
+        new WorldDefinition(51, "Ultima", "Japan", "Gaia"),
+        new WorldDefinition(44, "Anima", "Japan", "Mana"),
+        new WorldDefinition(23, "Asura", "Japan", "Mana"),
+        new WorldDefinition(70, "Chocobo", "Japan", "Mana"),
+        new WorldDefinition(47, "Hades", "Japan", "Mana"),
+        new WorldDefinition(48, "Ixion", "Japan", "Mana"),
+        new WorldDefinition(96, "Masamune", "Japan", "Mana"),
+        new WorldDefinition(28, "Pandaemonium", "Japan", "Mana"),
+        new WorldDefinition(61, "Titan", "Japan", "Mana"),
+        new WorldDefinition(24, "Belias", "Japan", "Meteor"),
+        new WorldDefinition(82, "Mandragora", "Japan", "Meteor"),
+        new WorldDefinition(60, "Ramuh", "Japan", "Meteor"),
+        new WorldDefinition(29, "Shinryu", "Japan", "Meteor"),
+        new WorldDefinition(30, "Unicorn", "Japan", "Meteor"),
+        new WorldDefinition(52, "Valefor", "Japan", "Meteor"),
+        new WorldDefinition(31, "Yojimbo", "Japan", "Meteor"),
+        new WorldDefinition(32, "Zeromus", "Japan", "Meteor"),
+        new WorldDefinition(73, "Adamantoise", "North America", "Aether"),
+        new WorldDefinition(79, "Cactuar", "North America", "Aether"),
+        new WorldDefinition(54, "Faerie", "North America", "Aether"),
+        new WorldDefinition(63, "Gilgamesh", "North America", "Aether"),
+        new WorldDefinition(40, "Jenova", "North America", "Aether"),
+        new WorldDefinition(65, "Midgardsormr", "North America", "Aether"),
+        new WorldDefinition(99, "Sargatanas", "North America", "Aether"),
+        new WorldDefinition(57, "Siren", "North America", "Aether"),
+        new WorldDefinition(91, "Balmung", "North America", "Crystal"),
+        new WorldDefinition(34, "Brynhildr", "North America", "Crystal"),
+        new WorldDefinition(74, "Coeurl", "North America", "Crystal"),
+        new WorldDefinition(62, "Diabolos", "North America", "Crystal"),
+        new WorldDefinition(81, "Goblin", "North America", "Crystal"),
+        new WorldDefinition(75, "Malboro", "North America", "Crystal"),
+        new WorldDefinition(37, "Mateus", "North America", "Crystal"),
+        new WorldDefinition(41, "Zalera", "North America", "Crystal"),
+        new WorldDefinition(408, "Cuchulainn", "North America", "Dynamis"),
+        new WorldDefinition(411, "Golem", "North America", "Dynamis"),
+        new WorldDefinition(406, "Halicarnassus", "North America", "Dynamis"),
+        new WorldDefinition(409, "Kraken", "North America", "Dynamis"),
+        new WorldDefinition(407, "Maduin", "North America", "Dynamis"),
+        new WorldDefinition(404, "Marilith", "North America", "Dynamis"),
+        new WorldDefinition(410, "Rafflesia", "North America", "Dynamis"),
+        new WorldDefinition(405, "Seraph", "North America", "Dynamis"),
+        new WorldDefinition(78, "Behemoth", "North America", "Primal"),
+        new WorldDefinition(93, "Excalibur", "North America", "Primal"),
+        new WorldDefinition(53, "Exodus", "North America", "Primal"),
+        new WorldDefinition(35, "Famfrit", "North America", "Primal"),
+        new WorldDefinition(95, "Hyperion", "North America", "Primal"),
+        new WorldDefinition(55, "Lamia", "North America", "Primal"),
+        new WorldDefinition(64, "Leviathan", "North America", "Primal"),
+        new WorldDefinition(77, "Ultros", "North America", "Primal"),
+        new WorldDefinition(22, "Bismarck", "Oceania", "Materia"),
+        new WorldDefinition(21, "Ravana", "Oceania", "Materia"),
+        new WorldDefinition(86, "Sephirot", "Oceania", "Materia"),
+        new WorldDefinition(87, "Sophia", "Oceania", "Materia"),
+        new WorldDefinition(88, "Zurvan", "Oceania", "Materia"),
+    };
+
+    public static IReadOnlyList<WorldDefinition> All { get; } = Array.AsReadOnly(WorldArray);
+    public static IReadOnlyDictionary<ushort, WorldDefinition> ById { get; } = new ReadOnlyDictionary<ushort, WorldDefinition>(WorldArray.ToDictionary(w => w.WorldId));
+    public static IReadOnlyDictionary<string, IReadOnlyList<WorldDefinition>> ByDataCenter { get; } = new ReadOnlyDictionary<string, IReadOnlyList<WorldDefinition>>(WorldArray
+        .GroupBy(w => w.DataCenter, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(
+            g => g.Key,
+            g => (IReadOnlyList<WorldDefinition>)g.OrderBy(w => w.Name, StringComparer.Ordinal).ToArray(),
+            StringComparer.OrdinalIgnoreCase));
+    public static IReadOnlyDictionary<string, IReadOnlyList<WorldDefinition>> ByRegion { get; } = new ReadOnlyDictionary<string, IReadOnlyList<WorldDefinition>>(WorldArray
+        .GroupBy(w => w.Region, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(
+            g => g.Key,
+            g => (IReadOnlyList<WorldDefinition>)g.OrderBy(w => w.Name, StringComparer.Ordinal).ToArray(),
+            StringComparer.OrdinalIgnoreCase));
+
+    public static bool TryGet(ushort worldId, out WorldDefinition definition) => ById.TryGetValue(worldId, out definition);
+    public static bool IsKnownWorld(ushort worldId) => ById.ContainsKey(worldId);
+}

LightlessSyncServer/LightlessSyncServer/Program.cs

@@ -41,7 +41,6 @@ public class Program
             metrics.SetGaugeTo(MetricsAPI.GaugeUsersRegistered, context.Users.AsNoTracking().Count());
             metrics.SetGaugeTo(MetricsAPI.GaugePairs, context.ClientPairs.AsNoTracking().Count());
             metrics.SetGaugeTo(MetricsAPI.GaugePairsPaused, context.Permissions.AsNoTracking().Where(p=>p.IsPaused).Count());
-
         }
 
         if (args.Length == 0 || !string.Equals(args[0], "dry", StringComparison.Ordinal))

LightlessSyncServer/LightlessSyncServer/Services/ChatChannelService.cs

@@ -0,0 +1,767 @@
+using System.Security.Cryptography;
+using LightlessSync.API.Data;
+using LightlessSync.API.Dto.Chat;
+using LightlessSyncServer.Configuration;
+using LightlessSyncServer.Models;
+using Microsoft.Extensions.Options;
+
+namespace LightlessSyncServer.Services;
+
+public sealed class ChatChannelService : IDisposable
+{
+    private readonly ILogger<ChatChannelService> _logger;
+    private readonly Dictionary<string, ZoneChannelDefinition> _zoneDefinitions;
+    private readonly Dictionary<ChannelKey, HashSet<string>> _membersByChannel = new();
+    private readonly Dictionary<string, Dictionary<ChannelKey, ChatPresenceEntry>> _presenceByUser = new(StringComparer.Ordinal);
+    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)
+    {
+        _logger = logger;
+        _zoneDefinitions = BuildZoneDefinitions(zoneOverrides?.Value);
+    }
+
+    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(
+                definition.Descriptor,
+                definition.DisplayName,
+                definition.TerritoryNames))
+            .ToArray();
+
+    public bool TryResolveZone(string? key, out ZoneChannelDefinition definition)
+    {
+        definition = default;
+        if (string.IsNullOrWhiteSpace(key))
+            return false;
+
+        return _zoneDefinitions.TryGetValue(key, out definition);
+    }
+
+    public ChatPresenceEntry? UpdateZonePresence(
+        string userUid,
+        ZoneChannelDefinition definition,
+        ushort worldId,
+        ushort territoryId,
+        string? hashedCid,
+        bool isLightfinder,
+        bool isActive)
+    {
+        if (worldId == 0 || !WorldRegistry.IsKnownWorld(worldId))
+        {
+            _logger.LogWarning("Rejected zone chat presence for {User} in {Zone}: unknown world {WorldId}", userUid, definition.Key, worldId);
+            return null;
+        }
+
+        if (!definition.TerritoryIds.Contains(territoryId))
+        {
+            _logger.LogWarning("Rejected zone chat presence for {User} in {Zone}: invalid territory {TerritoryId}", userUid, definition.Key, territoryId);
+            return null;
+        }
+
+        var descriptor = definition.Descriptor with { WorldId = worldId, ZoneId = territoryId };
+        var participant = new ChatParticipantInfo(
+            Token: string.Empty,
+            UserUid: userUid,
+            User: null,
+            HashedCid: isLightfinder ? hashedCid : null,
+            IsLightfinder: isLightfinder);
+
+        return UpdatePresence(
+            userUid,
+            descriptor,
+            definition.DisplayName,
+            participant,
+            isActive,
+            replaceExistingOfSameType: true);
+    }
+
+    public ChatPresenceEntry? UpdateGroupPresence(
+        string userUid,
+        string groupId,
+        string displayName,
+        UserData user,
+        string? hashedCid,
+        bool isActive)
+    {
+        var descriptor = new ChatChannelDescriptor
+        {
+            Type = ChatChannelType.Group,
+            WorldId = 0,
+            ZoneId = 0,
+            CustomKey = groupId
+        };
+
+        var participant = new ChatParticipantInfo(
+            Token: string.Empty,
+            UserUid: userUid,
+            User: user,
+            HashedCid: hashedCid,
+            IsLightfinder: !string.IsNullOrEmpty(hashedCid));
+
+        return UpdatePresence(
+            userUid,
+            descriptor,
+            displayName,
+            participant,
+            isActive,
+            replaceExistingOfSameType: false);
+    }
+
+    public bool TryGetPresence(string userUid, ChatChannelDescriptor channel, out ChatPresenceEntry presence)
+    {
+        var key = ChannelKey.FromDescriptor(channel);
+
+        lock (_syncRoot)
+        {
+            if (_presenceByUser.TryGetValue(userUid, out var entries) && entries.TryGetValue(key, out presence))
+            {
+                return true;
+            }
+        }
+
+        presence = default;
+        return false;
+    }
+
+    public IReadOnlyCollection<string> GetMembers(ChatChannelDescriptor channel)
+    {
+        var key = ChannelKey.FromDescriptor(channel);
+
+        lock (_syncRoot)
+        {
+            if (_membersByChannel.TryGetValue(key, out var members))
+            {
+                return members.ToArray();
+            }
+        }
+
+        return Array.Empty<string>();
+    }
+
+    public string RecordMessage(ChatChannelDescriptor channel, ChatParticipantInfo participant, string message, DateTime sentAtUtc)
+    {
+        var key = ChannelKey.FromDescriptor(channel);
+        var messageId = Guid.NewGuid().ToString("N");
+        var entry = new ChatMessageLogEntry(
+            messageId,
+            channel,
+            sentAtUtc,
+            participant.UserUid,
+            participant.User,
+            participant.IsLightfinder,
+            participant.HashedCid,
+            message);
+
+        lock (_syncRoot)
+        {
+            if (!_messagesByChannel.TryGetValue(key, out var list))
+            {
+                list = new LinkedList<ChatMessageLogEntry>();
+                _messagesByChannel[key] = list;
+            }
+
+            var node = list.AddLast(entry);
+            _messageIndex[messageId] = (key, node);
+
+            while (list.Count > MaxMessagesPerChannel)
+            {
+                var removedNode = list.First;
+                if (removedNode is null)
+                {
+                    break;
+                }
+
+                list.RemoveFirst();
+                _messageIndex.Remove(removedNode.Value.MessageId);
+            }
+        }
+
+        return messageId;
+    }
+
+    public bool TryGetMessage(string messageId, out ChatMessageLogEntry entry)
+    {
+        lock (_syncRoot)
+        {
+            if (_messageIndex.TryGetValue(messageId, out var located))
+            {
+                entry = located.Node.Value;
+                return true;
+            }
+        }
+
+        entry = default;
+        return false;
+    }
+
+    public IReadOnlyList<ChatMessageLogEntry> GetRecentMessages(ChatChannelDescriptor descriptor, int maxCount)
+    {
+        lock (_syncRoot)
+        {
+            var key = ChannelKey.FromDescriptor(descriptor);
+            if (!_messagesByChannel.TryGetValue(key, out var list) || list.Count == 0)
+            {
+                return Array.Empty<ChatMessageLogEntry>();
+            }
+
+            var take = Math.Min(maxCount, list.Count);
+            var result = new ChatMessageLogEntry[take];
+            var node = list.Last;
+            for (var i = take - 1; i >= 0 && node is not null; i--)
+            {
+                result[i] = node.Value;
+                node = node.Previous;
+            }
+
+            return result;
+        }
+    }
+
+    public bool RemovePresence(string userUid, ChatChannelDescriptor? channel = null)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(userUid);
+
+        lock (_syncRoot)
+        {
+            if (!_presenceByUser.TryGetValue(userUid, out var entries))
+            {
+                return false;
+            }
+
+            if (channel is null)
+            {
+                foreach (var existing in entries.Keys.ToList())
+                {
+                    RemovePresenceInternal(userUid, entries, existing);
+                }
+
+                _presenceByUser.Remove(userUid);
+                return true;
+            }
+
+            var key = ChannelKey.FromDescriptor(channel.Value);
+            var removed = RemovePresenceInternal(userUid, entries, key);
+
+            if (entries.Count == 0)
+            {
+                _presenceByUser.Remove(userUid);
+            }
+
+            return removed;
+        }
+    }
+
+    public void RefreshLightfinderState(string userUid, string? hashedCid, bool isLightfinder)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(userUid);
+
+        lock (_syncRoot)
+        {
+            if (!_presenceByUser.TryGetValue(userUid, out var entries) || entries.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var (key, existing) in entries.ToArray())
+            {
+                var updatedParticipant = existing.Participant with
+                {
+                    HashedCid = isLightfinder ? hashedCid : null,
+                    IsLightfinder = isLightfinder
+                };
+
+                var updatedEntry = existing with
+                {
+                    Participant = updatedParticipant,
+                    UpdatedAt = DateTime.UtcNow
+                };
+
+                entries[key] = updatedEntry;
+
+                if (_participantsByChannel.TryGetValue(key, out var participants))
+                {
+                    participants[updatedParticipant.Token] = updatedParticipant;
+                }
+            }
+        }
+    }
+
+    private ChatPresenceEntry? UpdatePresence(
+        string userUid,
+        ChatChannelDescriptor descriptor,
+        string displayName,
+        ChatParticipantInfo participant,
+        bool isActive,
+        bool replaceExistingOfSameType)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(userUid);
+
+        var normalizedDescriptor = descriptor.WithNormalizedCustomKey();
+        var key = ChannelKey.FromDescriptor(normalizedDescriptor);
+
+        lock (_syncRoot)
+        {
+            if (!_presenceByUser.TryGetValue(userUid, out var entries))
+            {
+                if (!isActive)
+                    return null;
+
+                entries = new Dictionary<ChannelKey, ChatPresenceEntry>();
+                _presenceByUser[userUid] = entries;
+            }
+
+            string? reusableToken = null;
+
+            if (entries.TryGetValue(key, out var existing))
+            {
+                reusableToken = existing.Participant.Token;
+                RemovePresenceInternal(userUid, entries, key);
+            }
+
+            if (replaceExistingOfSameType)
+            {
+                foreach (var candidate in entries.Keys.Where(k => k.Type == key.Type).ToList())
+                {
+                    if (entries.TryGetValue(candidate, out var entry))
+                    {
+                        reusableToken ??= entry.Participant.Token;
+                    }
+
+                    RemovePresenceInternal(userUid, entries, candidate);
+                }
+
+                if (!isActive)
+                {
+                    if (entries.Count == 0)
+                    {
+                        _presenceByUser.Remove(userUid);
+                    }
+
+                    _logger.LogDebug("Chat presence cleared for {User} ({Type})", userUid, normalizedDescriptor.Type);
+                    return null;
+                }
+            }
+            else if (!isActive)
+            {
+                var removed = RemovePresenceInternal(userUid, entries, key);
+                if (removed)
+                {
+                    _logger.LogDebug("Chat presence removed for {User} from {Channel}", userUid, Describe(key));
+                }
+
+                if (entries.Count == 0)
+                {
+                    _presenceByUser.Remove(userUid);
+                }
+
+                return null;
+            }
+
+            var token = !string.IsNullOrEmpty(participant.Token)
+                ? participant.Token
+                : reusableToken ?? GenerateToken();
+
+            var finalParticipant = participant with { Token = token };
+            var entryToStore = new ChatPresenceEntry(
+                normalizedDescriptor,
+                key,
+                displayName,
+                finalParticipant,
+                DateTime.UtcNow);
+
+            entries[key] = entryToStore;
+
+            if (!_membersByChannel.TryGetValue(key, out var members))
+            {
+                members = new HashSet<string>(StringComparer.Ordinal);
+                _membersByChannel[key] = members;
+            }
+
+            members.Add(userUid);
+
+            if (!_participantsByChannel.TryGetValue(key, out var participantsByToken))
+            {
+                participantsByToken = new Dictionary<string, ChatParticipantInfo>(StringComparer.Ordinal);
+                _participantsByChannel[key] = participantsByToken;
+            }
+
+            participantsByToken[token] = finalParticipant;
+
+            ApplyUIDMuteIfPresent(normalizedDescriptor, finalParticipant);
+
+            _logger.LogDebug("Chat presence updated for {User} in {Channel}", userUid, Describe(key));
+            return entryToStore;
+        }
+    }
+
+    private bool RemovePresenceInternal(string userUid, Dictionary<ChannelKey, ChatPresenceEntry> entries, ChannelKey key)
+    {
+        if (!entries.TryGetValue(key, out var existing))
+        {
+            return false;
+        }
+
+        entries.Remove(key);
+
+        if (_membersByChannel.TryGetValue(key, out var members))
+        {
+            members.Remove(userUid);
+            if (members.Count == 0)
+            {
+                _membersByChannel.Remove(key);
+                // Preserve message history even when a channel becomes empty so moderation can still resolve reports.
+            }
+        }
+
+        if (_participantsByChannel.TryGetValue(key, out var participants))
+        {
+            participants.Remove(existing.Participant.Token);
+            if (participants.Count == 0)
+            {
+                _participantsByChannel.Remove(key);
+            }
+        }
+
+        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];
+        RandomNumberGenerator.Fill(buffer);
+        return Convert.ToHexString(buffer);
+    }
+
+    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/ImageCheckService.cs

@@ -0,0 +1,105 @@
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+
+namespace LightlessSyncServer.Services
+{
+    public class ImageCheckService
+    {
+        private static readonly int _imageWidthAvatar = 512;
+        private static readonly int _imageHeightAvatar = 512;
+        private static readonly int _imageWidthBanner = 840;
+        private static readonly int _imageHeightBanner = 260;
+        private static readonly int _imageSize = 2000;
+
+        public class ImageLoadResult
+        {
+            public bool Success { get; init; }
+            public string? Base64Image { get; init; }
+            public string? ErrorMessage { get; init; }
+
+            public static ImageLoadResult Fail(string message) => new()
+            {
+                Success = false,
+                ErrorMessage = message,
+            };
+
+            public static ImageLoadResult Ok(string base64) => new()
+            {
+                Success = true,
+                Base64Image = base64,
+            };
+        }
+
+
+        public static async Task<ImageLoadResult> ValidateImageAsync(string base64String, bool banner, CancellationToken token)
+        {
+            if (token.IsCancellationRequested)
+                return ImageLoadResult.Fail("Operation cancelled.");
+
+            byte[] imageData;
+            try
+            {
+                imageData = Convert.FromBase64String(base64String);
+            }
+            catch (FormatException)
+            {
+                return ImageLoadResult.Fail("The provided image is not a valid Base64 string.");
+            }
+
+            Image<Rgba32>? image = null;
+            bool imageLoaded = false;
+            IImageFormat? format = null;
+
+            try
+            {
+                using (var ms = new MemoryStream(imageData))
+                {
+                    format = await Image.DetectFormatAsync(ms, token).ConfigureAwait(false);
+                }
+
+                if (format == null)
+                {
+                    return ImageLoadResult.Fail("Unable to detect image format.");
+                }
+
+                using (image = Image.Load<Rgba32>(imageData))
+                {
+                    imageLoaded = true;
+
+                    int maxWidth = banner ? _imageWidthBanner : _imageWidthAvatar;
+                    int maxHeight = banner ? _imageHeightBanner : _imageHeightAvatar;
+
+                    if (image.Width > maxWidth || image.Height > maxHeight)
+                    {
+                        var ratio = Math.Min((double)maxWidth / image.Width, (double)maxHeight / image.Height);
+                        int newWidth = (int)(image.Width * ratio);
+                        int newHeight = (int)(image.Height * ratio);
+
+                        image.Mutate(x => x.Resize(newWidth, newHeight));
+                    }
+
+                    using var memoryStream = new MemoryStream();
+
+                    await image.SaveAsPngAsync(memoryStream, token).ConfigureAwait(false);
+
+                    if (memoryStream.Length > _imageSize * 1024)
+                    {
+                        return ImageLoadResult.Fail("Your image exceeds 2 MiB after resizing/conversion.");
+                    }
+
+                    string base64Png = Convert.ToBase64String(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
+                    return ImageLoadResult.Ok(base64Png);
+                }
+            }
+            catch
+            {
+                if (imageLoaded)
+                    image?.Dispose();
+
+                return ImageLoadResult.Fail("Failed to load or process the image. It may be corrupted or unsupported.");
+            }
+        }
+    }
+}

LightlessSyncServer/LightlessSyncServer/Services/Interfaces/IPruneService.cs

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -1,6 +1,7 @@
 using LightlessSync.API.Dto;
 using LightlessSync.API.SignalR;
 using LightlessSyncServer.Hubs;
+using LightlessSyncServer.Models;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.Services;
@@ -52,6 +53,13 @@ public sealed class SystemInfoService : BackgroundService
                 _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeAvailableIOWorkerThreads, ioThreads);
 
                 var onlineUsers = (_redis.SearchKeysAsync("UID:*").GetAwaiter().GetResult()).Count();
+
+                var allLightfinderKeys = _redis.SearchKeysAsync("broadcast:*").GetAwaiter().GetResult().Where(c => !c.Contains("owner", StringComparison.Ordinal)).ToHashSet(StringComparer.Ordinal);
+                var allLightfinderItems = _redis.GetAllAsync<BroadcastRedisEntry>(allLightfinderKeys).GetAwaiter().GetResult();
+
+                var countLightFinderUsers = allLightfinderItems.Count;
+                var countLightFinderSyncshells = allLightfinderItems.Count(static l => !string.IsNullOrEmpty(l.Value.GID));
+
                 SystemInfoDto = new SystemInfoDto()
                 {
                     OnlineUsers = onlineUsers,
@@ -64,12 +72,16 @@ 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().Where(p => p.IsPaused).Count());
+                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairsPaused, db.Permissions.AsNoTracking().Count(p => p.IsPaused));
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroups, db.Groups.AsNoTracking().Count());
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroupPairs, db.GroupPairs.AsNoTracking().Count());
+                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeLightFinderGroups, countLightFinderSyncshells);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeUsersRegistered, db.Users.AsNoTracking().Count());
                 }
 

LightlessSyncServer/LightlessSyncServer/Startup.cs

@@ -1,10 +1,13 @@
 using AspNetCoreRateLimit;
+using LightlessSync.API.Data;
+using LightlessSync.API.Dto.Group;
 using LightlessSync.API.SignalR;
-using LightlessSyncAuthService.Controllers;
-using LightlessSyncServer.Controllers;
 using LightlessSyncServer.Configuration;
+using LightlessSyncServer.Controllers;
 using LightlessSyncServer.Hubs;
 using LightlessSyncServer.Services;
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncServer.Worker;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.RequirementHandlers;
@@ -19,6 +22,7 @@ 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;
@@ -73,7 +77,7 @@ public class Startup
             a.FeatureProviders.Remove(a.FeatureProviders.OfType<ControllerFeatureProvider>().First());
             if (lightlessConfig.GetValue<Uri>(nameof(ServerConfiguration.MainServerAddress), defaultValue: null) == null)
             {
-                a.FeatureProviders.Add(new AllowedControllersFeatureProvider(typeof(LightlessServerConfigurationController), typeof(LightlessBaseConfigurationController), typeof(ClientMessageController), typeof(UserController)));
+                a.FeatureProviders.Add(new AllowedControllersFeatureProvider(typeof(LightlessServerConfigurationController), typeof(LightlessBaseConfigurationController), typeof(ClientMessageController), typeof(UserController), typeof(GroupController)));
             }
             else
             {
@@ -89,11 +93,13 @@ 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>();
         services.AddSingleton<SystemInfoService>();
         services.AddSingleton<OnlineSyncedPairCacheService>();
+        services.AddSingleton<ChatChannelService>();
         services.AddHostedService(provider => provider.GetService<SystemInfoService>());
         // configure services based on main server status
         ConfigureServicesBasedOnShardType(services, lightlessConfig, isMainServer);
@@ -109,9 +115,12 @@ 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>());
     }
 
@@ -120,6 +129,8 @@ 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;
@@ -131,21 +142,10 @@ public class Startup
             hubOptions.AddFilter<ConcurrencyFilter>();
         }).AddMessagePackProtocol(opt =>
         {
-            var resolver = CompositeResolver.Create(StandardResolverAllowPrivate.Instance,
+            opt.SerializerOptions = msgpackOptions;
-                BuiltinResolver.Instance,
-                AttributeFormatterResolver.Instance,
-                // replace enum resolver
-                DynamicEnumAsStringResolver.Instance,
-                DynamicGenericResolver.Instance,
-                DynamicUnionResolver.Instance,
-                DynamicObjectResolver.Instance,
-                PrimitiveObjectResolver.Instance,
-                // final fallback(last priority)
-                StandardResolver.Instance);
 
-            opt.SerializerOptions = MessagePackSerializerOptions.Standard
+            var dummy = new GroupPruneSettingsDto(new GroupData("TEST-GID", null), true, 14);
-                .WithCompression(MessagePackCompression.Lz4Block)
+            MessagePackSerializer.Serialize(dummy, msgpackOptions);
-                .WithResolver(resolver);
         });
 
 
@@ -166,7 +166,7 @@ public class Startup
             KeyPrefix = "",
             Hosts = new RedisHost[]
             {
-                new RedisHost(){ Host = address, Port = port },
+                new(){ Host = address, Port = port },
             },
             AllowAdmin = true,
             ConnectTimeout = options.ConnectTimeout,
@@ -292,9 +292,12 @@ 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,
@@ -310,7 +313,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

@@ -0,0 +1,26 @@
+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

@@ -1,6 +1,8 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
+using LightlessSync.API.Dto.Group;
+using LightlessSync.API.Dto.User;
 using LightlessSyncShared.Models;
 using static LightlessSyncServer.Hubs.LightlessHub;
 
@@ -8,18 +10,97 @@ namespace LightlessSyncServer.Utils;
 
 public static class Extensions
 {
+    public static void UpdateProfileFromDto(this GroupProfile profile, GroupProfileDto dto, string? base64PictureString = null, string? base64BannerString = null)
+    {
+        ArgumentNullException.ThrowIfNull(profile);
+        ArgumentNullException.ThrowIfNull(dto);
+
+        if (profile == null || dto == null) return;
+
+        if (base64PictureString != null) profile.Base64GroupProfileImage = base64PictureString;
+        if (base64BannerString != null) profile.Base64GroupBannerImage = base64BannerString;
+        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)
+    {
+        ArgumentNullException.ThrowIfNull(profile);
+        ArgumentNullException.ThrowIfNull(dto);
+
+        if (profile == null || dto == null) return;
+
+        if (base64PictureString != null) profile.Base64ProfileImage = base64PictureString;
+        if (base64BannerString != null) profile.Base64BannerImage = base64BannerString;
+        if (dto.Tags != null) profile.Tags = dto.Tags;
+        if (dto.Description != null) profile.UserDescription = dto.Description;
+        if (dto.IsNSFW.HasValue) profile.IsNSFW = dto.IsNSFW.Value;
+    }
+
+    public static GroupProfileDto ToDTO(this GroupProfile groupProfile)
+    {
+        if (groupProfile == null)
+        {
+            return new GroupProfileDto(Group: null, Description: null, Tags: null, PictureBase64: null, BannerBase64: null, IsNsfw: false, IsDisabled: false);
+        }
+
+        var groupData = groupProfile.Group?.ToGroupData()
+            ?? (!string.IsNullOrWhiteSpace(groupProfile.GroupGID) ? new GroupData(groupProfile.GroupGID) : null);
+
+        return new GroupProfileDto(
+            groupData,
+            groupProfile.Description,
+            groupProfile.Tags,
+            groupProfile.Base64GroupProfileImage,
+            groupProfile.Base64GroupBannerImage,
+            groupProfile.IsNSFW,
+            groupProfile.ProfileDisabled
+        );
+    }
+
+    public static UserProfileDto ToDTO(this UserProfileData userProfileData)
+    {
+        if (userProfileData == null)
+        {
+            return new UserProfileDto(User: null, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: null, Tags: []);
+        }
+
+        var userData = userProfileData.User?.ToUserData();
+
+        return new UserProfileDto(
+            userData,
+            userProfileData.ProfileDisabled,
+            userProfileData.IsNSFW,
+            userProfileData.Base64ProfileImage,
+            userProfileData.Base64BannerImage,
+            userProfileData.UserDescription,
+            userProfileData.Tags
+        );
+    }
+
     public static GroupData ToGroupData(this Group group)
     {
+        if (group == null)
+            return null;
+
         return new GroupData(group.GID, group.Alias, group.CreatedDate);
     }
 
     public static UserData ToUserData(this GroupPair pair)
     {
+        if (pair == null)
+            return null;
+
         return new UserData(pair.GroupUser.UID, pair.GroupUser.Alias);
     }
 
     public static UserData ToUserData(this User user)
     {
+        if (user == null)
+            return null;
+
         return new UserData(user.UID, user.Alias);
     }
 
@@ -37,6 +118,7 @@ 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

@@ -1,5 +1,4 @@
-using LightlessSync.API.SignalR;
+using LightlessSyncServer.Hubs;
-using LightlessSyncServer.Hubs;
 using System.Runtime.CompilerServices;
 
 namespace LightlessSyncServer.Utils;
@@ -31,4 +30,14 @@ 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

@@ -0,0 +1,68 @@
+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,6 +7,7 @@
       "Default": "Information",
       "Microsoft": "Warning",
       "Microsoft.Hosting.Lifetime": "Information",
+      "Microsoft.EntityFrameworkCore.Database.Command": "Warning",
       "LightlessSyncServer.Authentication": "Warning",
       "System.IO.IOException": "Warning"
     },
@@ -36,7 +37,12 @@
     "NotifyOwnerOnPairRequest": true,
     "EnableBroadcasting": true,
     "EnableSyncshellBroadcastPayloads": true,
-    "PairRequestNotificationTemplate": "{DisplayName} sent you a pair request. To accept, right-click them, open the context menu, and send a request back."
+    "PairRequestNotificationTemplate": "{DisplayName} sent you a pair request. To accept, right-click them, open the context menu, and send a request back.",
+    "PairRequestRateLimit": 5,
+    "PairRequestRateWindow": 60
+  },
+  "ChatZoneOverrides": {
+    "Zones": []
   },
   "AllowedHosts": "*",
   "Kestrel": {

LightlessSyncServer/LightlessSyncServices/Discord/DiscordBot.cs

@@ -1,3 +1,6 @@
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
 using Discord;
 using Discord.Interactions;
 using Discord.Rest;
@@ -5,6 +8,7 @@ using Discord.WebSocket;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Models;
 using LightlessSyncShared.Services;
+using LightlessSync.API.Dto.Chat;
 using LightlessSyncShared.Utils.Configuration;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis;
@@ -13,6 +17,12 @@ namespace LightlessSyncServices.Discord;
 
 internal class DiscordBot : IHostedService
 {
+    private static readonly JsonSerializerOptions ChatReportSerializerOptions = new(JsonSerializerDefaults.General)
+    {
+        PropertyNameCaseInsensitive = true
+    };
+    private const string ChatReportButtonPrefix = "lightless-chat-report-button";
+
     private readonly DiscordBotServices _botServices;
     private readonly IConfigurationService<ServicesConfiguration> _configurationService;
     private readonly IConnectionMultiplexer _connectionMultiplexer;
@@ -21,7 +31,7 @@ internal class DiscordBot : IHostedService
     private readonly IDbContextFactory<LightlessDbContext> _dbContextFactory;
     private readonly IServiceProvider _services;
     private InteractionService _interactionModule;
-    private readonly CancellationTokenSource? _processReportQueueCts;
+    private CancellationTokenSource? _chatReportProcessingCts;
     private CancellationTokenSource? _clientConnectedCts;
 
     public DiscordBot(DiscordBotServices botServices, IServiceProvider services, IConfigurationService<ServicesConfiguration> configuration,
@@ -66,6 +76,7 @@ internal class DiscordBot : IHostedService
                 var ctx = new SocketInteractionContext(_discordClient, x);
                 await _interactionModule.ExecuteCommandAsync(ctx, _services).ConfigureAwait(false);
             };
+            _discordClient.ButtonExecuted += OnChatReportButton;
             _discordClient.UserJoined += OnUserJoined;
 
             await _botServices.Start().ConfigureAwait(false);
@@ -94,9 +105,11 @@ internal class DiscordBot : IHostedService
         if (!string.IsNullOrEmpty(_configurationService.GetValueOrDefault(nameof(ServicesConfiguration.DiscordBotToken), string.Empty)))
         {
             await _botServices.Stop().ConfigureAwait(false);
-            _processReportQueueCts?.Cancel();
+            _chatReportProcessingCts?.Cancel();
+            _chatReportProcessingCts?.Dispose();
             _clientConnectedCts?.Cancel();
 
+            _discordClient.ButtonExecuted -= OnChatReportButton;
             await _discordClient.LogoutAsync().ConfigureAwait(false);
             await _discordClient.StopAsync().ConfigureAwait(false);
             _interactionModule?.Dispose();
@@ -112,6 +125,13 @@ internal class DiscordBot : IHostedService
         _clientConnectedCts = new();
         _ = UpdateStatusAsync(_clientConnectedCts.Token);
 
+        _chatReportProcessingCts?.Cancel();
+        _chatReportProcessingCts?.Dispose();
+        _chatReportProcessingCts = new();
+        _ = PollChatReportsAsync(_chatReportProcessingCts.Token);
+
+        await PublishChatReportsAsync(CancellationToken.None).ConfigureAwait(false);
+
         await CreateOrUpdateModal(guild).ConfigureAwait(false);
         _botServices.UpdateGuild(guild);
         await _botServices.LogToChannel("Bot startup complete.").ConfigureAwait(false);
@@ -120,6 +140,358 @@ internal class DiscordBot : IHostedService
         _ = RemoveUnregisteredUsers(_clientConnectedCts.Token);
     }
 
+    private async Task PollChatReportsAsync(CancellationToken token)
+    {
+        while (!token.IsCancellationRequested)
+        {
+            try
+            {
+                await PublishChatReportsAsync(token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed while polling chat reports");
+            }
+
+            try
+            {
+                await Task.Delay(TimeSpan.FromMinutes(1), token).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+        }
+    }
+
+    private async Task PublishChatReportsAsync(CancellationToken token)
+    {
+        var reportChannelId = _configurationService.GetValueOrDefault(nameof(ServicesConfiguration.DiscordChannelForChatReports), (ulong?)null);
+        if (reportChannelId is null)
+        {
+            return;
+        }
+
+        var channel = await _discordClient.Rest.GetChannelAsync(reportChannelId.Value).ConfigureAwait(false) as RestTextChannel;
+        if (channel is null)
+        {
+            _logger.LogWarning("Configured chat report channel {ChannelId} could not be resolved.", reportChannelId);
+            return;
+        }
+
+        using var dbContext = await _dbContextFactory.CreateDbContextAsync(token).ConfigureAwait(false);
+        var pendingReports = await dbContext.ReportedChatMessages
+            .Where(r => !r.Resolved && r.DiscordMessageId == null)
+            .OrderBy(r => r.ReportTimeUtc)
+            .Take(10)
+            .ToListAsync(token)
+            .ConfigureAwait(false);
+
+        if (pendingReports.Count == 0)
+        {
+            return;
+        }
+
+        foreach (var report in pendingReports)
+        {
+            var embed = await BuildChatReportEmbedAsync(dbContext, report, token).ConfigureAwait(false);
+
+            var components = new ComponentBuilder()
+                .WithButton("Resolve", $"{ChatReportButtonPrefix}-resolve-{report.ReportId}", ButtonStyle.Danger)
+                .WithButton("Dismiss", $"{ChatReportButtonPrefix}-dismiss-{report.ReportId}", ButtonStyle.Secondary)
+                .WithButton("Ban From Chat", $"{ChatReportButtonPrefix}-banchat-{report.ReportId}", ButtonStyle.Danger);
+
+            var postedMessage = await channel.SendMessageAsync(embed: embed.Build(), components: components.Build()).ConfigureAwait(false);
+
+            report.DiscordMessageId = postedMessage.Id;
+            report.DiscordMessagePostedAtUtc = DateTime.UtcNow;
+        }
+
+        await dbContext.SaveChangesAsync(token).ConfigureAwait(false);
+    }
+
+    private async Task<EmbedBuilder> BuildChatReportEmbedAsync(LightlessDbContext dbContext, ReportedChatMessage report, CancellationToken token)
+    {
+        var reporter = await FormatUserForEmbedAsync(dbContext, report.ReporterUserUid, token).ConfigureAwait(false);
+        var reportedUser = await FormatUserForEmbedAsync(dbContext, report.ReportedUserUid, token).ConfigureAwait(false);
+        var channelDescription = await DescribeChannelAsync(dbContext, report, token).ConfigureAwait(false);
+
+        var embed = new EmbedBuilder()
+            .WithTitle("Chat Report")
+            .WithColor(Color.DarkTeal)
+            .WithTimestamp(report.ReportTimeUtc)
+            .AddField("Report ID", report.ReportId, inline: true)
+            .AddField("Reporter", reporter, inline: true)
+            .AddField("Reported User", string.IsNullOrEmpty(reportedUser) ? "-" : reportedUser, inline: true)
+            .AddField("Channel", channelDescription, inline: false)
+            .AddField("Reason", string.IsNullOrWhiteSpace(report.Reason) ? "-" : report.Reason);
+
+        if (!string.IsNullOrWhiteSpace(report.AdditionalContext))
+        {
+            embed.AddField("Additional Context", report.AdditionalContext);
+        }
+
+        embed.AddField("Message", $"```{Truncate(report.MessageContent, 1000)}```");
+
+        var snapshotPreview = BuildSnapshotPreview(report.SnapshotJson);
+        if (!string.IsNullOrEmpty(snapshotPreview))
+        {
+            embed.AddField("Recent Activity", snapshotPreview);
+        }
+
+        embed.WithFooter($"Message ID: {report.MessageId}");
+
+        return embed;
+    }
+
+    private async Task<string> DescribeChannelAsync(LightlessDbContext dbContext, ReportedChatMessage report, CancellationToken token)
+    {
+        if (report.ChannelType == ChatChannelType.Group)
+        {
+            if (!string.IsNullOrEmpty(report.ChannelKey))
+            {
+                var group = await dbContext.Groups.AsNoTracking()
+                    .SingleOrDefaultAsync(g => g.GID == report.ChannelKey, token)
+                    .ConfigureAwait(false);
+                if (group != null)
+                {
+                    var name = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;
+                    return $"Group: {name} ({group.GID})";
+                }
+            }
+
+            return $"Group: {report.ChannelKey ?? "unknown"}";
+        }
+
+        return $"Zone: {report.ChannelKey ?? "unknown"} (World {report.WorldId}, Zone {report.ZoneId})";
+    }
+
+    private async Task<string> FormatUserForEmbedAsync(LightlessDbContext dbContext, string? userUid, CancellationToken token)
+    {
+        if (string.IsNullOrEmpty(userUid))
+        {
+            return "-";
+        }
+
+        var user = await dbContext.Users.AsNoTracking()
+            .SingleOrDefaultAsync(u => u.UID == userUid, token)
+            .ConfigureAwait(false);
+
+        var display = user?.Alias ?? user?.UID ?? userUid;
+
+        var lodestone = await dbContext.LodeStoneAuth
+            .Include(l => l.User)
+            .AsNoTracking()
+            .SingleOrDefaultAsync(l => l.User != null && l.User.UID == userUid, token)
+            .ConfigureAwait(false);
+
+        if (lodestone != null)
+        {
+            display = $"{display} (<@{lodestone.DiscordId}>)";
+        }
+
+        return display;
+    }
+
+    private string BuildSnapshotPreview(string snapshotJson)
+    {
+        if (string.IsNullOrWhiteSpace(snapshotJson))
+        {
+            return string.Empty;
+        }
+
+        try
+        {
+            var snapshot = JsonSerializer.Deserialize<List<ChatReportSnapshotItem>>(snapshotJson, ChatReportSerializerOptions);
+            if (snapshot is null || snapshot.Count == 0)
+            {
+                return string.Empty;
+            }
+
+            var builder = new StringBuilder();
+            foreach (var item in snapshot.TakeLast(5))
+            {
+                var sender = item.SenderAlias ?? item.SenderUserUid;
+                builder.AppendLine($"{item.SentAtUtc:HH\\:mm} {sender}: {Truncate(item.Message, 120)}");
+            }
+
+            return $"```{builder.ToString().TrimEnd()}```";
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to parse chat report snapshot");
+            return string.Empty;
+        }
+    }
+
+    private static string Truncate(string value, int maxLength)
+    {
+        if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
+        {
+            return value;
+        }
+
+        return value[..maxLength] + "...";
+    }
+
+    private async Task OnChatReportButton(SocketMessageComponent arg)
+    {
+        if (!arg.Data.CustomId.StartsWith(ChatReportButtonPrefix, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        if (arg.GuildId is null)
+        {
+            await arg.RespondAsync("This action is only available inside the server.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var guild = _discordClient.GetGuild(arg.GuildId.Value);
+        if (guild is null)
+        {
+            await arg.RespondAsync("Unable to resolve the guild for this interaction.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var guildUser = guild.GetUser(arg.User.Id);
+        if (guildUser is null || !(guildUser.GuildPermissions.ManageMessages || guildUser.GuildPermissions.BanMembers || guildUser.GuildPermissions.Administrator))
+        {
+            await arg.RespondAsync("You do not have permission to resolve chat reports.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var parts = arg.Data.CustomId.Split('-', StringSplitOptions.RemoveEmptyEntries);
+        if (parts.Length < 5 || !int.TryParse(parts[^1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var reportId))
+        {
+            await arg.RespondAsync("Invalid report action.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        var action = parts[^2];
+
+        await using var dbContext = await _dbContextFactory.CreateDbContextAsync().ConfigureAwait(false);
+        var report = await dbContext.ReportedChatMessages.SingleOrDefaultAsync(r => r.ReportId == reportId).ConfigureAwait(false);
+        if (report is null)
+        {
+            await arg.RespondAsync("This report could not be found.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        if (report.Resolved)
+        {
+            await arg.RespondAsync("This report has already been processed.", ephemeral: true).ConfigureAwait(false);
+            return;
+        }
+
+        string resolutionLabel;
+        switch (action)
+        {
+            case "resolve":
+                resolutionLabel = "Resolved";
+                break;
+            case "dismiss":
+                resolutionLabel = "Dismissed";
+                break;
+            case "banchat":
+                resolutionLabel = "Chat access revoked";
+                if (!string.IsNullOrEmpty(report.ReportedUserUid))
+                {
+                    var targetUser = await dbContext.Users.SingleOrDefaultAsync(u => u.UID == report.ReportedUserUid).ConfigureAwait(false);
+                    if (targetUser is not null && !targetUser.ChatBanned)
+                    {
+                        targetUser.ChatBanned = true;
+                        dbContext.Update(targetUser);
+                    }
+                }
+                break;
+            default:
+                await arg.RespondAsync("Unknown action.", ephemeral: true).ConfigureAwait(false);
+                return;
+        }
+
+        try
+        {
+            await UpdateChatReportMessageAsync(report, action, guildUser).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to update Discord message for resolved report {ReportId}", report.ReportId);
+        }
+
+        dbContext.ReportedChatMessages.Remove(report);
+        await dbContext.SaveChangesAsync().ConfigureAwait(false);
+
+        string responseText = action switch
+        {
+            "resolve" => "resolved",
+            "dismiss" => "dismissed",
+            "banchat" => "chat access revoked",
+            _ => "processed"
+        };
+
+        await arg.RespondAsync($"Report {report.ReportId} {responseText}.", ephemeral: true).ConfigureAwait(false);
+    }
+
+    private async Task UpdateChatReportMessageAsync(ReportedChatMessage report, string action, SocketGuildUser moderator)
+    {
+        if (report.DiscordMessageId is null)
+        {
+            return;
+        }
+
+        var reportChannelId = _configurationService.GetValueOrDefault(nameof(ServicesConfiguration.DiscordChannelForChatReports), (ulong?)null);
+        if (reportChannelId is null)
+        {
+            return;
+        }
+
+        var channel = await _discordClient.Rest.GetChannelAsync(reportChannelId.Value).ConfigureAwait(false) as RestTextChannel;
+        if (channel is null)
+        {
+            return;
+        }
+
+        var message = await channel.GetMessageAsync(report.DiscordMessageId.Value).ConfigureAwait(false) as IUserMessage;
+        if (message is null)
+        {
+            return;
+        }
+
+        var existingEmbed = message.Embeds.FirstOrDefault();
+        var embedBuilder = existingEmbed is Embed richEmbed
+            ? richEmbed.ToEmbedBuilder()
+            : new EmbedBuilder().WithTitle("Chat Report");
+
+        embedBuilder.Fields.RemoveAll(f => string.Equals(f.Name, "Resolution", StringComparison.OrdinalIgnoreCase));
+        var resolutionText = action switch
+        {
+            "resolve" => "Resolved",
+            "dismiss" => "Dismissed",
+            "banchat" => "Chat access revoked",
+            _ => "Processed"
+        };
+        var resolutionColor = action switch
+        {
+            "resolve" => Color.DarkRed,
+            "dismiss" => Color.Green,
+            "banchat" => Color.DarkRed,
+            _ => Color.LightGrey
+        };
+        embedBuilder.AddField("Resolution", $"{resolutionText} by {moderator.Mention} at <t:{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}:F>");
+        embedBuilder.WithColor(resolutionColor);
+
+        await message.ModifyAsync(props =>
+        {
+            props.Embed = embedBuilder.Build();
+            props.Components = new ComponentBuilder().Build();
+        }).ConfigureAwait(false);
+    }
+
     private async Task UpdateVanityRoles(RestGuild guild, CancellationToken token)
     {
         while (!token.IsCancellationRequested)
@@ -488,16 +860,26 @@ internal class DiscordBot : IHostedService
         }
     }
 
-    private async Task UpdateStatusAsync(CancellationToken token)
+    private sealed record ChatReportSnapshotItem(
+        string MessageId,
+        DateTime SentAtUtc,
+        string SenderUserUid,
+        string? SenderAlias,
+        bool SenderIsLightfinder,
+        string? SenderHashedCid,
+        string Message);
+
+    private async Task UpdateStatusAsync(CancellationToken cancellationToken)
     {
-        while (!token.IsCancellationRequested)
+        while (!cancellationToken.IsCancellationRequested)
         {
             var endPoint = _connectionMultiplexer.GetEndPoints().First();
-            var onlineUsers = await _connectionMultiplexer.GetServer(endPoint).KeysAsync(pattern: "UID:*").CountAsync().ConfigureAwait(false);
+            var keys = _connectionMultiplexer.GetServer(endPoint).KeysAsync(pattern: "UID:*");
+            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)).ConfigureAwait(false);
+            await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken).ConfigureAwait(false);
         }
     }
 }

LightlessSyncServer/LightlessSyncServices/Discord/LightlessModule.cs

@@ -1,15 +1,17 @@
 using Discord;
 using Discord.Interactions;
+using LightlessSync.API.Data.Enum;
+using LightlessSync.API.Dto.Group;
+using LightlessSync.API.Dto.User;
 using LightlessSyncShared.Data;
+using LightlessSyncShared.Models;
+using LightlessSyncShared.Services;
+using LightlessSyncShared.Utils;
+using LightlessSyncShared.Utils.Configuration;
 using Microsoft.EntityFrameworkCore;
 using Prometheus;
-using LightlessSyncShared.Models;
-using LightlessSyncShared.Utils;
-using LightlessSyncShared.Services;
 using StackExchange.Redis;
-using LightlessSync.API.Data.Enum;
+using System.Net.Http.Json;
-using LightlessSyncShared.Utils.Configuration;
-using LightlessSync.API.Dto.User;
 
 namespace LightlessSyncServices.Discord;
 
@@ -39,11 +41,81 @@ public class LightlessModule : InteractionModuleBase
         _logger.LogInformation("SlashCommand:{userId}:{Method}",
             Context.Interaction.User.Id, nameof(UserInfo));
 
+        try
+        {
+            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);
+
+                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);
+                    
+                    var mainEmbedData = embeds[0];
+                    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(),
+                        ephemeral: true).ConfigureAwait(false);
+                } 
+                else
+                {
+                    await RespondAsync(
+                        embeds: embeds.ToArray(),
+                        ephemeral: true).ConfigureAwait(false);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            EmbedBuilder eb = new();
+            eb.WithTitle("An error occured");
+            eb.WithDescription("Please report this error to bug-reports: " + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine);
+
+            await RespondAsync(embeds: new Embed[] { eb.Build() }, ephemeral: true).ConfigureAwait(false);
+        }
+    }
+
+    [SlashCommand("groupinfo", "Shows you your group profile information")]
+    public async Task GroupInfo([Summary("gid", "ADMIN ONLY: GID to check for")] string? uid = null)
+    {
+        _logger.LogInformation("SlashCommand:{userId}:{Method}",
+            Context.Interaction.User.Id, nameof(GroupInfo));
+
         try
         {
             EmbedBuilder eb = new();
 
-            eb = await HandleUserInfo(eb, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);
+            //eb = await HandleUserInfo(eb, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);
 
             await RespondAsync(embeds: new[] { eb.Build() }, ephemeral: true).ConfigureAwait(false);
         }
@@ -110,10 +182,10 @@ public class LightlessModule : InteractionModuleBase
             var testUri = new Uri(_lightlessServicesConfiguration.GetValue<Uri>
                 (nameof(ServicesConfiguration.MainServerAddress)), "/msgc/sendMessage");
 
-            await c.PostAsJsonAsync(
+            using (await c.PostAsJsonAsync(
                 new Uri(_lightlessServicesConfiguration.GetValue<Uri>(nameof(ServicesConfiguration.MainServerAddress)), "/msgc/sendMessage"),
                 new ClientMessage(messageType, message, uid ?? string.Empty)
-            ).ConfigureAwait(false);
+            ).ConfigureAwait(false)) { }
 
             var discordChannelForMessages = _lightlessServicesConfiguration.GetValueOrDefault<ulong?>(nameof(ServicesConfiguration.DiscordChannelForMessages), null);
             if (uid == null && discordChannelForMessages != null)
@@ -146,20 +218,47 @@ public class LightlessModule : InteractionModuleBase
         }
     }
 
-    [SlashCommand("unbanbydiscord", "ADMIN ONLY: Unban a user by their discord ID")]
+    [SlashCommand("serviceunban", "ADMIN ONLY: Unban a user by their discord ID or user ID [CHOOSE ONE ONLY]")]
-    public async Task UnbanByDiscord([Summary("discord_id", "Discord ID to unban")] string discordId)
+    public async Task ServiceUnban(
+        [Summary("discord_id", "Discord ID to unban")] string? discordId = null,
+        [Summary("uid", "UID to unban")] string? uid = null
+        )
     {
         _logger.LogInformation("SlashCommand:{userId}:{Method}:{params}",
-            Context.Interaction.User.Id, nameof(UnbanByDiscord),
+            Context.Interaction.User.Id, nameof(ServiceUnban),
-            string.Join(",", new[] { $"{nameof(discordId)}:{discordId}" }));
+            string.Join(",", new[] { $"{nameof(discordId)}:{discordId}", $"{nameof(uid)}:{uid}" }));
+
         try
         {
             using HttpClient c = new HttpClient();
 
             c.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _serverTokenGenerator.Token);
-            await c.PostAsJsonAsync(new Uri(_lightlessServicesConfiguration.GetValue<Uri>
+
-                (nameof(ServicesConfiguration.MainServerAddress)), "/user/unbanDiscord"), new UnbanRequest(string.Empty, discordId))
+            string endpoint;
-                .ConfigureAwait(false);
+            UnbanRequest unbanRequest;
+
+            if (!string.IsNullOrEmpty(uid))
+            {
+                endpoint = "/user/unbanUID";
+                unbanRequest = new UnbanRequest(uid, string.Empty);
+            }
+            else if (!string.IsNullOrEmpty(discordId))
+            {
+                endpoint = "/user/unbanDiscord";
+                unbanRequest = new UnbanRequest(string.Empty, discordId);
+            }
+            else
+            {
+                await RespondAsync("You must provide either a UID or Discord ID.", ephemeral: true).ConfigureAwait(false);
+                return;
+            }
+
+            using (await c.PostAsJsonAsync(
+                new Uri(_lightlessServicesConfiguration.GetValue<Uri>(nameof(ServicesConfiguration.MainServerAddress)), endpoint),
+                unbanRequest).ConfigureAwait(false))
+            {
+            }
+
             var discordChannelForMessages = _lightlessServicesConfiguration.GetValueOrDefault<ulong?>(nameof(ServicesConfiguration.DiscordChannelForMessages), null);
             if (discordChannelForMessages != null)
             {
@@ -168,10 +267,12 @@ public class LightlessModule : InteractionModuleBase
                 {
                     var embedColor = Color.Blue;
 
+                    String idToUse = !string.IsNullOrEmpty(uid) ? uid : discordId;
+
                     EmbedBuilder eb = new();
                     eb.WithTitle("Unban Alert!");
                     eb.WithColor(embedColor);
-                    eb.WithDescription(discordId + " has been unbanned");
+                    eb.WithDescription(idToUse + " has been unbanned");
 
                     await discordChannel.SendMessageAsync(embed: eb.Build()).ConfigureAwait(false);
                 }
@@ -188,64 +289,20 @@ public class LightlessModule : InteractionModuleBase
         }
     }
 
-    [SlashCommand("unbanbyuid", "ADMIN ONLY: Unban a user by their uid")]
+    [SlashCommand("serviceban", "ADMIN ONLY: ban a user by their uid")]
-    public async Task UnbanByUID([Summary("uid", "uid to unban")] string uid)
+    public async Task ServiceBan([Summary("uid", "uid to ban")] string uid)
     {
         _logger.LogInformation("SlashCommand:{userId}:{Method}:{params}",
-            Context.Interaction.User.Id, nameof(UnbanByUID),
+            Context.Interaction.User.Id, nameof(ServiceBan),
-            string.Join(",", new[] { $"{nameof(uid)}:{uid}" }));
-        try
-        {
-            using HttpClient c = new HttpClient();
-            var testUri = new Uri(_lightlessServicesConfiguration.GetValue<Uri>
-                (nameof(ServicesConfiguration.MainServerAddress)), "/user/unbanDiscord");
-
-            c.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _serverTokenGenerator.Token);
-            await c.PostAsJsonAsync(new Uri(_lightlessServicesConfiguration.GetValue<Uri>
-                (nameof(ServicesConfiguration.MainServerAddress)), "/user/unbanUID"), new UnbanRequest(uid, string.Empty))
-                .ConfigureAwait(false);
-            var discordChannelForMessages = _lightlessServicesConfiguration.GetValueOrDefault<ulong?>(nameof(ServicesConfiguration.DiscordChannelForMessages), null);
-            if (discordChannelForMessages != null)
-            {
-                var discordChannel = await Context.Guild.GetChannelAsync(discordChannelForMessages.Value).ConfigureAwait(false) as IMessageChannel;
-                if (discordChannel != null)
-                {
-                    var embedColor = Color.Blue;
-
-                    EmbedBuilder eb = new();
-                    eb.WithTitle("Unban Alert!");
-                    eb.WithColor(embedColor);
-                    eb.WithDescription(uid + " has been unbanned");
-
-                    await discordChannel.SendMessageAsync(embed: eb.Build()).ConfigureAwait(false);
-                }
-            }
-
-            await RespondAsync("Message sent", ephemeral: true).ConfigureAwait(false);
-        }
-        catch (Exception ex)
-        {
-            EmbedBuilder eb = new();
-            eb.WithTitle("An error occured");
-            eb.WithDescription("Please report this: " + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine);
-            await RespondAsync(embeds: new Embed[] { eb.Build() }, ephemeral: true).ConfigureAwait(false);
-        }
-    }
-
-    [SlashCommand("markforban", "ADMIN ONLY: ban a user by their uid")]
-    public async Task MarkUidForBan([Summary("uid", "uid to ban")] string uid)
-    {
-        _logger.LogInformation("SlashCommand:{userId}:{Method}:{params}",
-            Context.Interaction.User.Id, nameof(MarkUidForBan),
             string.Join(",", new[] { $"{nameof(uid)}:{uid}" }));
         try
         {
             using HttpClient c = new HttpClient();
 
             c.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _serverTokenGenerator.Token);
-            await c.PostAsJsonAsync(new Uri(_lightlessServicesConfiguration.GetValue<Uri>
+            using (await c.PostAsJsonAsync(new Uri(_lightlessServicesConfiguration.GetValue<Uri>
                 (nameof(ServicesConfiguration.MainServerAddress)), "/user/ban"), new BanRequest(uid))
-                .ConfigureAwait(false);
+                .ConfigureAwait(false)) { }
             var discordChannelForMessages = _lightlessServicesConfiguration.GetValueOrDefault<ulong?>(nameof(ServicesConfiguration.DiscordChannelForMessages), null);
             if (discordChannelForMessages != null)
             {
@@ -274,6 +331,100 @@ public class LightlessModule : InteractionModuleBase
         }
     }
 
+    [SlashCommand("toggleuserprofile", "ADMIN ONLY: disable a user profile by their uid")]
+    public async Task ToggleUserProfile(
+        [Summary("uid", "uid to disable")] string uid,
+        [Summary("toggle", "Enable or Disable the profile")]
+        [Choice("Enable", "Enable")]
+        [Choice("Disable", "Disable")] string toggle
+        )
+    {
+        _logger.LogInformation("SlashCommand:{userId}:{Method}:{params}",
+            Context.Interaction.User.Id, nameof(ToggleUserProfile),
+            string.Join(",", new[] { $"{nameof(uid)}:{uid}" }));
+        try
+        {
+            using HttpClient c = new HttpClient();
+            c.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _serverTokenGenerator.Token);
+            string endpoint = string.Equals(toggle, "Enable", StringComparison.Ordinal) ? "/user/enableProfile" : "/user/disableProfile";
+            using (await c.PostAsJsonAsync(new Uri(_lightlessServicesConfiguration.GetValue<Uri>
+                (nameof(ServicesConfiguration.MainServerAddress)), endpoint), new UserProfileAvailabilityRequest(uid))
+                .ConfigureAwait(false)) { }
+            var discordChannelForMessages = _lightlessServicesConfiguration.GetValueOrDefault<ulong?>(nameof(ServicesConfiguration.DiscordChannelForMessages), null);
+            if (discordChannelForMessages != null)
+            {
+                var discordChannel = await Context.Guild.GetChannelAsync(discordChannelForMessages.Value).ConfigureAwait(false) as IMessageChannel;
+                if (discordChannel != null)
+                {
+                    var embedColor = Color.Blue;
+                    var action = string.Equals(toggle, "Enable", StringComparison.Ordinal) ? "enabled" : "disabled";
+
+                    EmbedBuilder eb = new();
+                    eb.WithTitle($"Profile {action}");
+                    eb.WithColor(embedColor);
+                    eb.WithDescription($"{uid}'s profile has been {action}");
+
+                    await discordChannel.SendMessageAsync(embed: eb.Build()).ConfigureAwait(false);
+                }
+            }
+            await RespondAsync("Message sent", ephemeral: true).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            EmbedBuilder eb = new();
+            eb.WithTitle("An error occured");
+            eb.WithDescription("Please report this: " + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine);
+            await RespondAsync(embeds: new Embed[] { eb.Build() }, ephemeral: true).ConfigureAwait(false);
+        }
+    }
+
+    [SlashCommand("togglegroupprofile", "ADMIN ONLY: toggle a group profile by their gid")]
+    public async Task ToggleGroupProfile(
+        [Summary("gid", "gid to disable")] string gid,
+        [Summary("toggle", "Enable or Disable the profile")]
+        [Choice("Enable", "Enable")]
+        [Choice("Disable", "Disable")] string toggle
+        )
+    {
+        _logger.LogInformation("SlashCommand:{userId}:{Method}:{params}",
+            Context.Interaction.User.Id, nameof(ToggleUserProfile),
+            string.Join(",", new[] { $"{nameof(gid)}:{gid}" }));
+        try
+        {
+            using HttpClient c = new HttpClient();
+            c.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _serverTokenGenerator.Token);
+            string endpoint = string.Equals(toggle, "Enable", StringComparison.Ordinal) ? "/group/enableProfile" : "/group/disableProfile";
+            using (await c.PostAsJsonAsync(new Uri(_lightlessServicesConfiguration.GetValue<Uri>
+                (nameof(ServicesConfiguration.MainServerAddress)), endpoint), new GroupProfileAvailabilityRequest(gid))
+                .ConfigureAwait(false)) { }
+            var discordChannelForMessages = _lightlessServicesConfiguration.GetValueOrDefault<ulong?>(nameof(ServicesConfiguration.DiscordChannelForMessages), null);
+            if (discordChannelForMessages != null)
+            {
+                var discordChannel = await Context.Guild.GetChannelAsync(discordChannelForMessages.Value).ConfigureAwait(false) as IMessageChannel;
+                if (discordChannel != null)
+                {
+                    var embedColor = Color.Blue;
+                    var action = string.Equals(toggle, "Enable", StringComparison.Ordinal) ? "enabled" : "disabled";
+
+                    EmbedBuilder eb = new();
+                    eb.WithTitle($"Profile {action}");
+                    eb.WithColor(embedColor);
+                    eb.WithDescription($"{gid}'s profile has been {action}");
+
+                    await discordChannel.SendMessageAsync(embed: eb.Build()).ConfigureAwait(false);
+                }
+            }
+            await RespondAsync("Message sent", ephemeral: true).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            EmbedBuilder eb = new();
+            eb.WithTitle("An error occured");
+            eb.WithDescription("Please report this: " + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine);
+            await RespondAsync(embeds: new Embed[] { eb.Build() }, ephemeral: true).ConfigureAwait(false);
+        }
+    }
+
     public async Task<Embed> HandleUserAdd(string desiredUid, ulong discordUserId)
     {
         var embed = new EmbedBuilder();
@@ -319,11 +470,9 @@ public class LightlessModule : InteractionModuleBase
         return embed.Build();
     }
 
-    private async Task<EmbedBuilder> HandleUserInfo(EmbedBuilder eb, ulong id, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
+    private async Task<(Embed mainEmbed, Embed? profileEmbed)> HandleUserInfo(LightlessDbContext db, ulong id, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
     {
         bool showForSecondaryUser = secondaryUserUid != null;
-        using var scope = _services.CreateScope();
-        await using var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
 
         var primaryUser = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.DiscordId == id).ConfigureAwait(false);
 
@@ -331,18 +480,20 @@ 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;
+            return (eb.Build(), null);
         }
 
         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;
+            return (eb.Build(), null);
         }
         else if ((optionalUser != null || uid != null) && isAdminCall)
         {
@@ -358,9 +509,10 @@ 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;
+                return (eb.Build(), null);
             }
 
             userToCheckForDiscordId = userInDb.DiscordId;
@@ -373,57 +525,131 @@ 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;
+                return (eb.Build(), null);
             }
         }
 
         var auth = await db.Auth.Include(u => u.PrimaryUser).SingleOrDefaultAsync(u => u.UserUID == dbUser.UID).ConfigureAwait(false);
         var groups = await db.Groups.Where(g => g.OwnerUID == dbUser.UID).ToListAsync().ConfigureAwait(false);
         var groupsJoined = await db.GroupPairs.Where(g => g.GroupUserUID == dbUser.UID).ToListAsync().ConfigureAwait(false);
+        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);
 
-        eb.WithTitle("User Information");
+        EmbedBuilder mainEmbed = new();
-        eb.WithDescription("This is the user information for Discord User <@" + userToCheckForDiscordId + ">" + Environment.NewLine + Environment.NewLine
+        mainEmbed.WithTitle("User Information");
+        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.");
-        eb.AddField("UID", dbUser.UID);
+        mainEmbed.AddField("UID", dbUser.UID);
         if (!string.IsNullOrEmpty(dbUser.Alias))
         {
-            eb.AddField("Vanity UID", dbUser.Alias);
+            mainEmbed.AddField("Vanity UID", dbUser.Alias);
         }
         if (showForSecondaryUser)
         {
-            eb.AddField("Primary UID for " + dbUser.UID, auth.PrimaryUserUID);
+            mainEmbed.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())
             {
-                eb.AddField("Secondary UIDs", string.Join(Environment.NewLine, secondaryUIDs));
+                mainEmbed.AddField("Secondary UIDs", string.Join(Environment.NewLine, secondaryUIDs));
             }
         }
-        eb.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
+        mainEmbed.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
-        eb.AddField("Currently online ", !string.IsNullOrEmpty(identity));
+        mainEmbed.AddField("Currently online ", !string.IsNullOrEmpty(identity));
-        eb.AddField("Hashed Secret Key", auth.HashedKey);
+        mainEmbed.AddField("Hashed Secret Key", auth.HashedKey);
-        eb.AddField("Joined Syncshells", groupsJoined.Count);
+        mainEmbed.AddField("Joined Syncshells", groupsJoined.Count);
-        eb.AddField("Owned Syncshells", groups.Count);
+        mainEmbed.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))
             {
-                eb.AddField("Owned Syncshell " + group.GID + " Vanity ID", group.Alias);
+                mainEmbed.AddField("Owned Syncshell " + group.GID + " Vanity ID", group.Alias);
             }
-            eb.AddField("Owned Syncshell " + group.GID + " User Count", syncShellUserCount);
+            mainEmbed.AddField("Owned Syncshell " + group.GID + " User Count", syncShellUserCount);
         }
 
         if (isAdminCall && !string.IsNullOrEmpty(identity))
         {
-            eb.AddField("Character Ident", identity);
+            mainEmbed.AddField("Character Ident", identity);
         }
 
-        return eb;
+        Embed? profileEmbedResult = null;
+        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)
+    {
+        var primaryUser = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.DiscordId == Context.User.Id).ConfigureAwait(false);
+        ulong userToCheckForDiscordId = Context.User.Id;
+        
+        if ((optionalUser != null || uid != null))
+        {
+            LodeStoneAuth userInDb = null;
+            if (optionalUser != null)
+            {
+                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.DiscordId == optionalUser).ConfigureAwait(false);
+            }
+            else if (uid != null)
+            {
+                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid). ConfigureAwait(false);
+            }
+            if (userInDb == null)
+            {
+                throw new Exception("The Discord user has no valid Lightless account");
+            }
+            userToCheckForDiscordId = userInDb.DiscordId;
+        }
+        var lodestoneUser = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.DiscordId == userToCheckForDiscordId).ConfigureAwait(false);
+        var dbUser = lodestoneUser.User;
+        if (secondaryUserUid != null)
+        {
+            dbUser = (await db.Auth.Include(u => u.User).SingleOrDefaultAsync(u => u.PrimaryUserUID == dbUser.UID && u.UserUID == secondaryUserUid))?.User;
+            if (dbUser == null)
+            {
+                throw new Exception($"A secondary UID {secondaryUserUid} was not found attached to your primary UID {primaryUser.User.UID}.");
+            }
+        }
+        return dbUser.UID;
+    }
+    private byte[] GetProfileImage(UserProfileData profile)
+    {
+        if (profile != null && profile.Base64ProfileImage != null && profile.Base64ProfileImage.Length > 0)
+        {
+            return Convert.FromBase64String(profile.Base64ProfileImage);
+        }
+        return Array.Empty<byte>();
+    }
+
+    private byte[] GetBannerImage(UserProfileData profile)
+    {
+        if (profile != null && profile.Base64BannerImage != null && profile.Base64BannerImage.Length > 0)
+        {
+            return Convert.FromBase64String(profile.Base64BannerImage);
+        }
+        return Array.Empty<byte>();
+    }
+
+    private async Task<UserProfileData> GetUserProfileData(LightlessDbContext db, string uid)
+    {
+        var profile = await db.UserProfileData.Where(u => u.UserUID == uid).SingleOrDefaultAsync().ConfigureAwait(false);
+        return profile;
     }
 }

LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.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/Discord/LightlessWizardModule.cs

@@ -329,13 +329,12 @@ public partial class LightlessWizardModule : InteractionModuleBase
 
     private int? ParseCharacterIdFromLodestoneUrl(string lodestoneUrl)
     {
-        var regex = new Regex(@"https:\/\/(na|eu|de|fr|jp)\.finalfantasyxiv\.com\/lodestone\/character\/\d+");
+        var regex = new Regex(@"^https:\/\/(na|eu|de|fr|jp)\.finalfantasyxiv\.com\/lodestone\/character\/(\d+)/?$");
         var matches = regex.Match(lodestoneUrl);
         var isLodestoneUrl = matches.Success;
         if (!isLodestoneUrl || matches.Groups.Count < 1) return null;
+        var stringId = matches.Groups[2].ToString();
 
-        lodestoneUrl = matches.Groups[0].ToString();
-        var stringId = lodestoneUrl.Split('/', StringSplitOptions.RemoveEmptyEntries).Last();
         if (!int.TryParse(stringId, out int lodestoneId))
         {
             return null;

LightlessSyncServer/LightlessSyncServices/LightlessSyncServices.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
@@ -21,7 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.17.0" />
+    <PackageReference Include="Discord.Net" Version="3.18.0" />
     <PackageReference Include="IDisposableAnalyzers" Version="4.0.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -32,6 +32,7 @@
     </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/LightlessDbContext.cs

@@ -45,6 +45,7 @@ public class LightlessDbContext : DbContext
     public DbSet<UserProfileData> UserProfileData { get; set; }
     public DbSet<User> Users { get; set; }
     public DbSet<UserPermissionSet> Permissions { get; set; }
+    public DbSet<ReportedChatMessage> ReportedChatMessages { get; set; }
     public DbSet<GroupPairPreferredPermission> GroupPairPreferredPermissions { get; set; }
     public DbSet<UserDefaultPreferredPermission> UserDefaultPreferredPermissions { get; set; }
     public DbSet<CharaData> CharaData { get; set; }
@@ -79,6 +80,9 @@ 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);
@@ -90,6 +94,12 @@ public class LightlessDbContext : DbContext
         mb.Entity<GroupProfile>().ToTable("group_profiles");
         mb.Entity<GroupProfile>().HasKey(u => u.GroupGID);
         mb.Entity<GroupProfile>().HasIndex(c => c.GroupGID);
+        mb.Entity<Group>()
+            .HasOne(g => g.Profile)
+            .WithOne(p => p.Group)
+            .HasForeignKey<GroupProfile>(p => p.GroupGID)
+            .IsRequired(false)
+            .OnDelete(DeleteBehavior.Cascade);
         mb.Entity<GroupTempInvite>().ToTable("group_temp_invites");
         mb.Entity<GroupTempInvite>().HasKey(u => new { u.GroupGID, u.Invite });
         mb.Entity<GroupTempInvite>().HasIndex(c => c.GroupGID);
@@ -153,5 +163,11 @@ public class LightlessDbContext : DbContext
         mb.Entity<CharaDataAllowance>().HasIndex(c => c.ParentId);
         mb.Entity<CharaDataAllowance>().HasOne(u => u.AllowedGroup).WithMany().HasForeignKey(u => u.AllowedGroupGID).OnDelete(DeleteBehavior.Cascade);
         mb.Entity<CharaDataAllowance>().HasOne(u => u.AllowedUser).WithMany().HasForeignKey(u => u.AllowedUserUID).OnDelete(DeleteBehavior.Cascade);
+
+        mb.Entity<ReportedChatMessage>().ToTable("reported_chat_messages");
+        mb.Entity<ReportedChatMessage>().HasIndex(r => r.ReporterUserUid);
+        mb.Entity<ReportedChatMessage>().HasIndex(r => r.ReportedUserUid);
+        mb.Entity<ReportedChatMessage>().HasIndex(r => r.MessageId).IsUnique();
+        mb.Entity<ReportedChatMessage>().HasIndex(r => r.DiscordMessageId);
     }
 }

LightlessSyncServer/LightlessSyncShared/LightlessSyncShared.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFramework>net9.0</TargetFramework>
+		<TargetFramework>net10.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 	</PropertyGroup>
 
@@ -47,7 +47,6 @@
 		<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/LightlessMetrics.cs

@@ -20,7 +20,7 @@ public class LightlessMetrics
             if (!string.Equals(gauge, MetricsAPI.GaugeConnections, StringComparison.OrdinalIgnoreCase))
                 _gauges.Add(gauge, Prometheus.Metrics.CreateGauge(gauge, gauge));
             else
-                _gauges.Add(gauge, Prometheus.Metrics.CreateGauge(gauge, gauge, new[] { "continent" }));
+                _gauges.Add(gauge, Prometheus.Metrics.CreateGauge(gauge, gauge, ["continent", "country"]));
         }
     }
 

LightlessSyncServer/LightlessSyncShared/Metrics/MetricsAPI.cs

@@ -9,6 +9,9 @@ public class MetricsAPI
     public const string GaugeAvailableIOWorkerThreads = "lightless_available_threadpool_io";
     public const string GaugeUsersRegistered = "lightless_users_registered";
     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/20251015173920_AddGroupDisabledAndNSFW.cs

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

LightlessSyncServer/LightlessSyncShared/Migrations/20251019163402_AddAndChangeTagsUserGroupProfile.cs

@@ -0,0 +1,51 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddAndChangeTagsUserGroupProfile : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int[]>(
+                name: "tags",
+                table: "user_profile_data",
+                type: "integer[]",
+                nullable: true);
+
+            migrationBuilder.Sql(
+                "ALTER TABLE group_profiles ALTER COLUMN tags TYPE integer[] USING string_to_array(tags, ',')::integer[];"
+            );
+
+            migrationBuilder.AlterColumn<int[]>(
+                name: "tags",
+                table: "group_profiles",
+                type: "integer[]",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+            migrationBuilder.DropColumn(
+                name: "tags",
+                table: "user_profile_data");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "tags",
+                table: "group_profiles",
+                type: "text",
+                nullable: true,
+                oldClrType: typeof(int[]),
+                oldType: "integer[]",
+                oldNullable: true);
+        }
+    }
+}

LightlessSyncServer/LightlessSyncShared/Migrations/20251020181150_AddBannerForProfiles.cs

@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBannerForProfiles : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "base64banner_image",
+                table: "user_profile_data",
+                type: "text",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "base64group_banner_image",
+                table: "group_profiles",
+                type: "text",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "base64banner_image",
+                table: "user_profile_data");
+
+            migrationBuilder.DropColumn(
+                name: "base64group_banner_image",
+                table: "group_profiles");
+        }
+    }
+}

LightlessSyncServer/LightlessSyncShared/Migrations/20251028215549_ChatReports.cs

@@ -0,0 +1,90 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class ChatReports : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "reported_chat_messages",
+                columns: table => new
+                {
+                    report_id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    report_time_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    reporter_user_uid = table.Column<string>(type: "text", nullable: false),
+                    reported_user_uid = table.Column<string>(type: "text", nullable: true),
+                    channel_type = table.Column<byte>(type: "smallint", nullable: false),
+                    world_id = table.Column<int>(type: "integer", nullable: false),
+                    zone_id = table.Column<int>(type: "integer", nullable: false),
+                    channel_key = table.Column<string>(type: "text", nullable: false),
+                    message_id = table.Column<string>(type: "text", nullable: false),
+                    message_sent_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    message_content = table.Column<string>(type: "text", nullable: false),
+                    sender_token = table.Column<string>(type: "text", nullable: false),
+                    sender_hashed_cid = table.Column<string>(type: "text", nullable: true),
+                    sender_display_name = table.Column<string>(type: "text", nullable: true),
+                    sender_was_lightfinder = table.Column<bool>(type: "boolean", nullable: false),
+                    snapshot_json = table.Column<string>(type: "text", nullable: true),
+                    reason = table.Column<string>(type: "text", nullable: true),
+                    additional_context = table.Column<string>(type: "text", nullable: true),
+                    discord_message_id = table.Column<decimal>(type: "numeric(20,0)", nullable: true),
+                    discord_message_posted_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    resolved = table.Column<bool>(type: "boolean", nullable: false),
+                    resolved_at_utc = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    resolution_notes = table.Column<string>(type: "text", nullable: true),
+                    resolved_by_user_uid = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_reported_chat_messages", x => x.report_id);
+                });
+
+            migrationBuilder.AddColumn<bool>(
+                name: "chat_banned",
+                table: "users",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_reported_chat_messages_discord_message_id",
+                table: "reported_chat_messages",
+                column: "discord_message_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_reported_chat_messages_message_id",
+                table: "reported_chat_messages",
+                column: "message_id",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_reported_chat_messages_reported_user_uid",
+                table: "reported_chat_messages",
+                column: "reported_user_uid");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_reported_chat_messages_reporter_user_uid",
+                table: "reported_chat_messages",
+                column: "reporter_user_uid");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "reported_chat_messages");
+
+            migrationBuilder.DropColumn(
+                name: "chat_banned",
+                table: "users");
+        }
+    }
+}

LightlessSyncServer/LightlessSyncShared/Migrations/20251117153226_FixForeignKeyGroupProfiles.cs

@@ -0,0 +1,41 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class FixForeignKeyGroupProfiles : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "fk_group_profiles_groups_group_gid",
+                table: "group_profiles");
+
+            migrationBuilder.AddForeignKey(
+                name: "fk_group_profiles_groups_group_gid",
+                table: "group_profiles",
+                column: "group_gid",
+                principalTable: "groups",
+                principalColumn: "gid",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "fk_group_profiles_groups_group_gid",
+                table: "group_profiles");
+
+            migrationBuilder.AddForeignKey(
+                name: "fk_group_profiles_groups_group_gid",
+                table: "group_profiles",
+                column: "group_gid",
+                principalTable: "groups",
+                principalColumn: "gid");
+        }
+    }
+}

LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.cs

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,29 @@
+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/LightlessDbContextModelSnapshot.cs

@@ -430,6 +430,20 @@ 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")
@@ -589,6 +603,10 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("character varying(20)")
                         .HasColumnName("group_gid");
 
+                    b.Property<string>("Base64GroupBannerImage")
+                        .HasColumnType("text")
+                        .HasColumnName("base64group_banner_image");
+
                     b.Property<string>("Base64GroupProfileImage")
                         .HasColumnType("text")
                         .HasColumnName("base64group_profile_image");
@@ -597,8 +615,16 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("text")
                         .HasColumnName("description");
 
-                    b.Property<string>("Tags")
+                    b.Property<bool>("IsNSFW")
-                        .HasColumnType("text")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_nsfw");
+
+                    b.Property<bool>("ProfileDisabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("profile_disabled");
+
+                    b.PrimitiveCollection<int[]>("Tags")
+                        .HasColumnType("integer[]")
                         .HasColumnName("tags");
 
                     b.HasKey("GroupGID")
@@ -671,6 +697,126 @@ namespace LightlessSyncServer.Migrations
                     b.ToTable("lodestone_auth", (string)null);
                 });
 
+            modelBuilder.Entity("LightlessSyncShared.Models.ReportedChatMessage", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("report_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("AdditionalContext")
+                        .HasColumnType("text")
+                        .HasColumnName("additional_context");
+
+                    b.Property<string>("ChannelKey")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("channel_key");
+
+                    b.Property<byte>("ChannelType")
+                        .HasColumnType("smallint")
+                        .HasColumnName("channel_type");
+
+                    b.Property<decimal?>("DiscordMessageId")
+                        .HasColumnType("numeric(20,0)")
+                        .HasColumnName("discord_message_id");
+
+                    b.Property<DateTime?>("DiscordMessagePostedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("discord_message_posted_at_utc");
+
+                    b.Property<string>("MessageContent")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("message_content");
+
+                    b.Property<string>("MessageId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("message_id");
+
+                    b.Property<DateTime>("MessageSentAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("message_sent_at_utc");
+
+                    b.Property<string>("Reason")
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<DateTime>("ReportTimeUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("report_time_utc");
+
+                    b.Property<string>("ReportedUserUid")
+                        .HasColumnType("text")
+                        .HasColumnName("reported_user_uid");
+
+                    b.Property<string>("ReporterUserUid")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reporter_user_uid");
+
+                    b.Property<string>("ResolutionNotes")
+                        .HasColumnType("text")
+                        .HasColumnName("resolution_notes");
+
+                    b.Property<bool>("Resolved")
+                        .HasColumnType("boolean")
+                        .HasColumnName("resolved");
+
+                    b.Property<DateTime?>("ResolvedAtUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resolved_at_utc");
+
+                    b.Property<string>("ResolvedByUserUid")
+                        .HasColumnType("text")
+                        .HasColumnName("resolved_by_user_uid");
+
+                    b.Property<string>("SenderDisplayName")
+                        .HasColumnType("text")
+                        .HasColumnName("sender_display_name");
+
+                    b.Property<string>("SenderHashedCid")
+                        .HasColumnType("text")
+                        .HasColumnName("sender_hashed_cid");
+
+                    b.Property<bool>("SenderWasLightfinder")
+                        .HasColumnType("boolean")
+                        .HasColumnName("sender_was_lightfinder");
+
+                    b.Property<string>("SnapshotJson")
+                        .HasColumnType("text")
+                        .HasColumnName("snapshot_json");
+
+                    b.Property<int>("WorldId")
+                        .HasColumnType("integer")
+                        .HasColumnName("world_id");
+
+                    b.Property<int>("ZoneId")
+                        .HasColumnType("integer")
+                        .HasColumnName("zone_id");
+
+                    b.HasKey("ReportId")
+                        .HasName("pk_reported_chat_messages");
+
+                    b.HasIndex("DiscordMessageId")
+                        .HasDatabaseName("ix_reported_chat_messages_discord_message_id");
+
+                    b.HasIndex("MessageId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_reported_chat_messages_message_id");
+
+                    b.HasIndex("ReportedUserUid")
+                        .HasDatabaseName("ix_reported_chat_messages_reported_user_uid");
+
+                    b.HasIndex("ReporterUserUid")
+                        .HasDatabaseName("ix_reported_chat_messages_reporter_user_uid");
+
+                    b.ToTable("reported_chat_messages", (string)null);
+                });
+
             modelBuilder.Entity("LightlessSyncShared.Models.User", b =>
                 {
                     b.Property<string>("UID")
@@ -683,6 +829,10 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("character varying(15)")
                         .HasColumnName("alias");
 
+                    b.Property<bool>("ChatBanned")
+                        .HasColumnType("boolean")
+                        .HasColumnName("chat_banned");
+
                     b.Property<bool>("HasVanity")
                         .HasColumnType("boolean")
                         .HasColumnName("has_vanity");
@@ -816,6 +966,10 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("character varying(10)")
                         .HasColumnName("user_uid");
 
+                    b.Property<string>("Base64BannerImage")
+                        .HasColumnType("text")
+                        .HasColumnName("base64banner_image");
+
                     b.Property<string>("Base64ProfileImage")
                         .HasColumnType("text")
                         .HasColumnName("base64profile_image");
@@ -832,6 +986,10 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("profile_disabled");
 
+                    b.PrimitiveCollection<int[]>("Tags")
+                        .HasColumnType("integer[]")
+                        .HasColumnName("tags");
+
                     b.Property<string>("UserDescription")
                         .HasColumnType("text")
                         .HasColumnName("user_description");
@@ -1071,6 +1229,7 @@ namespace LightlessSyncServer.Migrations
                     b.HasOne("LightlessSyncShared.Models.Group", "Group")
                         .WithOne("Profile")
                         .HasForeignKey("LightlessSyncShared.Models.GroupProfile", "GroupGID")
+                        .OnDelete(DeleteBehavior.Cascade)
                         .HasConstraintName("fk_group_profiles_groups_group_gid");
 
                     b.Navigation("Group");

LightlessSyncServer/LightlessSyncShared/Models/Group.cs

@@ -12,10 +12,13 @@ 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/GroupProfile.cs

@@ -13,6 +13,9 @@ public class GroupProfile
     public string GroupGID { get; set; }
     public Group Group { get; set; }
     public string Description { get; set; }
-    public string Tags { get; set; }
+    public int[] Tags { get; set; }
     public string Base64GroupProfileImage { get; set; }
+    public string Base64GroupBannerImage { get; set; }
+    public bool IsNSFW { get; set; } = false;
+    public bool ProfileDisabled { get; set; } = false;
 }

LightlessSyncServer/LightlessSyncShared/Models/ReportedChatMessage.cs

@@ -0,0 +1,66 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using LightlessSync.API.Dto.Chat;
+
+namespace LightlessSyncShared.Models;
+
+/// <summary>
+///     Stores metadata about chat reports submitted by users.
+/// </summary>
+public class ReportedChatMessage
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public int ReportId { get; set; }
+
+    [Required]
+    public DateTime ReportTimeUtc { get; set; }
+
+    [Required]
+    public string ReporterUserUid { get; set; } = string.Empty;
+
+    public string? ReportedUserUid { get; set; }
+
+    [Required]
+    public ChatChannelType ChannelType { get; set; }
+
+    public ushort WorldId { get; set; }
+
+    public ushort ZoneId { get; set; }
+
+    [Required]
+    public string ChannelKey { get; set; } = string.Empty;
+
+    [Required]
+    public string MessageId { get; set; } = string.Empty;
+
+    public DateTime MessageSentAtUtc { get; set; }
+
+    [Required]
+    public string MessageContent { get; set; } = string.Empty;
+
+    public string? SenderHashedCid { get; set; }
+
+    public string? SenderDisplayName { get; set; }
+
+    public bool SenderWasLightfinder { get; set; }
+
+    public string SnapshotJson { get; set; } = string.Empty;
+
+    public string? Reason { get; set; }
+
+    public string? AdditionalContext { get; set; }
+
+    public ulong? DiscordMessageId { get; set; }
+
+    public DateTime? DiscordMessagePostedAtUtc { get; set; }
+
+    public bool Resolved { get; set; }
+
+    public DateTime? ResolvedAtUtc { get; set; }
+
+    public string? ResolutionNotes { get; set; }
+
+    public string? ResolvedByUserUid { get; set; }
+}

LightlessSyncServer/LightlessSyncShared/Models/User.cs

@@ -22,6 +22,8 @@ public class User
     [MaxLength(9)]
     public string? TextGlowColorHex { get; set; } = string.Empty;
 
+    public bool ChatBanned { get; set; } = false;
+
     public DateTime LastLoggedIn { get; set; }
     [MaxLength(15)]
     public string Alias { get; set; }

LightlessSyncServer/LightlessSyncShared/Models/UserProfileData.cs

@@ -6,12 +6,14 @@ namespace LightlessSyncShared.Models;
 public class UserProfileData
 {
     public string Base64ProfileImage { get; set; }
+    public string Base64BannerImage { get; set; }
     public bool FlaggedForReport { get; set; }
     public bool IsNSFW { get; set; }
     public bool ProfileDisabled { get; set; }
     public User User { get; set; }
 
     public string UserDescription { get; set; }
+    public int[] Tags { get; set; }
 
     [Required]
     [Key]

LightlessSyncServer/LightlessSyncShared/Utils/Configuration/ServicesConfiguration.cs

@@ -7,6 +7,7 @@ public class ServicesConfiguration : LightlessConfigurationBase
     public string DiscordBotToken { get; set; } = string.Empty;
     public ulong? DiscordChannelForMessages { get; set; } = null;
     public ulong? DiscordChannelForCommands { get; set; } = null;
+    public ulong? DiscordChannelForChatReports { get; set; } = null;
     public ulong? DiscordRoleAprilFools2024 { get; set; } = null;
     public ulong? DiscordChannelForBotLog { get; set; } = null!;
     public ulong? DiscordRoleRegistered { get; set; } = null!;
@@ -22,6 +23,7 @@ public class ServicesConfiguration : LightlessConfigurationBase
         sb.AppendLine($"{nameof(MainServerAddress)} => {MainServerAddress}");
         sb.AppendLine($"{nameof(DiscordChannelForMessages)} => {DiscordChannelForMessages}");
         sb.AppendLine($"{nameof(DiscordChannelForCommands)} => {DiscordChannelForCommands}");
+        sb.AppendLine($"{nameof(DiscordChannelForChatReports)} => {DiscordChannelForChatReports}");
         sb.AppendLine($"{nameof(DiscordRoleAprilFools2024)} => {DiscordRoleAprilFools2024}");
         sb.AppendLine($"{nameof(DiscordRoleRegistered)} => {DiscordRoleRegistered}");
         sb.AppendLine($"{nameof(KickNonRegisteredUsers)} => {KickNonRegisteredUsers}");

LightlessSyncServer/LightlessSyncShared/Utils/Configuration/StaticFilesServerConfiguration.cs

@@ -20,6 +20,8 @@ public class StaticFilesServerConfiguration : LightlessConfigurationBase
     public string ColdStorageDirectory { get; set; } = null;
     public double ColdStorageSizeHardLimitInGiB { get; set; } = -1;
     public int ColdStorageUnusedFileRetentionPeriodInDays { get; set; } = 30;
+    public bool EnableDirectDownloads { get; set; } = true;
+    public int DirectDownloadTokenLifetimeSeconds { get; set; } = 300;
     [RemoteConfiguration]
     public double SpeedTestHoursRateLimit { get; set; } = 0.5;
     [RemoteConfiguration]
@@ -40,6 +42,8 @@ public class StaticFilesServerConfiguration : LightlessConfigurationBase
         sb.AppendLine($"{nameof(CacheDirectory)} => {CacheDirectory}");
         sb.AppendLine($"{nameof(DownloadQueueSize)} => {DownloadQueueSize}");
         sb.AppendLine($"{nameof(DownloadQueueReleaseSeconds)} => {DownloadQueueReleaseSeconds}");
+        sb.AppendLine($"{nameof(EnableDirectDownloads)} => {EnableDirectDownloads}");
+        sb.AppendLine($"{nameof(DirectDownloadTokenLifetimeSeconds)} => {DirectDownloadTokenLifetimeSeconds}");
         return sb.ToString();
     }
 }

LightlessSyncServer/LightlessSyncShared/Utils/MareClaimTypes.cs

@@ -8,6 +8,7 @@ public static class LightlessClaimTypes
     public const string Internal = "internal";
     public const string Expires = "expiration_date";
     public const string Continent = "continent";
+    public const string Country = "country";
     public const string DiscordUser = "discord_user";
     public const string DiscordId = "discord_user_id";
     public const string OAuthLoginToken = "oauth_login_token";

LightlessSyncServer/LightlessSyncStaticFilesServer/Controllers/ServerFilesController.cs

@@ -10,6 +10,7 @@ using LightlessSyncShared.Services;
 using LightlessSyncShared.Utils.Configuration;
 using LightlessSyncStaticFilesServer.Services;
 using LightlessSyncStaticFilesServer.Utils;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
@@ -32,12 +33,15 @@ public class ServerFilesController : ControllerBase
     private readonly IDbContextFactory<LightlessDbContext> _lightlessDbContext;
     private readonly LightlessMetrics _metricsClient;
     private readonly MainServerShardRegistrationService _shardRegistrationService;
+    private readonly CDNDownloadUrlService _cdnDownloadUrlService;
+    private readonly CDNDownloadsService _cdnDownloadsService;
 
     public ServerFilesController(ILogger<ServerFilesController> logger, CachedFileProvider cachedFileProvider,
         IConfigurationService<StaticFilesServerConfiguration> configuration,
         IHubContext<LightlessHub> hubContext,
         IDbContextFactory<LightlessDbContext> lightlessDbContext, LightlessMetrics metricsClient,
-        MainServerShardRegistrationService shardRegistrationService) : base(logger)
+        MainServerShardRegistrationService shardRegistrationService, CDNDownloadUrlService cdnDownloadUrlService,
+        CDNDownloadsService cdnDownloadsService) : base(logger)
     {
         _basePath = configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.UseColdStorage), false)
             ? configuration.GetValue<string>(nameof(StaticFilesServerConfiguration.ColdStorageDirectory))
@@ -48,6 +52,8 @@ public class ServerFilesController : ControllerBase
         _lightlessDbContext = lightlessDbContext;
         _metricsClient = metricsClient;
         _shardRegistrationService = shardRegistrationService;
+        _cdnDownloadUrlService = cdnDownloadUrlService;
+        _cdnDownloadsService = cdnDownloadsService;
     }
 
     [HttpPost(LightlessFiles.ServerFiles_DeleteAll)]
@@ -105,6 +111,16 @@ public class ServerFilesController : ControllerBase
                 baseUrl = shard.Value ?? _configuration.GetValue<Uri>(nameof(StaticFilesServerConfiguration.CdnFullUrl));
             }
 
+            var cdnDownloadUrl = string.Empty;
+            if (forbiddenFile == null)
+            {
+                var directUri = _cdnDownloadUrlService.TryCreateDirectDownloadUri(baseUrl, file.Hash);
+                if (directUri != null)
+                {
+                    cdnDownloadUrl = directUri.ToString();
+                }
+            }
+
             response.Add(new DownloadFileDto
             {
                 FileExists = file.Size > 0,
@@ -113,6 +129,7 @@ public class ServerFilesController : ControllerBase
                 Hash = file.Hash,
                 Size = file.Size,
                 Url = baseUrl?.ToString() ?? string.Empty,
+                CDNDownloadUrl = cdnDownloadUrl,
                 RawSize = file.RawSize
             });
         }
@@ -127,6 +144,22 @@ public class ServerFilesController : ControllerBase
         return Ok(JsonSerializer.Serialize(allFileShards.SelectMany(t => t.RegionUris.Select(v => v.Value.ToString()))));
     }
 
+    [HttpGet(LightlessFiles.ServerFiles_DirectDownload + "/{hash}")]
+    [AllowAnonymous]
+    public async Task<IActionResult> DownloadFileDirect(string hash, [FromQuery] long expires, [FromQuery] string signature)
+    {
+        var result = await _cdnDownloadsService.GetDownloadAsync(hash, expires, signature).ConfigureAwait(false);
+
+        return result.Status switch
+        {
+            CDNDownloadsService.ResultStatus.Disabled => NotFound(),
+            CDNDownloadsService.ResultStatus.Unauthorized => Unauthorized(),
+            CDNDownloadsService.ResultStatus.NotFound => NotFound(),
+            CDNDownloadsService.ResultStatus.Success => PhysicalFile(result.File!.FullName, "application/octet-stream"),
+            _ => NotFound()
+        };
+    }
+
     [HttpPost(LightlessFiles.ServerFiles_FilesSend)]
     public async Task<IActionResult> FilesSend([FromBody] FilesSendDto filesSendDto)
     {

LightlessSyncServer/LightlessSyncStaticFilesServer/Controllers/ShardServerFilesController.cs

@@ -0,0 +1,34 @@
+using LightlessSync.API.Routes;
+using LightlessSyncStaticFilesServer.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace LightlessSyncStaticFilesServer.Controllers;
+
+[Route(LightlessFiles.ServerFiles)]
+public class ShardServerFilesController : ControllerBase
+{
+    private readonly CDNDownloadsService _cdnDownloadsService;
+
+    public ShardServerFilesController(ILogger<ShardServerFilesController> logger,
+        CDNDownloadsService cdnDownloadsService) : base(logger)
+    {
+        _cdnDownloadsService = cdnDownloadsService;
+    }
+
+    [HttpGet(LightlessFiles.ServerFiles_DirectDownload + "/{hash}")]
+    [AllowAnonymous]
+    public async Task<IActionResult> DownloadFileDirect(string hash, [FromQuery] long expires, [FromQuery] string signature)
+    {
+        var result = await _cdnDownloadsService.GetDownloadAsync(hash, expires, signature).ConfigureAwait(false);
+
+        return result.Status switch
+        {
+            CDNDownloadsService.ResultStatus.Disabled => NotFound(),
+            CDNDownloadsService.ResultStatus.Unauthorized => Unauthorized(),
+            CDNDownloadsService.ResultStatus.NotFound => NotFound(),
+            CDNDownloadsService.ResultStatus.Success => PhysicalFile(result.File!.FullName, "application/octet-stream"),
+            _ => NotFound()
+        };
+    }
+}

LightlessSyncServer/LightlessSyncStaticFilesServer/LightlessSyncStaticFilesServer.csproj

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

LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CDNDownloadUrlService.cs

@@ -0,0 +1,108 @@
+using LightlessSync.API.Routes;
+using LightlessSyncShared.Services;
+using LightlessSyncShared.Utils.Configuration;
+using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.WebUtilities;
+using System.Security.Cryptography;
+using System.Text;
+using System.Globalization;
+using System.Linq;
+
+namespace LightlessSyncStaticFilesServer.Services;
+
+public class CDNDownloadUrlService
+{
+    private readonly IConfigurationService<StaticFilesServerConfiguration> _staticConfig;
+    private readonly IConfigurationService<LightlessConfigurationBase> _globalConfig;
+    private readonly ILogger<CDNDownloadUrlService> _logger;
+
+    public CDNDownloadUrlService(IConfigurationService<StaticFilesServerConfiguration> staticConfig,
+        IConfigurationService<LightlessConfigurationBase> globalConfig, ILogger<CDNDownloadUrlService> logger)
+    {
+        _staticConfig = staticConfig;
+        _globalConfig = globalConfig;
+        _logger = logger;
+    }
+
+    public bool DirectDownloadsEnabled =>
+        _staticConfig.GetValueOrDefault(nameof(StaticFilesServerConfiguration.EnableDirectDownloads), false);
+
+    public Uri? TryCreateDirectDownloadUri(Uri? baseUri, string hash)
+    {
+        if (!DirectDownloadsEnabled || baseUri == null)
+        {
+            return null;
+        }
+
+        if (!IsSupportedHash(hash))
+        {
+            _logger.LogDebug("Skipping direct download link generation for invalid hash {hash}", hash);
+            return null;
+        }
+
+        var normalizedHash = hash.ToUpperInvariant();
+
+        var lifetimeSeconds = Math.Max(5,
+            _staticConfig.GetValueOrDefault(nameof(StaticFilesServerConfiguration.DirectDownloadTokenLifetimeSeconds), 300));
+        var expiresAt = DateTimeOffset.UtcNow.AddSeconds(lifetimeSeconds);
+        var signature = CreateSignature(normalizedHash, expiresAt.ToUnixTimeSeconds());
+
+        var directPath = $"{LightlessFiles.ServerFiles}/{LightlessFiles.ServerFiles_DirectDownload}/{normalizedHash}";
+        var builder = new UriBuilder(new Uri(baseUri, directPath));
+        var query = new QueryBuilder
+        {
+            { "expires", expiresAt.ToUnixTimeSeconds().ToString(CultureInfo.InvariantCulture) },
+            { "signature", signature }
+        };
+        builder.Query = query.ToQueryString().Value!.TrimStart('?');
+        return builder.Uri;
+    }
+
+    public bool TryValidateSignature(string hash, long expiresUnixSeconds, string signature)
+    {
+        if (!DirectDownloadsEnabled)
+        {
+            return false;
+        }
+
+        if (string.IsNullOrEmpty(signature) || !IsSupportedHash(hash))
+        {
+            return false;
+        }
+
+        var normalizedHash = hash.ToUpperInvariant();
+
+        DateTimeOffset expiresAt;
+        try
+        {
+            expiresAt = DateTimeOffset.FromUnixTimeSeconds(expiresUnixSeconds);
+        }
+        catch (ArgumentOutOfRangeException)
+        {
+            return false;
+        }
+
+        if (expiresAt < DateTimeOffset.UtcNow)
+        {
+            return false;
+        }
+
+        var expected = CreateSignature(normalizedHash, expiresAt.ToUnixTimeSeconds());
+        return CryptographicOperations.FixedTimeEquals(
+            Encoding.UTF8.GetBytes(expected),
+            Encoding.UTF8.GetBytes(signature));
+    }
+
+    private string CreateSignature(string hash, long expiresUnixSeconds)
+    {
+        var signingKey = _globalConfig.GetValue<string>(nameof(LightlessConfigurationBase.Jwt));
+        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(signingKey));
+        var payload = Encoding.UTF8.GetBytes($"{hash}:{expiresUnixSeconds}");
+        return WebEncoders.Base64UrlEncode(hmac.ComputeHash(payload));
+    }
+
+    private static bool IsSupportedHash(string hash)
+    {
+        return hash.Length == 40 && hash.All(char.IsAsciiLetterOrDigit);
+    }
+}

LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CDNDownloadsService.cs

@@ -0,0 +1,56 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace LightlessSyncStaticFilesServer.Services;
+
+public class CDNDownloadsService
+{
+    public enum ResultStatus
+    {
+        Disabled,
+        Unauthorized,
+        NotFound,
+        Success
+    }
+
+    public readonly record struct Result(ResultStatus Status, FileInfo? File);
+
+    private readonly CDNDownloadUrlService _cdnDownloadUrlService;
+    private readonly CachedFileProvider _cachedFileProvider;
+
+    public CDNDownloadsService(CDNDownloadUrlService cdnDownloadUrlService, CachedFileProvider cachedFileProvider)
+    {
+        _cdnDownloadUrlService = cdnDownloadUrlService;
+        _cachedFileProvider = cachedFileProvider;
+    }
+
+    public bool DownloadsEnabled => _cdnDownloadUrlService.DirectDownloadsEnabled;
+
+    public async Task<Result> GetDownloadAsync(string hash, long expiresUnixSeconds, string signature)
+    {
+        if (!_cdnDownloadUrlService.DirectDownloadsEnabled)
+        {
+            return new Result(ResultStatus.Disabled, null);
+        }
+
+        if (string.IsNullOrEmpty(signature) || string.IsNullOrEmpty(hash))
+        {
+            return new Result(ResultStatus.Unauthorized, null);
+        }
+
+        hash = hash.ToUpperInvariant();
+
+        if (!_cdnDownloadUrlService.TryValidateSignature(hash, expiresUnixSeconds, signature))
+        {
+            return new Result(ResultStatus.Unauthorized, null);
+        }
+
+        var fileInfo = await _cachedFileProvider.DownloadAndGetLocalFileInfo(hash).ConfigureAwait(false);
+        if (fileInfo == null)
+        {
+            return new Result(ResultStatus.NotFound, null);
+        }
+
+        return new Result(ResultStatus.Success, fileInfo);
+    }
+}

LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs

@@ -102,36 +102,37 @@ 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);
-        }
 
-        return false;
+			File.SetLastAccessTimeUtc(coldStorageFilePath.FullName, DateTime.UtcNow);
-    }
+			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)
     {
@@ -170,15 +171,22 @@ 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;
 
-        fi.LastAccessTimeUtc = DateTime.UtcNow;
+		try
+		{
+			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)
     {

LightlessSyncServer/LightlessSyncStaticFilesServer/Startup.cs

@@ -87,6 +87,8 @@ public class Startup
         services.AddSingleton<RequestFileStreamResultFactory>();
         services.AddSingleton<ServerTokenGenerator>();
         services.AddSingleton<RequestQueueService>();
+        services.AddSingleton<CDNDownloadUrlService>();
+        services.AddSingleton<CDNDownloadsService>();
         services.AddHostedService(p => p.GetService<RequestQueueService>());
         services.AddHostedService(m => m.GetService<FileStatisticsService>());
         services.AddSingleton<IConfigurationService<LightlessConfigurationBase>, LightlessConfigurationServiceClient<LightlessConfigurationBase>>();
@@ -204,11 +206,12 @@ public class Startup
             }
             else if (_isDistributionNode)
             {
-                a.FeatureProviders.Add(new AllowedControllersFeatureProvider(typeof(CacheController), typeof(RequestController), typeof(DistributionController), typeof(SpeedTestController)));
+                a.FeatureProviders.Add(new AllowedControllersFeatureProvider(typeof(CacheController), typeof(RequestController),
+                    typeof(DistributionController), typeof(ShardServerFilesController), typeof(SpeedTestController)));
             }
             else
             {
-                a.FeatureProviders.Add(new AllowedControllersFeatureProvider(typeof(CacheController), typeof(RequestController), typeof(SpeedTestController)));
+                a.FeatureProviders.Add(new AllowedControllersFeatureProvider(typeof(CacheController), typeof(ShardServerFilesController), typeof(RequestController), typeof(SpeedTestController)));
             }
         });
 
@@ -233,7 +236,6 @@ public class Startup
         }).AddJwtBearer();
         services.AddAuthorization(options =>
         {
-            options.FallbackPolicy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
             options.AddPolicy("Internal", new AuthorizationPolicyBuilder().RequireClaim(LightlessClaimTypes.Internal, "true").Build());
         });
         services.AddSingleton<IUserIdProvider, IdBasedUserIdProvider>();

LightlessSyncServer/LightlessSyncStaticFilesServer/appsettings.json

@@ -25,7 +25,9 @@
     "UnusedFileRetentionPeriodInDays": 7,
     "CacheDirectory": "G:\\ServerTest",
     "ServiceAddress": "http://localhost:5002",
-    "RemoteCacheSourceUri": ""
+    "RemoteCacheSourceUri": "",
+    "EnableDirectDownloads": true,
+    "DirectDownloadTokenLifetimeSeconds": 300
   },
   "AllowedHosts": "*"
 }