Merge pull request 'Updated links for Xivapi sources' (#54) from xivapi-link-changes into master

Reviewed-on: #54

.gitignore

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

LightlessSyncServer/LightlessSyncAuthService/LightlessSyncAuthService.csproj

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

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/Hubs/LightlessHub.Chat.cs

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

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs

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

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs

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

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs

@@ -1,6 +1,7 @@
 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;
@@ -11,10 +12,8 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using Newtonsoft.Json.Linq;
 using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
-using System.Reflection;
+using System.Collections.Concurrent;
 using System.Security.Cryptography;
 
 namespace LightlessSyncServer.Hubs;
@@ -29,29 +28,78 @@ public partial class LightlessHub
         var (userHasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
         if (!userHasRights) return;
 
-        var (userExists, groupPair) = await TryValidateUserInGroup(dto.Group.GID, dto.User.UID).ConfigureAwait(false);
-        if (!userExists) return;
+        var targetUid = dto.User.UID?.Trim();
+        if (string.IsNullOrWhiteSpace(targetUid)) return;
 
-        if (groupPair.IsModerator || string.Equals(group.OwnerUID, dto.User.UID, StringComparison.Ordinal)) return;
+        if (string.Equals(group.OwnerUID, targetUid, StringComparison.Ordinal))
+            return;
 
-        var alias = string.IsNullOrEmpty(groupPair.GroupUser.Alias) ? "-" : groupPair.GroupUser.Alias;
-        var ban = new GroupBan()
+        var groupPair = await DbContext.GroupPairs
+            .Include(p => p.GroupUser)
+            .SingleOrDefaultAsync(p => p.GroupGID == dto.Group.GID && p.GroupUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair?.IsModerator == true)
+            return;
+
+        var now = DateTime.UtcNow;
+
+        var existingBan = await DbContext.Set<GroupBan>().SingleOrDefaultAsync(b => b.GroupGID == dto.Group.GID && b.BannedUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+        var userExists = await DbContext.Users.AsNoTracking().AnyAsync(u => u.UID == targetUid || u.Alias == targetUid, RequestAbortedToken).ConfigureAwait(false);
+
+        if (!userExists && existingBan == null)
+            return;
+
+        const string marker = " (Alias at time of ban:";
+        string suffix;
+
+        if (existingBan?.BannedReason is { } existingReason)
         {
-            BannedByUID = UserUID,
-            BannedReason = $"{reason} (Alias at time of ban: {alias})",
-            BannedOn = DateTime.UtcNow,
-            BannedUserUID = dto.User.UID,
-            GroupGID = dto.Group.GID,
-        };
+            var idx = existingReason.IndexOf(marker, StringComparison.Ordinal);
+            suffix = idx >= 0 ? existingReason.Substring(startIndex: idx) : string.Empty;
+        }
+        else
+        {
+            var alias = groupPair?.GroupUser?.Alias;
+            alias = string.IsNullOrWhiteSpace(alias) ? "-" : alias;
+            suffix = $" (Alias at time of ban: {alias})";
+        }
 
-        DbContext.Add(ban);
-        await DbContext.SaveChangesAsync().ConfigureAwait(false);
+        var baseReason = (reason ?? string.Empty).Trim();
+        var finalReason = string.IsNullOrEmpty(suffix) ? baseReason : (baseReason + suffix);
 
-        await GroupRemoveUser(dto).ConfigureAwait(false);
+        if (existingBan != null)
+        {
+            existingBan.BannedByUID = UserUID;
+            existingBan.BannedReason = finalReason;
+
+            DbContext.Update(existingBan);
+        }
+        else
+        {
+            var ban = new GroupBan
+            {
+                BannedByUID = UserUID,
+                BannedReason = finalReason,
+                BannedOn = now,
+                BannedUserUID = targetUid,
+                GroupGID = dto.Group.GID,
+            };
+
+            DbContext.Add(ban);
+        }
+
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair != null)
+        {
+            await GroupRemoveUser(dto).ConfigureAwait(false);
+        }
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
     }
 
