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

package/src/structures/Modal.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const { setTimeout } = require('node:timers');
+const BaseMessageComponent = require('./BaseMessageComponent');
+const User = require('./User');
+const SnowflakeUtil = require('../util/SnowflakeUtil');
+const Util = require('../util/Util');
+
+/**
+ * Represents a modal (form) to be shown in response to an interaction
+ */
+class Modal {
+  /**
+   * @typedef {Object} ModalOptions
+   * @property {string} [customId] A unique string to be sent in the interaction when clicked
+   * @property {string} [title] The title to be displayed on this modal
+   * @property {Array<(MessageActionRow|MessageActionRowOptions)>} [components]
+   * Action rows containing interactive components for the modal (text input components)
+   */
+
+  /**
+   * @param {Modal|ModalOptions} data Modal to clone or raw data
+   * @param {Client} client The client constructing this Modal, if provided
+   */
+  constructor(data = {}, client = null) {
+    /**
+     * A list of MessageActionRows in the modal
+     * @type {MessageActionRow[]}
+     */
+    this.components = data.components?.map(c => BaseMessageComponent.create(c, client)) ?? [];
+
+    /**
+     * A unique string to be sent in the interaction when submitted
+     * @type {?string}
+     */
+    this.customId = data.custom_id ?? data.customId ?? null;
+
+    /**
+     * The title to be displayed on this modal
+     * @type {?string}
+     */
+    this.title = data.title ?? null;
+
+    /**
+     * Timestamp (Discord epoch) of when this modal was created
+     * @type {?Snowflake}
+     */
+    this.nonce = data.nonce ?? null;
+
+    /**
+     * ID slash / button / menu when modal is displayed
+     * @type {?Snowflake}
+     */
+    this.id = data.id ?? null;
+
+    /**
+     * Application sending the modal
+     * @type {?Object}
+     */
+    this.application = data.application
+      ? {
+          ...data.application,
+          bot: data.application.bot ? new User(client, data.application.bot, data.application) : null,
+        }
+      : null;
+
+    this.client = client;
+  }
+
+  /**
+   * Get Interaction Response
+   * @type {?InteractionResponse}
+   * @readonly
+   */
+  get sendFromInteraction() {
+    if (this.id && this.nonce && this.client) {
+      const cache = this.client._interactionCache.get(this.nonce);
+      const channel = cache.guildId
+        ? this.client.guilds.cache.get(cache.guildId)?.channels.cache.get(cache.channelId)
+        : this.client.channels.cache.get(cache.channelId);
+      return channel.interactions.cache.get(this.id);
+    }
+    return null;
+  }
+
+  /**
+   * Adds components to the modal.
+   * @param {...MessageActionRowResolvable[]} components The components to add
+   * @returns {Modal}
+   */
+  addComponents(...components) {
+    this.components.push(...components.flat(Infinity).map(c => BaseMessageComponent.create(c)));
+    return this;
+  }
+
+  /**
+   * Sets the components of the modal.
+   * @param {...MessageActionRowResolvable[]} components The components to set
+   * @returns {Modal}
+   */
+  setComponents(...components) {
+    this.spliceComponents(0, this.components.length, components);
+    return this;
+  }
+
+  /**
+   * Sets the custom id for this modal
+   * @param {string} customId A unique string to be sent in the interaction when submitted
+   * @returns {Modal}
+   */
+  setCustomId(customId) {
+    this.customId = Util.verifyString(customId, RangeError, 'MODAL_CUSTOM_ID');
+    return this;
+  }
+
+  /**
+   * Removes, replaces, and inserts components in the modal.
+   * @param {number} index The index to start at
+   * @param {number} deleteCount The number of components to remove
+   * @param {...MessageActionRowResolvable[]} [components] The replacing components
+   * @returns {Modal}
+   */
+  spliceComponents(index, deleteCount, ...components) {
+    this.components.splice(index, deleteCount, ...components.flat(Infinity).map(c => BaseMessageComponent.create(c)));
+    return this;
+  }
+
+  /**
+   * Sets the title of this modal
+   * @param {string} title The title to be displayed on this modal
+   * @returns {Modal}
+   */
+  setTitle(title) {
+    this.title = Util.verifyString(title, RangeError, 'MODAL_TITLE');
+    return this;
+  }
+
+  toJSON() {
+    return {
+      components: this.components.map(c => c.toJSON()),
+      custom_id: this.customId,
+      title: this.title,
+      id: this.id,
+    };
+  }
+
+  /**
+   * @typedef {Object} TextInputComponentReplyData
+   * @property {string} [customId] TextInputComponent custom id
+   * @property {string} [value] TextInputComponent value
+   */
+
+  /**
+   * @typedef {Object} ModalReplyData
+   * @property {?GuildResolvable} [guild] Guild to send the modal to
+   * @property {?TextChannelResolvable} [channel] User to send the modal to
+   * @property {?TextInputComponentReplyData[]} [data] Reply data
+   */
+
+  /**
+   * Reply to this modal with data. (Event only)
+   * @param  {ModalReplyData} data Data to send with the modal
+   * @returns {Promise<InteractionResponse>}
+   * @example
+   * client.on('interactionModalCreate', modal => {
+   * // 1.
+   *  modal.reply({
+   *     data: [
+   *         {
+   *             customId: 'code',
+   *             value: '1+1'
+   *         }, {
+   *             customId: 'message',
+   *             value: 'hello'
+   *         }
+   *     ],
+   *    channel: 'id', // optional
+   *    guild: 'id', // optional
+   *  })
+   * // or 2.
+   * modal.components[0].components[0].setValue('1+1');
+   * modal.components[1].components[0].setValue('hello');
+   * modal.reply();
+   * })
+   */
+  async reply(data = {}) {
+    if (!this.application) throw new Error('Modal cannot reply (Missing Application)');
+    const data_cache = this.sendFromInteraction;
+    const guild = this.client.guilds.resolveId(data?.guild) || data_cache.guildId || null;
+    const channel = this.client.channels.resolveId(data?.channel) || data_cache.channelId;
+    if (!channel) throw new Error('Modal cannot reply (Missing data)');
+    // Add data to components
+    // this.components = [ MessageActionRow.components = [ TextInputComponent ] ]
+    // 5 MessageActionRow / Modal, 1 TextInputComponent / 1 MessageActionRow
+    if (Array.isArray(data?.data) && data?.data?.length > 0) {
+      for (let i = 0; i < this.components.length; i++) {
+        const value = data.data.find(d => d.customId == this.components[i].components[0].customId);
+        if (this.components[i].components[0].required == true && !value) {
+          throw new Error(
+            'MODAL_REQUIRED_FIELD_MISSING\n' +
+              `Required fieldId ${this.components[i].components[0].customId} missing value`,
+          );
+        }
+        if (value) {
+          if (value?.value?.includes('\n') && this.components[i].components[0].style == 'SHORT') {
+            throw new Error(
+              'MODAL_REPLY_DATA_INVALID\n' +
+                `value must be a single line, got multiple lines [Custom ID: ${value.customId}]`,
+            );
+          }
+          this.components[i].components[0].setValue(value.value);
+        }
+      }
+    }
+    // Get Object
+    const dataFinal = this.toJSON();
+    dataFinal.components = dataFinal.components
+      .map(c => {
+        delete c.components[0].max_length;
+        delete c.components[0].min_length;
+        delete c.components[0].required;
+        delete c.components[0].placeholder;
+        delete c.components[0].label;
+        delete c.components[0].style;
+        return c;
+      })
+      .filter(c => c.components[0].value && c.components[0].value !== '');
+    delete dataFinal.title;
+    const nonce = SnowflakeUtil.generate();
+    const postData = {
+      type: 5, // Modal
+      application_id: this.application.id,
+      guild_id: guild || null,
+      channel_id: channel,
+      data: dataFinal,
+      nonce,
+      session_id: this.client.session_id,
+    };
+    await this.client.api.interactions.post({
+      data: postData,
+    });
+    this.client._interactionCache.set(nonce, {
+      channelId: channel,
+      guildId: guild,
+      metadata: postData,
+    });
+    return new Promise((resolve, reject) => {
+      const handler = data => {
+        timeout.refresh();
+        if (data.metadata.nonce !== nonce) return;
+        clearTimeout(timeout);
+        this.client.removeListener('interactionResponse', handler);
+        this.client.decrementMaxListeners();
+        if (data.status) {
+          resolve(data.metadata);
+        } else {
+          reject(
+            new Error('INTERACTION_ERROR', {
+              cause: data,
+            }),
+          );
+        }
+      };
+      const timeout = setTimeout(() => {
+        this.client.removeListener('interactionResponse', handler);
+        this.client.decrementMaxListeners();
+        reject(
+          new Error('INTERACTION_TIMEOUT', {
+            cause: postData,
+          }),
+        );
+      }, this.client.options.interactionTimeout).unref();
+      this.client.incrementMaxListeners();
+      this.client.on('interactionResponse', handler);
+    });
+  }
+}
+
+module.exports = Modal;

