feat: Implement IRC Gateway Service and related functionality

- Add IrcGatewayService to handle IRC connections and commands. - Create IrcMessage class for parsing IRC protocol lines. - Implement IrcMessageFormatter for formatting messages as IRC lines. - Define IrcNumericReply constants for IRC numeric replies. - Add IrcOptions class for configuration settings related to IRC. - Create IrcServiceExtensions for adding IRC services to the application. - Refactor ChannelsController to use IChatService for broadcasting messages and channel updates. - Update ChatHub to utilize IChatService for user connection and message handling. - Introduce ChatService to manage chat-related operations and interactions. - Implement SignalRBroadcaster for broadcasting messages to SignalR clients. - Update PresenceTracker to retrieve usernames for connections. - Modify appsettings.example.json to include IRC configuration options. - Update solution file to include the new IRC project.
2026-09-04 08:36:11 +02:00 · 2026-02-19 11:31:20 +01:00
parent da7c16d5d0
commit cb6b9d1e55
21 changed files with 1706 additions and 215 deletions
@@ -4,12 +4,10 @@ using EchoHub.Core.Contracts;
 using EchoHub.Core.DTOs;
 using EchoHub.Core.Models;
 using EchoHub.Server.Data;
-using EchoHub.Server.Hubs;
 using EchoHub.Server.Services;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.RateLimiting;
-using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;

 namespace EchoHub.Server.Controllers;
@@ -23,7 +21,7 @@ public class ChannelsController(
    FileStorageService fileStorage,
    ImageToAsciiService asciiService,
    IHttpClientFactory httpClientFactory,
-    IHubContext<ChatHub, IEchoHubClient> hubContext) : ControllerBase
+    IChatService chatService) : ControllerBase
 {
    [HttpGet]
    public async Task<IActionResult> GetChannels([FromQuery] int offset = 0, [FromQuery] int limit = 50)
@@ -78,7 +76,7 @@ public class ChannelsController(
        await db.SaveChangesAsync();

        var dto = new ChannelDto(channel.Id, channel.Name, channel.Topic, 0, channel.CreatedAt);
-        await hubContext.Clients.All.ChannelUpdated(dto);
+        await chatService.BroadcastChannelUpdatedAsync(dto);

        return Created($"/api/channels/{channelName}", dto);
    }
@@ -107,7 +105,7 @@ public class ChannelsController(

        var messageCount = await db.Messages.CountAsync(m => m.ChannelId == dbChannel.Id);
        var dto = new ChannelDto(dbChannel.Id, dbChannel.Name, dbChannel.Topic, messageCount, dbChannel.CreatedAt);
-        await hubContext.Clients.Group(channelName).ChannelUpdated(dto);
+        await chatService.BroadcastChannelUpdatedAsync(dto, channelName);

        return Ok(dto);
    }
@@ -214,7 +212,7 @@ public class ChannelsController(
            file.FileName,
            message.SentAt);

-        await hubContext.Clients.Group(channelName).ReceiveMessage(messageDto);
+        await chatService.BroadcastMessageAsync(channelName, messageDto);

        return Ok(messageDto);
    }
@@ -331,7 +329,7 @@ public class ChannelsController(
            fileName,
            message.SentAt);

-        await hubContext.Clients.Group(channelName).ReceiveMessage(messageDto);
+        await chatService.BroadcastMessageAsync(channelName, messageDto);

        return Ok(messageDto);
    }
@@ -2,6 +2,7 @@

  <ItemGroup>
    <ProjectReference Include="..\EchoHub.Core\EchoHub.Core.csproj" />
+    <ProjectReference Include="..\EchoHub.Server.Irc\EchoHub.Server.Irc.csproj" />
  </ItemGroup>

  <ItemGroup>
@@ -3,16 +3,13 @@ using EchoHub.Core.Constants;
 using EchoHub.Core.Contracts;
 using EchoHub.Core.DTOs;
 using EchoHub.Core.Models;
-using EchoHub.Server.Data;
-using EchoHub.Server.Services;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
-using Microsoft.EntityFrameworkCore;

 namespace EchoHub.Server.Hubs;

 [Authorize]
