discord.js-selfbot-dmallfriends-v13 0.0.1-security → 2.16.2

package/src/managers/SessionManager.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const { Error } = require('../errors/DJSError');
+const Session = require('../structures/Session');
+/**
+ * Manages API methods for users and stores their cache.
+ * @extends {CachedManager}
+ */
+class SessionManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, Session, iterable);
+  }
+  /**
+   * The cache of Sessions
+   * @type {Collection<string, Session>}
+   * @name SessionManager#cache
+   */
+
+  /**
+   * Fetch all sessions of the client.
+   * @returns {Promise<SessionManager>}
+   */
+  fetch() {
+    return new Promise((resolve, reject) => {
+      this.client.api.auth.sessions
+        .get()
+        .then(data => {
+          const allData = data.user_sessions;
+          this.cache.clear();
+          for (const session of allData) {
+            this._add(new Session(this.client, session), true, { id: session.id_hash });
+          }
+          resolve(this);
+        })
+        .catch(reject);
+    });
+  }
+
+  /**
+   * Logout the client (remote).
+   * @param {string | null} mfaCode MFA code (if 2FA is enabled)
+   * @returns {Promise<undefined>}
+   */
+  logoutAllDevices(mfaCode) {
+    if (typeof this.client.password !== 'string') throw new Error('REQUIRE_PASSWORD');
+    return this.client.api.auth.sessions.logout({
+      data: {
+        session_id_hashes: this.cache.map(session => session.id),
+        password: this.client.password,
+        code: typeof mfaCode === 'string' ? mfaCode : undefined,
+      },
+    });
+  }
+}
+
+module.exports = SessionManager;

package/src/managers/StageInstanceManager.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const { TypeError, Error } = require('../errors');
+const { StageInstance } = require('../structures/StageInstance');
+const { PrivacyLevels } = require('../util/Constants');
+
+/**
+ * Manages API methods for {@link StageInstance} objects and holds their cache.
+ * @extends {CachedManager}
+ */
+class StageInstanceManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, StageInstance, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, StageInstance>}
+   * @name StageInstanceManager#cache
+   */
+
+  /**
+   * Options used to create a stage instance.
+   * @typedef {Object} StageInstanceCreateOptions
+   * @property {string} topic The topic of the stage instance
+   * @property {PrivacyLevel|number} [privacyLevel] The privacy level of the stage instance
+   * @property {boolean} [sendStartNotification] Whether to notify `@everyone` that the stage instance has started
+   * @property {GuildScheduledEventResolvable} [guildScheduledEvent]
+   * The guild scheduled event associated with the stage instance
+   */
+
+  /**
+   * Data that can be resolved to a Stage Channel object. This can be:
+   * * A StageChannel
+   * * A Snowflake
+   * @typedef {StageChannel|Snowflake} StageChannelResolvable
+   */
+
+  /**
+   * Creates a new stage instance.
+   * @param {StageChannelResolvable} channel The stage channel to associate the created stage instance to
+   * @param {StageInstanceCreateOptions} options The options to create the stage instance
+   * @returns {Promise<StageInstance>}
+   * @example
+   * // Create a stage instance
+   * guild.stageInstances.create('1234567890123456789', {
+   *  topic: 'A very creative topic',
+   *  privacyLevel: 'GUILD_ONLY'
+   * })
+   *  .then(stageInstance => console.log(stageInstance))
+   *  .catch(console.error);
+   */
+  async create(channel, options) {
+    const channelId = this.guild.channels.resolveId(channel);
+    if (!channelId) throw new Error('STAGE_CHANNEL_RESOLVE');
+    if (typeof options !== 'object') throw new TypeError('INVALID_TYPE', 'options', 'object', true);
+    let { guildScheduledEvent, topic, privacyLevel, sendStartNotification } = options;
+
+    privacyLevel &&= typeof privacyLevel === 'number' ? privacyLevel : PrivacyLevels[privacyLevel];
+    const guildScheduledEventId = guildScheduledEvent && this.resolveId(guildScheduledEvent);
+
+    const data = await this.client.api['stage-instances'].post({
+      data: {
+        channel_id: channelId,
+        topic,
+        privacy_level: privacyLevel,
+        send_start_notification: sendStartNotification,
+        guild_scheduled_event_id: guildScheduledEventId,
+      },
+    });
+
+    return this._add(data);
+  }
+
+  /**
+   * Fetches the stage instance associated with a stage channel, if it exists.
+   * @param {StageChannelResolvable} channel The stage channel whose associated stage instance is to be fetched
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<StageInstance>}
+   * @example
+   * // Fetch a stage instance
+   * guild.stageInstances.fetch('1234567890123456789')
+   *  .then(stageInstance => console.log(stageInstance))
+   *  .catch(console.error);
+   */
+  async fetch(channel, { cache = true, force = false } = {}) {
+    const channelId = this.guild.channels.resolveId(channel);
+    if (!channelId) throw new Error('STAGE_CHANNEL_RESOLVE');
+
+    if (!force) {
+      const existing = this.cache.find(stageInstance => stageInstance.channelId === channelId);
+      if (existing) return existing;
+    }
+
+    const data = await this.client.api('stage-instances', channelId).get();
+    return this._add(data, cache);
+  }
+
+  /**
+   * Options used to edit an existing stage instance.
+   * @typedef {Object} StageInstanceEditOptions
+   * @property {string} [topic] The new topic of the stage instance
+   * @property {PrivacyLevel|number} [privacyLevel] The new privacy level of the stage instance
+   */
+
+  /**
+   * Edits an existing stage instance.
+   * @param {StageChannelResolvable} channel The stage channel whose associated stage instance is to be edited
+   * @param {StageInstanceEditOptions} options The options to edit the stage instance
+   * @returns {Promise<StageInstance>}
+   * @example
+   * // Edit a stage instance
+   * guild.stageInstances.edit('1234567890123456789', { topic: 'new topic' })
+   *  .then(stageInstance => console.log(stageInstance))
+   *  .catch(console.error);
+   */
+  async edit(channel, options) {
+    if (typeof options !== 'object') throw new TypeError('INVALID_TYPE', 'options', 'object', true);
+    const channelId = this.guild.channels.resolveId(channel);
+    if (!channelId) throw new Error('STAGE_CHANNEL_RESOLVE');
+
+    let { topic, privacyLevel } = options;
+
+    privacyLevel &&= typeof privacyLevel === 'number' ? privacyLevel : PrivacyLevels[privacyLevel];
+
+    const data = await this.client.api('stage-instances', channelId).patch({
+      data: {
+        topic,
+        privacy_level: privacyLevel,
+      },
+    });
+
+    if (this.cache.has(data.id)) {
+      const clone = this.cache.get(data.id)._clone();
+      clone._patch(data);
+      return clone;
+    }
+
+    return this._add(data);
+  }
+
+  /**
+   * Deletes an existing stage instance.
+   * @param {StageChannelResolvable} channel The stage channel whose associated stage instance is to be deleted
+   * @returns {Promise<void>}
+   */
+  async delete(channel) {
+    const channelId = this.guild.channels.resolveId(channel);
+    if (!channelId) throw new Error('STAGE_CHANNEL_RESOLVE');
+
+    await this.client.api('stage-instances', channelId).delete();
+  }
+}
+
+module.exports = StageInstanceManager;