package/src/structures/ModalSubmitFieldsResolver.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { TypeError } = require('../errors');
+const { MessageComponentTypes } = require('../util/Constants');
+
+/**
+ * A resolver for modal submit interaction text inputs.
+ */
+class ModalSubmitFieldsResolver {
+  constructor(components) {
+    /**
+     * The components within the modal
+     * @type {PartialModalActionRow[]} The components in the modal
+     */
+    this.components = components;
+  }
+
+  /**
+   * The extracted fields from the modal
+   * @type {PartialInputTextData[]} The fields in the modal
+   * @private
+   */
+  get _fields() {
+    return this.components.reduce((previous, next) => previous.concat(next.components), []);
+  }
+
+  /**
+   * Gets a field given a custom id from a component
+   * @param {string} customId The custom id of the component
+   * @returns {?PartialInputTextData}
+   */
+  getField(customId) {
+    const field = this._fields.find(f => f.customId === customId);
+    if (!field) throw new TypeError('MODAL_SUBMIT_INTERACTION_FIELD_NOT_FOUND', customId);
+    return field;
+  }
+
+  /**
+   * Gets the value of a text input component given a custom id
+   * @param {string} customId The custom id of the text input component
+   * @returns {?string}
+   */
+  getTextInputValue(customId) {
+    const field = this.getField(customId);
+    const expectedType = MessageComponentTypes[MessageComponentTypes.TEXT_INPUT];
+    if (field.type !== expectedType) {
+      throw new TypeError('MODAL_SUBMIT_INTERACTION_FIELD_TYPE', customId, field.type, expectedType);
+    }
+    return field.value;
+  }
+}
+
+module.exports = ModalSubmitFieldsResolver;