+    private static readonly ConcurrentDictionary<string, DateTime> GroupChatToggleCooldowns = new(StringComparer.Ordinal);
+
     [Authorize(Policy = "Identified")]
     public async Task GroupChangeGroupPermissionState(GroupPermissionDto dto)
     {
@@ -60,15 +108,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);
-        group.PreferDisableSounds = dto.Permissions.HasFlag(GroupPermissions.PreferDisableSounds);
-        group.PreferDisableAnimations = dto.Permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
-        group.PreferDisableVFX = dto.Permissions.HasFlag(GroupPermissions.PreferDisableVFX);
+        var permissions = dto.Permissions;
+        var isOwner = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal);
+        var chatEnabled = group.ChatEnabled;
+        var chatChanged = 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")]
@@ -235,6 +341,7 @@ public partial class LightlessHub
             PreferDisableAnimations = defaultPermissions.DisableGroupAnimations,
             PreferDisableSounds = defaultPermissions.DisableGroupSounds,
             PreferDisableVFX = defaultPermissions.DisableGroupVFX,
+            ChatEnabled = true,
             CreatedDate = currentTime,
         };
 
@@ -266,7 +373,7 @@ public partial class LightlessHub
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
             newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
             .ConfigureAwait(false);
-        
+
         _logger.LogCallInfo(LightlessHubLogger.Args(gid));
 
         return new GroupJoinDto(newGroup.ToGroupData(), passwd, initialPrefPermissions.ToEnum());
@@ -340,9 +447,9 @@ public partial class LightlessHub
 
         var banEntries = await DbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
-        List<BannedGroupUserDto> bannedGroupUsers = banEntries.Select(b =>
+        List<BannedGroupUserDto> bannedGroupUsers = [.. banEntries.Select(b =>
             new BannedGroupUserDto(group.ToGroupData(), b.BannedUser.ToUserData(), b.BannedReason, b.BannedOn,
-                b.BannedByUID)).ToList();
+                b.BannedByUID))];
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, bannedGroupUsers.Count));
 
@@ -771,7 +878,7 @@ public partial class LightlessHub
         }
 
         var data = await DbContext.GroupProfiles
-            .Include(gp => gp.Group) 
+            .Include(gp => gp.Group)
             .FirstOrDefaultAsync(
                 g => g.Group.GID == dto.Group.GID || g.Group.Alias == dto.Group.AliasOrGID,
                 cancellationToken
@@ -802,91 +909,85 @@ public partial class LightlessHub
     [Authorize(Policy = "Identified")]
     public async Task GroupSetProfile(GroupProfileDto dto)
     {
-            _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
-            var cancellationToken = RequestAbortedToken;
+        var cancellationToken = RequestAbortedToken;
 
-            if (dto.Group == null) return;
+        if (dto.Group == null) return;
 
-            var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
-            if (!hasRights) return;
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
+        if (!hasRights) return;
 
-            var groupProfileDb = await DbContext.GroupProfiles
-                .Include(g => g.Group)
-                .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID, cancellationToken)
+        var groupProfileDb = await DbContext.GroupProfiles
+            .Include(g => g.Group)
+            .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID, cancellationToken)
+            .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);
+        }
 
-            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;
-
-                if (groupProfileDb?.ProfileDisabled ?? false)
-                {
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
-                    return;
-                }
-
-                groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
-            }
-
-            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);
+        await DbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
     }
 
     [Authorize(Policy = "Identified")]
@@ -1049,11 +1150,11 @@ public partial class LightlessHub
             return false;
         }
 
-        var (isOwner, _) = await TryValidateOwner(dto.GID).ConfigureAwait(false);
-        if (!isOwner)
+        var (isOwnerOrMod, _) = await TryValidateGroupModeratorOrOwner(dto.GID).ConfigureAwait(false);
+        if (!isOwnerOrMod)
         {
             _logger.LogCallWarning(LightlessHubLogger.Args("Unauthorized syncshell broadcast change", "User", UserUID, "GID", dto.GID));
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner of the syncshell to broadcast it.");
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner or moderator of the syncshell to broadcast it.");
             return false;
         }
 

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs

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

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs

@@ -16,6 +16,8 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
+using LightlessSync.API.Dto.CharaData;
+using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Services.Interfaces;
 
 namespace LightlessSyncServer.Hubs;
@@ -217,6 +219,8 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
                 await RemoveUserFromRedis().ConfigureAwait(false);
 
                 _lightlessCensus.ClearStatistics(UserUID);
