[INSTALL] Support quoting forwards, remove Quote#exec

Author: GamingGeek

lib/extensions/message.ts

@@ -9,6 +9,7 @@ import { PermissionFlagsBits } from "discord-api-types/v9";
 import {
   Channel,
   Collection,
+  Constants,
   DMChannel,
   DiscordAPIError,
   EmojiIdentifierResolvable,
@@ -409,6 +410,24 @@ export class FireMessage extends Message {
     webhook?: WebhookClient,
     debug?: string[]
   ) {
+    // check for forwarded message from guilds on current cluster
+    if (
+      this.reference?.type == Constants.MessageReferenceType.FORWARD &&
+      this.client.guilds.cache.has(this.reference.guildId)
+    ) {
+      const guild = this.client.guilds.cache.get(this.reference.guildId);
+      if (!guild) return;
+      const channel = guild.channels.cache.get(this.reference.channelId);
+      if (!channel || !("messages" in channel)) return;
+      const message = (await channel.messages.fetch(
+        this.reference.messageId
+      )) as FireMessage;
+      if (message)
+        return await message.quote(destination, quoter, webhook, debug);
+      else return;
+    } else if (this.reference?.type == Constants.MessageReferenceType.FORWARD)
+      return; // not cached and nothing to quote so just ignore it
+
     // check for quoteable content first
     if (
       !this.content &&

lib/util/clientutil.ts

@@ -1057,11 +1057,9 @@ export class Util extends ClientUtil {
 
   async getQuoteWebhookURL(destination: GuildTextChannel | ThreadChannel) {
     let thread: ThreadChannel;
-    if (destination instanceof ThreadChannel) {
-      // we can't assign thread to destination since we're reassigning it
-      thread = this.client.channels.cache.get(destination.id) as ThreadChannel;
+    if (destination instanceof ThreadChannel)
       destination = destination.parent as GuildTextChannel;
-    } else if (typeof destination.fetchWebhooks != "function") return;
+    else if (typeof destination.fetchWebhooks != "function") return;
     if (
       !destination
         .permissionsFor(destination.guild.members.me)
@@ -1071,7 +1069,7 @@ export class Util extends ClientUtil {
     const hooks = await destination.fetchWebhooks().catch(() => {});
     let hook: Webhook;
     if (hooks) hook = hooks.filter((hook) => !!hook.token).first();
-    if (!hook) {
+    if (!hook)
       hook = await destination
         .createWebhook(`Fire Quotes #${destination.name}`.slice(0, 80), {
           avatar: this.client.user.displayAvatarURL({
@@ -1083,10 +1081,13 @@ export class Util extends ClientUtil {
           ) as string,
         })
         .catch(() => null);
-    }
-    return thread && hook?.url
-      ? `${hook?.url}?thread_id=${thread.id}`
-      : hook?.url;
+    return (
+      hook && {
+        id: hook.id,
+        token: hook.token,
+        threadId: thread?.id,
+      }
+    );
   }
 
   makeImageUrl(root: string, { format = "webp", size = 512 } = {}) {

lib/util/command.ts

@@ -257,6 +257,10 @@ export class Command extends AkairoCommand {
     this.slashIds = {};
   }
 
+  get console() {
+    return this.client.getLogger(`Command:${this.constructor.name}`);
+  }
+
   async init(): Promise<any> {}
 
   async unload(): Promise<any> {}

src/commands/Moderation/lockdown.ts

@@ -149,7 +149,7 @@ export default class Lockdown extends Command {
             .catch(() => {});
         })
         .catch((e) => {
-          this.client.console.debug(
+          this.console.debug(
             `Lockdown permission overwrite failed for ${channel.name} (${channel.id})\n${e.stack}`
           );
           failed.push(channel.toString());

src/commands/Utilities/quote.ts

@@ -1,23 +1,27 @@
-import { ApplicationCommandMessage } from "@fire/lib/extensions/appcommandmessage";
 import { ContextCommandMessage } from "@fire/lib/extensions/contextcommandmessage";
-import { FireMember } from "@fire/lib/extensions/guildmember";
+import { FireGuild } from "@fire/lib/extensions/guild";
 import { FireMessage } from "@fire/lib/extensions/message";
 import { MessageContextMenuInteraction } from "@fire/lib/extensions/messagecontextmenuinteraction";
-import { FireUser } from "@fire/lib/extensions/user";
-import { PartialQuoteDestination } from "@fire/lib/interfaces/messages";
+import {
+  MessageLinkMatch,
+  PartialQuoteDestination,
+} from "@fire/lib/interfaces/messages";
 import { Command } from "@fire/lib/util/command";
 import { GuildTextChannel, constants } from "@fire/lib/util/constants";
+import { messageConverter } from "@fire/lib/util/converters";
 import { Language } from "@fire/lib/util/language";
-import { ThreadhookClient } from "@fire/lib/util/threadhookclient";
+import { Message } from "@fire/lib/ws/Message";
+import { EventType } from "@fire/lib/ws/util/constants";
+import { MessageUtil } from "@fire/lib/ws/util/MessageUtil";
 import { Snowflake } from "discord-api-types/globals";
 import { PermissionFlagsBits } from "discord-api-types/v9";
 import {
   Collection,
   Constants,
   GuildChannelResolvable,
+  GuildTextBasedChannel,
   MessageActionRow,
   MessageButton,
-  MessageEmbed,
 } from "discord.js";
 
 const { regexes } = constants;
@@ -47,6 +51,8 @@ export default class Quote extends Command {
       context: ["save to quote"],
       restrictTo: "all", // required for context cmd
       ephemeral: true, // context only
+      slashOnly: true,
+      hidden: true,
     });
 
     this.savedQuotes = new Collection();
@@ -57,71 +63,128 @@ export default class Quote extends Command {
     }, 30000);
   }
 
-  async exec(
-    message?: FireMessage,
-    args?: {
-      destination?: PartialQuoteDestination;
-      quoter?: FireMember | FireUser;
-      quote?: FireMessage;
-      webhook?: string;
-      debug?: boolean;
-    }
+  async handleLocalQuote(
+    message: FireMessage,
+    match: MessageLinkMatch,
+    debug = false // TODO: reimplement debug messages
   ) {
-    if (
-      message &&
-      !message.guild &&
-      !message.author.hasExperiment(3069732134, 1)
-    )
-      return await message.error("COMMAND_GUILD_ONLY", {
-        invite: this.client.config.inviteLink,
-      });
-    if (!args?.quote) return;
-    let debugMessages: string[];
-    if (args.debug) debugMessages = [];
-    let webhook: ThreadhookClient;
-    if (args.webhook) {
-      const match = regexes.discord.webhook.exec(args.webhook);
-      regexes.discord.webhook.lastIndex = 0;
-      if (!match?.groups.id || !match?.groups.token) return;
-      webhook = new ThreadhookClient(
-        { id: match.groups.id as Snowflake, token: match.groups.token },
-        { threadId: match.groups.threadId as Snowflake }
+    const convertedMessage = await messageConverter(
+      message,
+      null,
+      debug,
+      match
+    ).catch(() => {});
+    if (!convertedMessage) return;
+    else if (
+      convertedMessage.reference?.type == Constants.MessageReferenceType.FORWARD
+    ) {
+      const { reference } = convertedMessage;
+      const shard = this.client.util.getShard(reference.guildId);
+      if (!(this.client.options.shards as number[]).includes(shard))
+        return this.forwardCrossClusterQuote(message, {
+          guild_id: reference.guildId,
+          channel_id: reference.channelId,
+          message_id: reference.messageId,
+        });
+      const guild = this.client.guilds.cache.get(
+        reference.guildId
+      ) as FireGuild;
+      if (!guild) return;
+      const channel = guild.channels.cache.get(
+        reference.channelId
+      ) as GuildTextBasedChannel;
+      if (!channel) return;
+      const referencedMessage = (await channel.messages
+        .fetch(reference.messageId)
+        .catch(() => {})) as FireMessage;
+      if (!referencedMessage) return;
+      else
+        return await referencedMessage.quote(
+          channel,
+          message.member ?? message.author
+        );
+    } else {
+      await convertedMessage.quote(
+        message.channel as GuildTextBasedChannel,
+        message.member ?? message.author
       );
-      return await args.quote
-        .quote(args.destination, args.quoter, webhook, debugMessages)
-        .catch(() => {});
+      if (match.iteratedMessages?.length)
+        for (const iterated of match.iteratedMessages)
+          await iterated.quote(
+            message.channel as GuildTextBasedChannel,
+            message.member ?? message.author
+          );
     }
-    if (!message) return; // we shouldn't get here without one
-    if (args.quote.content.length > 2000)
-      return await message.error(QUOTE_PREMIUM_INCREASED_LENGTH);
-    const quoted = await args.quote
-      .quote(
-        message instanceof ApplicationCommandMessage
-          ? (message.realChannel as GuildTextChannel)
-          : (message.channel as GuildTextChannel),
-        message.member ?? message.author,
-        webhook,
-        debugMessages
+  }
+
+  async forwardCrossClusterQuote(
+    message: FireMessage,
+    quote: MessageLinkMatch
+  ) {
+    const shard = this.client.util.getShard(quote.guild_id);
+    const webhook = await this.client.util.getQuoteWebhookURL(
+      message.channel as GuildTextChannel
+    );
+    if (!webhook?.token) return;
+    this.console.log("Forwarding cross-cluster quote", {
+      user: `${message.author} (${message.author.id})`,
+      guild: `${message.guild} (${message.guild.id})`,
+      source: `${quote.guild_id}/${quote.channel_id}/${quote.message_id}`,
+      destination: `${message.guild.id}/${message.channelId}`,
+      shard,
+    });
+    this.client.manager.ws.send(
+      MessageUtil.encode(
+        new Message(EventType.CROSS_CLUSTER_QUOTE, {
+          shard,
+          quoter: message.author.id,
+          webhook,
+          message: quote,
+          destination: {
+            nsfw: (message.channel as GuildTextChannel)?.nsfw || false,
+            permissions: message.guild
+              ? message.member?.permissions.bitfield.toString() || "0"
+              : "0",
+            guild_id: message.guild?.id,
+            id: message.channelId,
+          } as PartialQuoteDestination,
+        })
       )
-      .catch((e: Error) =>
-        (args.quoter ?? message.author).isSuperuser() ? e.stack : e.message
-      );
-    if (quoted == QUOTE_PREMIUM_INCREASED_LENGTH)
-      return await message.error(quoted);
-    else if (quoted == "nsfw") return await message.error("QUOTE_NSFW_TO_SFW");
-    else if (quoted == "empty")
-      return await message.error("QUOTE_MISSING_CONTENT");
-    if (typeof quoted == "string" && debugMessages) debugMessages.push(quoted);
-    if (args.debug) {
-      if (!debugMessages.length) return;
-      const content = debugMessages.join("\n");
-      if (content.length > 2000 && content.length < 4096)
-        return await message.channel.send({
-          embeds: [new MessageEmbed().setDescription(content)],
-        });
-      else if (content.length <= 2000)
-        return await message.channel.send(content);
+    );
+  }
+
+  returnCrossClusterQuote(
+    destination: PartialQuoteDestination,
+    quote: MessageLinkMatch,
+    quoter: Snowflake,
+    webhook: {
+      id: Snowflake;
+      token: string;
+      threadId?: Snowflake;
     }
+  ) {
+    if (!webhook?.token) return;
+
+    const shard = this.client.util.getShard(destination.guild_id);
+    this.console.log(
+      "Returning cross cluster quote due to forwarded message on another cluster",
+      {
+        quoter,
+        quote,
+        shard,
+      }
+    );
+    this.client.manager.ws.send(
+      MessageUtil.encode(
+        new Message(EventType.CROSS_CLUSTER_QUOTE, {
+          shard,
+          quoter,
+          webhook,
+          message: quote,
+          destination,
+        })
+      )
+    );
   }
 
   // Slash & Context commands will always try Command#run first