discord-selfbot-v13.js 0.0.1-security → 1.0.0

package/src/structures/MessageMentions.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { ChannelTypes } = require('../util/Constants');
+const Util = require('../util/Util');
+
+/**
+ * Keeps track of mentions in a {@link Message}.
+ */
+class MessageMentions {
+  constructor(message, users, roles, everyone, crosspostedChannels, repliedUser) {
+    /**
+     * The client the message is from
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: message.client });
+
+    /**
+     * The guild the message is in
+     * @type {?Guild}
+     * @readonly
+     */
+    Object.defineProperty(this, 'guild', { value: message.guild });
+
+    /**
+     * The initial message content
+     * @type {string}
+     * @readonly
+     * @private
+     */
+    Object.defineProperty(this, '_content', { value: message.content });
+
+    /**
+     * Whether `@everyone` or `@here` were mentioned
+     * @type {boolean}
+     */
+    this.everyone = Boolean(everyone);
+
+    if (users) {
+      if (users instanceof Collection) {
+        /**
+         * Any users that were mentioned
+         * <info>Order as received from the API, not as they appear in the message content</info>
+         * @type {Collection<Snowflake, User>}
+         */
+        this.users = new Collection(users);
+      } else {
+        this.users = new Collection();
+        for (const mention of users) {
+          if (mention.member && message.guild) {
+            message.guild.members._add(Object.assign(mention.member, { user: mention }));
+          }
+          const user = message.client.users._add(mention);
+          this.users.set(user.id, user);
+        }
+      }
+    } else {
+      this.users = new Collection();
+    }
+
+    if (roles instanceof Collection) {
+      /**
+       * Any roles that were mentioned
+       * <info>Order as received from the API, not as they appear in the message content</info>
+       * @type {Collection<Snowflake, Role>}
+       */
+      this.roles = new Collection(roles);
+    } else if (roles) {
+      this.roles = new Collection();
+      const guild = message.guild;
+      if (guild) {
+        for (const mention of roles) {
+          const role = guild.roles.cache.get(mention);
+          if (role) this.roles.set(role.id, role);
+        }
+      }
+    } else {
+      this.roles = new Collection();
+    }
+
+    /**
+     * Cached members for {@link MessageMentions#members}
+     * @type {?Collection<Snowflake, GuildMember>}
+     * @private
+     */
+    this._members = null;
+
+    /**
+     * Cached channels for {@link MessageMentions#channels}
+     * @type {?Collection<Snowflake, Channel>}
+     * @private
+     */
+    this._channels = null;
+
+    /**
+     * Cached users for {@link MessageMentions#parsedUsers}
+     * @type {?Collection<Snowflake, User>}
+     * @private
+     */
+    this._parsedUsers = null;
+
+    /**
+     * Crossposted channel data.
+     * @typedef {Object} CrosspostedChannel
+     * @property {Snowflake} channelId The mentioned channel's id
+     * @property {Snowflake} guildId The id of the guild that has the channel
+     * @property {ChannelType} type The channel's type
+     * @property {string} name The channel's name
+     */
+
+    if (crosspostedChannels) {
+      if (crosspostedChannels instanceof Collection) {
+        /**
+         * A collection of crossposted channels
+         * <info>Order as received from the API, not as they appear in the message content</info>
+         * @type {Collection<Snowflake, CrosspostedChannel>}
+         */
+        this.crosspostedChannels = new Collection(crosspostedChannels);
+      } else {
+        this.crosspostedChannels = new Collection();
+        const channelTypes = Object.keys(ChannelTypes);
+        for (const d of crosspostedChannels) {
+          const type = channelTypes[d.type];
+          this.crosspostedChannels.set(d.id, {
+            channelId: d.id,
+            guildId: d.guild_id,
+            type: type ?? 'UNKNOWN',
+            name: d.name,
+          });
+        }
+      }
+    } else {
+      this.crosspostedChannels = new Collection();
+    }
+
+    /**
+     * The author of the message that this message is a reply to
+     * @type {?User}
+     */
+    this.repliedUser = repliedUser ? this.client.users._add(repliedUser) : null;
+  }
+
+  /**
+   * Any members that were mentioned (only in {@link Guild}s)
+   * <info>Order as received from the API, not as they appear in the message content</info>
+   * @type {?Collection<Snowflake, GuildMember>}
+   * @readonly
+   */
+  get members() {
+    if (this._members) return this._members;
+    if (!this.guild) return null;
+    this._members = new Collection();
+    this.users.forEach(user => {
+      const member = this.guild.members.resolve(user);
+      if (member) this._members.set(member.user.id, member);
+    });
+    return this._members;
+  }
+
+  /**
+   * Any channels that were mentioned
+   * <info>Order as they appear first in the message content</info>
+   * @type {Collection<Snowflake, Channel>}
+   * @readonly
+   */
+  get channels() {
+    if (this._channels) return this._channels;
+    this._channels = new Collection();
+    let matches;
+    while ((matches = this.constructor.CHANNELS_PATTERN.exec(this._content)) !== null) {
+      const chan = this.client.channels.cache.get(matches[1]);
+      if (chan) this._channels.set(chan.id, chan);
+    }
+    return this._channels;
+  }
+
+  /**
+   * Any user mentions that were included in the message content
+   * <info>Order as they appear first in the message content</info>
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   */
+  get parsedUsers() {
+    if (this._parsedUsers) return this._parsedUsers;
+    this._parsedUsers = new Collection();
+    let matches;
+    while ((matches = this.constructor.USERS_PATTERN.exec(this._content)) !== null) {
+      const user = this.client.users.cache.get(matches[1]);
+      if (user) this._parsedUsers.set(user.id, user);
+    }
+    return this._parsedUsers;
+  }
+
+  /**
+   * Options used to check for a mention.
+   * @typedef {Object} MessageMentionsHasOptions
+   * @property {boolean} [ignoreDirect=false] Whether to ignore direct mentions to the item
+   * @property {boolean} [ignoreRoles=false] Whether to ignore role mentions to a guild member
+   * @property {boolean} [ignoreRepliedUser=false] Whether to ignore replied user mention to an user
+   * @property {boolean} [ignoreEveryone=false] Whether to ignore `@everyone`/`@here` mentions
+   */
+
+  /**
+   * Checks if a user, guild member, thread member, role, or channel is mentioned.
+   * Takes into account user mentions, role mentions, channel mentions,
+   * replied user mention, and `@everyone`/`@here` mentions.
+   * @param {UserResolvable|RoleResolvable|ChannelResolvable} data The User/Role/Channel to check for
+   * @param {MessageMentionsHasOptions} [options] The options for the check
+   * @returns {boolean}
+   */
+  has(data, { ignoreDirect = false, ignoreRoles = false, ignoreRepliedUser = false, ignoreEveryone = false } = {}) {
+    const user = this.client.users.resolve(data);
+    if (!ignoreEveryone && user && this.everyone) return true;
+
+    const userWasRepliedTo = user && this.repliedUser?.id === user.id;
+
+    if (!ignoreRepliedUser && userWasRepliedTo && this.users.has(user.id)) return true;
+    if (!ignoreRepliedUser && this.users.has(this.repliedUser?.id) && this.repliedUser?.id === user?.id) return true;
+    if (!ignoreDirect) {
+      if (user && (!ignoreRepliedUser || this.parsedUsers.has(user.id)) && this.users.has(user.id)) return true;
+
+      const role = this.guild?.roles.resolve(data);
+      if (role && this.roles.has(role.id)) return true;
+
+      const channel = this.client.channels.resolve(data);
+      if (channel && this.channels.has(channel.id)) return true;
+    }
+    if (user && !ignoreEveryone && this.everyone) return true;
+    if (!ignoreRoles) {
+      const member = this.guild?.members.resolve(data);
+      if (member) {
+        for (const mentionedRole of this.roles.values()) if (member.roles.cache.has(mentionedRole.id)) return true;
+      }
+    }
+
+    return false;
+  }
+
+  toJSON() {
+    return Util.flatten(this, {
+      members: true,
+      channels: true,
+    });
+  }
+}
+
+/**
+ * Regular expression that globally matches `@everyone` and `@here`
+ * @type {RegExp}
+ */
+MessageMentions.EVERYONE_PATTERN = /@(everyone|here)/g;
+
+/**
+ * Regular expression that globally matches user mentions like `<@81440962496172032>`
+ * @type {RegExp}
+ */
+MessageMentions.USERS_PATTERN = /<@!?(\d{17,19})>/g;
+
+/**
+ * Regular expression that globally matches role mentions like `<@&297577916114403338>`
+ * @type {RegExp}
+ */
+MessageMentions.ROLES_PATTERN = /<@&(\d{17,19})>/g;
+
+/**
+ * Regular expression that globally matches channel mentions like `<#222079895583457280>`
+ * @type {RegExp}
+ */
+MessageMentions.CHANNELS_PATTERN = /<#(\d{17,19})>/g;
+
+module.exports = MessageMentions;

