Merge branch 'knub30' into k30_messageSaver

backend/src/plugins/AutoReactions/AutoReactionsPlugin.ts

@@ -0,0 +1,45 @@
+import { zeppelinPlugin } from "../ZeppelinPluginBlueprint";
+import { ConfigSchema, AutoReactionsPluginType } from "./types";
+import { PluginOptions } from "knub";
+import { NewAutoReactionsCmd } from "./commands/NewAutoReactionsCmd";
+import { DisableAutoReactionsCmd } from "./commands/DisableAutoReactionsCmd";
+import { MessageCreateEvt } from "./events/MessageCreateEvt";
+import { GuildSavedMessages } from "src/data/GuildSavedMessages";
+import { GuildAutoReactions } from "src/data/GuildAutoReactions";
+
+const defaultOptions: PluginOptions<AutoReactionsPluginType> = {
+  config: {
+    can_manage: false,
+  },
+  overrides: [
+    {
+      level: ">=100",
+      config: {
+        can_manage: true,
+      },
+    },
+  ],
+};
+
+export const AutoReactionsPlugin = zeppelinPlugin<AutoReactionsPluginType>()("auto_reactions", {
+  configSchema: ConfigSchema,
+  defaultOptions,
+
+  // prettier-ignore
+  commands: [
+    NewAutoReactionsCmd,
+    DisableAutoReactionsCmd,
+  ],
+
+  // prettier-ignore
+  events: [
+    MessageCreateEvt,
+  ],
+
+  onLoad(pluginData) {
+    const { state, guild } = pluginData;
+
+    state.savedMessages = GuildSavedMessages.getGuildInstance(guild.id);
+    state.autoReactions = GuildAutoReactions.getGuildInstance(guild.id);
+  },
+});

backend/src/plugins/AutoReactions/commands/DisableAutoReactionsCmd.ts

@@ -0,0 +1,24 @@
+import { autoReactionsCmd } from "../types";
+import { commandTypeHelpers as ct } from "../../../commandTypes";
+import { sendErrorMessage, sendSuccessMessage } from "src/pluginUtils";
+
+export const DisableAutoReactionsCmd = autoReactionsCmd({
+  trigger: "auto_reactions disable",
+  permission: "can_manage",
+  usage: "!auto_reactions disable 629990160477585428",
+
+  signature: {
+    channelId: ct.channelId(),
+  },
+
+  async run({ message: msg, args, pluginData }) {
+    const autoReaction = await pluginData.state.autoReactions.getForChannel(args.channelId);
+    if (!autoReaction) {
+      sendErrorMessage(pluginData, msg.channel, `Auto-reactions aren't enabled in <#${args.channelId}>`);
+      return;
+    }
+
+    await pluginData.state.autoReactions.removeFromChannel(args.channelId);
+    sendSuccessMessage(pluginData, msg.channel, `Auto-reactions disabled in <#${args.channelId}>`);
+  },
+});

backend/src/plugins/AutoReactions/commands/NewAutoReactionsCmd.ts

@@ -0,0 +1,47 @@
+import { autoReactionsCmd } from "../types";
+import { commandTypeHelpers as ct } from "../../../commandTypes";
+import { isEmoji, customEmojiRegex, canUseEmoji } from "src/utils";
+import { sendErrorMessage, sendSuccessMessage } from "src/pluginUtils";
+
+export const NewAutoReactionsCmd = autoReactionsCmd({
+  trigger: "auto_reactions",
+  permission: "can_manage",
+  usage: "!auto_reactions 629990160477585428 👍 👎",
+
+  signature: {
+    channelId: ct.channelId(),
+    reactions: ct.string({ rest: true }),
+  },
+
+  async run({ message: msg, args, pluginData }) {
+    const finalReactions = [];
+
+    for (const reaction of args.reactions) {
+      if (!isEmoji(reaction)) {
+        sendErrorMessage(pluginData, msg.channel, "One or more of the specified reactions were invalid!");
+        return;
+      }
+
+      let savedValue;
+
+      const customEmojiMatch = reaction.match(customEmojiRegex);
+      if (customEmojiMatch) {
+        // Custom emoji
+        if (!canUseEmoji(pluginData.client, customEmojiMatch[2])) {
+          sendErrorMessage(pluginData, msg.channel, "I can only use regular emojis and custom emojis from this server");
+          return;
+        }
+
+        savedValue = `${customEmojiMatch[1]}:${customEmojiMatch[2]}`;
+      } else {
+        // Unicode emoji
+        savedValue = reaction;
+      }
+
+      finalReactions.push(savedValue);
+    }
+
+    await pluginData.state.autoReactions.set(args.channelId, finalReactions);
+    sendSuccessMessage(pluginData, msg.channel, `Auto-reactions set for <#${args.channelId}>`);
+  },
+});