+                
+                await UpdateLocation(new LocationDto(new UserData(UserUID), new LocationInfo()), offline: true).ConfigureAwait(false);
 
                 await SendOfflineToAllPairedUsers().ConfigureAwait(false);
 
@@ -227,7 +231,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
             catch { }
             finally
             {
-                _chatChannelService.RemovePresence(UserUID);
+                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/ChatModels.cs

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

LightlessSyncServer/LightlessSyncServer/Models/ChatZoneDefinitions.cs

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

LightlessSyncServer/LightlessSyncServer/Services/ChatChannelService.cs

@@ -1,15 +1,13 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography;
+using System.Security.Cryptography;
 using LightlessSync.API.Data;
 using LightlessSync.API.Dto.Chat;
+using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Models;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace LightlessSyncServer.Services;
 
-public sealed class ChatChannelService
+public sealed class ChatChannelService : IDisposable
 {
     private readonly ILogger<ChatChannelService> _logger;
     private readonly Dictionary<string, ZoneChannelDefinition> _zoneDefinitions;
@@ -18,16 +16,137 @@ public sealed class ChatChannelService
     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)
+    public ChatChannelService(ILogger<ChatChannelService> logger, IOptions<ChatZoneOverridesOptions>? zoneOverrides = null)
     {
         _logger = logger;
-        _zoneDefinitions = ChatZoneDefinitions.Defaults
-            .ToDictionary(definition => definition.Key, StringComparer.OrdinalIgnoreCase);
+        _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(
@@ -154,7 +273,6 @@ public sealed class ChatChannelService
             messageId,
             channel,
             sentAtUtc,
-            participant.Token,
             participant.UserUid,
             participant.User,
             participant.IsLightfinder,
@@ -260,23 +378,6 @@ public sealed class ChatChannelService
         }
     }
 
-    public bool TryResolveParticipant(ChatChannelDescriptor channel, string token, out ChatParticipantInfo participant)
-    {
-        var key = ChannelKey.FromDescriptor(channel);
-
-        lock (_syncRoot)
-        {
-            if (_participantsByChannel.TryGetValue(key, out var participants) &&
-                participants.TryGetValue(token, out participant))
-            {
-                return true;
-            }
-        }
-
-        participant = default;
-        return false;
-    }
-
     public void RefreshLightfinderState(string userUid, string? hashedCid, bool isLightfinder)
     {
         ArgumentException.ThrowIfNullOrEmpty(userUid);
@@ -413,6 +514,8 @@ public sealed class ChatChannelService
 
             participantsByToken[token] = finalParticipant;
 
+            ApplyUIDMuteIfPresent(normalizedDescriptor, finalParticipant);
+
             _logger.LogDebug("Chat presence updated for {User} in {Channel}", userUid, Describe(key));
             return entryToStore;
         }
@@ -446,9 +549,113 @@ public sealed class ChatChannelService
             }
         }
 
+        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];
@@ -458,4 +665,103 @@ public sealed class ChatChannelService
 
     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/LightlessCensus.cs

@@ -72,7 +72,7 @@ public class LightlessCensus : IHostedService
 
         Dictionary<ushort, short> worldDcs = new();
 
-        var dcs = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/WorldDCGroupType.csv", cancellationToken).ConfigureAwait(false);
+        var dcs = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/WorldDCGroupType.csv", cancellationToken).ConfigureAwait(false);
         // dc: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/WorldDCGroupType.csv
         // id, name, region
 
@@ -92,7 +92,7 @@ public class LightlessCensus : IHostedService
             _dcs[id] = name;
         }
 
-        var worlds = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/World.csv", cancellationToken).ConfigureAwait(false);
+        var worlds = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/World.csv", cancellationToken).ConfigureAwait(false);
         // world: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/World.csv
         // id, internalname, name, region, usertype, datacenter, ispublic
 
@@ -114,7 +114,7 @@ public class LightlessCensus : IHostedService
             _logger.LogInformation("World: ID: {id}, Name: {name}, DC: {dc}", id, name, dc);
         }
 
-        var races = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Race.csv", cancellationToken).ConfigureAwait(false);
+        var races = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/Race.csv", cancellationToken).ConfigureAwait(false);
         // race: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Race.csv
         // id, masc name, fem name, other crap I don't care about
 
