server:

Fixed cli help texts
Added administrator options for critical methods
Added result state for client and server specific errors
Redirect root to help text
Fixed fingerprint error, fingerprint must be case sensitive
Re-Added online messages
Added typing trigger for discord bot messages
client:
fixed chunkString for empty results preemtive
wrap error objects for server messages
both:
added raw lua RS Bridge command entry

CHANGELOG

@@ -0,0 +1 @@
+

MinecraftDiscordBot/AesCipher.cs

@@ -0,0 +1,44 @@
+using System.Security.Cryptography;
+
+namespace MinecraftDiscordBot;
+
+public class AesCipher : ICipher {
+    private readonly byte[] key;
+    private readonly byte[] iv;
+
+    public AesCipher() {
+        using var aes = Aes.Create();
+        aes.GenerateKey();
+        aes.GenerateIV();
+        key = aes.Key;
+        iv = aes.IV;
+    }
+
+    public byte[] Encrypt(byte[] plain) {
+        using var aes = Aes.Create();
+        aes.Key = key;
+        aes.IV = iv;
+        var transformer = aes.CreateEncryptor();
+        using var ms = new MemoryStream();
+        using (var cs = new CryptoStream(ms, transformer, CryptoStreamMode.Write))
+            cs.Write(plain);
+        return ms.ToArray();
+    }
+
+    public byte[] Decrypt(byte[] cipher) {
+        using Aes aes = Aes.Create();
+        aes.Key = key;
+        aes.IV = iv;
+        var transformer = aes.CreateDecryptor();
+        using MemoryStream ms = new MemoryStream(cipher);
+        using CryptoStream cs = new CryptoStream(ms, transformer, CryptoStreamMode.Read);
+        using MemoryStream os = new MemoryStream();
+        cs.CopyTo(os);
+        return os.ToArray();
+    }
+}
+
+public interface ICipher {
+    byte[] Decrypt(byte[] cipher);
+    byte[] Encrypt(byte[] plain);
+}

MinecraftDiscordBot/BotConfiguration.cs

@@ -1,14 +1,52 @@
-using Newtonsoft.Json;
+using CommandLine;
+using Newtonsoft.Json;
+using System.Text;
 
 namespace MinecraftDiscordBot;
 
-public class BotConfiguration {
+[Verb("config", HelpText = "Manually configure the bot with CLI arguments.")]
+public class BotConfiguration : IBotConfiguration, IBotConfigurator {
+    private const string DEFAULT_PREFIX = "!";
+    private const int DEFAULT_PORT = 8080;
     [JsonProperty("token", Required = Required.Always)]
-    public string Token { get; set; } = default!;
-    [JsonProperty("port", Required = Required.Always)]
-    public int Port { get; set; } = default!;
+    [Option('t', "token", HelpText = "The Discord bot token", Required = true)]
+    public string Token { get; init; } = default!;
+    [JsonProperty("port", Required = Required.DisallowNull)]
+    [Option('p', "port", Default = DEFAULT_PORT, HelpText = "The websocket server port")]
+    public int Port { get; init; } = DEFAULT_PORT;
     [JsonProperty("channels", Required = Required.Always)]
-    public IEnumerable<ulong> Channels { get; set; } = default!;
-    [JsonProperty("prefix", Required = Required.Always)]
-    public string Prefix { get; set; } = default!;
+    [Option('c', "channel", HelpText = "The list of whitelisted channels", Required = true, Min = 1)]
+    public IEnumerable<ulong> Channels { get; init; } = default!;
+    [JsonProperty("prefix", Required = Required.DisallowNull)]
+    [Option("prefix", Default = DEFAULT_PREFIX, HelpText = "The Discord bot command prefix")]
+    public string Prefix { get; init; } = DEFAULT_PREFIX;
+    [JsonProperty("host", Required = Required.Always)]
+    [Option("host", Default = DEFAULT_PREFIX, HelpText = "The external websocket hostname.", Required = true)]
+    public string SocketHost { get; init; } = default!;
+    [JsonProperty("admins", Required = Required.DisallowNull)]
+    [Option("admins", Default = new ulong[] { }, HelpText = "The list of bot administrators.")]
+    public ulong[] Administrators { get; init; } = Array.Empty<ulong>();
+    [JsonIgnore]
+    public BotConfiguration Config => this;
 }
+
+public interface IBotConfigurator {
+    BotConfiguration Config { get; }
+}
+
+public interface IBotConfiguration {
+    string Token { get; }
+    int Port { get; }
+    IEnumerable<ulong> Channels { get; }
+    string Prefix { get; }
+}
+
+[Verb("file", true, HelpText = "Load a bot configuration file.")]
+public class ConfigFile : IBotConfigurator {
+    private const string DEFAULT_CONFIGPATH = "config.json";
+    [Option('f', "file", Default = DEFAULT_CONFIGPATH, HelpText = "The path of the configuration file")]
+    public string ConfigPath { get; set; } = DEFAULT_CONFIGPATH;
+    public BotConfiguration Config
+        => JsonConvert.DeserializeObject<BotConfiguration>(File.ReadAllText(ConfigPath, Encoding.UTF8))
+        ?? throw new InvalidProgramException("Invalid empty config file!");
+}

MinecraftDiscordBot/ChunkWaiter.cs

@@ -0,0 +1,52 @@
+using MinecraftDiscordBot.Models;
+using MinecraftDiscordBot.Services;
+
+namespace MinecraftDiscordBot;
+
+public class ChunkWaiter<T> : IChunkWaiter {
+    public int ID { get; }
+    private readonly CancellationToken _ct;
+    public ChunkWaiter(int id, Func<string, T> resultParser, CancellationToken ct) {
+        ID = id;
+        this.resultParser = resultParser;
+        _ct = ct;
+    }
+    private readonly TaskCompletionSource<T> tcs = new();
+    private readonly Func<string, T> resultParser;
+    public Task<T> Task => tcs.Task.WaitAsync(_ct);
+    public bool Finished { get; private set; } = false;
+    public bool IsCancellationRequested => _ct.IsCancellationRequested;
+    private string?[]? _chunks = null;
+    private int _receivedChunks = 0;
+    private ResultState? _state = null;
+    private readonly object _syncRoot = new();
+    public void AddChunk(int chunkId, int totalChunks, string value) {
+        lock (_syncRoot) {
+            if (_chunks is null) _chunks = new string[totalChunks];
+            else if (_chunks.Length != totalChunks) {
+                Program.LogErrorAsync(Program.WebSocketSource, new InvalidOperationException("Different numbers of chunks in same message ID!"));
+                return;
+            }
+            ref string? chunk = ref _chunks[chunkId - 1]; // Lua 1-indexed
+            if (chunk is not null) {
+                Program.LogErrorAsync(Program.WebSocketSource, new InvalidOperationException($"Chunk with ID {chunkId} was already received!"));
+                return;
+            }
+            chunk = value;
+        }
+        if (++_receivedChunks == totalChunks) FinalizeResult(_chunks);
+    }
+    private void FinalizeResult(string?[] _chunks) {
+        var resultString = string.Concat(_chunks);
+        switch (_state) {
+        case ResultState.Successful: tcs.SetResult(resultParser(resultString)); break;
+        case ResultState.Unsuccessful: tcs.SetException(new ReplyException(resultString)); break;
+        case ResultState.Fatal: tcs.SetException(new InvalidProgramException($"Client script failed: {resultString}")); break;
+        default: throw new InvalidProgramException($"Program cannot handle result state '{_state}'!");
+        }
+        Finished = true;
+    }
+    public void SetResultState(ResultState state) => _state = _state is ResultState oldState && state != oldState
+    ? throw new InvalidOperationException("Cannot set two different result states for same message!")
+    : state;
+}

MinecraftDiscordBot/ClientScript.lua

@@ -0,0 +1,164 @@
+local secretToken = "$TOKEN"
+local connectionUri = "$HOST"
+local waitSeconds = 5
+
+local function chunkString(value, chunkSize)
+	if not chunkSize then chunkSize = 10000 end
+	local length = value:len()
+	local total = math.ceil(length / chunkSize)
+	local chunks = {}
+	if length == 0 then
+		total = 1
+		chunks[1] = ""
+	else
+		local i = 1
+		for i=1,total do
+			local pos = 1 + ((i - 1) * chunkSize)
+			chunks[i] = value:sub(pos, pos + chunkSize - 1)
+		end
+	end
+	return total, chunks
+end
+
+local function sendJson(socket, message)
+	return socket.send(textutils.serializeJSON(message))
+end
+
+local function sendResponse(socket, id, result, success)
+	if success == nil then success = 0 end
+
+	local total, chunks = chunkString(result)
+	for i, chunk in pairs(chunks) do
+		sendJson(socket, { id = id, result = chunk, chunk = i, total = total, success = success })
+	end
+end
+
+-- error: no rs system
+-- return rssystem rs
+local function getPeripheral(name)
+	local dev = peripheral.find(name)
+	if not dev then error({message = "No peripheral '"..name.."' attached to the computer!"}) end
+	return dev
+end
+
+local function runRsCommand(params)
+	local script, reason = loadstring("local rs = peripheral.find(\"rsBridge\") if not rs then error({message = \"RS Bridge is not attached!\"}) end return rs."..params.command)
+	if not script then error({message = "Invalid command: "..reason.."!"}) end
+	local result = table.pack(pcall(script))
+	local success = result[1]
+	if not success then error({message = "Command execution failed: "..result[2].."!"}) end
+
+	local retvals = {}
+	retvals.n = result.n - 1
+	for i=1,retvals.n do retvals[tostring(i)] = result[i + 1] end
+	return textutils.serializeJSON(retvals)
+end
+
+-- error: any error during execution
+-- return string result
+local function getResponse(parsed)
+	if parsed.method == "energyusage" then
+		return tostring(getPeripheral("rsBridge").getEnergyUsage())
+	elseif parsed.method == "energystorage" then
+		return tostring(getPeripheral("rsBridge").getEnergyStorage())
+	elseif parsed.method == "listitems" then
+		return textutils.serializeJSON(getPeripheral("rsBridge").listItems())
+	elseif parsed.method == "listfluids" then
+		return textutils.serializeJSON(getPeripheral("rsBridge").listFluids())
+	elseif parsed.method == "craft" then
+		return tostring(getPeripheral("rsBridge").craftItem(parsed.params))
+	elseif parsed.method == "getitem" then
+		local item = getPeripheral("rsBridge").getItem(parsed.params)
+		if not item then error({message = "Requested item not found!"}) end
+		return textutils.serializeJSON(item)
+	elseif parsed.method == "command" then
+		return runRsCommand(parsed.params)
+	end
+
+	error({message = "No message handler for method: "..parsed.method.."!"})
+end
+
+local function logJSON(json, prefix)
+	if not prefix then prefix = "" end
+	for k,v in pairs(json) do
+		local key = prefix..k
+		if type(v) == "table" then
+			logJSON(v, key..".")
+		else
+			print(key, "=", textutils.serializeJSON(v))
+		end
+	end
+end
+
+-- return bool success
+local function handleMessage(socket, message)
+	local parsed, reason = textutils.unserializeJSON(message)
+	if not parsed then
+		print("Received message:", message)
+		printError("Message could not be parsed:", reason)
+		return false
+	end
+
+	pcall(function() print("Received JSON:") logJSON(parsed) end)
+
+	if parsed.type == "request" then
+		local success, result = pcall(function() return getResponse(parsed) end)
+		if not success then
+			if not result.message then
+				sendResponse(socket, parsed.id, result, 2)
+			else
+				sendResponse(socket, parsed.id, result.message, 1)
+			end
+		else
+			sendResponse(socket, parsed.id, result, 0)
+		end
+		return true
+	end
+
+	printError("Invalid message type:", parsed.type)
+	return false
+end
+
+local function socketClient()
+	print("Connecting to the socket server at "..connectionUri.."...")
+	local socket, reason = http.websocket(connectionUri)
+	if not socket then error("Socket server could not be reached: "..reason) end
+	print("Connection successful!")
+
+	socket.send("login="..secretToken)
+	while true do
+		local message, binary = socket.receive()
+		if not not message and not binary then
+			if message == "outdated" then
+				printError("Current script is outdated! Please update from the host!")
+				return
+			end
+			handleMessage(socket, message)
+		end
+	end
+end
+
+local function termWaiter()
+	os.pullEvent("terminate")
+end
+
+local function services()
+	parallel.waitForAny(termWaiter, function()
+		parallel.waitForAll(socketClient)
+	end)
+end
+
+local function main()
+	while true do
+		local status, error = pcall(services)
+		if status then break end
+		printError("An uncaught exception was raised:", error)
+		printError("Restarting in", waitSeconds, "seconds...")
+		sleep(waitSeconds)
+	end
+end
+
+local oldPullEvent = os.pullEvent
+os.pullEvent = os.pullEventRaw
+pcall(main)
+os.pullEvent = oldPullEvent

MinecraftDiscordBot/Commands/CommandHandlerAttribute.cs

@@ -0,0 +1,8 @@
+namespace MinecraftDiscordBot.Commands;
+
+[AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
+public sealed class CommandHandlerAttribute : Attribute {
+    public CommandHandlerAttribute(string commandName) => CommandName = commandName;
+    public string CommandName { get; }
+    public string? HelpText { get; init; }
+}

MinecraftDiscordBot/Commands/CommandRouter.cs

@@ -0,0 +1,46 @@
+using Discord.WebSocket;
+using MinecraftDiscordBot.Services;
+using System.Reflection;
+using System.Text;
+
+namespace MinecraftDiscordBot.Commands;
+
+public abstract class CommandRouter : ICommandHandler<ResponseType> {
+    public record struct HandlerStruct(HandleCommandDelegate<ResponseType> Delegate, CommandHandlerAttribute Attribute);
+    private readonly Dictionary<string, HandlerStruct> _handlers = new();
+    public abstract string HelpTextPrefix { get; }
+    public CommandRouter() {
+        foreach (var method in GetType().GetMethods())
+            if (GetHandlerAttribute(method) is CommandHandlerAttribute attribute)
+                try {
+                    _handlers.Add(attribute.CommandName, new(method.CreateDelegate<HandleCommandDelegate<ResponseType>>(this), attribute));
+                } catch (Exception) {
+                    Program.LogWarning("CommandRouter", $"Could not add delegate for method {attribute.CommandName} in function {method.ReturnType} {method.Name}(...)!");
+                    throw;
+                }
+    }
+
+    [CommandHandler("help", HelpText = "Show this help information!")]
+    public virtual Task<ResponseType> GetHelpText(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => Task.FromResult(ResponseType.AsString(GenerateHelp()));
+    private static CommandHandlerAttribute? GetHandlerAttribute(MethodInfo method)
+        => method.GetCustomAttributes(typeof(CommandHandlerAttribute), true).OfType<CommandHandlerAttribute>().FirstOrDefault();
+    public virtual Task<ResponseType> RootAnswer(SocketUserMessage message, CancellationToken ct) => GetHelpText(message, Array.Empty<string>(), ct);
+    public abstract Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct);
+    public Task<ResponseType> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => parameters is { Length: 0 }
+            ? RootAnswer(message, ct)
+            : _handlers.TryGetValue(parameters[0], out var handler)
+                ? handler.Delegate(message, parameters[1..], ct)
+                : FallbackHandler(message, parameters[0], parameters[1..], ct);
+    private string GenerateHelp() {
+        var sb = new StringBuilder();
+        sb.Append("Command usage:");
+        foreach (var (name, handler) in _handlers) {
+            sb.Append($"\n{HelpTextPrefix}{name}");
+            if (handler.Attribute.HelpText is string help)
+                sb.Append($": {help}");
+        }
+        return sb.ToString();
+    }
+}

MinecraftDiscordBot/Commands/ICommandHandler.cs

@@ -0,0 +1,11 @@
+using Discord.WebSocket;
+
+namespace MinecraftDiscordBot.Commands;
+
+public interface ICommandHandler {
+    Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct);
+}
+
+public interface ICommandHandler<T> {
+    Task<T> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct);
+}