package/src/structures/ModalSubmitInteraction.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const Interaction = require('./Interaction');
+const InteractionWebhook = require('./InteractionWebhook');
+const ModalSubmitFieldsResolver = require('./ModalSubmitFieldsResolver');
+const InteractionResponses = require('./interfaces/InteractionResponses');
+const { MessageComponentTypes } = require('../util/Constants');
+
+/**
+ * Represents a modal submit interaction.
+ * @extends {Interaction}
+ * @implements {InteractionResponses}
+ */
+class ModalSubmitInteraction extends Interaction {
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The custom id of the modal.
+     * @type {string}
+     */
+    this.customId = data.data.custom_id;
+
+    /**
+     * @typedef {Object} PartialTextInputData
+     * @property {string} [customId] A unique string to be sent in the interaction when submitted
+     * @property {MessageComponentType} [type] The type of this component
+     * @property {string} [value] Value of this text input component
+     */
+
+    /**
+     * @typedef {Object} PartialModalActionRow
+     * @property {MessageComponentType} [type] The type of this component
+     * @property {PartialTextInputData[]} [components] Partial text input components
+     */
+
+    /**
+     * The inputs within the modal
+     * @type {PartialModalActionRow[]}
+     */
+    this.components =
+      data.data.components?.map(c => ({
+        type: MessageComponentTypes[c.type],
+        components: ModalSubmitInteraction.transformComponent(c),
+      })) ?? [];
+
+    /**
+     * The message associated with this interaction
+     * @type {Message|APIMessage|null}
+     */
+    this.message = data.message ? this.channel?.messages._add(data.message) ?? data.message : null;
+
+    /**
+     * The fields within the modal
+     * @type {ModalSubmitFieldsResolver}
+     */
+    this.fields = new ModalSubmitFieldsResolver(this.components);
+
+    /**
+     * Whether the reply to this interaction has been deferred
+     * @type {boolean}
+     */
+    this.deferred = false;
+
+    /**
+     * Whether the reply to this interaction is ephemeral
+     * @type {?boolean}
+     */
+    this.ephemeral = null;
+
+    /**
+     * Whether this interaction has already been replied to
+     * @type {boolean}
+     */
+    this.replied = false;
+
+    /**
+     * An associated interaction webhook, can be used to further interact with this interaction
+     * @type {InteractionWebhook}
+     */
+    this.webhook = new InteractionWebhook(this.client, this.applicationId, this.token);
+  }
+
+  /**
+   * Transforms component data to discord.js-compatible data
+   * @param {*} rawComponent The data to transform
+   * @returns {PartialTextInputData[]}
+   */
+  static transformComponent(rawComponent) {
+    return rawComponent.components.map(c => ({
+      value: c.value,
+      type: MessageComponentTypes[c.type],
+      customId: c.custom_id,
+    }));
+  }
+
+  /**
+   * Whether this is from a {@link MessageComponentInteraction}.
+   * @returns {boolean}
+   */
+  isFromMessage() {
+    return Boolean(this.message);
+  }
+
+  // These are here only for documentation purposes - they are implemented by InteractionResponses
+  /* eslint-disable no-empty-function */
+  deferReply() {}
+  reply() {}
+  fetchReply() {}
+  editReply() {}
+  deleteReply() {}
+  followUp() {}
+  update() {}
+  deferUpdate() {}
+}
+
+InteractionResponses.applyToClass(ModalSubmitInteraction, ['showModal', 'awaitModalSubmit']);
+
+module.exports = ModalSubmitInteraction;