@@ -134,7 +134,7 @@ public class LightlessCensus : IHostedService
             _logger.LogInformation("Race: ID: {id}, Name: {name}", id, name);
         }
 
-        var tribe = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Tribe.csv", cancellationToken).ConfigureAwait(false);
+        var tribe = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/Tribe.csv", cancellationToken).ConfigureAwait(false);
         // tribe: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Tribe.csv
         // id masc name, fem name, other crap I don't care about
 

LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs

@@ -2,15 +2,19 @@
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Models;
 using Microsoft.EntityFrameworkCore;
+using StackExchange.Redis.Extensions.Core.Abstractions;
 
 namespace LightlessSyncServer.Services
 {
-    public class PruneService(LightlessDbContext dbContext) : IPruneService
+    public class PruneService(LightlessDbContext dbContext, IRedisDatabase redis) : IPruneService
     {
         private readonly LightlessDbContext _dbContext = dbContext;
+        private readonly IRedisDatabase _redis = redis;
 
         public async Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct)
         {
+            var onlineUids = await GetOnlineUidsAsync().ConfigureAwait(false);
+
             var allGroupUsers = await _dbContext.GroupPairs
                 .Include(p => p.GroupUser)
                 .Include(p => p.Group)
@@ -20,17 +24,14 @@ namespace LightlessSyncServer.Services
             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();
+            var usersToPrune = GetPruneUserList(allGroupUsers, onlineUids, inactivitySpan, now);
+            return usersToPrune.Count;
         }
 
         public async Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct)
         {
+            var onlineUids = await GetOnlineUidsAsync().ConfigureAwait(false);
+
             var allGroupUsers = await _dbContext.GroupPairs
                 .Include(p => p.GroupUser)
                 .Include(p => p.Group)
@@ -40,12 +41,7 @@ namespace LightlessSyncServer.Services
             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();
+            var usersToPrune = GetPruneUserList(allGroupUsers, onlineUids, inactivitySpan, now);
 
             _dbContext.GroupPairs.RemoveRange(usersToPrune);
             await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
@@ -53,8 +49,52 @@ namespace LightlessSyncServer.Services
             return usersToPrune;
         }
 
-        private static TimeSpan GetInactivitySpan(int days) => days == 0
-                ? TimeSpan.FromMinutes(15)
-                : TimeSpan.FromDays(days);
+        private static List<GroupPair> GetPruneUserList(
+            List<GroupPair> allGroupUsers,
+            HashSet<string> onlineUids,
+            TimeSpan inactivitySpan,
+            DateTime now)
+        {
+            return
+            [
+                .. allGroupUsers.Where(p =>
+                    !p.IsPinned &&
+                    !p.IsModerator &&
+                    !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
+                    !onlineUids.Contains(p.GroupUserUID) &&
+                    p.GroupUser.LastLoggedIn < now - inactivitySpan),
+            ];
+        }
+
+        private async Task<HashSet<string>> GetOnlineUidsAsync()
+        {
+            var keys = await _redis.SearchKeysAsync("UID:*").ConfigureAwait(false);
+
+            var set = new HashSet<string>(StringComparer.Ordinal);
+
+            foreach (var k in keys)
+            {
+                if (string.IsNullOrEmpty(k)) continue;
+
+                const string prefix = "UID:";
+                if (k.StartsWith(prefix, StringComparison.Ordinal))
+                {
+                    var uid = k.Substring(prefix.Length);
+                    if (!string.IsNullOrEmpty(uid))
+                        set.Add(uid);
+                }
+                else
+                {
+                    var idx = k.IndexOf(':', StringComparison.Ordinal);
+                    if (idx >= 0 && idx < k.Length - 1)
+                        set.Add(k[(idx + 1)..]);
+                }
+            }
+
+            return set;
+        }
+
+        private static TimeSpan GetInactivitySpan(int days) =>
+            days == 0 ? TimeSpan.FromHours(2) : TimeSpan.FromDays(days);
     }
-}
+}

LightlessSyncServer/LightlessSyncServer/Startup.cs

@@ -93,6 +93,7 @@ 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>();

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

@@ -118,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

@@ -30,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

@@ -24,7 +24,7 @@ namespace LightlessSyncServer.Worker
                         var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<LightlessHub>>();
 
                         var groups = await db.Groups