package/src/structures/MessagePayload.js

@@ -0,0 +1,358 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const BaseMessageComponent = require('./BaseMessageComponent');
+const MessageEmbed = require('./MessageEmbed');
+const WebEmbed = require('./WebEmbed');
+const { RangeError } = require('../errors');
+const ActivityFlags = require('../util/ActivityFlags');
+const DataResolver = require('../util/DataResolver');
+const MessageFlags = require('../util/MessageFlags');
+const Util = require('../util/Util');
+
+/**
+ * Represents a message to be sent to the API.
+ */
+class MessagePayload {
+  /**
+   * @param {MessageTarget} target The target for this message to be sent to
+   * @param {MessageOptions|WebhookMessageOptions} options Options passed in from send
+   */
+  constructor(target, options) {
+    /**
+     * The target for this message to be sent to
+     * @type {MessageTarget}
+     */
+    this.target = target;
+
+    /**
+     * Options passed in from send
+     * @type {MessageOptions|WebhookMessageOptions}
+     */
+    this.options = options;
+
+    /**
+     * Data sendable to the API
+     * @type {?APIMessage}
+     */
+    this.data = null;
+
+    /**
+     * @typedef {Object} MessageFile
+     * @property {Buffer|string|Stream} attachment The original attachment that generated this file
+     * @property {string} name The name of this file
+     * @property {Buffer|Stream} file The file to be sent to the API
+     * @extends {APIAttachment}
+     */
+
+    /**
+     * Files sendable to the API
+     * @type {?MessageFile[]}
+     */
+    this.files = null;
+  }
+
+  /**
+   * Whether or not using new API to upload files
+   * @type {boolean}
+   * @readonly
+   */
+  get usingNewAttachmentAPI() {
+    return Boolean(this.options?.usingNewAttachmentAPI);
+  }
+
+  /**
+   * Whether or not the target is a {@link Webhook} or a {@link WebhookClient}
+   * @type {boolean}
+   * @readonly
+   */
+  get isWebhook() {
+    const Webhook = require('./Webhook');
+    const WebhookClient = require('../client/WebhookClient');
+    return this.target instanceof Webhook || this.target instanceof WebhookClient;
+  }
+
+  /**
+   * Whether or not the target is a {@link User}
+   * @type {boolean}
+   * @readonly
+   */
+  get isUser() {
+    const User = require('./User');
+    const { GuildMember } = require('./GuildMember');
+    return this.target instanceof User || this.target instanceof GuildMember;
+  }
+
+  /**
+   * Whether or not the target is a {@link Message}
+   * @type {boolean}
+   * @readonly
+   */
+  get isMessage() {
+    const { Message } = require('./Message');
+    return this.target instanceof Message;
+  }
+
+  /**
+   * Whether or not the target is a {@link MessageManager}
+   * @type {boolean}
+   * @readonly
+   */
+  get isMessageManager() {
+    const MessageManager = require('../managers/MessageManager');
+    return this.target instanceof MessageManager;
+  }
+
+  /**
+   * Whether or not the target is an {@link Interaction} or an {@link InteractionWebhook}
+   * @type {boolean}
+   * @readonly
+   */
+  get isInteraction() {
+    const Interaction = require('./Interaction');
+    const InteractionWebhook = require('./InteractionWebhook');
+    return this.target instanceof Interaction || this.target instanceof InteractionWebhook;
+  }
+
+  /**
+   * Makes the content of this message.
+   * @returns {?string}
+   */
+  makeContent() {
+    let content;
+    if (this.options.content === null) {
+      content = '';
+    } else if (typeof this.options.content !== 'undefined') {
+      content = Util.verifyString(this.options.content, RangeError, 'MESSAGE_CONTENT_TYPE', false);
+    }
+
+    return content;
+  }
+
+  /**
+   * Resolves data.
+   * @returns {MessagePayload}
+   */
+  async resolveData() {
+    if (this.data) return this;
+    const isInteraction = this.isInteraction;
+    const isWebhook = this.isWebhook;
+
+    let content = this.makeContent();
+    const tts = Boolean(this.options.tts);
+
+    let nonce;
+    if (typeof this.options.nonce !== 'undefined') {
+      nonce = this.options.nonce;
+      // eslint-disable-next-line max-len
+      if (typeof nonce === 'number' ? !Number.isInteger(nonce) : typeof nonce !== 'string') {
+        throw new RangeError('MESSAGE_NONCE_TYPE');
+      }
+    }
+
+    const components = this.options.components?.map(c => BaseMessageComponent.create(c).toJSON());
+
+    let username;
+    let avatarURL;
+    let threadName;
+    if (isWebhook) {
+      username = this.options.username ?? this.target.name;
+      if (this.options.avatarURL) avatarURL = this.options.avatarURL;
+      if (this.options.threadName) threadName = this.options.threadName;
+    }
+
+    let flags;
+    if (
+      typeof this.options.flags !== 'undefined' ||
+      (this.isMessage && typeof this.options.reply === 'undefined') ||
+      this.isMessageManager
+    ) {
+      // eslint-disable-next-line eqeqeq
+      flags = this.options.flags != null ? new MessageFlags(this.options.flags).bitfield : this.target.flags?.bitfield;
+    }
+
+    if (isInteraction && this.options.ephemeral) {
+      flags |= MessageFlags.FLAGS.EPHEMERAL;
+    }
+
+    let allowedMentions =
+      typeof this.options.allowedMentions === 'undefined'
+        ? this.target.client.options.allowedMentions
+        : this.options.allowedMentions;
+
+    if (allowedMentions) {
+      allowedMentions = Util.cloneObject(allowedMentions);
+      allowedMentions.replied_user = allowedMentions.repliedUser;
+      delete allowedMentions.repliedUser;
+    }
+
+    let message_reference;
+    if (typeof this.options.reply === 'object') {
+      const reference = this.options.reply.messageReference;
+      const message_id = this.isMessage ? reference.id ?? reference : this.target.messages.resolveId(reference);
+      if (message_id) {
+        message_reference = {
+          message_id,
+          fail_if_not_exists: this.options.reply.failIfNotExists ?? this.target.client.options.failIfNotExists,
+        };
+      }
+    }
+
+    const attachments = this.options.files?.map((file, index) => ({
+      id: index.toString(),
+      description: file.description,
+    }));
+    if (Array.isArray(this.options.attachments)) {
+      this.options.attachments.push(...(attachments ?? []));
+    } else {
+      this.options.attachments = attachments;
+    }
+
+    if (this.options.embeds) {
+      if (!Array.isArray(this.options.embeds)) {
+        this.options.embeds = [this.options.embeds];
+      }
+
+      const webembeds = this.options.embeds.filter(e => e instanceof WebEmbed);
+      this.options.embeds = this.options.embeds.filter(e => !(e instanceof WebEmbed));
+
+      if (webembeds.length > 0) {
+        if (!content) content = '';
+        // Add hidden embed link
+        content += `\n${WebEmbed.hiddenEmbed} \n`;
+        if (webembeds.length > 1) {
+          console.warn('[WARN] Multiple webembeds are not supported, this will be ignored.');
+        }
+        // Const embed = webembeds[0];
+        for (const webE of webembeds) {
+          const data = await webE.toMessage();
+          content += `\n${data}`;
+        }
+      }
+      // Check content
+      if (typeof content == 'string' && content.length > 2000) {
+        console.warn('[WARN] Content is longer than 2000 characters.');
+      }
+      if (typeof content == 'string' && content.length > 4000) {
+        // Max length if user has nitro boost
+        throw new RangeError('MESSAGE_EMBED_LINK_LENGTH');
+      }
+    }
+
+    // Activity
+    let activity;
+    if (
+      this.options.activity instanceof Object &&
+      typeof this.options.activity.partyId == 'string' &&
+      this.options.activity.type
+    ) {
+      const type = ActivityFlags.resolve(this.options.activity.type);
+      const sessionId = this.target.client.sessionId;
+      const partyId = this.options.activity.partyId;
+      activity = {
+        type,
+        party_id: partyId,
+        session_id: sessionId,
+      };
+    }
+
+    this.data = {
+      activity,
+      content,
+      tts,
+      nonce,
+      embeds: this.options.embeds?.map(embed => new MessageEmbed(embed).toJSON()),
+      components,
+      username,
+      avatar_url: avatarURL,
+      allowed_mentions:
+        typeof content === 'undefined' && typeof message_reference === 'undefined' ? undefined : allowedMentions,
+      flags,
+      message_reference,
+      attachments: this.options.attachments,
+      sticker_ids: this.options.stickers?.map(sticker => sticker.id ?? sticker),
+      thread_name: threadName,
+    };
+    return this;
+  }
+
+  /**
+   * Resolves files.
+   * @returns {Promise<MessagePayload>}
+   */
+  async resolveFiles() {
+    if (this.files) return this;
+
+    this.files = await Promise.all(this.options.files?.map(file => this.constructor.resolveFile(file)) ?? []);
+    return this;
+  }
+
+  /**
+   * Resolves a single file into an object sendable to the API.
+   * @param {BufferResolvable|Stream|FileOptions|MessageAttachment} fileLike Something that could be resolved to a file
+   * @returns {Promise<MessageFile>}
+   */
+  static async resolveFile(fileLike) {
+    let attachment;
+    let name;
+
+    const findName = thing => {
+      if (typeof thing === 'string') {
+        return Util.basename(thing);
+      }
+
+      if (thing.path) {
+        return Util.basename(thing.path);
+      }
+
+      return 'file.jpg';
+    };
+
+    const ownAttachment =
+      typeof fileLike === 'string' || fileLike instanceof Buffer || typeof fileLike.pipe === 'function';
+    if (ownAttachment) {
+      attachment = fileLike;
+      name = findName(attachment);
+    } else {
+      attachment = fileLike.attachment;
+      name = fileLike.name ?? findName(attachment);
+    }
+
+    const resource = await DataResolver.resolveFile(attachment);
+    return {
+      attachment,
+      name,
+      file: resource,
+      description: fileLike.description,
+      duration_secs: fileLike.duration,
+      waveform: fileLike.waveform,
+    };
+  }
+
+  /**
+   * Creates a {@link MessagePayload} from user-level arguments.
+   * @param {MessageTarget} target Target to send to
+   * @param {string|MessageOptions|WebhookMessageOptions} options Options or content to use
+   * @param {MessageOptions|WebhookMessageOptions} [extra={}] Extra options to add onto specified options
+   * @returns {MessagePayload}
+   */
+  static create(target, options, extra = {}) {
+    return new this(
+      target,
+      typeof options !== 'object' || options === null ? { content: options, ...extra } : { ...options, ...extra },
+    );
+  }
+}
+
+module.exports = MessagePayload;
+
+/**
+ * A target for a message.
+ * @typedef {TextBasedChannels|DMChannel|User|GuildMember|Webhook|WebhookClient|Interaction|InteractionWebhook|
+ * Message|MessageManager} MessageTarget
+ */
+
+/**
+ * @external APIMessage
+ * @see {@link https://discord.com/developers/docs/resources/channel#message-object}
+ */