backend/src/plugins/AutoReactions/events/MessageCreateEvt.ts

@@ -0,0 +1,43 @@
+import { autoReactionsEvt } from "../types";
+import { isDiscordRESTError } from "src/utils";
+import { logger } from "knub";
+import { LogType } from "src/data/LogType";
+
+export const MessageCreateEvt = autoReactionsEvt({
+  event: "messageCreate",
+  allowOutsideOfGuild: false,
+
+  async listener(meta) {
+    const pluginData = meta.pluginData;
+    const msg = meta.args.message;
+
+    const autoReaction = await pluginData.state.autoReactions.getForChannel(msg.channel.id);
+    if (!autoReaction) return;
+
+    for (const reaction of autoReaction.reactions) {
+      try {
+        await msg.addReaction(reaction);
+      } catch (e) {
+        if (isDiscordRESTError(e)) {
+          logger.warn(
+            `Could not apply auto-reaction to ${msg.channel.id}/${msg.id} in guild ${pluginData.guild.name} (${pluginData.guild.id}) (error code ${e.code})`,
+          );
+
+          if (e.code === 10008) {
+            pluginData.state.logs.log(LogType.BOT_ALERT, {
+              body: `Could not apply auto-reactions in <#${msg.channel.id}> for message \`${msg.id}\`. Make sure nothing is deleting the message before the reactions are applied.`,
+            });
+          } else {
+            pluginData.state.logs.log(LogType.BOT_ALERT, {
+              body: `Could not apply auto-reactions in <#${msg.channel.id}> for message \`${msg.id}\`. Error code ${e.code}.`,
+            });
+          }
+
+          return;
+        } else {
+          throw e;
+        }
+      }
+    }
+  },
+});

backend/src/plugins/AutoReactions/types.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+import { BasePluginType, command, eventListener } from "knub";
+import { GuildLogs } from "src/data/GuildLogs";
+import { GuildSavedMessages } from "src/data/GuildSavedMessages";
+import { GuildAutoReactions } from "src/data/GuildAutoReactions";
+
+export const ConfigSchema = t.type({
+  can_manage: t.boolean,
+});
+export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
+
+export interface AutoReactionsPluginType extends BasePluginType {
+  config: TConfigSchema;
+  state: {
+    logs: GuildLogs;
+    savedMessages: GuildSavedMessages;
+    autoReactions: GuildAutoReactions;
+  };
+}
+
+export const autoReactionsCmd = command<AutoReactionsPluginType>();
+export const autoReactionsEvt = eventListener<AutoReactionsPluginType>();

backend/src/plugins/LocateUser/commands/FollowCmd.ts