-                            .Where(g => g.AutoPruneEnabled && g.AutoPruneDays > 0)
+                            .Where(g => g.AutoPruneEnabled)
                             .ToListAsync(stoppingToken).ConfigureAwait(false);
 
                         foreach (var group in groups)

LightlessSyncServer/LightlessSyncServer/appsettings.json

@@ -41,6 +41,9 @@
     "PairRequestRateLimit": 5,
     "PairRequestRateWindow": 60
   },
+  "ChatZoneOverrides": {
+    "Zones": []
+  },
   "AllowedHosts": "*",
   "Kestrel": {
     "Endpoints": {

LightlessSyncServer/LightlessSyncServices/Discord/DiscordBot.cs

@@ -1,9 +1,6 @@
-using System.Collections.Generic;
-using System;
 using System.Globalization;
 using System.Text;
 using System.Text.Json;
-using System.Linq;
 using Discord;
 using Discord.Interactions;
 using Discord.Rest;
@@ -204,7 +201,7 @@ internal class DiscordBot : IHostedService
             var embed = await BuildChatReportEmbedAsync(dbContext, report, token).ConfigureAwait(false);
 
             var components = new ComponentBuilder()
-                .WithButton("Actioned", $"{ChatReportButtonPrefix}-resolve-{report.ReportId}", ButtonStyle.Danger)
+                .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);
 
@@ -395,7 +392,7 @@ internal class DiscordBot : IHostedService
         switch (action)
         {
             case "resolve":
-                resolutionLabel = "Actioned";
+                resolutionLabel = "Resolved";
                 break;
             case "dismiss":
                 resolutionLabel = "Dismissed";
@@ -431,7 +428,7 @@ internal class DiscordBot : IHostedService
 
         string responseText = action switch
         {
-            "resolve" => "actioned",
+            "resolve" => "resolved",
             "dismiss" => "dismissed",
             "banchat" => "chat access revoked",
             _ => "processed"
@@ -473,7 +470,7 @@ internal class DiscordBot : IHostedService
         embedBuilder.Fields.RemoveAll(f => string.Equals(f.Name, "Resolution", StringComparison.OrdinalIgnoreCase));
         var resolutionText = action switch
         {
-            "resolve" => "Actioned",
+            "resolve" => "Resolved",
             "dismiss" => "Dismissed",
             "banchat" => "Chat access revoked",
             _ => "Processed"
@@ -872,16 +869,17 @@ internal class DiscordBot : IHostedService
         string? SenderHashedCid,
         string Message);
 
-    private async Task UpdateStatusAsync(CancellationToken token)
+    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

@@ -43,33 +43,54 @@ public class LightlessModule : InteractionModuleBase
 
         try
         {
-            EmbedBuilder eb = new();
-
             using var scope = _services.CreateScope();
             var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
             await using (db.ConfigureAwait(false))
             {
-                eb = await HandleUserInfo(eb, db, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);
+                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);
-                    eb.WithThumbnailUrl("attachment://profileimage.png");
-                    eb.WithImageUrl("attachment://bannerimage.png");
+                    
+                    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: new[] { eb.Build() },
+                        embeds: embeds.ToArray(),
                         ephemeral: true).ConfigureAwait(false);
                 } 
                 else
                 {
                     await RespondAsync(
-                        embeds: new[] { eb.Build() },
+                        embeds: embeds.ToArray(),
                         ephemeral: true).ConfigureAwait(false);
                 }
             }
@@ -449,7 +470,7 @@ public class LightlessModule : InteractionModuleBase
         return embed.Build();
     }
 
-    private async Task<EmbedBuilder> HandleUserInfo(EmbedBuilder eb, LightlessDbContext db, 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;
 
@@ -459,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)
         {
@@ -486,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;
@@ -501,9 +525,10 @@ 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);
             }
         }
 
@@ -513,55 +538,61 @@ public class LightlessModule : InteractionModuleBase
         var profile = await db.UserProfileData.Where(u => u.UserUID == dbUser.UID).SingleOrDefaultAsync().ConfigureAwait(false);
         var identity = await _connectionMultiplexer.GetDatabase().StringGetAsync("UID:" + dbUser.UID).ConfigureAwait(false);
 