-public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTracker presenceTracker) : Hub<IEchoHubClient>
+public class ChatHub(IChatService chatService, ILogger<ChatHub> logger) : Hub<IEchoHubClient>
 {
    private Guid CurrentUserId =>
        Guid.Parse(Context.User?.FindFirstValue(ClaimTypes.NameIdentifier)
@@ -26,19 +23,8 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            presenceTracker.UserConnected(Context.ConnectionId, CurrentUserId, CurrentUsername);
-
-            var user = await db.Users.FindAsync(CurrentUserId);
-            if (user is not null)
-            {
-                user.LastSeenAt = DateTimeOffset.UtcNow;
-                user.Status = UserStatus.Online;
-                await db.SaveChangesAsync();
-            }
-
+            await chatService.UserConnectedAsync(Context.ConnectionId, CurrentUserId, CurrentUsername);
            await base.OnConnectedAsync();
-
-            logger.LogInformation("{User} connected (ConnectionId: {ConnectionId})", CurrentUsername, Context.ConnectionId);
        }
        catch (Exception ex)
        {
@@ -51,39 +37,8 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            var preDisconnectUsername = Context.User?.FindFirstValue("username");
-            var channelsBeforeDisconnect = preDisconnectUsername is not null
-                ? presenceTracker.GetChannelsForUser(preDisconnectUsername)
-                : [];
-
-            var username = presenceTracker.UserDisconnected(Context.ConnectionId);
-
-            if (username is not null && !presenceTracker.IsOnline(username))
-            {
-                var user = await db.Users.FirstOrDefaultAsync(u => u.Username == username);
-                if (user is not null)
-                {
-                    user.LastSeenAt = DateTimeOffset.UtcNow;
-                    user.Status = UserStatus.Invisible;
-                    await db.SaveChangesAsync();
-
-                    var presence = new UserPresenceDto(
-                        username,
-                        user.DisplayName,
-                        user.NicknameColor,
-                        UserStatus.Invisible,
-                        user.StatusMessage);
-
-                    foreach (var channel in channelsBeforeDisconnect)
-                    {
-                        await Clients.Group(channel).UserStatusChanged(presence);
-                    }
-                }
-            }
-
+            await chatService.UserDisconnectedAsync(Context.ConnectionId);
            await base.OnDisconnectedAsync(exception);
-
-            logger.LogInformation("{User} disconnected (ConnectionId: {ConnectionId})", username ?? "Unknown", Context.ConnectionId);
        }
        catch (Exception ex)
        {
@@ -96,32 +51,16 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            channelName = channelName.ToLowerInvariant().Trim();
+            var (history, error) = await chatService.JoinChannelAsync(
+                Context.ConnectionId, CurrentUserId, CurrentUsername, channelName);

-            if (!ValidationConstants.ChannelNameRegex().IsMatch(channelName))
+            if (error is not null)
            {
-                await Clients.Caller.Error("Invalid channel name. Use 2-100 characters: letters, digits, underscores, or hyphens.");
+                await Clients.Caller.Error(error);
                return [];
            }

-            var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
-
-            if (channel is null)
-            {
-                await Clients.Caller.Error($"Channel '{channelName}' does not exist. Create it first via the channel list.");
-                return [];
-            }
-
-            var isNewJoin = presenceTracker.JoinChannel(CurrentUsername, channelName);
-
-            if (isNewJoin)
-            {
-                await Groups.AddToGroupAsync(Context.ConnectionId, channelName);
-                await Clients.OthersInGroup(channelName).UserJoined(channelName, CurrentUsername);
-                logger.LogInformation("{User} joined channel '{Channel}'", CurrentUsername, channelName);
-            }
-
-            var history = await GetChannelHistory(channelName, HubConstants.DefaultHistoryCount);
+            await Groups.AddToGroupAsync(Context.ConnectionId, channelName.ToLowerInvariant().Trim());
            return history;
        }
        catch (Exception ex)
@@ -137,13 +76,8 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
        try
        {
            channelName = channelName.ToLowerInvariant().Trim();
-
-            presenceTracker.LeaveChannel(CurrentUsername, channelName);
-
+            await chatService.LeaveChannelAsync(Context.ConnectionId, CurrentUsername, channelName);
            await Groups.RemoveFromGroupAsync(Context.ConnectionId, channelName);
-            await Clients.OthersInGroup(channelName).UserLeft(channelName, CurrentUsername);
-
-            logger.LogInformation("{User} left channel '{Channel}'", CurrentUsername, channelName);
        }
        catch (Exception ex)
        {
@@ -156,64 +90,9 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            channelName = channelName.ToLowerInvariant().Trim();
-
-            if (!ValidationConstants.ChannelNameRegex().IsMatch(channelName))
-            {
-                await Clients.Caller.Error("Invalid channel name.");
-                return;
-            }
-
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                await Clients.Caller.Error("Message content cannot be empty.");
-                return;
-            }
-
-            if (content.Length > HubConstants.MaxMessageLength)
-            {
-                await Clients.Caller.Error($"Message exceeds maximum length of {HubConstants.MaxMessageLength} characters.");
-                return;
-            }
-
-            var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
-
-            if (channel is null)
-            {
-                await Clients.Caller.Error($"Channel '{channelName}' does not exist.");
-                return;
-            }
-
-            var sender = await db.Users.FindAsync(CurrentUserId);
-
-            var message = new Message
-            {
-                Id = Guid.NewGuid(),
-                Content = content,
-                Type = MessageType.Text,
-                SentAt = DateTimeOffset.UtcNow,
-                ChannelId = channel.Id,
-                SenderUserId = CurrentUserId,
-                SenderUsername = CurrentUsername,
-            };
-
-            db.Messages.Add(message);
-            await db.SaveChangesAsync();
-
-            var messageDto = new MessageDto(
-                message.Id,
-                message.Content,
-                message.SenderUsername,
-                sender?.NicknameColor,
-                channelName,
-                MessageType.Text,
-                null,
-                null,
-                message.SentAt);
-
-            await Clients.Group(channelName).ReceiveMessage(messageDto);
-
-            logger.LogDebug("{User} sent message in '{Channel}'", CurrentUsername, channelName);
+            var error = await chatService.SendMessageAsync(CurrentUserId, CurrentUsername, channelName, content);
+            if (error is not null)
+                await Clients.Caller.Error(error);
        }
        catch (Exception ex)
        {
@@ -226,35 +105,7 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            channelName = channelName.ToLowerInvariant().Trim();
-            count = Math.Clamp(count, 1, ValidationConstants.MaxHistoryCount);
-
-            var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
-
-            if (channel is null)
-                return [];
-
-            var messages = await db.Messages
-                .Where(m => m.ChannelId == channel.Id)
-                .OrderByDescending(m => m.SentAt)
-                .Take(count)
-                .Join(db.Users,
-                    m => m.SenderUserId,
-                    u => u.Id,
-                    (m, u) => new MessageDto(
-                        m.Id,
-                        m.Content,
-                        m.SenderUsername,
-                        u.NicknameColor,
-                        channelName,
-                        m.Type,
-                        m.AttachmentUrl,
-                        m.AttachmentFileName,
-                        m.SentAt))
-                .ToListAsync();
-
-            messages.Reverse();
-            return messages;
+            return await chatService.GetChannelHistoryAsync(channelName, count);
        }
        catch (Exception ex)
        {
@@ -268,37 +119,9 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            if (statusMessage is not null && statusMessage.Length > ValidationConstants.MaxStatusMessageLength)
-            {
-                await Clients.Caller.Error($"Status message must not exceed {ValidationConstants.MaxStatusMessageLength} characters.");
-                return;
-            }
-
-            var user = await db.Users.FindAsync(CurrentUserId);
-
-            if (user is null)
-            {
-                await Clients.Caller.Error("User not found.");
-                return;
-            }
-
-            user.Status = status;
-            user.StatusMessage = statusMessage?.Trim();
-            user.LastSeenAt = DateTimeOffset.UtcNow;
-            await db.SaveChangesAsync();
-
-            var presence = new UserPresenceDto(
-                user.Username,
-                user.DisplayName,
-                user.NicknameColor,
-                status,
-                statusMessage);
-
-            var channels = presenceTracker.GetChannelsForUser(CurrentUsername);
-            var connections = presenceTracker.GetConnectionsInChannels(channels);
-
-            if (connections.Count > 0)
-                await Clients.Clients(connections).UserStatusChanged(presence);
+            var error = await chatService.UpdateStatusAsync(CurrentUserId, CurrentUsername, status, statusMessage);
+            if (error is not null)
+                await Clients.Caller.Error(error);
        }
        catch (Exception ex)
        {
@@ -311,21 +134,7 @@ public class ChatHub(EchoHubDbContext db, ILogger<ChatHub> logger, PresenceTrack
    {
        try
        {
-            channelName = channelName.ToLowerInvariant().Trim();
-
-            var onlineUsernames = presenceTracker.GetOnlineUsersInChannel(channelName);
-
-            var users = await db.Users
-                .Where(u => onlineUsernames.Contains(u.Username))
-                .Select(u => new UserPresenceDto(
-                    u.Username,
-                    u.DisplayName,
-                    u.NicknameColor,
-                    u.Status,
-                    u.StatusMessage))
-                .ToListAsync();
-
-            return users;
+            return await chatService.GetOnlineUsersAsync(channelName);
        }
        catch (Exception ex)
        {
@@ -1,10 +1,12 @@
 using System.Text;
 using System.Threading.RateLimiting;
 using EchoHub.Core.Constants;
+using EchoHub.Core.Contracts;
 using EchoHub.Core.Models;
 using EchoHub.Server.Auth;
 using EchoHub.Server.Data;
 using EchoHub.Server.Hubs;
+using EchoHub.Server.Irc;
 using EchoHub.Server.Services;
 using EchoHub.Server.Setup;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
@@ -101,6 +103,14 @@ while (true)
        builder.Services.AddSingleton<ImageToAsciiService>();
        builder.Services.AddSingleton<FileStorageService>();
        builder.Services.AddHostedService<ServerDirectoryService>();
+
+        // ── Chat Service + Broadcasters ─────────────────────────────────────
+        builder.Services.AddSingleton<IChatBroadcaster, SignalRBroadcaster>();
+        builder.Services.AddSingleton<IChatService, ChatService>();
+
+        // ── IRC Gateway (optional) ──────────────────────────────────────────
+        builder.AddIrcGateway();
+
        builder.Services.AddHttpClient("ImageDownload", client =>
        {
            client.Timeout = TimeSpan.FromSeconds(15);
@@ -0,0 +1,330 @@
+using EchoHub.Core.Constants;
+using EchoHub.Core.Contracts;
+using EchoHub.Core.DTOs;
+using EchoHub.Core.Models;
+using EchoHub.Server.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace EchoHub.Server.Services;
+
+public class ChatService(
+    IServiceScopeFactory scopeFactory,
+    PresenceTracker presenceTracker,
+    IEnumerable<IChatBroadcaster> broadcasters,
+    ILogger<ChatService> logger) : IChatService
+{
+    public async Task UserConnectedAsync(string connectionId, Guid userId, string username)
+    {
+        presenceTracker.UserConnected(connectionId, userId, username);
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var user = await db.Users.FindAsync(userId);
+        if (user is not null)
+        {
+            user.LastSeenAt = DateTimeOffset.UtcNow;
+            user.Status = UserStatus.Online;
+            await db.SaveChangesAsync();
+        }
+
+        logger.LogInformation("{User} connected (ConnectionId: {ConnectionId})", username, connectionId);
+    }
+
+    public async Task<string?> UserDisconnectedAsync(string connectionId)
+    {
+        var preDisconnectUsername = presenceTracker.GetUsernameForConnection(connectionId);
+        var channelsBeforeDisconnect = preDisconnectUsername is not null
+            ? presenceTracker.GetChannelsForUser(preDisconnectUsername)
+            : [];
+
+        var username = presenceTracker.UserDisconnected(connectionId);
+
+        if (username is not null && !presenceTracker.IsOnline(username))
+        {
+            using var scope = scopeFactory.CreateScope();
+            var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+            var user = await db.Users.FirstOrDefaultAsync(u => u.Username == username);
+            if (user is not null)
+            {
+                user.LastSeenAt = DateTimeOffset.UtcNow;
+                user.Status = UserStatus.Invisible;
+                await db.SaveChangesAsync();
+
+                var presence = new UserPresenceDto(
+                    username,
+                    user.DisplayName,
+                    user.NicknameColor,
+                    UserStatus.Invisible,
+                    user.StatusMessage);
+
+                await BroadcastToAllAsync(b => b.SendUserStatusChangedAsync(channelsBeforeDisconnect, presence));
+            }
+        }
+
+        logger.LogInformation("{User} disconnected (ConnectionId: {ConnectionId})", username ?? "Unknown", connectionId);
+        return username;
+    }
+
+    public async Task<(List<MessageDto> History, string? Error)> JoinChannelAsync(
+        string connectionId, Guid userId, string username, string channelName)
+    {
+        channelName = channelName.ToLowerInvariant().Trim();
+
+        if (!ValidationConstants.ChannelNameRegex().IsMatch(channelName))
+            return ([], "Invalid channel name. Use 2-100 characters: letters, digits, underscores, or hyphens.");
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
+        if (channel is null)
+            return ([], $"Channel '{channelName}' does not exist. Create it first via the channel list.");
+
+        var isNewJoin = presenceTracker.JoinChannel(username, channelName);
+
+        if (isNewJoin)
+        {
+            await BroadcastToAllAsync(b => b.SendUserJoinedAsync(channelName, username, connectionId));
+            logger.LogInformation("{User} joined channel '{Channel}'", username, channelName);
+        }
+
+        var history = await GetChannelHistoryInternalAsync(db, channelName, HubConstants.DefaultHistoryCount);
+        return (history, null);
+    }
+
+    public async Task LeaveChannelAsync(string connectionId, string username, string channelName)
+    {
+        channelName = channelName.ToLowerInvariant().Trim();
+        presenceTracker.LeaveChannel(username, channelName);
+        await BroadcastToAllAsync(b => b.SendUserLeftAsync(channelName, username));
+        logger.LogInformation("{User} left channel '{Channel}'", username, channelName);
+    }
+
+    public async Task<string?> SendMessageAsync(Guid userId, string username, string channelName, string content)
+    {
+        channelName = channelName.ToLowerInvariant().Trim();
+
+        if (!ValidationConstants.ChannelNameRegex().IsMatch(channelName))
+            return "Invalid channel name.";
+
+        if (string.IsNullOrWhiteSpace(content))
+            return "Message content cannot be empty.";
+
+        if (content.Length > HubConstants.MaxMessageLength)
+            return $"Message exceeds maximum length of {HubConstants.MaxMessageLength} characters.";
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
+        if (channel is null)
+            return $"Channel '{channelName}' does not exist.";
+
+        var sender = await db.Users.FindAsync(userId);
+
+        var message = new Message
+        {
+            Id = Guid.NewGuid(),
+            Content = content,
+            Type = MessageType.Text,
+            SentAt = DateTimeOffset.UtcNow,
+            ChannelId = channel.Id,
+            SenderUserId = userId,
+            SenderUsername = username,
+        };
+
+        db.Messages.Add(message);
+        await db.SaveChangesAsync();
+
+        var messageDto = new MessageDto(
+            message.Id,
+            message.Content,
+            message.SenderUsername,
+            sender?.NicknameColor,
+            channelName,
+            MessageType.Text,
+            null,
+            null,
+            message.SentAt);
+
+        await BroadcastToAllAsync(b => b.SendMessageToChannelAsync(channelName, messageDto));
+
+        logger.LogDebug("{User} sent message in '{Channel}'", username, channelName);
+        return null;
+    }
+
+    public async Task<List<MessageDto>> GetChannelHistoryAsync(string channelName, int count)
+    {
+        channelName = channelName.ToLowerInvariant().Trim();
+        count = Math.Clamp(count, 1, ValidationConstants.MaxHistoryCount);
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        return await GetChannelHistoryInternalAsync(db, channelName, count);
+    }
+
+    public async Task<string?> UpdateStatusAsync(Guid userId, string username, UserStatus status, string? statusMessage)
+    {
+        if (statusMessage is not null && statusMessage.Length > ValidationConstants.MaxStatusMessageLength)
+            return $"Status message must not exceed {ValidationConstants.MaxStatusMessageLength} characters.";
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var user = await db.Users.FindAsync(userId);
+        if (user is null)
+            return "User not found.";
+
+        user.Status = status;
+        user.StatusMessage = statusMessage?.Trim();
+        user.LastSeenAt = DateTimeOffset.UtcNow;
+        await db.SaveChangesAsync();
+
+        var presence = new UserPresenceDto(
+            user.Username,
+            user.DisplayName,
+            user.NicknameColor,
+            status,
+            statusMessage);
+
+        var channels = presenceTracker.GetChannelsForUser(username);
+        await BroadcastToAllAsync(b => b.SendUserStatusChangedAsync(channels, presence));
+
+        return null;
+    }
+
+    public async Task<List<UserPresenceDto>> GetOnlineUsersAsync(string channelName)
+    {
+        channelName = channelName.ToLowerInvariant().Trim();
+        var onlineUsernames = presenceTracker.GetOnlineUsersInChannel(channelName);
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        return await db.Users
+            .Where(u => onlineUsernames.Contains(u.Username))
+            .Select(u => new UserPresenceDto(
+                u.Username,
+                u.DisplayName,
+                u.NicknameColor,
+                u.Status,
+                u.StatusMessage))
+            .ToListAsync();
+    }
+
+    public Task BroadcastMessageAsync(string channelName, MessageDto message)
+        => BroadcastToAllAsync(b => b.SendMessageToChannelAsync(channelName, message));
+
+    public Task BroadcastChannelUpdatedAsync(ChannelDto channel, string? channelName = null)
+        => BroadcastToAllAsync(b => b.SendChannelUpdatedAsync(channel, channelName));
+
+    private async Task BroadcastToAllAsync(Func<IChatBroadcaster, Task> action)
+    {
+        foreach (var broadcaster in broadcasters)
+        {
+            try
+            {
+                await action(broadcaster);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Broadcaster {Type} failed", broadcaster.GetType().Name);
+            }
+        }
+    }
+
+    public async Task<UserProfileDto?> GetUserProfileAsync(string username)
+    {
+        username = username.ToLowerInvariant();
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var user = await db.Users.FirstOrDefaultAsync(u => u.Username == username);
+        if (user is null) return null;
+
+        return new UserProfileDto(
+            user.Id, user.Username, user.DisplayName, user.Bio,
+            user.NicknameColor, user.AvatarAscii, user.Status,
+            user.StatusMessage, user.CreatedAt, user.LastSeenAt);
+    }
+
+    public async Task<(string? Topic, bool Exists)> GetChannelTopicAsync(string channelName)
+    {
+        channelName = channelName.ToLowerInvariant().Trim();
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
+        if (channel is null) return (null, false);
+
+        return (channel.Topic, true);
+    }
+
+    public async Task<List<ChannelListItem>> GetChannelListAsync()
+    {
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var channels = await db.Channels.OrderBy(c => c.Name).ToListAsync();
+
+        return channels.Select(c => new ChannelListItem(
+            c.Name,
+            c.Topic,
+            presenceTracker.GetOnlineUsersInChannel(c.Name).Count)).ToList();
+    }
+
+    public Task<List<string>> GetChannelsForUserAsync(string username)
+        => Task.FromResult(presenceTracker.GetChannelsForUser(username));
+
+    public async Task<(Guid UserId, string Username)?> AuthenticateUserAsync(string username, string password)
+    {
+        username = username.ToLowerInvariant();
+
+        using var scope = scopeFactory.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
+
+        var user = await db.Users.FirstOrDefaultAsync(u => u.Username == username);
+        if (user is null) return null;
+
+        if (!BCrypt.Net.BCrypt.Verify(password, user.PasswordHash))
+            return null;
+
+        return (user.Id, user.Username);
+    }
+
+    private static async Task<List<MessageDto>> GetChannelHistoryInternalAsync(EchoHubDbContext db, string channelName, int count)
+    {
+        var channel = await db.Channels.FirstOrDefaultAsync(c => c.Name == channelName);
+        if (channel is null)
+            return [];
+
+        var messages = await db.Messages
+            .Where(m => m.ChannelId == channel.Id)
+            .OrderByDescending(m => m.SentAt)
+            .Take(count)
+            .Join(db.Users,
+                m => m.SenderUserId,
+                u => u.Id,
+                (m, u) => new MessageDto(
+                    m.Id,
+                    m.Content,
+                    m.SenderUsername,
+                    u.NicknameColor,
+                    channelName,
+                    m.Type,
+                    m.AttachmentUrl,
+                    m.AttachmentFileName,
+                    m.SentAt))
+            .ToListAsync();
+
+        messages.Reverse();
+        return messages;
+    }
+}
@@ -137,6 +137,11 @@ public class PresenceTracker
        }
    }

+    public string? GetUsernameForConnection(string connectionId)
+    {
+        return _connections.TryGetValue(connectionId, out var info) ? info.username : null;
+    }
+
    public bool IsOnline(string username)
    {
        return _userConnections.TryGetValue(username, out var connections) && connections.Count > 0;
@@ -0,0 +1,53 @@
+using EchoHub.Core.Contracts;
+using EchoHub.Core.DTOs;
+using EchoHub.Server.Hubs;
+using Microsoft.AspNetCore.SignalR;
+
+namespace EchoHub.Server.Services;
+
+public class SignalRBroadcaster(
+    IHubContext<ChatHub, IEchoHubClient> hubContext,
+    PresenceTracker presenceTracker) : IChatBroadcaster
+{
+    public Task SendMessageToChannelAsync(string channelName, MessageDto message)
+        => hubContext.Clients.Group(channelName).ReceiveMessage(message);
+
+    public Task SendUserJoinedAsync(string channelName, string username, string? excludeConnectionId = null)
+    {
+        if (excludeConnectionId is not null && !excludeConnectionId.StartsWith("irc-"))
+            return hubContext.Clients.GroupExcept(channelName, [excludeConnectionId]).UserJoined(channelName, username);
+
+        return hubContext.Clients.Group(channelName).UserJoined(channelName, username);
+    }
+
+    public Task SendUserLeftAsync(string channelName, string username)
+        => hubContext.Clients.Group(channelName).UserLeft(channelName, username);
+
+    public Task SendChannelUpdatedAsync(ChannelDto channel, string? channelName = null)
+    {
+        if (channelName is not null)
+            return hubContext.Clients.Group(channelName).ChannelUpdated(channel);
+
+        return hubContext.Clients.All.ChannelUpdated(channel);
+    }
+
+    public Task SendUserStatusChangedAsync(List<string> channelNames, UserPresenceDto presence)
+    {
+        var connections = presenceTracker.GetConnectionsInChannels(channelNames)
+            .Where(c => !c.StartsWith("irc-"))
+            .ToList();
+
+        if (connections.Count == 0)
+            return Task.CompletedTask;
+
+        return hubContext.Clients.Clients(connections).UserStatusChanged(presence);
+    }
+
+    public Task SendErrorAsync(string connectionId, string message)
+    {
+        if (connectionId.StartsWith("irc-"))
+            return Task.CompletedTask;
+
+        return hubContext.Clients.Client(connectionId).Error(message);
+    }
+}
@@ -14,6 +14,16 @@
    "PublicServer": false,
    "PublicHost": ""
  },
+  "Irc": {
+    "Enabled": false,
+    "Port": 6667,
+    "TlsEnabled": false,
+    "TlsPort": 6697,
+    "TlsCertPath": "",
+    "TlsCertPassword": "",
+    "ServerName": "echohub",
+    "Motd": "Welcome to EchoHub IRC Gateway!"
+  },
  "Serilog": {
    "MinimumLevel": {
      "Default": "Information",