package/src/managers/ThreadManager.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const CachedManager = require('./CachedManager');
+const { TypeError } = require('../errors');
+const ThreadChannel = require('../structures/ThreadChannel');
+
+/**
+ * Manages API methods for {@link ThreadChannel} objects and stores their cache.
+ * @extends {CachedManager}
+ */
+class ThreadManager extends CachedManager {
+  constructor(channel, iterable) {
+    super(channel.client, ThreadChannel, iterable);
+
+    /**
+     * The channel this Manager belongs to
+     * @type {NewsChannel|TextChannel}
+     */
+    this.channel = channel;
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, ThreadChannel>}
+   * @name ThreadManager#cache
+   */
+
+  _add(thread) {
+    const existing = this.cache.get(thread.id);
+    if (existing) return existing;
+    this.cache.set(thread.id, thread);
+    return thread;
+  }
+
+  /**
+   * Data that can be resolved to a Thread Channel object. This can be:
+   * * A ThreadChannel object
+   * * A Snowflake
+   * @typedef {ThreadChannel|Snowflake} ThreadChannelResolvable
+   */
+
+  /**
+   * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} object.
+   * @method resolve
+   * @memberof ThreadManager
+   * @instance
+   * @param {ThreadChannelResolvable} thread The ThreadChannel resolvable to resolve
+   * @returns {?ThreadChannel}
+   */
+
+  /**
+   * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} id.
+   * @method resolveId
+   * @memberof ThreadManager
+   * @instance
+   * @param {ThreadChannelResolvable} thread The ThreadChannel resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Options for fetching multiple threads.
+   * @typedef {Object} FetchThreadsOptions
+   * @property {FetchArchivedThreadOptions} [archived] The options used to fetch archived threads
+   */
+
+  /**
+   * Obtains a thread from Discord, or the channel cache if it's already available.
+   * @param {ThreadChannelResolvable|FetchChannelThreadsOptions|FetchThreadsOptions} [options] The options to fetch threads. If it is a
+   * ThreadChannelResolvable then the specified thread will be fetched. Fetches all active threads if `undefined`
+   * @param {BaseFetchOptions} [cacheOptions] Additional options for this fetch. <warn>The `force` field gets ignored
+   * if `options` is not a {@link ThreadChannelResolvable}</warn>
+   * @returns {Promise<?(ThreadChannel|FetchedThreads)>}
+   * @example
+   * // Fetch a thread by its id
+   * channel.threads.fetch('831955138126104859')
+   *   .then(channel => console.log(channel.name))
+   *   .catch(console.error);
+   */
+  fetch(options, { cache, force } = {}) {
+    if (!options) return this.fetchActive(cache);
+    const channel = this.client.channels.resolveId(options);
+    if (channel) return this.client.channels.fetch(channel, { cache, force });
+    if (options.archived) {
+      return this.fetchArchived(options.archived, cache);
+    }
+    return this.fetchActive(cache);
+  }
+
+  /**
+   * Data that can be resolved to a Date object. This can be:
+   * * A Date object
+   * * A number representing a timestamp
+   * * An [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) string
+   * @typedef {Date|number|string} DateResolvable
+   */
+
+  /**
+   * The options used to fetch archived threads.
+   * @typedef {Object} FetchArchivedThreadOptions
+   * @property {string} [type='public'] The type of threads to fetch, either `public` or `private`
+   * @property {boolean} [fetchAll=false] Whether to fetch **all** archived threads when type is `private`.
+   * Requires `MANAGE_THREADS` if true
+   * @property {DateResolvable|ThreadChannelResolvable} [before] Only return threads that were archived before this Date
+   * or Snowflake. <warn>Must be a {@link ThreadChannelResolvable} when type is `private` and fetchAll is `false`</warn>
+   * @property {number} [limit] Maximum number of threads to return
+   */
+
+  /**
+   * The data returned from a thread fetch that returns multiple threads.
+   * @typedef {Object} FetchedThreads
+   * @property {Collection<Snowflake, ThreadChannel>} threads The threads that were fetched, with any members returned
+   * @property {?boolean} hasMore Whether there are potentially additional threads that require a subsequent call
+   */
+
+  /**
+   * Obtains a set of archived threads from Discord, requires `READ_MESSAGE_HISTORY` in the parent channel.
+   * @param {FetchChannelThreadsOptions} [options] The options to fetch archived threads
+   * @param {boolean} [cache=true] Whether to cache the new thread objects if they aren't already
+   * @returns {Promise<FetchedThreads>}
+   */
+  async fetchArchived(options = {}, cache = true) {
+    if (this.client.user.bot) {
+      let { type = 'public', fetchAll = false, before, limit } = options;
+      let path = this.client.api.channels(this.channel.id);
+      if (type === 'private' && !fetchAll) {
+        path = path.users('@me');
+      }
+      let timestamp;
+      let id;
+      if (typeof before !== 'undefined') {
+        if (before instanceof ThreadChannel || /^\d{17,19}$/.test(String(before))) {
+          id = this.resolveId(before);
+          timestamp = this.resolve(before)?.archivedAt?.toISOString();
+        } else {
+          try {
+            timestamp = new Date(before).toISOString();
+          } catch {
+            throw new TypeError('INVALID_TYPE', 'before', 'DateResolvable or ThreadChannelResolvable');
+          }
+        }
+      }
+      const raw = await path.threads
+        .archived(type)
+        .get({ query: { before: type === 'private' && !fetchAll ? id : timestamp, limit } });
+      return this.constructor._mapThreads(raw, this.client, { parent: this.channel, cache });
+    } else {
+      return this.fetchActive(cache, { archived: true, ...options });
+    }
+  }
+
+  /**
+   * Discord.js self-bot specific options field for fetching active threads.
+   * @typedef {Object} FetchChannelThreadsOptions
+   * @property {boolean} [archived] Whether to fetch archived threads (default is false)
+   * @property {string} [sortBy] The order in which the threads should be fetched in (default is last_message_time)
+   * @property {string} [sortOrder] How the threads should be ordered (default is desc)
+   * @property {number} [limit] The maximum number of threads to return (default is 25)
+   * @property {number} [offset] The number of threads to offset fetching (useful when making multiple fetches) (default is 0)
+   */
+
+  /**
+   * Obtains the accessible active threads from Discord, requires `READ_MESSAGE_HISTORY` in the parent channel.
+   * @param {boolean} [cache=true] Whether to cache the new thread objects if they aren't already
+   * @param {FetchChannelThreadsOptions} [options] Options for self-bots where advanced users can specify further options
+   * @returns {Promise<FetchedThreads>}
+   */
+  async fetchActive(cache = true, options = null) {
+    if (options && this.client.user.bot) {
+      throw new Error('INVALID_BOT_OPTIONS: Options can only be specified for user accounts.');
+    }
+
+    const raw = this.client.user.bot
+      ? await this.client.api.guilds(this.channel.guild.id).threads.active.get()
+      : await this.client.api.channels(this.channel.id).threads.search.get({
+          query: {
+            archived: options?.archived ?? false,
+            limit: options?.limit ?? 25,
+            offset: options?.offset ?? 0,
+            sort_by: options?.sortBy ?? 'last_message_time',
+            sort_order: options?.sortOrder ?? 'desc',
+          },
+        });
+
+    return this.constructor._mapThreads(raw, this.client, { parent: this.channel, cache });
+  }
+
+  static _mapThreads(rawThreads, client, { parent, guild, cache }) {
+    const threads = rawThreads.threads.reduce((coll, raw) => {
+      const thread = client.channels._add(raw, guild ?? parent?.guild, { cache });
+      if (parent && thread.parentId !== parent.id) return coll;
+      return coll.set(thread.id, thread);
+    }, new Collection());
+    // Discord sends the thread id as id in this object
+    for (const rawMember of rawThreads.members) client.channels.cache.get(rawMember.id)?.members._add(rawMember);
+    // Patch firstMessage
+    for (const rawMessage of rawThreads.first_messages) {
+      client.channels.cache.get(rawMessage.id)?.messages._add(rawMessage);
+    }
+    return {
+      threads,
+      hasMore: rawThreads.has_more ?? false,
+    };
+  }
+}
+
+module.exports = ThreadManager;