-        eb.WithTitle("User Information");
-        eb.WithDescription("This is the user information for Discord User <@" + userToCheckForDiscordId + ">" + Environment.NewLine + Environment.NewLine
+        EmbedBuilder mainEmbed = new();
+        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));
             }
         }
-        if(profile != null)
-        {
-            eb.AddField("Profile Description", string.IsNullOrEmpty(profile.UserDescription) ? "(No description set)" : profile.UserDescription);
-            eb.AddField("Profile NSFW", profile.IsNSFW);
-            eb.AddField("Profile Disabled", profile.ProfileDisabled);
-            eb.AddField("Profile Flagged for Report", profile.FlaggedForReport);
-            eb.AddField("Profile Tags", profile.Tags != null && profile.Tags.Length > 0 ? string.Join(", ", profile.Tags) : "(No tags set)");
-        }
-        eb.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
-        eb.AddField("Currently online ", !string.IsNullOrEmpty(identity));
-        eb.AddField("Hashed Secret Key", auth.HashedKey);
-        eb.AddField("Joined Syncshells", groupsJoined.Count);
-        eb.AddField("Owned Syncshells", groups.Count);
+        mainEmbed.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
+        mainEmbed.AddField("Currently online ", !string.IsNullOrEmpty(identity));
+        mainEmbed.AddField("Hashed Secret Key", auth.HashedKey);
+        mainEmbed.AddField("Joined Syncshells", groupsJoined.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)
@@ -578,7 +609,7 @@ public class LightlessModule : InteractionModuleBase
             }
             else if (uid != null)
             {
-                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid).ConfigureAwait(false);
+                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid). ConfigureAwait(false);
             }
             if (userInDb == null)
             {

LightlessSyncServer/LightlessSyncServices/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

@@ -80,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);

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/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/20251229015535_ShareLocation.cs

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

LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs

@@ -438,6 +438,12 @@ namespace LightlessSyncServer.Migrations
                         .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")
@@ -776,11 +782,6 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("text")
                         .HasColumnName("sender_hashed_cid");
 
-                    b.Property<string>("SenderToken")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("sender_token");
-
                     b.Property<bool>("SenderWasLightfinder")
                         .HasColumnType("boolean")
                         .HasColumnName("sender_was_lightfinder");
@@ -940,6 +941,10 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("is_paused");
 
+                    b.Property<DateTimeOffset>("ShareLocationUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("share_location_until");
+
                     b.Property<bool>("Sticky")
                         .HasColumnType("boolean")
                         .HasColumnName("sticky");

LightlessSyncServer/LightlessSyncShared/Models/Group.cs

@@ -19,5 +19,6 @@ public class Group
     public bool PreferDisableSounds { get; set; }
     public bool PreferDisableAnimations { get; set; }
     public bool PreferDisableVFX { get; set; }
+    public bool ChatEnabled { get; set; } = true;
     public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
 }

LightlessSyncServer/LightlessSyncShared/Models/ReportedChatMessage.cs

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

LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs

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

LightlessSyncServer/LightlessSyncStaticFilesServer/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/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);
-        if (string.IsNullOrEmpty(coldStorageDir)) return false;
+		string coldStorageDir = _configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.ColdStorageDirectory), string.Empty);
+		if (string.IsNullOrEmpty(coldStorageDir)) return false;
 
-        var coldStorageFilePath = FilePathUtil.GetFileInfoForHash(coldStorageDir, hash);
-        if (coldStorageFilePath == null) return false;
+		var coldStorageFilePath = FilePathUtil.GetFileInfoForHash(coldStorageDir, hash);
+		if (coldStorageFilePath == null) return false;
 
-        try
-        {
-            _logger.LogDebug("Copying {hash} from cold storage: {path}", hash, coldStorageFilePath);
-            var tempFileName = destinationFilePath + ".dl";
-            File.Copy(coldStorageFilePath.FullName, tempFileName, 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);
-        }
+		try
+		{
+			_logger.LogDebug("Copying {hash} from cold storage: {path}", hash, coldStorageFilePath);
+			var tempFileName = destinationFilePath + ".dl";
+			File.Copy(coldStorageFilePath.FullName, tempFileName, true);
+			File.Move(tempFileName, destinationFilePath, true);
 
-        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);
-        if (fi == null) return null;
+		var fi = FilePathUtil.GetFileInfoForHash(_hotStoragePath, hash);
+		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)
     {