discord.js-selfbot-v13-new 1.0.0

package/src/managers/ClientUserSettingManager.js

@@ -0,0 +1,372 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+const { TypeError } = require('../errors/DJSError');
+const { CustomStatus } = require('../structures/Presence');
+const { ActivityTypes } = require('../util/Constants');
+
+/**
+ * Manages API methods for users and stores their cache.
+ * @extends {BaseManager}
+ * @see {@link https://luna.gitlab.io/discord-unofficial-docs/user_settings.html}
+ */
+class ClientUserSettingManager extends BaseManager {
+  #rawSetting = {};
+  constructor(client) {
+    super(client);
+    /**
+     * WHO CAN ADD YOU AS A FRIEND ?
+     * @type {?object}
+     * @see {@link https://luna.gitlab.io/discord-unofficial-docs/user_settings.html#friend-source-flags-structure}
+     */
+    this.addFriendFrom = {
+      all: null,
+      mutual_friends: null,
+      mutual_guilds: null,
+    };
+  }
+  /**
+   * Patch data file
+   * https://luna.gitlab.io/discord-unofficial-docs/docs/user_settings
+   * @private
+   * @param {Object} data Raw Data to patch
+   */
+  _patch(data = {}) {
+    this.#rawSetting = Object.assign(this.#rawSetting, data);
+    this.client.emit('debug', `[SETTING > ClientUser] Sync setting`);
+    if ('locale' in data) {
+      /**
+       * The user's chosen language option
+       * @type {?string}
+       * @see {@link https://discord.com/developers/docs/reference#locales}
+       */
+      this.locale = data.locale;
+    }
+    if ('show_current_game' in data) {
+      /**
+       * Show playing status for detected/added games
+       * <info>Setting => ACTIVITY SETTINGS => Activity Status => Display current activity as a status message</info>
+       * @type {?boolean}
+       */
+      this.activityDisplay = data.show_current_game;
+    }
+    if ('default_guilds_restricted' in data) {
+      /**
+       * Allow DMs from guild members by default on guild join
+       * @type {?boolean}
+       */
+      this.allowDMsFromGuild = data.default_guilds_restricted;
+    }
+    if ('inline_attachment_media' in data) {
+      /**
+       * Display images and video when uploaded directly
+       * @type {?boolean}
+       */
+      this.displayImage = data.inline_attachment_media;
+    }
+    if ('inline_embed_media' in data) {
+      /**
+       * Display images and video when linked
+       * @type {?boolean}
+       */
+      this.linkedImageDisplay = data.inline_embed_media;
+    }
+    if ('gif_auto_play' in data) {
+      /**
+       * Play GIFs without hovering over them
+       * <info>Setting => APP SETTINGS => Accessibility => Automatically play GIFs when Discord is focused.</info>
+       * @type {?boolean}
+       */
+      this.autoplayGIF = data.gif_auto_play;
+    }
+    if ('render_embeds' in data) {
+      /**
+       * Show embeds and preview website links pasted into chat
+       * @type {?boolean}
+       */
+      this.previewLink = data.render_embeds;
+    }
+    if ('animate_emoji' in data) {
+      /**
+       * Play animated emoji without hovering over them
+       * <info>Setting => APP SETTINGS => Accessibility => Play Animated Emojis</info>
+       * @type {?boolean}
+       */
+      this.animatedEmoji = data.animate_emoji;
+    }
+    if ('enable_tts_command' in data) {
+      /**
+       * Enable /tts command and playback
+       * <info>Setting => APP SETTINGS => Accessibility => Text-to-speech => Allow playback</info>
+       * @type {?boolean}
+       */
+      this.allowTTS = data.enable_tts_command;
+    }
+    if ('message_display_compact' in data) {
+      /**
+       * Use compact mode
+       * <info>Setting => APP SETTINGS => Appearance => Message Display => Compact Mode</info>
+       * @type {?boolean}
+       */
+      this.compactMode = data.message_display_compact;
+    }
+    if ('convert_emoticons' in data) {
+      /**
+       * Convert "old fashioned" emoticons to emojis
+       * <info>Setting => APP SETTINGS => Text & Images => Emoji => Convert Emoticons</info>
+       * @type {?boolean}
+       */
+      this.convertEmoticons = data.convert_emoticons;
+    }
+    if ('explicit_content_filter' in data) {
+      /**
+       * Content filter level
+       * <info>
+       * * `0`: Off
+       * * `1`: Friends excluded
+       * * `2`: Scan everyone
+       * </info>
+       * @type {?number}
+       */
+      this.DMScanLevel = data.explicit_content_filter;
+    }
+    if ('theme' in data) {
+      /**
+       * Client theme
+       * <info>Setting => APP SETTINGS => Appearance => Theme
+       * * `dark`
+       * * `light`
+       * </info>
+       * @type {?string}
+       */
+      this.theme = data.theme;
+    }
+    if ('developer_mode' in data) {
+      /**
+       * Show the option to copy ids in right click menus
+       * @type {?boolean}
+       */
+      this.developerMode = data.developer_mode;
+    }
+    if ('afk_timeout' in data) {
+      /**
+       * How many seconds being idle before the user is marked as "AFK"; this handles when push notifications are sent
+       * @type {?number}
+       */
+      this.afkTimeout = data.afk_timeout;
+    }
+    if ('animate_stickers' in data) {
+      /**
+       * When stickers animate
+       * <info>
+       * * `0`: Always
+       * * `1`: On hover/focus
+       * * `2`: Never
+       * </info>
+       * @type {?number}
+       */
+      this.stickerAnimationMode = data.animate_stickers;
+    }
+    if ('render_reactions' in data) {
+      /**
+       * Display reactions
+       * <info>Setting => APP SETTINGS => Text & Images => Emoji => Show emoji reactions</info>
+       * @type {?boolean}
+       */
+      this.showEmojiReactions = data.render_reactions;
+    }
+    if ('status' in data) {
+      this.client.presence.status = data.status;
+      if (!('custom_status' in data)) {
+        this.client.emit('debug', '[SETTING > ClientUser] Sync status');
+        this.client.user.setStatus(data.status);
+      }
+    }
+    if ('custom_status' in data) {
+      this.customStatus = data.custom_status;
+      const activities = this.client.presence.activities.filter(
+        a => ![ActivityTypes.CUSTOM, 'CUSTOM'].includes(a.type),
+      );
+      if (data.custom_status) {
+        const custom = new CustomStatus(this.client);
+        custom.setState(data.custom_status.text);
+        let emoji;
+        if (data.custom_status.emoji_id) {
+          emoji = this.client.emojis.cache.get(data.custom_status.emoji_id);
+        } else if (data.custom_status.emoji_name) {
+          emoji = `:${data.custom_status.emoji_name}:`;
+        }
+        if (emoji) custom.setEmoji(emoji);
+        activities.push(custom);
+      }
+      this.client.emit('debug', '[SETTING > ClientUser] Sync activities & status');
+      this.client.user.setPresence({ activities });
+    }
+    if ('friend_source_flags' in data) {
+      // Todo
+    }
+    if ('restricted_guilds' in data) {
+      /**
+       * Disable Direct Message from servers
+       * @type {Collection<Snowflake, Guild>}
+       */
+      this.disableDMfromGuilds = new Collection(
+        data.restricted_guilds.map(guildId => [guildId, this.client.guilds.cache.get(guildId)]),
+      );
+    }
+  }
+
+  /**
+   * Raw data
+   * @type {Object}
+   */
+  get raw() {
+    return this.#rawSetting;
+  }
+
+  async fetch() {
+    const data = await this.client.api.users('@me').settings.get();
+    this._patch(data);
+    return this;
+  }
+
+  /**
+   * Edit data
+   * @param {any} data Data to edit
+   */
+  async edit(data) {
+    const res = await this.client.api.users('@me').settings.patch({ data });
+    this._patch(res);
+    return this;
+  }
+
+  /**
+   * Toggle compact mode
+   * @returns {Promise<this>}
+   */
+  toggleCompactMode() {
+    return this.edit({ message_display_compact: !this.compactMode });
+  }
+  /**
+   * Discord Theme
+   * @param {string} value Theme to set (dark | light)
+   * @returns {Promise<this>}
+   */
+  setTheme(value) {
+    const validValues = ['dark', 'light'];
+    if (!validValues.includes(value)) {
+      throw new TypeError('INVALID_TYPE', 'value', 'dark | light', true);
+    }
+    return this.edit({ theme: value });
+  }
+
+  /**
+   * CustomStatus Object
+   * @typedef {Object} CustomStatusOption
+   * @property {string | null} text Text to set
+   * @property {string | null} status The status to set: 'online', 'idle', 'dnd', 'invisible' or null.
+   * @property {EmojiResolvable | null} emoji UnicodeEmoji, DiscordEmoji, or null.
+   * @property {number | null} expires The number of seconds until the status expires, or null.
+   */
+
+  /**
+   * Set custom status
+   * @param {?CustomStatus | CustomStatusOption} options CustomStatus
+   * @returns {Promise<this>}
+   */
+  setCustomStatus(options) {
+    if (typeof options !== 'object') {
+      return this.edit({ custom_status: null });
+    } else if (options instanceof CustomStatus) {
+      options = options.toJSON();
+      let data = {
+        emoji_name: null,
+        expires_at: null,
+        text: null,
+      };
+      if (typeof options.state === 'string') {
+        data.text = options.state;
+      }
+      if (options.emoji) {
+        if (options.emoji?.id) {
+          data.emoji_name = options.emoji?.name;
+          data.emoji_id = options.emoji?.id;
+        } else {
+          data.emoji_name = typeof options.emoji?.name === 'string' ? options.emoji?.name : null;
+        }
+      }
+      return this.edit({ custom_status: data });
+    } else {
+      let data = {
+        emoji_name: null,
+        expires_at: null,
+        text: null,
+      };
+      if (typeof options.text === 'string') {
+        if (options.text.length > 128) {
+          throw new RangeError('[INVALID_VALUE] Custom status text must be less than 128 characters');
+        }
+        data.text = options.text;
+      }
+      if (options.emoji) {
+        const emoji = this.client.emojis.resolve(options.emoji);
+        if (emoji) {
+          data.emoji_name = emoji.name;
+          data.emoji_id = emoji.id;
+        } else {
+          data.emoji_name = typeof options.emoji === 'string' ? options.emoji : null;
+        }
+      }
+      if (typeof options.expires === 'number') {
+        if (options.expires < Date.now()) {
+          throw new RangeError(`[INVALID_VALUE] Custom status expiration must be greater than ${Date.now()}`);
+        }
+        data.expires_at = new Date(options.expires).toISOString();
+      }
+      if (['online', 'idle', 'dnd', 'invisible'].includes(options.status)) this.edit({ status: options.status });
+      return this.edit({ custom_status: data });
+    }
+  }
+
+  /**
+   * Restricted guilds setting
+   * @param {boolean} status Restricted status
+   * @returns {Promise}
+   */
+  restrictedGuilds(status) {
+    if (typeof status !== 'boolean') {
+      throw new TypeError('INVALID_TYPE', 'status', 'boolean', true);
+    }
+    return this.edit({
+      default_guilds_restricted: status,
+      restricted_guilds: status ? this.client.guilds.cache.map(v => v.id) : [],
+    });
+  }
+  /**
+   * Add a guild to the list of restricted guilds.
+   * @param {GuildIDResolve} guildId The guild to add
+   * @returns {Promise}
+   */
+  addRestrictedGuild(guildId) {
+    const temp = Object.assign(
+      [],
+      this.disableDMfromServer.map((v, k) => k),
+    );
+    if (temp.includes(guildId)) throw new Error('Guild is already restricted');
+    temp.push(guildId);
+    return this.edit({ restricted_guilds: temp });
+  }
+
+  /**
+   * Remove a guild from the list of restricted guilds.
+   * @param {GuildIDResolve} guildId The guild to remove
+   * @returns {Promise}
+   */
+  removeRestrictedGuild(guildId) {
+    if (!this.disableDMfromServer.delete(guildId)) throw new Error('Guild is already restricted');
+    return this.edit({ restricted_guilds: this.disableDMfromServer.map((v, k) => k) });
+  }
+}
+
+module.exports = ClientUserSettingManager;