MinecraftDiscordBot/ConnectedComputer.cs

@@ -1,340 +0,0 @@
-using Discord;
-using Discord.WebSocket;
-using Fleck;
-using Newtonsoft.Json;
-using System.Diagnostics;
-using System.Text;
-
-namespace MinecraftDiscordBot;
-
-public class ConnectedComputer {
-    protected readonly IWebSocketConnection _socket;
-    public ConnectedComputer(IWebSocketConnection socket) {
-        socket.OnMessage = OnMessage;
-        _socket = socket;
-    }
-
-    private void OnMessage(string message) {
-        if (JsonConvert.DeserializeObject<ReplyMessage>(message) is not ReplyMessage msg) return;
-        IChunkWaiter? waiter;
-        lock (_syncRoot) {
-            if (!_waits.TryGetValue(msg.AnswerId, out waiter)) {
-                Program.LogWarning("Socket", $"Invalid wait id '{msg.AnswerId}'!");
-                return;
-            }
-        }
-        waiter.AddChunk(msg.Chunk, msg.Total, msg.Result);
-        if (waiter.Finished || waiter.IsCancellationRequested)
-            lock (_syncRoot)
-                _waits.Remove(waiter.ID);
-    }
-    public Task Send(string message) => _socket.Send(message);
-    protected Task Send(Message message) => Send(JsonConvert.SerializeObject(message));
-    private readonly object _syncRoot = new();
-    private readonly Dictionary<int, IChunkWaiter> _waits = new();
-    private readonly Random _rnd = new();
-    public IWebSocketConnectionInfo ConnectionInfo => _socket.ConnectionInfo;
-
-    protected interface IChunkWaiter {
-        bool Finished { get; }
-        int ID { get; }
-        bool IsCancellationRequested { get; }
-        void AddChunk(int chunkId, int totalChunks, string value);
-    }
-
-    protected class ChunkWaiter<T> : IChunkWaiter {
-        public int ID { get; }
-        private readonly CancellationToken _ct;
-        public ChunkWaiter(int id, Func<string, T> resultParser, CancellationToken ct) {
-            ID = id;
-            this.resultParser = resultParser;
-            _ct = ct;
-        }
-        private readonly TaskCompletionSource<T> tcs = new();
-        private readonly Func<string, T> resultParser;
-        public Task<T> Task => tcs.Task.WaitAsync(_ct);
-        public bool Finished { get; private set; } = false;
-        public bool IsCancellationRequested => _ct.IsCancellationRequested;
-        private string?[]? _chunks = null;
-        private int _receivedChunks = 0;
-        private readonly object _syncRoot = new();
-        public void AddChunk(int chunkId, int totalChunks, string value) {
-            lock (_syncRoot) {
-                if (_chunks is null) _chunks = new string[totalChunks];
-                else if (_chunks.Length != totalChunks) {
-                    Program.LogError(Program.WebSocketSource, new InvalidOperationException("Different numbers of chunks in same message ID!"));
-                    return;
-                }
-                ref string? chunk = ref _chunks[chunkId - 1]; // Lua 1-indexed
-                if (chunk is not null) {
-                    Program.LogError(Program.WebSocketSource, new InvalidOperationException($"Chunk with ID {chunkId} was already received!"));
-                    return;
-                }
-                chunk = value;
-            }
-            if (++_receivedChunks == totalChunks) FinalizeResult(_chunks);
-        }
-        private void FinalizeResult(string?[] _chunks) {
-            tcs.SetResult(resultParser(string.Concat(_chunks)));
-            Finished = true;
-        }
-    }
-
-    protected int GetFreeId() {
-        var attempts = 0;
-        while (true) {
-            var id = _rnd.Next();
-            if (!_waits.ContainsKey(id))
-                return id;
-            Program.LogWarning(Program.WebSocketSource, $"Could not get a free ID after {++attempts} attempts!");
-        }
-    }
-
-    protected ChunkWaiter<T> GetWaiter<T>(Func<string, T> resultParser, CancellationToken ct) {
-        ChunkWaiter<T> waiter;
-        lock (_syncRoot) {
-            waiter = new ChunkWaiter<T>(GetFreeId(), resultParser, ct);
-            _waits.Add(waiter.ID, waiter);
-        }
-        return waiter;
-    }
-
-    protected static Func<string, T> Deserialize<T>() => msg
-         => JsonConvert.DeserializeObject<T>(msg) ?? throw new InvalidProgramException("Empty response!");
-}
-
-public class RefinedStorageComputer : ConnectedComputer {
-    public const string Role = "rs";
-    private const string CmdEnergyUsage = "energyusage";
-    private const string CmdEnergyStorage = "energystorage";
-    private const string CmdListItems = "listitems";
-    private const string CmdItemName = "itemname";
-    private const string CmdListFluids = "listfluids";
-
-    public RefinedStorageComputer(IWebSocketConnection socket) : base(socket) { }
-    public async Task<int> GetEnergyUsageAsync(CancellationToken ct) {
-        var waiter = GetWaiter(int.Parse, ct);
-        await Send(new RequestMessage(waiter.ID, CmdEnergyUsage));
-        return await waiter.Task;
-    }
-    public async Task<int> GetEnergyStorageAsync(CancellationToken ct) {
-        var waiter = GetWaiter(int.Parse, ct);
-        await Send(new RequestMessage(waiter.ID, CmdEnergyStorage));
-        return await waiter.Task;
-    }
-    public async Task<IEnumerable<Item>> ListItemsAsync(CancellationToken ct) {
-        var waiter = GetWaiter(Deserialize<IEnumerable<Item>>(), ct);
-        await Send(new RequestMessage(waiter.ID, CmdListItems));
-        return await waiter.Task;
-    }
-
-    public async Task<IEnumerable<Fluid>> ListFluidsAsync(CancellationToken ct) {
-        var waiter = GetWaiter(Deserialize<IEnumerable<Fluid>>(), ct);
-        await Send(new RequestMessage(waiter.ID, CmdListFluids));
-        return await waiter.Task;
-    }
-
-    public async Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
-        if (parameters is not { Length: > 0 }) {
-            await message.ReplyAsync($"Refined Storage system is online");
-            return;
-        }
-
-        try {
-            switch (parameters[0].ToLower()) {
-            case CmdEnergyUsage:
-                await message.ReplyAsync($"Refined Storage system currently uses {await GetEnergyUsageAsync(ct)} RF/t");
-                break;
-            case CmdEnergyStorage:
-                await message.ReplyAsync($"Refined Storage system stores {await GetEnergyStorageAsync(ct)} RF/t");
-                break;
-            case CmdListItems:
-                await HandleItemListing(message, ct);
-                break;
-            case CmdItemName:
-                await HandleItemName(message, parameters, ct);
-                break;
-            case CmdListFluids:
-                await HandleFluidListing(message, ct);
-                break;
-            case string other:
-                await message.ReplyAsync($"Refined Storages cannot do '{other}', bruh");
-                break;
-            }
-        } catch (TaskCanceledException) {
-            await message.ReplyAsync("The Refined Storage system request timed out!");
-        }
-    }
-
-    private async Task HandleItemName(SocketUserMessage message, string[] parameters, CancellationToken ct) {
-        if (parameters.Length < 2) await message.ReplyAsync($"Usage: {CmdItemName} filters...");
-        else {
-            var items = await FilterItems(message, parameters[1..], ct);
-            var sb = new StringBuilder();
-            sb.AppendLine("Did you mean:");
-            sb.AppendJoin("\n", items.Select(i => i.ToString()));
-            await message.ReplyAsync(sb.ToString());
-        }
-    }
-
-    private Task<IEnumerable<Item>> FilterItems(SocketUserMessage message, IEnumerable<string> filters, CancellationToken ct)
-        => FilterItems(message, filters.Select(ItemFilter.Parse), ct);
-
-    private async Task<IEnumerable<Item>> FilterItems(SocketUserMessage message, IEnumerable<ItemFilter> filters, CancellationToken ct) {
-        var items = Items?.ToList().AsEnumerable();
-        if (items is null) items = (await RefreshItemList(ct)).ToList();
-        foreach (var filter in filters)
-            items = items.Where(filter.MatchItem);
-        return items.ToList();
-    }
-
-    public abstract class ItemFilter {
-        public abstract bool Match(Fluid item);
-        public virtual bool MatchItem(Item item) => Match(item);
-
-        public static ItemFilter Parse(string filter)
-            => filter.StartsWith('@')
-                ? new ModNameFilter(filter[1..])
-                : filter.StartsWith('$')
-                ? new TagFilter(filter[1..])
-                : new ItemNameFilter(filter);
-
-        private class ModNameFilter : ItemFilter {
-            private readonly string filter;
-            public ModNameFilter(string filter) => this.filter = filter;
-            public override bool Match(Fluid item) => item.ItemId.ModName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
-        }
-
-        private class TagFilter : ItemFilter {
-            private readonly string filter;
-            public TagFilter(string filter) => this.filter = filter;
-            public override bool Match(Fluid item)
-                => item.Tags?.Any(tag => tag.Contains(filter, StringComparison.InvariantCultureIgnoreCase)) ?? false;
-        }
-
-        private class ItemNameFilter : ItemFilter {
-            private readonly string filter;
-            public ItemNameFilter(string filter) => this.filter = filter;
-            public override bool Match(Fluid item) => item.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
-        }
-    }
-
-    private async Task HandleFluidListing(SocketUserMessage message, CancellationToken ct) {
-        var sb = new StringBuilder();
-        sb.Append("The Refined Storage system stores those fluids:");
-        var fluids = await ListFluidsAsync(ct);
-        foreach (var fluid in fluids.OrderByDescending(i => i.Amount))
-            if (fluid.Amount > 10000) sb.AppendFormat("\n{0:n2} B of {1}", fluid.Amount / 1000.0f, fluid.DisplayName);
-            else sb.AppendFormat("\n{0:n0} mB of {1}", fluid.Amount, fluid.DisplayName);
-        await message.ReplyAsync(sb.ToString());
-    }
-
-    private List<Item>? Items;
-    private readonly object _itemLock = new();
-
-    private async Task HandleItemListing(SocketUserMessage message, CancellationToken ct) {
-        var sb = new StringBuilder();
-        sb.Append("The Refined Storage system currently stores these items:");
-        var items = await RefreshItemList(ct);
-        lock (_itemLock) {
-            int taken = 0;
-            foreach (var item in items) {
-                if (sb.Length > 500) break;
-                sb.AppendFormat("\n{0:n0}x {1}", item.Amount, item.DisplayName);
-                taken++;
-            }
-            if (items.Count > taken) sb.AppendFormat("\nand {0} more items.", items.Skip(taken).Sum(i => i.Amount));
-        }
-        await message.ReplyAsync(sb.ToString());
-    }
-
-    private async Task<List<Item>> RefreshItemList(CancellationToken ct) {
-        var response = await ListItemsAsync(ct);
-        lock (_itemLock) {
-            Items = response.OrderByDescending(i => i.Amount).ToList();
-            return Items;
-        }
-    }
-}
-
-[JsonObject(MemberSerialization.OptIn, Description = "Describes an item in a Refined Storage system.", MissingMemberHandling = MissingMemberHandling.Ignore)]
-[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-public class Item : Fluid {
-    [JsonProperty("fingerprint", Required = Required.Always)]
-    public Md5Hash Fingerprint { get; set; } = default!;
-    [JsonProperty("nbt", Required = Required.DisallowNull)]
-    public dynamic? NBT { get; set; }
-    public override string ToString() => $"{Amount:n0}x {DisplayName}";
-}
-
-[JsonObject(MemberSerialization.OptIn, Description = "Describes a fluid in a Refined Storage system.", MissingMemberHandling = MissingMemberHandling.Ignore)]
-[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-public class Fluid {
-    [JsonProperty("amount", Required = Required.Always)]
-    public int Amount { get; set; }
-    [JsonProperty("displayName", Required = Required.Always)]
-    public string DisplayName { get; set; } = default!;
-    [JsonProperty("tags", Required = Required.DisallowNull)]
-    public string[]? Tags { get; set; } = default;
-    [JsonProperty("name", Required = Required.Always)]
-    public ModItemId ItemId { get; set; } = default!;
-    public override string ToString() => Amount > 10000
-        ? $"{Amount / 1000.0f:n2} B of {DisplayName}"
-        : $"{Amount:n0} mB of {DisplayName}";
-}
-
-[JsonConverter(typeof(ModItemIdJsonConverter))]
-[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-public class ModItemId {
-    public ModItemId(string name) {
-        var colon = name.IndexOf(':');
-        if (colon < 0) throw new ArgumentException("Invalid mod item id!", nameof(name));
-        ModName = name[..colon];
-        ModItem = name[(colon + 1)..];
-        if (ToString() != name) throw new InvalidProgramException("Bad Parsing!");
-    }
-    public override string ToString() => $"{ModName}:{ModItem}";
-    public string ModName { get; }
-    public string ModItem { get; }
-
-    public class ModItemIdJsonConverter : JsonConverter<ModItemId> {
-        public override ModItemId? ReadJson(JsonReader reader, Type objectType, ModItemId? existingValue, bool hasExistingValue, JsonSerializer serializer)
-            => reader.Value is string value
-                ? new(value)
-                : throw new JsonException($"Could not parse mod name with token '{reader.Value}'");
-        public override void WriteJson(JsonWriter writer, ModItemId? value, JsonSerializer serializer) {
-            if (value is null) writer.WriteNull();
-            else writer.WriteValue(value.ToString());
-        }
-    }
-}
-
-[JsonConverter(typeof(Md5JsonConverter))]
-[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-public class Md5Hash : IEquatable<Md5Hash?> {
-    private readonly byte[] _hash;
-    public Md5Hash(string hash) : this(Convert.FromHexString(hash)) { }
-    public Md5Hash(byte[] hash) {
-        if (hash is not { Length: 16 }) throw new ArgumentException("Invalid digest size!", nameof(hash));
-        _hash = hash;
-    }
-    public override bool Equals(object? obj) => Equals(obj as Md5Hash);
-    public bool Equals(Md5Hash? other) => other != null && _hash.SequenceEqual(other._hash);
-    public override int GetHashCode() {
-        var hashCode = new HashCode();
-        hashCode.AddBytes(_hash);
-        return hashCode.ToHashCode();
-    }
-    public override string ToString() => Convert.ToHexString(_hash);
-
-    public class Md5JsonConverter : JsonConverter<Md5Hash> {
-        public override Md5Hash? ReadJson(JsonReader reader, Type objectType, Md5Hash? existingValue, bool hasExistingValue, JsonSerializer serializer)
-            => reader.Value is string { Length: 32 } value
-                ? new(value)
-                : throw new JsonException($"Could not parse MD5 hash with token '{reader.Value}'");
-        public override void WriteJson(JsonWriter writer, Md5Hash? value, JsonSerializer serializer) {
-            if (value is null) writer.WriteNull();
-            else writer.WriteValue(value.ToString());
-        }
-    }
-}

MinecraftDiscordBot/IChunkWaiter.cs

@@ -0,0 +1,11 @@
+using MinecraftDiscordBot.Models;
+
+namespace MinecraftDiscordBot;
+
+public interface IChunkWaiter {
+    bool Finished { get; }
+    int ID { get; }
+    bool IsCancellationRequested { get; }
+    void AddChunk(int chunkId, int totalChunks, string value);
+    void SetResultState(ResultState state);
+}

MinecraftDiscordBot/IUserRoleManager.cs

@@ -0,0 +1,13 @@
+using Discord.WebSocket;
+
+namespace MinecraftDiscordBot;
+
+public interface IUserRoleManager {
+    /// <summary>
+    /// Verifies that a user is a bot administrator.
+    /// </summary>
+    /// <param name="user">User ID.</param>
+    /// <param name="message">An optional message to throw when user is not authorized.</param>
+    /// <exception cref="ReplyException">User is not authorized.</exception>
+    void RequireAdministrator(ulong user, string? message = null);
+}

MinecraftDiscordBot/ItemFilter.cs

@@ -0,0 +1,34 @@
+using MinecraftDiscordBot.Models;
+
+namespace MinecraftDiscordBot;
+
+public abstract class ItemFilter {
+    public abstract bool Match(Fluid item);
+    public virtual bool MatchItem(Item item) => Match(item);
+
+    public static ItemFilter Parse(string filter)
+        => filter.StartsWith('@')
+            ? new ModNameFilter(filter[1..])
+            : filter.StartsWith('$')
+            ? new TagFilter(filter[1..])
+            : new ItemNameFilter(filter);
+
+    private class ModNameFilter : ItemFilter {
+        private readonly string filter;
+        public ModNameFilter(string filter) => this.filter = filter;
+        public override bool Match(Fluid item) => item.ItemId.ModName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
+    }
+
+    private class TagFilter : ItemFilter {
+        private readonly string filter;
+        public TagFilter(string filter) => this.filter = filter;
+        public override bool Match(Fluid item)
+            => item.Tags?.Any(tag => tag.Contains(filter, StringComparison.InvariantCultureIgnoreCase)) ?? false;
+    }
+
+    private class ItemNameFilter : ItemFilter {
+        private readonly string filter;
+        public ItemNameFilter(string filter) => this.filter = filter;
+        public override bool Match(Fluid item) => item.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
+    }
+}

MinecraftDiscordBot/MinecraftDiscordBot.csproj

@@ -6,8 +6,19 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    <Version>1.1.1</Version>
+    <Authors>Michael Chen</Authors>
+    <Company>$(Authors)</Company>
+    <RepositoryUrl>https://gitlab.com/chenmichael/mcdiscordbot</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+    <AssemblyVersion>$(VersionPrefix)</AssemblyVersion>
+    <FileVersion>$(VersionPrefix)</FileVersion>
   </PropertyGroup>
 
+  <ItemGroup>
+    <EmbeddedResource Include="ClientScript.lua" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="CommandLineParser" Version="2.8.0" />
     <PackageReference Include="Discord.Net" Version="3.1.0" />
@@ -17,7 +28,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="Properties\" />
+    <Resource Include="ClientScript.lua" />
   </ItemGroup>
 
 </Project>

MinecraftDiscordBot/Models/Fluid.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+using System.Diagnostics;
+
+namespace MinecraftDiscordBot.Models;
+
+[JsonObject(MemberSerialization.OptIn, Description = "Describes a fluid in a Refined Storage system.", MissingMemberHandling = MissingMemberHandling.Ignore)]
+[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
+public class Fluid {
+    [JsonProperty("amount", Required = Required.Always)]
+    public int Amount { get; set; }
+    [JsonProperty("displayName", Required = Required.Always)]
+    public string DisplayName { get; set; } = default!;
+    [JsonProperty("tags", Required = Required.DisallowNull)]
+    public string[]? Tags { get; set; } = default;
+    [JsonProperty("name", Required = Required.Always)]
+    public ModItemId ItemId { get; set; } = default!;
+    public override string ToString() => Amount > 10000
+        ? $"{Amount / 1000.0f:n2} B of {DisplayName}"
+        : $"{Amount:n0} mB of {DisplayName}";
+    [JsonIgnore]
+    public string CleanDisplayName => DisplayName[1..^1];
+}

MinecraftDiscordBot/Models/Item.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+using System.Diagnostics;
+
+namespace MinecraftDiscordBot.Models;
+
+[JsonObject(MemberSerialization.OptIn, Description = "Describes an item in a Refined Storage system.", MissingMemberHandling = MissingMemberHandling.Ignore)]
+[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
+public class Item : Fluid {
+    [JsonProperty("fingerprint", Required = Required.Always)]
+    public Md5Hash Fingerprint { get; set; } = default!;
+    [JsonProperty("nbt", Required = Required.DisallowNull)]
+    public dynamic? NBT { get; set; }
+    public override string ToString() => $"{Amount:n0}x {DisplayName}";
+}

MinecraftDiscordBot/Models/LuaPackedArray.cs

@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace MinecraftDiscordBot.Models;
+
+public class LuaPackedArray {
+    public ref object? this[int i] => ref _items[i];
+    private readonly object?[] _items;
+    public LuaPackedArray(IDictionary<string, object> packedTable) {
+        if (packedTable["n"] is not long n) throw new ArgumentException("No length in packed array!");
+        _items = new object?[n];
+        for (var i = 0; i < _items.Length; i++)
+            _items[i] = packedTable.TryGetValue((i + 1).ToString(), out var val) ? val : null;
+    }
+    public static LuaPackedArray Deserialize(string value) {
+        var dict = JsonConvert.DeserializeObject<Dictionary<string, object>>(value);
+        return new LuaPackedArray(dict ?? throw new Exception("Not a packed table (empty object)!"));
+    }
+    public override string ToString() => _items is { Length: 0 }
+        ? "Empty Array"
+        : string.Join(", ", _items.Select(i => i is null ? "nil" : i.ToString()));
+}

MinecraftDiscordBot/Models/Md5Hash.cs

@@ -0,0 +1,45 @@
+using Newtonsoft.Json;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+namespace MinecraftDiscordBot.Models;
+
+[JsonConverter(typeof(Md5JsonConverter))]
+[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
+public class Md5Hash : IEquatable<Md5Hash?> {
+    private readonly byte[] _hash;
+    public Md5Hash(string hash) : this(Convert.FromHexString(hash)) { }
+    public Md5Hash(byte[] hash) {
+        if (hash is not { Length: 16 }) throw new ArgumentException("Invalid digest size!", nameof(hash));
+        _hash = hash;
+    }
+    public override bool Equals(object? obj) => Equals(obj as Md5Hash);
+    public bool Equals(Md5Hash? other) => other != null && _hash.SequenceEqual(other._hash);
+    public override int GetHashCode() {
+        var hashCode = new HashCode();
+        hashCode.AddBytes(_hash);
+        return hashCode.ToHashCode();
+    }
+    public override string ToString() => Convert.ToHexString(_hash).ToLower();
+
+    public class Md5JsonConverter : JsonConverter<Md5Hash> {
+        public override Md5Hash? ReadJson(JsonReader reader, Type objectType, Md5Hash? existingValue, bool hasExistingValue, JsonSerializer serializer)
+            => reader.Value is string { Length: 32 } value
+                ? new(value)
+                : throw new JsonException($"Could not parse MD5 hash with token '{reader.Value}'");
+        public override void WriteJson(JsonWriter writer, Md5Hash? value, JsonSerializer serializer) {
+            if (value is null) writer.WriteNull();
+            else writer.WriteValue(value.ToString());
+        }
+    }
+
+    public static bool TryParse(string itemid, [NotNullWhen(true)] out Md5Hash? fingerprint) {
+        try {
+            fingerprint = new Md5Hash(itemid);
+            return true;
+        } catch (Exception) {
+            fingerprint = null;
+            return false;
+        }
+    }
+}

MinecraftDiscordBot/Models/Message.cs

@@ -1,7 +1,7 @@
 using Discord.WebSocket;
 using Newtonsoft.Json;
 
-namespace MinecraftDiscordBot;
+namespace MinecraftDiscordBot.Models;
 
 public abstract class Message {
     [JsonProperty("type")]
@@ -11,7 +11,7 @@ public abstract class Message {
 public class CapabilityMessage : Message {
     public override string Type => "roles";
     [JsonProperty("role", Required = Required.Always)]
-    public string Role { get; set; } = default!;
+    public string[] Role { get; set; } = default!;
 }
 
 public class TextMessage : Message {
@@ -36,18 +36,20 @@ public class ReplyMessage : Message {
     public int AnswerId { get; set; }
     [JsonProperty("result", Required = Required.Always)]
     public string Result { get; set; }
-    [JsonProperty("chunk", Required = Required.Always)]
-    public int Chunk { get; set; }
-    [JsonProperty("total", Required = Required.Always)]
-    public int Total { get; set; }
+    [JsonProperty("chunk", Required = Required.DisallowNull)]
+    public int Chunk { get; set; } = 1;
+    [JsonProperty("total", Required = Required.DisallowNull)]
+    public int Total { get; set; } = 1;
+    [JsonProperty("success", Required = Required.DisallowNull)]
+    public ResultState State { get; set; } = ResultState.Successful;
     public override string Type => "reply";
 }
 
 public class RequestMessage : Message {
-    public RequestMessage(int answerId, string method, Dictionary<string, string>? parameters = null) {
+    public RequestMessage(int answerId, string method, Dictionary<string, object>? parameters = null) {
         AnswerId = answerId;
         Method = method;
-        Parameters = (parameters ?? Enumerable.Empty<KeyValuePair<string, string>>())
+        Parameters = (parameters ?? Enumerable.Empty<KeyValuePair<string, object>>())
             .ToDictionary(i => i.Key, i => i.Value);
     }
     [JsonProperty("id")]
@@ -55,6 +57,12 @@ public class RequestMessage : Message {
     [JsonProperty("method")]
     public string Method { get; set; }
     [JsonProperty("params")]
-    public Dictionary<string, string> Parameters { get; }
+    public Dictionary<string, object> Parameters { get; }
     public override string Type => "request";
+}
+
+public enum ResultState {
+    Successful,
+    Unsuccessful,
+    Fatal
 }

MinecraftDiscordBot/Models/ModItemId.cs

@@ -0,0 +1,30 @@
+using Newtonsoft.Json;
+using System.Diagnostics;
+
+namespace MinecraftDiscordBot.Models;
+
+[JsonConverter(typeof(ModItemIdJsonConverter))]
+[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
+public class ModItemId {
+    public ModItemId(string name) {
+        var colon = name.IndexOf(':');
+        if (colon < 0) throw new ArgumentException("Invalid mod item id!", nameof(name));
+        ModName = name[..colon];
+        ModItem = name[(colon + 1)..];
+        if (ToString() != name) throw new InvalidProgramException("Bad Parsing!");
+    }
+    public override string ToString() => $"{ModName}:{ModItem}";
+    public string ModName { get; }
+    public string ModItem { get; }
+
+    public class ModItemIdJsonConverter : JsonConverter<ModItemId> {
+        public override ModItemId? ReadJson(JsonReader reader, Type objectType, ModItemId? existingValue, bool hasExistingValue, JsonSerializer serializer)
+            => reader.Value is string value
+                ? new(value)
+                : throw new JsonException($"Could not parse mod name with token '{reader.Value}'");
+        public override void WriteJson(JsonWriter writer, ModItemId? value, JsonSerializer serializer) {
+            if (value is null) writer.WriteNull();
+            else writer.WriteValue(value.ToString());
+        }
+    }
+}

MinecraftDiscordBot/Program.cs

@@ -1,19 +1,22 @@
+using CommandLine;
 using Discord;
 using Discord.Commands;
 using Discord.Rest;
 using Discord.WebSocket;
 using Fleck;
-using Newtonsoft.Json;
+using MinecraftDiscordBot.Commands;
+using MinecraftDiscordBot.Services;
 using System.Collections.Concurrent;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
 namespace MinecraftDiscordBot;
 
-public class Program : IDisposable {
+public class Program : IDisposable, ICommandHandler<ResponseType>, IUserRoleManager {
     public const string WebSocketSource = "WebSocket";
     public const string BotSource = "Bot";
     private static readonly object LogLock = new();
+    public const int ChoiceTimeout = 20 * 1000;
     private readonly DiscordSocketClient _client = new(new() {
         LogLevel = LogSeverity.Verbose,
         GatewayIntents = GatewayIntents.AllUnprivileged & ~(GatewayIntents.GuildScheduledEvents | GatewayIntents.GuildInvites)
@@ -21,19 +24,36 @@ public class Program : IDisposable {
     private readonly WebSocketServer _wssv;
     private readonly BotConfiguration _config;
     private readonly HashSet<ulong> _whitelistedChannels;
-    private readonly ConcurrentDictionary<Guid, ConnectedComputer> _connections = new();
+    private readonly ConcurrentDictionary<Guid, RootCommandService> _connections = new();
     private static readonly char[] WhiteSpace = new char[] { '\t', '\n', ' ', '\r' };
     public ITextChannel[] _channels = Array.Empty<ITextChannel>();
-    private RefinedStorageComputer? _rsSystem = null;
+    private RootCommandService? _rsSystem = null;
     private bool disposedValue;
+    public static bool OnlineNotifications => true;
+    private const string ClientScriptName = "MinecraftDiscordBot.ClientScript.lua";
+    public readonly string ClientScript;
+    private readonly ITokenProvider _tokenProvider = new TimeoutTokenProvider(InstanceId, 10);
+    private static readonly int InstanceId = new Random().Next();
 
-    public RefinedStorageComputer? RsSystem {
+    private string GetVerifiedClientScript() => ClientScript
+        .Replace("$TOKEN", _tokenProvider.GenerateToken());
+
+    private static string GetClientScript(BotConfiguration config) {
+        using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(ClientScriptName);
+        if (stream is null) throw new FileNotFoundException("Client script could not be loaded!");
+        using var sr = new StreamReader(stream);
+        return sr.ReadToEnd()
+            .Replace("$HOST", $"ws://{config.SocketHost}:{config.Port}");
+    }
+
+    public RootCommandService? Computer {
         get => _rsSystem; set {
             if (_rsSystem != value) {
                 _rsSystem = value;
-                _ = Task.Run(() => Broadcast(i => i.SendMessageAsync(value is null
-                    ? $"The Refined Storage went offline. Please check the server!"
-                    : $"The Refined Storage is back online!")));
+                if (OnlineNotifications)
+                    _ = Task.Run(() => Broadcast(i => i.SendMessageAsync(value is null
+                          ? $"The Minecraft client has gone offline!"
+                          : $"The Minecraft client is now online!")));
             }
         }
     }
@@ -41,8 +61,11 @@ public class Program : IDisposable {
     private async Task Broadcast(Func<ITextChannel, Task<IUserMessage>> message) => _ = await Task.WhenAll(_channels.Select(message));
     public Program(BotConfiguration config) {
         _config = config;
+        _administrators = config.Administrators.ToHashSet();
+        ClientScript = GetClientScript(config);
         _client.Log += LogAsync;
         _client.MessageReceived += (msg) => DiscordMessageReceived(msg);
+        _client.ReactionAdded += DiscordReactionAdded;
         _wssv = new WebSocketServer($"ws://0.0.0.0:{config.Port}") {
             RestartAfterListenError = true
         };
@@ -60,107 +83,169 @@ public class Program : IDisposable {
 
 
     public static Task<int> Main(string[] args)
-        => JsonConvert.DeserializeObject<BotConfiguration>(File.ReadAllText("config.json")) is BotConfiguration config
-            ? new Program(config).RunAsync()
-            : throw new InvalidProgramException("Configuration file missing!");
+        => Parser.Default.ParseArguments<BotConfiguration, ConfigFile>(args)
+        .MapResult<BotConfiguration, ConfigFile, Task<int>>(
+            RunWithConfig,
+            RunWithConfig,
+            errs => Task.FromResult(1));
+
+    private static Task<int> RunWithConfig(IBotConfigurator arg) => new Program(arg.Config).RunAsync();
 
     public async Task<int> RunAsync() {
+        StartWebSocketServer();
         await _client.LoginAsync(TokenType.Bot, _config.Token);
         await _client.StartAsync();
-        await VerifyTextChannels();
-        StartWebSocketServer();
+        if (!await HasValidChannels())
+            return 1;
 
         // Block this task until the program is closed.
         await Task.Delay(-1);
         return 0;
     }
 
+    private async Task<bool> HasValidChannels() {
+        if (await GetValidChannels(_whitelistedChannels).ToArrayAsync() is not { Length: > 0 } channels) {
+            await LogErrorAsync(BotSource, new InvalidOperationException("No valid textchannel was whitelisted!"));
+            return false;
+        }
+        _channels = channels;
+        return true;
+    }
+
     private void StartWebSocketServer() => _wssv.Start(socket => {
         socket.OnOpen = async () => await SocketOpened(socket);
         socket.OnClose = async () => await SocketClosed(socket);
         socket.OnMessage = async message => await SocketReceived(socket, message);
     });
+
     private async IAsyncEnumerable<ITextChannel> GetValidChannels(IEnumerable<ulong> ids) {
         foreach (var channelId in ids) {
             var channel = await _client.GetChannelAsync(channelId);
             if (channel is not ITextChannel textChannel) {
-                if (channel is null) await LogWarning(BotSource, $"Channel with id [{channelId}] does not exist!");
-                else await LogWarning(BotSource, $"Channel is not a text channels and will not be used: {channel.Name} [{channel.Id}]!");
+                if (channel is null) await LogWarningAsync(BotSource, $"Channel with id [{channelId}] does not exist!");
+                else await LogWarningAsync(BotSource, $"Channel is not a text channels and will not be used: {channel.Name} [{channel.Id}]!");
                 continue;
             }
 
             if (textChannel.Guild is RestGuild guild) {
                 await guild.UpdateAsync();
-                await LogInfo(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on server {guild.Name} [{guild.Id}]");
+                await LogInfoAsync(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on server {guild.Name} [{guild.Id}]");
             } else {
-                await LogWarning(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on unknown server!");
+                await LogWarningAsync(BotSource, $"Whitelisted in channel: {channel.Name} [{channel.Id}] on unknown server!");
             }
             yield return textChannel;
         }
     }
 
-    private async Task VerifyTextChannels() => _channels = await GetValidChannels(_whitelistedChannels).ToArrayAsync();
-
     private async Task SocketReceived(IWebSocketConnection socket, string message) {
-        if (JsonConvert.DeserializeObject<CapabilityMessage>(message) is not CapabilityMessage capability) return;
+        await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Received: {message}");
+        await (message switch {
+            "getcode" => SendClientCode(socket),
+            string s when s.StartsWith("login=") => ClientComputerConnected(socket, s[6..]),
+            _ => DisruptClientConnection(socket, "Protocol violation!")
+        });
+    }
 
-        try {
-            var pc = capability.Role switch {
-                RefinedStorageComputer.Role => new RefinedStorageComputer(socket),
-                string role => throw new ArgumentException($"Invalid role '{role}'!")
-            };
-            AddComputerSocket(socket, pc);
-            await LogInfo(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Presented capability as {pc.GetType().Name}");
-        } catch (ArgumentException e) {
-            await LogError(WebSocketSource, e);
+    private async Task ClientComputerConnected(IWebSocketConnection socket, string token) {
+        if (!_tokenProvider.VerifyToken(token)) {
+            await DisruptClientConnection(socket, "outdated");
+            return;
         }
+        await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client logged in with valid script!");
+        AddComputerSocket(socket, new(socket, this));
     }
 
-    private void AddComputerSocket(IWebSocketConnection socket, ConnectedComputer pc) {
-        if (pc is RefinedStorageComputer rs) RsSystem = rs;
+    private static async Task DisruptClientConnection(IWebSocketConnection socket, string reason) {
+        await socket.Send(reason);
+        await LogWarningAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client will be terminated, reason: {reason}");
+        socket.Close();
     }
 
+    private async Task SendClientCode(IWebSocketConnection socket) {
+        await socket.Send(GetVerifiedClientScript());
+        await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Script sent to client!");
+    }
+
+    private void AddComputerSocket(IWebSocketConnection socket, RootCommandService pc) => Computer = pc;
+
     private void RemoveComputerSocket(IWebSocketConnection socket) {
-        if (RsSystem?.ConnectionInfo.Id == socket.ConnectionInfo.Id) RsSystem = null;
+        if (Computer is { ConnectionInfo.Id: Guid id } && id == socket.ConnectionInfo.Id) Computer = null;
     }
 
     private async Task SocketClosed(IWebSocketConnection socket) {
         RemoveComputerSocket(socket);
-        await LogInfo(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client disconnected!");
+        await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client disconnected!");
     }
 
-    private static async Task SocketOpened(IWebSocketConnection socket)
-        => await LogInfo(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client connected from {socket.ConnectionInfo.ClientIpAddress}:{socket.ConnectionInfo.ClientPort}!");
+    private static async Task SocketOpened(IWebSocketConnection socket) => await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client connected from {socket.ConnectionInfo.ClientIpAddress}:{socket.ConnectionInfo.ClientPort}!");
 
     private async Task DiscordMessageReceived(SocketMessage arg, int timeout = 10000) {
         if (arg is not SocketUserMessage message) return;
         if (message.Author.IsBot) return;
         if (!IsChannelWhitelisted(arg.Channel)) return;
+        if (arg.Type is not MessageType.Default) return;
 
         var cts = new CancellationTokenSource(timeout);
 
         if (IsCommand(message, out var argPos)) {
+            await arg.Channel.TriggerTypingAsync();
             var parameters = message.Content[argPos..].Split(WhiteSpace, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-            _ = Task.Run(() => HandleCommand(message, parameters, cts.Token));
+            _ = Task.Run(async () => {
+                var response = await HandleCommand(message, parameters, cts.Token);
+                await SendResponse(message, response);
+            });
             return;
         }
 
-        await LogInfo("Discord", $"[{arg.Author.Username}] {arg.Content}");
+        await LogInfoAsync("Discord", $"[{arg.Author.Username}] {arg.Content}");
         // TODO: Relay Message to Chat Receiver   
     }
 
-    private Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
-        => parameters is { Length: > 0 }
-            ? parameters[0].ToLower() switch {
-                RefinedStorageComputer.Role => HandleRefinedStorageCommand(message, parameters[1..], ct),
-                _ => message.ReplyAsync($"What the fuck do you mean by '{parameters[0]}'?")
-            }
-            : message.ReplyAsync($"You really think an empty command works?");
+    private Task SendResponse(SocketUserMessage message, ResponseType response) => response switch {
+        ResponseType.IChoiceResponse res => HandleChoice(message, res),
+        ResponseType.StringResponse res => message.ReplyAsync(res.Message),
+        _ => message.ReplyAsync($"Whoops, someone forgot to implement '{response.GetType()}' responses?"),
+    };
 
-    private Task HandleRefinedStorageCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
-        => RsSystem is RefinedStorageComputer rs
-            ? rs.HandleCommand(message, parameters, ct)
-            : message.ReplyAsync("The Refined Storage system is currently unavailable!");
+    private readonly ConcurrentDictionary<ulong, ResponseType.IChoiceResponse> _choiceWait = new();
+    private readonly HashSet<ulong> _administrators;
+
+    private async Task DiscordReactionAdded(Cacheable<IUserMessage, ulong> message, Cacheable<IMessageChannel, ulong> channel, SocketReaction reaction) {
+        var msgObject = await message.GetOrDownloadAsync();
+        if (reaction.UserId == _client.CurrentUser.Id) return;
+        if (!_choiceWait.TryRemove(message.Id, out var choice)) { await LogInfoAsync(BotSource, "Reaction was added to message without choice object!"); return; }
+        await msgObject.DeleteAsync();
+        await LogInfoAsync(BotSource, $"Reaction {reaction.Emote.Name} was added to the choice by {reaction.UserId}!");
+    }
+
+    private async Task HandleChoice(SocketUserMessage message, ResponseType.IChoiceResponse res) {
+        var reply = await message.ReplyAsync($"{res.Query}\n{string.Join("\n", res.Options)}");
+        _choiceWait[reply.Id] = res;
+        var reactions = new Emoji[] { new("0️⃣")/*, new("1️⃣"), new("2️⃣"), new("3️⃣"), new("4️⃣"), new("5️⃣"), new("6️⃣"), new("7️⃣"), new("8️⃣"), new("9️⃣")*/ };
+        await reply.AddReactionsAsync(reactions);
+        _ = Task.Run(async () => {
+            await Task.Delay(ChoiceTimeout);
+            _ = _choiceWait.TryRemove(message.Id, out _);
+            await reply.ModifyAsync(i => i.Content = "You did not choose in time!");
+            await reply.RemoveAllReactionsAsync();
+        });
+    }
+
+    public async Task<ResponseType> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        if (Computer is ICommandHandler<ResponseType> handler)
+            try {
+                return await handler.HandleCommand(message, parameters, ct);
+            } catch (TaskCanceledException) {
+                return ResponseType.AsString("Your request could not be processed in time!");
+            } catch (ReplyException e) {
+                await LogInfoAsync(BotSource, e.Message);
+                return ResponseType.AsString(e.Message);
+            } catch (Exception e) {
+                await LogErrorAsync(BotSource, e);
+                return ResponseType.AsString($"Oopsie doopsie, this should not have happened!");
+            }
+        else return ResponseType.AsString("The Minecraft server is currently unavailable!");
+    }
 
     private bool IsCommand(SocketUserMessage message, out int argPos) {
         argPos = 0;
@@ -169,16 +254,19 @@ public class Program : IDisposable {
     private bool IsChannelWhitelisted(ISocketMessageChannel channel)
         => _whitelistedChannels.Contains(channel.Id);
 
-    public static ConfiguredTaskAwaitable LogInfo(string source, string message) => LogAsync(new(LogSeverity.Info, source, message)).ConfigureAwait(false);
-    public static ConfiguredTaskAwaitable LogWarning(string source, string message) => LogAsync(new(LogSeverity.Warning, source, message)).ConfigureAwait(false);
-    public static ConfiguredTaskAwaitable LogError(string source, Exception exception) => LogAsync(new(LogSeverity.Error, source, exception?.Message, exception)).ConfigureAwait(false);
+    public static ConfiguredTaskAwaitable LogInfoAsync(string source, string message) => LogAsync(new(LogSeverity.Info, source, message)).ConfigureAwait(false);
+    public static ConfiguredTaskAwaitable LogWarningAsync(string source, string message) => LogAsync(new(LogSeverity.Warning, source, message)).ConfigureAwait(false);
+    public static ConfiguredTaskAwaitable LogErrorAsync(string source, Exception exception) => LogAsync(new(LogSeverity.Error, source, exception?.Message, exception)).ConfigureAwait(false);
+    public static void LogInfo(string source, string message) => Log(new(LogSeverity.Info, source, message));
+    public static void LogWarning(string source, string message) => Log(new(LogSeverity.Warning, source, message));
+    public static void LogError(string source, Exception exception) => Log(new(LogSeverity.Error, source, exception?.Message, exception));
 
     private static async Task LogAsync(LogMessage msg) {
         Log(msg);
         await Task.CompletedTask;
     }
 
-    private static void Log(LogMessage msg) {
+    public static void Log(LogMessage msg) {
         lock (LogLock)
             Console.WriteLine(msg.ToString());
     }
@@ -209,4 +297,38 @@ public class Program : IDisposable {
         Dispose(disposing: true);
         GC.SuppressFinalize(this);
     }
+
+    public void RequireAdministrator(ulong user, string? message = null) {
+        if (!_administrators.Contains(user))
+            throw new ReplyException(message ?? "User is not authorized to access this command!");
+    }
 }
+
+public abstract class ResponseType {
+    private static string DefaultDisplay<T>(T obj) => obj?.ToString() ?? throw new InvalidProgramException("ToString did not yield anything!");
+    public static ResponseType AsString(string message) => new StringResponse(message);
+    public static ResponseType FromChoice<T>(string query, IEnumerable<T> choice, Func<T, Task> resultHandler, Func<T, string>? display = null) => new ChoiceResponse<T>(query, choice, resultHandler, display ?? DefaultDisplay);
+    public class StringResponse : ResponseType {
+        public StringResponse(string message) => Message = message;
+        public string Message { get; }
+    }
+    public interface IChoiceResponse {
+        IEnumerable<string> Options { get; }
+        string Query { get; }
+        Task HandleResult(int index);
+    }
+    public class ChoiceResponse<T> : ResponseType, IChoiceResponse {
+        private readonly Func<T, Task> _resultHandler;
+        private readonly T[] _options;
+        private readonly Func<T, string> _displayer;
+        public IEnumerable<string> Options => _options.Select(_displayer);
+        public string Query { get; }
+        public Task HandleResult(int index) => _resultHandler(_options[index]);
+        public ChoiceResponse(string query, IEnumerable<T> choice, Func<T, Task> resultHandler, Func<T, string> display) {
+            Query = query;
+            _resultHandler = resultHandler;
+            _options = choice.ToArray();
+            _displayer = display;
+        }
+    }
+}

MinecraftDiscordBot/Services/RefinedStorageService.cs

@@ -0,0 +1,166 @@
+using Discord.WebSocket;
+using MinecraftDiscordBot.Commands;
+using MinecraftDiscordBot.Models;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace MinecraftDiscordBot.Services;
+
+public class RefinedStorageService : CommandRouter {
+    private readonly ITaskWaitSource _taskSource;
+    private readonly IUserRoleManager _roleManager;
+    public override string HelpTextPrefix => "!rs ";
+    public RefinedStorageService(ITaskWaitSource taskSource, IUserRoleManager roleManager) : base() {
+        _taskSource = taskSource;
+        _roleManager = roleManager;
+    }
+
+    public override Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct)
+        => throw new ReplyException($"The RS system has no command '{method}'!");
+
+    private async Task<T> Method<T>(string methodName, Func<string, T> parser, CancellationToken ct, Dictionary<string, object>? parameters = null) {
+        var waiter = _taskSource.GetWaiter(parser, ct);
+        await _taskSource.Send(new RequestMessage(waiter.ID, methodName, parameters));
+        return await waiter.Task;
+    }
+
+    private const string CmdEnergyUsage = "energyusage";
+    private const string CmdEnergyStorage = "energystorage";
+    private const string CmdListItems = "listitems";
+    private const string CmdItemName = "itemname";
+    private const string CmdListFluids = "listfluids";
+    private const string CmdCraftItem = "craft";
+    private const string CmdGetItem = "getitem";
+    private const string CmdCommand = "command";
+
+    public async Task<int> GetEnergyUsageAsync(CancellationToken ct) => await Method(CmdEnergyUsage, int.Parse, ct);
+    public async Task<int> GetEnergyStorageAsync(CancellationToken ct) => await Method(CmdEnergyStorage, int.Parse, ct);
+    public async Task<IEnumerable<Item>> ListItemsAsync(CancellationToken ct) => await Method(CmdListItems, RootCommandService.Deserialize<IEnumerable<Item>>(), ct);
+    public async Task<IEnumerable<Fluid>> ListFluidsAsync(CancellationToken ct) => await Method(CmdListFluids, RootCommandService.Deserialize<IEnumerable<Fluid>>(), ct);
+    public async Task<Item> GetItemData(string itemid, CancellationToken ct) => await Method(CmdGetItem, RootCommandService.Deserialize<Item>(), ct, new() {
+        ["name"] = itemid
+    });
+    public async Task<Item> GetItemData(Md5Hash fingerprint, CancellationToken ct) => await Method(CmdGetItem, RootCommandService.Deserialize<Item>(), ct, new() {
+        ["fingerprint"] = fingerprint.ToString()
+    });
+    public async Task<bool> CraftItem(string itemid, int amount, CancellationToken ct) => await Method(CmdCraftItem, RootCommandService.Deserialize<bool>(), ct, new() {
+        ["name"] = itemid,
+        ["count"] = amount
+    });
+    public async Task<LuaPackedArray> RawCommand(string command, CancellationToken ct) => await Method(CmdCommand, LuaPackedArray.Deserialize, ct, new() {
+        ["command"] = command
+    });
+
+    private Task<IEnumerable<Item>> FilterItems(SocketUserMessage message, IEnumerable<string> filters, CancellationToken ct)
+        => FilterItems(message, filters.Select(ItemFilter.Parse), ct);
+
+    private async Task<IEnumerable<Item>> FilterItems(SocketUserMessage message, IEnumerable<ItemFilter> filters, CancellationToken ct) {
+        var items = Items?.ToList().AsEnumerable();
+        if (items is null) items = (await RefreshItemList(ct)).ToList();
+        foreach (var filter in filters)
+            items = items.Where(filter.MatchItem);
+        return items.ToList();
+    }
+
+    private async Task<List<Item>> RefreshItemList(CancellationToken ct) {
+        var response = await ListItemsAsync(ct);
+        lock (_itemLock) {
+            Items = response.OrderByDescending(i => i.Amount).ToList();
+            return Items;
+        }
+    }
+
+    private List<Item>? Items;
+    private readonly object _itemLock = new();
+
+    [CommandHandler(CmdEnergyStorage, HelpText = "Get the amount of energy stored in the RS system.")]
+    public async Task<ResponseType> HandleEnergyStorage(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => ResponseType.AsString($"Refined Storage system stores {await GetEnergyStorageAsync(ct)} RF/t");
+    [CommandHandler(CmdEnergyUsage, HelpText = "Get the amount of energy used by the RS system.")]
+    public async Task<ResponseType> HandleEnergyUsage(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => ResponseType.AsString($"Refined Storage system currently uses {await GetEnergyUsageAsync(ct)} RF/t");
+    [CommandHandler(CmdCraftItem, HelpText = "Craft a specific item given an item ID and optionally an amount.")]
+    public async Task<ResponseType> HandleCraftItem(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        var amount = 1;
+        string itemid;
+        if (parameters.Length is 1 or 2) {
+            itemid = parameters[0];
+            if (parameters.Length is 2)
+                amount = int.TryParse(parameters[1], out var value)
+                    ? value
+                    : throw new ReplyException($"I expected an amount to craft, not '{parameters[1]}'!");
+        } else return parameters.Length is < 1
+            ? throw new ReplyException("You have to give me at least an item name!")
+            : parameters.Length is > 2
+            ? throw new ReplyException("Yo, those are way too many arguments! I want only item name and maybe an amount!")
+            : throw new InvalidOperationException($"Forgot to match parameter length {parameters.Length}!");
+        return await CraftItem(itemid, amount, ct)
+            ? ResponseType.AsString($"Alright, I'm starting to craft {amount} {itemid}.")
+            : ResponseType.AsString($"Nope, that somehow doesn't work!");
+    }
+    [CommandHandler(CmdGetItem, HelpText = "Get information about a specific item.")]
+    public async Task<ResponseType> HandleGetItemData(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        string itemid;
+        if (parameters.Length is not 1) throw new ReplyException($"I only want one name or fingerprint to search for, you gave me {parameters.Length} arguments!");
+        itemid = parameters[0];
+        var item = await (Md5Hash.TryParse(itemid, out var fingerprint)
+            ? GetItemData(fingerprint, ct)
+            : GetItemData(itemid, ct));
+        var sb = new StringBuilder();
+        sb.Append($"We currently have {item.Amount:n0} {item.CleanDisplayName}!");
+        if (item.Tags is not null and var tags) {
+            sb.AppendLine("\nThis item has the following tags:");
+            sb.AppendJoin('\n', tags.Select(tag => $"- {tag}"));
+        }
+        sb.Append($"\nRefer to this item with fingerprint {item.Fingerprint}");
+        return ResponseType.AsString(sb.ToString());
+    }
+
+    [CommandHandler(CmdItemName, HelpText = "Filter items by name.")]
+    public async Task<ResponseType> HandleItemName(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        if (parameters.Length < 2) return ResponseType.AsString($"Usage: {CmdItemName} filters...");
+        else {
+            var items = await FilterItems(message, parameters[1..], ct);
+            var sb = new StringBuilder();
+            sb.AppendLine("Did you mean:");
+            sb.AppendJoin("\n", items.Select(i => i.ToString()));
+            return ResponseType.AsString(sb.ToString());
+        }
+    }
+
+    [CommandHandler(CmdListFluids, HelpText = "Gets a list of fluids that are currently stored in the RS system.")]
+    public async Task<ResponseType> HandleFluidListing(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        var sb = new StringBuilder();
+        sb.Append("The Refined Storage system stores those fluids:");
+        var fluids = await ListFluidsAsync(ct);
+        foreach (var fluid in fluids.OrderByDescending(i => i.Amount))
+            if (fluid.Amount > 10000) sb.AppendFormat("\n{0:n2} B of {1}", fluid.Amount / 1000.0f, fluid.DisplayName);
+            else sb.AppendFormat("\n{0:n0} mB of {1}", fluid.Amount, fluid.DisplayName);
+        return ResponseType.AsString(sb.ToString());
+    }
+
+    [CommandHandler(CmdCommand, HelpText = "Runs a raw command on the RS system.")]
+    public async Task<ResponseType> HandleRawCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        _roleManager.RequireAdministrator(message.Author.Id, "You are not authorized to run raw commands on this instance!");
+        var command = string.Join(' ', parameters);
+        var response = await RawCommand(command, ct);
+        return ResponseType.AsString(response.ToString());
+    }
+
+    [CommandHandler(CmdListItems, HelpText = "Gets a list of items that are currently stored in the RS system.")]
+    public async Task<ResponseType> HandleItemListing(SocketUserMessage message, string[] parameters, CancellationToken ct) {
+        var sb = new StringBuilder();
+        sb.Append("The Refined Storage system currently stores these items:");
+        var items = await RefreshItemList(ct);
+        lock (_itemLock) {
+            var taken = 0;
+            foreach (var item in items) {
+                if (sb.Length > 500) break;
+                sb.AppendFormat("\n{0:n0}x {1}", item.Amount, item.DisplayName);
+                taken++;
+            }
+            if (items.Count > taken) sb.AppendFormat("\nand {0} more items.", items.Skip(taken).Sum(i => i.Amount));
+        }
+        return ResponseType.AsString(sb.ToString());
+    }
+}

MinecraftDiscordBot/Services/ReplyException.cs

@@ -0,0 +1,11 @@
+using System.Runtime.Serialization;
+
+namespace MinecraftDiscordBot.Services;
+
+[Serializable]
+public class ReplyException : Exception {
+    public ReplyException() { }
+    public ReplyException(string message) : base(message) { }
+    public ReplyException(string message, Exception inner) : base(message, inner) { }
+    protected ReplyException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+}

MinecraftDiscordBot/Services/RootCommandService.cs

@@ -0,0 +1,75 @@
+using Discord.WebSocket;
+using Fleck;
+using MinecraftDiscordBot.Commands;
+using MinecraftDiscordBot.Models;
+using Newtonsoft.Json;
+
+namespace MinecraftDiscordBot.Services;
+
+public delegate Task<TResponse> HandleCommandDelegate<TResponse>(SocketUserMessage message, string[] parameters, CancellationToken ct);
+public delegate Task HandleCommandDelegate(SocketUserMessage message, string[] parameters, CancellationToken ct);
+
+public class RootCommandService : CommandRouter, ITaskWaitSource {
+    protected readonly IWebSocketConnection _socket;
+    public override string HelpTextPrefix => "!";
+    public RootCommandService(IWebSocketConnection socket, IUserRoleManager roleManager) : base() {
+        socket.OnMessage = OnMessage;
+        _socket = socket;
+        _rs = new RefinedStorageService(this, roleManager);
+    }
+
+    private void OnMessage(string message) {
+        if (JsonConvert.DeserializeObject<ReplyMessage>(message) is not ReplyMessage msg) return;
+        IChunkWaiter? waiter;
+        lock (_syncRoot) if (!_waits.TryGetValue(msg.AnswerId, out waiter)) {
+                Program.LogWarningAsync("Socket", $"Invalid wait id '{msg.AnswerId}'!");
+                return;
+            }
+        waiter.SetResultState(msg.State);
+        waiter.AddChunk(msg.Chunk, msg.Total, msg.Result);
+        if (waiter.Finished || waiter.IsCancellationRequested)
+            lock (_syncRoot)
+                _waits.Remove(waiter.ID);
+    }
+
+    public Task Send(string message) => _socket.Send(message);
+    public Task Send(Message message) => Send(JsonConvert.SerializeObject(message));
+    private readonly object _syncRoot = new();
+    private readonly Dictionary<int, IChunkWaiter> _waits = new();
+    private readonly Random _rnd = new();
+    public IWebSocketConnectionInfo ConnectionInfo => _socket.ConnectionInfo;
+
+    private int GetFreeId() {
+        var attempts = 0;
+        while (true) {
+            var id = _rnd.Next();
+            if (!_waits.ContainsKey(id))
+                return id;
+            Program.LogWarningAsync(Program.WebSocketSource, $"Could not get a free ID after {++attempts} attempts!");
+        }
+    }
+
+    public ChunkWaiter<T> GetWaiter<T>(Func<string, T> resultParser, CancellationToken ct) {
+        ChunkWaiter<T> waiter;
+        lock (_syncRoot) {
+            waiter = new ChunkWaiter<T>(GetFreeId(), resultParser, ct);
+            _waits.Add(waiter.ID, waiter);
+        }
+        return waiter;
+    }
+
+    private readonly ICommandHandler<ResponseType> _rs;
+    [CommandHandler("rs", HelpText = "Provides some commands for interacting with the Refined Storage system.")]
+    public Task<ResponseType> RefinedStorageHandler(SocketUserMessage message, string[] parameters, CancellationToken ct)
+        => _rs.HandleCommand(message, parameters, ct);
+
+    public static Func<string, T> Deserialize<T>() => msg
+             => JsonConvert.DeserializeObject<T>(msg) ?? throw new InvalidProgramException("Empty response!");
+    public override Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct)
+        => throw new ReplyException($"What the fuck do you mean by '{method}'?");
+}
+
+public interface ITaskWaitSource {
+    ChunkWaiter<T> GetWaiter<T>(Func<string, T> resultParser, CancellationToken ct);
+    Task Send(Message requestMessage);
+}

MinecraftDiscordBot/TimeoutTokenProvider.cs

@@ -0,0 +1,36 @@
+namespace MinecraftDiscordBot;
+
+public class TimeoutTokenProvider : ITokenProvider {
+    public TimeoutTokenProvider(int instanceId, int timeoutSeconds, ICipher? cipher = null) {
+        InstancePrefix = Convert.ToHexString(BitConverter.GetBytes(instanceId));
+        _timeout = timeoutSeconds;
+        _cipher = cipher ?? new AesCipher();
+    }
+    private readonly ICipher _cipher;
+    private readonly int _timeout;
+    public string InstancePrefix { get; }
+    public bool VerifyToken(string token) {
+        if (!token.StartsWith(InstancePrefix)) return false;
+        token = token[InstancePrefix.Length..];
+        byte[] data;
+        try {
+            data = _cipher.Decrypt(Convert.FromHexString(token));
+        } catch (Exception e) {
+            Program.LogError("TokenProvider", e);
+            return false;
+        }
+        var when = DateTime.FromBinary(BitConverter.ToInt64(data, 0));
+        return when >= DateTime.UtcNow.AddSeconds(-_timeout);
+    }
+    public string GenerateToken() {
+        var time = BitConverter.GetBytes(DateTime.UtcNow.ToBinary());
+        var key = Guid.NewGuid().ToByteArray();
+        var token = InstancePrefix + Convert.ToHexString(_cipher.Encrypt(time.Concat(key).ToArray()));
+        return token;
+    }
+}
+
+public interface ITokenProvider {
+    string GenerateToken();
+    bool VerifyToken(string token);
+}