package/src/structures/NewsChannel.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const BaseGuildTextChannel = require('./BaseGuildTextChannel');
+const { Error } = require('../errors');
+
+/**
+ * Represents a guild news channel on Discord.
+ * @extends {BaseGuildTextChannel}
+ */
+class NewsChannel extends BaseGuildTextChannel {
+  /**
+   * Adds the target to this channel's followers.
+   * <info>If you need the created webhook id, use {@link GuildChannelManager#addFollower}.</info>
+   * @param {TextChannelResolvable} channel The channel where the webhook should be created
+   * @param {string} [reason] Reason for creating the webhook
+   * @returns {Promise<NewsChannel>}
+   * @example
+   * if (channel.type === 'GUILD_NEWS') {
+   *   channel.addFollower('222197033908436994', 'Important announcements')
+   *     .then(() => console.log('Added follower'))
+   *     .catch(console.error);
+   * }
+   */
+  async addFollower(channel, reason) {
+    const channelId = this.guild.channels.resolveId(channel);
+    if (!channelId) throw new Error('GUILD_CHANNEL_RESOLVE');
+    await this.client.api.channels(this.id).followers.post({ data: { webhook_channel_id: channelId }, reason });
+    return this;
+  }
+}
+
+module.exports = NewsChannel;

package/src/structures/OAuth2Guild.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const BaseGuild = require('./BaseGuild');
+const Permissions = require('../util/Permissions');
+
+/**
+ * A partial guild received when using {@link GuildManager#fetch} to fetch multiple guilds.
+ * @extends {BaseGuild}
+ */
+class OAuth2Guild extends BaseGuild {
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * Whether the client user is the owner of the guild
+     * @type {boolean}
+     */
+    this.owner = data.owner;
+
+    /**
+     * The permissions that the client user has in this guild
+     * @type {Readonly<Permissions>}
+     */
+    this.permissions = new Permissions(BigInt(data.permissions)).freeze();
+  }
+}
+
+module.exports = OAuth2Guild;