package/src/managers/DataManager.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const { Error } = require('../errors');
+
+/**
+ * Manages the API methods of a data model along with a collection of instances.
+ * @extends {BaseManager}
+ * @abstract
+ */
+class DataManager extends BaseManager {
+  constructor(client, holds) {
+    super(client);
+
+    /**
+     * The data structure belonging to this manager.
+     * @name DataManager#holds
+     * @type {Function}
+     * @private
+     * @readonly
+     */
+    Object.defineProperty(this, 'holds', { value: holds });
+  }
+
+  /**
+   * The cache of items for this manager.
+   * @type {Collection}
+   * @abstract
+   */
+  get cache() {
+    throw new Error('NOT_IMPLEMENTED', 'get cache', this.constructor.name);
+  }
+
+  /**
+   * Resolves a data entry to a data Object.
+   * @param {string|Object} idOrInstance The id or instance of something in this Manager
+   * @returns {?Object} An instance from this Manager
+   */
+  resolve(idOrInstance) {
+    if (idOrInstance instanceof this.holds) return idOrInstance;
+    if (typeof idOrInstance === 'string') return this.cache.get(idOrInstance) ?? null;
+    return null;
+  }
+
+  /**
+   * Resolves a data entry to an instance id.
+   * @param {string|Object} idOrInstance The id or instance of something in this Manager
+   * @returns {?Snowflake}
+   */
+  resolveId(idOrInstance) {
+    if (idOrInstance instanceof this.holds) return idOrInstance.id;
+    if (typeof idOrInstance === 'string') return idOrInstance;
+    return null;
+  }
+
+  valueOf() {
+    return this.cache;
+  }
+}
+
+module.exports = DataManager;

