Rewrite PluralKit in C#

Solved issues: Closes #5, closes #74, closes #77, closes #92, closes #104
Irrelevant issues: Closes #7, closes 320, closes #40

.gitignore

@@ -1,8 +1,8 @@
+bin/
+obj/
 .env
 .vscode/
 .idea/
-venv/
 
-*.pyc
 pluralkit.conf
 pluralkit.*.conf

.vscode/launch.json

@@ -1,16 +1,28 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
         {
-            "name": "PluralKit",
-            "type": "python",
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
             "request": "launch",
-            "program": "${workspaceRoot}/src/bot_main.py",
-            "args": ["${workspaceRoot}/pluralkit.conf"],
-            "console": "integratedTerminal",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/bin/Debug/netcoreapp2.2/PluralKit.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            // For more information about the 'console' field, see https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md#console-terminal-window
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "envFile": "${workspaceFolder}/.env"
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
         }
     ]
 }

Dockerfile

@@ -0,0 +1,9 @@
+FROM mcr.microsoft.com/dotnet/core/sdk:2.2-alpine
+
+WORKDIR /app
+COPY PluralKit.API /app/PluralKit.API
+COPY PluralKit.Bot /app/PluralKit.Bot
+COPY PluralKit.Core /app/PluralKit.Core
+COPY PluralKit.Web /app/PluralKit.Web
+COPY PluralKit.sln /app
+RUN dotnet build

PluralKit.API/Controllers/MemberController.cs

@@ -0,0 +1,67 @@
+using System.Data;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using PluralKit.Core;
+
+namespace PluralKit.API.Controllers
+{
+    [ApiController]
+    [Route("m")]
+    [Route("v1/m")]
+    public class MemberController: ControllerBase
+    {
+        private MemberStore _members;
+        private IDbConnection _conn;
+        private TokenAuthService _auth;
+
+        public MemberController(MemberStore members, IDbConnection conn, TokenAuthService auth)
+        {
+            _members = members;
+            _conn = conn;
+            _auth = auth;
+        }
+
+        [HttpGet("{hid}")]
+        public async Task<ActionResult<PKMember>> GetMember(string hid)
+        {
+            var member = await _members.GetByHid(hid);
+            if (member == null) return NotFound("Member not found.");
+
+            return Ok(member);
+        }
+
+        [HttpPatch("{hid}")]
+        [RequiresSystem]
+        public async Task<ActionResult<PKMember>> PatchMember(string hid, [FromBody] PKMember newMember)
+        {
+            var member = await _members.GetByHid(hid);
+            if (member == null) return NotFound("Member not found.");
+
+            if (member.System != _auth.CurrentSystem.Id) return Unauthorized($"Member '{hid}' is not part of your system.");
+
+            // Explicit bounds checks
+            if (newMember.Name.Length > Limits.MaxMemberNameLength)
+                return BadRequest($"Member name too long ({newMember.Name.Length} > {Limits.MaxMemberNameLength}.");
+            if (newMember.Pronouns.Length > Limits.MaxPronounsLength)
+                return BadRequest($"Member pronouns too long ({newMember.Pronouns.Length} > {Limits.MaxPronounsLength}.");
+            if (newMember.Description.Length > Limits.MaxDescriptionLength)
+                return BadRequest($"Member descriptions too long ({newMember.Description.Length} > {Limits.MaxDescriptionLength}.");
+
+            // Sanity bounds checks
+            if (newMember.AvatarUrl.Length > 1000 || newMember.Prefix.Length > 1000 || newMember.Suffix.Length > 1000)
+                return BadRequest();
+
+            member.Name = newMember.Name;
+            member.Color = newMember.Color;
+            member.AvatarUrl = newMember.AvatarUrl;
+            member.Birthday = newMember.Birthday;
+            member.Pronouns = newMember.Pronouns;
+            member.Description = newMember.Description;
+            member.Prefix = newMember.Prefix;
+            member.Suffix = newMember.Suffix;
+            await _members.Save(member);
+            
+            return Ok();
+        }
+    }
+}

PluralKit.API/Controllers/SystemController.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using Dapper;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using NodaTime;
+using PluralKit.Core;
+
+namespace PluralKit.API.Controllers
+{
+    public struct SwitchesReturn
+    {
+        [JsonProperty("timestamp")] public Instant Timestamp { get; set; }
+        [JsonProperty("members")] public IEnumerable<string> Members { get; set; }
+    }
+
+    public struct FrontersReturn
+    {
+        [JsonProperty("timestamp")] public Instant Timestamp { get; set; }
+        [JsonProperty("members")] public IEnumerable<PKMember> Members { get; set; }
+    }
+
+    public struct PostSwitchParams
+    {
+        public ICollection<string> Members { get; set; }
+    }
+
+    [ApiController]
+    [Route("s")]
+    [Route("v1/s")]
+    public class SystemController : ControllerBase
+    {
+        private SystemStore _systems;
+        private MemberStore _members;
+        private SwitchStore _switches;
+        private DbConnectionFactory _conn;
+        private TokenAuthService _auth;
+
+        public SystemController(SystemStore systems, MemberStore members, SwitchStore switches, DbConnectionFactory conn, TokenAuthService auth)
+        {
+            _systems = systems;
+            _members = members;
+            _switches = switches;
+            _conn = conn;
+            _auth = auth;
+        }
+
+        [HttpGet("{hid}")]
+        public async Task<ActionResult<PKSystem>> GetSystem(string hid)
+        {
+            var system = await _systems.GetByHid(hid);
+            if (system == null) return NotFound("System not found.");
+            return Ok(system);
+        }
+
+        [HttpGet("{hid}/members")]
+        public async Task<ActionResult<IEnumerable<PKMember>>> GetMembers(string hid)
+        {
+            var system = await _systems.GetByHid(hid);
+            if (system == null) return NotFound("System not found.");
+
+            var members = await _members.GetBySystem(system);
+            return Ok(members);
+        }
+
+        [HttpGet("{hid}/switches")]
+        public async Task<ActionResult<IEnumerable<SwitchesReturn>>> GetSwitches(string hid, [FromQuery(Name = "before")] Instant? before)
+        {
+            if (before == null) before = SystemClock.Instance.GetCurrentInstant();
+            
+            var system = await _systems.GetByHid(hid);
+            if (system == null) return NotFound("System not found.");
+
+            using (var conn = await _conn.Obtain())
+            {
+                var res = await conn.QueryAsync<SwitchesReturn>(
+                    @"select *, array(
+                        select members.hid from switch_members, members
+                        where switch_members.switch = switches.id and members.id = switch_members.member
+                    ) as members from switches
+                    where switches.system = @System and switches.timestamp < @Before
+                    order by switches.timestamp desc
+                    limit 100;", new {System = system.Id, Before = before});
+                return Ok(res);
+            }
+        }
+
+        [HttpGet("{hid}/fronters")]
+        public async Task<ActionResult<FrontersReturn>> GetFronters(string hid)
+        {
+            var system = await _systems.GetByHid(hid);
+            if (system == null) return NotFound("System not found.");
+            
+            var sw = await _switches.GetLatestSwitch(system);
+            if (sw == null) return NotFound("System has no registered switches."); 
+                
+            var members = await _switches.GetSwitchMembers(sw);
+            return Ok(new FrontersReturn
+            {
+                Timestamp = sw.Timestamp,
+                Members = members
+            });
+        }
+
+        [HttpPatch]
+        [RequiresSystem]
+        public async Task<ActionResult<PKSystem>> EditSystem([FromBody] PKSystem newSystem)
+        {
+            var system = _auth.CurrentSystem;
+            
+            // Bounds checks
+            if (newSystem.Name.Length > Limits.MaxSystemNameLength)
+                return BadRequest($"System name too long ({newSystem.Name.Length} > {Limits.MaxSystemNameLength}.");
+            if (newSystem.Tag.Length > Limits.MaxSystemTagLength)
+                return BadRequest($"System tag too long ({newSystem.Tag.Length} > {Limits.MaxSystemTagLength}.");
+            if (newSystem.Description.Length > Limits.MaxDescriptionLength)
+                return BadRequest($"System description too long ({newSystem.Description.Length} > {Limits.MaxDescriptionLength}.");
+
+            system.Name = newSystem.Name;
+            system.Description = newSystem.Description;
+            system.Tag = newSystem.Tag;
+            system.AvatarUrl = newSystem.AvatarUrl;
+            system.UiTz = newSystem.UiTz ?? "UTC";
+            
+            await _systems.Save(system);
+            return Ok(system);
+        }
+
+        [HttpPost("switches")]
+        [RequiresSystem]
+        public async Task<IActionResult> PostSwitch([FromBody] PostSwitchParams param)
+        {
+            if (param.Members.Distinct().Count() != param.Members.Count())
+                return BadRequest("Duplicate members in member list.");
+            
+            // We get the current switch, if it exists
+            var latestSwitch = await _switches.GetLatestSwitch(_auth.CurrentSystem);
+            var latestSwitchMembers = await _switches.GetSwitchMembers(latestSwitch);
+
+            // Bail if this switch is identical to the latest one
+            if (latestSwitchMembers.Select(m => m.Hid).SequenceEqual(param.Members))
+                return BadRequest("New members identical to existing fronters.");
+            
+            // Resolve member objects for all given IDs
+            IEnumerable<PKMember> membersList;
+            using (var conn = await _conn.Obtain())
+                membersList = (await conn.QueryAsync<PKMember>("select * from members where hid = any(@Hids)", new {Hids = param.Members})).ToList();
+            
+            foreach (var member in membersList)
+                if (member.System != _auth.CurrentSystem.Id)
+                    return BadRequest($"Cannot switch to member '{member.Hid}' not in system.");
+
+            // membersList is in DB order, and we want it in actual input order
+            // so we go through a dict and map the original input appropriately
+            var membersDict = membersList.ToDictionary(m => m.Hid);
+            
+            var membersInOrder = new List<PKMember>();
+            // We do this without .Select() since we want to have the early return bail if it doesn't find the member
+            foreach (var givenMemberId in param.Members)
+            {
+                if (!membersDict.TryGetValue(givenMemberId, out var member)) return BadRequest($"Member '{givenMemberId}' not found.");
+                membersInOrder.Add(member);
+            }
+
+            // Finally, log the switch (yay!)
+            await _switches.RegisterSwitch(_auth.CurrentSystem, membersInOrder);
+            return NoContent();
+        }
+    }
+}

PluralKit.API/PluralKit.API.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp2.2</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
+        <PackageReference Include="Microsoft.AspNetCore.HttpsPolicy" Version="2.2.0" />
+        <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.2.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\PluralKit.Core\PluralKit.Core.csproj" />
+    </ItemGroup>
+
+</Project>

PluralKit.API/Program.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace PluralKit.API
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            InitUtils.Init();
+            CreateWebHostBuilder(args).Build().Run();
+        }
+
+        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseConfiguration(InitUtils.BuildConfiguration(args).Build())
+                .UseStartup<Startup>();
+    }
+}

PluralKit.API/Properties/launchSettings.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false, 
+    "anonymousAuthentication": true, 
+    "iisExpress": {
+      "applicationUrl": "http://localhost:48228",
+      "sslPort": 44372
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "PluralKit.API": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

PluralKit.API/RequiresSystemAttribute.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace PluralKit.API
+{
+    public class RequiresSystemAttribute: ActionFilterAttribute
+    {
+
+        public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+        {
+            var auth = context.HttpContext.RequestServices.GetRequiredService<TokenAuthService>();
+            if (auth.CurrentSystem == null)
+            {
+                context.Result = new UnauthorizedObjectResult("Invalid or missing token in Authorization header.");
+                return;
+            }
+
+            await base.OnActionExecutionAsync(context, next);
+        }
+    }
+}

PluralKit.API/Startup.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.HttpsPolicy;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NodaTime;
+using NodaTime.Serialization.JsonNet;
+using Npgsql;
+
+namespace PluralKit.API
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddMvc(opts => { })
+                .SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
+                .AddJsonOptions(opts => { opts.SerializerSettings.BuildSerializerSettings(); });
+
+            services
+                .AddTransient<SystemStore>()
+                .AddTransient<MemberStore>()
+                .AddTransient<SwitchStore>()
+                .AddTransient<MessageStore>()
+
+                .AddScoped<TokenAuthService>()
+
+                .AddTransient(_ => Configuration.GetSection("PluralKit").Get<CoreConfig>() ?? new CoreConfig())
+                .AddSingleton(svc => new DbConnectionFactory(svc.GetRequiredService<CoreConfig>().Database));
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            else
+            {
+                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
+                //app.UseHsts();
+            }
+
+            app.UseHttpsRedirection();
+            app.UseMiddleware<TokenAuthService>();
+            app.UseMvc();
+        }
+    }
+}

PluralKit.API/TokenAuthService.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+
+namespace PluralKit.API
+{
+    public class TokenAuthService: IMiddleware
+    {
+        public PKSystem CurrentSystem { get; set; }
+
+        private SystemStore _systems;
+
+        public TokenAuthService(SystemStore systems)
+        {
+            _systems = systems;
+        }
+
+        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
+        {
+            var token = context.Request.Headers["Authorization"].FirstOrDefault();
+            if (token != null)
+            {
+                CurrentSystem = await _systems.GetByToken(token);
+            }
+            
+            await next.Invoke(context);
+            CurrentSystem = null;
+        }
+    }
+}

PluralKit.API/app.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <runtime>
+    <gcServer enabled="true"/>
+  </runtime>
+</configuration>

PluralKit.API/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "System": "Information",
+      "Microsoft": "Information"
+    }
+  }
+}

PluralKit.API/appsettings.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}

PluralKit.Bot/Bot.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using NodaTime;
+using Npgsql;
+
+namespace PluralKit.Bot
+{
+    class Initialize
+    {
+        private IConfiguration _config;
+        
+        static void Main(string[] args) => new Initialize { _config = InitUtils.BuildConfiguration(args).Build()}.MainAsync().GetAwaiter().GetResult();
+
+        private async Task MainAsync()
+        {
+            Console.WriteLine("Starting PluralKit...");
+            
+            InitUtils.Init();
+            
+            using (var services = BuildServiceProvider())
+            {
+                Console.WriteLine("- Connecting to database...");
+                using (var conn = await services.GetRequiredService<DbConnectionFactory>().Obtain())
+                    await Schema.CreateTables(conn);
+
+                Console.WriteLine("- Connecting to Discord...");
+                var client = services.GetRequiredService<IDiscordClient>() as DiscordSocketClient;
+                await client.LoginAsync(TokenType.Bot, services.GetRequiredService<BotConfig>().Token);
+                await client.StartAsync();
+
+                Console.WriteLine("- Initializing bot...");
+                await services.GetRequiredService<Bot>().Init();
+                
+                await Task.Delay(-1);
+            }
+        }
+
+        public ServiceProvider BuildServiceProvider() => new ServiceCollection()
+                .AddTransient(_ => _config.GetSection("PluralKit").Get<CoreConfig>() ?? new CoreConfig())
+                .AddTransient(_ => _config.GetSection("PluralKit").GetSection("Bot").Get<BotConfig>() ?? new BotConfig())
+                
+                .AddTransient(svc => new DbConnectionFactory(svc.GetRequiredService<CoreConfig>().Database))
+                
+                .AddSingleton<IDiscordClient, DiscordSocketClient>()
+                .AddSingleton<Bot>()
+
+                .AddTransient<CommandService>(_ => new CommandService(new CommandServiceConfig
+                {
+                    CaseSensitiveCommands = false,
+                    QuotationMarkAliasMap = new Dictionary<char, char>
+                    {
+                        {'"', '"'},
+                        {'\'', '\''},
+                        {'‘', '’'},
+                        {'“', '”'},
+                        {'„', '‟'},
+                    },
+                    DefaultRunMode = RunMode.Async
+                }))
+                .AddTransient<EmbedService>()
+                .AddTransient<ProxyService>()
+                .AddTransient<LogChannelService>()
+                .AddTransient<DataFileService>()
+                
+                .AddSingleton<WebhookCacheService>()
+                
+                .AddTransient<SystemStore>()
+                .AddTransient<MemberStore>()
+                .AddTransient<MessageStore>()
+                .AddTransient<SwitchStore>()
+                .BuildServiceProvider();
+    }
+    class Bot
+    {
+        private IServiceProvider _services;
+        private DiscordSocketClient _client;
+        private CommandService _commands;
+        private ProxyService _proxy;
+        private Timer _updateTimer;
+
+        public Bot(IServiceProvider services, IDiscordClient client, CommandService commands, ProxyService proxy)
+        {
+            this._services = services;
+            this._client = client as DiscordSocketClient;
+            this._commands = commands;
+            this._proxy = proxy;
+        }
+
+        public async Task Init()
+        {
+            _commands.AddTypeReader<PKSystem>(new PKSystemTypeReader());
+            _commands.AddTypeReader<PKMember>(new PKMemberTypeReader());
+            _commands.CommandExecuted += CommandExecuted;
+            await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
+
+            _client.Ready += Ready;
+
+            // Deliberately wrapping in an async function *without* awaiting, we don't want to "block" since this'd hold up the main loop
+            // These handlers return Task so we gotta be careful not to return the Task itself (which would then be awaited) - kinda weird design but eh
+            _client.MessageReceived += async (msg) => MessageReceived(msg).CatchException(HandleRuntimeError);
+            _client.ReactionAdded += async (message, channel, reaction) => _proxy.HandleReactionAddedAsync(message, channel, reaction).CatchException(HandleRuntimeError);
+            _client.MessageDeleted += async (message, channel) => _proxy.HandleMessageDeletedAsync(message, channel).CatchException(HandleRuntimeError);
+        }
+
+        private async Task UpdatePeriodic()
+        {
+            // Method called every 60 seconds
+            await _client.SetGameAsync($"pk;help | in {_client.Guilds.Count} servers");
+        }
+
+        private async Task Ready()
+        {
+            _updateTimer = new Timer((_) => UpdatePeriodic(), null, 0, 60*1000);
+
+            Console.WriteLine($"Shard #{_client.ShardId} connected to {_client.Guilds.Sum(g => g.Channels.Count)} channels in {_client.Guilds.Count} guilds.");
+            Console.WriteLine($"PluralKit started as {_client.CurrentUser.Username}#{_client.CurrentUser.Discriminator} ({_client.CurrentUser.Id}).");
+        }
+
+        private async Task CommandExecuted(Optional<CommandInfo> cmd, ICommandContext ctx, IResult _result)
+        {
+            // TODO: refactor this entire block, it's fugly.
+            if (!_result.IsSuccess) {
+                if (_result.Error == CommandError.Unsuccessful || _result.Error == CommandError.Exception) {
+                    // If this is a PKError (ie. thrown deliberately), show user facing message
+                    // If not, log as error
+                    var exception = (_result as ExecuteResult?)?.Exception;
+                    if (exception is PKError) {
+                        await ctx.Message.Channel.SendMessageAsync($"{Emojis.Error} {exception.Message}");
+                    } else if (exception is TimeoutException) {
+                        await ctx.Message.Channel.SendMessageAsync($"{Emojis.Error} Operation timed out. Try being faster next time :)");
+                    } else if (_result is PreconditionResult)
+                    {
+                        await ctx.Message.Channel.SendMessageAsync($"{Emojis.Error} {_result.ErrorReason}");
+                    } else {
+                        HandleRuntimeError((_result as ExecuteResult?)?.Exception);
+                    }
+                } else if ((_result.Error == CommandError.BadArgCount || _result.Error == CommandError.MultipleMatches) && cmd.IsSpecified) {
+                    await ctx.Message.Channel.SendMessageAsync($"{Emojis.Error} {_result.ErrorReason}\n**Usage: **pk;{cmd.Value.Remarks}");
+                } else if (_result.Error == CommandError.UnknownCommand || _result.Error == CommandError.UnmetPrecondition || _result.Error == CommandError.ObjectNotFound) {
+                    await ctx.Message.Channel.SendMessageAsync($"{Emojis.Error} {_result.ErrorReason}");
+                }
+            }
+        }
+
+        private async Task MessageReceived(SocketMessage _arg)
+        {
+            var serviceScope = _services.CreateScope();
+            
+            // Ignore system messages (member joined, message pinned, etc)
+            var arg = _arg as SocketUserMessage;
+            if (arg == null) return;
+
+            // Ignore bot messages
+            if (arg.Author.IsBot || arg.Author.IsWebhook) return;
+
+            int argPos = 0;
+            // Check if message starts with the command prefix
+            if (arg.HasStringPrefix("pk;", ref argPos, StringComparison.OrdinalIgnoreCase) || arg.HasStringPrefix("pk!", ref argPos, StringComparison.OrdinalIgnoreCase) || arg.HasMentionPrefix(_client.CurrentUser, ref argPos))
+            {
+                // Essentially move the argPos pointer by however much whitespace is at the start of the post-argPos string
+                var trimStartLengthDiff = arg.Content.Substring(argPos).Length - arg.Content.Substring(argPos).TrimStart().Length;
+                argPos += trimStartLengthDiff;
+                
+                // If it does, fetch the sender's system (because most commands need that) into the context,
+                // and start command execution
+                // Note system may be null if user has no system, hence `OrDefault`
+                PKSystem system;
+                using (var conn = await serviceScope.ServiceProvider.GetService<DbConnectionFactory>().Obtain())
+                    system = await conn.QueryFirstOrDefaultAsync<PKSystem>("select systems.* from systems, accounts where accounts.uid = @Id and systems.id = accounts.system", new { Id = arg.Author.Id });
+                await _commands.ExecuteAsync(new PKCommandContext(_client, arg, system), argPos, serviceScope.ServiceProvider);
+            }
+            else
+            {
+                // If not, try proxying anyway
+                await _proxy.HandleMessageAsync(arg);
+            }
+        }
+
+        private void HandleRuntimeError(Exception e)
+        {
+            Console.Error.WriteLine(e);
+        }
+    }
+}

PluralKit.Bot/BotConfig.cs

@@ -0,0 +1,8 @@
+namespace PluralKit.Bot
+{
+    public class BotConfig
+    {
+        public string Token { get; set; }
+        public ulong? ClientId { get; set; }
+    }
+}

PluralKit.Bot/Commands/APICommands.cs

@@ -0,0 +1,66 @@
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+
+namespace PluralKit.Bot.Commands
+{
+    [Group("token")]
+    public class APICommands: ModuleBase<PKCommandContext>
+    {
+        public SystemStore Systems { get; set; }
+        
+        [Command]
+        [MustHaveSystem]
+        [Remarks("token")]
+        public async Task GetToken()
+        {
+            // Get or make a token
+            var token = Context.SenderSystem.Token ?? await MakeAndSetNewToken();
+            
+            // If we're not already in a DM, reply with a reminder to check
+            if (!(Context.Channel is IDMChannel))
+            {
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Check your DMs!");
+            }
+
+            // DM the user a security disclaimer, and then the token in a separate message (for easy copying on mobile)
+            await Context.User.SendMessageAsync($"{Emojis.Warn} Please note that this grants access to modify (and delete!) all your system data, so keep it safe and secure. If it leaks or you need a new one, you can invalidate this one with `pk;token refresh`.\n\nYour token is below:");
+            await Context.User.SendMessageAsync(token);
+        }
+
+        private async Task<string> MakeAndSetNewToken()
+        {
+            Context.SenderSystem.Token = PluralKit.Utils.GenerateToken();
+            await Systems.Save(Context.SenderSystem);
+            return Context.SenderSystem.Token;
+        }
+
+        [Command("refresh")]
+        [MustHaveSystem]
+        [Alias("expire", "invalidate", "update", "new")]
+        [Remarks("token refresh")]
+        public async Task RefreshToken()
+        {
+            if (Context.SenderSystem.Token == null)
+            {
+                // If we don't have a token, call the other method instead
+                // This does pretty much the same thing, except words the messages more appropriately for that :)
+                await GetToken();
+                return;
+            }
+            
+            // Make a new token from scratch
+            var token = await MakeAndSetNewToken();
+            
+            // If we're not already in a DM, reply with a reminder to check
+            if (!(Context.Channel is IDMChannel))
+            {
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Check your DMs!");
+            }
+            
+            // DM the user an invalidation disclaimer, and then the token in a separate message (for easy copying on mobile)
+            await Context.User.SendMessageAsync($"{Emojis.Warn} Your previous API token has been invalidated. You will need to change it anywhere it's currently used.\n\nYour token is below:");
+            await Context.User.SendMessageAsync(token);
+        }
+    }
+}

PluralKit.Bot/Commands/HelpCommands.cs

@@ -0,0 +1,48 @@
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+
+namespace PluralKit.Bot.Commands
+{
+    public class HelpCommands: ModuleBase<PKCommandContext>
+    {
+        [Group("help")]
+        public class HelpGroup: ModuleBase<PKCommandContext> 
+        {
+            [Command("proxy")]
+            [Priority(1)]
+            [Remarks("help proxy")]
+            public async Task HelpProxy()
+            {
+                await Context.Channel.SendMessageAsync(
+                    "The proxy help page has been moved! See the website: https://pluralkit.me/guide#proxying");
+            }
+            
+            [Command]
+            [Remarks("help")]
+            public async Task HelpRoot([Remainder] string _ignored = null)
+            {
+                await Context.Channel.SendMessageAsync(embed: new EmbedBuilder()
+                    .WithTitle("PluralKit")
+                    .WithDescription("PluralKit is a bot designed for plural communities on Discord. It allows you to register systems, maintain system information, set up message proxying, log switches, and more.")
+                    .AddField("What is this for? What are systems?", "This bot detects messages with certain tags associated with a profile, then replaces that message under a \"pseudo-account\" of that profile using webhooks. This is useful for multiple people sharing one body (aka \"systems\"), people who wish to roleplay as different characters without having several accounts, or anyone else who may want to post messages as a different person from the same account.")
+                    .AddField("Why are people's names saying [BOT] next to them?", "These people are not actually bots, this is just a Discord limitation. See [the documentation](https://pluralkit.me/guide#proxying) for an in-depth explanation.")
+                    .AddField("How do I get started?", "To get started using PluralKit, try running the following commands (of course replacing the relevant names with your own):\n**1**. `pk;system new` - Create a system (if you haven't already)\n**2**. `pk;member add John` - Add a new member to your system\n**3**. `pk;member John proxy [text]` - Set up [square brackets] as proxy tags\n**4**. You're done! You can now type [a message in brackets] and it'll be proxied appropriately.\n**5**. Optionally, you may set an avatar from the URL of an image with `pk;member John avatar [link to image]`, or from a file by typing `pk;member John avatar` and sending the message with an attached image.\n\nSee [the documentation](https://pluralkit.me/guide#member-management) for more information.")
+                    .AddField("Useful tips", $"React with {Emojis.Error} on a proxied message to delete it (only if you sent it!)\nReact with {Emojis.RedQuestion} on a proxied message to look up information about it (like who sent it)\nType **`pk;invite`** to get a link to invite this bot to your own server!")
+                    .AddField("More information", "For a full list of commands, see [the command list](https://pluralkit.me/commands).\nFor a more in-depth explanation of message proxying, see [the documentation](https://pluralkit.me/guide#proxying).\nIf you're an existing user of Tupperbox, type `pk;import` and attach a Tupperbox export file (from `tul!export`) to import your data from there.")
+                    .AddField("Support server", "We also have a Discord server for support, discussion, suggestions, announcements, etc: https://discord.gg/PczBt78")
+                    .WithFooter("By @Ske#6201 | GitHub: https://github.com/xSke/PluralKit/ | Website: https://pluralkit.me/")
+                    .WithColor(Color.Blue)
+                    .Build());
+            }
+        }
+
+        [Command("commands")]
+        [Remarks("commands")]
+        public async Task CommandList()
+        {
+            await Context.Channel.SendMessageAsync(
+                "The command list has been moved! See the website: https://pluralkit.me/commands");
+        }
+    }
+}

PluralKit.Bot/Commands/ImportExportCommands.cs

@@ -0,0 +1,136 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Discord.Net;
+using Newtonsoft.Json;
+
+namespace PluralKit.Bot.Commands
+{
+    public class ImportExportCommands : ModuleBase<PKCommandContext>
+    {
+        public DataFileService DataFiles { get; set; }
+
+        [Command("import")]
+        [Remarks("import [fileurl]")]
+        public async Task Import([Remainder] string url = null)
+        {
+            if (url == null) url = Context.Message.Attachments.FirstOrDefault()?.Url;
+            if (url == null) throw Errors.NoImportFilePassed;
+
+            await Context.BusyIndicator(async () =>
+            {
+                using (var client = new HttpClient())
+                {
+                    var response = await client.GetAsync(url);
+                    if (!response.IsSuccessStatusCode) throw Errors.InvalidImportFile;
+                    var json = await response.Content.ReadAsStringAsync();
+
+                    var settings = new JsonSerializerSettings
+                    {
+                        MissingMemberHandling = MissingMemberHandling.Error
+                    };
+                    
+
+                    DataFileSystem data;
+                    
+                    // TODO: can we clean up this mess?
+                    try
+                    {
+                        data = JsonConvert.DeserializeObject<DataFileSystem>(json, settings);
+                    }
+                    catch (JsonException)
+                    {
+                        try
+                        {
+                            var tupperbox = JsonConvert.DeserializeObject<TupperboxProfile>(json, settings);
+                            if (!tupperbox.Valid) throw Errors.InvalidImportFile;
+                            
+                            var res = tupperbox.ToPluralKit();
+                            if (res.HadGroups || res.HadMultibrackets || res.HadIndividualTags)
+                            {
+                                var issueStr =
+                                    $"{Emojis.Warn} The following potential issues were detected converting your Tupperbox input file:";
+                                if (res.HadGroups)
+                                    issueStr +=
+                                        "\n- PluralKit does not support member groups. Members will be imported without groups.";
+                                if (res.HadMultibrackets)
+                                    issueStr += "\n- PluralKit does not support members with multiple proxy tags. Only the first pair will be imported.";
+                                if (res.HadIndividualTags)
+                                    issueStr +=
+                                        "\n- PluralKit does not support per-member system tags. Since you had multiple members with distinct tags, tags will not be imported. You can set your system tag using the `pk;system tag <tag>` command later.";
+
+                                var msg = await Context.Channel.SendMessageAsync($"{issueStr}\n\nDo you want to proceed with the import?");
+                                if (!await Context.PromptYesNo(msg)) throw Errors.ImportCancelled;
+                            }
+                            
+                            data = res.System;
+                        }
+                        catch (JsonException)
+                        {
+                            throw Errors.InvalidImportFile;
+                        }
+                    }
+                    
+                    
+                    if (!data.Valid) throw Errors.InvalidImportFile;
+
+                    if (data.LinkedAccounts != null && !data.LinkedAccounts.Contains(Context.User.Id))
+                    {
+                        var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} You seem to importing a system profile belonging to another account. Are you sure you want to proceed?");
+                        if (!await Context.PromptYesNo(msg)) throw Errors.ImportCancelled;
+                    }
+
+                    // If passed system is null, it'll create a new one
+                    // (and that's okay!)
+                    var result = await DataFiles.ImportSystem(data, Context.SenderSystem, Context.User.Id);
+                    
+                    if (Context.SenderSystem == null)
+                    {
+                        await Context.Channel.SendMessageAsync($"{Emojis.Success} PluralKit has created a system for you based on the given file. Your system ID is `{result.System.Hid}`. Type `pk;system` for more information.");
+                    }
+                    else
+                    {
+                        await Context.Channel.SendMessageAsync($"{Emojis.Success} Updated {result.ModifiedNames.Count} members, created {result.AddedNames.Count} members. Type `pk;system list` to check!");
+                    }
+                }
+            });
+        }
+
+        [Command("export")]
+        [Remarks("export")]
+        [MustHaveSystem]
+        public async Task Export()
+        {
+            var json = await Context.BusyIndicator(async () =>
+            {
+                // Make the actual data file
+                var data = await DataFiles.ExportSystem(Context.SenderSystem);
+                return JsonConvert.SerializeObject(data, Formatting.None);
+            });
+            
+                            
+            // Send it as a Discord attachment *in DMs*
+            var stream = new MemoryStream(Encoding.UTF8.GetBytes(json));
+
+            try
+            {
+                await Context.User.SendFileAsync(stream, "system.json", $"{Emojis.Success} Here you go!");
+                
+                // If the original message wasn't posted in DMs, send a public reminder
+                if (!(Context.Channel is IDMChannel))
+                    await Context.Channel.SendMessageAsync($"{Emojis.Success} Check your DMs!");
+            }
+            catch (HttpException)
+            {
+                // If user has DMs closed, tell 'em to open them
+                await Context.Channel.SendMessageAsync(
+                    $"{Emojis.Error} Could not send the data file in your DMs. Do you have DMs closed?");
+            }
+        }
+    }
+}

PluralKit.Bot/Commands/LinkCommands.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+
+namespace PluralKit.Bot.Commands
+{
+    public class LinkCommands: ModuleBase<PKCommandContext>
+    {
+        public SystemStore Systems { get; set; }
+
+
+        [Command("link")]
+        [Remarks("link <account>")]
+        [MustHaveSystem]
+        public async Task LinkSystem(IUser account)
+        {
+            var accountIds = await Systems.GetLinkedAccountIds(Context.SenderSystem);
+            if (accountIds.Contains(account.Id)) throw Errors.AccountAlreadyLinked;
+
+            var existingAccount = await Systems.GetByAccount(account.Id);
+            if (existingAccount != null) throw Errors.AccountInOtherSystem(existingAccount); 
+
+            var msg = await Context.Channel.SendMessageAsync(
+                $"{account.Mention}, please confirm the link by clicking the {Emojis.Success} reaction on this message.");
+            if (!await Context.PromptYesNo(msg, user: account)) throw Errors.MemberLinkCancelled;
+            await Systems.Link(Context.SenderSystem, account.Id);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Account linked to system.");
+        }
+
+        [Command("unlink")]
+        [Remarks("unlink [account]")]
+        [MustHaveSystem]
+        public async Task UnlinkAccount(IUser account = null)
+        {
+            if (account == null) account = Context.User;
+            
+            var accountIds = (await Systems.GetLinkedAccountIds(Context.SenderSystem)).ToList();
+            if (!accountIds.Contains(account.Id)) throw Errors.AccountNotLinked;
+            if (accountIds.Count == 1) throw Errors.UnlinkingLastAccount;
+            
+            var msg = await Context.Channel.SendMessageAsync(
+                $"Are you sure you want to unlink {account.Mention} from your system?");
+            if (!await Context.PromptYesNo(msg)) throw Errors.MemberUnlinkCancelled;
+
+            await Systems.Unlink(Context.SenderSystem, account.Id);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Account unlinked.");
+        }
+    }
+}

PluralKit.Bot/Commands/MemberCommands.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using NodaTime;
+using PluralKit.Core;
+using Image = SixLabors.ImageSharp.Image;
+
+namespace PluralKit.Bot.Commands
+{
+    [Group("member")]
+    [Alias("m")]
+    public class MemberCommands : ContextParameterModuleBase<PKMember>
+    {
+        public SystemStore Systems { get; set; }
+        public MemberStore Members { get; set; }
+        public EmbedService Embeds { get; set;  }
+
+        public override string Prefix => "member";
+        public override string ContextNoun => "member";
+
+        [Command("new")]
+        [Alias("n", "add", "create", "register")]
+        [Remarks("member new <name>")]
+        [MustHaveSystem]
+        public async Task NewMember([Remainder] string memberName) {
+            // Hard name length cap
+            if (memberName.Length > Limits.MaxMemberNameLength) throw Errors.MemberNameTooLongError(memberName.Length);
+
+            // Warn if member name will be unproxyable (with/without tag)
+            if (memberName.Length > Context.SenderSystem.MaxMemberNameLength) {
+                var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} Member name too long ({memberName.Length} > {Context.SenderSystem.MaxMemberNameLength} characters), this member will be unproxyable. Do you want to create it anyway? (You can change the name later)");
+                if (!await Context.PromptYesNo(msg)) throw new PKError("Member creation cancelled.");
+            }
+
+            // Warn if there's already a member by this name
+            var existingMember = await Members.GetByName(Context.SenderSystem, memberName);
+            if (existingMember != null) {
+                var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} You already have a member in your system with the name \"{existingMember.Name.Sanitize()}\" (with ID `{existingMember.Hid}`). Do you want to create another member with the same name?");
+                if (!await Context.PromptYesNo(msg)) throw new PKError("Member creation cancelled.");
+            }
+
+            // Create the member
+            var member = await Members.Create(Context.SenderSystem, memberName);
+            
+            // Send confirmation and space hint
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member \"{memberName.Sanitize()}\" (`{member.Hid}`) registered! Type `pk;help member` for a list of commands to edit this member.");
+            if (memberName.Contains(" ")) await Context.Channel.SendMessageAsync($"{Emojis.Note} Note that this member's name contains spaces. You will need to surround it with \"double quotes\" when using commands referring to it, or just use the member's 5-character ID (which is `{member.Hid}`).");
+        }
+
+        [Command("rename")]
+        [Alias("name", "changename", "setname")]
+        [Remarks("member <member> rename <newname>")]
+        [MustPassOwnMember]
+        public async Task RenameMember([Remainder] string newName) {
+            // TODO: this method is pretty much a 1:1 copy/paste of the above creation method, find a way to clean?
+
+            // Hard name length cap
+            if (newName.Length > Limits.MaxMemberNameLength) throw Errors.MemberNameTooLongError(newName.Length);
+
+            // Warn if member name will be unproxyable (with/without tag)
+            if (newName.Length > Context.SenderSystem.MaxMemberNameLength) {
+                var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} New member name too long ({newName.Length} > {Context.SenderSystem.MaxMemberNameLength} characters), this member will be unproxyable. Do you want to change it anyway?");
+                if (!await Context.PromptYesNo(msg)) throw new PKError("Member renaming cancelled.");
+            }
+
+            // Warn if there's already a member by this name
+            var existingMember = await Members.GetByName(Context.SenderSystem, newName);
+            if (existingMember != null) {
+                var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} You already have a member in your system with the name \"{existingMember.Name.Sanitize()}\" (`{existingMember.Hid}`). Do you want to rename this member to that name too?");
+                if (!await Context.PromptYesNo(msg)) throw new PKError("Member renaming cancelled.");
+            }
+
+            // Rename the member
+            ContextEntity.Name = newName;
+            await Members.Save(ContextEntity);
+
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member renamed.");
+            if (newName.Contains(" ")) await Context.Channel.SendMessageAsync($"{Emojis.Note} Note that this member's name now contains spaces. You will need to surround it with \"double quotes\" when using commands referring to it.");
+        }
+
+        [Command("description")]
+        [Alias("info", "bio", "text", "desc")]
+        [Remarks("member <member> description <description>")]
+        [MustPassOwnMember]
+        public async Task MemberDescription([Remainder] string description = null) {
+            if (description.IsLongerThan(Limits.MaxDescriptionLength)) throw Errors.DescriptionTooLongError(description.Length);
+
+            ContextEntity.Description = description;
+            await Members.Save(ContextEntity);
+
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member description {(description == null ? "cleared" : "changed")}.");
+        }
+
+        [Command("pronouns")]
+        [Alias("pronoun")]
+        [Remarks("member <member> pronouns <pronouns>")]
+        [MustPassOwnMember]
+        public async Task MemberPronouns([Remainder] string pronouns = null) {
+            if (pronouns.IsLongerThan(Limits.MaxPronounsLength)) throw Errors.MemberPronounsTooLongError(pronouns.Length);
+
+            ContextEntity.Pronouns = pronouns;
+            await Members.Save(ContextEntity);
+
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member pronouns {(pronouns == null ? "cleared" : "changed")}.");
+        }
+
+        [Command("color")]
+        [Alias("colour")]
+        [Remarks("member <member> color <color>")]
+        [MustPassOwnMember]
+        public async Task MemberColor([Remainder] string color = null)
+        {
+            if (color != null)
+            {
+                if (color.StartsWith("#")) color = color.Substring(1);
+                if (!Regex.IsMatch(color, "^[0-9a-f]{6}$")) throw Errors.InvalidColorError(color);
+            }
+
+            ContextEntity.Color = color;
+            await Members.Save(ContextEntity);
+
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member color {(color == null ? "cleared" : "changed")}.");
+        }
+
+        [Command("birthday")]
+        [Alias("birthdate", "bday", "cakeday", "bdate")]
+        [Remarks("member <member> birthday <birthday>")]
+        [MustPassOwnMember]
+        public async Task MemberBirthday([Remainder] string birthday = null)
+        {
+            LocalDate? date = null;
+            if (birthday != null)
+            {
+                date = PluralKit.Utils.ParseDate(birthday, true);
+                if (date == null) throw Errors.BirthdayParseError(birthday);
+            }
+
+            ContextEntity.Birthday = date;
+            await Members.Save(ContextEntity);
+            
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member birthdate {(date == null ? "cleared" : $"changed to {ContextEntity.BirthdayString}")}.");
+        }
+
+        [Command("proxy")]
+        [Alias("proxy", "tags", "proxytags", "brackets")]
+        [Remarks("member <member> proxy <proxy tags>")]
+        [MustPassOwnMember]
+        public async Task MemberProxy([Remainder] string exampleProxy = null)
+        {
+            // Handling the clear case in an if here to keep the body dedented
+            if (exampleProxy == null)
+            {
+                // Just reset and send OK message
+                ContextEntity.Prefix = null;
+                ContextEntity.Suffix = null;
+                await Members.Save(ContextEntity);
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Member proxy tags cleared.");
+                return;
+            }
+            
+            // Make sure there's one and only one instance of "text" in the example proxy given
+            var prefixAndSuffix = exampleProxy.Split("text");
+            if (prefixAndSuffix.Length < 2) throw Errors.ProxyMustHaveText;
+            if (prefixAndSuffix.Length > 2) throw Errors.ProxyMultipleText;
+
+            // If the prefix/suffix is empty, use "null" instead (for DB)
+            ContextEntity.Prefix = prefixAndSuffix[0].Length > 0 ? prefixAndSuffix[0] : null;
+            ContextEntity.Suffix = prefixAndSuffix[1].Length > 0 ? prefixAndSuffix[1] : null;
+            await Members.Save(ContextEntity);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member proxy tags changed to `{ContextEntity.ProxyString.Sanitize()}`. Try proxying now!");
+        }
+
+        [Command("delete")]
+        [Alias("remove", "destroy", "erase", "yeet")]
+        [Remarks("member <member> delete")]
+        [MustPassOwnMember]
+        public async Task MemberDelete()
+        {
+            await Context.Channel.SendMessageAsync($"{Emojis.Warn} Are you sure you want to delete \"{ContextEntity.Name.Sanitize()}\"? If so, reply to this message with the member's ID (`{ContextEntity.Hid}`). __***This cannot be undone!***__");
+            if (!await Context.ConfirmWithReply(ContextEntity.Hid)) throw Errors.MemberDeleteCancelled;
+            await Members.Delete(ContextEntity);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member deleted.");
+        }
+
+        [Command("avatar")]
+        [Alias("profile", "picture", "icon", "image", "pic", "pfp")]
+        [Remarks("member <member> avatar <avatar url>")]
+        [MustPassOwnMember]
+        public async Task MemberAvatar([Remainder] string avatarUrl = null)
+        {
+            string url = avatarUrl ?? Context.Message.Attachments.FirstOrDefault()?.ProxyUrl;
+            if (url != null) await Context.BusyIndicator(() => Utils.VerifyAvatarOrThrow(url));
+
+            ContextEntity.AvatarUrl = url;
+            await Members.Save(ContextEntity);
+
+            var embed = url != null ? new EmbedBuilder().WithImageUrl(url).Build() : null;
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Member avatar {(url == null ? "cleared" : "changed")}.", embed: embed);
+        }
+
+        [Command]
+        [Alias("view", "show", "info")]
+        [Remarks("member <member>")]
+        public async Task ViewMember(PKMember member)
+        {
+            var system = await Systems.GetById(member.System);
+            await Context.Channel.SendMessageAsync(embed: await Embeds.CreateMemberEmbed(system, member));
+        }
+        
+        public override async Task<PKMember> ReadContextParameterAsync(string value)
+        {
+            var res = await new PKMemberTypeReader().ReadAsync(Context, value, _services);
+            return res.IsSuccess ? res.BestMatch as PKMember : null;        
+        }
+    }
+}

PluralKit.Bot/Commands/MiscCommands.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+
+namespace PluralKit.Bot.Commands {
+    public class MiscCommands: ModuleBase<PKCommandContext> {
+        public BotConfig BotConfig { get; set; }
+        
+        [Command("invite")]
+        [Alias("inv")]
+        [Remarks("invite")]
+        public async Task Invite()
+        {
+            var clientId = BotConfig.ClientId ?? (await Context.Client.GetApplicationInfoAsync()).Id;
+            var permissions = new GuildPermissions(
+                addReactions: true,
+                attachFiles: true,
+                embedLinks: true,
+                manageMessages: true,
+                manageWebhooks: true,
+                readMessageHistory: true,
+                sendMessages: true
+            );
+
+            var invite = $"https://discordapp.com/oauth2/authorize?client_id={clientId}&scope=bot&permissions={permissions.RawValue}";
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Use this link to add PluralKit to your server:\n<{invite}>");
+        }
+
+        [Command("mn")] public Task Mn() => Context.Channel.SendMessageAsync("Gotta catch 'em all!");
+        [Command("fire")] public Task Fire() => Context.Channel.SendMessageAsync("*A giant lightning bolt promptly erupts into a pillar of fire as it hits your opponent.*");
+        [Command("thunder")] public Task Thunder() => Context.Channel.SendMessageAsync("*A giant ball of lightning is conjured and fired directly at your opponent, vanquishing them.*");
+        [Command("freeze")] public Task Freeze() => Context.Channel.SendMessageAsync("*A giant crystal ball of ice is charged and hurled toward your opponent, bursting open and freezing them solid on contact.*");
+        [Command("starstorm")] public Task Starstorm() => Context.Channel.SendMessageAsync("*Vibrant colours burst forth from the sky as meteors rain down upon your opponent.*");
+
+    }
+}

PluralKit.Bot/Commands/ModCommands.cs

@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+
+namespace PluralKit.Bot.Commands
+{
+    public class ModCommands: ModuleBase<PKCommandContext>
+    {
+        public LogChannelService LogChannels { get; set; }
+        public MessageStore Messages { get; set; }
+        
+        public EmbedService Embeds { get; set; }
+        
+        [Command("log")]
+        [Remarks("log <channel>")]
+        [RequireUserPermission(GuildPermission.ManageGuild, ErrorMessage = "You must have the Manage Server permission to use this command.")]
+        [RequireContext(ContextType.Guild, ErrorMessage = "This command can not be run in a DM.")]
+        public async Task SetLogChannel(ITextChannel channel = null)
+        {
+            await LogChannels.SetLogChannel(Context.Guild, channel);
+
+            if (channel != null)
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Proxy logging channel set to #{channel.Name.Sanitize()}.");
+            else
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Proxy logging channel cleared.");
+        }
+
+        [Command("message")]
+        [Remarks("message <messageid>")]
+        [Alias("msg")]
+        public async Task GetMessage(ulong messageId)
+        {
+            var message = await Messages.Get(messageId);
+            if (message == null) throw Errors.MessageNotFound(messageId);
+
+            await Context.Channel.SendMessageAsync(embed: await Embeds.CreateMessageInfoEmbed(message));
+        }
+
+        [Command("message")]
+        [Remarks("message <messageid>")]
+        [Alias("msg")]
+        public async Task GetMessage(IMessage msg) => await GetMessage(msg.Id);
+    }
+}

PluralKit.Bot/Commands/SwitchCommands.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using NodaTime;
+using NodaTime.TimeZones;
+
+namespace PluralKit.Bot.Commands
+{
+    [Group("switch")]
+    [Alias("sw")]
+    public class SwitchCommands: ModuleBase<PKCommandContext>
+    {
+        public SystemStore Systems { get; set; }
+        public SwitchStore Switches { get; set; }
+
+        [Command]
+        [Remarks("switch <member> [member...]")]
+        [MustHaveSystem]
+        public async Task Switch(params PKMember[] members) => await DoSwitchCommand(members);
+
+        [Command("out")]
+        [Alias("none")]
+        [Remarks("switch out")]
+        [MustHaveSystem]
+        public async Task SwitchOut() => await DoSwitchCommand(new PKMember[] { });
+
+        private async Task DoSwitchCommand(ICollection<PKMember> members)
+        {
+            // Make sure all the members *are actually in the system*
+            // PKMember parameters won't let this happen if they resolve by name
+            // but they can if they resolve with ID
+            if (members.Any(m => m.System != Context.SenderSystem.Id)) throw Errors.SwitchMemberNotInSystem;
+            
+            // Make sure there are no dupes in the list
+            // We do this by checking if removing duplicate member IDs results in a list of different length 
+            if (members.Select(m => m.Id).Distinct().Count() != members.Count) throw Errors.DuplicateSwitchMembers;
+
+            // Find the last switch and its members if applicable
+            var lastSwitch = await Switches.GetLatestSwitch(Context.SenderSystem);
+            if (lastSwitch != null)
+            {
+                var lastSwitchMembers = await Switches.GetSwitchMembers(lastSwitch);
+                // Make sure the requested switch isn't identical to the last one
+                if (lastSwitchMembers.Select(m => m.Id).SequenceEqual(members.Select(m => m.Id)))
+                    throw Errors.SameSwitch(members);
+            }
+
+            await Switches.RegisterSwitch(Context.SenderSystem, members);
+
+            if (members.Count == 0)
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Switch-out registered.");
+            else
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} Switch registered. Current fronter is now {string.Join(", ", members.Select(m => m.Name)).Sanitize()}.");
+        }
+
+        [Command("move")]
+        [Alias("shift")]
+        [Remarks("switch move <date/time>")]
+        [MustHaveSystem]
+        public async Task SwitchMove([Remainder] string str)
+        {
+            var tz = TzdbDateTimeZoneSource.Default.ForId(Context.SenderSystem.UiTz ?? "UTC");
+            
+            var result = PluralKit.Utils.ParseDateTime(str, true, tz);
+            if (result == null) throw Errors.InvalidDateTime(str);
+            
+            var time = result.Value;
+            if (time.ToInstant() > SystemClock.Instance.GetCurrentInstant()) throw Errors.SwitchTimeInFuture;
+
+            // Fetch the last two switches for the system to do bounds checking on
+            var lastTwoSwitches = (await Switches.GetSwitches(Context.SenderSystem, 2)).ToArray();
+            
+            // If we don't have a switch to move, don't bother
+            if (lastTwoSwitches.Length == 0) throw Errors.NoRegisteredSwitches;
+            
+            // If there's a switch *behind* the one we move, we check to make srue we're not moving the time further back than that
+            if (lastTwoSwitches.Length == 2)
+            {
+                if (lastTwoSwitches[1].Timestamp > time.ToInstant())
+                    throw Errors.SwitchMoveBeforeSecondLast(lastTwoSwitches[1].Timestamp.InZone(tz));
+            }
+            
+            // Now we can actually do the move, yay!
+            // But, we do a prompt to confirm.
+            var lastSwitchMembers = await Switches.GetSwitchMembers(lastTwoSwitches[0]);
+            var lastSwitchMemberStr = string.Join(", ", lastSwitchMembers.Select(m => m.Name));
+            var lastSwitchTimeStr = Formats.ZonedDateTimeFormat.Format(lastTwoSwitches[0].Timestamp.InZone(Context.SenderSystem.Zone));
+            var lastSwitchDeltaStr = Formats.DurationFormat.Format(SystemClock.Instance.GetCurrentInstant() - lastTwoSwitches[0].Timestamp);
+            var newSwitchTimeStr = Formats.ZonedDateTimeFormat.Format(time);
+            var newSwitchDeltaStr = Formats.DurationFormat.Format(SystemClock.Instance.GetCurrentInstant() - time.ToInstant());
+            
+            // yeet
+            var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} This will move the latest switch ({lastSwitchMemberStr.Sanitize()}) from {lastSwitchTimeStr} ({lastSwitchDeltaStr} ago) to {newSwitchTimeStr} ({newSwitchDeltaStr} ago). Is this OK?");
+            if (!await Context.PromptYesNo(msg)) throw Errors.SwitchMoveCancelled;
+            
+            // aaaand *now* we do the move
+            await Switches.MoveSwitch(lastTwoSwitches[0], time.ToInstant());
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Switch moved.");
+        }
+
+        [Command("delete")]
+        [Remarks("switch delete")]
+        [Alias("remove", "erase", "cancel", "yeet")]
+        [MustHaveSystem]
+        public async Task SwitchDelete()
+        {
+            // Fetch the last two switches for the system to do bounds checking on
+            var lastTwoSwitches = (await Switches.GetSwitches(Context.SenderSystem, 2)).ToArray();
+            if (lastTwoSwitches.Length == 0) throw Errors.NoRegisteredSwitches;
+
+            var lastSwitchMembers = await Switches.GetSwitchMembers(lastTwoSwitches[0]);
+            var lastSwitchMemberStr = string.Join(", ", lastSwitchMembers.Select(m => m.Name));
+            var lastSwitchDeltaStr = Formats.DurationFormat.Format(SystemClock.Instance.GetCurrentInstant() - lastTwoSwitches[0].Timestamp);
+
+            IUserMessage msg;
+            if (lastTwoSwitches.Length == 1)
+            {
+                msg = await Context.Channel.SendMessageAsync(
+                    $"{Emojis.Warn} This will delete the latest switch ({lastSwitchMemberStr.Sanitize()}, {lastSwitchDeltaStr} ago). You have no other switches logged. Is this okay?");
+            }
+            else
+            {
+                var secondSwitchMembers = await Switches.GetSwitchMembers(lastTwoSwitches[1]);
+                var secondSwitchMemberStr = string.Join(", ", secondSwitchMembers.Select(m => m.Name));
+                var secondSwitchDeltaStr = Formats.DurationFormat.Format(SystemClock.Instance.GetCurrentInstant() - lastTwoSwitches[1].Timestamp);
+                msg = await Context.Channel.SendMessageAsync(
+                    $"{Emojis.Warn} This will delete the latest switch ({lastSwitchMemberStr.Sanitize()}, {lastSwitchDeltaStr} ago). The next latest switch is {secondSwitchMemberStr.Sanitize()} ({secondSwitchDeltaStr} ago). Is this okay?");
+            }
+
+            if (!await Context.PromptYesNo(msg)) throw Errors.SwitchDeleteCancelled;
+            await Switches.DeleteSwitch(lastTwoSwitches[0]);
+            
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Switch deleted.");
+        }
+    }
+}

PluralKit.Bot/Commands/SystemCommands.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Dapper;
+using Discord.Commands;
+using NodaTime;
+using NodaTime.Extensions;
+using NodaTime.Text;
+using NodaTime.TimeZones;
+using PluralKit.Core;
+
+namespace PluralKit.Bot.Commands
+{
+    [Group("system")]
+    [Alias("s")]
+    public class SystemCommands : ContextParameterModuleBase<PKSystem>
+    {
+        public override string Prefix => "system";
+        public override string ContextNoun => "system";
+
+        public SystemStore Systems {get; set;}
+        public MemberStore Members {get; set;}
+        
+        public SwitchStore Switches {get; set;}
+        public EmbedService EmbedService {get; set;}
+        
+
+        [Command]
+        [Remarks("system <name>")]
+        public async Task Query(PKSystem system = null) {
+            if (system == null) system = Context.SenderSystem;
+            if (system == null) throw Errors.NoSystemError;
+
+            await Context.Channel.SendMessageAsync(embed: await EmbedService.CreateSystemEmbed(system));
+        }
+
+        [Command("new")]
+        [Alias("register", "create", "init", "add", "make")]
+        [Remarks("system new <name>")]
+        public async Task New([Remainder] string systemName = null)
+        {
+            if (ContextEntity != null) throw Errors.NotOwnSystemError;
+            if (Context.SenderSystem != null) throw Errors.ExistingSystemError;
+
+            var system = await Systems.Create(systemName);
+            await Systems.Link(system, Context.User.Id);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} Your system has been created. Type `pk;system` to view it, and type `pk;help` for more information about commands you can use now.");
+        }
+
+        [Command("name")]
+        [Alias("rename", "changename")]
+        [Remarks("system name <name>")]
+        [MustHaveSystem]
+        public async Task Name([Remainder] string newSystemName = null) {
+            if (newSystemName != null && newSystemName.Length > Limits.MaxSystemNameLength) throw Errors.SystemNameTooLongError(newSystemName.Length);
+
+            Context.SenderSystem.Name = newSystemName;
+            await Systems.Save(Context.SenderSystem);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} System name {(newSystemName != null ? "changed" : "cleared")}.");
+        }
+
+        [Command("description")]
+        [Alias("desc")]
+        [Remarks("system description <description>")]
+        [MustHaveSystem]
+        public async Task Description([Remainder] string newDescription = null) {
+            if (newDescription != null && newDescription.Length > Limits.MaxDescriptionLength) throw Errors.DescriptionTooLongError(newDescription.Length);
+
+            Context.SenderSystem.Description = newDescription;
+            await Systems.Save(Context.SenderSystem);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} System description {(newDescription != null ? "changed" : "cleared")}.");
+        }
+
+        [Command("tag")]
+        [Remarks("system tag <tag>")]
+        [MustHaveSystem]
+        public async Task Tag([Remainder] string newTag = null) {
+
+            Context.SenderSystem.Tag = newTag;
+
+            if (newTag != null)
+            {
+                if (newTag.Length > Limits.MaxSystemTagLength) throw Errors.SystemNameTooLongError(newTag.Length);
+
+                // Check unproxyable messages *after* changing the tag (so it's seen in the method) but *before* we save to DB (so we can cancel)
+                var unproxyableMembers = await Members.GetUnproxyableMembers(Context.SenderSystem);
+                if (unproxyableMembers.Count > 0)
+                {
+                    var msg = await Context.Channel.SendMessageAsync(
+                        $"{Emojis.Warn} Changing your system tag to '{newTag}' will result in the following members being unproxyable, since the tag would bring their name over 32 characters:\n**{string.Join(", ", unproxyableMembers.Select((m) => m.Name))}**\nDo you want to continue anyway?");
+                    if (!await Context.PromptYesNo(msg)) throw new PKError("Tag change cancelled.");
+                }
+            }
+
+            await Systems.Save(Context.SenderSystem);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} System tag {(newTag != null ? "changed" : "cleared")}.");
+        }
+
+        [Command("delete")]
+        [Alias("remove", "destroy", "erase", "yeet")]
+        [Remarks("system delete")]
+        [MustHaveSystem]
+        public async Task Delete() {
+            var msg = await Context.Channel.SendMessageAsync($"{Emojis.Warn} Are you sure you want to delete your system? If so, reply to this message with your system's ID (`{Context.SenderSystem.Hid}`).\n**Note: this action is permanent.**");
+            var reply = await Context.AwaitMessage(Context.Channel, Context.User, timeout: TimeSpan.FromMinutes(1));
+            if (reply.Content != Context.SenderSystem.Hid) throw new PKError($"System deletion cancelled. Note that you must reply with your system ID (`{Context.SenderSystem.Hid}`) *verbatim*.");
+
+            await Systems.Delete(Context.SenderSystem);
+            await Context.Channel.SendMessageAsync($"{Emojis.Success} System deleted.");
+        }
+
+        [Group("list")]
+        [Alias("l", "members")]
+        public class SystemListCommands: ModuleBase<PKCommandContext> {
+            public MemberStore Members { get; set; }
+
+            [Command]
+            [Remarks("system [system] list")]
+            public async Task MemberShortList() {
+                var system = Context.GetContextEntity<PKSystem>() ?? Context.SenderSystem;
+                if (system == null) throw Errors.NoSystemError;
+
+                var members = await Members.GetBySystem(system);
+                var embedTitle = system.Name != null ? $"Members of {system.Name} (`{system.Hid}`)" : $"Members of `{system.Hid}`";
+                await Context.Paginate<PKMember>(
+                    members.OrderBy(m => m.Name).ToList(),
+                    25,
+                    embedTitle,
+                    (eb, ms) => eb.Description = string.Join("\n", ms.Select((m) => {
+                        if (m.HasProxyTags) return $"[`{m.Hid}`] **{m.Name}** *({m.ProxyString})*";
+                        return $"[`{m.Hid}`] **{m.Name}**";
+                    }))
+                );
+            }
+
+            [Command("full")]
+            [Alias("big", "details", "long")]
+            [Remarks("system [system] list full")]
+            public async Task MemberLongList() {
+                var system = Context.GetContextEntity<PKSystem>() ?? Context.SenderSystem;
+                if (system == null) throw Errors.NoSystemError;
+
+                var members = await Members.GetBySystem(system);
+                var embedTitle = system.Name != null ? $"Members of {system.Name} (`{system.Hid}`)" : $"Members of `{system.Hid}`";
+                await Context.Paginate<PKMember>(
+                    members.OrderBy(m => m.Name).ToList(),
+                    10,
+                    embedTitle,
+                    (eb, ms) => {
+                        foreach (var m in ms) {
+                            var profile = $"**ID**: {m.Hid}";
+                            if (m.Pronouns != null) profile += $"\n**Pronouns**: {m.Pronouns}";
+                            if (m.Birthday != null) profile += $"\n**Birthdate**: {m.BirthdayString}";
+                            if (m.Prefix != null || m.Suffix != null) profile += $"\n**Proxy tags**: {m.ProxyString}";
+                            if (m.Description != null) profile += $"\n\n{m.Description}";
+                            eb.AddField(m.Name, profile);
+                        }
+                    }
+                );
+            }
+        }
+
+        [Command("fronter")]
+        [Alias("f", "front", "fronters")]
+        [Remarks("system [system] fronter")]
+        public async Task SystemFronter()
+        {
+            var system = ContextEntity ?? Context.SenderSystem;
+            if (system == null) throw Errors.NoSystemError;
+            
+            var sw = await Switches.GetLatestSwitch(system);
+            if (sw == null) throw Errors.NoRegisteredSwitches;
+            
+            await Context.Channel.SendMessageAsync(embed: await EmbedService.CreateFronterEmbed(sw, system.Zone));
+        }
+
+        [Command("fronthistory")]
+        [Alias("fh", "history", "switches")]
+        [Remarks("system [system] fronthistory")]
+        public async Task SystemFrontHistory()
+        {
+            var system = ContextEntity ?? Context.SenderSystem;
+            if (system == null) throw Errors.NoSystemError;
+
+            var sws = (await Switches.GetSwitches(system, 10)).ToList();
+            if (sws.Count == 0) throw Errors.NoRegisteredSwitches;
+            
+            await Context.Channel.SendMessageAsync(embed: await EmbedService.CreateFrontHistoryEmbed(sws, system.Zone));
+        }
+
+        [Command("frontpercent")]
+        [Alias("frontbreakdown", "frontpercent", "front%", "fp")]
+        [Remarks("system [system] frontpercent [duration]")]
+        public async Task SystemFrontPercent(string durationStr = "30d")
+        {
+            var system = ContextEntity ?? Context.SenderSystem;
+            if (system == null) throw Errors.NoSystemError;
+
+            var duration = PluralKit.Utils.ParsePeriod(durationStr);
+            if (duration == null) throw Errors.InvalidDateTime(durationStr); 
+            
+            var rangeEnd = SystemClock.Instance.GetCurrentInstant();
+            var rangeStart = rangeEnd - duration.Value;
+            
+            var frontpercent = await Switches.GetPerMemberSwitchDuration(system, rangeEnd - duration.Value, rangeEnd);
+            await Context.Channel.SendMessageAsync(embed: await EmbedService.CreateFrontPercentEmbed(frontpercent, rangeStart.InZone(system.Zone)));
+        }
+
+        [Command("timezone")]
+        [Alias("tz")]
+        [Remarks("system timezone [timezone]")]
+        [MustHaveSystem]
+        public async Task SystemTimezone([Remainder] string zoneStr = null)
+        {
+            if (zoneStr == null)
+            {
+                Context.SenderSystem.UiTz = "UTC";
+                await Systems.Save(Context.SenderSystem);
+                await Context.Channel.SendMessageAsync($"{Emojis.Success} System time zone cleared.");
+                return;
+            }
+
+            var zone = await FindTimeZone(zoneStr);
+            if (zone == null) throw Errors.InvalidTimeZone(zoneStr);
+
+            var currentTime = SystemClock.Instance.GetCurrentInstant().InZone(zone);
+            var msg = await Context.Channel.SendMessageAsync(
+                $"This will change the system time zone to {zone.Id}. The current time is {Formats.ZonedDateTimeFormat.Format(currentTime)}. Is this correct?");
+            if (!await Context.PromptYesNo(msg)) throw Errors.TimezoneChangeCancelled;
+            Context.SenderSystem.UiTz = zone.Id;
+            await Systems.Save(Context.SenderSystem);
+
+            await Context.Channel.SendMessageAsync($"System time zone changed to {zone.Id}.");
+        }
+
+        public async Task<DateTimeZone> FindTimeZone(string zoneStr) {
+            // First, if we're given a flag emoji, we extract the flag emoji code from it.
+            zoneStr = PluralKit.Utils.ExtractCountryFlag(zoneStr) ?? zoneStr;
+            
+            // Then, we find all *locations* matching either the given country code or the country name.
+            var locations = TzdbDateTimeZoneSource.Default.Zone1970Locations;
+            var matchingLocations = locations.Where(l => l.Countries.Any(c =>
+                string.Equals(c.Code, zoneStr, StringComparison.InvariantCultureIgnoreCase) ||
+                string.Equals(c.Name, zoneStr, StringComparison.InvariantCultureIgnoreCase)));
+            
+            // Then, we find all (unique) time zone IDs that match.
+            var matchingZones = matchingLocations.Select(l => DateTimeZoneProviders.Tzdb.GetZoneOrNull(l.ZoneId))
+                .Distinct().ToList();
+            
+            // If the set of matching zones is empty (ie. we didn't find anything), we try a few other things.
+            if (matchingZones.Count == 0)
+            {
+                // First, we try to just find the time zone given directly and return that.
+                var givenZone = DateTimeZoneProviders.Tzdb.GetZoneOrNull(zoneStr);
+                if (givenZone != null) return givenZone;
+
+                // If we didn't find anything there either, we try parsing the string as an offset, then
+                // find all possible zones that match that offset. For an offset like UTC+2, this doesn't *quite*
+                // work, since there are 57(!) matching zones (as of 2019-06-13) - but for less populated time zones
+                // this could work nicely.
+                var inputWithoutUtc = zoneStr.Replace("UTC", "").Replace("GMT", "");
+
+                var res = OffsetPattern.CreateWithInvariantCulture("+H").Parse(inputWithoutUtc);
+                if (!res.Success) res = OffsetPattern.CreateWithInvariantCulture("+H:mm").Parse(inputWithoutUtc);
+
+                // If *this* didn't parse correctly, fuck it, bail.
+                if (!res.Success) return null;
+                var offset = res.Value;
+
+                // To try to reduce the count, we go by locations from the 1970+ database instead of just the full database
+                // This elides regions that have been identical since 1970, omitting small distinctions due to Ancient History(tm).
+                var allZones = TzdbDateTimeZoneSource.Default.Zone1970Locations.Select(l => l.ZoneId).Distinct();
+                matchingZones = allZones.Select(z => DateTimeZoneProviders.Tzdb.GetZoneOrNull(z))
+                    .Where(z => z.GetUtcOffset(SystemClock.Instance.GetCurrentInstant()) == offset).ToList();
+            }
+            
+            // If we have a list of viable time zones, we ask the user which is correct.
+            
+            // If we only have one, return that one.
+            if (matchingZones.Count == 1)
+                return matchingZones.First();
+            
+            // Otherwise, prompt and return!
+            return await Context.Choose("There were multiple matches for your time zone query. Please select the region that matches you the closest:", matchingZones,
+                z =>
+                {
+                    if (TzdbDateTimeZoneSource.Default.Aliases.Contains(z.Id))
+                        return $"**{z.Id}**, {string.Join(", ", TzdbDateTimeZoneSource.Default.Aliases[z.Id])}";
+
+                    return $"**{z.Id}**";
+                });
+        } 
+
+        public override async Task<PKSystem> ReadContextParameterAsync(string value)
+        {
+            var res = await new PKSystemTypeReader().ReadAsync(Context, value, _services);
+            return res.IsSuccess ? res.BestMatch as PKSystem : null;
+        }
+    }
+}

PluralKit.Bot/ContextUtils.cs

@@ -0,0 +1,216 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+
+namespace PluralKit.Bot {
+    public static class ContextUtils {
+                public static async Task<bool> PromptYesNo(this ICommandContext ctx, IUserMessage message, IUser user = null, TimeSpan? timeout = null) {
+            await message.AddReactionsAsync(new[] {new Emoji(Emojis.Success), new Emoji(Emojis.Error)});
+            var reaction = await ctx.AwaitReaction(message, user ?? ctx.User, (r) => r.Emote.Name == Emojis.Success || r.Emote.Name == Emojis.Error, timeout ?? TimeSpan.FromMinutes(1));
+            return reaction.Emote.Name == Emojis.Success;
+        }
+
+        public static async Task<SocketReaction> AwaitReaction(this ICommandContext ctx, IUserMessage message, IUser user = null, Func<SocketReaction, bool> predicate = null, TimeSpan? timeout = null) {
+            var tcs = new TaskCompletionSource<SocketReaction>();
+            Task Inner(Cacheable<IUserMessage, ulong> _message, ISocketMessageChannel _channel, SocketReaction reaction) {
+                if (message.Id != _message.Id) return Task.CompletedTask; // Ignore reactions for different messages
+                if (user != null && user.Id != reaction.UserId) return Task.CompletedTask; // Ignore messages from other users if a user was defined
+                if (predicate != null && !predicate.Invoke(reaction)) return Task.CompletedTask; // Check predicate
+                tcs.SetResult(reaction);
+                return Task.CompletedTask;
+            }
+
+            (ctx.Client as BaseSocketClient).ReactionAdded += Inner;
+            try {
+                return await (tcs.Task.TimeoutAfter(timeout));
+            } finally {
+                (ctx.Client as BaseSocketClient).ReactionAdded -= Inner;
+            }
+        }
+
+        public static async Task<IUserMessage> AwaitMessage(this ICommandContext ctx, IMessageChannel channel, IUser user = null, Func<SocketMessage, bool> predicate = null, TimeSpan? timeout = null) {
+            var tcs = new TaskCompletionSource<IUserMessage>();
+            Task Inner(SocketMessage msg) {
+                if (channel != msg.Channel) return Task.CompletedTask; // Ignore messages in a different channel
+                if (user != null && user != msg.Author) return Task.CompletedTask; // Ignore messages from other users
+                if (predicate != null && !predicate.Invoke(msg)) return Task.CompletedTask; // Check predicate
+
+                (ctx.Client as BaseSocketClient).MessageReceived -= Inner;
+                tcs.SetResult(msg as IUserMessage);
+                
+                return Task.CompletedTask;
+            }
+
+            (ctx.Client as BaseSocketClient).MessageReceived += Inner;
+            return await (tcs.Task.TimeoutAfter(timeout));
+        }
+        
+        public static async Task<bool> ConfirmWithReply(this ICommandContext ctx, string expectedReply)
+        {
+            var msg = await ctx.AwaitMessage(ctx.Channel, ctx.User, timeout: TimeSpan.FromMinutes(1));
+            return string.Equals(msg.Content, expectedReply, StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        public static async Task Paginate<T>(this ICommandContext ctx, ICollection<T> items, int itemsPerPage, string title, Action<EmbedBuilder, IEnumerable<T>> renderer) {
+            // TODO: make this generic enough we can use it in Choose<T> below
+            
+            var pageCount = (items.Count / itemsPerPage) + 1;
+            Embed MakeEmbedForPage(int page) {
+                var eb = new EmbedBuilder();
+                eb.Title = pageCount > 1 ? $"[{page+1}/{pageCount}] {title}" : title;
+                renderer(eb, items.Skip(page*itemsPerPage).Take(itemsPerPage));
+                return eb.Build();
+            }
+
+            var msg = await ctx.Channel.SendMessageAsync(embed: MakeEmbedForPage(0));
+            if (pageCount == 1) return; // If we only have one page, don't bother with the reaction/pagination logic, lol
+            var botEmojis = new[] { new Emoji("\u23EA"), new Emoji("\u2B05"), new Emoji("\u27A1"), new Emoji("\u23E9"), new Emoji(Emojis.Error) };
+            await msg.AddReactionsAsync(botEmojis);
+
+            try {
+                var currentPage = 0;
+                while (true) {
+                    var reaction = await ctx.AwaitReaction(msg, ctx.User, timeout: TimeSpan.FromMinutes(5));
+
+                    // Increment/decrement page counter based on which reaction was clicked
+                    if (reaction.Emote.Name == "\u23EA") currentPage = 0; // <<
+                    if (reaction.Emote.Name == "\u2B05") currentPage = (currentPage - 1) % pageCount; // <
+                    if (reaction.Emote.Name == "\u27A1") currentPage = (currentPage + 1) % pageCount; // >
+                    if (reaction.Emote.Name == "\u23E9") currentPage = pageCount - 1; // >>
+                    if (reaction.Emote.Name == Emojis.Error) break; // X
+                    
+                    // If we can, remove the user's reaction (so they can press again quickly)
+                    if (await ctx.HasPermission(ChannelPermission.ManageMessages) && reaction.User.IsSpecified) await msg.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
+                    
+                    // Edit the embed with the new page
+                    await msg.ModifyAsync((mp) => mp.Embed = MakeEmbedForPage(currentPage));
+                }
+            } catch (TimeoutException) {
+                // "escape hatch", clean up as if we hit X
+            }
+
+            if (await ctx.HasPermission(ChannelPermission.ManageMessages)) await msg.RemoveAllReactionsAsync();
+            else await msg.RemoveReactionsAsync(ctx.Client.CurrentUser, botEmojis);
+        }
+        
+        public static async Task<T> Choose<T>(this ICommandContext ctx, string description, IList<T> items, Func<T, string> display = null)
+        {
+            // Generate a list of :regional_indicator_?: emoji surrogate pairs (starting at codepoint 0x1F1E6)
+            // We just do 7 (ABCDEFG), this amount is arbitrary (although sending a lot of emojis takes a while)
+            var pageSize = 7;
+            var indicators = new string[pageSize];
+            for (var i = 0; i < pageSize; i++) indicators[i] = char.ConvertFromUtf32(0x1F1E6 + i);
+
+            // Default to x.ToString()
+            if (display == null) display = x => x.ToString();
+
+            string MakeOptionList(int page)
+            {
+                var makeOptionList = string.Join("\n", items
+                    .Skip(page * pageSize)
+                    .Take(pageSize)
+                    .Select((x, i) => $"{indicators[i]} {display(x)}"));
+                return makeOptionList;
+            }
+
+            // If we have more items than the page size, we paginate as appropriate
+            if (items.Count > pageSize)
+            {
+                var currPage = 0;
+                var pageCount = (items.Count-1) / pageSize + 1;
+                
+                // Send the original message
+                var msg = await ctx.Channel.SendMessageAsync($"**[Page {currPage + 1}/{pageCount}]**\n{description}\n{MakeOptionList(currPage)}");
+                
+                // Add back/forward reactions and the actual indicator emojis
+                async Task AddEmojis()
+                {
+                    await msg.AddReactionAsync(new Emoji("\u2B05"));
+                    await msg.AddReactionAsync(new Emoji("\u27A1"));
+                    for (int i = 0; i < items.Count; i++) await msg.AddReactionAsync(new Emoji(indicators[i]));
+                }
+
+                AddEmojis(); // Not concerned about awaiting
+
+
+                while (true)
+                {
+                    // Wait for a reaction
+                    var reaction = await ctx.AwaitReaction(msg, ctx.User);
+                    
+                    // If it's a movement reaction, inc/dec the page index
+                    if (reaction.Emote.Name == "\u2B05") currPage -= 1; // <
+                    if (reaction.Emote.Name == "\u27A1") currPage += 1; // >
+                    if (currPage < 0) currPage += pageCount;
+                    if (currPage >= pageCount) currPage -= pageCount;
+
+                    // If it's an indicator emoji, return the relevant item
+                    if (indicators.Contains(reaction.Emote.Name))
+                    {
+                        var idx = Array.IndexOf(indicators, reaction.Emote.Name) + pageSize * currPage;
+                        // only if it's in bounds, though
+                        // eg. 8 items, we're on page 2, and I hit D (3 + 1*7 = index 10 on an 8-long list) = boom 
+                        if (idx < items.Count) return items[idx];
+                    }
+
+                    msg.RemoveReactionAsync(reaction.Emote, ctx.User); // don't care about awaiting
+                    await msg.ModifyAsync(mp => mp.Content = $"**[Page {currPage + 1}/{pageCount}]**\n{description}\n{MakeOptionList(currPage)}");
+                }
+            }
+            else
+            {
+                var msg = await ctx.Channel.SendMessageAsync($"{description}\n{MakeOptionList(0)}");
+
+                // Add the relevant reactions (we don't care too much about awaiting)
+                async Task AddEmojis()
+                {
+                    for (int i = 0; i < items.Count; i++) await msg.AddReactionAsync(new Emoji(indicators[i]));
+                }
+
+                AddEmojis();
+
+                // Then wait for a reaction and return whichever one we found
+                var reaction = await ctx.AwaitReaction(msg, ctx.User,rx => indicators.Contains(rx.Emote.Name));
+                return items[Array.IndexOf(indicators, reaction.Emote.Name)];
+            }
+        }
+
+        public static async Task<ChannelPermissions> Permissions(this ICommandContext ctx) {
+            if (ctx.Channel is IGuildChannel) {
+                var gu = await ctx.Guild.GetCurrentUserAsync();
+                return gu.GetPermissions(ctx.Channel as IGuildChannel);
+            }
+            return ChannelPermissions.DM;
+        }
+
+        public static async Task<bool> HasPermission(this ICommandContext ctx, ChannelPermission permission) => (await Permissions(ctx)).Has(permission);
+
+        public static async Task BusyIndicator(this ICommandContext ctx, Func<Task> f, string emoji = "\u23f3" /* hourglass */)
+        {
+            await ctx.BusyIndicator<object>(async () =>
+            {
+                await f();
+                return null;
+            }, emoji);
+        }
+
+        public static async Task<T> BusyIndicator<T>(this ICommandContext ctx, Func<Task<T>> f, string emoji = "\u23f3" /* hourglass */)
+        {
+            var task = f();
+
+            try
+            {
+                await Task.WhenAll(ctx.Message.AddReactionAsync(new Emoji(emoji)), task);
+                return await task;
+            }
+            finally
+            {
+                ctx.Message.RemoveReactionAsync(new Emoji(emoji), ctx.Client.CurrentUser);
+            }
+        }
+    }
+}

PluralKit.Bot/Errors.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using Humanizer;
+using NodaTime;
+using PluralKit.Core;
+
+namespace PluralKit.Bot {
+    public static class Errors {
+        // TODO: is returning constructed errors and throwing them at call site a good idea, or should these be methods that insta-throw instead?
+
+        public static PKError NotOwnSystemError => new PKError($"You can only run this command on your own system.");
+        public static PKError NotOwnMemberError => new PKError($"You can only run this command on your own member.");
+        public static PKError NoSystemError => new PKError("You do not have a system registered with PluralKit. To create one, type `pk;system new`.");
+        public static PKError ExistingSystemError => new PKError("You already have a system registered with PluralKit. To view it, type `pk;system`. If you'd like to delete your system and start anew, type `pk;system delete`, or if you'd like to unlink this account from it, type `pk;unlink`.");
+        public static PKError MissingMemberError => new PKSyntaxError("You need to specify a member to run this command on.");
+
+        public static PKError SystemNameTooLongError(int length) => new PKError($"System name too long ({length}/{Limits.MaxSystemNameLength} characters).");
+        public static PKError SystemTagTooLongError(int length) => new PKError($"System tag too long ({length}/{Limits.MaxSystemTagLength} characters).");
+        public static PKError DescriptionTooLongError(int length) => new PKError($"Description too long ({length}/{Limits.MaxDescriptionLength} characters).");
+        public static PKError MemberNameTooLongError(int length) => new PKError($"Member name too long ({length}/{Limits.MaxMemberNameLength} characters).");
+        public static PKError MemberPronounsTooLongError(int length) => new PKError($"Member pronouns too long ({length}/{Limits.MaxMemberNameLength} characters).");
+        
+        public static PKError InvalidColorError(string color) => new PKError($"\"{color.Sanitize()}\" is not a valid color. Color must be in 6-digit RGB hex format (eg. #ff0000).");
+        public static PKError BirthdayParseError(string birthday) => new PKError($"\"{birthday.Sanitize()}\" could not be parsed as a valid date. Try a format like \"2016-12-24\" or \"May 3 1996\".");
+        public static PKError ProxyMustHaveText => new PKSyntaxError("Example proxy message must contain the string 'text'.");
+        public static PKError ProxyMultipleText => new PKSyntaxError("Example proxy message must contain the string 'text' exactly once.");
+        
+        public static PKError MemberDeleteCancelled => new PKError($"Member deletion cancelled. Stay safe! {Emojis.ThumbsUp}");
+        public static PKError AvatarServerError(HttpStatusCode statusCode) => new PKError($"Server responded with status code {(int) statusCode}, are you sure your link is working?");
+        public static PKError AvatarFileSizeLimit(long size) => new PKError($"File size too large ({size.Bytes().ToString("#.#")} > {Limits.AvatarFileSizeLimit.Bytes().ToString("#.#")}), try shrinking or compressing the image.");
+        public static PKError AvatarNotAnImage(string mimeType) => new PKError($"The given link does not point to an image{(mimeType != null ? $" ({mimeType.Sanitize()})" : "")}. Make sure you're using a direct link (ending in .jpg, .png, .gif).");
+        public static PKError AvatarDimensionsTooLarge(int width, int height) => new PKError($"Image too large ({width}x{height} > {Limits.AvatarDimensionLimit}x{Limits.AvatarDimensionLimit}), try resizing the image.");
+        public static PKError InvalidUrl(string url) => new PKError($"The given URL is invalid.");
+        
+        public static PKError AccountAlreadyLinked => new PKError("That account is already linked to your system.");
+        public static PKError AccountNotLinked => new PKError("That account isn't linked to your system.");
+        public static PKError AccountInOtherSystem(PKSystem system) => new PKError($"The mentioned account is already linked to another system (see `pk;system {system.Hid}`).");
+        public static PKError UnlinkingLastAccount => new PKError("Since this is the only account linked to this system, you cannot unlink it (as that would leave your system account-less).");
+        public static PKError MemberLinkCancelled => new PKError("Member link cancelled.");
+        public static PKError MemberUnlinkCancelled => new PKError("Member unlink cancelled.");
+
+        public static PKError SameSwitch(ICollection<PKMember> members)
+        {
+            if (members.Count == 0) return new PKError("There's already no one in front.");
+            if (members.Count == 1) return new PKError($"Member {members.First().Name.Sanitize()} is already fronting.");
+            return new PKError($"Members {string.Join(", ", members.Select(m => m.Name.Sanitize()))} are already fronting.");
+        }
+
+        public static PKError DuplicateSwitchMembers => new PKError("Duplicate members in member list.");
+        public static PKError SwitchMemberNotInSystem => new PKError("One or more switch members aren't in your own system.");
+
+        public static PKError InvalidDateTime(string str) => new PKError($"Could not parse '{str.Sanitize()}' as a valid date/time. Try using a syntax such as \"May 21, 12:30 PM\" or \"3d12h\" (ie. 3 days, 12 hours ago).");
+        public static PKError SwitchTimeInFuture => new PKError("Can't move switch to a time in the future.");
+        public static PKError NoRegisteredSwitches => new PKError("There are no registered switches for this system.");
+
+        public static PKError SwitchMoveBeforeSecondLast(ZonedDateTime time) => new PKError($"Can't move switch to before last switch time ({Formats.ZonedDateTimeFormat.Format(time)}), as it would cause conflicts.");
+        public static PKError SwitchMoveCancelled => new PKError("Switch move cancelled.");
+        public static PKError SwitchDeleteCancelled => new PKError("Switch deletion cancelled.");
+        public static PKError TimezoneParseError(string timezone) => new PKError($"Could not parse timezone offset {timezone.Sanitize()}. Offset must be a value like 'UTC+5' or 'GMT-4:30'.");
+
+        public static PKError InvalidTimeZone(string zoneStr) => new PKError($"Invalid time zone ID '{zoneStr.Sanitize()}'. To find your time zone ID, use the following website: <https://xske.github.io/tz>");
+        public static PKError TimezoneChangeCancelled => new PKError("Time zone change cancelled.");
+        public static PKError AmbiguousTimeZone(string zoneStr, int count) => new PKError($"The time zone query '{zoneStr.Sanitize()}' resulted in **{count}** different time zone regions. Try being more specific - e.g. pass an exact time zone specifier from the following website: <https://xske.github.io/tz>");
+        public static PKError NoImportFilePassed => new PKError("You must either pass an URL to a file as a command parameter, or as an attachment to the message containing the command.");
+        public static PKError InvalidImportFile => new PKError("Imported data file invalid. Make sure this is a .json file directly exported from PluralKit or Tupperbox.");
+        public static PKError ImportCancelled => new PKError("Import cancelled.");
+        public static PKError MessageNotFound(ulong id) => new PKError($"Message with ID '{id}' not found. Are you sure it's a message proxied by PluralKit?");
+        
+        public static PKError DurationParseError(string durationStr) => new PKError($"Could not parse '{durationStr.Sanitize()}' as a valid duration. Try a format such as `30d`, `1d3h` or `20m30s`.");
+    }
+}

PluralKit.Bot/PluralKit.Bot.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>netcoreapp2.2</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\PluralKit.Core\PluralKit.Core.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Discord.Net.Commands" Version="2.0.1" />
+      <PackageReference Include="Discord.Net.Webhook" Version="2.0.1" />
+      <PackageReference Include="Discord.Net.WebSocket" Version="2.0.1" />
+      <PackageReference Include="Humanizer.Core" Version="2.6.2" />
+      <PackageReference Include="SixLabors.ImageSharp" Version="1.0.0-beta0006" />
+    </ItemGroup>
+
+</Project>

PluralKit.Bot/Preconditions.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Threading.Tasks;
+using Discord.Commands;
+
+namespace PluralKit.Bot {
+    class MustHaveSystem : PreconditionAttribute
+    {
+        public override async Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services)
+        {
+            var c = context as PKCommandContext;
+            if (c == null) return PreconditionResult.FromError("Must be called on a PKCommandContext (should never happen!)");
+            if (c.SenderSystem == null) return PreconditionResult.FromError(Errors.NoSystemError);
+            return PreconditionResult.FromSuccess();
+        }
+    }
+
+    class MustPassOwnMember : PreconditionAttribute
+    {
+        public override async Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services)
+        {
+            // OK when:
+            // - Sender has a system
+            // - Sender passes a member as a context parameter
+            // - Sender owns said member 
+
+            var c = context as PKCommandContext;
+            if (c == null) 
+            if (c.SenderSystem == null) return PreconditionResult.FromError(Errors.NoSystemError);
+            if (c.GetContextEntity<PKMember>() == null) return PreconditionResult.FromError(Errors.MissingMemberError);
+            if (c.GetContextEntity<PKMember>().System != c.SenderSystem.Id) return PreconditionResult.FromError(Errors.NotOwnMemberError);
+            return PreconditionResult.FromSuccess();
+        }
+    }
+}

PluralKit.Bot/Services/EmbedService.cs

@@ -0,0 +1,168 @@
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Humanizer;
+using NodaTime;
+
+namespace PluralKit.Bot {
+    public class EmbedService {
+        private SystemStore _systems;
+        private MemberStore _members;
+        private SwitchStore _switches;
+        private MessageStore _messages;
+        private IDiscordClient _client;
+
+        public EmbedService(SystemStore systems, MemberStore members, IDiscordClient client, SwitchStore switches, MessageStore messages)
+        {
+            _systems = systems;
+            _members = members;
+            _client = client;
+            _switches = switches;
+            _messages = messages;
+        }
+
+        public async Task<Embed> CreateSystemEmbed(PKSystem system) {
+            var accounts = await _systems.GetLinkedAccountIds(system);
+
+            // Fetch/render info for all accounts simultaneously
+            var users = await Task.WhenAll(accounts.Select(async uid => (await _client.GetUserAsync(uid))?.NameAndMention() ?? $"(deleted account {uid})"));
+
+            var eb = new EmbedBuilder()
+                .WithColor(Color.Blue)
+                .WithTitle(system.Name ?? null)
+                .WithDescription(system.Description?.Truncate(1024))
+                .WithThumbnailUrl(system.AvatarUrl ?? null)
+                .WithFooter($"System ID: {system.Hid}");
+
+            eb.AddField("Linked accounts", string.Join(", ", users));
+            eb.AddField("Members", $"(see `pk;system {system.Hid} list` or `pk;system {system.Hid} list full`)");
+            // TODO: fronter
+            return eb.Build();
+        }
+
+        public Embed CreateLoggedMessageEmbed(PKSystem system, PKMember member, IMessage message, IUser sender) {
+            // TODO: pronouns in ?-reacted response using this card
+            return new EmbedBuilder()
+                .WithAuthor($"#{message.Channel.Name}: {member.Name}", member.AvatarUrl)
+                .WithDescription(message.Content)
+                .WithFooter($"System ID: {system.Hid} | Member ID: {member.Hid} | Sender: {sender.Username}#{sender.Discriminator} ({sender.Id}) | Message ID: {message.Id}")
+                .WithTimestamp(message.Timestamp)
+                .Build();
+        }
+
+        public async Task<Embed> CreateMemberEmbed(PKSystem system, PKMember member)
+        {
+            var name = member.Name;
+            if (system.Name != null) name = $"{member.Name} ({system.Name})";
+            
+            var color = member.Color?.ToDiscordColor() ?? Color.Default;
+
+            var messageCount = await _members.MessageCount(member);
+
+            var eb = new EmbedBuilder()
+                // TODO: add URL of website when that's up
+                .WithAuthor(name, member.AvatarUrl)
+                .WithColor(color)
+                .WithDescription(member.Description)
+                .WithFooter($"System ID: {system.Hid} | Member ID: {member.Hid}");
+
+            if (member.Birthday != null) eb.AddField("Birthdate", member.BirthdayString);
+            if (member.Pronouns != null) eb.AddField("Pronouns", member.Pronouns);
+            if (messageCount > 0) eb.AddField("Message Count", messageCount);
+            if (member.HasProxyTags) eb.AddField("Proxy Tags", $"{member.Prefix}text{member.Suffix}");
+
+            return eb.Build();
+        }
+
+        public async Task<Embed> CreateFronterEmbed(PKSwitch sw, DateTimeZone zone)
+        {
+            var members = (await _switches.GetSwitchMembers(sw)).ToList();
+            var timeSinceSwitch = SystemClock.Instance.GetCurrentInstant() - sw.Timestamp;
+            return new EmbedBuilder()
+                .WithColor(members.FirstOrDefault()?.Color?.ToDiscordColor() ?? Color.Blue)
+                .AddField($"Current {"fronter".ToQuantity(members.Count, ShowQuantityAs.None)}", members.Count > 0 ? string.Join(", ", members.Select(m => m.Name)) : "*(no fronter)*")
+                .AddField("Since", $"{Formats.ZonedDateTimeFormat.Format(sw.Timestamp.InZone(zone))} ({Formats.DurationFormat.Format(timeSinceSwitch)} ago)")
+                .Build();
+        }
+
+        public async Task<Embed> CreateFrontHistoryEmbed(IEnumerable<PKSwitch> sws, DateTimeZone zone)
+        {
+            var outputStr = "";
+
+            PKSwitch lastSw = null;
+            foreach (var sw in sws)
+            {
+                // Fetch member list and format
+                var members = (await _switches.GetSwitchMembers(sw)).ToList();
+                var membersStr = members.Any() ? string.Join(", ", members.Select(m => m.Name)) : "no fronter";
+
+                var switchSince = SystemClock.Instance.GetCurrentInstant() - sw.Timestamp;
+                
+                // If this isn't the latest switch, we also show duration
+                if (lastSw != null)
+                {
+                    // Calculate the time between the last switch (that we iterated - ie. the next one on the timeline) and the current one
+                    var switchDuration = lastSw.Timestamp - sw.Timestamp;
+                    outputStr += $"**{membersStr}** ({Formats.ZonedDateTimeFormat.Format(sw.Timestamp.InZone(zone))}, {Formats.DurationFormat.Format(switchSince)} ago, for {Formats.DurationFormat.Format(switchDuration)})\n";
+                }
+                else
+                {
+                    outputStr += $"**{membersStr}** ({Formats.ZonedDateTimeFormat.Format(sw.Timestamp.InZone(zone))}, {Formats.DurationFormat.Format(switchSince)} ago)\n";
+                }
+
+                lastSw = sw;
+            }
+            
+            return new EmbedBuilder()
+                .WithTitle("Past switches")
+                .WithDescription(outputStr)
+                .Build();
+        }
+
+        public async Task<Embed> CreateMessageInfoEmbed(MessageStore.StoredMessage msg)
+        {
+            var channel = (ITextChannel) await _client.GetChannelAsync(msg.Message.Channel);
+            var serverMsg = await channel.GetMessageAsync(msg.Message.Mid);
+
+            var memberStr = $"{msg.Member.Name} (`{msg.Member.Hid}`)";
+            if (msg.Member.Pronouns != null) memberStr += $"\n*(pronouns: **{msg.Member.Pronouns}**)*";
+            
+            return new EmbedBuilder()
+                .WithAuthor(msg.Member.Name, msg.Member.AvatarUrl)
+                .WithDescription(serverMsg?.Content ?? "*(message contents deleted or inaccessible)*")
+                .AddField("System", msg.System.Name != null ? $"{msg.System.Name} (`{msg.System.Hid}`)" : $"`{msg.System.Hid}`", true)
+                .AddField("Member", memberStr, true)
+                .WithTimestamp(SnowflakeUtils.FromSnowflake(msg.Message.Mid))
+                .Build();
+        }
+
+        public async Task<Embed> CreateFrontPercentEmbed(IDictionary<PKMember, Duration> frontpercent, ZonedDateTime startingFrom)
+        {
+            var totalDuration = SystemClock.Instance.GetCurrentInstant() - startingFrom.ToInstant();
+            
+            var eb = new EmbedBuilder()
+                .WithColor(Color.Blue)
+                .WithFooter($"Since {Formats.ZonedDateTimeFormat.Format(startingFrom)} ({Formats.DurationFormat.Format(totalDuration)} ago)");
+
+            var maxEntriesToDisplay = 24; // max 25 fields allowed in embed - reserve 1 for "others"
+            
+            var membersOrdered = frontpercent.OrderBy(pair => pair.Value).Take(maxEntriesToDisplay).ToList();
+            foreach (var pair in membersOrdered)
+            {
+                var frac = pair.Value / totalDuration;
+                eb.AddField(pair.Key.Name, $"{frac*100:F0}% ({Formats.DurationFormat.Format(pair.Value)})");
+            }
+
+            if (membersOrdered.Count > maxEntriesToDisplay)
+            {
+                eb.AddField("(others)",
+                    Formats.DurationFormat.Format(membersOrdered.Skip(maxEntriesToDisplay)
+                        .Aggregate(Duration.Zero, (prod, next) => prod + next.Value)), true);
+            }
+
+            return eb.Build();
+        }
+    }
+}

PluralKit.Bot/Services/LogChannelService.cs

@@ -0,0 +1,57 @@
+using System.Data;
+using System.Threading.Tasks;
+using Dapper;
+using Discord;
+
+namespace PluralKit.Bot {
+    public class ServerDefinition {
+        public ulong Id { get; set; }
+        public ulong? LogChannel { get; set; } 
+    }
+
+    public class LogChannelService {
+        private IDiscordClient _client;
+        private DbConnectionFactory _conn;
+        private EmbedService _embed;
+
+        public LogChannelService(IDiscordClient client, DbConnectionFactory conn, EmbedService embed)
+        {
+            this._client = client;
+            this._conn = conn;
+            this._embed = embed;
+        }
+
+        public async Task LogMessage(PKSystem system, PKMember member, IMessage message, IUser sender) {
+            var channel = await GetLogChannel((message.Channel as IGuildChannel).Guild);
+            if (channel == null) return;
+
+            var embed = _embed.CreateLoggedMessageEmbed(system, member, message, sender);
+            await channel.SendMessageAsync(text: message.GetJumpUrl(), embed: embed);
+        }
+
+        public async Task<ITextChannel> GetLogChannel(IGuild guild) {
+            using (var conn = await _conn.Obtain())
+            {
+                var server =
+                    await conn.QueryFirstOrDefaultAsync<ServerDefinition>("select * from servers where id = @Id",
+                        new {Id = guild.Id});
+                if (server?.LogChannel == null) return null;
+                return await _client.GetChannelAsync(server.LogChannel.Value) as ITextChannel;
+            }
+        }
+
+        public async Task SetLogChannel(IGuild guild, ITextChannel newLogChannel) {
+            var def = new ServerDefinition {
+                Id = guild.Id,
+                LogChannel = newLogChannel?.Id
+            };
+
+            using (var conn = await _conn.Obtain())
+            {
+                await conn.QueryAsync(
+                    "insert into servers (id, log_channel) values (@Id, @LogChannel) on conflict (id) do update set log_channel = @LogChannel",
+                    def);
+            }
+        }
+    }
+}

PluralKit.Bot/Services/ProxyService.cs

@@ -0,0 +1,237 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Dapper;
+using Discord;
+using Discord.Webhook;
+using Discord.WebSocket;
+
+namespace PluralKit.Bot
+{
+    class ProxyDatabaseResult
+    {
+        public PKSystem System;
+        public PKMember Member;
+    }
+
+    class ProxyMatch {
+        public PKMember Member;
+        public PKSystem System;
+        public string InnerText;
+
+        public string ProxyName => Member.Name + (System.Tag != null ? " " + System.Tag : "");
+    }
+
+    class ProxyService {
+        private IDiscordClient _client;
+        private DbConnectionFactory _conn;
+        private LogChannelService _logger;
+        private WebhookCacheService _webhookCache;
+        private MessageStore _messageStorage;
+        private EmbedService _embeds;
+        
+        public ProxyService(IDiscordClient client, WebhookCacheService webhookCache, DbConnectionFactory conn, LogChannelService logger, MessageStore messageStorage, EmbedService embeds)
+        {
+            _client = client;
+            _webhookCache = webhookCache;
+            _conn = conn;
+            _logger = logger;
+            _messageStorage = messageStorage;
+            _embeds = embeds;
+        }
+
+        private ProxyMatch GetProxyTagMatch(string message, IEnumerable<ProxyDatabaseResult> potentials)
+        {
+            // If the message starts with a @mention, and then proceeds to have proxy tags,
+            // extract the mention and place it inside the inner message
+            // eg. @Ske [text] => [@Ske text]
+            int matchStartPosition = 0;
+            string leadingMention = null;
+            if (Utils.HasMentionPrefix(message, ref matchStartPosition))
+            {
+                leadingMention = message.Substring(0, matchStartPosition);
+                message = message.Substring(matchStartPosition);
+            }
+
+            // Sort by specificity (ProxyString length desc = prefix+suffix length desc = inner message asc = more specific proxy first!)
+            var ordered = potentials.OrderByDescending(p => p.Member.ProxyString.Length);
+            foreach (var potential in ordered)
+            {
+                if (potential.Member.Prefix == null && potential.Member.Suffix == null) continue;
+                
+                var prefix = potential.Member.Prefix ?? "";
+                var suffix = potential.Member.Suffix ?? "";
+
+                if (message.StartsWith(prefix) && message.EndsWith(suffix)) {
+                    var inner = message.Substring(prefix.Length, message.Length - prefix.Length - suffix.Length);
+                    if (leadingMention != null) inner = $"{leadingMention} {inner}";
+                    return new ProxyMatch { Member = potential.Member, System = potential.System, InnerText = inner };
+                }
+            }
+            
+            return null;
+        }
+
+        public async Task HandleMessageAsync(IMessage message)
+        {
+            IEnumerable<ProxyDatabaseResult> results;
+            using (var conn = await _conn.Obtain())
+            {
+                results = await conn.QueryAsync<PKMember, PKSystem, ProxyDatabaseResult>(
+                    "select members.*, systems.* from members, systems, accounts where members.system = systems.id and accounts.system = systems.id and accounts.uid = @Uid",
+                    (member, system) =>
+                        new ProxyDatabaseResult {Member = member, System = system}, new {Uid = message.Author.Id});
+            }
+
+            // Find a member with proxy tags matching the message
+            var match = GetProxyTagMatch(message.Content, results);
+            if (match == null) return;
+
+            // We know message.Channel can only be ITextChannel as PK doesn't work in DMs/groups
+            // Afterwards we ensure the bot has the right permissions, otherwise bail early
+            if (!await EnsureBotPermissions(message.Channel as ITextChannel)) return;
+
+            // Fetch a webhook for this channel, and send the proxied message
+            var webhook = await _webhookCache.GetWebhook(message.Channel as ITextChannel);
+            var hookMessage = await ExecuteWebhook(webhook, match.InnerText, match.ProxyName, match.Member.AvatarUrl, message.Attachments.FirstOrDefault());
+
+            // Store the message in the database, and log it in the log channel (if applicable)
+            await _messageStorage.Store(message.Author.Id, hookMessage.Id, hookMessage.Channel.Id, match.Member);
+            await _logger.LogMessage(match.System, match.Member, hookMessage, message.Author);
+
+            // Wait a second or so before deleting the original message
+            await Task.Delay(1000);
+            await message.DeleteAsync();
+        }
+
+        private async Task<bool> EnsureBotPermissions(ITextChannel channel)
+        {
+            var guildUser = await channel.Guild.GetCurrentUserAsync();
+            var permissions = guildUser.GetPermissions(channel);
+
+            if (!permissions.ManageWebhooks)
+            {
+                await channel.SendMessageAsync(
+                    $"{Emojis.Error} PluralKit does not have the *Manage Webhooks* permission in this channel, and thus cannot proxy messages. Please contact a server administrator to remedy this.");
+                return false;
+            }
+            
+            if (!permissions.ManageMessages)
+            {
+                await channel.SendMessageAsync(
+                    $"{Emojis.Error} PluralKit does not have the *Manage Messages* permission in this channel, and thus cannot delete the original trigger message. Please contact a server administrator to remedy this.");
+                return false;
+            }
+
+            return true;
+        }
+
+        private async Task<IMessage> ExecuteWebhook(IWebhook webhook, string text, string username, string avatarUrl, IAttachment attachment)
+        {
+            username = FixClyde(username);
+            
+            // TODO: DiscordWebhookClient's ctor does a call to GetWebhook that may be unnecessary, see if there's a way to do this The Hard Way :tm:
+            // TODO: this will probably crash if there are multiple consecutive failures, perhaps have a loop instead?
+            DiscordWebhookClient client;
+            try
+            {
+                client = new DiscordWebhookClient(webhook);
+            }
+            catch (InvalidOperationException)
+            {
+                // webhook was deleted or invalid
+                webhook = await _webhookCache.InvalidateAndRefreshWebhook(webhook);
+                client = new DiscordWebhookClient(webhook);
+            }
+
+            ulong messageId;
+            if (attachment != null) {
+                using (var http = new HttpClient())
+                using (var stream = await http.GetStreamAsync(attachment.Url)) {
+                    messageId = await client.SendFileAsync(stream, filename: attachment.Filename, text: text, username: username, avatarUrl: avatarUrl);
+                }
+            } else {
+                messageId = await client.SendMessageAsync(text, username: username, avatarUrl: avatarUrl);
+            }
+            
+            // TODO: SendMessageAsync should return a full object(??), see if there's a way to avoid the extra server call here
+            return await webhook.Channel.GetMessageAsync(messageId);
+        }
+
+        public Task HandleReactionAddedAsync(Cacheable<IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
+        {
+            // Dispatch on emoji
+            switch (reaction.Emote.Name)
+            {
+                case "\u274C": // Red X
+                    return HandleMessageDeletionByReaction(message, reaction.UserId);
+                case "\u2753": // Red question mark
+                case "\u2754": // White question mark
+                    return HandleMessageQueryByReaction(message, reaction.UserId, reaction.Emote);
+                default:
+                    return Task.CompletedTask;
+            }
+        }
+
+        private async Task HandleMessageQueryByReaction(Cacheable<IUserMessage, ulong> message, ulong userWhoReacted, IEmote reactedEmote)
+        {
+            // Find the user who sent the reaction, so we can DM them
+            var user = await _client.GetUserAsync(userWhoReacted);
+            if (user == null) return;
+
+            // Find the message in the DB
+            var msg = await _messageStorage.Get(message.Id);
+            if (msg == null) return;
+            
+            // DM them the message card
+            await user.SendMessageAsync(embed: await _embeds.CreateMessageInfoEmbed(msg));
+            
+            // And finally remove the original reaction (if we can)
+            var msgObj = await message.GetOrDownloadAsync();
+            if (await msgObj.Channel.HasPermission(ChannelPermission.ManageMessages))
+                await msgObj.RemoveReactionAsync(reactedEmote, user);
+        }
+
+        public async Task HandleMessageDeletionByReaction(Cacheable<IUserMessage, ulong> message, ulong userWhoReacted)
+        {
+            // Find the message in the database
+            var storedMessage = await _messageStorage.Get(message.Id);
+            if (storedMessage == null) return; // (if we can't, that's ok, no worries)
+
+            // Make sure it's the actual sender of that message deleting the message
+            if (storedMessage.Message.Sender != userWhoReacted) return;
+
+            try {
+                // Then, fetch the Discord message and delete that
+                // TODO: this could be faster if we didn't bother fetching it and just deleted it directly
+                // somehow through REST?
+                await (await message.GetOrDownloadAsync()).DeleteAsync();
+            } catch (NullReferenceException) {
+                // Message was deleted before we got to it... cool, no problem, lmao
+            }
+
+            // Finally, delete it from our database.
+            await _messageStorage.Delete(message.Id);
+        }
+
+        public async Task HandleMessageDeletedAsync(Cacheable<IMessage, ulong> message, ISocketMessageChannel channel)
+        {
+            await _messageStorage.Delete(message.Id);
+        }
+
+        private string FixClyde(string name)
+        {
+            var match = Regex.Match(name, "clyde", RegexOptions.IgnoreCase);
+            if (!match.Success) return name;
+            
+            // Put a hair space (\u200A) between the "c" and the "lyde" in the match to avoid Discord matching it
+            // since Discord blocks webhooks containing the word "Clyde"... for some reason. /shrug
+            return name.Substring(0, match.Index + 1) + '\u200A' + name.Substring(match.Index + 1);
+        }
+    }
+}

PluralKit.Bot/Services/WebhookCacheService.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading.Tasks;
+using Discord;
+using Discord.WebSocket;
+
+namespace PluralKit.Bot
+{
+    public class WebhookCacheService
+    {
+        public static readonly string WebhookName = "PluralKit Proxy Webhook";
+            
+        private IDiscordClient _client;
+        private ConcurrentDictionary<ulong, Lazy<Task<IWebhook>>> _webhooks;
+
+        public WebhookCacheService(IDiscordClient client)
+        {
+            this._client = client;
+            _webhooks = new ConcurrentDictionary<ulong, Lazy<Task<IWebhook>>>();
+        }
+
+        public async Task<IWebhook> GetWebhook(ulong channelId)
+        {
+            var channel = await _client.GetChannelAsync(channelId) as ITextChannel;
+            if (channel == null) return null;
+            return await GetWebhook(channel);
+        }
+
+        public async Task<IWebhook> GetWebhook(ITextChannel channel)
+        {
+            // We cache the webhook through a Lazy<Task<T>>, this way we make sure to only create one webhook per channel
+            // If the webhook is requested twice before it's actually been found, the Lazy<T> wrapper will stop the
+            // webhook from being created twice.
+            var lazyWebhookValue =    
+                _webhooks.GetOrAdd(channel.Id, new Lazy<Task<IWebhook>>(() => GetOrCreateWebhook(channel)));
+            
+            // It's possible to "move" a webhook to a different channel after creation
+            // Here, we ensure it's actually still pointing towards the proper channel, and if not, wipe and refetch one.
+            var webhook = await lazyWebhookValue.Value;
+            if (webhook.Channel.Id != channel.Id) return await InvalidateAndRefreshWebhook(webhook);
+            return webhook;
+        }
+
+        public async Task<IWebhook> InvalidateAndRefreshWebhook(IWebhook webhook)
+        {
+            _webhooks.TryRemove(webhook.Channel.Id, out _);
+            return await GetWebhook(webhook.Channel.Id);
+        }
+
+        private async Task<IWebhook> GetOrCreateWebhook(ITextChannel channel) =>
+            await FindExistingWebhook(channel) ?? await DoCreateWebhook(channel);
+
+        private async Task<IWebhook> FindExistingWebhook(ITextChannel channel) => (await channel.GetWebhooksAsync()).FirstOrDefault(IsWebhookMine);
+        
+        private async Task<IWebhook> DoCreateWebhook(ITextChannel channel) => await channel.CreateWebhookAsync(WebhookName);
+        private bool IsWebhookMine(IWebhook arg) => arg.Creator.Id == _client.CurrentUser.Id && arg.Name == WebhookName;
+    }
+}

PluralKit.Bot/Utils.cs

@@ -0,0 +1,251 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Globalization;
+using System.Linq;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Dapper;
+using Discord;
+using Discord.Commands;
+using Discord.Commands.Builders;
+using Discord.WebSocket;
+using Microsoft.Extensions.DependencyInjection;
+using NodaTime;
+using PluralKit.Core;
+using Image = SixLabors.ImageSharp.Image;
+
+namespace PluralKit.Bot
+{
+    public static class Utils {
+        public static string NameAndMention(this IUser user) {
+            return $"{user.Username}#{user.Discriminator} ({user.Mention})";
+        }
+
+        public static Color? ToDiscordColor(this string color)
+        {
+            if (uint.TryParse(color, NumberStyles.HexNumber, null, out var colorInt))
+                return new Color(colorInt);
+            throw new ArgumentException($"Invalid color string '{color}'.");
+        }
+
+        public static async Task VerifyAvatarOrThrow(string url)
+        {
+            // List of MIME types we consider acceptable
+            var acceptableMimeTypes = new[]
+            {
+                "image/jpeg",
+                "image/gif",
+                "image/png"
+                // TODO: add image/webp once ImageSharp supports this
+            };
+
+            using (var client = new HttpClient())
+            {
+                Uri uri;
+                try
+                {
+                    uri = new Uri(url);
+                    if (!uri.IsAbsoluteUri) throw Errors.InvalidUrl(url);
+                }
+                catch (UriFormatException)
+                {
+                    throw Errors.InvalidUrl(url);
+                }
+                
+                var response = await client.GetAsync(uri);
+                if (!response.IsSuccessStatusCode) // Check status code
+                    throw Errors.AvatarServerError(response.StatusCode);
+                if (response.Content.Headers.ContentLength == null) // Check presence of content length
+                    throw Errors.AvatarNotAnImage(null);
+                if (response.Content.Headers.ContentLength > Limits.AvatarFileSizeLimit) // Check content length
+                    throw Errors.AvatarFileSizeLimit(response.Content.Headers.ContentLength.Value);
+                if (!acceptableMimeTypes.Contains(response.Content.Headers.ContentType.MediaType)) // Check MIME type
+                    throw Errors.AvatarNotAnImage(response.Content.Headers.ContentType.MediaType);
+
+                // Parse the image header in a worker
+                var stream = await response.Content.ReadAsStreamAsync();
+                var image = await Task.Run(() => Image.Identify(stream));
+                if (image.Width > Limits.AvatarDimensionLimit || image.Height > Limits.AvatarDimensionLimit) // Check image size 
+                    throw Errors.AvatarDimensionsTooLarge(image.Width, image.Height);
+            }
+        }
+        
+        public static bool HasMentionPrefix(string content, ref int argPos)
+        {
+            // Roughly ported from Discord.Commands.MessageExtensions.HasMentionPrefix
+            if (string.IsNullOrEmpty(content) || content.Length <= 3 || (content[0] != '<' || content[1] != '@'))
+                return false;
+            int num = content.IndexOf('>');
+            if (num == -1 || content.Length < num + 2 || content[num + 1] != ' ' || !MentionUtils.TryParseUser(content.Substring(0, num + 1), out _))
+                return false;
+            argPos = num + 2;
+            return true;
+        }
+
+        public static string Sanitize(this string input) =>
+            Regex.Replace(Regex.Replace(input, "<@[!&]?(\\d{17,19})>", "<\\@$1>"), "@(everyone|here)", "@\u200B$1");
+
+        public static async Task<ChannelPermissions> PermissionsIn(this IChannel channel)
+        {
+            switch (channel)
+            {
+                case IDMChannel _:
+                    return ChannelPermissions.DM;
+                case IGroupChannel _:
+                    return ChannelPermissions.Group;
+                case IGuildChannel gc:
+                    var currentUser = await gc.Guild.GetCurrentUserAsync();
+                    return currentUser.GetPermissions(gc);
+                default:
+                    return ChannelPermissions.None;
+            }
+        }
+
+        public static async Task<bool> HasPermission(this IChannel channel, ChannelPermission permission) =>
+            (await PermissionsIn(channel)).Has(permission);
+    }
+
+    class PKSystemTypeReader : TypeReader
+    {
+        public override async Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)
+        {
+            var client = services.GetService<IDiscordClient>();
+            var systems = services.GetService<SystemStore>();
+
+            // System references can take three forms:
+            // - The direct user ID of an account connected to the system
+            // - A @mention of an account connected to the system (<@uid>)
+            // - A system hid
+
+            // First, try direct user ID parsing
+            if (ulong.TryParse(input, out var idFromNumber)) return await FindSystemByAccountHelper(idFromNumber, client, systems);
+
+            // Then, try mention parsing.
+            if (MentionUtils.TryParseUser(input, out var idFromMention)) return await FindSystemByAccountHelper(idFromMention, client, systems);
+
+            // Finally, try HID parsing
+            var res = await systems.GetByHid(input);
+            if (res != null) return TypeReaderResult.FromSuccess(res);
+            return TypeReaderResult.FromError(CommandError.ObjectNotFound, $"System with ID `{input}` not found.");
+        }
+
+        async Task<TypeReaderResult> FindSystemByAccountHelper(ulong id, IDiscordClient client, SystemStore systems)
+        {
+            var foundByAccountId = await systems.GetByAccount(id);
+            if (foundByAccountId != null) return TypeReaderResult.FromSuccess(foundByAccountId);
+
+            // We didn't find any, so we try to resolve the user ID to find the associated account,
+            // so we can print their username.
+            var user = await client.GetUserAsync(id);
+
+            // Return descriptive errors based on whether we found the user or not.
+            if (user == null) return TypeReaderResult.FromError(CommandError.ObjectNotFound, $"System or account with ID `{id}` not found.");
+            return TypeReaderResult.FromError(CommandError.ObjectNotFound, $"Account **{user.Username}#{user.Discriminator}** not found.");
+        }
+    }
+
+    class PKMemberTypeReader : TypeReader
+    {
+        public override async Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)
+        {
+            var members = services.GetRequiredService<MemberStore>();
+
+            // If the sender of the command is in a system themselves,
+            // then try searching by the member's name
+            if (context is PKCommandContext ctx && ctx.SenderSystem != null)
+            {
+                var foundByName = await members.GetByName(ctx.SenderSystem, input);
+                if (foundByName != null) return TypeReaderResult.FromSuccess(foundByName);
+            }
+
+            // Otherwise, if sender isn't in a system, or no member found by that name,
+            // do a standard by-hid search.
+            var foundByHid = await members.GetByHid(input);
+            if (foundByHid != null) return TypeReaderResult.FromSuccess(foundByHid);
+            return TypeReaderResult.FromError(CommandError.ObjectNotFound, $"Member '{input}' not found.");
+        }
+    }
+
+    /// Subclass of ICommandContext with PK-specific additional fields and functionality
+    public class PKCommandContext : SocketCommandContext
+    {
+        public PKSystem SenderSystem { get; }
+        
+        private object _entity;
+
+        public PKCommandContext(DiscordSocketClient client, SocketUserMessage msg, PKSystem system) : base(client, msg)
+        {
+            SenderSystem = system;
+        }
+
+        public T GetContextEntity<T>() where T: class  {
+            return _entity as T;
+        }
+
+        public void SetContextEntity(object entity) {
+            _entity = entity;
+        }
+    }
+
+    public abstract class ContextParameterModuleBase<T> : ModuleBase<PKCommandContext> where T: class
+    {
+        public IServiceProvider _services { get; set; }
+        public CommandService _commands { get; set; }
+
+        public abstract string Prefix { get; }
+        public abstract string ContextNoun { get; }
+        public abstract Task<T> ReadContextParameterAsync(string value);
+
+        public T ContextEntity => Context.GetContextEntity<T>();
+
+        protected override void OnModuleBuilding(CommandService commandService, ModuleBuilder builder) {
+            // We create a catch-all command that intercepts the first argument, tries to parse it as
+            // the context parameter, then runs the command service AGAIN with that given in a wrapped
+            // context, with the context argument removed so it delegates to the subcommand executor
+            builder.AddCommand("", async (ctx, param, services, info) => {
+                var pkCtx = ctx as PKCommandContext;
+                pkCtx.SetContextEntity(param[0] as T);
+
+                await commandService.ExecuteAsync(pkCtx, Prefix + " " + param[1] as string, services);
+            }, (cb) => {
+                cb.WithPriority(-9999);
+                cb.AddPrecondition(new MustNotHaveContextPrecondition());
+                cb.AddParameter<T>("contextValue", (pb) => pb.WithDefault(""));
+                cb.AddParameter<string>("rest", (pb) => pb.WithDefault("").WithIsRemainder(true));
+            });
+        }
+    }
+
+    public class MustNotHaveContextPrecondition : PreconditionAttribute
+    {
+        public MustNotHaveContextPrecondition()
+        {
+        }
+
+        public override async Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services)
+        {
+            // This stops the "delegating command" we define above from being called multiple times
+            // If we've already added a context object to the context, then we'll return with the same
+            // error you get when there's an invalid command - it's like it didn't exist
+            // This makes sure the user gets the proper error, instead of the command trying to parse things weirdly
+            if ((context as PKCommandContext)?.GetContextEntity<object>() == null) return PreconditionResult.FromSuccess();
+            return PreconditionResult.FromError(command.Module.Service.Search("<unknown>"));
+        }
+    }
+
+    public class PKError : Exception
+    {
+        public PKError(string message) : base(message)
+        {
+        }
+    }
+
+    public class PKSyntaxError : PKError
+    {
+        public PKSyntaxError(string message) : base(message)
+        {
+        }
+    }
+}

PluralKit.Core/CoreConfig.cs

@@ -0,0 +1,7 @@
+namespace PluralKit
+{
+    public class CoreConfig
+    {
+        public string Database { get; set; }
+    }
+}

PluralKit.Core/DataFiles.cs

@@ -0,0 +1,276 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using NodaTime;
+using NodaTime.Text;
+
+namespace PluralKit.Bot
+{
+    public class DataFileService
+    {
+        private SystemStore _systems;
+        private MemberStore _members;
+        private SwitchStore _switches;
+
+        public DataFileService(SystemStore systems, MemberStore members, SwitchStore switches)
+        {
+            _systems = systems;
+            _members = members;
+            _switches = switches;
+        }
+
+        public async Task<DataFileSystem> ExportSystem(PKSystem system)
+        {
+            var members = new List<DataFileMember>();
+            foreach (var member in await _members.GetBySystem(system)) members.Add(await ExportMember(member));
+
+            var switches = new List<DataFileSwitch>();
+            foreach (var sw in await _switches.GetSwitches(system, 999999)) switches.Add(await ExportSwitch(sw));
+
+            return new DataFileSystem
+            {
+                Id = system.Hid,
+                Name = system.Name,
+                Description = system.Description,
+                Tag = system.Tag,
+                AvatarUrl = system.AvatarUrl,
+                TimeZone = system.UiTz,
+                Members = members,
+                Switches = switches,
+                Created = Formats.TimestampExportFormat.Format(system.Created),
+                LinkedAccounts = (await _systems.GetLinkedAccountIds(system)).ToList()
+            };
+        }
+
+        private async Task<DataFileMember> ExportMember(PKMember member) => new DataFileMember
+        {
+            Id = member.Hid,
+            Name = member.Name,
+            Description = member.Description,
+            Birthday = member.Birthday != null ? Formats.DateExportFormat.Format(member.Birthday.Value) : null,
+            Pronouns = member.Pronouns,
+            Color = member.Color,
+            AvatarUrl = member.AvatarUrl,
+            Prefix = member.Prefix,
+            Suffix = member.Suffix,
+            Created = Formats.TimestampExportFormat.Format(member.Created),
+            MessageCount = await _members.MessageCount(member)
+        };
+
+        private async Task<DataFileSwitch> ExportSwitch(PKSwitch sw) => new DataFileSwitch
+        {
+            Members = (await _switches.GetSwitchMembers(sw)).Select(m => m.Hid).ToList(),
+            Timestamp = Formats.TimestampExportFormat.Format(sw.Timestamp)
+        };
+
+        public async Task<ImportResult> ImportSystem(DataFileSystem data, PKSystem system, ulong accountId)
+        {
+            // TODO: make atomic, somehow - we'd need to obtain one IDbConnection and reuse it
+            // which probably means refactoring SystemStore.Save and friends etc
+            
+            var result = new ImportResult {AddedNames = new List<string>(), ModifiedNames = new List<string>()};
+
+            // If we don't already have a system to save to, create one
+            if (system == null) system = await _systems.Create(data.Name);
+
+            // Apply system info
+            system.Name = data.Name;
+            if (data.Description != null) system.Description = data.Description;
+            if (data.Tag != null) system.Tag = data.Tag;
+            if (data.AvatarUrl != null) system.AvatarUrl = data.AvatarUrl;
+            if (data.TimeZone != null) system.UiTz = data.TimeZone ?? "UTC";
+            await _systems.Save(system);
+            
+            // Make sure to link the sender account, too
+            await _systems.Link(system, accountId);
+
+            // Apply members
+            // TODO: parallelize?
+            foreach (var dataMember in data.Members)
+            {
+                // If member's given an ID, we try to look up the member with the given ID
+                PKMember member = null;
+                if (dataMember.Id != null)
+                {
+                    member = await _members.GetByHid(dataMember.Id);
+
+                    // ...but if it's a different system's member, we just make a new one anyway
+                    if (member != null && member.System != system.Id) member = null;
+                }
+
+                // Try to look up by name, too
+                if (member == null) member = await _members.GetByName(system, dataMember.Name);
+
+                // And if all else fails (eg. fresh import from Tupperbox, etc) we just make a member lol
+                if (member == null)
+                {
+                    member = await _members.Create(system, dataMember.Name);
+                    result.AddedNames.Add(dataMember.Name);
+                }
+                else
+                {
+                    result.ModifiedNames.Add(dataMember.Name);
+                }
+
+                // Apply member info
+                member.Name = dataMember.Name;
+                if (dataMember.Description != null) member.Description = dataMember.Description;
+                if (dataMember.Color != null) member.Color = dataMember.Color;
+                if (dataMember.AvatarUrl != null) member.AvatarUrl = dataMember.AvatarUrl;
+                if (dataMember.Prefix != null || dataMember.Suffix != null)
+                {
+                    member.Prefix = dataMember.Prefix;
+                    member.Suffix = dataMember.Suffix;
+                }
+
+                if (dataMember.Birthday != null)
+                {
+                    var birthdayParse = Formats.DateExportFormat.Parse(dataMember.Birthday);
+                    member.Birthday = birthdayParse.Success ? (LocalDate?) birthdayParse.Value : null;
+                }
+
+                await _members.Save(member);
+            }
+
+            // TODO: import switches, too?
+
+            result.System = system;
+            return result;
+        }
+    }
+
+    public struct ImportResult
+    {
+        public ICollection<string> AddedNames;
+        public ICollection<string> ModifiedNames;
+        public PKSystem System;
+    }
+
+    public struct DataFileSystem
+    {
+        [JsonProperty("id")] public string Id;
+        [JsonProperty("name")] public string Name;
+        [JsonProperty("description")] public string Description;
+        [JsonProperty("tag")] public string Tag;
+        [JsonProperty("avatar_url")] public string AvatarUrl;
+        [JsonProperty("timezone")] public string TimeZone;
+        [JsonProperty("members")] public ICollection<DataFileMember> Members;
+        [JsonProperty("switches")] public ICollection<DataFileSwitch> Switches;
+        [JsonProperty("accounts")] public ICollection<ulong> LinkedAccounts;
+        [JsonProperty("created")] public string Created;
+
+        private bool TimeZoneValid => TimeZone == null || DateTimeZoneProviders.Tzdb.GetZoneOrNull(TimeZone) != null;
+
+        [JsonIgnore] public bool Valid => TimeZoneValid && Members != null && Members.All(m => m.Valid);
+    }
+
+    public struct DataFileMember
+    {
+        [JsonProperty("id")] public string Id;
+        [JsonProperty("name")] public string Name;
+        [JsonProperty("description")] public string Description;
+        [JsonProperty("birthday")] public string Birthday;
+        [JsonProperty("pronouns")] public string Pronouns;
+        [JsonProperty("color")] public string Color;
+        [JsonProperty("avatar_url")] public string AvatarUrl;
+        [JsonProperty("prefix")] public string Prefix;
+        [JsonProperty("suffix")] public string Suffix;
+        [JsonProperty("message_count")] public int MessageCount;
+        [JsonProperty("created")] public string Created;
+
+        [JsonIgnore] public bool Valid => Name != null;
+    }
+
+    public struct DataFileSwitch
+    {
+        [JsonProperty("timestamp")] public string Timestamp;
+        [JsonProperty("members")] public ICollection<string> Members;
+    }
+
+    public struct TupperboxConversionResult
+    {
+        public bool HadGroups;
+        public bool HadIndividualTags;
+        public bool HadMultibrackets;
+        public DataFileSystem System;
+    }
+
+    public struct TupperboxProfile
+    {
+        [JsonProperty("tuppers")] public ICollection<TupperboxTupper> Tuppers;
+        [JsonProperty("groups")] public ICollection<TupperboxGroup> Groups;
+
+        [JsonIgnore] public bool Valid => Tuppers != null && Groups != null && Tuppers.All(t => t.Valid) && Groups.All(g => g.Valid);
+
+        public TupperboxConversionResult ToPluralKit()
+        {
+            // Set by member conversion function
+            string lastSetTag = null;
+            
+            TupperboxConversionResult output = default(TupperboxConversionResult);
+            
+            output.System = new DataFileSystem
+            {
+                Members = Tuppers.Select(t => t.ToPluralKit(ref lastSetTag, ref output.HadMultibrackets,
+                    ref output.HadGroups, ref output.HadMultibrackets)).ToList(),
+                
+                // If we haven't had multiple tags set, use the last (and only) one we set as the system tag
+                Tag = !output.HadIndividualTags ? lastSetTag : null
+            };
+            return output;
+        }
+    }
+
+    public struct TupperboxTupper
+    {
+        [JsonProperty("name")] public string Name;
+        [JsonProperty("avatar_url")] public string AvatarUrl;
+        [JsonProperty("brackets")] public ICollection<string> Brackets;
+        [JsonProperty("posts")] public int Posts; // Not supported by PK
+        [JsonProperty("show_brackets")] public bool ShowBrackets; // Not supported by PK
+        [JsonProperty("birthday")] public string Birthday;
+        [JsonProperty("description")] public string Description;
+        [JsonProperty("tag")] public string Tag; // Not supported by PK
+        [JsonProperty("group_id")] public string GroupId; // Not supported by PK
+        [JsonProperty("group_pos")] public int? GroupPos; // Not supported by PK
+
+        [JsonIgnore] public bool Valid => Name != null && Brackets != null && Brackets.Count % 2 == 0;
+
+        public DataFileMember ToPluralKit(ref string lastSetTag, ref bool multipleTags, ref bool hasGroup, ref bool hasMultiBrackets)
+        {
+            // If we've set a tag before and it's not the same as this one,
+            // then we have multiple unique tags and we pass that flag back to the caller
+            if (Tag != null && lastSetTag != null && lastSetTag != Tag) multipleTags = true;
+            lastSetTag = Tag;
+
+            // If this member is in a group, we have a (used) group and we flag that
+            if (GroupId != null) hasGroup = true;
+
+            // Brackets in Tupperbox format are arranged as a single array
+            // [prefix1, suffix1, prefix2, suffix2, prefix3... etc]
+            // If there are more than two entries this member has multiple brackets and we flag that
+            if (Brackets.Count > 2) hasMultiBrackets = true;
+
+            return new DataFileMember
+            {
+                Name = Name,
+                AvatarUrl = AvatarUrl,
+                Birthday = Birthday,
+                Description = Description,
+                Prefix = Brackets.FirstOrDefault(),
+                Suffix = Brackets.Skip(1).FirstOrDefault() // TODO: can Tupperbox members have no proxies at all?
+            };
+        }
+    }
+
+    public struct TupperboxGroup
+    {
+        [JsonProperty("id")] public int Id;
+        [JsonProperty("name")] public string Name;
+        [JsonProperty("description")] public string Description;
+        [JsonProperty("tag")] public string Tag;
+
+        [JsonIgnore] public bool Valid => true;
+    }
+}

PluralKit.Core/Limits.cs

@@ -0,0 +1,12 @@
+namespace PluralKit.Core {
+    public static class Limits {
+        public static readonly int MaxSystemNameLength = 100;
+        public static readonly int MaxSystemTagLength = 31;
+        public static readonly int MaxDescriptionLength = 1000;
+        public static readonly int MaxMemberNameLength = 50;
+        public static readonly int MaxPronounsLength = 100;
+
+        public static readonly long AvatarFileSizeLimit = 1024 * 1024;
+        public static readonly int AvatarDimensionLimit = 1000;
+    }
+}

PluralKit.Core/Models.cs

@@ -0,0 +1,70 @@
+using Dapper.Contrib.Extensions;
+using Newtonsoft.Json;
+using NodaTime;
+using NodaTime.Text;
+
+namespace PluralKit
+{
+    public class PKSystem
+    {
+        [Key] [JsonIgnore] public int Id { get; set; }
+        [JsonProperty("id")] public string Hid { get; set; }
+        [JsonProperty("name")] public string Name { get; set; }
+        [JsonProperty("description")] public string Description { get; set; }
+        [JsonProperty("tag")] public string Tag { get; set; }
+        [JsonProperty("avatar_url")] public string AvatarUrl { get; set; }
+        [JsonIgnore] public string Token { get; set; }
+        [JsonProperty("created")] public Instant Created { get; set; }
+        [JsonProperty("tz")] public string UiTz { get; set; }
+
+        [JsonIgnore] public int MaxMemberNameLength => Tag != null ? 32 - Tag.Length - 1 : 32;
+
+        [JsonIgnore] public DateTimeZone Zone => DateTimeZoneProviders.Tzdb.GetZoneOrNull(UiTz);
+    }
+
+    public class PKMember
+    {
+        [JsonIgnore] public int Id { get; set; }
+        [JsonProperty("id")] public string Hid { get; set; }
+        [JsonIgnore] public int System { get; set; }
+        [JsonProperty("color")] public string Color { get; set; }
+        [JsonProperty("avatar_url")] public string AvatarUrl { get; set; }
+        [JsonProperty("name")] public string Name { get; set; }
+        [JsonProperty("birthday")] public LocalDate? Birthday { get; set; }
+        [JsonProperty("pronouns")] public string Pronouns { get; set; }
+        [JsonProperty("description")] public string Description { get; set; }
+        [JsonProperty("prefix")] public string Prefix { get; set; }
+        [JsonProperty("suffix")] public string Suffix { get; set; }
+        [JsonProperty("created")] public Instant Created { get; set; }
+
+        /// Returns a formatted string representing the member's birthday, taking into account that a year of "0001" is hidden
+        [JsonIgnore] public string BirthdayString
+        {
+            get
+            {
+                if (Birthday == null) return null;
+
+                var format = LocalDatePattern.CreateWithInvariantCulture("MMM dd, yyyy");
+                if (Birthday?.Year == 1) format = LocalDatePattern.CreateWithInvariantCulture("MMM dd");
+                return format.Format(Birthday.Value);
+            }
+        }
+
+        [JsonIgnore] public bool HasProxyTags => Prefix != null || Suffix != null;
+        [JsonIgnore] public string ProxyString => $"{Prefix ?? ""}text{Suffix ?? ""}";
+    }
+
+    public class PKSwitch
+    {
+        public int Id { get; set; }
+        public int System { get; set; }
+        public Instant Timestamp { get; set; }
+    }
+
+    public class PKSwitchMember
+    {
+        public int Id { get; set; }
+        public int Switch { get; set; }
+        public int Member { get; set; }
+    }
+}

PluralKit.Core/PluralKit.Core.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp2.2</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Dapper" Version="1.60.6" />
+      <PackageReference Include="Dapper.Contrib" Version="1.60.1" />
+      <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.2.0" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="2.2.4" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="2.2.0" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="2.2.4" />
+      <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.2.0" />
+      <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
+      <PackageReference Include="NodaTime" Version="3.0.0-alpha01" />
+      <PackageReference Include="NodaTime.Serialization.JsonNet" Version="2.2.0" />
+      <PackageReference Include="Npgsql" Version="4.0.6" />
+      <PackageReference Include="Npgsql.NodaTime" Version="4.0.6" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Remove="db_schema.sql" />
+      <EmbeddedResource Include="db_schema.sql" />
+    </ItemGroup>
+
+</Project>

PluralKit.Core/Schema.cs

@@ -0,0 +1,19 @@
+using System.Data;
+using System.IO;
+using System.Threading.Tasks;
+using Dapper;
+
+namespace PluralKit {
+    public static class Schema {
+        public static async Task CreateTables(IDbConnection connection)
+        {
+            // Load the schema from disk (well, embedded resource) and execute the commands in there
+            using (var stream = typeof(Schema).Assembly.GetManifestResourceStream("PluralKit.Core.db_schema.sql"))
+            using (var reader = new StreamReader(stream))
+            {
+                var result = await reader.ReadToEndAsync();
+                await connection.ExecuteAsync(result);
+            }
+        }
+    }
+}

PluralKit.Core/Stores.cs

@@ -0,0 +1,330 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using Dapper;
+using Dapper.Contrib.Extensions;
+using NodaTime;
+
+namespace PluralKit {
+    public class SystemStore {
+        private DbConnectionFactory _conn;
+
+        public SystemStore(DbConnectionFactory conn) {
+            this._conn = conn;
+        }
+        
+        public async Task<PKSystem> Create(string systemName = null) {
+            // TODO: handle HID collision case
+            var hid = Utils.GenerateHid();
+            
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleAsync<PKSystem>("insert into systems (hid, name) values (@Hid, @Name) returning *", new { Hid = hid, Name = systemName });
+        }
+
+        public async Task Link(PKSystem system, ulong accountId) {
+            // We have "on conflict do nothing" since linking an account when it's already linked to the same system is idempotent
+            // This is used in import/export, although the pk;link command checks for this case beforehand
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("insert into accounts (uid, system) values (@Id, @SystemId) on conflict do nothing", new { Id = accountId, SystemId = system.Id });
+        }
+        
+        public async Task Unlink(PKSystem system, ulong accountId) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("delete from accounts where uid = @Id and system = @SystemId", new { Id = accountId, SystemId = system.Id });
+        }
+
+        public async Task<PKSystem> GetByAccount(ulong accountId) {
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleOrDefaultAsync<PKSystem>("select systems.* from systems, accounts where accounts.system = systems.id and accounts.uid = @Id", new { Id = accountId });
+        }
+
+        public async Task<PKSystem> GetByHid(string hid) {
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleOrDefaultAsync<PKSystem>("select * from systems where systems.hid = @Hid", new { Hid = hid.ToLower() });
+        }
+
+        public async Task<PKSystem> GetByToken(string token) {
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleOrDefaultAsync<PKSystem>("select * from systems where token = @Token", new { Token = token });
+        }
+        
+        public async Task<PKSystem> GetById(int id)
+        {
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleOrDefaultAsync<PKSystem>("select * from systems where id = @Id", new { Id = id });
+        }
+
+        public async Task Save(PKSystem system) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("update systems set name = @Name, description = @Description, tag = @Tag, avatar_url = @AvatarUrl, token = @Token, ui_tz = @UiTz where id = @Id", system);
+        }
+
+        public async Task Delete(PKSystem system) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("delete from systems where id = @Id", system);
+        }        
+
+        public async Task<IEnumerable<ulong>> GetLinkedAccountIds(PKSystem system)
+        {
+            using (var conn = await _conn.Obtain())
+                return await conn.QueryAsync<ulong>("select uid from accounts where system = @Id", new { Id = system.Id });
+        }
+    }
+
+    public class MemberStore {
+        private DbConnectionFactory _conn;
+
+        public MemberStore(DbConnectionFactory conn) {
+            this._conn = conn;
+        }
+
+        public async Task<PKMember> Create(PKSystem system, string name) {
+            // TODO: handle collision
+            var hid = Utils.GenerateHid();
+            
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleAsync<PKMember>("insert into members (hid, system, name) values (@Hid, @SystemId, @Name) returning *", new {
+                    Hid = hid,
+                    SystemID = system.Id,
+                    Name = name
+                });
+        }
+
+        public async Task<PKMember> GetByHid(string hid) {
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleOrDefaultAsync<PKMember>("select * from members where hid = @Hid", new { Hid = hid.ToLower() });
+        }
+
+        public async Task<PKMember> GetByName(PKSystem system, string name) {
+            // QueryFirst, since members can (in rare cases) share names
+            using (var conn = await _conn.Obtain())
+                return await conn.QueryFirstOrDefaultAsync<PKMember>("select * from members where lower(name) = lower(@Name) and system = @SystemID", new { Name = name, SystemID = system.Id });
+        }
+
+        public async Task<ICollection<PKMember>> GetUnproxyableMembers(PKSystem system) {
+            return (await GetBySystem(system))
+                .Where((m) => {
+                    var proxiedName = $"{m.Name} {system.Tag}";
+                    return proxiedName.Length > 32 || proxiedName.Length < 2;
+                }).ToList();
+        }
+
+        public async Task<IEnumerable<PKMember>> GetBySystem(PKSystem system) {
+            using (var conn = await _conn.Obtain())
+                return await conn.QueryAsync<PKMember>("select * from members where system = @SystemID", new { SystemID = system.Id });
+        }
+
+        public async Task Save(PKMember member) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("update members set name = @Name, description = @Description, color = @Color, avatar_url = @AvatarUrl, birthday = @Birthday, pronouns = @Pronouns, prefix = @Prefix, suffix = @Suffix where id = @Id", member);
+        }
+
+        public async Task Delete(PKMember member) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("delete from members where id = @Id", member);
+        }
+
+        public async Task<int> MessageCount(PKMember member)
+        {
+            using (var conn = await _conn.Obtain())
+                return await conn.QuerySingleAsync<int>("select count(*) from messages where member = @Id", member);
+        }
+    }
+
+    public class MessageStore {
+        public struct PKMessage
+        {
+            public ulong Mid;
+            public ulong Channel;
+            public ulong Sender;
+        }
+        public class StoredMessage
+        {
+            public PKMessage Message;
+            public PKMember Member;
+            public PKSystem System;
+        }
+
+        private DbConnectionFactory _conn;
+
+        public MessageStore(DbConnectionFactory conn) {
+            this._conn = conn;
+        }
+
+        public async Task Store(ulong senderId, ulong messageId, ulong channelId, PKMember member) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("insert into messages(mid, channel, member, sender) values(@MessageId, @ChannelId, @MemberId, @SenderId)", new {
+                    MessageId = messageId,
+                    ChannelId = channelId,
+                    MemberId = member.Id,
+                    SenderId = senderId
+                });      
+        }
+
+        public async Task<StoredMessage> Get(ulong id)
+        {
+            using (var conn = await _conn.Obtain())
+                return (await conn.QueryAsync<PKMessage, PKMember, PKSystem, StoredMessage>("select messages.*, members.*, systems.* from messages, members, systems where mid = @Id and messages.member = members.id and systems.id = members.system", (msg, member, system) => new StoredMessage
+                {
+                    Message = msg,
+                    System = system,
+                    Member = member
+                }, new { Id = id })).FirstOrDefault();
+        }
+        
+        public async Task Delete(ulong id) {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("delete from messages where mid = @Id", new { Id = id });
+        }
+    }
+
+    public class SwitchStore
+    {
+        private DbConnectionFactory _conn;
+
+        public SwitchStore(DbConnectionFactory conn)
+        {
+            _conn = conn;
+        }
+
+        public async Task RegisterSwitch(PKSystem system, IEnumerable<PKMember> members)
+        {
+            // Use a transaction here since we're doing multiple executed commands in one
+            using (var conn = await _conn.Obtain())
+            using (var tx = conn.BeginTransaction())
+            {
+                // First, we insert the switch itself
+                var sw = await conn.QuerySingleAsync<PKSwitch>("insert into switches(system) values (@System) returning *",
+                    new {System = system.Id});
+                
+                // Then we insert each member in the switch in the switch_members table
+                // TODO: can we parallelize this or send it in bulk somehow?
+                foreach (var member in members)
+                {
+                    await conn.ExecuteAsync(
+                        "insert into switch_members(switch, member) values(@Switch, @Member)",
+                        new {Switch = sw.Id, Member = member.Id});
+                }
+                
+                // Finally we commit the tx, since the using block will otherwise rollback it
+                tx.Commit();
+            }
+        }
+
+        public async Task<IEnumerable<PKSwitch>> GetSwitches(PKSystem system, int count = 9999999)
+        {
+            // TODO: refactor the PKSwitch data structure to somehow include a hydrated member list
+            // (maybe when we get caching in?)
+            using (var conn = await _conn.Obtain())
+                return await conn.QueryAsync<PKSwitch>("select * from switches where system = @System order by timestamp desc limit @Count", new {System = system.Id, Count = count});
+        }
+
+        public async Task<IEnumerable<int>> GetSwitchMemberIds(PKSwitch sw)
+        {
+            using (var conn = await _conn.Obtain())
+                return await conn.QueryAsync<int>("select member from switch_members where switch = @Switch order by switch_members.id",
+                    new {Switch = sw.Id});
+        }
+        
+        public async Task<IEnumerable<PKMember>> GetSwitchMembers(PKSwitch sw)
+        {
+            using (var conn = await _conn.Obtain())
+                return await conn.QueryAsync<PKMember>(
+                    "select * from switch_members, members where switch_members.member = members.id and switch_members.switch = @Switch order by switch_members.id",
+                    new {Switch = sw.Id});
+        }
+
+        public async Task<PKSwitch> GetLatestSwitch(PKSystem system) => (await GetSwitches(system, 1)).FirstOrDefault();
+
+        public async Task MoveSwitch(PKSwitch sw, Instant time)
+        {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("update switches set timestamp = @Time where id = @Id",
+                    new {Time = time, Id = sw.Id});
+        }
+
+        public async Task DeleteSwitch(PKSwitch sw)
+        {
+            using (var conn = await _conn.Obtain())
+                await conn.ExecuteAsync("delete from switches where id = @Id", new {Id = sw.Id});
+        }
+        
+        public struct SwitchListEntry
+        {
+            public ICollection<PKMember> Members;
+            public Duration TimespanWithinRange;
+        }
+
+        public async Task<IEnumerable<SwitchListEntry>> GetTruncatedSwitchList(PKSystem system, Instant periodStart, Instant periodEnd)
+        {
+            // TODO: only fetch the necessary switches here
+            // todo: this is in general not very efficient LOL
+            // returns switches in chronological (newest first) order
+            var switches = await GetSwitches(system);
+            
+            // we skip all switches that happened later than the range end, and taking all the ones that happened after the range start
+            // *BUT ALSO INCLUDING* the last switch *before* the range (that partially overlaps the range period)
+            var switchesInRange = switches.SkipWhile(sw => sw.Timestamp >= periodEnd).TakeWhileIncluding(sw => sw.Timestamp > periodStart).ToList();
+
+            // query DB for all members involved in any of the switches above and collect into a dictionary for future use
+            // this makes sure the return list has the same instances of PKMember throughout, which is important for the dictionary
+            // key used in GetPerMemberSwitchDuration below
+            Dictionary<int, PKMember> memberObjects;
+            using (var conn = await _conn.Obtain())
+            {
+                memberObjects = (await conn.QueryAsync<PKMember>(
+                        "select distinct members.* from members, switch_members where switch_members.switch = any(@Switches) and switch_members.member = members.id", // lol postgres specific `= any()` syntax
+                        new {Switches = switchesInRange.Select(sw => sw.Id).ToList()}))
+                    .ToDictionary(m => m.Id);
+            }
+
+
+            // we create the entry objects
+            var outList = new List<SwitchListEntry>();
+
+            // loop through every switch that *occurred* in-range and add it to the list
+            // end time is the switch *after*'s timestamp - we cheat and start it out at the range end so the first switch in-range "ends" there instead of the one after's start point
+            var endTime = periodEnd;
+            foreach (var switchInRange in switchesInRange)
+            {
+                // find the start time of the switch, but clamp it to the range (only applicable to the Last Switch Before Range we include in the TakeWhileIncluding call above)
+                var switchStartClamped = switchInRange.Timestamp;
+                if (switchStartClamped < periodStart) switchStartClamped = periodStart;
+                
+                var span = endTime - switchStartClamped;
+                outList.Add(new SwitchListEntry
+                {
+                    Members = (await GetSwitchMemberIds(switchInRange)).Select(id => memberObjects[id]).ToList(),
+                    TimespanWithinRange = span
+                });
+                
+                // next switch's end is this switch's start
+                endTime = switchInRange.Timestamp;
+            }
+
+            return outList;
+        }
+
+        public async Task<IDictionary<PKMember, Duration>> GetPerMemberSwitchDuration(PKSystem system, Instant periodStart,
+            Instant periodEnd)
+        {
+            var dict = new Dictionary<PKMember, Duration>();
+            
+            // Sum up all switch durations for each member
+            // switches with multiple members will result in the duration to add up to more than the actual period range
+            foreach (var sw in await GetTruncatedSwitchList(system, periodStart, periodEnd))
+            {
+                foreach (var member in sw.Members)
+                {
+                    if (!dict.ContainsKey(member)) dict.Add(member, sw.TimespanWithinRange);
+                    else dict[member] += sw.TimespanWithinRange;
+                }
+            }
+            
+            return dict;
+        }
+    }
+}

PluralKit.Core/TaskUtils.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PluralKit {
+    public static class TaskUtils {
+        public static async Task CatchException(this Task task, Action<Exception> handler) {
+            try {
+                await task;
+            } catch (Exception e) {
+                handler(e);
+            }
+        }
+        
+        public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan? timeout) {
+            // https://stackoverflow.com/a/22078975
+            using (var timeoutCancellationTokenSource = new CancellationTokenSource()) {
+                var completedTask = await Task.WhenAny(task, Task.Delay(timeout ?? TimeSpan.FromMilliseconds(-1), timeoutCancellationTokenSource.Token));
+                if (completedTask == task) {
+                    timeoutCancellationTokenSource.Cancel();
+                    return await task;  // Very important in order to propagate exceptions
+                } else {
+                    throw new TimeoutException();
+                }
+            }
+        }
+    }
+}

PluralKit.Core/Utils.cs

@@ -0,0 +1,354 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Dapper;
+using Microsoft.Extensions.Configuration;
+using Newtonsoft.Json;
+using NodaTime;
+using NodaTime.Serialization.JsonNet;
+using NodaTime.Text;
+using Npgsql;
+
+
+namespace PluralKit
+{
+    public static class Utils
+    {
+        public static string GenerateHid()
+        {
+            var rnd = new Random();
+            var charset = "abcdefghijklmnopqrstuvwxyz";
+            string hid = "";
+            for (int i = 0; i < 5; i++)
+            {
+                hid += charset[rnd.Next(charset.Length)];
+            }
+            return hid;
+        }
+
+        public static string GenerateToken()
+        {
+            var buf = new byte[48]; // Results in a 64-byte Base64 string (no padding)
+            new RNGCryptoServiceProvider().GetBytes(buf);
+            return Convert.ToBase64String(buf);
+        }
+
+        public static string Truncate(this string str, int maxLength, string ellipsis = "...") {
+            if (str.Length < maxLength) return str;
+            return str.Substring(0, maxLength - ellipsis.Length) + ellipsis;
+        }
+
+        public static bool IsLongerThan(this string str, int length)
+        {
+            if (str != null) return str.Length > length;
+            return false;
+        }
+
+        public static Duration? ParsePeriod(string str)
+        {
+            
+            Duration d = Duration.Zero;
+            
+            foreach (Match match in Regex.Matches(str, "(\\d{1,6})(\\w)"))
+            {
+                var amount = int.Parse(match.Groups[1].Value);
+                var type = match.Groups[2].Value;
+
+                if (type == "w") d += Duration.FromDays(7) * amount;
+                else if (type == "d") d += Duration.FromDays(1) * amount;
+                else if (type == "h") d += Duration.FromHours(1) * amount;
+                else if (type == "m") d += Duration.FromMinutes(1) * amount;
+                else if (type == "s") d += Duration.FromSeconds(1) * amount;
+                else return null;
+            }
+
+            if (d == Duration.Zero) return null;
+            return d;
+        }
+
+        public static LocalDate? ParseDate(string str, bool allowNullYear = false)
+        {
+            // NodaTime can't parse constructs like "1st" and "2nd" so we quietly replace those away
+            // Gotta make sure to do the regex otherwise we'll catch things like the "st" in "August" too
+            str = Regex.Replace(str, "(\\d+)(st|nd|rd|th)", "$1");
+            
+            var patterns = new[]
+            {
+                "MMM d yyyy",   // Jan 1 2019
+                "MMM d, yyyy",  // Jan 1, 2019
+                "MMMM d yyyy",  // January 1 2019
+                "MMMM d, yyyy", // January 1, 2019
+                "yyyy-MM-dd",   // 2019-01-01
+                "yyyy MM dd",   // 2019 01 01
+                "yyyy/MM/dd"    // 2019/01/01
+            }.ToList();
+
+            if (allowNullYear) patterns.AddRange(new[]
+            {
+                "MMM d",        // Jan 1
+                "MMMM d",       // January 1
+                "MM-dd",        // 01-01
+                "MM dd",        // 01 01
+                "MM/dd"         // 01/01
+            });
+
+            // Giving a template value so year will be parsed as 0001 if not present
+            // This means we can later disambiguate whether a null year was given
+            // TODO: should we be using invariant culture here?
+            foreach (var pattern in patterns.Select(p => LocalDatePattern.CreateWithInvariantCulture(p).WithTemplateValue(new LocalDate(0001, 1, 1))))
+            {
+                var result = pattern.Parse(str);
+                if (result.Success) return result.Value;
+            }
+
+            return null;
+        }
+
+        public static ZonedDateTime? ParseDateTime(string str, bool nudgeToPast = false, DateTimeZone zone = null)
+        {
+            if (zone == null) zone = DateTimeZone.Utc;
+            
+            // Find the current timestamp in the given zone, find the (naive) midnight timestamp, then put that into the same zone (and make it naive again)
+            // Should yield a <current *local @ zone* date> 12:00:00 AM.
+            var now = SystemClock.Instance.GetCurrentInstant().InZone(zone).LocalDateTime;
+            var midnight = now.Date.AtMidnight();
+            
+            // First we try to parse the string as a relative time using the period parser
+            var relResult = ParsePeriod(str);
+            if (relResult != null)
+            {
+                // if we can, we just subtract that amount from the 
+                return now.InZoneLeniently(zone).Minus(relResult.Value);
+            }
+
+            var timePatterns = new[]
+            {
+                "H:mm",         // 4:30
+                "HH:mm",        // 23:30
+                "H:mm:ss",      // 4:30:29
+                "HH:mm:ss",     // 23:30:29
+                "h tt",         // 2 PM
+                "htt",          // 2PM
+                "h:mm tt",      // 4:30 PM
+                "h:mmtt",       // 4:30PM
+                "h:mm:ss tt",   // 4:30:29 PM
+                "h:mm:sstt",    // 4:30:29PM
+                "hh:mm tt",     // 11:30 PM
+                "hh:mmtt",      // 11:30PM
+                "hh:mm:ss tt",   // 11:30:29 PM
+                "hh:mm:sstt"   // 11:30:29PM
+            };
+
+            var datePatterns = new[]
+            {
+                "MMM d yyyy",   // Jan 1 2019
+                "MMM d, yyyy",  // Jan 1, 2019
+                "MMMM d yyyy",  // January 1 2019
+                "MMMM d, yyyy", // January 1, 2019
+                "yyyy-MM-dd",   // 2019-01-01
+                "yyyy MM dd",   // 2019 01 01
+                "yyyy/MM/dd",   // 2019/01/01
+                "MMM d",        // Jan 1
+                "MMMM d",       // January 1
+                "MM-dd",        // 01-01
+                "MM dd",        // 01 01
+                "MM/dd"         // 01-01
+            };
+            
+            // First, we try all the timestamps that only have a time
+            foreach (var timePattern in timePatterns)
+            {
+                var pat = LocalDateTimePattern.CreateWithInvariantCulture(timePattern).WithTemplateValue(midnight);
+                var result = pat.Parse(str);
+                if (result.Success)
+                {
+                    // If we have a successful match and we need a time in the past, we try to shove a future-time a date before
+                    // Example: "4:30 pm" at 3:30 pm likely refers to 4:30 pm the previous day
+                    var val = result.Value;
+                    
+                    // If we need to nudge, we just subtract a day. This only occurs when we're parsing specifically *just time*, so
+                    // we know we won't nudge it by more than a day since we use today's midnight timestamp as a date template.
+                    
+                    // Since this is a naive datetime, this ensures we're actually moving by one calendar day even if 
+                    // DST changes occur, since they'll be resolved later wrt. the right side of the boundary
+                    if (val > now && nudgeToPast) val = val.PlusDays(-1);
+                    return val.InZoneLeniently(zone);
+                }
+            }
+            
+            // Then we try specific date+time combinations, both date first and time first, with and without commas
+            foreach (var timePattern in timePatterns)
+            {
+                foreach (var datePattern in datePatterns)
+                {
+                    foreach (var patternStr in new[]
+                    {
+                        $"{timePattern}, {datePattern}", $"{datePattern}, {timePattern}",
+                        $"{timePattern} {datePattern}", $"{datePattern} {timePattern}"
+                    })
+                    {
+                        var pattern = LocalDateTimePattern.CreateWithInvariantCulture(patternStr).WithTemplateValue(midnight);
+                        var res = pattern.Parse(str);
+                        if (res.Success) return res.Value.InZoneLeniently(zone);
+                    }
+                }
+            }
+            
+            // Finally, just date patterns, still using midnight as the template
+            foreach (var datePattern in datePatterns)
+            {
+                var pat = LocalDateTimePattern.CreateWithInvariantCulture(datePattern).WithTemplateValue(midnight);
+                var res = pat.Parse(str);
+                if (res.Success) return res.Value.InZoneLeniently(zone);
+            }
+
+            // Still haven't parsed something, we just give up lmao
+            return null;
+        }
+        
+        public static string ExtractCountryFlag(string flag)
+        {
+            if (flag.Length != 4) return null;
+            try
+            {
+                var cp1 = char.ConvertToUtf32(flag, 0);
+                var cp2 = char.ConvertToUtf32(flag, 2);
+                if (cp1 < 0x1F1E6 || cp1 > 0x1F1FF) return null;
+                if (cp2 < 0x1F1E6 || cp2 > 0x1F1FF) return null;
+                return $"{(char) (cp1 - 0x1F1E6 + 'A')}{(char) (cp2 - 0x1F1E6 + 'A')}";
+            }
+            catch (ArgumentException)
+            {
+                return null;
+            }
+        }
+        
+        public static IEnumerable<T> TakeWhileIncluding<T>(this IEnumerable<T> list, Func<T, bool> predicate)
+        {
+            // modified from https://stackoverflow.com/a/6817553
+            foreach(var el in list)
+            {
+                yield return el;
+                if (!predicate(el))
+                    yield break;
+            }
+        }
+    }
+
+    public static class Emojis {
+        public static readonly string Warn = "\u26A0";
+        public static readonly string Success = "\u2705";
+        public static readonly string Error = "\u274C";
+        public static readonly string Note = "\u2757";
+        public static readonly string ThumbsUp = "\U0001f44d";
+        public static readonly string RedQuestion = "\u2753";
+    }
+
+    public static class Formats
+    {
+        public static IPattern<Instant> TimestampExportFormat = InstantPattern.CreateWithInvariantCulture("g");
+        public static IPattern<LocalDate> DateExportFormat = LocalDatePattern.CreateWithInvariantCulture("yyyy-MM-dd");
+        
+        // We create a composite pattern that only shows the two most significant things
+        // eg. if we have something with nonzero day component, we show <x>d <x>h, but if it's
+        // a smaller duration we may only bother with showing <x>h <x>m or <x>m <x>s
+        public static IPattern<Duration> DurationFormat = new CompositePatternBuilder<Duration>
+        {
+            {DurationPattern.CreateWithInvariantCulture("s's'"), d => true},
+            {DurationPattern.CreateWithInvariantCulture("m'm' s's'"), d => d.Minutes > 0},
+            {DurationPattern.CreateWithInvariantCulture("H'h' m'm'"), d => d.Hours > 0},
+            {DurationPattern.CreateWithInvariantCulture("D'd' h'h'"), d => d.Days > 0}
+        }.Build();
+        
+        public static IPattern<LocalDateTime> LocalDateTimeFormat = LocalDateTimePattern.CreateWithInvariantCulture("yyyy-MM-dd HH:mm:ss");
+        public static IPattern<ZonedDateTime> ZonedDateTimeFormat = ZonedDateTimePattern.CreateWithInvariantCulture("yyyy-MM-dd HH:mm:ss x", DateTimeZoneProviders.Tzdb);
+    }
+    public static class InitUtils
+    {
+        public static IConfigurationBuilder BuildConfiguration(string[] args) => new ConfigurationBuilder()
+            .SetBasePath(Directory.GetCurrentDirectory())
+            .AddJsonFile("pluralkit.conf", true)
+            .AddEnvironmentVariables()
+            .AddCommandLine(args);
+
+        public static void Init()
+        {
+            InitDatabase();
+        }
+        
+        private static void InitDatabase()
+        {
+            // Dapper by default tries to pass ulongs to Npgsql, which rejects them since PostgreSQL technically
+            // doesn't support unsigned types on its own.
+            // Instead we add a custom mapper to encode them as signed integers instead, converting them back and forth.
+            SqlMapper.RemoveTypeMap(typeof(ulong));
+            SqlMapper.AddTypeHandler<ulong>(new UlongEncodeAsLongHandler());
+            Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;
+
+            // Also, use NodaTime. it's good.
+            NpgsqlConnection.GlobalTypeMapper.UseNodaTime();
+            // With the thing we add above, Npgsql already handles NodaTime integration
+            // This makes Dapper confused since it thinks it has to convert it anyway and doesn't understand the types
+            // So we add a custom type handler that literally just passes the type through to Npgsql
+            SqlMapper.AddTypeHandler(new PassthroughTypeHandler<Instant>());
+            SqlMapper.AddTypeHandler(new PassthroughTypeHandler<LocalDate>());
+        }
+
+        public static JsonSerializerSettings BuildSerializerSettings() => new JsonSerializerSettings().BuildSerializerSettings();
+
+        public static JsonSerializerSettings BuildSerializerSettings(this JsonSerializerSettings settings)
+        {
+            settings.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
+            return settings;
+        }
+    }
+    
+    public class UlongEncodeAsLongHandler : SqlMapper.TypeHandler<ulong>
+    {
+        public override ulong Parse(object value)
+        {
+            // Cast to long to unbox, then to ulong (???)
+            return (ulong)(long)value;
+        }
+
+        public override void SetValue(IDbDataParameter parameter, ulong value)
+        {
+            parameter.Value = (long)value;
+        }
+    }
+
+    public class PassthroughTypeHandler<T> : SqlMapper.TypeHandler<T>
+    {
+        public override void SetValue(IDbDataParameter parameter, T value)
+        {
+            parameter.Value = value;
+        }
+
+        public override T Parse(object value)
+        {
+            return (T) value;
+        }
+    }
+    
+    public class DbConnectionFactory
+    {
+        private string _connectionString;
+
+        public DbConnectionFactory(string connectionString)
+        {
+            _connectionString = connectionString;
+        }
+
+        public async Task<IDbConnection> Obtain()
+        {
+            var conn = new NpgsqlConnection(_connectionString);
+            await conn.OpenAsync();
+            return conn;
+        }
+    }
+}

PluralKit.Core/db_schema.sql

@@ -0,0 +1,69 @@
+create table if not exists systems
+(
+    id          serial primary key,
+    hid         char(5) unique not null,
+    name        text,
+    description text,
+    tag         text,
+    avatar_url  text,
+    token       text,
+    created     timestamp      not null default (current_timestamp at time zone 'utc'),
+    ui_tz       text           not null default 'UTC'
+);
+
+create table if not exists members
+(
+    id          serial primary key,
+    hid         char(5) unique not null,
+    system      serial         not null references systems (id) on delete cascade,
+    color       char(6),
+    avatar_url  text,
+    name        text           not null,
+    birthday    date,
+    pronouns    text,
+    description text,
+    prefix      text,
+    suffix      text,
+    created     timestamp      not null default (current_timestamp at time zone 'utc')
+);
+
+create table if not exists accounts
+(
+    uid    bigint primary key,
+    system serial not null references systems (id) on delete cascade
+);
+
+create table if not exists messages
+(
+    mid     bigint primary key,
+    channel bigint not null,
+    member  serial not null references members (id) on delete cascade,
+    sender  bigint not null
+);
+
+create table if not exists switches
+(
+    id        serial primary key,
+    system    serial    not null references systems (id) on delete cascade,
+    timestamp timestamp not null default (current_timestamp at time zone 'utc')
+);
+
+create table if not exists switch_members
+(
+    id     serial primary key,
+    switch serial not null references switches (id) on delete cascade,
+    member serial not null references members (id) on delete cascade
+);
+
+create table if not exists webhooks
+(
+    channel bigint primary key,
+    webhook bigint not null,
+    token   text   not null
+);
+
+create table if not exists servers
+(
+    id          bigint primary key,
+    log_channel bigint
+);

PluralKit.Web/Pages/Error.cshtml

@@ -0,0 +1,26 @@
+@page
+@model ErrorModel
+@{
+    ViewData["Title"] = "Error";
+}
+
+<h1 class="text-danger">Error.</h1>
+<h2 class="text-danger">An error occurred while processing your request.</h2>
+
+@if (Model.ShowRequestId)
+{
+    <p>
+        <strong>Request ID:</strong> <code>@Model.RequestId</code>
+    </p>
+}
+
+<h3>Development Mode</h3>
+<p>
+    Swapping to the <strong>Development</strong> environment displays detailed information about the error that occurred.
+</p>
+<p>
+    <strong>The Development environment shouldn't be enabled for deployed applications.</strong>
+    It can result in displaying sensitive information from exceptions to end users.
+    For local debugging, enable the <strong>Development</strong> environment by setting the <strong>ASPNETCORE_ENVIRONMENT</strong> environment variable to <strong>Development</strong>
+    and restarting the app.
+</p>

PluralKit.Web/Pages/Error.cshtml.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace PluralKit.Web.Pages
+{
+    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
+    public class ErrorModel : PageModel
+    {
+        public string RequestId { get; set; }
+
+        public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
+
+        public void OnGet()
+        {
+            RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
+        }
+    }
+}

PluralKit.Web/Pages/Index.cshtml

@@ -0,0 +1,10 @@
+@page
+@model IndexModel
+@{
+    ViewData["Title"] = "Home page";
+}
+
+<div class="text-center">
+    <h1 class="display-4">Welcome</h1>
+    <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
+</div>

PluralKit.Web/Pages/Index.cshtml.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace PluralKit.Web.Pages
+{
+    public class IndexModel : PageModel
+    {
+        public void OnGet()
+        {
+        }
+    }
+}

PluralKit.Web/Pages/Shared/_Layout.cshtml

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>@ViewData["Title"] - PluralKit.Web</title>
+
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.3.1/css/bootstrap.min.css"/>
+    <link href="https://fonts.googleapis.com/css?family=PT+Sans" rel="stylesheet">
+
+    <style>
+        body {
+            font-family: "PT Sans", sans-serif;
+        }
+    </style>
+</head>
+<body>
+
+<div class="container">
+    <main role="main" class="p-3">
+        @RenderBody()
+    </main>
+</div>
+
+<footer class="border-top footer text-muted">
+    <div class="container">
+    </div>
+</footer>
+
+@RenderSection("Scripts", required: false)
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/feather-icons/4.21.0/feather.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.3.1/js/bootstrap.min.js"></script>
+<script>
+    feather.replace();
+</script>
+</body>
+</html>

PluralKit.Web/Pages/ViewSystem.cshtml

@@ -0,0 +1,122 @@
+@page "/s/{systemId}"
+@model PluralKit.Web.Pages.ViewSystem
+
+<div class="system">
+    <ul class="taglist">
+        <li>
+            <i data-feather="hash"></i>
+            @Model.System.Hid
+        </li>
+
+        @if (Model.System.Tag != null)
+        {
+            <li>
+                <i data-feather="tag"></i>
+                @Model.System.Tag
+            </li>
+        }
+        
+        @if (Model.System.UiTz != null)
+        {
+            <li>
+                <i data-feather="clock"></i>
+                @Model.System.UiTz
+            </li>
+        }
+    </ul>
+
+    @if (Model.System.Name != null)
+    {
+        <h1>@Model.System.Name</h1>
+    }
+
+    @if (Model.System.Description != null)
+    {
+        <div>@Model.System.Description</div>
+    }
+
+    <h2>Members</h2>
+    @foreach (var member in Model.Members)
+    {
+        <div class="member-card">
+            <div class="member-avatar" style="background-image: url(@member.AvatarUrl); border-color: #@member.Color;"></div>
+            <div class="member-body">
+                <span class="member-name">@member.Name</span>
+                <div class="member-description">@member.Description</div>
+
+                <ul class="taglist">
+                    <li>
+                        <i data-feather="hash"></i>
+                        @member.Hid
+                    </li>
+
+                    @if (member.Birthday != null)
+                    {
+                        <li>
+                            <i data-feather="calendar"></i>
+                            @member.BirthdayString
+                        </li>
+                    }
+
+                    @if (member.Pronouns != null)
+                    {
+                        <li>
+                            <i data-feather="message-circle"></i>
+                            @member.Pronouns
+                        </li>
+                    }
+                </ul>
+            </div>
+        </div>
+    }
+</div>
+
+@section Scripts {
+    <style>
+        .taglist {
+            margin: 0;
+            padding: 0;
+            color: #aaa;
+            display: flex;
+        }
+        
+        .taglist li {
+            display: inline-block;
+            margin-right: 1rem;
+            list-style-type: none;
+        }
+        
+        .taglist .feather {
+            display: inline-block;
+            margin-top: -2px;
+            width: 1em;
+        }
+        
+        .member-card {
+            display: flex;
+            flex-direction: row;
+        }
+        
+        .member-avatar {
+            margin: 1.5rem 1rem 0 0;
+            border-radius: 50%;
+            background-size: cover;
+            background-position: top center;
+            flex-basis: 4rem;
+            height: 4rem;
+            border: 4px solid white;
+        }
+        
+        .member-body {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            padding: 1rem 1rem 1rem 0;
+        }
+        
+        .member-name {
+            font-size: 13pt;
+            font-weight: bold;
+        }
+    </style>
+}

PluralKit.Web/Pages/ViewSystem.cshtml.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace PluralKit.Web.Pages
+{
+    public class ViewSystem : PageModel
+    {
+        private SystemStore _systems;
+        private MemberStore _members;
+
+        public ViewSystem(SystemStore systems, MemberStore members)
+        {
+            _systems = systems;
+            _members = members;
+        }
+        
+        public PKSystem System { get; set; }
+        public IEnumerable<PKMember> Members { get; set; }
+
+        public async Task<IActionResult> OnGet(string systemId)
+        {
+            System = await _systems.GetByHid(systemId);
+            if (System == null) return NotFound();
+
+            Members = await _members.GetBySystem(System);
+
+            return Page();
+        }
+    }
+}

PluralKit.Web/Pages/_ViewImports.cshtml

@@ -0,0 +1,3 @@
+@using PluralKit.Web
+@namespace PluralKit.Web.Pages
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

PluralKit.Web/Pages/_ViewStart.cshtml

@@ -0,0 +1,3 @@
+@{
+    Layout = "Shared/_Layout";
+}

PluralKit.Web/PluralKit.Web.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp2.2</TargetFramework>
+        <DebugType>full</DebugType>
+    </PropertyGroup>
+
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
+        <PackageReference Include="Microsoft.AspNetCore.HttpsPolicy" Version="2.2.0" />
+        <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.2.0" />
+        <PackageReference Include="Microsoft.AspNetCore.StaticFiles" Version="2.2.0" />
+    </ItemGroup>
+
+
+    <ItemGroup>
+      <ProjectReference Include="..\PluralKit.Core\PluralKit.Core.csproj" />
+    </ItemGroup>
+
+</Project>

PluralKit.Web/Program.cs

@@ -0,0 +1,19 @@
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+
+namespace PluralKit.Web
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateWebHostBuilder(args).Build().Run();
+        }
+
+        public static IWebHostBuilder CreateWebHostBuilder(string[] args)
+        {
+            return WebHost.CreateDefaultBuilder(args)
+                .UseStartup<Startup>();
+        }
+    }
+}

PluralKit.Web/Startup.cs

@@ -0,0 +1,57 @@
+using System.Data;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Npgsql;
+
+namespace PluralKit.Web
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            InitUtils.Init();
+
+            var config = Configuration.GetSection("PluralKit").Get<CoreConfig>();
+            
+            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
+            
+            services
+                .AddScoped<IDbConnection, NpgsqlConnection>(_ => new NpgsqlConnection(config.Database))
+                .AddTransient<SystemStore>()
+                .AddTransient<MemberStore>()
+                .AddSingleton(config);
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public async void Configure(IApplicationBuilder app, IHostingEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            else
+            {
+                app.UseExceptionHandler("/Error");
+            }
+
+            //app.UseHttpsRedirection();
+            app.UseMvc();
+
+            var conn = app.ApplicationServices.GetRequiredService<IDbConnection>();
+            conn.Open();
+            
+            await Schema.CreateTables(conn);
+        }
+    }
+}

PluralKit.sln

@@ -0,0 +1,34 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PluralKit.Bot", "PluralKit.Bot\PluralKit.Bot.csproj", "{F2C5562D-FD96-4C11-B54E-93737D127959}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PluralKit.Core", "PluralKit.Core\PluralKit.Core.csproj", "{5DBE037D-179D-4C05-8A28-35E37129C961}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PluralKit.Web", "PluralKit.Web\PluralKit.Web.csproj", "{975F9DED-78D1-4742-8412-DF70BB381E92}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PluralKit.API", "PluralKit.API\PluralKit.API.csproj", "{3420F8A9-125C-4F7F-A444-10DD16945754}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F2C5562D-FD96-4C11-B54E-93737D127959}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2C5562D-FD96-4C11-B54E-93737D127959}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2C5562D-FD96-4C11-B54E-93737D127959}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2C5562D-FD96-4C11-B54E-93737D127959}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5DBE037D-179D-4C05-8A28-35E37129C961}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5DBE037D-179D-4C05-8A28-35E37129C961}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5DBE037D-179D-4C05-8A28-35E37129C961}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5DBE037D-179D-4C05-8A28-35E37129C961}.Release|Any CPU.Build.0 = Release|Any CPU
+		{975F9DED-78D1-4742-8412-DF70BB381E92}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{975F9DED-78D1-4742-8412-DF70BB381E92}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{975F9DED-78D1-4742-8412-DF70BB381E92}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{975F9DED-78D1-4742-8412-DF70BB381E92}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3420F8A9-125C-4F7F-A444-10DD16945754}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3420F8A9-125C-4F7F-A444-10DD16945754}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3420F8A9-125C-4F7F-A444-10DD16945754}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3420F8A9-125C-4F7F-A444-10DD16945754}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

README.md

@@ -1,21 +1,22 @@
 # PluralKit
-
 PluralKit is a Discord bot meant for plural communities. It has features like message proxying through webhooks, switch tracking, system and member profiles, and more.
 
-PluralKit has a Discord server for support and discussion: https://discord.gg/PczBt78 
+**Do you just want to add PluralKit to your server? If so, you don't need any of this. Use the bot's invite link: https://discordapp.com/oauth2/authorize?client_id=466378653216014359&scope=bot&permissions=536995904**
+
+PluralKit has a Discord server for support, feedback, and discussion: https://discord.gg/PczBt78 
 
 # Requirements
-Running the bot requires Python (specifically version 3.6) and PostgreSQL.
+Running the bot requires [.NET Core](https://dotnet.microsoft.com/download) (v2.2) and a PostgreSQL database.
 
 # Configuration
-Configuring the bot is done through a configuration file. An example of the configuration format can be seen in [`pluralkit.conf.example`](https://github.com/xSke/PluralKit/blob/master/pluralkit.conf.example).
+Configuring the bot is done through a JSON configuration file. An example of the configuration format can be seen in [`pluralkit.conf.example`](https://github.com/xSke/PluralKit/blob/master/pluralkit.conf.example).
+The configuration file needs to be placed in the bot's working directory (usually the repository root) and must be called `pluralkit.conf`.
+
+The configuration file is in JSON format (albeit with a `.conf` extension), and the following keys (using `.` to indicate a nested object level) are available:
 
 The following keys are available:
-* `token`: the Discord bot token to connect with
-* `database_uri`: the URI of the database to connect to (format: `postgres://username:password@hostname:port/database_name`)
-* `log_channel` (optional): a Discord channel ID the bot will post exception tracebacks in (make this private!)
-
-The environment variables `TOKEN` and `DATABASE_URI` will override the configuration file values when present.
+* `PluralKit.Database`: the URI of the database to connect to (in [ADO.NET Npgsql format](https://www.connectionstrings.com/npgsql/))
+* `PluralKit.Bot.Token`: the Discord bot token to connect with
 
 # Running
 
@@ -23,16 +24,26 @@ The environment variables `TOKEN` and `DATABASE_URI` will override the configura
 Running PluralKit is pretty easy with Docker. The repository contains a `docker-compose.yml` file ready to use.
 
 * Clone this repository: `git clone https://github.com/xSke/PluralKit`
-* Create a `pluralkit.conf` file in the same directory as `docker-compose.yml` containing at least a `token` field
+* Create a `pluralkit.conf` file in the same directory as `docker-compose.yml` containing at least a `PluralKit.Bot.Token` field
+  * (`PluralKit.Database` is overridden in `docker-compose.yml` to point to the Postgres container)
 * Build the bot: `docker-compose build`
 * Run the bot: `docker-compose up`
 
+In other words:
+```
+$ git clone https://github.com/xSke/PluralKit
+$ cd PluralKit
+$ cp pluralkit.conf.example pluralkit.conf
+$ nano pluralkit.conf  # (or vim, or whatever)
+$ docker-compose up -d
+```
+
 ## Manually
+* Install the .NET Core 2.2 SDK (see https://dotnet.microsoft.com/download)
 * Clone this repository: `git clone https://github.com/xSke/PluralKit`
-* Create a virtualenv: `virtualenv --python=python3.6 venv`
-* Install dependencies: `venv/bin/pip install -r requirements.txt`
-* Run PluralKit with the config file: `venv/bin/python src/bot_main.py`
-  * The bot optionally takes a parameter describing the location of the configuration file, defaulting to `./pluralkit.conf`.
+* Create and fill in a `pluralkit.conf` file in the same directory as `docker-compose.yml`
+* Run the bot: `dotnet run --project PluralKit.Bot`
+
 
 # License
 This project is under the Apache License, Version 2.0. It is available at the following link: https://www.apache.org/licenses/LICENSE-2.0

docker-compose.yml

@@ -1,38 +1,35 @@
-version: '3'
+version: "3"
 services:
   bot:
-    build: src/
-    entrypoint:
-    - python
-    - bot_main.py
-    volumes:
-    - "./pluralkit.conf:/app/pluralkit.conf:ro"
+    build: .
+    entrypoint: ["dotnet", "run", "--project", "PluralKit.Bot"]
     environment:
-    - "DATABASE_URI=postgres://postgres:postgres@db:5432/postgres"
-    depends_on:
-    - db
+      - "PluralKit:Database=Host=db;Username=postgres;Password=postgres;Database=postgres"
+    volumes:
+      - "./pluralkit.conf:/app/pluralkit.conf:ro"
+    links:
+      - db
+    restart: always
+  web:
+    build: .
+    entrypoint: ["dotnet", "run", "--project", "PluralKit.Web"]
+    environment:
+      - "PluralKit:Database=Host=db;Username=postgres;Password=postgres;Database=postgres"
+    links: 
+      - db
+    ports:
+      - 2837:80
     restart: always
   api:
-    build: src/
-    entrypoint:
-    - python
-    - api_main.py
-    depends_on:
-    - db
-    restart: always
-    ports:
-    - "2939:8080"
+    build: .
+    entrypoint: ["dotnet", "run", "--project", "PluralKit.API"]
     environment:
-    - "DATABASE_URI=postgres://postgres:postgres@db:5432/postgres"
-    - "CLIENT_ID"
-    - "INVITE_CLIENT_ID_OVERRIDE"
-    - "CLIENT_SECRET"
-    - "REDIRECT_URI"
+      - "PluralKit:Database=Host=db;Username=postgres;Password=postgres;Database=postgres"
+    links:
+      - db
+    ports:
+      - 2838:80
+    restart: always
   db:
     image: postgres:alpine
-    volumes:
-    - "db_data:/var/lib/postgresql/data"
-    restart: always
-
-volumes:
-  db_data:
+    restart: always

docs/.gitignore

@@ -0,0 +1,7 @@
+_site
+.sass-cache
+.jekyll-metadata
+
+.bundle
+vendor
+Gemfile.lock

docs/1-user-guide.md

@@ -0,0 +1,362 @@
+---
+layout: default
+title: User Guide
+permalink: /guide
+---
+
+# User Guide
+{: .no_toc }
+
+## Table of Contents
+{: .no_toc .text-delta }
+
+1. TOC
+{:toc}
+
+## Adding the bot to your server
+If you want to use PluralKit on a Discord server, you must first *add* it to the server in question. For this, you'll need the *Manage Server* permission on there.
+
+Use this link to add the bot to your server:
+
+[https://discordapp.com/oauth2/authorize?client_id=466378653216014359&scope=bot&permissions=536995904](https://discordapp.com/oauth2/authorize?client_id=466378653216014359&scope=bot&permissions=536995904)
+
+Once you go through the wizard, the bot account will automatically join the server you've chosen. Please ensure the bot has the *Read Messages*, *Send Messages*, *Manage Messages*, *Attach Files* and *Manage Webhooks* permission in the channels you want it to work in. 
+
+## System management
+In order to do most things with the PluralKit bot, you'll need to have a system registered with it. A *system* is a collection of *system members* that may be used by one or more *Discord accounts*.
+
+### Creating a system
+If you do not already have a system registered, use the following command to create one:
+
+    pk;system new
+   
+Optionally, you can attach a *system name*, which will be displayed in various information cards, like so:
+
+    pk;system new My System Name
+    
+### Viewing information about a system
+To view information about your own system, simply type:
+
+    pk;system
+    
+To view information about *a different* system, there are a number of ways to do so. You can either look up a system by @mention, by account ID, or by system ID. For example:
+
+    pk;system @Craig#5432
+    pk;system 466378653216014359
+    pk;system abcde
+    
+### System description
+If you'd like to add a small blurb to your system information card, you can add a *system description*. To do so, use the `pk;system description` command, as follows:
+
+    pk;system description This is my system description. Hello. Lorem ipsum dolor sit amet.
+    
+There's a 1000 character length limit on your system description - which is quite a lot! 
+
+If you'd like to remove your system description, just type `pk;system description` without any further parameters.
+
+### System avatars
+If you'd like your system to have an associated "system avatar", displayed on your system information card, you can add a system avatar. To do so, use the `pk;system avatar` command. You can either supply it with an direct URL to an image, or attach an image directly. For example.
+
+    pk;system avatar http://placebeard.it/512.jpg
+    pk;system avatar [with attached image]
+    
+To clear your avatar, simply type `pk;system avatar` with no attachment or link.
+
+### System tags
+Your system tag is a little snippet of text that'll be added to the end of all proxied messages.
+For example, if you want to proxy a member named `James`, and your system tag is `| The Boys`, the final name displayed
+will be `James | The Boys`. This is useful for identifying your system in-chat, and some servers may require you use
+a system tag. Note that emojis *are* supported! To set one, use the `pk;system tag` command, like so:
+
+    pk;system tag | The Boys
+    pk;system tag (Test System)
+    pk;system tag 🛰️
+    
+If you want to remove your system tag, just type `pk;system tag` with no extra parameters.
+
+**NB:** When proxying, the *total webhook username* must be 32 characters or below. As such, if you have a long system name, your tag might be enough
+to bump it over that limit. PluralKit will warn you if you have a member name/tag combination that will bring the combined username above the limit.
+You can either make the member name or the system tag shorter to solve this. 
+    
+### Adding or removing Discord accounts to the system
+If you have multiple Discord accounts you want to use the same system on, you don't need to create multiple systems.
+Instead, you can *link* the same system to multiple accounts.
+
+Let's assume the account you want to link to is called @Craig#5432. You'd link it to your *current* system by running this command from an account that already has access to the system:
+
+    pk;link @Craig#5432
+    
+PluralKit will require you to confirm the link by clicking on a reaction *from the other account*. 
+
+If you now want to unlink that account, use the following command:
+
+    pk;unlink @Craig#5432
+    
+You may not remove the only account linked to a system, as that would leave the system inaccessible. Both the `pk;link` and `pk;unlink` commands work with account IDs instead of @mentions, too.
+
+### Setting a system time zone
+PluralKit defaults to showing dates and times in [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time). 
+If you'd like, you can set a *system time zone*, and as such every date and time displayed in PluralKit
+(on behalf of your system) will be in the system time zone. To do so, use the `pk;system timezone` command, like so:
+
+    pk;system timezone Europe/Copenhagen
+    pk;system timezone America/New_York
+    pk;system timezone DE
+    pk;system timezone 🇬🇧
+    
+You can specify time zones in various ways. In regions with large amounts of time zones (eg. the Americas, Europe, etc),
+specifying an exact time zone code is the best way. To get your local time zone code, visit [this site](https://xske.github.io/tz).
+You can see the full list [here, on Wikipedia](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) (see the column *TZ database name*).
+You can also search by country code, either by giving the two-character [*ISO-3166-1 alpha-2* country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) (eg. `GB` or `DE`), or just by a country flag emoji.
+
+To clear a time zone, type `pk;system timezone` without any parameters. 
+
+### Deleting a system
+If you want to delete your own system, simply use the command:
+
+    pk;system delete
+    
+You will need to verify by typing the system's ID when the bot prompts you to - to prevent accidental deletions.
+
+## Member management
+
+In order to do most things related to PluralKit, you need to work with *system members*.
+
+Most member commands follow the format of `pk;member MemberName verb Parameter`. Note that if a member's name has multiple words, you'll need to enclose it in "double quotes" throughout the commands below.
+
+### Creating a member
+You can't do much with PluralKit without having registered members with your system, but doing so is quite simple - just use the `pk;member new` command followed by the member's name, like so:
+
+    pk;member new John
+    pk;member new Craig Smith
+    
+As the one exception to the rule above, if the name consists of multiple words you must *not* enclose it in double quotes.
+
+### Looking up member info
+To view information about a member, there are a couple ways to do it. Either you can address a member by their name (if they're in your own system), or by their 5-character *member ID*, like so:
+
+    pk;member John
+    pk;member qazws
+
+Member IDs are the only way to address a member in another system, and you can find it in various places - for example the system's member list, or on a message info card gotten by reacting to messages with a question mark.
+
+### Listing system members
+To list all the members in a system, use the `pk;system list` command. This will show a paginated list of all member names in the system. You can either run it on your own system, or another - like so:
+
+    pk;system list
+    pk;system @Craig#5432 list
+    pk;system qazws list
+    
+If you want a more detailed list, with fields such as pronouns and description, add the word `full` to the end of the command, like so:
+
+    pk;system list full
+    pk;system @Craig#5432 list full
+    pk;system qazws list full
+
+### Member renaming
+If you want to change the name of a member, you can use the `pk;member rename` command, like so:
+
+    pk;member John rename Joanne
+    pk;member "Craig Smith" rename "Craig Johnson"
+    
+### Member description
+In the same way as a system can have a description, so can a member. You can set a description using the `pk;member description` command, like so:
+
+    pk;member John description John is a very cool person, and you should give him hugs.
+    
+As with system descriptions, the member description has a 1000 character length limit. 
+To clear a member description, use the command with no additional parameters (eg. `pk;member John description`).
+
+### Member color
+A system member can have an associated color value.
+This color is *not* displayed as a name color on proxied messages due to a Discord limitation,
+but it's shown in member cards, and it can be used in third-party apps, too.
+To set a member color, use the `pk;member color` command with [a hexadecimal color code](https://htmlcolorcodes.com/), like so:
+
+    pk;member John color #ff0000
+    pk;member John color #87ceeb
+    
+To clear a member color, use the command with no color code argument (eg. `pk;member John color`).
+
+### Member avatar
+If you want your member to have an associated avatar to display on the member information card and on proxied messages, you can set the member avatar. To do so, use the `pk;member avatar` command. You can either supply it with an direct URL to an image, or attach an image directly. For example.
+
+    pk;member John avatar http://placebeard.it/512.jpg
+    pk;member "Craig Johnson" avatar [with attached image]
+    
+To clear your avatar, simply use the command with no attachment or link (eg. `pk;member John avatar`).
+
+### Member pronouns
+If you want to list a member's preferred pronouns, you can use the pronouns field on a member profile. This is a free text field, so you can put whatever you'd like in there (with a 100 character limit), like so:
+
+    pk;member John pronouns he/him
+    pk;member "Craig Johnson" pronouns anything goes, really
+    pk;member Skyler pronouns xe/xir or they/them
+
+To remove a member's pronouns, use the command with no pronoun argument (eg. `pk;member John pronouns`).
+
+### Member birthdate 
+If you want to list a member's birthdate on their information card, you can set their birthdate through PluralKit using the `pk;member birthdate` command. Please use [ISO-8601 format](https://xkcd.com/1179/) (`YYYY-MM-DD`) for best results, like so:
+
+    pk;member John birthdate 1996-07-24
+    pk;member "Craig Johnson" birthdate 2004-02-28
+    
+You can also set a birthdate without a year, either in `MM-DD` format or `Month Day` format, like so:
+
+    pk;member John birthdate 07-24
+    pk;member "Craig Johnson" birthdate Feb 28
+    
+To clear a birthdate, use the command with no birthday argument (eg. `pk;member John birthdate`).
+
+### Deleting members
+If you want to delete a member, use the `pk;member delete` command, like so:
+
+    pk;member John delete
+    
+You'll need to confirm the deletion by replying with the member's ID when the bot asks you to - this is to avoid accidental deletion.
+
+## Proxying
+Proxying is probably the most important part of PluralKit. This allows you to essentially speak "as" the member,
+with the proper name and avatar displayed on the message. To do so, you must at least [have created a member](#creating-a-system).
+
+### Setting up proxy tags
+You'll need to register a set of *proxy tags*, which are prefixes and/or suffixes you "enclose" the real message in, as a signal to PluralKit to indicate
+which member to proxy as. Common proxy tags include `[square brackets]`, `{curly braces}` or `A:letter prefixes`.
+
+To set a proxy tag, use the `pk;member proxy` command on the member in question. You'll need to provide a "proxy example", containing the word `text`.
+For example, if you want square brackets, the proxy example must be `[text]`. If you want a letter prefix, make it something like `A:text`. For example:
+
+    pk;member John proxy [text]
+    pk;member "Craig Johnson" proxy {text}
+    pk;member John proxy J:text
+    
+You can have any proxy tags you want, including one containing emojis.
+
+You can now type a message enclosed in your proxy tags, and it'll be deleted by PluralKit and reposted with the appropriate member name and avatar (if set).
+
+**NB:** If you want `<angle brackets>` as proxy tags, there is currently a bug where custom server emojis will (wrongly)
+be interpreted as proxying with that member (see [issue #37](https://github.com/xSke/PluralKit/issues/37)). The current workaround is to use different proxy tags.
+
+### Querying message information
+If you want information about a proxied message (eg. for moderation reasons), you can query the message for its sender account, system, member, etc.
+
+Either you can react to the message itself with the ❔ or ❓ emoji, which will DM you information about the message in question, 
+or you can use the `pk;message` command followed by [the message's ID](https://support.discordapp.com/hc/en-us/articles/206346498-Where-can-I-find-my-User-Server-Message-ID-).
+
+### Deleting messages
+Since the messages will be posted by PluralKit's webhook, there's no way to delete the message as you would a normal user message.
+To delete a PluralKit-proxied message, you can react to it with the ❌ emoji. Note that this only works if the message has
+been sent from your own account.
+
+## Managing switches
+PluralKit allows you to log member switches through the bot.
+Essentially, this means you can mark one or more members as *the current fronter(s)* for the duration until the next switch.
+You can then view the list of switches and fronters over time, and get statistics over which members have fronted for how long.
+
+### Logging switches
+To log a switch, use the `pk;switch` command with one or more members. For example:
+
+    pk;switch John
+    pk;switch "Craig Johnson" John
+    
+Note that the order of members are preserved (this is useful for indicating who's "more" at front, if applicable).
+If you want to specify a member with multiple words in their name, remember to encase the name in "double quotes".
+
+### Switching out
+If you want to log a switch with *no* members, you can log a switch-out as follows:
+
+    pk;switch out
+
+### Moving switches
+If you want to log a switch that happened further back in time, you can log a switch and then *move* it back in time, using the `pk;switch move` command.
+You can either specify a time either in relative terms (X days/hours/minutes/seconds ago) or in absolute terms (this date, at this time).
+Absolute times will be interpreted in the [system time zone](#setting-a-system-time-zone). For example:
+
+    pk;switch move 1h
+    pk;switch move 4d12h
+    pk;switch move 2 PM
+    pk;switch move May 8th 4:30 PM
+
+Note that you can't move a switch *before* the *previous switch*, to avoid breaking consistency. Here's a rough ASCII-art illustration of this:
+
+           YOU CAN NOT               YOU CAN
+            MOVE HERE               MOVE HERE       CURRENT SWITCH                 
+                v                       v               START                   NOW
+    [===========================]       |                 v                      v
+                                 [=== PREVIOUS SWITCH ===]|                      |
+                                 \________________________[=== CURRENT SWITCH ===]
+                                                          
+    ----- TIME AXIS ---->
+
+### Delete switches
+If you'd like to delete the most recent switch, use the `pk;switch delete` command. You'll need to confirm
+the deletion by clicking a reaction.
+
+### Querying fronter
+To see the current fronter in a system, use the `pk;system fronter` command. You can use this on your current system, or on other systems. For example:
+
+    pk;system fronter
+    pk;system @Craig#5432 fronter
+    pk;system qazws fronter
+
+### Querying front history
+To look at the front history of a system (currently limited to the last 10 switches). use the `pk;system fronthistory` command, for example:
+
+    pk;system fronthistory
+    pk;system @Craig#5432 fronthistory
+    pk;system qazws fronthistory
+    
+### Querying front percentage
+To look at the per-member breakdown of the front over a given time period, use the `pk;system frontpercent` command. If you don't provide a time period, it'll default to 30 days. For example:
+
+    pk;system frontpercent
+    pk;system @Craig#5432 frontpercent 7d
+    pk;system qazws frontpercent 100d12h
+
+Note that in cases of switches with multiple members, each involved member will have the full length of the switch counted towards it. This means that the percentages may add up to over 100%.
+
+## Moderation commands
+
+### Log channel
+If you want to log every proxied message to a separate channel for moderation purposes, you can use the `pk;log` command with the channel name.
+This requires you to have the *Manage Server* permission on the server. For example:
+
+    pk;log #proxy-log
+    
+To disable logging, use the `pk;log` command with no channel name.
+
+## Importing and exporting data
+If you're a user of another proxy bot (eg. Tupperbox), or you want to import a saved system backup, you can use the importing and exporting commands.
+
+### Importing from Tupperbox
+If you're a user of the *other proxying bot* Tupperbox, you can import system and member information from there. This is a fairly simple process:
+
+1. Export your data from Tupperbox:
+```
+tul!export
+```
+2. Copy the URL for the data file (or download it)
+3. Import your data into PluralKit:
+```
+pk;import https://link/to/the/data/file.json
+```
+*(alternatively, run `pk;import` by itself and attach the .json file)*
+
+Note that while Tupperbox supports features such as multiple proxies per member, per-member system tags, and member groups, PluralKit does not.
+PluralKit will warn you when you're importing a Tupperbox file that makes use of such features, as they will not carry over. 
+
+### Importing from PluralKit
+If you have an exported file from PluralKit, you can import system, member and switch information from there like so:
+1. Export your data from PluralKit:
+```
+pk;export
+```
+2. Copy the URL for the data file (or download it)
+3. Import your data into PluralKit:
+```
+pk;import https://link/to/the/data/file.json
+```
+*(alternatively, run `pk;import` by itself and attach the .json file)*
+
+### Exporting your PluralKit data
+To export all the data associated with your system, run the `pk;export` command. This will send you a JSON file containing your system, member, and switch information.

docs/2-command-list.md

@@ -0,0 +1,55 @@
+---
+layout: default
+title: Command List
+permalink: /commands
+---
+
+# How to read this
+Words in <angle brackets> are *required parameters*. Words in [square brackets] are *optional parameters*. Words with ellipses... indicate multiple repeating parameters.
+
+# Commands
+## System commands
+- `pk;system [id]` - Shows information about a system.
+- `pk;system new [name]` - Creates a new system registered to your account.
+- `pk;system rename [new name]` - Changes the description of your system.
+- `pk;system description [description]` - Changes the description of your system.
+- `pk;system avatar [avatar url]` - Changes the avatar of your system.
+- `pk;system tag [tag]` - Changes the system tag of your system.
+- `pk;system timezone [location]` - Changes the time zone of your system.
+- `pk;system delete` - Deletes your system.
+- `pk;system [id] fronter` - Shows the current fronter of a system.
+- `pk;system [id] fronthistory` - Shows the last 10 fronters of a system.
+- `pk;system [id] frontpercent [timeframe]` - Shows the aggregated front history of a system within a given time frame.
+- `pk;system [id] list` - Shows a paginated list of a system's members.
+- `pk;system [id] list full` - Shows a paginated list of a system's members, with increased detail.
+- `pk;link <account>` - Links this system to a different account.
+- `pk;unlink [account]` - Unlinks an account from this system.
+## Member commands
+- `pk;member <name>` - Shows information about a member.
+- `pk;member new <name>` - Creates a new system member.
+- `pk;member <name> rename <new name>` - Changes the name of a member.
+- `pk;member <name> description [description` - Changes the description of a member.
+- `pk;member <name> avatar [avatar url]` - Changes the avatar of a member.
+- `pk;member <name> proxy [tags]` - Changes the proxy tags of a member.
+- `pk;member <name> pronouns [pronouns]` - Changes the pronouns of a member.
+- `pk;member <name> color [color]` - Changes the color of a member.
+- `pk;member <name> birthdate [birthdate]` - Changes the birthday of a member.
+- `pk;member <name> delete` - Deletes a member. 
+## Switching commands
+- `pk;switch [member...]` - Registers a switch with the given members.
+- `pk;switch move <time>` - Moves the latest switch backwards in time.
+- `pk;switch delete` - Deletes the latest switch.
+- `pk;switch out` - Registers a 'switch-out' - a switch with no associated members.
+## Utility
+- `pk;log <channel>` - Sets the channel to log all proxied messages.
+- `pk;message <message id>` - Looks up information about a proxied message by its message ID.
+- `pk;invite` - Sends the bot invite link for PluralKit.
+- `pk;import` - Imports a data file from PluralKit or Tupperbox.
+- `pk;expoort` - Exports a data file containing your system information.
+## API
+- `pk;token` - DMs you a token for using the PluralKit API.
+- `pk;token refresh` - Refreshes your API token and invalidates the old one.
+## Help
+- `pk;help` - Displays a basic help message describing how to use the bot.
+- `pk;help proxy` - Directs you to [this page](/guide#proxying).
+- `pk;commands` - Directs you to this page!

docs/3-api-documentation.md

@@ -0,0 +1,260 @@
+---
+layout: default
+title: API documentation
+permalink: /api
+---
+
+# API documentation
+PluralKit has a basic HTTP REST API for querying and modifying your system.
+The root endpoint of the API is `https://api.pluralkit.me/v1/`.
+
+Endpoints will always return all fields, using `null` when a value is missing. On `PATCH` endpoints, you *must* include
+all fields, too. Missing fields will be interpreted as `null`, and `null` fields will have their value removed. To
+preserve a value, pass the existing value again.
+
+## Authentication
+Authentication is done with a simple "system token". You can get your system token by running `pk;token` using the
+Discord bot, either in a channel with the bot or in DMs. Then, pass this token in the `Authorization` HTTP header
+on requests that require it. Failure to do so on endpoints that require authentication will return a `401 Unauthorized`.
+
+## Models
+The following three models (usually represented in JSON format) represent the various objects in PluralKit's API. A `?` after the column type indicates an optional (nullable) parameter.
+### System model
+|Key|Type|Patchable?|Notes|
+|---|---|---|---|
+|id|string|No|
+|name|string?|Yes|100-character limit.
+|description|string?|Yes|1000-character limit.
+|tag|string?|Yes|
+|avatar_url|url?|Yes|Not validated server-side.
+|tz|string?|Yes|Tzdb identifier. Patching with `null` will store `"UTC"`.
+|created|datetime|No|
+
+### Member model
+|Key|Type|Patchable?|Notes|
+|---|---|---|---|
+|id|string|No|
+|name|string?|Yes|50-character limit.
+|description|string?|Yes|1000-character limit.
+|color|color?|Yes|6-char hex (eg. `ff7000`), sans `#`.
+|avatar_url|url?|Yes|Not validated server-side.
+|birthday|date?|Yes|ISO-8601 (`YYYY-MM-DD`) format, year of `0001` means hidden year.
+|prefix|string?|Yes||
+|suffix|string?|Yes||
+|created|datetime|No|
+### Switch model
+|Key|Type|Notes|
+|---|---|---|
+|timestamp|datetime|
+|members|list of id/Member|Is sometimes in plain ID list form (eg. `GET /s/<id>/switches`), sometimes includes the full Member model (eg. `GET /s/<id>/fronters`).
+
+## Endpoints
+
+### `GET /s/<id>`
+Queries a system by its 5-character ID, and returns information about it. If the system doesn't exist, returns `404 Not Found`.
+
+#### Example request
+    GET https://api.pluralkit.me/v1/s/abcde
+
+#### Example response
+```json
+{
+  "id": "abcde",
+  "name": "My System",
+  "description": "This is my system description. Yay.",
+  "tag": "[MySys]",
+  "avatar_url": "https://path/to/avatar/image.png",
+  "tz": "Europe/Copenhagen",
+  "created": "2019-01-01T14:30:00.987654Z"
+}
+```
+
+### `GET /s/<id>/members`
+Queries a system's member list by its 5-character ID. If the system doesn't exist, returns `404 Not Found`.
+
+#### Example request
+    GET https://api.pluralkit.me/v1/s/abcde/members
+    
+#### Example response
+```json
+[
+  {
+    "id": "qwert",
+    "name": "Craig Johnson",
+    "color": "ff7000",
+    "avatar_url": "https://path/to/avatar/image.png",
+    "birthday": "1997-07-14",
+    "pronouns": "he/him or they/them",
+    "description": "I am Craig, example user extraordinaire.",
+    "prefix": "[",
+    "suffix": "]",
+    "created": "2019-01-01T15:00:00.654321Z"
+  }
+]
+```
+
+### `GET /s/<id>/switches[?before=<timestamp>]`
+Returns a system's switch history in newest-first chronological order, with a maximum of 100 switches. If the system doesn't exist, returns `404 Not Found`.
+Optionally takes a `?before=` query parameter with an ISO-8601-formatted timestamp, and will only return switches
+that happen before that timestamp.
+
+#### Example request
+    GET https://api.pluralkit.me/v1/s/abcde/switches?before=2019-03-01T14:00:00Z
+
+#### Example response
+```json
+[
+  {
+    "timestamp": "2019-02-23T14:20:59.123456Z",
+    "members": ["qwert", "yuiop"]
+  },
+  {
+    "timestamp": "2019-02-22T12:00:00Z",
+    "members": ["yuiop"]
+  },
+  {
+    "timestamp": "2019-02-20T09:30:00Z",
+    "members": []
+  }
+]
+```
+
+### `GET /s/<id>/fronters`
+Returns a system's current fronter(s), with fully hydrated member objects. If the system doesn't exist, *or* the system has no registered switches, returns `404 Not Found`.
+
+#### Example request
+    GET https://api.pluralkit.me/v1/s/abcde/fronters
+
+#### Example response
+```json
+{
+  "timestamp": "2019-07-09T17:22:46.47441Z",
+  "members": [
+      {
+        "id": "qwert",
+        "name": "Craig Johnson",
+        "color": "ff7000",
+        "avatar_url": "https://path/to/avatar/image.png",
+        "birthday": "1997-07-14",
+        "pronouns": "he/him or they/them",
+        "description": "I am Craig, example user extraordinaire.",
+        "prefix": "[",
+        "suffix": "]",
+        "created": "2019-01-01T15:00:00.654321Z"
+      }
+  ]
+}
+```
+
+### `PATCH /s`
+**Requires authentication.**
+
+Edits your own system's information. Missing fields will be set to `null`. Will return the new system object.
+
+#### Example request
+    PATCH https://api.pluralkit.me/v1/s
+   
+```json
+{
+    "name": "New System Name",
+    "tag": "{Sys}",
+    "avatar_url": "https://path/to/new/avatar.png"
+    "tz": "America/New_York"
+}
+```
+(note the absence of a `description` field, which is set to null in the response)
+
+#### Example response
+```json
+{
+  "id": "abcde",
+  "name": "New System Name",
+  "description": null,
+  "tag": "{Sys}",
+  "avatar_url": "https://path/to/new/avatar.png",
+  "tz": "America/New_York",
+  "created": "2019-01-01T14:30:00.987654Z"
+}
+```
+
+### `POST /s/switches`
+**Requires authentication.**
+
+Registers a new switch to your own system given a list of member IDs.
+
+#### Example request
+    POST https://api.pluralkit.me/v1/s/switches
+    
+```json
+{
+    "members": ["qwert", "yuiop"]
+}
+```
+
+#### Example response
+(`204 No Content`)
+
+### `GET /m/<id>`
+Queries a member's information by its 5-character member ID. If the member does not exist, will return `404 Not Found`.
+
+#### Example request
+    GET https://api.pluralkit.me/v1/m/qwert
+
+#### Example response
+```json
+{
+    "id": "qwert",
+    "name": "Craig Johnson",
+    "color": "ff7000",
+    "avatar_url": "https://path/to/avatar/image.png",
+    "birthday": "1997-07-14",
+    "pronouns": "he/him or they/them",
+    "description": "I am Craig, example user extraordinaire.",
+    "prefix": "[",
+    "suffix": "]",
+    "created": "2019-01-01T15:00:00.654321Z"
+}
+```
+
+### `PATCH /m/<id>`
+**Requires authentication.**
+
+Edits a member's information. Missing fields will be set to `null`. Will return the new member object. Member must (obviously) belong to your own system.
+
+#### Example request
+    PATCH https://api.pluralkit.me/v1/m/qwert
+    
+```json
+{
+    "name": "Craig Peterson",
+    "color": null,
+    "avatar_url": "https://path/to/new/image.png",
+    "birthday": "1997-07-14",
+    "pronouns": "they/them",
+    "description": "I am Craig, cooler example user extraordinaire.",
+    "prefix": "["
+}
+```
+(note the absence of a `suffix` field, which is set to null in the response) 
+
+#### Example response
+```json
+{
+    "id": "qwert",
+    "name": "Craig Peterson",
+    "color": null,
+    "avatar_url": "https://path/to/new/image.png",
+    "birthday": "1997-07-14",
+    "pronouns": "they/them",
+    "description": "I am Craig, cooler example user extraordinaire.",
+    "prefix": "[",
+    "suffix": null,
+    "created": "2019-01-01T15:00:00.654321Z"
+}
+```
+
+## Version history
+* 2019-07-10 **(v1)**
+  * First specified version
+* (prehistory)
+  * Initial release

docs/4-privacy-policy.md

@@ -0,0 +1,30 @@
+---
+layout: default
+title: Privacy Policy
+permalink: /privacy
+---
+
+# Privacy Policy
+
+I'm not a lawyer. I don't want to write a 50 page document no one wants to (or can) read. In short:
+
+This is the data PluralKit collects indefinitely:
+
+* Information *you give the bot* (eg. system/member profiles, switch history, linked accounts, etc)
+* Metadata about proxied messages (sender account ID, sender system/member, timestamp)
+* Aggregate anonymous usage metrics (eg. gateway events received/second, messages proxied/second, commands executed/second)
+* Nightly database backups of the above information
+
+This is the data PluralKit does *not* collect:
+* Anything not listed above, including...
+* Proxied message *contents* (they are fetched on-demand from the original message object when queried)
+* Metadata about deleted messages, members, switches or systems
+* Information added *and deleted* between nightly backups
+* Information about messages that *aren't* proxied through PluralKit
+
+You can export your system information using the `pk;export` command. This does not include message metadata (as the file would be huge). If there's demand for a command to export that, [let me know on GitHub](https://github.com/xSke/PluralKit/issues).
+
+You can delete your information using `pk;delete`. This will delete all system information and associated members, switches, and messages. This will not delete your information from the database backups. Contact me if you want that wiped, too.
+
+The bot is [open-source](https://github.com/xSke/PluralKit). While I can't *prove* this is the code that's running on the production server...
+it is, promise.

docs/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gem 'github-pages', group: :jekyll_plugins

docs/_config.yml

@@ -0,0 +1,9 @@
+title: PluralKit
+baseurl: ""
+url: "https://pluralkit.me"
+remote_theme: pmarsceill/just-the-docs
+
+search_enabled: true
+aux_links:
+  "Add PluralKit to your server":
+    - "https://discordapp.com/oauth2/authorize?client_id=466378653216014359&scope=bot&permissions=536995904"

docs/_sass/custom/custom.scss

@@ -0,0 +1 @@
+$link-color: $blue-100;

docs/index.md

@@ -0,0 +1,8 @@
+---
+# Feel free to add content and custom Front Matter to this file.
+# To modify the layout, see https://jekyllrb.com/docs/themes/#overriding-theme-defaults
+
+layout: home
+---
+
+OwO

pluralkit.conf.example

@@ -1,5 +1,8 @@
 {
-    "database_uri": "postgres://username:password@hostname:port/database_name",
-    "token": "BOT_TOKEN_GOES_HERE",
-    "log_channel": null
+  "PluralKit": {
+    "Bot": {
+      "Token": "BOT_TOKEN_GOES_HERE"
+    },
+    "Database": "Host=localhost;Port=5432;Username=myusername;Password=mypassword;Database=mydatabasename"
+  }
 }

src/Dockerfile

@@ -1,10 +0,0 @@
-FROM python:3.6-alpine
-
-RUN apk --no-cache add build-base libffi-dev
-
-WORKDIR /app
-ADD requirements.txt /app
-RUN pip install --trusted-host pypi.python.org -r requirements.txt
-
-ADD . /app
-

src/api_main.py

@@ -1,254 +0,0 @@
-import json
-import logging
-import os
-
-from aiohttp import web, ClientSession
-
-from pluralkit import db, utils
-from pluralkit.errors import PluralKitError
-from pluralkit.member import Member
-from pluralkit.system import System
-
-logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s")
-logger = logging.getLogger("pluralkit.api")
-
-def require_system(f):
-    async def inner(request):
-        if "system" not in request:
-            raise web.HTTPUnauthorized()
-        return await f(request)
-    return inner
-
-@web.middleware
-async def error_middleware(request, handler):
-    try:
-        return await handler(request)
-    except json.JSONDecodeError:
-        raise web.HTTPBadRequest()
-    except PluralKitError as e:
-        return web.json_response({"error": e.message}, status=400)
-
-@web.middleware
-async def db_middleware(request, handler):
-    async with request.app["pool"].acquire() as conn:
-        request["conn"] = conn
-        return await handler(request)
-
-@web.middleware
-async def auth_middleware(request, handler):
-    token = request.headers.get("Authorization") or request.query.get("token")
-    if token:
-        system = await System.get_by_token(request["conn"], token)
-        if system:
-            request["system"] = system
-    return await handler(request)
-
-@web.middleware
-async def cors_middleware(request, handler):
-    try:
-        resp = await handler(request)
-    except web.HTTPException as r:
-        resp = r
-    resp.headers["Access-Control-Allow-Origin"] = "*"
-    resp.headers["Access-Control-Allow-Methods"] = "GET, POST, PATCH"
-    resp.headers["Access-Control-Allow-Headers"] = "Authorization"
-    return resp
-
-class Handlers:
-    @require_system
-    async def get_system(request):
-        return web.json_response(request["system"].to_json())
-
-    async def get_other_system(request):
-        system_id = request.match_info.get("system")
-        system = await System.get_by_hid(request["conn"], system_id)
-        if not system:
-            raise web.HTTPNotFound(body="null")
-        return web.json_response(system.to_json())
-
-    async def get_system_members(request):
-        system_id = request.match_info.get("system")
-        system = await System.get_by_hid(request["conn"], system_id)
-        if not system:
-            raise web.HTTPNotFound(body="null")
-
-        members = await system.get_members(request["conn"])
-        return web.json_response([m.to_json() for m in members])
-
-    async def get_system_switches(request):
-        system_id = request.match_info.get("system")
-        system = await System.get_by_hid(request["conn"], system_id)
-        if not system:
-            raise web.HTTPNotFound(body="null")
-
-        switches = await system.get_switches(request["conn"], 9999)
-
-        cache = {}
-        async def hid_getter(member_id):
-            if not member_id in cache:
-                cache[member_id] = await Member.get_member_by_id(request["conn"], member_id)
-            return cache[member_id].hid
-
-        return web.json_response([await s.to_json(hid_getter) for s in switches])
-
-    async def get_system_fronters(request):
-        system_id = request.match_info.get("system")
-        system = await System.get_by_hid(request["conn"], system_id)
-
-        if not system:
-            raise web.HTTPNotFound(body="null")
-
-        members, stamp = await utils.get_fronters(request["conn"], system.id)
-        if not stamp:
-            # No switch has been registered at all
-            raise web.HTTPNotFound(body="null")
-
-        data = {
-            "timestamp": stamp.isoformat(),
-            "members": [member.to_json() for member in members]
-        }
-        return web.json_response(data)
-
-    @require_system
-    async def patch_system(request):
-        req = await request.json()
-        if "name" in req:
-            await request["system"].set_name(request["conn"], req["name"])
-        if "description" in req:
-            await request["system"].set_description(request["conn"], req["description"])
-        if "tag" in req:
-            await request["system"].set_tag(request["conn"], req["tag"])
-        if "avatar_url" in req:
-            await request["system"].set_avatar(request["conn"], req["name"])
-        if "tz" in req:
-            await request["system"].set_time_zone(request["conn"], req["tz"])
-        return web.json_response((await System.get_by_id(request["conn"], request["system"].id)).to_json())
-
-    async def get_member(request):
-        member_id = request.match_info.get("member")
-        member = await Member.get_member_by_hid(request["conn"], None, member_id)
-        if not member:
-            raise web.HTTPNotFound(body="{}")
-        system = await System.get_by_id(request["conn"], member.system)
-        member_json = member.to_json()
-        member_json["system"] = system.to_json()
-        return web.json_response(member_json)
-
-    @require_system
-    async def post_member(request):
-        req = await request.json()
-        member = await request["system"].create_member(request["conn"], req["name"])
-        return web.json_response(member.to_json())
-
-    @require_system
-    async def patch_member(request):
-        member_id = request.match_info.get("member")
-        member = await Member.get_member_by_hid(request["conn"], None, member_id)
-        if not member:
-            raise web.HTTPNotFound()
-        if member.system != request["system"].id:
-            raise web.HTTPUnauthorized()
-
-        req = await request.json()
-        if "name" in req:
-            await member.set_name(request["conn"], req["name"])
-        if "description" in req:
-            await member.set_description(request["conn"], req["description"])
-        if "avatar_url" in req:
-            await member.set_avatar_url(request["conn"], req["avatar_url"])
-        if "color" in req:
-            await member.set_color(request["conn"], req["color"])
-        if "birthday" in req:
-            await member.set_birthdate(request["conn"], req["birthday"])
-        if "pronouns" in req:
-            await member.set_pronouns(request["conn"], req["pronouns"])
-        if "prefix" in req or "suffix" in req:
-            await member.set_proxy_tags(request["conn"], req.get("prefix", member.prefix), req.get("suffix", member.suffix))
-        return web.json_response((await Member.get_member_by_id(request["conn"], member.id)).to_json())
-
-    @require_system
-    async def delete_member(request):
-        member_id = request.match_info.get("member")
-        member = await Member.get_member_by_hid(request["conn"], None, member_id)
-        if not member:
-            raise web.HTTPNotFound()
-        if member.system != request["system"].id:
-            raise web.HTTPUnauthorized()
-
-        await member.delete(request["conn"])
-
-    @require_system
-    async def post_switch(request):
-        req = await request.json()
-        if isinstance(req, str):
-            req = [req]
-        if req is None:
-            req = []
-        if not isinstance(req, list):
-            raise web.HTTPBadRequest()
-
-        members = [await Member.get_member_by_hid(request["conn"], request["system"].id, hid) for hid in req]
-        if not all(members):
-            raise web.HTTPNotFound(body=json.dumps({"error": "One or more members not found."}))
-
-        switch = await request["system"].add_switch(request["conn"], members)
-
-        hids = {member.id: member.hid for member in members}
-        async def hid_getter(mid):
-            return hids[mid]
-
-        return web.json_response(await switch.to_json(hid_getter))
-
-    async def discord_oauth(request):
-        code = await request.text()
-        async with ClientSession() as sess:
-            data = {
-                'client_id': os.environ["CLIENT_ID"],
-                'client_secret': os.environ["CLIENT_SECRET"],
-                'grant_type': 'authorization_code',
-                'code': code,
-                'redirect_uri': os.environ["REDIRECT_URI"],
-                'scope': 'identify'
-            }
-            headers = {
-                'Content-Type': 'application/x-www-form-urlencoded'
-            }
-            res = await sess.post("https://discordapp.com/api/v6/oauth2/token", data=data, headers=headers)
-            if res.status != 200:
-                raise web.HTTPBadRequest()
-
-            access_token = (await res.json())["access_token"]
-            res = await sess.get("https://discordapp.com/api/v6/users/@me", headers={"Authorization": "Bearer " + access_token})
-            user_id = int((await res.json())["id"])
-
-            system = await System.get_by_account(request["conn"], user_id)
-            if not system:
-                raise web.HTTPUnauthorized()
-            return web.Response(text=await system.get_token(request["conn"]))
-
-async def run():
-    app = web.Application(middlewares=[cors_middleware, db_middleware, auth_middleware, error_middleware])
-    def cors_fallback(req):
-        return web.Response(headers={"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Authorization", "Access-Control-Allow-Methods": "GET, POST, PATCH"}, status=404 if req.method != "OPTIONS" else 200)
-    app.add_routes([
-        web.get("/s", Handlers.get_system),
-        web.post("/s/switches", Handlers.post_switch),
-        web.get("/s/{system}", Handlers.get_other_system),
-        web.get("/s/{system}/members", Handlers.get_system_members),
-        web.get("/s/{system}/switches", Handlers.get_system_switches),
-        web.get("/s/{system}/fronters", Handlers.get_system_fronters),
-        web.patch("/s", Handlers.patch_system),
-        web.get("/m/{member}", Handlers.get_member),
-        web.post("/m", Handlers.post_member),
-        web.patch("/m/{member}", Handlers.patch_member),
-        web.delete("/m/{member}", Handlers.delete_member),
-        web.post("/discord_oauth", Handlers.discord_oauth),
-        web.route("*", "/{tail:.*}", cors_fallback)
-    ])
-    app["pool"] = await db.connect(
-        os.environ["DATABASE_URI"]
-    )
-    return app
-
-
-web.run_app(run())

src/bot_main.py

@@ -1,12 +0,0 @@
-import asyncio
-import sys
-
-try:
-    # uvloop doesn't work on Windows, therefore an optional dependency
-    import uvloop
-    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-except ImportError:
-    pass
-
-from pluralkit import bot
-bot.run(bot.Config.from_file_and_env(sys.argv[1] if len(sys.argv) > 1 else "pluralkit.conf"))

src/pluralkit/bot/__init__.py

@@ -1,148 +0,0 @@
-import asyncio
-import sys
-
-import asyncpg
-from collections import namedtuple
-import discord
-import logging
-import json
-import os
-import traceback
-
-from pluralkit import db
-from pluralkit.bot import commands, proxy, channel_logger, embeds
-
-logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s")
-
-class Config:
-    required_fields = ["database_uri", "token"]
-    fields = ["database_uri", "token", "log_channel"]
-
-    database_uri: str
-    token: str
-    log_channel: str
-
-    def __init__(self, database_uri: str, token: str, log_channel: str = None):
-        self.database_uri = database_uri
-        self.token = token
-        self.log_channel = log_channel
-        
-    @staticmethod
-    def from_file_and_env(filename: str) -> "Config":
-        try:
-            with open(filename, "r") as f:
-                config = json.load(f)
-        except IOError as e:
-            # If all the required fields are specified as environment variables, it's OK to 
-            # not raise the IOError, we can just construct the dict from these
-            if all([rf.upper() in os.environ for rf in Config.required_fields]):
-                config = {}
-            else:
-                # If they aren't, though, then rethrow
-                raise e
-
-        # Override with environment variables
-        for f in Config.fields:
-            if f.upper() in os.environ:
-                config[f] = os.environ[f.upper()]
-
-        # If we currently don't have all the required fields, then raise
-        if not all([rf in config for rf in Config.required_fields]):
-            raise RuntimeError("Some required config fields were missing: " + ", ".join(filter(lambda rf: rf not in config, Config.required_fields)))
-
-        return Config(**config)
-
-
-def connect_to_database(uri: str) -> asyncpg.pool.Pool:
-    return asyncio.get_event_loop().run_until_complete(db.connect(uri))
-
-
-def run(config: Config):
-    pool = connect_to_database(config.database_uri)
-
-    async def create_tables():
-        async with pool.acquire() as conn:
-            await db.create_tables(conn)
-
-    asyncio.get_event_loop().run_until_complete(create_tables())
-
-    client = discord.AutoShardedClient()
-    logger = channel_logger.ChannelLogger(client)
-
-    @client.event
-    async def on_ready():
-        print("PluralKit started.")
-        print("User: {}#{} (ID: {})".format(client.user.name, client.user.discriminator, client.user.id))
-        print("{} servers".format(len(client.guilds)))
-        print("{} shards".format(client.shard_count or 1))
-
-        await client.change_presence(activity=discord.Game(name="pk;help \u2014 in {} servers".format(len(client.guilds))))
-
-    @client.event
-    async def on_message(message: discord.Message):
-        # Ignore messages from bots
-        if message.author.bot:
-            return
-
-        # Grab a database connection from the pool
-        async with pool.acquire() as conn:
-            # First pass: do command handling
-            did_run_command = await commands.command_dispatch(client, message, conn)
-            if did_run_command:
-                return
-
-            # Second pass: do proxy matching
-            await proxy.try_proxy_message(conn, message, logger, client.user)
-
-    @client.event
-    async def on_raw_message_delete(payload: discord.RawMessageDeleteEvent):
-        async with pool.acquire() as conn:
-            await proxy.handle_deleted_message(conn, client, payload.message_id, None, logger)
-
-    @client.event
-    async def on_raw_bulk_message_delete(payload: discord.RawBulkMessageDeleteEvent):
-        async with pool.acquire() as conn:
-            for message_id in payload.message_ids:
-                await proxy.handle_deleted_message(conn, client, message_id, None, logger)
-
-    @client.event
-    async def on_raw_reaction_add(payload: discord.RawReactionActionEvent):
-        if payload.emoji.name == "\u274c":  # Red X
-            async with pool.acquire() as conn:
-                await proxy.try_delete_by_reaction(conn, client, payload.message_id, payload.user_id, logger)
-        if payload.emoji.name in "\u2753\u2754":  # Question mark
-            async with pool.acquire() as conn:
-                await proxy.do_query_message(conn, client, payload.user_id, payload.message_id, payload.emoji)
-
-    @client.event
-    async def on_error(event_name, *args, **kwargs):
-        # Print it to stderr
-        logging.getLogger("pluralkit").exception("Exception while handling event {}".format(event_name))
-
-        # Then log it to the given log channel
-        # TODO: replace this with Sentry or something
-        if not config.log_channel:
-            return
-        log_channel = client.get_channel(int(config.log_channel))
-
-        # If this is a message event, we can attach additional information in an event
-        # ie. username, channel, content, etc
-        if args and isinstance(args[0], discord.Message):
-            message: discord.Message = args[0]
-            embed = embeds.exception_log(
-                message.content,
-                message.author.name,
-                message.author.discriminator,
-                message.author.id,
-                message.guild.id if message.guild else None,
-                message.channel.id
-            )
-        else:
-            # If not, just post the string itself
-            embed = None
-
-        traceback_str = "```python\n{}```".format(traceback.format_exc())
-        if len(traceback.format_exc()) >= (2000 - len("```python\n```")):
-            traceback_str = "```python\n...{}```".format(traceback.format_exc()[- (2000 - len("```python\n...```")):])
-        await log_channel.send(content=traceback_str, embed=embed)
-    client.run(config.token)

src/pluralkit/bot/channel_logger.py

@@ -1,104 +0,0 @@
-import discord
-import logging
-from datetime import datetime
-
-from pluralkit import db
-
-
-def embed_set_author_name(embed: discord.Embed, channel_name: str, member_name: str, system_name: str, avatar_url: str):
-    name = "#{}: {}".format(channel_name, member_name)
-    if system_name:
-        name += " ({})".format(system_name)
-
-    embed.set_author(name=name, icon_url=avatar_url or discord.Embed.Empty)
-
-
-class ChannelLogger:
-    def __init__(self, client: discord.Client):
-        self.logger = logging.getLogger("pluralkit.bot.channel_logger")
-        self.client = client
-
-    async def get_log_channel(self, conn, server_id: int):
-        server_info = await db.get_server_info(conn, server_id)
-
-        if not server_info:
-            return None
-
-        log_channel = server_info["log_channel"]
-
-        if not log_channel:
-            return None
-
-        return self.client.get_channel(log_channel)
-
-    async def send_to_log_channel(self, log_channel: discord.TextChannel, embed: discord.Embed, text: str = None):
-        try:
-            await log_channel.send(content=text, embed=embed)
-        except discord.Forbidden:
-            # TODO: spew big error
-            self.logger.warning(
-                "Did not have permission to send message to logging channel (server={}, channel={})".format(
-                    log_channel.guild.id, log_channel.id))
-
-    async def log_message_proxied(self, conn,
-                                  server_id: int,
-                                  channel_name: str,
-                                  channel_id: int,
-                                  sender_name: str,
-                                  sender_disc: int,
-                                  sender_id: int,
-                                  member_name: str,
-                                  member_hid: str,
-                                  member_avatar_url: str,
-                                  system_name: str,
-                                  system_hid: str,
-                                  message_text: str,
-                                  message_image: str,
-                                  message_timestamp: datetime,
-                                  message_id: int):
-        log_channel = await self.get_log_channel(conn, server_id)
-        if not log_channel:
-            return
-
-        message_link = "https://discordapp.com/channels/{}/{}/{}".format(server_id, channel_id, message_id)
-
-        embed = discord.Embed()
-        embed.colour = discord.Colour.blue()
-        embed.description = message_text
-        embed.timestamp = message_timestamp
-
-        embed_set_author_name(embed, channel_name, member_name, system_name, member_avatar_url)
-        embed.set_footer(
-            text="System ID: {} | Member ID: {} | Sender: {}#{} ({}) | Message ID: {}".format(system_hid, member_hid,
-                                                                                              sender_name, sender_disc,
-                                                                                              sender_id, message_id))
-
-        if message_image:
-            embed.set_thumbnail(url=message_image)
-
-        await self.send_to_log_channel(log_channel, embed, message_link)
-
-    async def log_message_deleted(self, conn,
-                                  server_id: int,
-                                  channel_name: str,
-                                  member_name: str,
-                                  member_hid: str,
-                                  member_avatar_url: str,
-                                  system_name: str,
-                                  system_hid: str,
-                                  message_text: str,
-                                  message_id: int):
-        log_channel = await self.get_log_channel(conn, server_id)
-        if not log_channel:
-            return
-
-        embed = discord.Embed()
-        embed.colour = discord.Colour.dark_red()
-        embed.description = message_text or "*(unknown, message deleted by moderator)*"
-        embed.timestamp = datetime.utcnow()
-
-        embed_set_author_name(embed, channel_name, member_name, system_name, member_avatar_url)
-        embed.set_footer(
-            text="System ID: {} | Member ID: {} | Message ID: {}".format(system_hid, member_hid, message_id))
-
-        await self.send_to_log_channel(log_channel, embed)

src/pluralkit/bot/commands/__init__.py

@@ -1,250 +0,0 @@
-import asyncio
-from datetime import datetime
-
-import discord
-import re
-from typing import Tuple, Optional, Union
-
-from pluralkit import db
-from pluralkit.bot import embeds, utils
-from pluralkit.errors import PluralKitError
-from pluralkit.member import Member
-from pluralkit.system import System
-
-def find_with_predicate(s: str, pred) -> int:
-    for i, v in enumerate(s):
-        if pred(v):
-            return i
-    return -1
-
-def next_arg(arg_string: str) -> Tuple[str, Optional[str]]:
-    # A basic quoted-arg parser
-
-    for quote in "“‟”":
-        arg_string = arg_string.replace(quote, "\"")
-
-    if arg_string.startswith("\""):
-        end_quote = arg_string[1:].find("\"") + 1
-        if end_quote > 0:
-            return arg_string[1:end_quote], arg_string[end_quote + 1:].strip()
-        else:
-            return arg_string[1:], None
-
-    next_space = find_with_predicate(arg_string, lambda ch: ch.isspace())
-    if next_space >= 0:
-        return arg_string[:next_space].strip(), arg_string[next_space:].strip()
-    else:
-        return arg_string.strip(), None
-
-
-class CommandError(Exception):
-    def __init__(self, text: str, help: Tuple[str, str] = None):
-        self.text = text
-        self.help = help
-
-    def format(self):
-        return "\u274c " + self.text, embeds.error("", self.help) if self.help else None
-
-
-class CommandContext:
-    client: discord.Client
-    message: discord.Message
-
-    def __init__(self, client: discord.Client, message: discord.Message, conn, args: str, system: Optional[System]):
-        self.client = client
-        self.message = message
-        self.conn = conn
-        self.args = args
-        self._system = system
-
-    async def get_system(self) -> Optional[System]:
-        return self._system
-
-    async def ensure_system(self) -> System:
-        system = await self.get_system()
-
-        if not system:
-            raise CommandError("No system registered to this account. Use `pk;system new` to register one.")
-
-        return system
-
-    def has_next(self) -> bool:
-        return bool(self.args)
-
-    def format_time(self, dt: datetime):
-        if self._system:
-            return self._system.format_time(dt)
-        return dt.isoformat(sep=" ", timespec="seconds") + " UTC"
-
-    def pop_str(self, error: CommandError = None) -> Optional[str]:
-        if not self.args:
-            if error:
-                raise error
-            return None
-
-        popped, self.args = next_arg(self.args)
-        return popped
-
-    def peek_str(self) -> Optional[str]:
-        if not self.args:
-            return None
-        popped, _ = next_arg(self.args)
-        return popped
-
-    def match(self, next) -> bool:
-        peeked = self.peek_str()
-        if peeked and peeked.lower() == next.lower():
-            self.pop_str()
-            return True
-        return False
-
-    async def pop_system(self, error: CommandError = None) -> System:
-        name = self.pop_str(error)
-        system = await utils.get_system_fuzzy(self.conn, self.client, name)
-
-        if not system:
-            raise CommandError("Unable to find system '{}'.".format(name))
-
-        return system
-
-    async def pop_member(self, error: CommandError = None, system_only: bool = True) -> Member:
-        name = self.pop_str(error)
-
-        if system_only:
-            system = await self.ensure_system()
-        else:
-            system = await self.get_system()
-
-        member = await utils.get_member_fuzzy(self.conn, system.id if system else None, name, system_only)
-        if not member:
-            raise CommandError("Unable to find member '{}'{}.".format(name, " in your system" if system_only else ""))
-
-        return member
-
-    def remaining(self):
-        return self.args
-
-    async def reply(self, content=None, embed=None):
-        return await self.message.channel.send(content=content, embed=embed)
-
-    async def reply_ok(self, content=None, embed=None):
-        return await self.reply(content="\u2705 {}".format(content or ""), embed=embed)
-
-    async def reply_warn(self, content=None, embed=None):
-        return await self.reply(content="\u26a0 {}".format(content or ""), embed=embed)
-
-    async def reply_ok_dm(self, content: str):
-        if isinstance(self.message.channel, discord.DMChannel):
-            await self.reply_ok(content="\u2705 {}".format(content or ""))
-        else:
-            await self.message.author.send(content="\u2705 {}".format(content or ""))
-            await self.reply_ok("DM'd!")
-
-    async def confirm_react(self, user: Union[discord.Member, discord.User], message: discord.Message):
-        await message.add_reaction("\u2705")  # Checkmark
-        await message.add_reaction("\u274c")  # Red X
-
-        try:
-            reaction, _ = await self.client.wait_for("reaction_add",
-                                                     check=lambda r, u: u.id == user.id and r.emoji in ["\u2705",
-                                                                                                        "\u274c"],
-                                                     timeout=60.0 * 5)
-            return reaction.emoji == "\u2705"
-        except asyncio.TimeoutError:
-            raise CommandError("Timed out - try again.")
-
-    async def confirm_text(self, user: discord.Member, channel: discord.TextChannel, confirm_text: str, message: str):
-        await self.reply(message)
-
-        try:
-            message = await self.client.wait_for("message",
-                                                 check=lambda m: m.channel.id == channel.id and m.author.id == user.id,
-                                                 timeout=60.0 * 5)
-            return message.content.lower() == confirm_text.lower()
-        except asyncio.TimeoutError:
-            raise CommandError("Timed out - try again.")
-
-
-import pluralkit.bot.commands.api_commands
-import pluralkit.bot.commands.import_commands
-import pluralkit.bot.commands.member_commands
-import pluralkit.bot.commands.message_commands
-import pluralkit.bot.commands.misc_commands
-import pluralkit.bot.commands.mod_commands
-import pluralkit.bot.commands.switch_commands
-import pluralkit.bot.commands.system_commands
-
-
-async def command_root(ctx: CommandContext):
-    if ctx.match("system") or ctx.match("s"):
-        await system_commands.system_root(ctx)
-    elif ctx.match("member") or ctx.match("m"):
-        await member_commands.member_root(ctx)
-    elif ctx.match("link"):
-        await system_commands.account_link(ctx)
-    elif ctx.match("unlink"):
-        await system_commands.account_unlink(ctx)
-    elif ctx.match("message"):
-        await message_commands.message_info(ctx)
-    elif ctx.match("log"):
-        await mod_commands.set_log(ctx)
-    elif ctx.match("invite"):
-        await misc_commands.invite_link(ctx)
-    elif ctx.match("export"):
-        await misc_commands.export(ctx)
-    elif ctx.match("switch") or ctx.match("sw"):
-        await switch_commands.switch_root(ctx)
-    elif ctx.match("token"):
-        await api_commands.token_root(ctx)
-    elif ctx.match("import"):
-        await import_commands.import_root(ctx)
-    elif ctx.match("help"):
-        await misc_commands.help_root(ctx)
-    elif ctx.match("tell"):
-        await misc_commands.tell(ctx)
-    elif ctx.match("fire"):
-        await misc_commands.pkfire(ctx)
-    elif ctx.match("thunder"):
-        await misc_commands.pkthunder(ctx)
-    elif ctx.match("freeze"):
-        await misc_commands.pkfreeze(ctx)
-    elif ctx.match("starstorm"):
-        await misc_commands.pkstarstorm(ctx)
-    elif ctx.match("mn"):
-        await misc_commands.pkmn(ctx)
-    elif ctx.match("commands"):
-        await misc_commands.command_list(ctx)
-    else:
-        raise CommandError("Unknown command {}. For a list of commands, type `pk;commands`.".format(ctx.pop_str()))
-
-
-async def run_command(ctx: CommandContext, func):
-    # lol nested try
-    try:
-        try:
-            await func(ctx)
-        except PluralKitError as e:
-            raise CommandError(e.message, e.help_page)
-    except CommandError as e:
-        content, embed = e.format()
-        await ctx.reply(content=content, embed=embed)
-
-
-async def command_dispatch(client: discord.Client, message: discord.Message, conn) -> bool:
-    prefix = "^(pk(;|!)|<@{}> )".format(client.user.id)
-    regex = re.compile(prefix, re.IGNORECASE)
-
-    cmd = message.content
-    match = regex.match(cmd)
-    if match:
-        remaining_string = cmd[match.span()[1]:].strip()
-        ctx = CommandContext(
-            client=client,
-            message=message,
-            conn=conn,
-            args=remaining_string,
-            system=await System.get_by_account(conn, message.author.id)
-        )
-        await run_command(ctx, command_root)
-        return True
-    return False

src/pluralkit/bot/commands/api_commands.py

@@ -1,35 +0,0 @@
-from pluralkit.bot.commands import CommandContext
-
-disclaimer = "\u26A0 Please note that this grants access to modify (and delete!) all your system data, so keep it safe and secure. If it leaks or you need a new one, you can invalidate this one with `pk;token refresh`."
-
-
-async def token_root(ctx: CommandContext):
-    if ctx.match("refresh") or ctx.match("expire") or ctx.match("invalidate") or ctx.match("update"):
-        await token_refresh(ctx)
-    else:
-        await token_get(ctx)
-
-
-async def token_get(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    if system.token:
-        token = system.token
-    else:
-        token = await system.refresh_token(ctx.conn)
-
-    token_message = "{}\n\u2705 Here's your API token:".format(disclaimer)
-    if token:
-        await ctx.reply_ok("DM'd!")
-        await ctx.message.author.send(token_message)
-        await ctx.message.author.send(token)
-    return
-
-async def token_refresh(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    token = await system.refresh_token(ctx.conn)
-    token_message = "Your previous API token has been invalidated. You will need to change it anywhere it's currently used.\n{}\n\u2705 Here's your new API token:".format(disclaimer)
-    if token:
-        await ctx.message.author.send(token_message)
-        await ctx.message.author.send(token)

src/pluralkit/bot/commands/import_commands.py

@@ -1,49 +0,0 @@
-import aiohttp
-import asyncio
-import io
-import json
-import os
-from datetime import datetime
-
-from pluralkit.errors import TupperboxImportError
-from pluralkit.bot.commands import *
-
-async def import_root(ctx: CommandContext):
-    # Only one import method rn, so why not default to Tupperbox?
-    await import_tupperbox(ctx)
-
-
-async def import_tupperbox(ctx: CommandContext):
-    await ctx.reply("To import from Tupperbox, reply to this message with a `tuppers.json` file imported from Tupperbox.\n\nTo obtain such a file, type `tul!export` (or your server's equivalent).")
-        
-    def predicate(msg):
-        if msg.author.id != ctx.message.author.id:
-            return False
-        if msg.attachments:
-            if msg.attachments[0].filename.endswith(".json"):
-                return True
-        return False
-
-    try:
-        message = await ctx.client.wait_for("message", check=predicate, timeout=60*5)
-    except asyncio.TimeoutError:
-        raise CommandError("Timed out. Try running `pk;import` again.")
-
-    s = io.BytesIO()
-    await message.attachments[0].save(s, use_cached=False)
-    data = json.load(s)
-    
-    system = await ctx.get_system()
-    if not system:
-        system = await System.create_system(ctx.conn, account_id=ctx.message.author.id)
-    
-    result = await system.import_from_tupperbox(ctx.conn, data)
-    tag_note = ""
-    if len(result.tags) > 1:
-        tag_note = "\n\nPluralKit's tags work on a per-system basis. Since your Tupperbox members have more than one unique tag, PluralKit has not imported the tags. Set your system tag manually with `pk;system tag <tag>`."
-    
-    await ctx.reply_ok("Updated {} member{}, created {} member{}. Type `pk;system list` to check!{}".format(
-        len(result.updated), "s" if len(result.updated) != 1 else "",
-        len(result.created), "s" if len(result.created) != 1 else "",
-        tag_note
-    ))

src/pluralkit/bot/commands/member_commands.py

@@ -1,195 +0,0 @@
-import pluralkit.bot.embeds
-from pluralkit.bot import help
-from pluralkit.bot.commands import *
-from pluralkit.errors import PluralKitError
-
-
-async def member_root(ctx: CommandContext):
-    if ctx.match("new") or ctx.match("create") or ctx.match("add") or ctx.match("register"):
-        await new_member(ctx)
-    elif ctx.match("set"):
-        await member_set(ctx)
-    # TODO "pk;member list"
-    elif not ctx.has_next():
-        raise CommandError("Must pass a subcommand. For a list of subcommands, type `pk;help member`.")
-    else:
-        await specific_member_root(ctx)
-
-
-async def specific_member_root(ctx: CommandContext):
-    member = await ctx.pop_member(system_only=False)
-
-    if ctx.has_next():
-        # Following commands operate on members only in the caller's own system
-        # error if not, to make sure you can't destructively edit someone else's member
-        system = await ctx.ensure_system()
-        if not member.system == system.id:
-            raise CommandError("Member must be in your own system.")
-
-        if ctx.match("name") or ctx.match("rename"):
-            await member_name(ctx, member)
-        elif ctx.match("description") or ctx.match("desc"):
-            await member_description(ctx, member)
-        elif ctx.match("avatar") or ctx.match("icon"):
-            await member_avatar(ctx, member)
-        elif ctx.match("proxy") or ctx.match("tags"):
-            await member_proxy(ctx, member)
-        elif ctx.match("pronouns") or ctx.match("pronoun"):
-            await member_pronouns(ctx, member)
-        elif ctx.match("color") or ctx.match("colour"):
-            await member_color(ctx, member)
-        elif ctx.match("birthday") or ctx.match("birthdate") or ctx.match("bday"):
-            await member_birthdate(ctx, member)
-        elif ctx.match("delete") or ctx.match("remove") or ctx.match("destroy") or ctx.match("erase"):
-            await member_delete(ctx, member)
-        else:
-            raise CommandError(
-                "Unknown subcommand {}. For a list of all commands, type `pk;help member`".format(ctx.pop_str()))
-    else:
-        # Basic lookup
-        await member_info(ctx, member)
-
-
-async def member_info(ctx: CommandContext, member: Member):
-    await ctx.reply(embed=await pluralkit.bot.embeds.member_card(ctx.conn, member))
-
-
-async def new_member(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    if not ctx.has_next():
-        raise CommandError("You must pass a name for the new member.")
-
-    new_name = ctx.remaining()
-
-    existing_member = await Member.get_member_by_name(ctx.conn, system.id, new_name)
-    if existing_member:
-        msg = await ctx.reply_warn(
-            "There is already a member with this name, with the ID `{}`. Do you want to create a duplicate member anyway?".format(
-                existing_member.hid))
-        if not await ctx.confirm_react(ctx.message.author, msg):
-            raise CommandError("Member creation cancelled.")
-
-    try:
-        member = await system.create_member(ctx.conn, new_name)
-    except PluralKitError as e:
-        raise CommandError(e.message)
-
-    await ctx.reply_ok(
-        "Member \"{}\" (`{}`) registered! Type `pk;help member` for a list of commands to edit this member.".format(new_name, member.hid))
-
-
-async def member_set(ctx: CommandContext):
-    raise CommandError(
-        "`pk;member set` has been retired. Please use the new member modifying commands. Type `pk;help member` for a list.")
-
-
-async def member_name(ctx: CommandContext, member: Member):
-    system = await ctx.ensure_system()
-    new_name = ctx.pop_str(CommandError("You must pass a new member name."))
-
-    # Warn if there's a member by the same name already
-    existing_member = await Member.get_member_by_name(ctx.conn, system.id, new_name)
-    if existing_member and existing_member.id != member.id:
-        msg = await ctx.reply_warn(
-            "There is already another member with this name, with the ID `{}`. Do you want to rename this member anyway? This will result in two members with the same name.".format(
-                existing_member.hid))
-        if not await ctx.confirm_react(ctx.message.author, msg):
-            raise CommandError("Member renaming cancelled.")
-
-    await member.set_name(ctx.conn, new_name)
-    await ctx.reply_ok("Member name updated.")
-
-    if len(new_name) < 2 and not system.tag:
-        await ctx.reply_warn(
-            "This member's new name is under 2 characters, and thus cannot be proxied. To prevent this, use a longer member name, or add a system tag.")
-    elif len(new_name) > 32:
-        exceeds_by = len(new_name) - 32
-        await ctx.reply_warn(
-            "This member's new name is longer than 32 characters, and thus cannot be proxied. To prevent this, shorten the member name by {} characters.".format(
-                exceeds_by))
-    elif len(new_name) > system.get_member_name_limit():
-        exceeds_by = len(new_name) - system.get_member_name_limit()
-        await ctx.reply_warn(
-            "This member's new name, when combined with the system tag `{}`, is longer than 32 characters, and thus cannot be proxied. To prevent this, shorten the name or system tag by at least {} characters.".format(
-                system.tag, exceeds_by))
-
-
-async def member_description(ctx: CommandContext, member: Member):
-    new_description = ctx.remaining() or None
-
-    await member.set_description(ctx.conn, new_description)
-    await ctx.reply_ok("Member description {}.".format("updated" if new_description else "cleared"))
-
-
-async def member_avatar(ctx: CommandContext, member: Member):
-    new_avatar_url = ctx.remaining() or None
-
-    if new_avatar_url:
-        user = await utils.parse_mention(ctx.client, new_avatar_url)
-        if user:
-            new_avatar_url = user.avatar_url_as(format="png")
-    
-    if not new_avatar_url and ctx.message.attachments:
-        new_avatar_url = ctx.message.attachments[0].url
-
-    await member.set_avatar(ctx.conn, new_avatar_url)
-    await ctx.reply_ok("Member avatar {}.".format("updated" if new_avatar_url else "cleared"))
-
-
-async def member_color(ctx: CommandContext, member: Member):
-    new_color = ctx.remaining() or None
-
-    await member.set_color(ctx.conn, new_color)
-    await ctx.reply_ok("Member color {}.".format("updated" if new_color else "cleared"))
-
-
-async def member_pronouns(ctx: CommandContext, member: Member):
-    new_pronouns = ctx.remaining() or None
-
-    await member.set_pronouns(ctx.conn, new_pronouns)
-    await ctx.reply_ok("Member pronouns {}.".format("updated" if new_pronouns else "cleared"))
-
-
-async def member_birthdate(ctx: CommandContext, member: Member):
-    new_birthdate = ctx.remaining() or None
-
-    await member.set_birthdate(ctx.conn, new_birthdate)
-    await ctx.reply_ok("Member birthdate {}.".format("updated" if new_birthdate else "cleared"))
-
-
-async def member_proxy(ctx: CommandContext, member: Member):
-    if not ctx.has_next():
-        prefix, suffix = None, None
-    else:
-        # Sanity checking
-        example = ctx.remaining()
-        if "text" not in example:
-            raise CommandError("Example proxy message must contain the string 'text'. For help, type `pk;help proxy`.")
-
-        if example.count("text") != 1:
-            raise CommandError("Example proxy message must contain the string 'text' exactly once. For help, type `pk;help proxy`.")
-
-        # Extract prefix and suffix
-        prefix = example[:example.index("text")].strip()
-        suffix = example[example.index("text") + 4:].strip()
-
-        # DB stores empty strings as None, make that work
-        if not prefix:
-            prefix = None
-        if not suffix:
-            suffix = None
-
-    async with ctx.conn.transaction():
-        await member.set_proxy_tags(ctx.conn, prefix, suffix)
-    await ctx.reply_ok(
-        "Proxy settings updated." if prefix or suffix else "Proxy settings cleared. If you meant to set your proxy tags, type `pk;help proxy` for help.")
-
-
-async def member_delete(ctx: CommandContext, member: Member):
-    delete_confirm_msg = "Are you sure you want to delete {}? If so, reply to this message with the member's ID (`{}`).".format(
-        member.name, member.hid)
-    if not await ctx.confirm_text(ctx.message.author, ctx.message.channel, member.hid, delete_confirm_msg):
-        raise CommandError("Member deletion cancelled.")
-
-    await member.delete(ctx.conn)
-    await ctx.reply_ok("Member deleted.")

src/pluralkit/bot/commands/message_commands.py

@@ -1,18 +0,0 @@
-from pluralkit.bot.commands import *
-
-
-async def message_info(ctx: CommandContext):
-    mid_str = ctx.pop_str(CommandError("You must pass a message ID."))
-
-    try:
-        mid = int(mid_str)
-    except ValueError:
-        raise CommandError("You must pass a valid number as a message ID.")
-
-    # Find the message in the DB
-    message = await db.get_message(ctx.conn, mid)
-    if not message:
-        raise CommandError(
-            "Message with ID '{}' not found. Are you sure it's a message proxied by PluralKit?".format(mid))
-
-    await ctx.reply(embed=await embeds.message_card(ctx.client, message))

src/pluralkit/bot/commands/misc_commands.py

@@ -1,211 +0,0 @@
-import io
-import json
-import os
-from discord.utils import oauth_url
-
-from pluralkit.bot import help
-from pluralkit.bot.commands import *
-from pluralkit.bot.embeds import help_footer_embed
-
-prefix = "pk;" # TODO: configurable
-
-def make_footer_embed():
-    embed = discord.Embed()
-    embed.set_footer(text=help.helpfile["footer"])
-    return embed
-
-def make_command_embed(command):
-    embed = make_footer_embed()
-    embed.title = prefix + command["usage"]
-    embed.description = (command["description"] + "\n" + command.get("longdesc", "")).strip()
-    if "aliases" in command:
-        embed.add_field(name="Aliases" if len(command["aliases"]) > 1 else "Alias", value="\n".join([prefix + cmd for cmd in command["aliases"]]), inline=False)
-    embed.add_field(name="Usage", value=prefix + command["usage"], inline=False)
-    if "examples" in command:
-        embed.add_field(name="Examples" if len(command["examples"]) > 1 else "Example", value="\n".join([prefix + cmd for cmd in command["examples"]]), inline=False)
-    if "subcommands" in command:
-        embed.add_field(name="Subcommands", value="\n".join([command["name"] + " " + sc["name"] for sc in command["subcommands"]]), inline=False)
-    return embed
-
-def find_command(command_list, name):
-    for command in command_list:
-        if command["name"].lower().strip() == name.lower().strip():
-            return command
-
-async def help_root(ctx: CommandContext):
-    for page_name, page_content in help.helpfile["pages"].items():
-        if ctx.match(page_name):
-            return await help_page(ctx, page_content)
-
-    if not ctx.has_next():
-        return await help_page(ctx, help.helpfile["pages"]["root"])
-
-    return await help_command(ctx, ctx.remaining())
-
-async def help_page(ctx, sections):
-    msg = ""
-    for section in sections:
-        msg += "__**{}**__\n{}\n\n".format(section["name"], section["content"])
-
-    return await ctx.reply(content=msg, embed=make_footer_embed())
-
-async def help_command(ctx, command_name):
-    name_parts = command_name.replace(prefix, "").split(" ")
-    command = find_command(help.helpfile["commands"], name_parts[0])
-    name_parts = name_parts[1:]
-    if not command:
-        raise CommandError("Could not find command '{}'.".format(command_name))
-    while len(name_parts) > 0:
-        found_command = find_command(command["subcommands"], name_parts[0])
-        if not found_command:
-            break
-        command = found_command
-        name_parts = name_parts[1:]
-
-    return await ctx.reply(embed=make_command_embed(command))
-
-async def command_list(ctx):
-    cmds = []
-
-    categories = {}
-    def make_command_list(lst):
-        for cmd in lst:
-            if not cmd["category"] in categories:
-                categories[cmd["category"]] = []
-            categories[cmd["category"]].append("**{}{}** - {}".format(prefix, cmd["usage"], cmd["description"]))
-            if "subcommands" in cmd:
-                make_command_list(cmd["subcommands"])
-    make_command_list(help.helpfile["commands"])
-
-    embed = discord.Embed()
-    embed.title = "PluralKit Commands"
-    embed.description = "Type `pk;help <command>` for more information."
-    for cat_name, cat_cmds in categories.items():
-        embed.add_field(name=cat_name, value="\n".join(cat_cmds))
-    await ctx.reply(embed=embed)
-
-
-async def invite_link(ctx: CommandContext):
-    client_id = (await ctx.client.application_info()).id
-
-    permissions = discord.Permissions()
-
-    # So the bot can actually add the webhooks it needs to do the proxy functionality
-    permissions.manage_webhooks = True
-
-    # So the bot can respond with status, error, and success messages
-    permissions.send_messages = True
-
-    # So the bot can delete channels
-    permissions.manage_messages = True
-
-    # So the bot can respond with extended embeds, ex. member cards
-    permissions.embed_links = True
-
-    # So the bot can send images too
-    permissions.attach_files = True
-
-    # (unsure if it needs this, actually, might be necessary for message lookup)
-    permissions.read_message_history = True
-
-    # So the bot can add reactions for confirm/deny prompts
-    permissions.add_reactions = True
-
-    url = oauth_url(client_id, permissions)
-    await ctx.reply_ok("Use this link to add PluralKit to your server: {}".format(url))
-
-
-async def export(ctx: CommandContext):
-    working_msg = await ctx.message.channel.send("Working...")
-
-    system = await ctx.ensure_system()
-
-    members = await system.get_members(ctx.conn)
-    accounts = await system.get_linked_account_ids(ctx.conn)
-    switches = await system.get_switches(ctx.conn, 999999)
-
-    data = {
-        "name": system.name,
-        "id": system.hid,
-        "description": system.description,
-        "tag": system.tag,
-        "avatar_url": system.avatar_url,
-        "created": system.created.isoformat(),
-        "members": [
-            {
-                "name": member.name,
-                "id": member.hid,
-                "color": member.color,
-                "avatar_url": member.avatar_url,
-                "birthday": member.birthday.isoformat() if member.birthday else None,
-                "pronouns": member.pronouns,
-                "description": member.description,
-                "prefix": member.prefix,
-                "suffix": member.suffix,
-                "created": member.created.isoformat(),
-                "message_count": await member.message_count(ctx.conn)
-            } for member in members
-        ],
-        "accounts": [str(uid) for uid in accounts],
-        "switches": [
-            {
-                "timestamp": switch.timestamp.isoformat(),
-                "members": [member.hid for member in await switch.fetch_members(ctx.conn)]
-            } for switch in switches
-        ]  # TODO: messages
-    }
-
-    await working_msg.delete()
-
-    try:
-        # Try sending the file to the user in a DM first
-        f = io.BytesIO(json.dumps(data).encode("utf-8"))
-        await ctx.message.author.send(content="Here you go! \u2709", file=discord.File(fp=f, filename="pluralkit_system.json"))
-        if not isinstance(ctx.message.channel, discord.DMChannel):
-            await ctx.reply_ok("DM'd!")
-    except discord.Forbidden:
-        # If that fails, warn the user and ask whether the want the file posted in the channel
-        fallback_msg = await ctx.reply_warn("I'm not allowed to DM you! Do you want me to post the exported data here instead? I can delete the file after you save it if you want.")
-        # Use reactions to get their response
-        if not await ctx.confirm_react(ctx.message.author, fallback_msg):
-            raise CommandError("Export cancelled.")
-        f = io.BytesIO(json.dumps(data).encode("utf-8"))
-        # If they reacted with ✅, post the file in the channel and give them the option to delete it
-        fallback_data = await ctx.message.channel.send(content="Here you go! \u2709\nReact with \u2705 if you want me to delete the file.", file=discord.File(fp=f, filename="pluralkit_system.json"))
-        if not await ctx.confirm_react(ctx.message.author, fallback_data):
-            await fallback_data.add_reaction("👌")
-            return
-        await fallback_data.delete()
-        await ctx.reply_ok("Export file deleted.")
-
-
-async def tell(ctx: CommandContext):
-    # Dev command only
-    # This is used to tell members of servers I'm not in when something is broken so they can contact me with debug info
-    if ctx.message.author.id != 102083498529026048:
-        # Just silently fail, not really a public use command
-        return
-
-    channel = ctx.pop_str()
-    message = ctx.remaining()
-
-    # lol error handling
-    await ctx.client.get_channel(int(channel)).send(content="[dev message] " + message)
-    await ctx.reply_ok("Sent!")
-
-
-# Easter eggs lmao because why not
-async def pkfire(ctx: CommandContext):
-    await ctx.message.channel.send("*A giant lightning bolt promptly erupts into a pillar of fire as it hits your opponent.*")
-
-async def pkthunder(ctx: CommandContext):
-    await ctx.message.channel.send("*A giant ball of lightning is conjured and fired directly at your opponent, vanquishing them.*")
-
-async def pkfreeze(ctx: CommandContext):
-    await ctx.message.channel.send("*A giant crystal ball of ice is charged and hurled toward your opponent, bursting open and freezing them solid on contact.*")
-
-async def pkstarstorm(ctx: CommandContext):
-    await ctx.message.channel.send("*Vibrant colours burst forth from the sky as meteors rain down upon your opponent.*")
-
-async def pkmn(ctx: CommandContext):
-    await ctx.message.channel.send("Gotta catch 'em all!")

src/pluralkit/bot/commands/mod_commands.py

@@ -1,21 +0,0 @@
-from pluralkit.bot.commands import *
-
-
-async def set_log(ctx: CommandContext):
-    if not ctx.message.author.guild_permissions.administrator:
-        raise CommandError("You must be a server administrator to use this command.")
-
-    server = ctx.message.guild
-    if not server:
-        raise CommandError("This command can not be run in a DM.")
-
-    if not ctx.has_next():
-        channel_id = None
-    else:
-        channel = utils.parse_channel_mention(ctx.pop_str(), server=server)
-        if not channel:
-            raise CommandError("Channel not found.")
-        channel_id = channel.id
-
-    await db.update_server(ctx.conn, server.id, logging_channel_id=channel_id)
-    await ctx.reply_ok("Updated logging channel." if channel_id else "Cleared logging channel.")

src/pluralkit/bot/commands/switch_commands.py

@@ -1,158 +0,0 @@
-from datetime import datetime
-from typing import List
-
-import dateparser
-import pytz
-
-from pluralkit.bot.commands import *
-from pluralkit.bot.commands.system_commands import system_fronthistory
-from pluralkit.member import Member
-from pluralkit.utils import display_relative
-
-
-async def switch_root(ctx: CommandContext):
-    if not ctx.has_next():
-        # We could raise an error here, but we display the system front history instead as a shortcut
-        #raise CommandError("You must use a subcommand. For a list of subcommands, type `pk;help member`.")
-        await system_fronthistory(ctx, await ctx.ensure_system())
-    if ctx.match("out"):
-        await switch_out(ctx)
-    elif ctx.match("move"):
-        await switch_move(ctx)
-    elif ctx.match("delete") or ctx.match("remove") or ctx.match("erase") or ctx.match("cancel"):
-        await switch_delete(ctx)
-    else:
-        await switch_member(ctx)
-
-
-async def switch_member(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    if not ctx.has_next():
-        raise CommandError("You must pass at least one member name or ID to register a switch to.")
-
-    members: List[Member] = []
-    while ctx.has_next():
-        members.append(await ctx.pop_member())
-
-    # Log the switch
-    await system.add_switch(ctx.conn, members)
-
-    if len(members) == 1:
-        await ctx.reply_ok("Switch registered. Current fronter is now {}.".format(members[0].name))
-    else:
-        await ctx.reply_ok(
-            "Switch registered. Current fronters are now {}.".format(", ".join([m.name for m in members])))
-
-
-async def switch_out(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    switch = await system.get_latest_switch(ctx.conn)
-    if switch and not switch.members:
-        raise CommandError("There's already no one in front.")
-
-    # Log it, and don't log any members
-    await system.add_switch(ctx.conn, [])
-    await ctx.reply_ok("Switch-out registered.")
-
-
-async def switch_delete(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    last_two_switches = await system.get_switches(ctx.conn, 2)
-    if not last_two_switches:
-        raise CommandError("You do not have a logged switch to delete.")
-
-    last_switch = last_two_switches[0]
-    next_last_switch = last_two_switches[1] if len(last_two_switches) > 1 else None
-
-    last_switch_members = ", ".join([member.name for member in await last_switch.fetch_members(ctx.conn)])
-    last_switch_time = display_relative(last_switch.timestamp)
-
-    if next_last_switch:
-        next_last_switch_members = ", ".join([member.name for member in await next_last_switch.fetch_members(ctx.conn)])
-        next_last_switch_time = display_relative(next_last_switch.timestamp)
-        msg = await ctx.reply_warn("This will delete the latest switch ({}, {} ago). The next latest switch is {} ({} ago). Is this okay?".format(last_switch_members, last_switch_time, next_last_switch_members, next_last_switch_time))
-    else:
-        msg = await ctx.reply_warn("This will delete the latest switch ({}, {} ago). You have no other switches logged. Is this okay?".format(last_switch_members, last_switch_time))
-
-    if not await ctx.confirm_react(ctx.message.author, msg):
-        raise CommandError("Switch deletion cancelled.")
-
-    await last_switch.delete(ctx.conn)
-
-    if next_last_switch:
-        # lol block scope amirite
-        # but yeah this is fine
-        await ctx.reply_ok("Switch deleted. Next latest switch is now {} ({} ago).".format(next_last_switch_members, next_last_switch_time))
-    else:
-        await ctx.reply_ok("Switch deleted. You now have no logged switches.")
-
-
-async def switch_move(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    if not ctx.has_next():
-        raise CommandError("You must pass a time to move the switch to.")
-
-    # Parse the time to move to
-    new_time = dateparser.parse(ctx.remaining(), languages=["en"], settings={
-        # Tell it to default to the system's given time zone
-        # If no time zone was given *explicitly in the string* it'll return as naive
-        "TIMEZONE": system.ui_tz
-    })
-
-    if not new_time:
-        raise CommandError("'{}' can't be parsed as a valid time.".format(ctx.remaining()))
-
-    tz = pytz.timezone(system.ui_tz)
-    # So we default to putting the system's time zone in the tzinfo
-    if not new_time.tzinfo:
-        new_time = tz.localize(new_time)
-
-    # Now that we have a system-time datetime, convert this to UTC and make it naive since that's what we deal with
-    new_time = pytz.utc.normalize(new_time).replace(tzinfo=None)
-
-    # Make sure the time isn't in the future
-    if new_time > datetime.utcnow():
-        raise CommandError("Can't move switch to a time in the future.")
-
-    # Make sure it all runs in a big transaction for atomicity
-    async with ctx.conn.transaction():
-        # Get the last two switches to make sure the switch to move isn't before the second-last switch
-        last_two_switches = await system.get_switches(ctx.conn, 2)
-        if len(last_two_switches) == 0:
-            raise CommandError("There are no registered switches for this system.")
-
-        last_switch = last_two_switches[0]
-        if len(last_two_switches) > 1:
-            second_last_switch = last_two_switches[1]
-
-            if new_time < second_last_switch.timestamp:
-                time_str = display_relative(second_last_switch.timestamp)
-                raise CommandError(
-                    "Can't move switch to before last switch time ({} ago), as it would cause conflicts.".format(time_str))
-
-        # Display the confirmation message w/ humanized times
-        last_fronters = await last_switch.fetch_members(ctx.conn)
-
-        members = ", ".join([member.name for member in last_fronters]) or "nobody"
-        last_absolute = ctx.format_time(last_switch.timestamp)
-        last_relative = display_relative(last_switch.timestamp)
-        new_absolute = ctx.format_time(new_time)
-        new_relative = display_relative(new_time)
-
-        # Confirm with user
-        switch_confirm_message = await ctx.reply(
-            "This will move the latest switch ({}) from {} ({} ago) to {} ({} ago). Is this OK?".format(members,
-                                                                                                        last_absolute,
-                                                                                                        last_relative,
-                                                                                                        new_absolute,
-                                                                                                        new_relative))
-
-        if not await ctx.confirm_react(ctx.message.author, switch_confirm_message):
-            raise CommandError("Switch move cancelled.")
-
-        # Actually move the switch
-        await last_switch.move(ctx.conn, new_time)
-        await ctx.reply_ok("Switch moved.")

src/pluralkit/bot/commands/system_commands.py

@@ -1,446 +0,0 @@
-from datetime import datetime, timedelta
-
-import aiohttp
-import dateparser
-import humanize
-import math
-import timezonefinder
-import pytz
-
-import pluralkit.bot.embeds
-from pluralkit.bot.commands import *
-from pluralkit.errors import ExistingSystemError, UnlinkingLastAccountError, AccountAlreadyLinkedError
-from pluralkit.utils import display_relative
-
-# This needs to load from the timezone file so we're preloading this so we
-# don't have to do it on every invocation
-tzf = timezonefinder.TimezoneFinder()
-
-async def system_root(ctx: CommandContext):
-    # Commands that operate without a specified system (usually defaults to the executor's own system)
-    if ctx.match("name") or ctx.match("rename"):
-        await system_name(ctx)
-    elif ctx.match("description") or ctx.match("desc"):
-        await system_description(ctx)
-    elif ctx.match("avatar") or ctx.match("icon"):
-        await system_avatar(ctx)
-    elif ctx.match("tag"):
-        await system_tag(ctx)
-    elif ctx.match("new") or ctx.match("register") or ctx.match("create") or ctx.match("init"):
-        await system_new(ctx)
-    elif ctx.match("delete") or ctx.match("remove") or ctx.match("destroy") or ctx.match("erase"):
-        await system_delete(ctx)
-    elif ctx.match("front") or ctx.match("fronter") or ctx.match("fronters"):
-        await system_fronter(ctx, await ctx.ensure_system())
-    elif ctx.match("fronthistory") or ctx.match("fh") or ctx.match("history") or ctx.match("switches"):
-        await system_fronthistory(ctx, await ctx.ensure_system())
-    elif ctx.match("frontpercent") or ctx.match("frontbreakdown") or ctx.match("frontpercentage") or ctx.match("front%") or ctx.match("fp"):
-        await system_frontpercent(ctx, await ctx.ensure_system())
-    elif ctx.match("timezone") or ctx.match("tz"):
-        await system_timezone(ctx)
-    elif ctx.match("set"):
-        await system_set(ctx)
-    elif ctx.match("list") or ctx.match("members"):
-        await system_list(ctx, await ctx.ensure_system())
-    elif not ctx.has_next():
-        # (no argument, command ends here, default to showing own system)
-        await system_info(ctx, await ctx.ensure_system())
-    else:
-        # If nothing matches, the next argument is likely a system name/ID, so delegate
-        # to the specific system root
-        await specified_system_root(ctx)
-
-
-async def specified_system_root(ctx: CommandContext):
-    # Commands that operate on a specified system (ie. not necessarily the command executor's)
-    system_name = ctx.pop_str()
-    system = await utils.get_system_fuzzy(ctx.conn, ctx.client, system_name)
-    if not system:
-        raise CommandError(
-            "Unable to find system `{}`. If you meant to run a command, type `pk;help system` for a list of system commands.".format(
-                system_name))
-
-    if ctx.match("front") or ctx.match("fronter"):
-        await system_fronter(ctx, system)
-    elif ctx.match("fronthistory"):
-        await system_fronthistory(ctx, system)
-    elif ctx.match("frontpercent") or ctx.match("frontbreakdown") or ctx.match("frontpercentage"):
-        await system_frontpercent(ctx, system)
-    elif ctx.match("list") or ctx.match("members"):
-        await system_list(ctx, system)
-    else:
-        await system_info(ctx, system)
-
-
-async def system_info(ctx: CommandContext, system: System):
-    this_system = await ctx.get_system()
-    await ctx.reply(embed=await pluralkit.bot.embeds.system_card(ctx.conn, ctx.client, system, this_system and this_system.id == system.id))
-
-
-async def system_new(ctx: CommandContext):
-    new_name = ctx.remaining() or None
-
-    try:
-        await System.create_system(ctx.conn, ctx.message.author.id, new_name)
-    except ExistingSystemError as e:
-        raise CommandError(e.message)
-
-    await ctx.reply_ok("System registered! To begin adding members, use `pk;member new <name>`.")
-
-
-async def system_set(ctx: CommandContext):
-    raise CommandError(
-        "`pk;system set` has been retired. Please use the new system modifying commands. Type `pk;help system` for a list.")
-
-
-async def system_name(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    new_name = ctx.remaining() or None
-
-    await system.set_name(ctx.conn, new_name)
-    await ctx.reply_ok("System name {}.".format("updated" if new_name else "cleared"))
-
-
-async def system_description(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    new_description = ctx.remaining() or None
-
-    await system.set_description(ctx.conn, new_description)
-    await ctx.reply_ok("System description {}.".format("updated" if new_description else "cleared"))
-
-
-async def system_timezone(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    city_query = ctx.remaining() or None
-
-    msg = await ctx.reply("\U0001F50D Searching '{}' (may take a while)...".format(city_query))
-
-    # Look up the city on Overpass (OpenStreetMap)
-    async with aiohttp.ClientSession() as sess:
-        # OverpassQL is weird, but this basically searches for every node of type city with name [input].
-        async with sess.get("https://nominatim.openstreetmap.org/search?city=novosibirsk&format=json&limit=1", params={"city": city_query, "format": "json", "limit": "1"}) as r:
-            if r.status != 200:
-                raise CommandError("OSM Nominatim API returned error. Try again.")
-            data = await r.json()
-
-    # If we didn't find a city, complain
-    if not data:
-        raise CommandError("City '{}' not found.".format(city_query))
-
-    # Take the lat/long given by Overpass and put it into timezonefinder
-    lat, lng = (float(data[0]["lat"]), float(data[0]["lon"]))
-    timezone_name = tzf.timezone_at(lng=lng, lat=lat)
-
-    # Also delete the original searching message
-    await msg.delete()
-
-    if not timezone_name:
-        raise CommandError("Time zone for city '{}' not found. This should never happen.".format(data[0]["display_name"]))
-
-    # This should hopefully result in a valid time zone name
-    # (if not, something went wrong)
-    tz = await system.set_time_zone(ctx.conn, timezone_name)
-    offset = tz.utcoffset(datetime.utcnow())
-    offset_str = "UTC{:+02d}:{:02d}".format(int(offset.total_seconds() // 3600), int(offset.total_seconds() // 60 % 60))
-
-    await ctx.reply_ok("System time zone set to {} ({}, {}).\n*Data from OpenStreetMap, queried using Nominatim.*".format(tz.tzname(datetime.utcnow()), offset_str, tz.zone))
-
-
-async def system_tag(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    new_tag = ctx.remaining() or None
-
-    await system.set_tag(ctx.conn, new_tag)
-    await ctx.reply_ok("System tag {}.".format("updated" if new_tag else "cleared"))
-
-    # System class is immutable, update the tag so get_member_name_limit works
-    system = system._replace(tag=new_tag)
-    members = await system.get_members(ctx.conn)
-
-    # Certain members might not be able to be proxied with this new tag, show a warning for those
-    members_exceeding = [member for member in members if
-                         len(member.name) > system.get_member_name_limit()]
-    if members_exceeding:
-        member_names = ", ".join([member.name for member in members_exceeding])
-        await ctx.reply_warn(
-            "Due to the length of this tag, the following members will not be able to be proxied: {}. Please use a shorter tag to prevent this.".format(
-                member_names))
-
-    # Edge case: members with name length 1 and no new tag
-    if not new_tag:
-        one_length_members = [member for member in members if len(member.name) == 1]
-        if one_length_members:
-            member_names = ", ".join([member.name for member in one_length_members])
-            await ctx.reply_warn(
-                "Without a system tag, you will not be able to proxy members with a one-character name: {}. To prevent this, please add a system tag or lengthen their name.".format(
-                    member_names))
-
-
-async def system_avatar(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    new_avatar_url = ctx.remaining() or None
-
-    if new_avatar_url:
-        user = await utils.parse_mention(ctx.client, new_avatar_url)
-        if user:
-            new_avatar_url = user.avatar_url_as(format="png")
-    
-    if not new_avatar_url and ctx.message.attachments[0]:
-        new_avatar_url = ctx.message.attachments[0].url
-
-    await system.set_avatar(ctx.conn, new_avatar_url)
-    await ctx.reply_ok("System avatar {}.".format("updated" if new_avatar_url else "cleared"))
-
-
-async def account_link(ctx: CommandContext):
-    system = await ctx.ensure_system()
-    account_name = ctx.pop_str(CommandError(
-        "You must pass an account to link this system to. You can either use a \\@mention, or a raw account ID."))
-
-    # Do the sanity checking here too (despite it being done in System.link_account)
-    # Because we want it to be done before the confirmation dialog is shown
-
-    # Find account to link
-    linkee = await utils.parse_mention(ctx.client, account_name)
-    if not linkee:
-        raise CommandError("Account `{}` not found.".format(account_name))
-
-    # Make sure account doesn't already have a system
-    account_system = await System.get_by_account(ctx.conn, linkee.id)
-    if account_system:
-        raise CommandError(AccountAlreadyLinkedError(account_system).message)
-
-    msg = await ctx.reply(
-        "{}, please confirm the link by clicking the \u2705 reaction on this message.".format(linkee.mention))
-    if not await ctx.confirm_react(linkee, msg):
-        raise CommandError("Account link cancelled.")
-
-    await system.link_account(ctx.conn, linkee.id)
-    await ctx.reply_ok("Account linked to system.")
-
-
-async def account_unlink(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    msg = await ctx.reply("Are you sure you want to unlink this account from your system?")
-    if not await ctx.confirm_react(ctx.message.author, msg):
-        raise CommandError("Account unlink cancelled.")
-
-    try:
-        await system.unlink_account(ctx.conn, ctx.message.author.id)
-    except UnlinkingLastAccountError as e:
-        raise CommandError(e.message)
-
-    await ctx.reply_ok("Account unlinked.")
-
-
-async def system_fronter(ctx: CommandContext, system: System):
-    embed = await embeds.front_status(ctx, await system.get_latest_switch(ctx.conn))
-    await ctx.reply(embed=embed)
-
-
-async def system_fronthistory(ctx: CommandContext, system: System):
-    lines = []
-    front_history = await pluralkit.utils.get_front_history(ctx.conn, system.id, count=10)
-
-    if not front_history:
-        raise CommandError("You have no logged switches. Use `pk;switch [member] [extra members...]` to start logging.")
-
-    for i, (timestamp, members) in enumerate(front_history):
-        # Special case when no one's fronting
-        if len(members) == 0:
-            name = "(no fronter)"
-        else:
-            name = ", ".join([member.name for member in members])
-
-        # Make proper date string
-        time_text = ctx.format_time(timestamp)
-        rel_text = display_relative(timestamp)
-
-        delta_text = ""
-        if i > 0:
-            last_switch_time = front_history[i - 1][0]
-            delta_text = ", for {}".format(display_relative(timestamp - last_switch_time))
-        lines.append("**{}** ({}, {} ago{})".format(name, time_text, rel_text, delta_text))
-
-    embed = embeds.status("\n".join(lines) or "(none)")
-    embed.title = "Past switches"
-    await ctx.reply(embed=embed)
-
-
-async def system_delete(ctx: CommandContext):
-    system = await ctx.ensure_system()
-
-    delete_confirm_msg = "Are you sure you want to delete your system? If so, reply to this message with the system's ID (`{}`).".format(
-        system.hid)
-    if not await ctx.confirm_text(ctx.message.author, ctx.message.channel, system.hid, delete_confirm_msg):
-        raise CommandError("System deletion cancelled.")
-
-    await system.delete(ctx.conn)
-    await ctx.reply_ok("System deleted.")
-
-
-async def system_frontpercent(ctx: CommandContext, system: System):
-    # Parse the time limit (will go this far back)
-    if ctx.remaining():
-        before = dateparser.parse(ctx.remaining(), languages=["en"], settings={
-            "TO_TIMEZONE": "UTC",
-            "RETURN_AS_TIMEZONE_AWARE": False
-        })
-
-        if not before:
-            raise CommandError("Could not parse '{}' as a valid time.".format(ctx.remaining()))
-
-        # If time is in the future, just kinda discard
-        if before and before > datetime.utcnow():
-            before = None
-    else:
-        before = datetime.utcnow() - timedelta(days=30)
-
-    # Fetch list of switches
-    all_switches = await pluralkit.utils.get_front_history(ctx.conn, system.id, 99999)
-    if not all_switches:
-        raise CommandError("No switches registered to this system.")
-
-    # Cull the switches *ending* before the limit, if given
-    # We'll need to find the first switch starting before the limit, then cut off every switch *before* that
-    if before:
-        for last_stamp, _ in all_switches:
-            if last_stamp < before:
-                break
-
-        all_switches = [(stamp, members) for stamp, members in all_switches if stamp >= last_stamp]
-
-    start_times = [stamp for stamp, _ in all_switches]
-    end_times = [datetime.utcnow()] + start_times
-    switch_members = [members for _, members in all_switches]
-
-    # Gonna save a list of members by ID for future lookup too
-    members_by_id = {}
-
-    # Using the ID as a key here because it's a simple number that can be hashed and used as a key
-    member_times = {}
-    for start_time, end_time, members in zip(start_times, end_times, switch_members):
-        # Cut off parts of the switch that occurs before the time limit (will only happen if this is the last switch)
-        if before and start_time < before:
-            start_time = before
-
-        # Calculate length of the switch
-        switch_length = end_time - start_time
-
-        def add_switch(id, length):
-            if id not in member_times:
-                member_times[id] = length
-            else:
-                member_times[id] += length
-
-        for member in members:
-            # Add the switch length to the currently registered time for that member
-            add_switch(member.id, switch_length)
-
-            # Also save the member in the ID map for future reference
-            members_by_id[member.id] = member
-
-        # Also register a no-fronter switch with the key None
-        if not members:
-            add_switch(None, switch_length)
-
-    # Find the total timespan of the range
-    span_start = max(start_times[-1], before) if before else start_times[-1]
-    total_time = datetime.utcnow() - span_start
-
-    embed = embeds.status("")
-    for member_id, front_time in sorted(member_times.items(), key=lambda x: x[1], reverse=True):
-        member = members_by_id[member_id] if member_id else None
-
-        # Calculate percent
-        fraction = front_time / total_time
-        percent = round(fraction * 100)
-
-        embed.add_field(name=member.name if member else "(no fronter)",
-                        value="{}% ({})".format(percent, humanize.naturaldelta(front_time)))
-
-    embed.set_footer(text="Since {} ({} ago)".format(ctx.format_time(span_start),
-                                                     display_relative(span_start)))
-    await ctx.reply(embed=embed)
-
-async def system_list(ctx: CommandContext, system: System):
-    # TODO: refactor this
-
-    all_members = sorted(await system.get_members(ctx.conn), key=lambda m: m.name.lower())
-    if ctx.match("full"):
-        page_size = 8
-        if len(all_members) <= page_size:
-            # If we have less than 8 members, don't bother paginating
-            await ctx.reply(embed=embeds.member_list_full(system, all_members, 0, page_size))
-        else:
-            current_page = 0
-            msg: discord.Message = None
-            while True:
-                page_count = math.ceil(len(all_members) / page_size)
-                embed = embeds.member_list_full(system, all_members, current_page, page_size)
-
-                # Add reactions for moving back and forth
-                if not msg:
-                    msg = await ctx.reply(embed=embed)
-                    await msg.add_reaction("\u2B05")
-                    await msg.add_reaction("\u27A1")
-                else:
-                    await msg.edit(embed=embed)
-
-                def check(reaction, user):
-                    return user.id == ctx.message.author.id and reaction.emoji in ["\u2B05", "\u27A1"]
-
-                try:
-                    reaction, _ = await ctx.client.wait_for("reaction_add", timeout=5*60, check=check)
-                except asyncio.TimeoutError:
-                    return
-
-                if reaction.emoji == "\u2B05":
-                    current_page = (current_page - 1) % page_count
-                elif reaction.emoji == "\u27A1":
-                    current_page = (current_page + 1) % page_count
-
-                # If we can, remove the original reaction from the member
-                # Don't bother checking permission if we're in DMs (wouldn't work anyway)
-                if ctx.message.guild:
-                    if ctx.message.channel.permissions_for(ctx.message.guild.get_member(ctx.client.user.id)).manage_messages:
-                        await reaction.remove(ctx.message.author)
-    else:
-
-        #Basically same code as above
-        #25 members at a time seems handy
-        page_size = 25
-        if len(all_members) <= page_size:
-            # If we have less than 25 members, don't bother paginating
-            await ctx.reply(embed=embeds.member_list_short(system, all_members, 0, page_size))
-        else:
-            current_page = 0
-            msg: discord.Message = None
-            while True:
-                page_count = math.ceil(len(all_members) / page_size)
-                embed = embeds.member_list_short(system, all_members, current_page, page_size)
-
-                if not msg:
-                    msg = await ctx.reply(embed=embed)
-                    await msg.add_reaction("\u2B05")
-                    await msg.add_reaction("\u27A1")
-                else:
-                    await msg.edit(embed=embed)
-
-                def check(reaction, user):
-                    return user.id == ctx.message.author.id and reaction.emoji in ["\u2B05", "\u27A1"]
-
-                try:
-                    reaction, _ = await ctx.client.wait_for("reaction_add", timeout=5*60, check=check)
-                except asyncio.TimeoutError:
-                    return
-
-                if reaction.emoji == "\u2B05":
-                    current_page = (current_page - 1) % page_count
-                elif reaction.emoji == "\u27A1":
-                    current_page = (current_page + 1) % page_count
-
-                if ctx.message.guild:
-                    if ctx.message.channel.permissions_for(ctx.message.guild.get_member(ctx.client.user.id)).manage_messages:
-                        await reaction.remove(ctx.message.author)

src/pluralkit/bot/embeds.py

@@ -1,290 +0,0 @@
-import discord
-import math
-import humanize
-from typing import Tuple, List
-
-from pluralkit import db
-from pluralkit.bot.utils import escape
-from pluralkit.member import Member
-from pluralkit.switch import Switch
-from pluralkit.system import System
-from pluralkit.utils import get_fronters, display_relative
-
-
-def truncate_field_name(s: str) -> str:
-    return s[:256]
-
-
-def truncate_field_body(s: str) -> str:
-    if len(s) > 1024:
-        return s[:1024-3] + "..."
-    return s
-
-
-def truncate_description(s: str) -> str:
-    return s[:2048]
-
-
-def truncate_description_list(s: str) -> str:
-    if len(s) > 512:
-        return s[:512-45] + "..."
-    return s
-
-
-def truncate_title(s: str) -> str:
-    return s[:256]
-
-
-def success(text: str) -> discord.Embed:
-    embed = discord.Embed()
-    embed.description = truncate_description(text)
-    embed.colour = discord.Colour.green()
-    return embed
-
-
-def error(text: str, help: Tuple[str, str] = None) -> discord.Embed:
-    embed = discord.Embed()
-    embed.description = truncate_description(text)
-    embed.colour = discord.Colour.dark_red()
-
-    if help:
-        help_title, help_text = help
-        embed.add_field(name=truncate_field_name(help_title), value=truncate_field_body(help_text))
-
-    return embed
-
-
-def status(text: str) -> discord.Embed:
-    embed = discord.Embed()
-    embed.description = truncate_description(text)
-    embed.colour = discord.Colour.blue()
-    return embed
-
-
-def exception_log(message_content, author_name, author_discriminator, author_id, server_id,
-                  channel_id) -> discord.Embed:
-    embed = discord.Embed()
-    embed.colour = discord.Colour.dark_red()
-    embed.title = truncate_title(message_content)
-
-    embed.set_footer(text="Sender: {}#{} ({}) | Server: {} | Channel: {}".format(
-        author_name, author_discriminator, author_id,
-        server_id if server_id else "(DMs)",
-        channel_id
-    ))
-    return embed
-
-
-async def system_card(conn, client: discord.Client, system: System, is_own_system: bool = True) -> discord.Embed:
-    card = discord.Embed()
-    card.colour = discord.Colour.blue()
-
-    all_members = await system.get_members(conn)
-    member_count = str(len(all_members))
-
-    if system.name:
-        card.title = truncate_title(system.name)
-
-    if system.avatar_url:
-        card.set_thumbnail(url=system.avatar_url)
-
-    if system.tag:
-        card.add_field(name="Tag", value=truncate_field_body(system.tag))
-
-    fronters, switch_time = await get_fronters(conn, system.id)
-    if fronters:
-        names = ", ".join([member.name for member in fronters])
-        fronter_val = "{} (for {})".format(names, humanize.naturaldelta(switch_time))
-        card.add_field(name="Current fronter" if len(fronters) == 1 else "Current fronters",
-                       value=truncate_field_body(fronter_val))
-
-    account_names = []
-    for account_id in await system.get_linked_account_ids(conn):
-        try:
-            account = await client.get_user_info(account_id)
-            account_names.append("<@{}> ({}#{})".format(account_id, account.name, account.discriminator))
-        except discord.NotFound:
-            account_names.append("(deleted account {})".format(account_id))
-
-    card.add_field(name="Linked accounts", value=truncate_field_body("\n".join(account_names)))
-
-    if system.description:
-        card.add_field(name="Description",
-                       value=truncate_field_body(system.description), inline=False)
-
-    card.add_field(name="Members ({})".format(member_count), value="*See `pk;system {0} list`for the short list, or `pk;system {0} list full` for the detailed list*".format(system.hid) if not is_own_system else "*See `pk;system list` for the short list, or `pk;system list full` for the detailed list*")
-    card.set_footer(text="System ID: {}".format(system.hid))
-    return card
-
-
-async def member_card(conn, member: Member) -> discord.Embed:
-    system = await member.fetch_system(conn)
-
-    card = discord.Embed()
-    card.colour = discord.Colour.blue()
-
-    name_and_system = member.name
-    if system.name:
-        name_and_system += " ({})".format(system.name)
-
-    card.set_author(name=truncate_field_name(name_and_system), icon_url=member.avatar_url or discord.Embed.Empty)
-    if member.avatar_url:
-        card.set_thumbnail(url=member.avatar_url)
-
-    if member.color:
-        card.colour = int(member.color, 16)
-
-    if member.birthday:
-        card.add_field(name="Birthdate", value=member.birthday_string())
-
-    if member.pronouns:
-        card.add_field(name="Pronouns", value=truncate_field_body(member.pronouns))
-
-    message_count = await member.message_count(conn)
-    if message_count > 0:
-        card.add_field(name="Message Count", value=str(message_count), inline=True)
-
-    if member.prefix or member.suffix:
-        prefix = member.prefix or ""
-        suffix = member.suffix or ""
-        card.add_field(name="Proxy Tags",
-                       value=truncate_field_body("{}text{}".format(prefix, suffix)))
-
-    if member.description:
-        card.add_field(name="Description",
-                       value=truncate_field_body(member.description), inline=False)
-
-    card.set_footer(text="System ID: {} | Member ID: {}".format(system.hid, member.hid))
-    return card
-
-
-async def front_status(ctx: "CommandContext", switch: Switch) -> discord.Embed:
-    if switch:
-        embed = status("")
-        fronter_names = [member.name for member in await switch.fetch_members(ctx.conn)]
-
-        if len(fronter_names) == 0:
-            embed.add_field(name="Current fronter", value="(no fronter)")
-        elif len(fronter_names) == 1:
-            embed.add_field(name="Current fronter", value=truncate_field_body(fronter_names[0]))
-        else:
-            embed.add_field(name="Current fronters", value=truncate_field_body(", ".join(fronter_names)))
-
-        if switch.timestamp:
-            embed.add_field(name="Since",
-                            value="{} ({})".format(ctx.format_time(switch.timestamp),
-                                                   display_relative(switch.timestamp)))
-    else:
-        embed = error("No switches logged.")
-    return embed
-
-
-async def get_message_contents(client: discord.Client, channel_id: int, message_id: int):
-    channel = client.get_channel(channel_id)
-    if channel:
-        try:
-            original_message = await channel.get_message(message_id)
-            return original_message.content or None
-        except (discord.errors.Forbidden, discord.errors.NotFound):
-            pass
-
-    return None
-
-
-async def message_card(client: discord.Client, message: db.MessageInfo, include_pronouns: bool = False):
-    # Get the original sender of the messages
-    try:
-        original_sender = await client.get_user_info(message.sender)
-    except discord.NotFound:
-        # Account was since deleted - rare but we're handling it anyway
-        original_sender = None
-
-    embed = discord.Embed()
-    embed.timestamp = discord.utils.snowflake_time(message.mid)
-    embed.colour = discord.Colour.blue()
-
-    if message.system_name:
-        system_value = "{} (`{}`)".format(message.system_name, message.system_hid)
-    else:
-        system_value = "`{}`".format(message.system_hid)
-    embed.add_field(name="System", value=system_value)
-
-    if include_pronouns and message.pronouns:
-        embed.add_field(name="Member", value="{} (`{}`)\n*(pronouns: **{}**)*".format(message.name, message.hid, message.pronouns))
-    else:
-        embed.add_field(name="Member", value="{} (`{}`)".format(message.name, message.hid))
-
-    if original_sender:
-        sender_name = "<@{}> ({}#{})".format(message.sender, original_sender.name, original_sender.discriminator)
-    else:
-        sender_name = "(deleted account {})".format(message.sender)
-
-    embed.add_field(name="Sent by", value=sender_name)
-
-    message_content = await get_message_contents(client, message.channel, message.mid)
-    embed.description = message_content or "(unknown, message deleted)"
-
-    embed.set_author(name=message.name, icon_url=message.avatar_url or discord.Embed.Empty)
-    return embed
-
-
-def help_footer_embed() -> discord.Embed:
-    embed = discord.Embed()
-    embed.set_footer(text="By @Ske#6201 | GitHub: https://github.com/xSke/PluralKit/")
-    return embed
-
-# TODO: merge these somehow, they're very similar
-def member_list_short(system: System, all_members: List[Member], current_page: int, page_size: int):
-    page_count = int(math.ceil(len(all_members) / page_size))
-
-    title = ""
-    if len(all_members) > page_size:
-        title += "[{}/{}] ".format(current_page + 1, page_count)
-
-    if system.name:
-        title += "Members of {} (`{}`)".format(system.name, system.hid)
-    else:
-        title += "Members of `{}`".format(system.hid)
-
-    embed = discord.Embed()
-    embed.title = title
-
-    desc = ""
-    for member in all_members[current_page*page_size:current_page*page_size+page_size]:
-        if member.prefix or member.suffix:
-            desc += "[`{}`] **{}** *({}text{})*\n".format(member.hid, member.name, member.prefix or "", member.suffix or "")
-        else:
-            desc += "[`{}`] **{}**\n".format(member.hid, member.name)
-    embed.description = desc
-    return embed
-
-def member_list_full(system: System, all_members: List[Member], current_page: int, page_size: int):
-    page_count = int(math.ceil(len(all_members) / page_size))
-
-    title = ""
-    if len(all_members) > page_size:
-        title += "[{}/{}] ".format(current_page + 1, page_count)
-
-    if system.name:
-        title += "Members of {} (`{}`)".format(system.name, system.hid)
-    else:
-        title += "Members of `{}`".format(system.hid)
-
-    embed = discord.Embed()
-    embed.title = title
-    for member in all_members[current_page*page_size:current_page*page_size+page_size]:
-        member_description = "**ID**: {}\n".format(member.hid)
-        if member.birthday:
-            member_description += "**Birthday:** {}\n".format(member.birthday_string())
-        if member.pronouns:
-            member_description += "**Pronouns:** {}\n".format(member.pronouns)
-        if member.prefix or member.suffix:
-            member_description += "**Proxy tags:** `{}text{}`\n".format(member.prefix or "", member.suffix or "")
-        if member.description:
-            if len(member.description) > 512:
-                member_description += "\n" + truncate_description_list(member.description) + "\n" + "Type `pk;member {}` for full description.".format(member.hid)
-            else:
-                member_description += "\n" + member.description
-
-        embed.add_field(name=member.name, value=truncate_field_body(member_description) or "\u200B", inline=False)
-    return embed

src/pluralkit/bot/help.json

@@ -1,337 +0,0 @@
-{
-    "commands": [
-        {
-            "name": "system",
-            "aliases": ["s"],
-            "usage": "system [id]",
-            "description": "Shows information about a system.",
-            "longdesc": "The given ID can either be a 5-character ID, a Discord account @mention, or a Discord account ID. Leave blank to show your own system.",
-            "examples": ["system", "system abcde", "system @Foo#1234", "system 102083498529026048"],
-            "category": "System",
-            "subcommands": [
-                {
-                    "name": "new",
-                    "aliases": ["system register", "system create", "system init"],
-                    "usage": "system new [name]",
-                    "category": "System",
-                    "description": "Creates a new system registered to your account."
-                },
-                {
-                    "name": "name",
-                    "alises": ["system rename"],
-                    "usage": "system name [name]",
-                    "category": "System",
-                    "description": "Changes the name of your system."
-                },
-                {
-                    "name": "description",
-                    "aliases": ["system desc"],
-                    "usage": "system description [description]",
-                    "category": "System",
-                    "description": "Changes the description of your system."
-                },
-                {
-                    "name": "avatar",
-                    "aliases": ["system icon"],
-                    "usage": "system avatar [avatar url]",
-                    "category": "System",
-                    "description": "Changes the avatar of your system.",
-                    "longdesc": "**NB:** Avatar URLs must be a *direct* link to an image (ending in .jpg, .gif or .png), AND must be under the size of 1000x1000 (in both dimensions), AND must be smaller than 1 MB. If the avatar doesn't show up properly, it is likely one or more of these rules aren't followed. If you need somewhere to host an image, you can upload it to Discord or Imgur and copy the *direct* link from there.\n\nYou can also upload an avatar by attaching an image and sending it with the command (without the url).",
-                    "examples": ["system avatar https://i.imgur.com/HmK2Wgo.png"]
-                },
-                {
-                    "name": "tag",
-                    "usage": "system tag [tag]",
-                    "category": "System",
-                    "description": "Changes the system tag of your system.",
-                    "longdesc": "The system tag is a snippet of text added to the end of your member's names when proxying. Many servers require the use of a system tag for identification. Leave blank to clear.\n\n**NB:** You may use standard Discord emojis, but server/Nitro emojis won't work.",
-                    "examples": ["system tag |ABC", "system tag 💮", "system tag"]
-                },
-                {
-                    "name": "timezone",
-                    "usage": "system timezone [location]",
-                    "category": "System",
-                    "description": "Changes the time zone of your system.",
-                    "longdesc": "This affects all dates or times displayed in PluralKit. Leave blank to clear.\n\n**NB:** You need to specify a location (eg. the nearest major city to you). This allows PluralKit to dynamically adjust for time zone or DST changes.",
-                    "examples": ["system timezone New York", "system timezone Wichita Falls", "system timezone"]
-                },
-                {
-                    "name": "delete",
-                    "aliases": ["system remove", "system destroy", "system erase"],
-                    "usage": "system delete",
-                    "category": "System",
-                    "description": "Deletes your system.",
-                    "longdesc": "The command will ask for confirmation.\n\n**This is irreversible, and will delete all information associated with your system, members, proxied messages, and accounts.**"
-                },
-                {
-                    "name": "fronter",
-                    "aliases": ["system front", "system fronters"],
-                    "usage": "system [id] fronter",
-                    "category": "System",
-                    "description": "Shows the current fronter of a system."
-                },
-                {
-                    "name": "fronthistory",
-                    "aliases": ["system fh", "system history", "system switches"],
-                    "usage": "system [id] fronthistory",
-                    "category": "System",
-                    "description": "Shows the last 10 switches of a system."
-                },
-                {
-                    "name": "frontpercent",
-                    "aliases": ["system frontbreakdown", "system frontpercentage", "system front%", "system fp"],
-                    "usage": "system [id] frontpercent [timeframe]",
-                    "category": "System",
-                    "description": "Shows the aggregated front history of a system within a given time frame.",
-                    "longdesc": "Percentages may add up to over 100% when multiple members cofront. Time frame will default to 1 month.",
-                    "examples": ["system frontpercent 1 month", "system frontpercent 2 weeks", "system @Foo#1234 frontpercent 4 days"]
-                },
-                {
-                    "name": "list",
-                    "aliases": ["system members"],
-                    "usage": "system [id] list [full]",
-                    "category": "System",
-                    "description": "Shows a paginated list of a system's members. Add 'full' for more details.",
-                    "examples": ["system list", "system list full", "system 102083498529026048 list"]
-                }
-            ]
-        },
-        {
-            "name": "link",
-            "usage": "link <account>",
-            "category": "System",
-            "description": "Links this system to a different account.",
-            "longdesc": "This means you can manage the system from both accounts. The other account will need to verify the link by reacting to a message.",
-            "examples": ["link @Foo#1234", "link 102083498529026048"]
-        },
-        {
-            "name": "unlink",
-            "usage": "unlink",
-            "category": "System",
-            "description": "Unlinks this account from its system.",
-            "longdesc": "You can't unlink the only account in a system."
-        },
-        {
-            "name": "member",
-            "aliases": ["m"],
-            "usage": "member <name>",
-            "category": "Member",
-            "description": "Shows information about a member.",
-            "longdesc": "The given member name can either be the name of a member in your own system or a 5-character member ID (in any system).",
-            "examples": ["member John", "member abcde"],
-            "subcommands": [
-                {
-                    "name": "new",
-                    "aliases": ["member add", "member create", "member register"],
-                    "usage": "member new <name>",
-                    "category": "Member",
-                    "description": "Creates a new system member.",
-                    "exmaples": ["member new Jack"]
-                },
-                {
-                    "name": "rename",
-                    "usage": "member <name> rename <name>",
-                    "category": "Member",
-                    "description": "Changes the name of a member.",
-                    "examples": ["member Jack rename Jill"]
-                },
-                {
-                    "name": "description",
-                    "aliases": ["member desc"],
-                    "usage": "member <name> description [description]",
-                    "category": "Member",
-                    "description": "Changes the description of a member.",
-                    "examples": ["member Jack description Very cool guy."]
-                },
-                {
-                    "name": "avatar",
-                    "aliases": ["member icon"],
-                    "usage": "member <name> avatar [avatarurl]",
-                    "category": "Member",
-                    "description": "Changes the avatar of a member.",
-                    "longdesc": "**NB:** Avatar URLs must be a *direct* link to an image (ending in .jpg, .gif or .png), AND must be under the size of 1000x1000 (in both dimensions), AND must be smaller than 1 MB. If the avatar doesn't show up properly, it is likely one or more of these rules aren't followed. If you need somewhere to host an image, you can upload it to Discord or Imgur and copy the *direct* link from there.\n\nYou can also upload an avatar by attaching an image and sending it with the command (without the url).",
-                    "examples": ["member Jack avatar https://i.imgur.com/HmK2Wgo.png"]
-                },
-                {
-                    "name": "proxy",
-                    "aliases": ["member tags"],
-                    "usage": "member <name> proxy [tags]",
-                    "category": "Member",
-                    "description": "Changes the proxy tags of a member.",
-                    "longdesc": "The proxy tags describe how to proxy this member through Discord. You must pass an \"example proxy\" of the word \"text\", ie. how you'd proxy the word \"text\". For example, if you want square brackets for this member, pass `[text]`. Emojis are allowed.",
-                    "examples": ["member Jack proxy [text]", "member Jill proxy J:text", "member Jones proxy 🍒text"]
-                },
-                {
-                    "name": "pronouns",
-                    "aliases": ["member pronoun"],
-                    "usage": "member <name> pronouns [pronouns]",
-                    "category": "Member",
-                    "description": "Changes the pronouns of a member.",
-                    "longdesc": "These will be displayed on their profile. This is a free text field, put whatever you'd like :)",
-                    "examples": ["member Jack pronouns he/him", "member Jill pronouns she/her or they/them", "member Jones pronouns use whatever lol"]
-                },
-                {
-                    "name": "color",
-                    "aliases": ["member colour"],
-                    "usage": "member <name> color [color]",
-                    "category": "Member",
-                    "description": "Changes the color of a member.",
-                    "longdesc": "This will displayed on their profile. Colors must be in hex format (eg. #ff0000).\n\n**NB:** Due to a Discord limitation, the colors don't affect proxied message names.",
-                    "examples": ["member Jack color #ff0000", "member Jill color #abcdef"]
-                },
-                {
-                    "name": "birthday",
-                    "aliases": ["member bday", "member birthdate"],
-                    "usage": "member <name> birthday [birthday]",
-                    "category": "Member",
-                    "description": "Changes the birthday of a member.",
-                    "longdesc": "This must be in YYYY-MM-DD format, or just MM-DD if you don't want to specify a year.",
-                    "examples": ["member Jack birthday 1997-03-27", "member Jill birthday 2018-01-03", "member Jones birthday 12-21"]
-                },
-                {
-                    "name": "delete",
-                    "aliases": ["member remove", "member destroy", "member erase"],
-                    "usage": "member <name> delete",
-                    "category": "Member",
-                    "description": "Deletes a member.",
-                    "longdesc": "This command will ask for confirmation.\n\n**This is irreversible, and will delete all data associated with this member.**"
-                }
-            ]
-        },
-        {
-            "name": "switch",
-            "aliases": ["sw"],
-            "usage": "switch [member] [extra members...]",
-            "category": "Switching",
-            "description": "Registers a switch with the given members, or displays a list of logged switches if no members are given.",
-            "longdesc": "You may specify multiple members to indicate cofronting. Shows the last 10 switches of a system if no members are given.",
-            "examples": ["switch Jack", "switch Jack Jill", "switch"],
-            "subcommands": [
-                {
-                    "name": "move",
-                    "usage": "switch move <time>",
-                    "category": "Switching",
-                    "description": "Moves the latest switch back or forwards in time.",
-                    "longdesc": "You can't move a switch into the future, and you can't move a switch further back than the second-latest switch (which would reorder front history).",
-                    "examples": ["switch move 1 day ago", "switch move 4:30 pm"]
-                },
-                {
-                    "name": "delete",
-                    "usage": "switch delete",
-                    "category": "Switching",
-                    "description": "Deletes the latest switch. Will ask for confirmation."
-                },
-                {
-                    "name": "out",
-                    "usage": "switch out",
-                    "category": "Switching",
-                    "description": "Will register a 'switch-out' - a switch with no associated members."
-                }
-            ]
-        },
-        {
-            "name": "log",
-            "usage": "log <channel>",
-            "category": "Utility",
-            "description": "Sets a channel to log all proxied messages.",
-            "longdesc": "This command is restricted to the server administrators (ie. users with the Administrator role).",
-            "examples": "log #pluralkit-log"
-        },
-        {
-            "name": "message",
-            "usage": "message <messageid>",
-            "category": "Utility",
-            "description": "Looks up information about a message by its message ID.",
-            "longdesc": " You can obtain a message ID by turning on Developer Mode in Discord's settings, and rightclicking/longpressing on a message.\n\n**Tip:** Reacting to a message with ❓ will DM you this information too.",
-            "examples": "message 561614629802082304"
-        },
-        {
-            "name": "invite",
-            "usage": "invite",
-            "category": "Utility",
-            "description": "Sends the bot invite link for PluralKit."
-        },
-        {
-            "name": "import",
-            "usage": "import",
-            "category": "Utility",
-            "description": "Imports a .json file from Tupperbox.",
-            "longdesc": "You will need to type the command, *then* send a new message containing the .json file as an attachment."
-        },
-        {
-            "name": "export",
-            "usage": "export",
-            "category": "Utility",
-            "description": "Exports your system to a .json file.",
-            "longdesc": "This will respond with a .json file containing your system and member data, useful for importing elsewhere."
-        },
-        {
-            "name": "token",
-            "usage": "token",
-            "category": "API",
-            "description": "DMs you a token for using the PluralKit API.",
-            "subcommands": [
-                {
-                    "name": "refresh",
-                    "usage": "token refresh",
-                    "category": "API",
-                    "description": "Refreshes your API token.",
-                    "longdesc": "This will invalide the old token and DM you a new one. Do this if your token leaks in any way."
-                }
-            ]
-        },
-        {
-            "name": "help",
-            "usage": "help [command]",
-            "category": "Help",
-            "description": "Displays help for a given command.",
-            "examples": ["help", "help system", "help member avatar", "help switch move"],
-            "subcommands": [
-                {
-                    "name": "proxy",
-                    "usage": "help proxy",
-                    "category": "Help",
-                    "description": "Displays a short guide to the proxy functionality."
-                }
-            ]
-        },
-        {
-            "name": "commands",
-            "usage": "commands",
-            "category": "Help",
-            "description": "Displays a paginated list of commands",
-            "examples": ["commands", "commands"]
-        }
-    ],
-    "pages": {
-        "root": [
-            {
-                "name": "PluralKit",
-                "content": "PluralKit is a bot designed for plural communities on Discord. It allows you to register systems, maintain system information, set up message proxying, log switches, and more.\n\n**What's this for? What are systems?**\nThis bot detects messages with certain tags associated with a profile, then replaces that message under a \"pseudo-account\" of that profile using webhooks. This is useful for multiple people sharing one body (aka \"systems\"), people who wish to roleplay as different characters without having several accounts, or anyone else who may want to post messages as a different person from the same account.\n\n**Why are people's names saying [BOT] next to them?**\nThese people are not actually bots, this is just a Discord limitation.\nType `pk;help proxy` for an in-depth explanation."
-            },
-            {
-                "name": "Getting started",
-                "content": "To get started using the bot, try running the following commands.\n**1**. `pk;system new` - Create a system if you haven't already\n**2**. `pk;member add John` - Add a new member to your system\n**3**. `pk;member John proxy [text]` - Set up square brackets as proxy tags\n**4**. You're done!\n**5**. Optionally, you may set an avatar from the URL of an image with:\n`pk;member John avatar [link to image]` or from a file by typing:\n`pk;member John avatar` and sending it with an attached image. \n\nType `pk;help member` for more information."
-            },
-            {
-                "name": "Useful tips",
-                "content": "React with ❌ on a proxied message to delete it (if you sent it!).\nReact with ❓ on a proxied message to look up information about it, like who sent it.\nType `pk;invite` for a link to invite this bot to your own server!"
-            },
-            {
-                "name": "More information",
-                "content": "For a full list of commands, type `pk;commands`.\nFor a more in-depth explanation of message proxying, type `pk;help proxy`.\nIf you're an existing user of Tupperbox, type `pk;import` to import your data from there."
-            },
-            {
-                "name": "Support server",
-                "content": "We also have a Discord server for support, discussion, suggestions, announcements, etc: <https://discord.gg/PczBt78>"
-            }
-        ],
-        "proxy": [
-            {
-                "name": "Proxying",
-                "content": "Proxying through PluralKit lets system members have their own faux-account with their name and avatar.\nYou'll type a message from your account in *proxy tags*, and PluralKit will recognize those tags and repost the message with the proper details, with the minor caveat of having the **[BOT]** icon next to the name (this is a Discord limitation and cannot be circumvented).\n\nTo set up a member's proxy tag, use the `pk;member <name> proxy [example match]` command.\n\nYou'll need to give the bot an \"example match\" containing the word `text`. Imagine you're proxying the word \"text\", and add that to the end of the command. For example: `pk;member John proxy [text]`. That will set the member John up to use square brackets as proxy tags. Now saying something like `[hello world]` will proxy the text \"hello world\" with John's name and avatar. You can also use other symbols, letters, numbers, et cetera, as prefixes, suffixes, or both. `J:text`, `$text` and `text]` are also examples of valid example matches."
-            }
-        ]
-    },
-    "footer": "By @Ske#6201 | GitHub: https://github.com/xSke/PluralKit/"
-}

src/pluralkit/bot/help.py

@@ -1,6 +0,0 @@
-import json
-import os.path
-
-helpfile = None
-with open(os.path.dirname(__file__) + "/help.json", "r") as f:
-    helpfile = json.load(f)

src/pluralkit/bot/proxy.py

@@ -1,267 +0,0 @@
-import asyncio
-import re
-
-import discord
-from io import BytesIO
-from typing import Optional
-
-from pluralkit import db
-from pluralkit.bot import utils, channel_logger, embeds
-from pluralkit.bot.channel_logger import ChannelLogger
-from pluralkit.member import Member
-from pluralkit.system import System
-
-
-class ProxyError(Exception):
-    pass
-
-async def get_or_create_webhook_for_channel(conn, bot_user: discord.User, channel: discord.TextChannel):
-    # First, check if we have one saved in the DB
-    webhook_from_db = await db.get_webhook(conn, channel.id)
-    if webhook_from_db:
-        webhook_id, webhook_token = webhook_from_db
-
-        session = channel._state.http._session
-        hook = discord.Webhook.partial(webhook_id, webhook_token, adapter=discord.AsyncWebhookAdapter(session))
-        return hook
-
-    try:
-        # If not, we check to see if there already exists one we've missed
-        for existing_hook in await channel.webhooks():
-            existing_hook_creator = existing_hook.user.id if existing_hook.user else None
-            is_mine = existing_hook.name == "PluralKit Proxy Webhook" and existing_hook_creator == bot_user.id
-            if is_mine:
-                # We found one we made, let's add that to the DB just to be sure
-                await db.add_webhook(conn, channel.id, existing_hook.id, existing_hook.token)
-                return existing_hook
-
-        # If not, we create one and save it
-        created_webhook = await channel.create_webhook(name="PluralKit Proxy Webhook")
-    except discord.Forbidden:
-        raise ProxyError(
-            "PluralKit does not have the \"Manage Webhooks\" permission, and thus cannot proxy your message. Please contact a server administrator.")
-
-    await db.add_webhook(conn, channel.id, created_webhook.id, created_webhook.token)
-    return created_webhook
-
-
-async def make_attachment_file(message: discord.Message):
-    if not message.attachments:
-        return None
-
-    first_attachment = message.attachments[0]
-
-    # Copy the file data to the buffer
-    # TODO: do this without buffering... somehow
-    bio = BytesIO()
-    await first_attachment.save(bio)
-
-    return discord.File(bio, first_attachment.filename)
-
-
-def fix_clyde(name: str) -> str:
-    # Discord doesn't allow any webhook username to contain the word "Clyde"
-    # So replace "Clyde" with "C lyde" (except with a hair space, hence \u200A)
-    # Zero-width spacers are ignored by Discord and will still trigger the error
-    return re.sub("(c)(lyde)", "\\1\u200A\\2", name, flags=re.IGNORECASE)
-
-
-async def send_proxy_message(conn, original_message: discord.Message, system: System, member: Member,
-                             inner_text: str, logger: ChannelLogger, bot_user: discord.User):
-    # Send the message through the webhook
-    webhook = await get_or_create_webhook_for_channel(conn, bot_user, original_message.channel)
-
-    # Bounds check the combined name to avoid silent erroring
-    full_username = "{} {}".format(member.name, system.tag or "").strip()
-    full_username = fix_clyde(full_username)
-    if len(full_username) < 2:
-        raise ProxyError(
-            "The webhook's name, `{}`, is shorter than two characters, and thus cannot be proxied. Please change the member name or use a longer system tag.".format(
-                full_username))
-    if len(full_username) > 32:
-        raise ProxyError(
-            "The webhook's name, `{}`, is longer than 32 characters, and thus cannot be proxied. Please change the member name or use a shorter system tag.".format(
-                full_username))
-
-    try:
-        sent_message = await webhook.send(
-            content=inner_text,
-            username=full_username,
-            avatar_url=member.avatar_url,
-            file=await make_attachment_file(original_message),
-            wait=True
-        )
-    except discord.NotFound:
-        # The webhook we got from the DB doesn't actually exist
-        # This can happen if someone manually deletes it from the server
-        # If we delete it from the DB then call the function again, it'll re-create one for us
-        # (lol, lazy)
-        await db.delete_webhook(conn, original_message.channel.id)
-        await send_proxy_message(conn, original_message, system, member, inner_text, logger, bot_user)
-        return
-
-    # Save the proxied message in the database
-    await db.add_message(conn, sent_message.id, original_message.channel.id, member.id,
-                         original_message.author.id)
-
-    # Log it in the log channel if possible
-    await logger.log_message_proxied(
-        conn,
-        original_message.channel.guild.id,
-        original_message.channel.name,
-        original_message.channel.id,
-        original_message.author.name,
-        original_message.author.discriminator,
-        original_message.author.id,
-        member.name,
-        member.hid,
-        member.avatar_url,
-        system.name,
-        system.hid,
-        inner_text,
-        sent_message.attachments[0].url if sent_message.attachments else None,
-        sent_message.created_at,
-        sent_message.id
-    )
-
-    # And finally, gotta delete the original.
-    # We wait half a second or so because if the client receives the message deletion
-    # event before the message actually gets confirmed sent on their end, the message
-    # doesn't properly get deleted for them, leading to duplication
-    try:
-        await asyncio.sleep(0.5)
-        await original_message.delete()
-    except discord.Forbidden:
-        raise ProxyError(
-            "PluralKit does not have permission to delete user messages. Please contact a server administrator.")
-    except discord.NotFound:
-        # Sometimes some other thing will delete the original message before PK gets to it
-        # This is not a problem - message gets deleted anyway :)
-        # Usually happens when Tupperware and PK conflict
-        pass
-
-
-async def try_proxy_message(conn, message: discord.Message, logger: ChannelLogger, bot_user: discord.User) -> bool:
-    # Don't bother proxying in DMs
-    if isinstance(message.channel, discord.abc.PrivateChannel):
-        return False
-
-    # Get the system associated with the account, if possible
-    system = await System.get_by_account(conn, message.author.id)
-    if not system:
-        return False
-
-    # Match on the members' proxy tags
-    proxy_match = await system.match_proxy(conn, message.content)
-    if not proxy_match:
-        return False
-
-    member, inner_message = proxy_match
-
-    # Make sure no @everyones slip through
-    # Webhooks implicitly have permission to mention @everyone so we have to enforce that manually
-    inner_message = utils.sanitize(inner_message)
-
-    # If we don't have an inner text OR an attachment, we cancel because the hook can't send that
-    # Strip so it counts a string of solely spaces as blank too
-    if not inner_message.strip() and not message.attachments:
-        return False
-
-    # So, we now have enough information to successfully proxy a message
-    async with conn.transaction():
-        try:
-            await send_proxy_message(conn, message, system, member, inner_message, logger, bot_user)
-        except ProxyError as e:
-            # First, try to send the error in the channel it was triggered in
-            # Failing that, send the error in a DM.
-            # Failing *that*... give up, I guess.
-            try:
-                await message.channel.send("\u274c {}".format(str(e)))
-            except discord.Forbidden:
-                try:
-                    await message.author.send("\u274c {}".format(str(e)))
-                except discord.Forbidden:
-                    pass
-
-    return True
-
-
-async def handle_deleted_message(conn, client: discord.Client, message_id: int,
-                                 message_content: Optional[str], logger: channel_logger.ChannelLogger) -> bool:
-    msg = await db.get_message(conn, message_id)
-    if not msg:
-        return False
-
-    channel = client.get_channel(msg.channel)
-    if not channel:
-        # Weird edge case, but channel *could* be deleted at this point (can't think of any scenarios it would be tho)
-        return False
-
-    await db.delete_message(conn, message_id)
-    await logger.log_message_deleted(
-        conn,
-        channel.guild.id,
-        channel.name,
-        msg.name,
-        msg.hid,
-        msg.avatar_url,
-        msg.system_name,
-        msg.system_hid,
-        message_content,
-        message_id
-    )
-    return True
-
-
-async def try_delete_by_reaction(conn, client: discord.Client, message_id: int, reaction_user: int,
-                                 logger: channel_logger.ChannelLogger) -> bool:
-    # Find the message by the given message id or reaction user
-    msg = await db.get_message_by_sender_and_id(conn, message_id, reaction_user)
-    if not msg:
-        # Either the wrong user reacted or the message isn't a proxy message
-        # In either case - not our problem
-        return False
-
-    # Find the original message
-    original_message = await client.get_channel(msg.channel).get_message(message_id)
-    if not original_message:
-        # Message got deleted, possibly race condition, eh
-        return False
-
-    # Then delete the original message
-    await original_message.delete()
-
-    await handle_deleted_message(conn, client, message_id, original_message.content, logger)
-
-async def do_query_message(conn, client: discord.Client, queryer_id: int, message_id: int, reacted_emoji: str) -> bool:
-    # Find the message that was queried
-    msg = await db.get_message(conn, message_id)
-    if not msg:
-        return False
-
-    # Then DM the queryer the message embed
-    card = await embeds.message_card(client, msg, include_pronouns=True)
-    user = client.get_user(queryer_id)
-    if not user:
-        # We couldn't find this user in the cache - bail
-        return False
-
-    # Remove the original reaction by the user if we have "Manage Messages"
-    channel = client.get_channel(msg.channel)
-    if isinstance(channel, discord.TextChannel) and channel.permissions_for(channel.guild.get_member(client.user.id)).manage_messages:
-        # We need the message instance itself to remove the reaction, since discord.py doesn't let you
-        # call HTTP endpoints with arbitrary IDs (at least, not without internals-hacking)
-        try:
-            message_instance = await channel.get_message(message_id)
-            member = channel.guild.get_member(queryer_id)
-            await message_instance.remove_reaction(reacted_emoji, member)
-        except (discord.Forbidden, discord.NotFound):
-            # Oh yeah, and this can also fail. yeet.
-            pass
-
-    # Send the card to the user
-    try:
-        await user.send(embed=card)
-    except discord.Forbidden:
-        # User doesn't have DMs enabled, not much we can do about that
-        pass

src/pluralkit/bot/utils.py

@@ -1,87 +0,0 @@
-import discord
-import logging
-import re
-from typing import Optional
-
-from pluralkit import db
-from pluralkit.member import Member
-from pluralkit.system import System
-
-logger = logging.getLogger("pluralkit.utils")
-
-
-def escape(s):
-    return s.replace("`", "\\`")
-
-
-def bounds_check_member_name(new_name, system_tag):
-    if len(new_name) > 32:
-        return "Name cannot be longer than 32 characters."
-
-    if system_tag:
-        if len("{} {}".format(new_name, system_tag)) > 32:
-            return "This name, combined with the system tag ({}), would exceed the maximum length of 32 characters. Please reduce the length of the tag, or use a shorter name.".format(
-                system_tag)
-
-
-async def parse_mention(client: discord.Client, mention: str) -> Optional[discord.User]:
-    # First try matching mention format
-    match = re.fullmatch("<@!?(\\d+)>", mention)
-    if match:
-        try:
-            return await client.get_user_info(int(match.group(1)))
-        except discord.NotFound:
-            return None
-
-    # Then try with just ID
-    try:
-        return await client.get_user_info(int(mention))
-    except (ValueError, discord.NotFound):
-        return None
-
-
-def parse_channel_mention(mention: str, server: discord.Guild) -> Optional[discord.TextChannel]:
-    match = re.fullmatch("<#(\\d+)>", mention)
-    if match:
-        return server.get_channel(int(match.group(1)))
-
-    try:
-        return server.get_channel(int(mention))
-    except ValueError:
-        return None
-
-
-async def get_system_fuzzy(conn, client: discord.Client, key) -> Optional[System]:
-    if isinstance(key, discord.User):
-        return await db.get_system_by_account(conn, account_id=key.id)
-
-    if isinstance(key, str) and len(key) == 5:
-        return await db.get_system_by_hid(conn, system_hid=key)
-
-    account = await parse_mention(client, key)
-    if account:
-        system = await db.get_system_by_account(conn, account_id=account.id)
-        if system:
-            return system
-    return None
-
-
-async def get_member_fuzzy(conn, system_id: int, key: str, system_only=True) -> Member:
-    # First search by hid
-    if system_only:
-        member = await db.get_member_by_hid_in_system(conn, system_id=system_id, member_hid=key)
-    else:
-        member = await db.get_member_by_hid(conn, member_hid=key)
-    if member is not None:
-        return member
-
-    # Then search by name, if we have a system
-    if system_id:
-        member = await db.get_member_by_name(conn, system_id=system_id, member_name=key)
-        if member is not None:
-            return member
-
-
-def sanitize(text):
-    # Insert a zero-width space in @everyone so it doesn't trigger
-    return text.replace("@everyone", "@\u200beveryone").replace("@here", "@\u200bhere")

src/pluralkit/db.py

@@ -1,383 +0,0 @@
-from collections import namedtuple
-from datetime import datetime
-import logging
-from typing import List, Optional
-import time
-
-import asyncpg
-import asyncpg.exceptions
-from discord.utils import snowflake_time
-
-from pluralkit.system import System
-from pluralkit.member import Member
-
-logger = logging.getLogger("pluralkit.db")
-async def connect(uri):
-    while True:
-        try:
-            return await asyncpg.create_pool(uri)
-        except (ConnectionError, asyncpg.exceptions.CannotConnectNowError):
-            logger.exception("Failed to connect to database, retrying in 5 seconds...")
-            time.sleep(5)
-
-def db_wrap(func):
-    async def inner(*args, **kwargs):
-        before = time.perf_counter()
-        try:
-            res = await func(*args, **kwargs)
-            after = time.perf_counter()
-
-            logger.debug(" - DB call {} took {:.2f} ms".format(func.__name__, (after - before) * 1000))
-            return res
-        except asyncpg.exceptions.PostgresError:
-            logger.exception("Error from database query {}".format(func.__name__))
-    return inner
-
-@db_wrap
-async def create_system(conn, system_name: str, system_hid: str) -> System:
-    logger.debug("Creating system (name={}, hid={})".format(
-        system_name, system_hid))
-    row = await conn.fetchrow("insert into systems (name, hid) values ($1, $2) returning *", system_name, system_hid)
-    return System(**row) if row else None
-
-
-@db_wrap
-async def remove_system(conn, system_id: int):
-    logger.debug("Deleting system (id={})".format(system_id))
-    await conn.execute("delete from systems where id = $1", system_id)
-
-
-@db_wrap
-async def create_member(conn, system_id: int, member_name: str, member_hid: str) -> Member:
-    logger.debug("Creating member (system={}, name={}, hid={})".format(
-        system_id, member_name, member_hid))
-    row = await conn.fetchrow("insert into members (name, system, hid) values ($1, $2, $3) returning *", member_name, system_id, member_hid)
-    return Member(**row) if row else None
-
-
-@db_wrap
-async def delete_member(conn, member_id: int):
-    logger.debug("Deleting member (id={})".format(member_id))
-    await conn.execute("delete from members where id = $1", member_id)
-
-
-@db_wrap
-async def link_account(conn, system_id: int, account_id: int):
-    logger.debug("Linking account (account_id={}, system_id={})".format(
-        account_id, system_id))
-    await conn.execute("insert into accounts (uid, system) values ($1, $2)", account_id, system_id)
-
-
-@db_wrap
-async def unlink_account(conn, system_id: int, account_id: int):
-    logger.debug("Unlinking account (account_id={}, system_id={})".format(
-        account_id, system_id))
-    await conn.execute("delete from accounts where uid = $1 and system = $2", account_id, system_id)
-
-
-@db_wrap
-async def get_linked_accounts(conn, system_id: int) -> List[int]:
-    return [row["uid"] for row in await conn.fetch("select uid from accounts where system = $1", system_id)]
-
-
-@db_wrap
-async def get_system_by_account(conn, account_id: int) -> System:
-    row = await conn.fetchrow("select systems.* from systems, accounts where accounts.uid = $1 and accounts.system = systems.id", account_id)
-    return System(**row) if row else None
-
-@db_wrap
-async def get_system_by_token(conn, token: str) -> Optional[System]:
-    row = await conn.fetchrow("select * from systems where token = $1", token)
-    return System(**row) if row else None
-
-@db_wrap
-async def get_system_by_hid(conn, system_hid: str) -> System:
-    row = await conn.fetchrow("select * from systems where hid = $1", system_hid)
-    return System(**row) if row else None
-
-
-@db_wrap
-async def get_system(conn, system_id: int) -> System:
-    row = await conn.fetchrow("select * from systems where id = $1", system_id)
-    return System(**row) if row else None
-
-
-@db_wrap
-async def get_member_by_name(conn, system_id: int, member_name: str) -> Member:
-    row = await conn.fetchrow("select * from members where system = $1 and lower(name) = lower($2)", system_id, member_name)
-    return Member(**row) if row else None
-
-
-@db_wrap
-async def get_member_by_hid_in_system(conn, system_id: int, member_hid: str) -> Member:
-    row = await conn.fetchrow("select * from members where system = $1 and hid = $2", system_id, member_hid)
-    return Member(**row) if row else None
-
-
-@db_wrap
-async def get_member_by_hid(conn, member_hid: str) -> Member:
-    row = await conn.fetchrow("select * from members where hid = $1", member_hid)
-    return Member(**row) if row else None
-
-
-@db_wrap
-async def get_member(conn, member_id: int) -> Member:
-    row = await conn.fetchrow("select * from members where id = $1", member_id)
-    return Member(**row) if row else None
-
-@db_wrap
-async def get_members(conn, members: list) -> List[Member]:
-    rows = await conn.fetch("select * from members where id = any($1)", members)
-    return [Member(**row) for row in rows]
-
-@db_wrap
-async def update_system_field(conn, system_id: int, field: str, value):
-    logger.debug("Updating system field (id={}, {}={})".format(
-        system_id, field, value))
-    await conn.execute("update systems set {} = $1 where id = $2".format(field), value, system_id)
-
-
-@db_wrap
-async def update_member_field(conn, member_id: int, field: str, value):
-    logger.debug("Updating member field (id={}, {}={})".format(
-        member_id, field, value))
-    await conn.execute("update members set {} = $1 where id = $2".format(field), value, member_id)
-
-
-@db_wrap
-async def get_all_members(conn, system_id: int) -> List[Member]:
-    rows = await conn.fetch("select * from members where system = $1", system_id)
-    return [Member(**row) for row in rows]
-
-@db_wrap
-async def get_members_exceeding(conn, system_id: int, length: int) -> List[Member]:
-    rows = await conn.fetch("select * from members where system = $1 and length(name) > $2", system_id, length)
-    return [Member(**row) for row in rows]
-
-
-@db_wrap
-async def get_webhook(conn, channel_id: int) -> (str, str):
-    row = await conn.fetchrow("select webhook, token from webhooks where channel = $1", channel_id)
-    return (str(row["webhook"]), row["token"]) if row else None
-
-
-@db_wrap
-async def add_webhook(conn, channel_id: int, webhook_id: int, webhook_token: str):
-    logger.debug("Adding new webhook (channel={}, webhook={}, token={})".format(
-        channel_id, webhook_id, webhook_token))
-    await conn.execute("insert into webhooks (channel, webhook, token) values ($1, $2, $3)", channel_id, webhook_id, webhook_token)
-
-@db_wrap
-async def delete_webhook(conn, channel_id: int):
-    await conn.execute("delete from webhooks where channel = $1", channel_id)
-
-@db_wrap
-async def add_message(conn, message_id: int, channel_id: int, member_id: int, sender_id: int):
-    logger.debug("Adding new message (id={}, channel={}, member={}, sender={})".format(
-        message_id, channel_id, member_id, sender_id))
-    await conn.execute("insert into messages (mid, channel, member, sender) values ($1, $2, $3, $4)", message_id, channel_id, member_id, sender_id)
-
-class ProxyMember(namedtuple("ProxyMember", ["id", "hid", "prefix", "suffix", "color", "name", "avatar_url", "tag", "system_name", "system_hid"])):
-    id: int
-    hid: str
-    prefix: str
-    suffix: str
-    color: str
-    name: str
-    avatar_url: str
-    tag: str
-    system_name: str
-    system_hid: str
-
-@db_wrap
-async def get_members_by_account(conn, account_id: int) -> List[ProxyMember]:
-    # Returns a "chimera" object
-    rows = await conn.fetch("""select
-            members.id, members.hid, members.prefix, members.suffix, members.color, members.name, members.avatar_url,
-            systems.tag, systems.name as system_name, systems.hid as system_hid
-        from
-            systems, members, accounts
-        where
-            accounts.uid = $1
-            and systems.id = accounts.system
-            and members.system = systems.id""", account_id)
-    return [ProxyMember(**row) for row in rows]
-
-class MessageInfo(namedtuple("MemberInfo", ["mid", "channel", "member", "sender", "name", "hid", "avatar_url", "system_name", "system_hid", "pronouns"])):
-    mid: int
-    channel: int
-    member: int
-    sender: int
-    name: str
-    hid: str
-    avatar_url: str
-    system_name: str
-    system_hid: str
-    pronouns: str
-
-    def to_json(self):
-        return {
-            "id": str(self.mid),
-            "channel": str(self.channel),
-            "member": self.hid,
-            "system": self.system_hid,
-            "message_sender": str(self.sender),
-            "timestamp": snowflake_time(self.mid).isoformat()
-        }
-
-@db_wrap
-async def get_message_by_sender_and_id(conn, message_id: int, sender_id: int) -> MessageInfo:
-    row = await conn.fetchrow("""select
-        messages.*,
-        members.name, members.hid, members.avatar_url, members.pronouns,
-        systems.name as system_name, systems.hid as system_hid
-    from
-        messages, members, systems
-    where
-        messages.member = members.id
-        and members.system = systems.id
-        and mid = $1
-        and sender = $2""", message_id, sender_id)
-    return MessageInfo(**row) if row else None
-
-
-@db_wrap
-async def get_message(conn, message_id: int) -> MessageInfo:
-    row = await conn.fetchrow("""select
-        messages.*,
-        members.name, members.hid, members.avatar_url, members.pronouns,
-        systems.name as system_name, systems.hid as system_hid
-    from
-        messages, members, systems
-    where
-        messages.member = members.id
-        and members.system = systems.id
-        and mid = $1""", message_id)
-    return MessageInfo(**row) if row else None
-
-
-@db_wrap
-async def delete_message(conn, message_id: int):
-    logger.debug("Deleting message (id={})".format(message_id))
-    await conn.execute("delete from messages where mid = $1", message_id)
-
-@db_wrap
-async def get_member_message_count(conn, member_id: int) -> int:
-    return await conn.fetchval("select count(*) from messages where member = $1", member_id)
-
-@db_wrap
-async def front_history(conn, system_id: int, count: int):
-    return await conn.fetch("""select
-        switches.*,
-        array(
-            select member from switch_members
-            where switch_members.switch = switches.id
-            order by switch_members.id asc
-        ) as members
-    from switches
-    where switches.system = $1
-    order by switches.timestamp desc
-    limit $2""", system_id, count)
-
-@db_wrap
-async def add_switch(conn, system_id: int):
-    logger.debug("Adding switch (system={})".format(system_id))
-    res = await conn.fetchrow("insert into switches (system) values ($1) returning *", system_id)
-    return res["id"]
-
-@db_wrap
-async def move_switch(conn, system_id: int, switch_id: int, new_time: datetime):
-    logger.debug("Moving latest switch (system={}, id={}, new_time={})".format(system_id, switch_id, new_time))
-    await conn.execute("update switches set timestamp = $1 where system = $2 and id = $3", new_time, system_id, switch_id)
-
-@db_wrap
-async def add_switch_member(conn, switch_id: int, member_id: int):
-    logger.debug("Adding switch member (switch={}, member={})".format(switch_id, member_id))
-    await conn.execute("insert into switch_members (switch, member) values ($1, $2)", switch_id, member_id)
-
-@db_wrap
-async def delete_switch(conn, switch_id: int):
-    logger.debug("Deleting switch (id={})".format(switch_id))
-    await conn.execute("delete from switches where id = $1", switch_id)
-
-@db_wrap
-async def get_server_info(conn, server_id: int):
-    return await conn.fetchrow("select * from servers where id = $1", server_id)
-
-@db_wrap
-async def update_server(conn, server_id: int, logging_channel_id: int):
-    logging_channel_id = logging_channel_id if logging_channel_id else None
-    logger.debug("Updating server settings (id={}, log_channel={})".format(server_id, logging_channel_id))
-    await conn.execute("insert into servers (id, log_channel) values ($1, $2) on conflict (id) do update set log_channel = $2", server_id, logging_channel_id)
-
-@db_wrap
-async def member_count(conn) -> int:
-    return await conn.fetchval("select count(*) from members")
-
-@db_wrap
-async def system_count(conn) -> int:
-    return await conn.fetchval("select count(*) from systems")
-
-@db_wrap
-async def message_count(conn) -> int:
-    return await conn.fetchval("select count(*) from messages")
-
-@db_wrap
-async def account_count(conn) -> int:
-    return await conn.fetchval("select count(*) from accounts")
-
-async def create_tables(conn):
-    await conn.execute("""create table if not exists systems (
-        id          serial primary key,
-        hid         char(5) unique not null,
-        name        text,
-        description text,
-        tag         text,
-        avatar_url  text,
-        token       text,
-        created     timestamp not null default (current_timestamp at time zone 'utc'),
-        ui_tz       text not null default 'UTC'
-    )""")
-    await conn.execute("""create table if not exists members (
-        id          serial primary key,
-        hid         char(5) unique not null,
-        system      serial not null references systems(id) on delete cascade,
-        color       char(6),
-        avatar_url  text,
-        name        text not null,
-        birthday    date,
-        pronouns    text,
-        description text,
-        prefix      text,
-        suffix      text,
-        created     timestamp not null default (current_timestamp at time zone 'utc')
-    )""")
-    await conn.execute("""create table if not exists accounts (
-        uid         bigint primary key,
-        system      serial not null references systems(id) on delete cascade
-    )""")
-    await conn.execute("""create table if not exists messages (
-        mid         bigint primary key,
-        channel     bigint not null,
-        member      serial not null references members(id) on delete cascade,
-        sender      bigint not null
-    )""")
-    await conn.execute("""create table if not exists switches (
-        id          serial primary key,
-        system      serial not null references systems(id) on delete cascade,
-        timestamp   timestamp not null default (current_timestamp at time zone 'utc')
-    )""")
-    await conn.execute("""create table if not exists switch_members (
-        id          serial primary key,
-        switch      serial not null references switches(id) on delete cascade,
-        member      serial not null references members(id) on delete cascade
-    )""")
-    await conn.execute("""create table if not exists webhooks (
-        channel     bigint primary key,
-        webhook     bigint not null,
-        token       text not null
-    )""")
-    await conn.execute("""create table if not exists servers (
-        id          bigint primary key,
-        log_channel bigint
-    )""")

src/pluralkit/errors.py

@@ -1,104 +0,0 @@
-from typing import Tuple
-
-
-class PluralKitError(Exception):
-    def __init__(self, message):
-        self.message = message
-        self.help_page = None
-
-    def with_help(self, help_page: Tuple[str, str]):
-        self.help_page = help_page
-
-
-class ExistingSystemError(PluralKitError):
-    def __init__(self):
-        super().__init__(
-            "You already have a system registered. To delete your system, use `pk;system delete`, or to unlink your system from this account, use `pk;system unlink`.")
-
-
-class DescriptionTooLongError(PluralKitError):
-    def __init__(self):
-        super().__init__("You can't have a description longer than 1024 characters.")
-
-
-class TagTooLongError(PluralKitError):
-    def __init__(self):
-        super().__init__("You can't have a system tag longer than 32 characters.")
-
-
-class TagTooLongWithMembersError(PluralKitError):
-    def __init__(self, member_names):
-        super().__init__(
-            "The maximum length of a name plus the system tag is 32 characters. The following members would exceed the limit: {}. Please reduce the length of the tag, or rename the members.".format(
-                ", ".join(member_names)))
-        self.member_names = member_names
-
-
-class CustomEmojiError(PluralKitError):
-    def __init__(self):
-        super().__init__(
-            "Due to a Discord limitation, custom emojis aren't supported. Please use a standard emoji instead.")
-
-
-class InvalidAvatarURLError(PluralKitError):
-    def __init__(self):
-        super().__init__("Invalid image URL.")
-
-
-class AccountInOwnSystemError(PluralKitError):
-    def __init__(self):
-        super().__init__("That account is already linked to your own system.")
-
-
-class AccountAlreadyLinkedError(PluralKitError):
-    def __init__(self, existing_system):
-        super().__init__("The mentioned account is already linked to a system (`{}`)".format(existing_system.hid))
-        self.existing_system = existing_system
-
-
-class UnlinkingLastAccountError(PluralKitError):
-    def __init__(self):
-        super().__init__("This is the only account on your system, so you can't unlink it.")
-
-
-class MemberNameTooLongError(PluralKitError):
-    def __init__(self, tag_present: bool):
-        if tag_present:
-            super().__init__(
-                "The maximum length of a name plus the system tag is 32 characters. Please reduce the length of the tag, or choose a shorter member name.")
-        else:
-            super().__init__("The maximum length of a member name is 32 characters.")
-
-
-class InvalidColorError(PluralKitError):
-    def __init__(self):
-        super().__init__("Color must be a valid hex color. (eg. #ff0000)")
-
-
-class InvalidDateStringError(PluralKitError):
-    def __init__(self):
-        super().__init__("Invalid date string. Date must be in ISO-8601 format (YYYY-MM-DD, eg. 1999-07-25).")
-
-
-class MembersAlreadyFrontingError(PluralKitError):
-    def __init__(self, members: "List[Member]"):
-        if len(members) == 0:
-            super().__init__("There are already no members fronting.")
-        elif len(members) == 1:
-            super().__init__("Member {} is already fronting.".format(members[0].name))
-        else:
-            super().__init__("Members {} are already fronting.".format(", ".join([member.name for member in members])))
-
-
-class DuplicateSwitchMembersError(PluralKitError):
-    def __init__(self):
-        super().__init__("Duplicate members in member list.")
-
-
-class InvalidTimeZoneError(PluralKitError):
-    def __init__(self, tz_name: str):
-        super().__init__("Invalid time zone designation \"{}\".\n\nFor a list of valid time zone designations, see the `TZ database name` column here: <https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List>.".format(tz_name))
-
-class TupperboxImportError(PluralKitError):
-    def __init__(self):
-        super().__init__("Invalid Tupperbox file.")

src/pluralkit/member.py

@@ -1,177 +0,0 @@
-import re
-from datetime import date, datetime
-
-from collections.__init__ import namedtuple
-from typing import Optional, Union
-
-from pluralkit import db, errors
-from pluralkit.utils import validate_avatar_url_or_raise, contains_custom_emoji
-
-
-class Member(namedtuple("Member",
-                        ["id", "hid", "system", "color", "avatar_url", "name", "birthday", "pronouns", "description",
-                         "prefix", "suffix", "created"])):
-    """An immutable representation of a system member fetched from the database."""
-    id: int
-    hid: str
-    system: int
-    color: str
-    avatar_url: str
-    name: str
-    birthday: date
-    pronouns: str
-    description: str
-    prefix: str
-    suffix: str
-    created: datetime
-
-    def to_json(self):
-        return {
-            "id": self.hid,
-            "name": self.name,
-            "color": self.color,
-            "avatar_url": self.avatar_url,
-            "birthday": self.birthday.isoformat() if self.birthday else None,
-            "pronouns": self.pronouns,
-            "description": self.description,
-            "prefix": self.prefix,
-            "suffix": self.suffix
-        }
-
-    @staticmethod
-    async def get_member_by_id(conn, member_id: int) -> Optional["Member"]:
-        """Fetch a member with the given internal member ID from the database."""
-        return await db.get_member(conn, member_id)
-
-    @staticmethod
-    async def get_member_by_name(conn, system_id: int, member_name: str) -> "Optional[Member]":
-        """Fetch a member by the given name in the given system from the database."""
-        member = await db.get_member_by_name(conn, system_id, member_name)
-        return member
-
-    @staticmethod
-    async def get_member_by_hid(conn, system_id: Optional[int], member_hid: str) -> "Optional[Member]":
-        """Fetch a member by the given hid from the database. If @`system_id` is present, will only return members from that system."""
-        if system_id:
-            member = await db.get_member_by_hid_in_system(conn, system_id, member_hid)
-        else:
-            member = await db.get_member_by_hid(conn, member_hid)
-
-        return member
-
-    @staticmethod
-    async def get_member_fuzzy(conn, system_id: int, name: str) -> "Optional[Member]":
-        by_hid = await Member.get_member_by_hid(conn, system_id, name)
-        if by_hid:
-            return by_hid
-
-        by_name = await Member.get_member_by_name(conn, system_id, name)
-        return by_name
-
-
-    async def set_name(self, conn, new_name: str):
-        """
-        Set the name of a member.
-        :raises: CustomEmojiError
-        """
-        # Custom emojis can't go in the member name
-        # Technically they *could*, but they wouldn't render properly
-        # so I'd rather explicitly ban them to in order to avoid confusion
-        if contains_custom_emoji(new_name):
-            raise errors.CustomEmojiError()
-
-        await db.update_member_field(conn, self.id, "name", new_name)
-
-    async def set_description(self, conn, new_description: Optional[str]):
-        """
-        Set or clear the description of a member.
-        :raises: DescriptionTooLongError
-        """
-        # Explicit length checking
-        if new_description and len(new_description) > 1024:
-            raise errors.DescriptionTooLongError()
-
-        await db.update_member_field(conn, self.id, "description", new_description)
-
-    async def set_avatar(self, conn, new_avatar_url: Optional[str]):
-        """
-        Set or clear the avatar of a member.
-        :raises: InvalidAvatarURLError
-        """
-        if new_avatar_url:
-            validate_avatar_url_or_raise(new_avatar_url)
-
-        await db.update_member_field(conn, self.id, "avatar_url", new_avatar_url)
-
-    async def set_color(self, conn, new_color: Optional[str]):
-        """
-        Set or clear the associated color of a member.
-        :raises: InvalidColorError
-        """
-        cleaned_color = None
-        if new_color:
-            match = re.fullmatch("#?([0-9A-Fa-f]{6})", new_color)
-            if not match:
-                raise errors.InvalidColorError()
-
-            cleaned_color = match.group(1).lower()
-
-        await db.update_member_field(conn, self.id, "color", cleaned_color)
-
-    async def set_birthdate(self, conn, new_date: Union[date, str]):
-        """
-        Set or clear the birthdate of a member. To hide the birth year, pass a year of 0001.
-
-        If passed a string, will attempt to parse the string as a date.
-        :raises: InvalidDateStringError
-        """
-
-        if isinstance(new_date, str):
-            date_str = new_date
-            try:
-                new_date = datetime.strptime(date_str, "%Y-%m-%d").date()
-            except ValueError:
-                try:
-                    # Try again, adding 0001 as a placeholder year
-                    # This is considered a "null year" and will be omitted from the info card
-                    # Useful if you want your birthday to be displayed yearless.
-                    new_date = datetime.strptime("0001-" + date_str, "%Y-%m-%d").date()
-                except ValueError:
-                    raise errors.InvalidDateStringError()
-
-        await db.update_member_field(conn, self.id, "birthday", new_date)
-
-    async def set_pronouns(self, conn, new_pronouns: str):
-        """Set or clear the associated pronouns with a member."""
-        await db.update_member_field(conn, self.id, "pronouns", new_pronouns)
-
-    async def set_proxy_tags(self, conn, prefix: Optional[str], suffix: Optional[str]):
-        """
-        Set the proxy tags for a member. Having no prefix *and* no suffix will disable proxying.
-        """
-        # Make sure empty strings or other falsey values are actually None
-        prefix = prefix or None
-        suffix = suffix or None
-
-        async with conn.transaction():
-            await db.update_member_field(conn, member_id=self.id, field="prefix", value=prefix)
-            await db.update_member_field(conn, member_id=self.id, field="suffix", value=suffix)
-
-    async def delete(self, conn):
-        """Delete this member from the database."""
-        await db.delete_member(conn, self.id)
-
-    async def fetch_system(self, conn) -> "System":
-        """Fetch the member's system from the database"""
-        return await db.get_system(conn, self.system)
-
-    async def message_count(self, conn) -> int:
-        return await db.get_member_message_count(conn, self.id)
-
-    def birthday_string(self) -> Optional[str]:
-        if not self.birthday:
-            return None
-
-        if self.birthday.year == 1:
-            return self.birthday.strftime("%b %d")
-        return self.birthday.strftime("%b %d, %Y")

src/pluralkit/switch.py

@@ -1,28 +0,0 @@
-from collections import namedtuple
-from datetime import datetime
-from typing import List
-
-from pluralkit import db
-from pluralkit.member import Member
-
-
-class Switch(namedtuple("Switch", ["id", "system", "timestamp", "members"])):
-    id: int
-    system: int
-    timestamp: datetime
-    members: List[int]
-
-    async def fetch_members(self, conn) -> List[Member]:
-        return await db.get_members(conn, self.members)
-
-    async def delete(self, conn):
-        await db.delete_switch(conn, self.id)
-
-    async def move(self, conn, new_timestamp):
-        await db.move_switch(conn, self.system, self.id, new_timestamp)
-
-    async def to_json(self, hid_getter):
-        return {
-            "timestamp": self.timestamp.isoformat(),
-            "members": [await hid_getter(m) for m in self.members]
-        }

src/pluralkit/system.py

@@ -1,324 +0,0 @@
-import random
-import re
-import string
-from collections.__init__ import namedtuple
-from datetime import datetime
-from typing import Optional, List, Tuple
-
-import pytz
-
-from pluralkit import db, errors
-from pluralkit.member import Member
-from pluralkit.switch import Switch
-from pluralkit.utils import generate_hid, contains_custom_emoji, validate_avatar_url_or_raise
-
-class TupperboxImportResult(namedtuple("TupperboxImportResult", ["updated", "created", "tags"])):
-    pass
-
-class System(namedtuple("System", ["id", "hid", "name", "description", "tag", "avatar_url", "token", "created", "ui_tz"])):
-    id: int
-    hid: str
-    name: str
-    description: str
-    tag: str
-    avatar_url: str
-    token: str
-    created: datetime
-    # pytz-compatible time zone name, usually Olson-style (eg. Europe/Amsterdam)
-    ui_tz: str
-
-    @staticmethod
-    async def get_by_id(conn, system_id: int) -> Optional["System"]:
-        return await db.get_system(conn, system_id)
-
-    @staticmethod
-    async def get_by_account(conn, account_id: int) -> Optional["System"]:
-        return await db.get_system_by_account(conn, account_id)
-
-    @staticmethod
-    async def get_by_token(conn, token: str) -> Optional["System"]:
-        return await db.get_system_by_token(conn, token)
-    
-    @staticmethod
-    async def get_by_hid(conn, hid: str) -> Optional["System"]:
-        return await db.get_system_by_hid(conn, hid)
-
-    @staticmethod
-    async def create_system(conn, account_id: int, system_name: Optional[str] = None) -> "System":
-        async with conn.transaction():
-            existing_system = await System.get_by_account(conn, account_id)
-            if existing_system:
-                raise errors.ExistingSystemError()
-
-            new_hid = generate_hid()
-            while await System.get_by_hid(conn, new_hid):
-                new_hid = generate_hid()
-
-            async with conn.transaction():
-                new_system = await db.create_system(conn, system_name, new_hid)
-                await db.link_account(conn, new_system.id, account_id)
-
-            return new_system
-
-    async def set_name(self, conn, new_name: Optional[str]):
-        await db.update_system_field(conn, self.id, "name", new_name)
-
-    async def set_description(self, conn, new_description: Optional[str]):
-        # Explicit length error
-        if new_description and len(new_description) > 1024:
-            raise errors.DescriptionTooLongError()
-
-        await db.update_system_field(conn, self.id, "description", new_description)
-
-    async def set_tag(self, conn, new_tag: Optional[str]):
-        if new_tag:
-            # Explicit length error
-            if len(new_tag) > 32:
-                raise errors.TagTooLongError()
-
-            if contains_custom_emoji(new_tag):
-                raise errors.CustomEmojiError()
-
-        await db.update_system_field(conn, self.id, "tag", new_tag)
-
-    async def set_avatar(self, conn, new_avatar_url: Optional[str]):
-        if new_avatar_url:
-            validate_avatar_url_or_raise(new_avatar_url)
-
-        await db.update_system_field(conn, self.id, "avatar_url", new_avatar_url)
-
-    async def link_account(self, conn, new_account_id: int):
-        async with conn.transaction():
-            existing_system = await System.get_by_account(conn, new_account_id)
-
-            if existing_system:
-                if existing_system.id == self.id:
-                    raise errors.AccountInOwnSystemError()
-
-                raise errors.AccountAlreadyLinkedError(existing_system)
-
-            await db.link_account(conn, self.id, new_account_id)
-
-    async def unlink_account(self, conn, account_id: int):
-        async with conn.transaction():
-            linked_accounts = await db.get_linked_accounts(conn, self.id)
-            if len(linked_accounts) == 1:
-                raise errors.UnlinkingLastAccountError()
-
-            await db.unlink_account(conn, self.id, account_id)
-
-    async def get_linked_account_ids(self, conn) -> List[int]:
-        return await db.get_linked_accounts(conn, self.id)
-
-    async def delete(self, conn):
-        await db.remove_system(conn, self.id)
-
-    async def refresh_token(self, conn) -> str:
-        new_token = "".join(random.choices(string.ascii_letters + string.digits, k=64))
-        await db.update_system_field(conn, self.id, "token", new_token)
-        return new_token
-
-    async def get_token(self, conn) -> str:
-        if self.token:
-            return self.token
-        return await self.refresh_token(conn)
-
-    async def create_member(self, conn, member_name: str) -> Member:
-        if len(member_name) > self.get_member_name_limit():
-            raise errors.MemberNameTooLongError(tag_present=bool(self.tag))
-        
-        new_hid = generate_hid()
-        while await db.get_member_by_hid(conn, new_hid):
-            new_hid = generate_hid()
-
-        member = await db.create_member(conn, self.id, member_name, new_hid)
-        return member
-
-    async def get_members(self, conn) -> List[Member]:
-        return await db.get_all_members(conn, self.id)
-
-    async def get_switches(self, conn, count) -> List[Switch]:
-        """Returns the latest `count` switches logged for this system, ordered latest to earliest."""
-        return [Switch(**s) for s in await db.front_history(conn, self.id, count)]
-
-    async def get_latest_switch(self, conn) -> Optional[Switch]:
-        """Returns the latest switch logged for this system, or None if no switches have been logged"""
-        switches = await self.get_switches(conn, 1)
-        if switches:
-            return switches[0]
-        else:
-            return None
-
-    async def add_switch(self, conn, members: List[Member]) -> Switch:
-        """
-        Logs a new switch for a system.
-
-        :raises: MembersAlreadyFrontingError, DuplicateSwitchMembersError
-        """
-        new_ids = [member.id for member in members]
-
-        last_switch = await self.get_latest_switch(conn)
-
-        # If we have a switch logged before, make sure this isn't a dupe switch
-        if last_switch:
-            last_switch_members = await last_switch.fetch_members(conn)
-            last_ids = [member.id for member in last_switch_members]
-
-            # We don't compare by set() here because swapping multiple is a valid operation
-            if last_ids == new_ids:
-                raise errors.MembersAlreadyFrontingError(members)
-
-        # Check for dupes
-        if len(set(new_ids)) != len(new_ids):
-            raise errors.DuplicateSwitchMembersError()
-
-        async with conn.transaction():
-            switch_id = await db.add_switch(conn, self.id)
-
-            # TODO: batch query here
-            for member in members:
-                await db.add_switch_member(conn, switch_id, member.id)
-
-            return await self.get_latest_switch(conn)
-
-    def get_member_name_limit(self) -> int:
-        """Returns the maximum length a member's name or nickname is allowed to be in order for the member to be proxied. Depends on the system tag."""
-        if self.tag:
-            return 32 - len(self.tag) - 1
-        else:
-            return 32
-
-    async def match_proxy(self, conn, message: str) -> Optional[Tuple[Member, str]]:
-        """Tries to find a member with proxy tags matching the given message. Returns the member and the inner contents."""
-        members = await db.get_all_members(conn, self.id)
-
-        # Sort by match specificity (longer prefix/suffix = smaller match = more specific)
-        members = sorted(members, key=lambda x: len(x.prefix or "") + len(x.suffix or ""), reverse=True)
-
-        for member in members:
-            proxy_prefix = member.prefix or ""
-            proxy_suffix = member.suffix or ""
-
-            if not proxy_prefix and not proxy_suffix:
-                # If the member has neither a prefix or a suffix, cancel early
-                # Otherwise it'd match any message no matter what
-                continue
-
-            # Check if the message matches these tags
-            if message.startswith(proxy_prefix) and message.endswith(proxy_suffix):
-                # If the message starts with a mention, "separate" that and match the bit after
-                mention_match = re.match(r"^(<(@|@!|#|@&|a?:\w+:)\d+>\s*)+", message)
-                leading_mentions = ""
-                if mention_match:
-                    message = message[mention_match.span(0)[1]:].strip()
-                    leading_mentions = mention_match.group(0)
-
-                # Extract the inner message (special case because -0 is invalid as an end slice)
-                if len(proxy_suffix) == 0:
-                    inner_message = message[len(proxy_prefix):]
-                else:
-                    inner_message = message[len(proxy_prefix):-len(proxy_suffix)]
-
-                # Add the stripped mentions back if there are any
-                inner_message = leading_mentions + inner_message
-                return member, inner_message
-
-    def format_time(self, dt: datetime) -> str:
-        """
-        Localizes the given `datetime` to a string based on the system's preferred time zone.
-
-        Assumes `dt` is a naïve `datetime` instance set to UTC, which is consistent with the rest of PluralKit.
-        """
-        tz = pytz.timezone(self.ui_tz)
-
-        # Set to aware (UTC), convert to tz, set to naive (tz), then format and append name
-        return tz.normalize(pytz.utc.localize(dt)).replace(tzinfo=None).isoformat(sep=" ", timespec="seconds") + " " + tz.tzname(dt)
-
-    async def set_time_zone(self, conn, tz_name: str) -> pytz.tzinfo:
-        """
-        Sets the system time zone to the time zone represented by the given string.
-
-        If `tz_name` is None or an empty string, will default to UTC.
-        If `tz_name` does not represent a valid time zone string, will raise InvalidTimeZoneError.
-
-        :raises: InvalidTimeZoneError
-        :returns: The `pytz.tzinfo` instance of the newly set time zone.
-        """
-
-        try:
-            tz = pytz.timezone(tz_name or "UTC")
-        except pytz.UnknownTimeZoneError:
-            raise errors.InvalidTimeZoneError(tz_name)
-
-        await db.update_system_field(conn, self.id, "ui_tz", tz.zone)
-        return tz
-
-    async def import_from_tupperbox(self, conn, data: dict):
-        """
-        Imports from a Tupperbox JSON data file.
-        :raises: TupperboxImportError
-        """
-        if not "tuppers" in data:
-            raise errors.TupperboxImportError()
-        if not isinstance(data["tuppers"], list):
-            raise errors.TupperboxImportError()
-        
-        all_tags = set()
-        created_members = set()
-        updated_members = set()
-        for tupper in data["tuppers"]:
-            # Sanity check tupper fields
-            for field in ["name", "avatar_url", "brackets", "birthday", "description", "tag"]:
-                if field not in tupper:
-                    raise errors.TupperboxImportError()
-            
-            # Find member by name, create if not exists
-            member_name = str(tupper["name"])
-            member = await Member.get_member_by_name(conn, self.id, member_name)
-            if not member:
-                # And keep track of created members
-                created_members.add(member_name)
-                member = await self.create_member(conn, member_name)
-            else:
-                # Keep track of updated members
-                updated_members.add(member_name)
-
-            # Set avatar
-            await member.set_avatar(conn, str(tupper["avatar_url"]))
-
-            # Set proxy tags
-            if not (isinstance(tupper["brackets"], list) and len(tupper["brackets"]) >= 2):
-                raise errors.TupperboxImportError()
-            await member.set_proxy_tags(conn, str(tupper["brackets"][0]), str(tupper["brackets"][1]))
-
-            # Set birthdate (input is in ISO-8601, first 10 characters is the date)
-            if tupper["birthday"]:
-                try:
-                    await member.set_birthdate(conn, str(tupper["birthday"][:10]))
-                except errors.InvalidDateStringError:
-                    pass
-            
-            # Set description
-            await member.set_description(conn, tupper["description"])
-
-            # Keep track of tag
-            all_tags.add(tupper["tag"])
-
-        # Since Tupperbox does tags on a per-member basis, we only apply a system tag if
-        # every member has the same tag (surprisingly common)
-        # If not, we just do nothing. (This will be reported in the caller function through the returned result)
-        if len(all_tags) == 1:
-            tag = list(all_tags)[0]
-            await self.set_tag(conn, tag)
-
-        return TupperboxImportResult(updated=updated_members, created=created_members, tags=all_tags)
-                
-    def to_json(self):
-        return {
-            "id": self.hid,
-            "name": self.name,
-            "description": self.description,
-            "tag": self.tag,
-            "avatar_url": self.avatar_url,
-            "tz": self.ui_tz
-        }

src/pluralkit/utils.py

@@ -1,73 +0,0 @@
-import humanize
-import re
-
-import random
-import string
-from datetime import datetime, timezone, timedelta
-from typing import List, Tuple, Union
-from urllib.parse import urlparse
-
-from pluralkit import db
-from pluralkit.errors import InvalidAvatarURLError
-
-
-def display_relative(time: Union[datetime, timedelta]) -> str:
-    if isinstance(time, datetime):
-        time = datetime.utcnow() - time
-    return humanize.naturaldelta(time)
-
-
-async def get_fronter_ids(conn, system_id) -> (List[int], datetime):
-    switches = await db.front_history(conn, system_id=system_id, count=1)
-    if not switches:
-        return [], None
-
-    if not switches[0]["members"]:
-        return [], switches[0]["timestamp"]
-
-    return switches[0]["members"], switches[0]["timestamp"]
-
-
-async def get_fronters(conn, system_id) -> (List["Member"], datetime):
-    member_ids, timestamp = await get_fronter_ids(conn, system_id)
-
-    # Collect in dict and then look up as list, to preserve return order
-    members = {member.id: member for member in await db.get_members(conn, member_ids)}
-    return [members[member_id] for member_id in member_ids], timestamp
-
-
-async def get_front_history(conn, system_id, count) -> List[Tuple[datetime, List["pluMember"]]]:
-    # Get history from DB
-    switches = await db.front_history(conn, system_id=system_id, count=count)
-    if not switches:
-        return []
-
-    # Get all unique IDs referenced
-    all_member_ids = {id for switch in switches for id in switch["members"]}
-
-    # And look them up in the database into a dict
-    all_members = {member.id: member for member in await db.get_members(conn, list(all_member_ids))}
-
-    # Collect in array and return
-    out = []
-    for switch in switches:
-        timestamp = switch["timestamp"]
-        members = [all_members[id] for id in switch["members"]]
-        out.append((timestamp, members))
-    return out
-
-
-def generate_hid() -> str:
-    return "".join(random.choices(string.ascii_lowercase, k=5))
-
-
-def contains_custom_emoji(value):
-    return bool(re.search("<a?:\w+:\d+>", value))
-
-
-def validate_avatar_url_or_raise(url):
-    u = urlparse(url)
-    if not (u.scheme in ["http", "https"] and u.netloc and u.path):
-        raise InvalidAvatarURLError()
-
-    # TODO: check file type and size of image

src/requirements.txt

@@ -1,10 +0,0 @@
-aiodns
-aiohttp==3.3.0
-asyncpg
-dateparser
-https://github.com/Rapptz/discord.py/archive/aceec2009a7c819d2236884fa9ccc5ce58a92bea.zip#egg=discord.py
-humanize
-uvloop; sys.platform != 'win32' and sys.platform != 'cygwin' and sys.platform != 'cli'
-ciso8601
-pytz
-timezonefinder

web/.babelrc

@@ -1,14 +0,0 @@
-{
-    "presets": [
-        [
-            "env",
-            {
-                "targets": {
-                    "browsers": [
-                        "last 2 Chrome versions"
-                    ]
-                }
-            }
-        ]
-    ]
-}

web/.gitignore

@@ -1,3 +0,0 @@
-.cache/
-dist/
-node_modules/

web/app/API.js

@@ -1,63 +0,0 @@
-import { EventEmitter } from "eventemitter3"
-
-const SITE_ROOT = process.env.NODE_ENV === "production" ? "https://pluralkit.me" : "http://localhost:1234";
-const API_ROOT = process.env.NODE_ENV === "production" ? "https://api.pluralkit.me" : "http://localhost:2939";
-const CLIENT_ID = process.env.NODE_ENV === "production" ? "466378653216014359" : "467772037541134367";
-export const AUTH_URI = `https://discordapp.com/api/oauth2/authorize?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(SITE_ROOT + "/auth/discord")}&response_type=code&scope=identify`
-
-
-class API extends EventEmitter {
-    async init() {
-        this.token = localStorage.getItem("pk-token");
-        if (this.token) {
-            this.me = await fetch(API_ROOT + "/s", {headers: {"X-Token": this.token}}).then(r => r.json());
-            this.emit("update", this.me);
-        }
-    }
-
-    async fetchSystem(id) {
-        return await fetch(API_ROOT + "/s/" + id).then(r => r.json()) || null;
-    }
-
-    async fetchSystemMembers(id) {
-        return await fetch(API_ROOT + "/s/" + id + "/members").then(r => r.json()) || [];
-    }
-
-    async fetchSystemSwitches(id) {
-        return await fetch(API_ROOT + "/s/" + id + "/switches").then(r => r.json()) || [];
-    }
-
-    async fetchMember(id) {
-        return await fetch(API_ROOT + "/m/" + id).then(r => r.json()) || null;
-    }
-
-    async saveSystem(system) {
-        return await fetch(API_ROOT + "/s", {
-            method: "PATCH",
-            headers: {"X-Token": this.token},
-            body: JSON.stringify(system)
-        });
-    }
-
-    async login(code) {
-        this.token = await fetch(API_ROOT + "/discord_oauth", {method: "POST", body: code}).then(r => r.text());
-        this.me = await fetch(API_ROOT + "/s", {headers: {"X-Token": this.token}}).then(r => r.json());
-
-        if (this.me) {
-            localStorage.setItem("pk-token", this.token);
-            this.emit("update", this.me);
-        } else {
-            this.logout();
-        }
-        return this.me;
-    }
-
-    logout() {
-        localStorage.removeItem("pk-token");
-        this.emit("update", null);
-        this.token = null;
-        this.me = null;
-    }
-}
-
-export default new API();