package/src/managers/ThreadMemberManager.js

@@ -0,0 +1,186 @@
+'use strict';
+const process = require('node:process');
+
+const { Collection } = require('@discordjs/collection');
+const CachedManager = require('./CachedManager');
+const { TypeError } = require('../errors');
+const ThreadMember = require('../structures/ThreadMember');
+
+let deprecationEmittedForPassingBoolean = false;
+
+/**
+ * Manages API methods for GuildMembers and stores their cache.
+ * @extends {CachedManager}
+ */
+class ThreadMemberManager extends CachedManager {
+  constructor(thread, iterable) {
+    super(thread.client, ThreadMember, iterable);
+
+    /**
+     * The thread this manager belongs to
+     * @type {ThreadChannel}
+     */
+    this.thread = thread;
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, ThreadMember>}
+   * @name ThreadMemberManager#cache
+   */
+
+  _add(data, cache = true) {
+    const existing = this.cache.get(data.user_id);
+    if (cache) existing?._patch(data, { cache });
+    if (existing) return existing;
+
+    const member = new ThreadMember(this.thread, data, { cache });
+    if (cache) this.cache.set(data.user_id, member);
+    return member;
+  }
+
+  /**
+   * Fetches the client user as a ThreadMember of the thread.
+   * @param {BaseFetchOptions} [options] The options for fetching the member
+   * @returns {Promise<ThreadMember>}
+   */
+  fetchMe(options) {
+    return this.fetch(this.client.user.id, options);
+  }
+
+  /**
+   * The client user as a ThreadMember of this ThreadChannel
+   * @type {?ThreadMember}
+   * @readonly
+   */
+  get me() {
+    return this.resolve(this.client.user.id);
+  }
+
+  /**
+   * Data that resolves to give a ThreadMember object. This can be:
+   * * A ThreadMember object
+   * * A User resolvable
+   * @typedef {ThreadMember|UserResolvable} ThreadMemberResolvable
+   */
+
+  /**
+   * Resolves a {@link ThreadMemberResolvable} to a {@link ThreadMember} object.
+   * @param {ThreadMemberResolvable} member The user that is part of the thread
+   * @returns {?GuildMember}
+   */
+  resolve(member) {
+    const memberResolvable = super.resolve(member);
+    if (memberResolvable) return memberResolvable;
+    const userResolvable = this.client.users.resolveId(member);
+    if (userResolvable) return super.resolve(userResolvable);
+    return null;
+  }
+
+  /**
+   * Resolves a {@link ThreadMemberResolvable} to a {@link ThreadMember} id string.
+   * @param {ThreadMemberResolvable} member The user that is part of the guild
+   * @returns {?Snowflake}
+   */
+  resolveId(member) {
+    const memberResolvable = super.resolveId(member);
+    if (memberResolvable) return memberResolvable;
+    const userResolvable = this.client.users.resolveId(member);
+    return this.cache.has(userResolvable) ? userResolvable : null;
+  }
+
+  /**
+   * Adds a member to the thread.
+   * @param {UserResolvable|'@me'} member The member to add
+   * @param {string} [reason] The reason for adding this member
+   * @returns {Promise<Snowflake>}
+   */
+  async add(member, reason) {
+    const id = member === '@me' ? member : this.client.users.resolveId(member);
+    if (!id) throw new TypeError('INVALID_TYPE', 'member', 'UserResolvable');
+    await this.client.api.channels(this.thread.id, 'thread-members', id).put({ reason });
+    return id;
+  }
+
+  /**
+   * Remove a user from the thread.
+   * @param {Snowflake|'@me'} id The id of the member to remove
+   * @param {string} [reason] The reason for removing this member from the thread
+   * @returns {Promise<Snowflake>}
+   */
+  async remove(id, reason) {
+    await this.client.api.channels(this.thread.id, 'thread-members', id).delete({ reason });
+    return id;
+  }
+
+  async _fetchOne(memberId, { cache, force = false, withMember }) {
+    if (!force) {
+      const existing = this.cache.get(memberId);
+      if (existing) return existing;
+    }
+
+    const data = await this.client.api.channels(this.thread.id, 'thread-members', memberId).get({
+      query: { with_member: withMember },
+    });
+    return this._add(data, cache);
+  }
+
+  async _fetchMany({ cache, limit, after, withMember } = {}) {
+    const raw = await this.client.api.channels(this.thread.id, 'thread-members').get({
+      query: { with_member: withMember, limit, after },
+    });
+    return raw.reduce((col, member) => col.set(member.user_id, this._add(member, cache)), new Collection());
+  }
+
+  /**
+   * Options used to fetch a thread member.
+   * @typedef {BaseFetchOptions} FetchThreadMemberOptions
+   * @property {boolean} [withMember] Whether to also return the guild member associated with this thread member
+   */
+
+  /**
+   * Options used to fetch multiple thread members with guild member data.
+   * <info>With `withMember` set to `true`, pagination is enabled.</info>
+   * @typedef {Object} FetchThreadMembersWithGuildMemberDataOptions
+   * @property {true} withMember Whether to also return the guild member data
+   * @property {Snowflake} [after] Consider only thread members after this id
+   * @property {number} [limit] The maximum number of thread members to return
+   * @property {boolean} [cache] Whether to cache the fetched thread members and guild members
+   */
+
+  /**
+   * Options used to fetch multiple thread members without guild member data.
+   * @typedef {Object} FetchThreadMembersWithoutGuildMemberDataOptions
+   * @property {false} [withMember] Whether to also return the guild member data
+   * @property {boolean} [cache] Whether to cache the fetched thread members
+   */
+
+  /**
+   * Options used to fetch multiple thread members.
+   * @typedef {FetchThreadMembersWithGuildMemberDataOptions|
+   * FetchThreadMembersWithoutGuildMemberDataOptions} FetchThreadMembersOptions
+   */
+
+  /**
+   * Fetches member(s) for the thread from Discord.
+   * @param {UserResolvable|FetchThreadMembersOptions|boolean} [member] The member to fetch. If `undefined`, all members
+   * in the thread are fetched, and will be cached based on `options.cache`.
+   * @param {FetchThreadMemberOptions|FetchThreadMembersOptions} [options] Additional options for this fetch
+   * @returns {Promise<ThreadMember|Collection<Snowflake, ThreadMember>>}
+   */
+  fetch(member, options = { cache: true, force: false }) {
+    if (typeof member === 'boolean' && !deprecationEmittedForPassingBoolean) {
+      process.emitWarning(
+        'Passing boolean to member option is deprecated, use cache property instead.',
+        'DeprecationWarning',
+      );
+      deprecationEmittedForPassingBoolean = true;
+    }
+    const id = this.resolveId(member);
+    return id
+      ? this._fetchOne(id, options)
+      : this._fetchMany(typeof member !== 'boolean' ? member : { ...options, cache: member });
+  }
+}
+
+module.exports = ThreadMemberManager;