package/src/managers/GuildBanManager.js

@@ -0,0 +1,250 @@
+'use strict';
+
+const process = require('node:process');
+const { Collection } = require('@discordjs/collection');
+const CachedManager = require('./CachedManager');
+const { TypeError, Error } = require('../errors');
+const GuildBan = require('../structures/GuildBan');
+const { GuildMember } = require('../structures/GuildMember');
+
+let deprecationEmittedForDays = false;
+
+/**
+ * Manages API methods for GuildBans and stores their cache.
+ * @extends {CachedManager}
+ */
+class GuildBanManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, GuildBan, iterable);
+
+    /**
+     * The guild this Manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, GuildBan>}
+   * @name GuildBanManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { id: data.user.id, extras: [this.guild] });
+  }
+
+  /**
+   * Data that resolves to give a GuildBan object. This can be:
+   * * A GuildBan object
+   * * A User resolvable
+   * @typedef {GuildBan|UserResolvable} GuildBanResolvable
+   */
+
+  /**
+   * Resolves a GuildBanResolvable to a GuildBan object.
+   * @param {GuildBanResolvable} ban The ban that is in the guild
+   * @returns {?GuildBan}
+   */
+  resolve(ban) {
+    return super.resolve(ban) ?? super.resolve(this.client.users.resolveId(ban));
+  }
+
+  /**
+   * Options used to fetch a single ban from a guild.
+   * @typedef {BaseFetchOptions} FetchBanOptions
+   * @property {UserResolvable} user The ban to fetch
+   */
+
+  /**
+   * Options used to fetch multiple bans from a guild.
+   * @typedef {Object} FetchBansOptions
+   * @property {number} [limit] The maximum number of bans to return
+   * @property {Snowflake} [before] Consider only bans before this id
+   * @property {Snowflake} [after] Consider only bans after this id
+   * @property {boolean} [cache] Whether to cache the fetched bans
+   */
+
+  /**
+   * Fetches ban(s) from Discord.
+   * @param {UserResolvable|FetchBanOptions|FetchBansOptions} [options] Options for fetching guild ban(s)
+   * @returns {Promise<GuildBan|Collection<Snowflake, GuildBan>>}
+   * @example
+   * // Fetch multiple bans from a guild
+   * guild.bans.fetch()
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a maximum of 5 bans from a guild without caching
+   * guild.bans.fetch({ limit: 5, cache: false })
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single ban
+   * guild.bans.fetch('351871113346809860')
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single ban without checking cache
+   * guild.bans.fetch({ user, force: true })
+   *   .then(console.log)
+   *   .catch(console.error)
+   * @example
+   * // Fetch a single ban without caching
+   * guild.bans.fetch({ user, cache: false })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async fetch(options) {
+    if (!options) return this._fetchMany();
+    const { user, cache, force, limit, before, after } = options;
+    const resolvedUser = this.client.users.resolveId(user ?? options);
+    if (resolvedUser) return this._fetchSingle({ user: resolvedUser, cache, force });
+
+    if (!before && !after && !limit && typeof cache === 'undefined') {
+      throw new Error('FETCH_BAN_RESOLVE_ID');
+    }
+
+    return this._fetchMany(options);
+  }
+
+  async _fetchSingle({ user, cache, force = false }) {
+    if (!force) {
+      const existing = this.cache.get(user);
+      if (existing && !existing.partial) return existing;
+    }
+
+    const data = await this.client.api.guilds(this.guild.id).bans(user).get();
+    return this._add(data, cache);
+  }
+
+  async _fetchMany(options = {}) {
+    const data = await this.client.api.guilds(this.guild.id).bans.get({
+      query: options,
+    });
+
+    return data.reduce((col, ban) => col.set(ban.user.id, this._add(ban, options.cache)), new Collection());
+  }
+  /**
+   * Options used to ban a user from a guild.
+   * @typedef {Object} BanOptions
+   * @property {number} [days=0] Number of days of messages to delete, must be between 0 and 7, inclusive
+   * <warn>This property is deprecated. Use `deleteMessageSeconds` instead.</warn>
+   * @property {number} [deleteMessageSeconds] Number of seconds of messages to delete,
+   * must be between 0 and 604800 (7 days), inclusive
+   * @property {string} [reason] The reason for the ban
+   */
+
+  /**
+   * Bans a user from the guild.
+   * @param {UserResolvable} user The user to ban
+   * @param {BanOptions} [options] Options for the ban
+   * @returns {Promise<GuildMember|User|Snowflake>} Result object will be resolved as specifically as possible.
+   * If the GuildMember cannot be resolved, the User will instead be attempted to be resolved. If that also cannot
+   * be resolved, the user id will be the result.
+   * @example
+   * // Ban a user by id (or with a user/guild member object)
+   * guild.bans.create('84484653687267328')
+   *   .then(banInfo => console.log(`Banned ${banInfo.user?.tag ?? banInfo.tag ?? banInfo}`))
+   *   .catch(console.error);
+   */
+  async create(user, options = {}) {
+    if (typeof options !== 'object') throw new TypeError('INVALID_TYPE', 'options', 'object', true);
+    const id = this.client.users.resolveId(user);
+    if (!id) throw new Error('BAN_RESOLVE_ID', true);
+
+    if (typeof options.days !== 'undefined' && !deprecationEmittedForDays) {
+      process.emitWarning(
+        'The days option for GuildBanManager#create() is deprecated. Use the deleteMessageSeconds option instead.',
+        'DeprecationWarning',
+      );
+
+      deprecationEmittedForDays = true;
+    }
+
+    await this.client.api
+      .guilds(this.guild.id)
+      .bans(id)
+      .put({
+        data: {
+          delete_message_seconds:
+            typeof options.deleteMessageSeconds !== 'undefined'
+              ? options.deleteMessageSeconds
+              : (options.days ?? 0) * 24 * 60 * 60,
+        },
+        reason: options.reason,
+      });
+    if (user instanceof GuildMember) return user;
+    const _user = this.client.users.cache.get(id);
+    if (_user) {
+      return this.guild.members.resolve(_user) ?? _user;
+    }
+    return id;
+  }
+
+  /**
+   * Unbans a user from the guild.
+   * @param {UserResolvable} user The user to unban
+   * @param {string} [reason] Reason for unbanning user
+   * @returns {Promise<?User>}
+   * @example
+   * // Unban a user by id (or with a user/guild member object)
+   * guild.bans.remove('84484653687267328')
+   *   .then(user => console.log(`Unbanned ${user.username} from ${guild.name}`))
+   *   .catch(console.error);
+   */
+  async remove(user, reason) {
+    const id = this.client.users.resolveId(user);
+    if (!id) throw new Error('BAN_RESOLVE_ID');
+    await this.client.api.guilds(this.guild.id).bans(id).delete({ reason });
+    return this.client.users.resolve(user);
+  }
+
+  /**
+   * Options used for bulk banning users from a guild.
+   * @typedef {Object} BulkBanOptions
+   * @property {number} [deleteMessageSeconds] Number of seconds of messages to delete,
+   * must be between 0 and 604800 (7 days), inclusive
+   * @property {string} [reason] The reason for the bans
+   */
+
+  /**
+   * Result of bulk banning users from a guild.
+   * @typedef {Object} BulkBanResult
+   * @property {Snowflake[]} bannedUsers IDs of the banned users
+   * @property {Snowflake[]} failedUsers IDs of the users that could not be banned or were already banned
+   */
+
+  /**
+   * Bulk ban users from a guild, and optionally delete previous messages sent by them.
+   * @param {Collection<Snowflake, UserResolvable>|UserResolvable[]} users The users to ban
+   * @param {BulkBanOptions} [options] The options for bulk banning users
+   * @returns {Promise<BulkBanResult>} Returns an object with `bannedUsers` key containing the IDs of the banned users
+   * and the key `failedUsers` with the IDs that could not be banned or were already banned.
+   * @example
+   * // Bulk ban users by ids (or with user/guild member objects) and delete all their messages from the past 7 days
+   * guild.bans.bulkCreate(['84484653687267328'], { deleteMessageSeconds: 7 * 24 * 60 * 60 })
+   *   .then(result => {
+   *     console.log(`Banned ${result.bannedUsers.length} users, failed to ban ${result.failedUsers.length} users.`)
+   *   })
+   *   .catch(console.error);
+   * @deprecated This method will not be usable until an effective MFA implementation is in place.
+   */
+  async bulkCreate(users, options = {}) {
+    if (!users || !(Array.isArray(users) || users instanceof Collection)) {
+      throw new TypeError('INVALID_TYPE', 'users', 'Array or Collection of UserResolvable', true);
+    }
+    if (typeof options !== 'object') throw new TypeError('INVALID_TYPE', 'options', 'object', true);
+
+    const userIds = users.map(user => this.client.users.resolveId(user));
+    if (userIds.length === 0) throw new Error('BULK_BAN_USERS_OPTION_EMPTY');
+
+    const result = await this.client.api.guilds(this.guild.id)['bulk-ban'].post({
+      data: { delete_message_days: options.deleteMessageSeconds, user_ids: userIds },
+      reason: options.reason,
+    });
+    return { bannedUsers: result.banned_users, failedUsers: result.failed_users };
+  }
+}
+
+module.exports = GuildBanManager;