diff --git a/ChatTwo/ChatTwo.csproj b/ChatTwo/ChatTwo.csproj
index fa990e4..88a83fa 100755
--- a/ChatTwo/ChatTwo.csproj
+++ b/ChatTwo/ChatTwo.csproj
@@ -46,14 +46,21 @@
$(DalamudLibPath)\Lumina.Excel.dll
false
+
+ $(DalamudLibPath)\Newtonsoft.Json.dll
+ false
+
+
+
+
@@ -74,4 +81,13 @@
+
+
+
+ Always
+
+
+ Always
+
+
diff --git a/ChatTwo/Configuration.cs b/ChatTwo/Configuration.cs
index 257d81d..eb84b19 100755
--- a/ChatTwo/Configuration.cs
+++ b/ChatTwo/Configuration.cs
@@ -120,6 +120,10 @@ internal class Configuration : IPluginConfiguration
public ConfigKeyBind? ChatTabForward;
public ConfigKeyBind? ChatTabBackward;
+ // Webinterface
+ public bool WebinterfaceEnabled;
+ public string WebinterfacePassword = WebinterfaceUtil.GenerateSimpleAuthCode();
+
internal void UpdateFrom(Configuration other, bool backToOriginal)
{
if (backToOriginal)
@@ -183,6 +187,8 @@ internal class Configuration : IPluginConfiguration
ChosenStyle = other.ChosenStyle;
ChatTabForward = other.ChatTabForward;
ChatTabBackward = other.ChatTabBackward;
+ WebinterfaceEnabled = other.WebinterfaceEnabled;
+ WebinterfacePassword = other.WebinterfacePassword;
}
}
@@ -286,26 +292,26 @@ internal class Tab
///
internal class MessageList
{
- private ReaderWriterLock rwl = new();
+ private readonly SemaphoreSlim LockSlim = new(1, 1);
- private readonly List messages;
- private readonly HashSet trackedMessageIds;
+ private readonly List Messages;
+ private readonly HashSet TrackedMessageIds;
public MessageList()
{
- messages = new();
- trackedMessageIds = new();
+ Messages = [];
+ TrackedMessageIds = [];
}
public MessageList(int initialCapacity)
{
- messages = new(initialCapacity);
- trackedMessageIds = new(initialCapacity);
+ Messages = new List(initialCapacity);
+ TrackedMessageIds = new HashSet(initialCapacity);
}
public void AddPrune(Message message, int max)
{
- rwl.AcquireWriterLock(-1);
+ LockSlim.Wait(-1);
try
{
AddLocked(message);
@@ -313,13 +319,13 @@ internal class Tab
}
finally
{
- rwl.ReleaseWriterLock();
+ LockSlim.Release();
}
}
public void AddSortPrune(IEnumerable messages, int max)
{
- rwl.AcquireWriterLock(-1);
+ LockSlim.Wait(-1);
try
{
foreach (var message in messages)
@@ -330,44 +336,60 @@ internal class Tab
}
finally
{
- rwl.ReleaseWriterLock();
+ LockSlim.Release();
}
}
private void AddLocked(Message message)
{
- if (trackedMessageIds.Contains(message.Id))
+ if (TrackedMessageIds.Contains(message.Id))
return;
- messages.Add(message);
- trackedMessageIds.Add(message.Id);
+ Messages.Add(message);
+ TrackedMessageIds.Add(message.Id);
}
public void Clear()
{
- rwl.AcquireWriterLock(-1);
+ LockSlim.Wait(-1);
try
{
- messages.Clear();
- trackedMessageIds.Clear();
+ Messages.Clear();
+ TrackedMessageIds.Clear();
}
finally
{
- rwl.ReleaseWriterLock();
+ LockSlim.Release();
}
}
private void SortLocked()
{
- messages.Sort((a, b) => a.Date.CompareTo(b.Date));
+ Messages.Sort((a, b) => a.Date.CompareTo(b.Date));
}
private void PruneMaxLocked(int max)
{
- while (messages.Count > max)
+ while (Messages.Count > max)
{
- trackedMessageIds.Remove(messages[0].Id);
- messages.RemoveAt(0);
+ TrackedMessageIds.Remove(Messages[0].Id);
+ Messages.RemoveAt(0);
+ }
+ }
+
+ ///
+ /// Returns an array copy of the message list for usage outside of main thread
+ ///
+ public async Task GetCopy(int millisecondsTimeout = -1)
+ {
+ await LockSlim.WaitAsync(millisecondsTimeout);
+ try
+ {
+ return Messages.ToArray();
+ }
+ finally
+ {
+ LockSlim.Release();
}
}
@@ -377,11 +399,11 @@ internal class Tab
///
public RLockedMessageList GetReadOnly(int millisecondsTimeout = -1)
{
- rwl.AcquireReaderLock(millisecondsTimeout);
- return new RLockedMessageList(rwl, messages);
+ LockSlim.Wait(millisecondsTimeout);
+ return new RLockedMessageList(LockSlim, Messages);
}
- internal class RLockedMessageList(ReaderWriterLock rwl, List messages) : IReadOnlyList, IDisposable
+ internal class RLockedMessageList(SemaphoreSlim lockSlim, List messages) : IReadOnlyList, IDisposable
{
public IEnumerator GetEnumerator()
{
@@ -399,7 +421,7 @@ internal class Tab
public void Dispose()
{
- rwl.ReleaseReaderLock();
+ lockSlim.Release();
}
}
}
diff --git a/ChatTwo/EmoteCache.cs b/ChatTwo/EmoteCache.cs
index aec3bf3..dd01c10 100644
--- a/ChatTwo/EmoteCache.cs
+++ b/ChatTwo/EmoteCache.cs
@@ -148,6 +148,8 @@ public static class EmoteCache
public bool Failed;
public bool IsLoaded;
+ public byte[] RawData = [];
+
protected IDalamudTextureWrap? Texture;
public virtual void Draw(Vector2 size)
@@ -155,39 +157,26 @@ public static class EmoteCache
ImGui.Image(Texture!.ImGuiHandle, size);
}
- internal static async Task LoadAsync(Emote emote)
+ internal async Task LoadAsync(Emote emote)
{
- try
- {
- // TODO: Remove after 01.06.2024
- var oldDir = Path.Join(Plugin.Interface.ConfigDirectory.FullName, "emotes");
- if (Directory.Exists(oldDir))
- Directory.Delete(oldDir, true);
- }
- catch
- {
- // Ignore
- }
-
var dir = Path.Join(Plugin.Interface.ConfigDirectory.FullName, "EmoteCacheV1");
Directory.CreateDirectory(dir);
- byte[] image;
var filePath = Path.Join(dir, $"{emote.Id}.{emote.ImageType}");
if (File.Exists(filePath))
{
- image = await File.ReadAllBytesAsync(filePath);
+ RawData = await File.ReadAllBytesAsync(filePath);
}
else
{
var content = await new HttpClient().GetAsync(EmotePath.Format(emote.Id));
- image = await content.Content.ReadAsByteArrayAsync();
+ RawData = await content.Content.ReadAsByteArrayAsync();
await using var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Read);
- stream.Write(image, 0, image.Length);
+ stream.Write(RawData, 0, RawData.Length);
}
- return image;
+ return RawData;
}
public abstract void InnerDispose();
diff --git a/ChatTwo/FontManager.cs b/ChatTwo/FontManager.cs
index 1198245..1172220 100644
--- a/ChatTwo/FontManager.cs
+++ b/ChatTwo/FontManager.cs
@@ -16,7 +16,7 @@ public class FontManager
internal IFontHandle FontAwesome { get; private set; }
- private readonly byte[] GameSymFont;
+ internal readonly byte[] GameSymFont;
private ushort[] Ranges;
private ushort[] JpRange;
diff --git a/ChatTwo/Http/MessageProtocol/OutgoingMessage.cs b/ChatTwo/Http/MessageProtocol/OutgoingMessage.cs
new file mode 100644
index 0000000..210dba4
--- /dev/null
+++ b/ChatTwo/Http/MessageProtocol/OutgoingMessage.cs
@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace ChatTwo.Http.MessageProtocol;
+
+public struct MessageResponse()
+{
+ [JsonProperty("timestamp")] public string Timestamp = "";
+ [JsonProperty("messageHTML")] public string Message = "";
+}
+
+public class WebSocketNewMessage(MessageResponse[] messages) : BaseOutboundMessage(MessageName)
+{
+ private const string MessageName = "chat-message";
+
+ [JsonProperty("messages")] public MessageResponse[] Messages { get; set; } = messages;
+}
+
+public class BaseOutboundMessage(string messageType)
+{
+ [JsonProperty("messageType")] public string MessageType { get; set; } = messageType;
+}
\ No newline at end of file
diff --git a/ChatTwo/Http/Processing.cs b/ChatTwo/Http/Processing.cs
new file mode 100644
index 0000000..087564d
--- /dev/null
+++ b/ChatTwo/Http/Processing.cs
@@ -0,0 +1,96 @@
+using System.Globalization;
+using ChatTwo.Code;
+using ChatTwo.Http.MessageProtocol;
+using ChatTwo.Util;
+using Dalamud.Game.Text.SeStringHandling.Payloads;
+using Ganss.Xss;
+
+namespace ChatTwo.Http;
+
+public class Processing
+{
+ private readonly Plugin Plugin;
+ private readonly HtmlSanitizer Sanitizer = new();
+
+ public Processing(Plugin plugin)
+ {
+ Plugin = plugin;
+ }
+
+ public string ReadChannelName()
+ {
+ var messages = new List();
+ foreach (var chunk in Plugin.ChatLogWindow.ReadChannelName(Plugin.ChatLogWindow.CurrentTab))
+ messages.Add(ProcessChunk(chunk, noColor: true));
+
+ return string.Join("", messages);
+ }
+
+ internal async Task> ReadMessageList()
+ {
+ var tabMessages = await Plugin.ChatLogWindow.CurrentTab!.Messages.GetCopy();
+ return tabMessages.Select(ReadMessageContent).ToList();
+ }
+
+ internal MessageResponse ReadMessageContent(Message message)
+ {
+ var response = new MessageResponse
+ {
+ Timestamp = message.Date.ToLocalTime().ToString("t", !Plugin.Config.Use24HourClock ? null : CultureInfo.CreateSpecificCulture("es-ES"))
+ };
+
+ var content = "";
+ if (message.Sender.Count > 0)
+ content = message.Sender.Aggregate(content, (current, chunk) => current + ProcessChunk(chunk));
+
+ content = message.Content.Aggregate(content, (current, chunk) => current + ProcessChunk(chunk));
+ response.Message = content;
+
+ return response;
+ }
+
+ private string ProcessChunk(Chunk chunk, bool noColor = false)
+ {
+ if (chunk is IconChunk { } icon)
+ {
+ return IconUtil.GfdFileView.TryGetEntry((uint) icon.Icon, out _)
+ ? $""
+ : "";
+ }
+
+ if (chunk is TextChunk { } text)
+ {
+ if (chunk.Link is EmotePayload emotePayload && Plugin.Config.ShowEmotes)
+ {
+ var image = EmoteCache.GetEmote(emotePayload.Code);
+ if (image is { Failed: false })
+ return $"![](\"/emote/{emotePayload.Code}\")
";
+ }
+
+ var colour = text.Foreground;
+ if (colour == null && text.FallbackColour != null)
+ {
+ var type = text.FallbackColour.Value;
+ colour = Plugin.Config.ChatColours.TryGetValue(type, out var col) ? col : type.DefaultColor();
+ }
+
+ var color = ColourUtil.RgbaToComponents(colour ?? 0);
+
+ var userContent = text.Content ?? "";
+ if (Plugin.ChatLogWindow.ScreenshotMode)
+ {
+ if (chunk.Link is PlayerPayload playerPayload)
+ userContent = Plugin.ChatLogWindow.HidePlayerInString(userContent, playerPayload.PlayerName, playerPayload.World.RowId);
+ else if (Plugin.ClientState.LocalPlayer is { } player)
+ userContent = Plugin.ChatLogWindow.HidePlayerInString(userContent, player.Name.TextValue, player.HomeWorld.Id);
+ }
+
+ userContent = Sanitizer.Sanitize(userContent);
+ return noColor
+ ? userContent
+ : $"{userContent}";
+ }
+
+ return string.Empty;
+ }
+}
\ No newline at end of file
diff --git a/ChatTwo/Http/RouteController.cs b/ChatTwo/Http/RouteController.cs
new file mode 100644
index 0000000..32e57a3
--- /dev/null
+++ b/ChatTwo/Http/RouteController.cs
@@ -0,0 +1,153 @@
+using Lumina.Data.Files;
+using WatsonWebserver.Core;
+
+using HttpMethod = WatsonWebserver.Core.HttpMethod;
+
+namespace ChatTwo.Http;
+
+public class RouteController
+{
+ private readonly Plugin Plugin;
+ private readonly ServerCore Core;
+
+ private readonly string AuthTemplate;
+ private readonly string ChatBoxTemplate;
+
+ public RouteController(Plugin plugin, ServerCore core)
+ {
+ Plugin = plugin;
+ Core = core;
+
+ AuthTemplate = File.ReadAllText(Path.Combine(Core.StaticDir, "templates", "auth.html"));
+ ChatBoxTemplate = File.ReadAllText(Path.Combine(Core.StaticDir, "templates", "start.html"));
+
+ // Pre Auth
+ Core.HostContext.Routes.PreAuthentication.Static.Add(HttpMethod.GET, "/", AuthRoute, ExceptionRoute);
+ Core.HostContext.Routes.PreAuthentication.Static.Add(HttpMethod.POST, "/auth", AuthenticateClient, ExceptionRoute);
+ Core.HostContext.Routes.PreAuthentication.Static.Add(HttpMethod.GET, "/files/gfdata.gfd", GetGfdData, ExceptionRoute);
+ Core.HostContext.Routes.PreAuthentication.Static.Add(HttpMethod.GET, "/files/fonticon_ps5.tex", GetTexData, ExceptionRoute);
+ Core.HostContext.Routes.PreAuthentication.Static.Add(HttpMethod.GET, "/files/FFXIV_Lodestone_SSF.ttf", GetLodestoneFont, ExceptionRoute);
+ Core.HostContext.Routes.PreAuthentication.Content.Add("/static", true, ExceptionRoute);
+
+ // Post Auth
+ Core.HostContext.Routes.PostAuthentication.Static.Add(HttpMethod.GET, "/chat", ChatBoxRoute, ExceptionRoute);
+ Core.HostContext.Routes.PostAuthentication.Static.Add(HttpMethod.POST, "/send", ReceiveMessage, ExceptionRoute);
+ Core.HostContext.Routes.PostAuthentication.Parameter.Add(HttpMethod.GET, "/emote/{name}", GetEmote, ExceptionRoute);
+ }
+
+ private async Task ExceptionRoute(HttpContextBase ctx, Exception _)
+ {
+ ctx.Response.StatusCode = 500;
+ await ctx.Response.Send("Internal Server Error, please try again");
+ }
+
+ private async Task AuthRoute(HttpContextBase ctx)
+ {
+ await ctx.Response.Send(AuthTemplate);
+ }
+
+ public void Dispose()
+ {
+
+ }
+
+ #region FileHandlerRoutes
+ private async Task GetTexData(HttpContextBase ctx)
+ {
+ var data = Plugin.DataManager.GetFile("common/font/fonticon_ps5.tex")!.Data;
+ await ctx.Response.Send(data);
+ }
+
+ private async Task GetGfdData(HttpContextBase ctx)
+ {
+ var data = Plugin.DataManager.GetFile("common/font/gfdata.gfd")!.Data;
+ await ctx.Response.Send(data);
+ }
+
+ private async Task GetLodestoneFont(HttpContextBase ctx)
+ {
+ var data = Plugin.FontManager.GameSymFont;
+ await ctx.Response.Send(data);
+ }
+
+ private async Task GetEmote(HttpContextBase ctx)
+ {
+ var name = ctx.Request.Url.Parameters["name"] ?? "";
+ if (name == "" || !EmoteCache.Exists(name))
+ {
+ ctx.Response.StatusCode = 400;
+ await ctx.Response.Send("Malformed emote name.");
+ return;
+ }
+
+
+ var emote = EmoteCache.GetEmote(name);
+ if (emote is not { IsLoaded: true })
+ {
+ ctx.Response.StatusCode = 400;
+ await ctx.Response.Send("Emote not valid.");
+ return;
+ }
+
+ ctx.Response.Headers.Add("Cache-Control", "max-age=86400");
+ await ctx.Response.Send(emote.RawData);
+ }
+ #endregion
+
+ #region PreAuthRoutes
+ private async Task AuthenticateClient(HttpContextBase ctx)
+ {
+ var receivedPassword = ctx.Request.DataAsString ?? "";
+ if (!receivedPassword.StartsWith("authcode="))
+ {
+ ctx.Response.StatusCode = 400;
+ await ctx.Response.Send("Authentication content invalid.");
+ return;
+ }
+
+ receivedPassword = receivedPassword[9..];
+ if (receivedPassword != Plugin.Config.WebinterfacePassword)
+ {
+ ctx.Response.StatusCode = 401;
+ await ctx.Response.Send("Authentication failed.");
+ return;
+ }
+
+ ctx.Response.Headers.Add("Set-Cookie", $"auth={Plugin.Config.WebinterfacePassword}");
+ ctx.Response.Headers.Add("Location", "/chat");
+ ctx.Response.StatusCode = 302;
+ await ctx.Response.Send();
+ }
+ #endregion
+
+ #region PostAuthRoutes
+ private async Task ChatBoxRoute(HttpContextBase ctx)
+ {
+ if (Plugin.ChatLogWindow.CurrentTab == null)
+ {
+ await ctx.Response.Send("No valid chat tab!");
+ return;
+ }
+
+ await ctx.Response.Send(ChatBoxTemplate);
+ }
+
+ private async Task ReceiveMessage(HttpContextBase ctx)
+ {
+ var content = ctx.Request.DataAsString;
+ if (content.Length is > 500 or < 2)
+ {
+ await ctx.Response.Send("Invalid length for a chat message received.");
+ return;
+ }
+
+ await Plugin.Framework.RunOnFrameworkThread(() =>
+ {
+ Plugin.ChatLogWindow.Chat = content;
+ Plugin.ChatLogWindow.SendChatBox(Plugin.ChatLogWindow.CurrentTab);
+ });
+
+ await ctx.Response.Send("Message was send to the channel.");
+ }
+ #endregion
+}
\ No newline at end of file
diff --git a/ChatTwo/Http/ServerCore.cs b/ChatTwo/Http/ServerCore.cs
new file mode 100644
index 0000000..c799950
--- /dev/null
+++ b/ChatTwo/Http/ServerCore.cs
@@ -0,0 +1,134 @@
+using ChatTwo.Http.MessageProtocol;
+using EmbedIO;
+using WatsonWebserver.Core;
+using WatsonWebserver.Lite;
+using ExceptionEventArgs = WatsonWebserver.Core.ExceptionEventArgs;
+
+namespace ChatTwo.Http;
+
+public class ServerCore : IDisposable
+{
+ private readonly Plugin Plugin;
+ private readonly Processing Processing;
+ private readonly RouteController RouteController;
+
+ internal readonly WebserverLite HostContext;
+ private readonly WebSocketServer Websocket;
+ private readonly WebServer Host;
+
+ internal readonly CancellationTokenSource TokenSource = new();
+ internal readonly string StaticDir = Path.Combine(Plugin.Interface.AssemblyLocation.DirectoryName!, "Http");
+
+ public ServerCore(Plugin plugin)
+ {
+ Plugin = plugin;
+ HostContext = new WebserverLite(new WebserverSettings("*", 9000), DefaultRoute);
+
+ Processing = new Processing(plugin);
+ RouteController = new RouteController(plugin, this);
+
+ HostContext.Routes.PreAuthentication.Content.BaseDirectory = StaticDir;
+ HostContext.Routes.AuthenticateRequest = CheckAuthenticationCookie;
+ HostContext.Events.ExceptionEncountered += ExceptionEncountered;
+
+ // Settings
+ HostContext.Settings.Debug.Requests = true;
+ HostContext.Settings.Debug.Routing = true;
+ HostContext.Settings.Debug.Responses = true;
+ HostContext.Settings.Debug.AccessControl = true;
+ HostContext.Events.Logger = logMessage => Plugin.Log.Information(logMessage);
+
+
+ // Websocket
+ Host = new WebServer(o => o
+ .WithUrlPrefixes($"http://*:9001")
+ .WithMode(HttpListenerMode.EmbedIO)
+ );
+
+ Websocket = new WebSocketServer("/ws");
+ Host.WithModule(Websocket);
+
+ Websocket.OnClientConnected += ClientConnected;
+ }
+
+ #region WebsocketFunctions
+ private void ClientConnected(object? sender, EventArgs args)
+ {
+ Task.Run(async () =>
+ {
+ var messages = await WebserverUtil.FrameworkWrapper(Processing.ReadMessageList);
+ Websocket.BroadcastMessage(new WebSocketNewMessage(messages.ToArray()));
+ });
+ }
+
+ internal void SendNewMessage(Message message)
+ {
+ try
+ {
+ Plugin.Framework.RunOnTick(() =>
+ {
+ Websocket.BroadcastMessage(new WebSocketNewMessage([Processing.ReadMessageContent(message)]));
+ });
+ }
+ catch (Exception ex)
+ {
+ Plugin.Log.Error(ex, "Send message to websockets failed.");
+ }
+ }
+ #endregion
+
+ #region GeneralHandlers
+ private static void ExceptionEncountered(object? _, ExceptionEventArgs args)
+ {
+ Plugin.Log.Error(args.Exception, "Webserver threw an exception.");
+ }
+
+ private async Task DefaultRoute(HttpContextBase ctx)
+ {
+ await ctx.Response.Send("Nothing to see here.");
+ }
+ #endregion
+
+ private async Task CheckAuthenticationCookie(HttpContextBase ctx)
+ {
+ var cookie = ctx.Request.Headers.Get("Cookie") ?? "";
+ if (!cookie.StartsWith("auth=") || cookie[5..] != Plugin.Config.WebinterfacePassword)
+ {
+ ctx.Response.StatusCode = 401;
+ await ctx.Response.Send("Your session auth code was invalid");
+ }
+
+ // Do nothing to let auth pass
+ }
+
+ public bool GetStats()
+ {
+ return HostContext.IsListening;
+ }
+
+ public void Start()
+ {
+ try
+ {
+ HostContext.Start(TokenSource.Token);
+ Host.Start(TokenSource.Token);
+ }
+ catch (Exception ex)
+ {
+ Plugin.Log.Error(ex, "Startup failed with an error.");
+ }
+ }
+
+ public void Dispose()
+ {
+ TokenSource.Cancel();
+
+ HostContext.Stop();
+ HostContext.Dispose();
+
+ Websocket.Dispose();
+ Host.Dispose();
+
+ RouteController.Dispose();
+ }
+}
\ No newline at end of file
diff --git a/ChatTwo/Http/Util.cs b/ChatTwo/Http/Util.cs
new file mode 100644
index 0000000..0161262
--- /dev/null
+++ b/ChatTwo/Http/Util.cs
@@ -0,0 +1,37 @@
+namespace ChatTwo.Http;
+
+public static class WebserverUtil
+{
+ public static async Task FrameworkWrapper(Func> func)
+ {
+ return await Plugin.Framework.RunOnTick(func).ConfigureAwait(false);
+ }
+
+ public class DisposableWrapper : IDisposable {
+ private readonly Action Down;
+ private bool Disposed;
+
+ public DisposableWrapper(Action down) {
+ Down = down;
+ }
+
+ public void Dispose() {
+ if (Disposed) return;
+
+ Down();
+ Disposed = true;
+
+ GC.SuppressFinalize(this);
+ }
+ }
+}
+
+public static class AsyncUtils {
+ public static async Task UseWaitAsync(this SemaphoreSlim semaphore, CancellationToken ct = default) {
+ await semaphore.WaitAsync(ct).ConfigureAwait(false);
+
+ return new WebserverUtil.DisposableWrapper(() => {
+ semaphore.Release();
+ });
+ }
+}
\ No newline at end of file
diff --git a/ChatTwo/Http/Websocket.cs b/ChatTwo/Http/Websocket.cs
new file mode 100644
index 0000000..0a94082
--- /dev/null
+++ b/ChatTwo/Http/Websocket.cs
@@ -0,0 +1,48 @@
+using ChatTwo.Http.MessageProtocol;
+using EmbedIO.WebSockets;
+using Newtonsoft.Json;
+
+namespace ChatTwo.Http;
+
+public class WebSocketServer : WebSocketModule {
+ private readonly SemaphoreSlim SendLock = new(1, 1);
+
+ public event EventHandler? OnClientConnected;
+
+ public WebSocketServer(string urlPath) : base(urlPath, true) {
+
+ }
+
+ protected override async Task OnMessageReceivedAsync(IWebSocketContext context, byte[] buffer, IWebSocketReceiveResult result)
+ {
+ // Unused method
+ }
+
+ protected override Task OnClientConnectedAsync(IWebSocketContext context)
+ {
+ Plugin.Log.Information($"Client connected: {context.Id}");
+ OnClientConnected?.Invoke(this, EventArgs.Empty);
+ return base.OnClientConnectedAsync(context);
+ }
+
+ protected override Task OnClientDisconnectedAsync(IWebSocketContext context)
+ {
+ Plugin.Log.Information($"Client disconnected: {context.Id}");
+ return base.OnClientConnectedAsync(context);
+ }
+
+ protected override void Dispose(bool disposing) {
+ base.Dispose(disposing);
+
+ SendLock.Dispose();
+ }
+
+ public void BroadcastMessage(BaseOutboundMessage message) {
+ Task.Run(async () => {
+ using (await SendLock.UseWaitAsync()) {
+ var serializedData = JsonConvert.SerializeObject(message);
+ await BroadcastAsync(serializedData);
+ }
+ });
+ }
+}
\ No newline at end of file
diff --git a/ChatTwo/Http/static/Inter.var.woff2 b/ChatTwo/Http/static/Inter.var.woff2
new file mode 100644
index 0000000..365eedc
Binary files /dev/null and b/ChatTwo/Http/static/Inter.var.woff2 differ
diff --git a/ChatTwo/Http/static/start.css b/ChatTwo/Http/static/start.css
new file mode 100644
index 0000000..abb0e1d
--- /dev/null
+++ b/ChatTwo/Http/static/start.css
@@ -0,0 +1,243 @@
+/* fonts */
+@font-face {
+ font-family: Lodestone;
+ src: url('files/FFXIV_Lodestone_SSF.ttf') format('truetype');
+ unicode-range: U+E020-E0DB;
+}
+
+@font-face {
+ font-family: 'Inter var';
+ font-weight: 100 900;
+ font-style: oblique 0deg 10deg;
+ src: url('static/Inter.var.woff2') format('woff2');
+}
+
+/* variables */
+:root {
+ --fg: white;
+ --fg-faint: #a0a0a0;
+ --fg-scrollbar: #404040;
+ --bg: #101010;
+ --bg-input: #202020;
+ --bg-input-hover: #282828;
+ --focus-color: #4060a0;
+
+ --gradient-clickable: linear-gradient(to bottom, #404040, var(--bg-input) 65%, var(--bg-input));
+ --gradient-clickable-hover: linear-gradient(to bottom, #505050, var(--bg-input-hover) 65%, var(--bg-input-hover));
+
+ --timestamp-width: 70px;
+}
+
+/* reset */
+*, *::before, *::after {
+ box-sizing: border-box;
+ margin: 0;
+ padding: 0;
+}
+
+* {
+ color: var(--fg);
+ font-family: Lodestone, 'Inter var', sans-serif;
+ font-feature-settings: 'tnum';
+}
+
+html {
+ font-size: 16px;
+}
+
+/* layout and global styles */
+body {
+ padding: 50px;
+ height: 100dvh;
+ background-color: var(--bg-input-hover);
+}
+
+body > main {
+ display: flex;
+ flex-direction: column;
+ width: 100%;
+ height: 100%;
+ background-color: var(--bg);
+ border-radius: 20px;
+
+ box-shadow: 0 0 50px 0 rgba(0, 0, 0, 0.5);
+}
+
+/* message list */
+section#messages {
+ position: relative;
+ flex: 1;
+ min-height: 0;
+ padding: 20px;
+ line-height: 1.5;
+
+ .scroll-container {
+ height: 100%;
+ overflow-y: scroll;
+ scrollbar-color: var(--fg-scrollbar) var(--bg);
+
+ &.more-messages::before {
+ content: '';
+ position: absolute;
+ bottom: -20px;
+ left: 100px;
+ width: calc(100% - 200px);
+ height: 200px;
+ background-image: radial-gradient(50% 20% at 50% 100%, #60a0ff40, transparent);
+ }
+ }
+
+ ol {
+ list-style-type: none;
+ }
+
+ li {
+ display: flex;
+ align-items: flex-start;
+ gap: 10px;
+
+ .timestamp {
+ flex: 0 0 var(--timestamp-width);
+ color: var(--fg-faint);
+ text-align: right;
+ }
+ }
+}
+
+#timestamp-width-probe {
+ position: absolute;
+ top: 0;
+ left: 0;
+ pointer-events: none;
+ opacity: 0;
+}
+
+/* input bar, channel selector, ... */
+section#input {
+ flex-grow: 0;
+ padding: 20px;
+
+ form {
+ display: flex;
+ gap: 10px;
+ }
+
+ input, button, select {
+ font-size: 1rem;
+ border: 3px solid transparent;
+ border-radius: 20px;
+ background-color: var(--bg-input);
+
+ &:focus {
+ outline: 2px solid var(--focus-color);
+ }
+ }
+
+ button, select {
+ padding: 5px 15px;
+ border: 3px solid var(--bg-input);
+ background-image: var(--gradient-clickable);
+ cursor: pointer;
+
+ &:hover {
+ border-color: var(--bg-input-hover);
+ background-color: var(--bg-input-hover);
+ background-image: var(--gradient-clickable-hover);
+ }
+ }
+
+ .select-container, button {
+ position: relative;
+ flex-grow: 0;
+ flex-shrink: 0;
+ }
+
+ .select-container {
+ flex-basis: 0;
+
+ &::before {
+ /* "message-circle" icon from https://github.com/feathericons/feather, under MIT license */
+ mask-image: url('data:image/svg+xml,');
+ }
+
+ select {
+ width: 100%;
+ padding-left: 1.5rem;
+ padding-right: 1.5rem;
+ appearance: none;
+ color: transparent;
+ }
+ }
+
+ button {
+ padding-left: calc(20px + 1.5rem);
+
+ &::before {
+ /* "send" icon from https://github.com/feathericons/feather, under MIT license */
+ mask-image: url('data:image/svg+xml,');
+ }
+ }
+
+ .select-container::before, button::before {
+ content: '';
+ position: absolute;
+ left: 15px;
+ top: 50%;
+ transform: translateY(-50%);
+ width: 1.3rem;
+ height: 1.3rem;
+ background-color: var(--fg);
+ mask-size: 100%;
+ pointer-events: none;
+ }
+
+ .select-container::before {
+ left: 50%;
+ transform: translateX(-50%) translateY(-50%);
+ }
+
+ .input-container {
+ flex: 1;
+ position: relative;
+
+ #chat-input {
+ width: 100%;
+ padding: 5px 20px;
+ }
+
+ #channel-hint {
+ position: absolute;
+ top: -1.2em;
+ left: 23px;
+ font-size: 1.1rem;
+ font-weight: 550;
+ pointer-events: none;
+ }
+ }
+}
+
+/*** mobile ***/
+@media ((max-width: 600px) and (orientation: portrait)) or (max-width: 400px) {
+body {
+ padding: 0;
+}
+
+body > main {
+ border-radius: 0;
+ box-shadow: none;
+}
+
+section#input {
+ button {
+ max-width: 0;
+ padding-left: 1.5rem;
+ padding-right: 1.5rem;
+ color: transparent;
+ }
+
+ button::before {
+ left: 50%;
+ transform: translateX(-50%) translateY(-50%);
+ }
+}
+}
diff --git a/ChatTwo/Http/static/start.js b/ChatTwo/Http/static/start.js
new file mode 100644
index 0000000..e39a7a2
--- /dev/null
+++ b/ChatTwo/Http/static/start.js
@@ -0,0 +1,243 @@
+// websocket connection
+class WSConnection {
+ constructor() {
+ this.socket = new WebSocket('ws://192.168.2.106:9001/ws');
+ this.socket.addEventListener('open', this.onWSOpen.bind(this));
+ this.socket.addEventListener('close', this.onWSClose.bind(this));
+ this.socket.addEventListener('message', this.onWSMessage.bind(this));
+ }
+
+ onWSOpen() {
+ // send request for initial data (channels, currently selected channel)
+ }
+
+ onWSClose() {
+ // open new websocket here? for mobile
+ }
+
+ onWSMessage(event) {
+ try {
+ let eventData = JSON.parse(event.data);
+ for (let message of eventData.messages)
+ {
+ addMessage(message);
+ }
+ } catch (error) {
+ // TODO: error handling?
+ return;
+ }
+ }
+
+ send(message) {
+ this.socket.send(message);
+ }
+}
+
+const ws = new WSConnection();
+
+
+// channel switcher
+function updateChannelHint(label) {
+ document.getElementById('channel-hint').innerText = label;
+}
+document.getElementById('channel-select').addEventListener('change', (event) => {
+ updateChannelHint(event.target.value);
+ // TODO: send new channel to "backend"
+ // ws.send(...);
+});
+
+
+// functions for handling the message list
+function scrollMessagesToBottom() {
+ const messagesContainer = document.querySelector('#messages > .scroll-container');
+ messagesContainer.scrollTop = messagesContainer.scrollHeight - messagesContainer.offsetHeight;
+}
+
+function messagesContainerIsScrolledToBottom() {
+ const messagesContainer = document.querySelector('#messages > .scroll-container');
+ return messagesContainer.scrollTop == messagesContainer.scrollHeight - messagesContainer.offsetHeight;
+}
+
+function addMessage(messageData) {
+ const scrolledToBottom = messagesContainerIsScrolledToBottom();
+
+ const liMessage = document.createElement('li');
+ const spanTimestamp = document.createElement('span');
+ spanTimestamp.classList.add('timestamp');
+ const spanMessage = document.createElement('span');
+ spanMessage.classList.add('message');
+
+ // suggestions, update with actual data model
+ spanTimestamp.innerText = messageData.timestamp;
+ spanMessage.innerHTML = messageData.messageHTML; // or build HTML in here
+
+ liMessage.appendChild(spanTimestamp);
+ liMessage.appendChild(spanMessage);
+ document.getElementById('messages-list').appendChild(liMessage);
+
+ if (scrolledToBottom) {
+ scrollMessagesToBottom();
+ }
+}
+
+function clearMessages() {
+ document.getElementById('messages-list').innerHTML = '';
+}
+
+//
+document.querySelector('#messages > .scroll-container').addEventListener('scroll', () => {
+ const messagesContainer = document.querySelector('#messages > .scroll-container');
+ if (!messagesContainerIsScrolledToBottom()) {
+ messagesContainer.classList.add('more-messages');
+ } else {
+ messagesContainer.classList.remove('more-messages');
+ }
+});
+
+
+// handle message sending
+document.querySelector('#input > form').addEventListener('submit', (event) => {
+ event.preventDefault();
+
+ const chatInput = document.getElementById('chat-input');
+ const message = chatInput.value;
+
+ fetch('/send', {
+ method: 'POST',
+ body: message,
+ headers: {
+ 'Content-type': 'application/txt; charset=UTF-8'
+ }
+ });
+
+ chatInput.value = '';
+});
+
+
+// calculate timestamp width
+// to ensure that all timestamps have the same width. some typefaces have the same width across
+// all number glyphs, others do not. the solution below is very rudimentary; at the very least,
+// delaying it to account for font loading might make sense. perhaps there's an even better way?
+window.setTimeout(() => {
+ const widthProbe = document.getElementById('timestamp-width-probe');
+ widthProbe.innerText = '88:88'; // assume 8 to be widest glyph
+ document.body.style.setProperty('--timestamp-width', Math.ceil(widthProbe.clientWidth) + 'px');
+}, 100);
+
+// From kizer
+async function AddGfdStylesheet(gfdPath, texPath) {
+ const texPromise = LoadTexAsBlob(texPath);
+ const gfdPromise = LoadGfd(gfdPath);
+ const texUrl = URL.createObjectURL(await texPromise);
+ const gfd = await gfdPromise;
+
+ let stylesheets = [];
+ for (const entry of gfd) {
+ if (entry.width * entry.height <= 0)
+ continue;
+
+ if (entry.redirect !== 0) {
+ stylesheets[entry.redirect][0].push(entry.id);
+ continue;
+ }
+
+ stylesheets[entry.id] = [
+ [entry.id],
+ [
+ `background-position: -${entry.left}px -${entry.top}px`,
+ `background-image: url('${texUrl}')`,
+ `width: ${entry.width}px`,
+ `height: ${entry.height}px`,
+ `margin-bottom: -20px`
+ ].join(";"),
+ [
+ `background-position: -${entry.left * 2}px -${entry.top * 2 + 341}px`,
+ `background-image: url('${texUrl}')`,
+ `width: ${entry.width * 2}px`,
+ `height: ${entry.height * 2}px`,
+ `margin-bottom: -40px`
+ ].join(";")
+ ];
+ }
+
+ let stylesheet = ".gfd-icon::before { content: ''; display: inline-block; overflow: hidden; vertical-align: top; height:0; }";
+ for (const entry of stylesheets) {
+ if (!entry)
+ continue;
+
+ stylesheet += `\n${entry[0].map(x => `.gfd-icon.gfd-icon-${x}::before`).join(', ')}{${entry[1]};}`;
+ stylesheet += `\n${entry[0].map(x => `.gfd-icon.gfd-icon-hq-${x}::before`).join(', ')}{${entry[2]};}`;
+ }
+
+ const styleNode = document.createElement("style");
+ styleNode.type = "text/css";
+ styleNode.appendChild(document.createTextNode(stylesheet));
+ document.head.appendChild(styleNode);
+}
+
+async function LoadTexAsBlob(path) {
+ const tex = ParseTex(await (await fetch(path)).arrayBuffer());
+ if (tex.format !== 0x1450) // B8G8R8A8
+ throw "Not supported";
+
+ const dataArray = new Uint8ClampedArray(tex.buffer, tex.offsetToSurface[0], tex.width * tex.height * 4);
+ for (let i = 0; i < dataArray.length; i += 4) {
+ const t = dataArray[i];
+ dataArray[i] = dataArray[i + 2];
+ dataArray[i + 2] = t;
+ }
+ const imageData = new ImageData(dataArray, tex.width, tex.height);
+ const bitmap = await createImageBitmap(imageData);
+
+ const canvas = new OffscreenCanvas(tex.width, tex.height);
+ canvas.getContext('bitmaprenderer').transferFromImageBitmap(bitmap);
+ return await canvas.convertToBlob();
+}
+
+async function LoadGfd(path) {
+ const buffer = new DataView(await (await fetch(path)).arrayBuffer());
+ const count = buffer.getInt32(8, true);
+ const entries = new Array(count);
+ for (let i = 0; i < count; i++) {
+ const offset = 0x10 + (i * 0x10);
+ entries[i] = {
+ id: buffer.getInt16(offset, true),
+ left: buffer.getInt16(offset + 2, true),
+ top: buffer.getInt16(offset + 4, true),
+ width: buffer.getInt16(offset + 6, true),
+ height: buffer.getInt16(offset + 8, true),
+ unk0A: buffer.getInt16(offset + 10, true),
+ redirect: buffer.getInt16(offset + 12, true),
+ unk0E: buffer.getInt16(offset + 14, true),
+ };
+ }
+
+ return entries;
+}
+
+function ParseTex(arrayBuffer) {
+ const buffer = new DataView(arrayBuffer);
+ const type = buffer.getInt32(0, true);
+ const format = buffer.getInt32(4, true);
+ const width = buffer.getInt16(8, true);
+ const height = buffer.getInt16(10, true);
+ const depth = buffer.getInt16(12, true);
+ const mipsAndFlag = buffer.getInt8(14, true);
+ const arraySize = buffer.getInt8(15, true);
+ const lodOffsets = [buffer.getInt32(16, true), buffer.getInt32(20, true), buffer.getInt32(24, true)];
+ const offsetToSurface = [buffer.getInt32(28, true), buffer.getInt32(32, true), buffer.getInt32(36, true), buffer.getInt32(40, true), buffer.getInt32(44, true), buffer.getInt32(48, true), buffer.getInt32(52, true), buffer.getInt32(56, true), buffer.getInt32(60, true), buffer.getInt32(64, true), buffer.getInt32(68, true), buffer.getInt32(72, true), buffer.getInt32(76, true)];
+ return {
+ buffer: arrayBuffer,
+ type,
+ format,
+ width,
+ height,
+ depth,
+ mipsAndFlag,
+ arraySize,
+ lodOffsets,
+ offsetToSurface,
+ };
+}
+
+AddGfdStylesheet("/files/gfdata.gfd", "/files/fonticon_ps5.tex");
diff --git a/ChatTwo/Http/templates/auth.html b/ChatTwo/Http/templates/auth.html
new file mode 100644
index 0000000..4a8a1e5
--- /dev/null
+++ b/ChatTwo/Http/templates/auth.html
@@ -0,0 +1,19 @@
+
+
+
+ Authentication
+
+
+
+
+
+
Authcode
+
+
+
+