@@ -13,7 +13,7 @@ export const FollowCmd = locateUserCommand({
 
   signature: {
     member: ct.resolvedMember(),
-    reminder: ct.string({ required: false, rest: true }),
+    reminder: ct.string({ required: false, catchAll: true }),
 
     duration: ct.delay({ option: true, shortcut: "d" }),
     active: ct.bool({ option: true, shortcut: "a" }),

backend/src/plugins/Reminders/RemindersPlugin.ts

@@ -0,0 +1,50 @@
+import { PluginOptions } from "knub";
+import { ConfigSchema, RemindersPluginType } from "./types";
+import { zeppelinPlugin } from "../ZeppelinPluginBlueprint";
+import { GuildReminders } from "src/data/GuildReminders";
+import { postDueRemindersLoop } from "./utils/postDueRemindersLoop";
+import { RemindCmd } from "./commands/RemindCmd";
+import { RemindersCmd } from "./commands/RemindersCmd";
+import { RemindersDeleteCmd } from "./commands/RemindersDeleteCmd";
+
+const defaultOptions: PluginOptions<RemindersPluginType> = {
+  config: {
+    can_use: false,
+  },
+  overrides: [
+    {
+      level: ">=50",
+      config: {
+        can_use: true,
+      },
+    },
+  ],
+};
+
+export const RemindersPlugin = zeppelinPlugin<RemindersPluginType>()("reminders", {
+  configSchema: ConfigSchema,
+  defaultOptions,
+
+  // prettier-ignore
+  commands: [
+    RemindCmd,
+    RemindersCmd,
+    RemindersDeleteCmd,
+  ],
+
+  onLoad(pluginData) {
+    const { state, guild } = pluginData;
+
+    state.reminders = GuildReminders.getGuildInstance(guild.id);
+    state.tries = new Map();
+    state.unloaded = false;
+
+    state.postRemindersTimeout = null;
+    postDueRemindersLoop(pluginData);
+  },
+
+  onUnload(pluginData) {
+    clearTimeout(pluginData.state.postRemindersTimeout);
+    pluginData.state.unloaded = true;
+  },
+});

backend/src/plugins/Reminders/commands/RemindCmd.ts

@@ -0,0 +1,65 @@
+import { commandTypeHelpers as ct } from "../../../commandTypes";
+import moment from "moment-timezone";
+import { convertDelayStringToMS } from "src/utils";
+import humanizeDuration from "humanize-duration";
+import { sendErrorMessage, sendSuccessMessage } from "src/pluginUtils";
+import { remindersCommand } from "../types";
+
+export const RemindCmd = remindersCommand({
+  trigger: ["remind", "remindme"],
+  usage: "!remind 3h Remind me of this in 3 hours please",
+  permission: "can_use",
+
+  signature: {
+    time: ct.string(),
+    reminder: ct.string({ required: false, catchAll: true }),
+  },
+
+  async run({ message: msg, args, pluginData }) {
+    const now = moment();
+
+    let reminderTime;
+    if (args.time.match(/^\d{4}-\d{1,2}-\d{1,2}$/)) {
+      // Date in YYYY-MM-DD format, remind at current time on that date
+      reminderTime = moment(args.time, "YYYY-M-D").set({
+        hour: now.hour(),
+        minute: now.minute(),
+        second: now.second(),
+      });
+    } else if (args.time.match(/^\d{4}-\d{1,2}-\d{1,2}T\d{2}:\d{2}$/)) {
+      // Date and time in YYYY-MM-DD[T]HH:mm format
+      reminderTime = moment(args.time, "YYYY-M-D[T]HH:mm").second(0);
+    } else {
+      // "Delay string" i.e. e.g. "2h30m"
+      const ms = convertDelayStringToMS(args.time);
+      if (ms === null) {
+        sendErrorMessage(pluginData, msg.channel, "Invalid reminder time");
+        return;
+      }
+
+      reminderTime = moment().add(ms, "millisecond");
+    }
+
+    if (!reminderTime.isValid() || reminderTime.isBefore(now)) {
+      sendErrorMessage(pluginData, msg.channel, "Invalid reminder time");
+      return;
+    }
+
+    const reminderBody = args.reminder || `https://discord.com/channels/${this.guildId}/${msg.channel.id}/${msg.id}`;
+    await pluginData.state.reminders.add(
+      msg.author.id,
+      msg.channel.id,
+      reminderTime.format("YYYY-MM-DD HH:mm:ss"),
+      reminderBody,
+      moment().format("YYYY-MM-DD HH:mm:ss"),
+    );
+
+    const msUntilReminder = reminderTime.diff(now);
+    const timeUntilReminder = humanizeDuration(msUntilReminder, { largest: 2, round: true });
+    sendSuccessMessage(
+      pluginData,
+      msg.channel,
+      `I will remind you in **${timeUntilReminder}** at **${reminderTime.format("YYYY-MM-DD, HH:mm")}**`,
+    );
+  },
+});

backend/src/plugins/Reminders/commands/RemindersCmd.ts

@@ -0,0 +1,31 @@
+import { remindersCommand } from "../types";
+import { sendErrorMessage } from "src/pluginUtils";
+import { sorter, createChunkedMessage } from "src/utils";
+import moment from "moment-timezone";
+import humanizeDuration from "humanize-duration";
+
+export const RemindersCmd = remindersCommand({
+  trigger: "reminders",
+  permission: "can_use",
+
+  async run({ message: msg, args, pluginData }) {
+    const reminders = await pluginData.state.reminders.getRemindersByUserId(msg.author.id);
+    if (reminders.length === 0) {
+      sendErrorMessage(pluginData, msg.channel, "No reminders");
+      return;
+    }
+
+    reminders.sort(sorter("remind_at"));
+    const longestNum = (reminders.length + 1).toString().length;
+    const lines = Array.from(reminders.entries()).map(([i, reminder]) => {
+      const num = i + 1;
+      const paddedNum = num.toString().padStart(longestNum, " ");
+      const target = moment(reminder.remind_at, "YYYY-MM-DD HH:mm:ss");
+      const diff = target.diff(moment());
+      const result = humanizeDuration(diff, { largest: 2, round: true });
+      return `\`${paddedNum}.\` \`${reminder.remind_at} (${result})\` ${reminder.body}`;
+    });
+
+    createChunkedMessage(msg.channel, lines.join("\n"));
+  },
+});

backend/src/plugins/Reminders/commands/RemindersDeleteCmd.ts

@@ -0,0 +1,29 @@
+import { remindersCommand } from "../types";
+import { sendErrorMessage, sendSuccessMessage } from "src/pluginUtils";
+import { sorter } from "src/utils";
+import { commandTypeHelpers as ct } from "../../../commandTypes";
+
+export const RemindersDeleteCmd = remindersCommand({
+  trigger: ["reminders delete", "reminders d"],
+  permission: "can_use",
+
+  signature: {
+    num: ct.number(),
+  },
+
+  async run({ message: msg, args, pluginData }) {
+    const reminders = await pluginData.state.reminders.getRemindersByUserId(msg.author.id);
+    reminders.sort(sorter("remind_at"));
+    const lastNum = reminders.length + 1;
+
+    if (args.num > lastNum || args.num < 0) {
+      sendErrorMessage(pluginData, msg.channel, "Unknown reminder");
+      return;
+    }
+
+    const toDelete = reminders[args.num - 1];
+    await pluginData.state.reminders.delete(toDelete.id);
+
+    sendSuccessMessage(pluginData, msg.channel, "Reminder deleted");
+  },
+});

backend/src/plugins/Reminders/types.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+import { BasePluginType, command } from "knub";
+import { GuildReminders } from "src/data/GuildReminders";
+
+export const ConfigSchema = t.type({
+  can_use: t.boolean,
+});
+export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
+
+export interface RemindersPluginType extends BasePluginType {
+  config: TConfigSchema;
+
+  state: {
+    reminders: GuildReminders;
+    tries: Map<number, number>;
+
+    postRemindersTimeout;
+    unloaded: boolean;
+  };
+}
+
+export const remindersCommand = command<RemindersPluginType>();

backend/src/plugins/Reminders/utils/postDueRemindersLoop.ts

@@ -0,0 +1,48 @@
+import { TextChannel } from "eris";
+import { PluginData } from "knub";
+import { RemindersPluginType } from "../types";
+import moment from "moment-timezone";
+import humanizeDuration from "humanize-duration";
+import { disableLinkPreviews } from "knub/dist/helpers";
+import { SECONDS } from "src/utils";
+
+const REMINDER_LOOP_TIME = 10 * SECONDS;
+const MAX_TRIES = 3;
+
+export async function postDueRemindersLoop(pluginData: PluginData<RemindersPluginType>) {
+  const pendingReminders = await pluginData.state.reminders.getDueReminders();
+  for (const reminder of pendingReminders) {
+    const channel = pluginData.guild.channels.get(reminder.channel_id);
+    if (channel && channel instanceof TextChannel) {
+      try {
+        // Only show created at date if one exists
+        if (moment(reminder.created_at).isValid()) {
+          const target = moment();
+          const diff = target.diff(moment(reminder.created_at, "YYYY-MM-DD HH:mm:ss"));
+          const result = humanizeDuration(diff, { largest: 2, round: true });
+          await channel.createMessage(
+            disableLinkPreviews(
+              `Reminder for <@!${reminder.user_id}>: ${reminder.body} \n\`Set at ${reminder.created_at} (${result} ago)\``,
+            ),
+          );
+        } else {
+          await channel.createMessage(disableLinkPreviews(`Reminder for <@!${reminder.user_id}>: ${reminder.body}`));
+        }
+      } catch (e) {
+        // Probably random Discord internal server error or missing permissions or somesuch
+        // Try again next round unless we've already tried to post this a bunch of times
+        const tries = pluginData.state.tries.get(reminder.id) || 0;
+        if (tries < MAX_TRIES) {
+          pluginData.state.tries.set(reminder.id, tries + 1);
+          continue;
+        }
+      }
+    }
+
+    await pluginData.state.reminders.delete(reminder.id);
+  }
+
+  if (!pluginData.state.unloaded) {
+    pluginData.state.postRemindersTimeout = setTimeout(() => postDueRemindersLoop(pluginData), REMINDER_LOOP_TIME);
+  }
+}

backend/src/plugins/UsernameSaver/UsernameSaverPlugin.ts

@@ -0,0 +1,21 @@
+import { zeppelinPlugin } from "../ZeppelinPluginBlueprint";
+import { UsernameHistory } from "src/data/UsernameHistory";
+import { Queue } from "src/Queue";
+import { UsernameSaverPluginType } from "./types";
+import { MessageCreateEvt } from "./events/MessageCreateEvt";
+import { VoiceChannelJoinEvt } from "./events/VoiceChannelJoinEvt";
+
+export const UsernameSaverPlugin = zeppelinPlugin<UsernameSaverPluginType>()("username_saver", {
+  // prettier-ignore
+  events: [
+    MessageCreateEvt,
+    VoiceChannelJoinEvt,
+  ],
+
+  onLoad(pluginData) {
+    const { state, guild } = pluginData;
+
+    state.usernameHistory = new UsernameHistory();
+    state.updateQueue = new Queue();
+  },
+});

backend/src/plugins/UsernameSaver/events/MessageCreateEvt.ts

@@ -0,0 +1,11 @@
+import { usernameEvent } from "../types";
+import { updateUsername } from "../updateUsername";
+
+export const MessageCreateEvt = usernameEvent({
+  event: "messageCreate",
+
+  async listener(meta) {
+    if (meta.args.message.author.bot) return;
+    meta.pluginData.state.updateQueue.add(() => updateUsername(meta.pluginData, meta.args.message.author));
+  },
+});

backend/src/plugins/UsernameSaver/events/VoiceChannelJoinEvt.ts

@@ -0,0 +1,11 @@
+import { usernameEvent } from "../types";
+import { updateUsername } from "../updateUsername";
+
+export const VoiceChannelJoinEvt = usernameEvent({
+  event: "voiceChannelJoin",
+
+  async listener(meta) {
+    if (meta.args.member.bot) return;
+    meta.pluginData.state.updateQueue.add(() => updateUsername(meta.pluginData, meta.args.member.user));
+  },
+});

backend/src/plugins/UsernameSaver/types.ts

@@ -0,0 +1,12 @@
+import { BasePluginType, eventListener } from "knub";
+import { UsernameHistory } from "src/data/UsernameHistory";
+import { Queue } from "src/Queue";
+
+export interface UsernameSaverPluginType extends BasePluginType {
+  state: {
+    usernameHistory: UsernameHistory;
+    updateQueue: Queue;
+  };
+}
+
+export const usernameEvent = eventListener<UsernameSaverPluginType>();

backend/src/plugins/UsernameSaver/updateUsername.ts

@@ -0,0 +1,12 @@
+import { User } from "eris";
+import { PluginData } from "knub";
+import { UsernameSaverPluginType } from "./types";
+
+export async function updateUsername(pluginData: PluginData<UsernameSaverPluginType>, user: User) {
+  if (!user) return;
+  const newUsername = `${user.username}#${user.discriminator}`;
+  const latestEntry = await pluginData.state.usernameHistory.getLastEntry(user.id);
+  if (!latestEntry || newUsername !== latestEntry.username) {
+    await pluginData.state.usernameHistory.addEntry(user.id, newUsername);
+  }
+}

backend/src/plugins/WelcomeMessage/WelcomeMessagePlugin.ts

@@ -0,0 +1,29 @@
+import { zeppelinPlugin } from "../ZeppelinPluginBlueprint";
+import { PluginOptions } from "knub";
+import { WelcomeMessagePluginType, ConfigSchema } from "./types";
+import { GuildLogs } from "src/data/GuildLogs";
+import { GuildMemberAddEvt } from "./events/GuildMemberAddEvt";
+
+const defaultOptions: PluginOptions<WelcomeMessagePluginType> = {
+  config: {
+    send_dm: false,
+    send_to_channel: null,
+    message: "",
+  },
+};
+
+export const WelcomeMessagePlugin = zeppelinPlugin<WelcomeMessagePluginType>()("welcome_message", {
+  configSchema: ConfigSchema,
+  defaultOptions,
+
+  // prettier-ignore
+  events: [
+    GuildMemberAddEvt,
+  ],
+
+  onLoad(pluginData) {
+    const { state, guild } = pluginData;
+
+    state.logs = new GuildLogs(guild.id);
+  },
+});

backend/src/plugins/WelcomeMessage/events/GuildMemberAddEvt.ts

@@ -0,0 +1,51 @@
+import { welcomeEvent } from "../types";
+import { renderTemplate } from "src/templateFormatter";
+import { stripObjectToScalars, createChunkedMessage } from "src/utils";
+import { LogType } from "src/data/LogType";
+import { TextChannel } from "eris";
+
+export const GuildMemberAddEvt = welcomeEvent({
+  event: "guildMemberAdd",
+
+  async listener(meta) {
+    const pluginData = meta.pluginData;
+    const member = meta.args.member;
+
+    const config = pluginData.config.get();
+    if (!config.message) return;
+    if (!config.send_dm && !config.send_to_channel) return;
+
+    const formatted = await renderTemplate(config.message, {
+      member: stripObjectToScalars(member, ["user"]),
+    });
+
+    if (config.send_dm) {
+      const dmChannel = await member.user.getDMChannel();
+      if (!dmChannel) return;
+
+      try {
+        await createChunkedMessage(dmChannel, formatted);
+      } catch (e) {
+        pluginData.state.logs.log(LogType.BOT_ALERT, {
+          body: `Failed send a welcome DM to {userMention(member)}`,
+          member: stripObjectToScalars(member),
+        });
+      }
+    }
+
+    if (config.send_to_channel) {
+      const channel = meta.args.guild.channels.get(config.send_to_channel);
+      if (!channel || !(channel instanceof TextChannel)) return;
+
+      try {
+        await createChunkedMessage(channel, formatted);
+      } catch (e) {
+        pluginData.state.logs.log(LogType.BOT_ALERT, {
+          body: `Failed send a welcome message for {userMention(member)} to {channelMention(channel)}`,
+          member: stripObjectToScalars(member),
+          channel: stripObjectToScalars(channel),
+        });
+      }
+    }
+  },
+});

backend/src/plugins/WelcomeMessage/types.ts

@@ -0,0 +1,20 @@
+import * as t from "io-ts";
+import { BasePluginType, eventListener } from "knub";
+import { tNullable } from "src/utils";
+import { GuildLogs } from "src/data/GuildLogs";
+
+export const ConfigSchema = t.type({
+  send_dm: t.boolean,
+  send_to_channel: tNullable(t.string),
+  message: t.string,
+});
+export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
+
+export interface WelcomeMessagePluginType extends BasePluginType {
+  config: TConfigSchema;
+  state: {
+    logs: GuildLogs;
+  };
+}
+
+export const welcomeEvent = eventListener<WelcomeMessagePluginType>();

backend/src/plugins/availablePlugins.ts

@@ -2,12 +2,20 @@ import { UtilityPlugin } from "./Utility/UtilityPlugin";
 import { LocateUserPlugin } from "./LocateUser/LocateUserPlugin";
 import { ZeppelinPluginBlueprint } from "./ZeppelinPluginBlueprint";
 import { MessageSaverPlugin } from "./MessageSaver/MessageSaverPlugin";
+import { AutoReactionsPlugin } from "./AutoReactions/AutoReactionsPlugin";
+import { RemindersPlugin } from "./Reminders/RemindersPlugin";
+import { UsernameSaverPlugin } from "./UsernameSaver/UsernameSaverPlugin";
+import { WelcomeMessagePlugin } from "./WelcomeMessage/WelcomeMessagePlugin";
 
 // prettier-ignore
 export const guildPlugins: Array<ZeppelinPluginBlueprint<any>> = [
+  AutoReactionsPlugin,
   LocateUserPlugin,
   MessageSaverPlugin,
+  RemindersPlugin,
+  UsernameSaverPlugin,
   UtilityPlugin,
+  WelcomeMessagePlugin,
 ];
 
 export const globalPlugins = [];