djs-selfbot-v13 3.1.5 → 3.1.7

package/src/managers/ReactionUserManager.js

@@ -3,15 +3,15 @@
 const { Collection } = require('@discordjs/collection');
 const CachedManager = require('./CachedManager');
 const { Error } = require('../errors');
-const User = require('../structures/User');
-
+const { lazy } = require('../util/Util');
+const User = lazy(() => require('../structures/User'));
 /**
  * Manages API methods for users who reacted to a reaction and stores their cache.
  * @extends {CachedManager}
  */
 class ReactionUserManager extends CachedManager {
   constructor(reaction, iterable) {
-    super(reaction.client, User, iterable);
+    super(reaction.client, User(), iterable);
 
     /**
      * The reaction that this manager belongs to
@@ -22,7 +22,7 @@ class ReactionUserManager extends CachedManager {
 
   /**
    * The cache of this manager
-   * @type {Collection<Snowflake, User>}
+   * @type {Collection<Snowflake, Discord.User>}
    * @name ReactionUserManager#cache
    */
 
@@ -36,7 +36,7 @@ class ReactionUserManager extends CachedManager {
   /**
    * Fetches all the users that gave this reaction. Resolves with a collection of users, mapped by their ids.
    * @param {FetchReactionUsersOptions} [options] Options for fetching the users
-   * @returns {Promise<Collection<Snowflake, User>>}
+   * @returns {Promise<Collection<Snowflake, Discord.User>>}
    */
   async fetch({ limit = 100, after } = {}) {
     const message = this.reaction.message;

package/src/managers/RelationshipManager.js

@@ -1,7 +1,7 @@
 'use strict';
 
+const Buffer = require('node:buffer').Buffer;
 const { Collection } = require('@discordjs/collection');
-const BaseManager = require('./BaseManager');
 const { GuildMember } = require('../structures/GuildMember');
 const { Message } = require('../structures/Message');
 const ThreadMember = require('../structures/ThreadMember');
@@ -11,22 +11,19 @@ const { RelationshipTypes } = require('../util/Constants');
 /**
  * Manages API methods for Relationships and stores their cache.
  */
-class RelationshipManager extends BaseManager {
+class RelationshipManager {
   constructor(client, users) {
-    super(client);
+    /**
+     * The client that instantiated this manager.
+     * @type {Client}
+     */
+    this.client = client;
     /**
      * A collection of users this manager is caching. (Type: Number)
      * @type {Collection<Snowflake, RelationshipTypes>}
+     * @readonly
      */
     this.cache = new Collection();
-    /**
-     * @type {Collection<Snowflake, string>}
-     */
-    this.friendNicknames = new Collection();
-    /**
-     * @type {Collection<Snowflake, Date>}
-     */
-    this.sinceCache = new Collection();
     this._setup(users);
   }
 
@@ -38,7 +35,7 @@ class RelationshipManager extends BaseManager {
   get friendCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.FRIEND)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
+      .map((value, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
@@ -50,7 +47,7 @@ class RelationshipManager extends BaseManager {
   get blockedCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.BLOCKED)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
+      .map((value, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
@@ -62,7 +59,7 @@ class RelationshipManager extends BaseManager {
   get incomingCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.PENDING_INCOMING)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
+      .map((value, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
@@ -74,29 +71,16 @@ class RelationshipManager extends BaseManager {
   get outgoingCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.PENDING_OUTGOING)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
+      .map((value, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
-  /**
-   * @typedef {Object} RelationshipJSONData
-   * @property {Snowflake} id The ID of the target user
-   * @property {RelationshipTypes} type The type of relationship
-   * @property {string | null} nickname The nickname of the user in this relationship (1-32 characters)
-   * @property {string} since When the user requested a relationship (ISO8601 timestamp)
-   */
-
   /**
    * Return array of cache
-   * @returns {RelationshipJSONData[]}
+   * @returns {Array<{id: Snowflake, type: RelationshipTypes}>}
    */
-  toJSON() {
-    return this.cache.map((value, key) => ({
-      id: key,
-      type: RelationshipTypes[value],
-      nickname: this.friendNicknames.get(key),
-      since: this.sinceCache.get(key).toISOString(),
-    }));
+  toArray() {
+    return this.cache.map((value, key) => ({ id: key, type: RelationshipTypes[value] }));
   }
 
   /**
@@ -107,9 +91,8 @@ class RelationshipManager extends BaseManager {
   _setup(users) {
     if (!Array.isArray(users)) return;
     for (const relationShip of users) {
-      this.friendNicknames.set(relationShip.id, relationShip.nickname);
+      this.client.user.friendNicknames.set(relationShip.id, relationShip.nickname);
       this.cache.set(relationShip.id, relationShip.type);
-      this.sinceCache.set(relationShip.id, new Date(relationShip.since || 0));
     }
   }
 
@@ -150,55 +133,66 @@ class RelationshipManager extends BaseManager {
   }
 
   /**
-   * Deletes a friend / blocked relationship with a client user or cancels a friend request.
+   * Deletes a friend relationship with a client user.
    * @param {UserResolvable} user Target
    * @returns {Promise<boolean>}
    */
-  async deleteRelationship(user) {
+  deleteFriend(user) {
     const id = this.resolveId(user);
-    if (
-      ![RelationshipTypes.FRIEND, RelationshipTypes.BLOCKED, RelationshipTypes.PENDING_OUTGOING].includes(
-        this.cache.get(id),
-      )
-    ) {
-      return Promise.resolve(false);
-    }
-    await this.client.api.users['@me'].relationships[id].delete({
-      DiscordContext: { location: 'Friends' },
-    });
-    return true;
+    // Check if already friends
+    if (this.cache.get(id) !== RelationshipTypes.FRIEND) return false;
+    return this.__cancel(id);
   }
 
   /**
-   * @typedef {Object} FriendRequestOptions
-   * @property {UserResolvable} [user] Target
-   * @property {string} [username] Discord username
-   * @property {number | null} [discriminator] Discord discriminator
+   * Deletes a blocked relationship with a client user.
+   * @param {UserResolvable} user Target
+   * @returns {Promise<boolean>}
    */
+  deleteBlocked(user) {
+    const id = this.resolveId(user);
+    // Check if already blocked
+    if (this.cache.get(id) !== RelationshipTypes.BLOCKED) return false;
+    return this.__cancel(id);
+  }
 
   /**
    * Sends a friend request.
-   * @param {FriendRequestOptions} options Target
+   * @param {string} username Username of the user to send the request to
+   * @param {?number} discriminator Discriminator of the user to send the request to
    * @returns {Promise<boolean>}
    */
-  async sendFriendRequest(options) {
-    if (options?.user) {
-      const id = this.resolveId(options.user);
-      await this.client.api.users['@me'].relationships[id].put({
-        data: {},
-        DiscordContext: { location: 'ContextMenu' },
-      });
-      return true;
-    } else {
-      await this.client.api.users['@me'].relationships.post({
-        data: {
-          username: options.username,
-          discriminator: options.discriminator,
-        },
-        DiscordContext: { location: 'Add Friend' },
-      });
-      return true;
-    }
+  async sendFriendRequest(username, discriminator) {
+    await this.client.api.users('@me').relationships.post({
+      data: {
+        username,
+        discriminator: discriminator == 0 ? null : parseInt(discriminator),
+      },
+      headers: {
+        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'Add Friend' }), 'utf8').toString('base64'),
+      },
+    });
+    return true;
+  }
+
+  /**
+   * Cancels a friend request.
+   * @param {UserResolvable} user  the user you want to delete
+   * @returns {Promise<boolean>}
+   */
+  cancelFriendRequest(user) {
+    const id = this.resolveId(user);
+    if (this.cache.get(id) !== RelationshipTypes.PENDING_OUTGOING) return false;
+    return this.__cancel(id);
+  }
+
+  async __cancel(id) {
+    await this.client.api.users['@me'].relationships[id].delete({
+      headers: {
+        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'Friends' }), 'utf8').toString('base64'),
+      },
+    });
+    return true;
   }
 
   /**
@@ -209,14 +203,16 @@ class RelationshipManager extends BaseManager {
   async addFriend(user) {
     const id = this.resolveId(user);
     // Check if already friends
-    if (this.cache.get(id) === RelationshipTypes.FRIEND) return Promise.resolve(false);
+    if (this.cache.get(id) === RelationshipTypes.FRIEND) return false;
     // Check if outgoing request
-    if (this.cache.get(id) === RelationshipTypes.PENDING_OUTGOING) return Promise.resolve(false);
+    if (this.cache.get(id) === RelationshipTypes.PENDING_OUTGOING) return false;
     await this.client.api.users['@me'].relationships[id].put({
       data: {
         type: RelationshipTypes.FRIEND,
       },
-      DiscordContext: { location: 'Friends' },
+      headers: {
+        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'Friends' }), 'utf8').toString('base64'),
+      },
     });
     return true;
   }
@@ -227,19 +223,14 @@ class RelationshipManager extends BaseManager {
    * @param {?string} nickname New nickname
    * @returns {Promise<boolean>}
    */
-  async setNickname(user, nickname = null) {
+  async setNickname(user, nickname) {
     const id = this.resolveId(user);
-    if (this.cache.get(id) !== RelationshipTypes.FRIEND) return Promise.resolve(false);
+    if (this.cache.get(id) !== RelationshipTypes.FRIEND) return false;
     await this.client.api.users['@me'].relationships[id].patch({
       data: {
         nickname: typeof nickname === 'string' ? nickname : null,
       },
     });
-    if (nickname) {
-      this.friendNicknames.set(id, nickname);
-    } else {
-      this.friendNicknames.delete(id);
-    }
     return true;
   }
 
@@ -251,12 +242,14 @@ class RelationshipManager extends BaseManager {
   async addBlocked(user) {
     const id = this.resolveId(user);
     // Check
-    if (this.cache.get(id) === RelationshipTypes.BLOCKED) return Promise.resolve(false);
+    if (this.cache.get(id) === RelationshipTypes.BLOCKED) return false;
     await this.client.api.users['@me'].relationships[id].put({
       data: {
         type: RelationshipTypes.BLOCKED,
       },
-      DiscordContext: { location: 'ContextMenu' },
+      headers: {
+        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'ContextMenu' }), 'utf8').toString('base64'),
+      },
     });
     return true;
   }

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/ThreadManager.js

@@ -2,6 +2,7 @@
 
 const { Collection } = require('@discordjs/collection');
 const CachedManager = require('./CachedManager');
+const { TypeError } = require('../errors');
 const ThreadChannel = require('../structures/ThreadChannel');
 
 /**
@@ -118,8 +119,34 @@ class ThreadManager extends CachedManager {
    * @param {boolean} [cache=true] Whether to cache the new thread objects if they aren't already
    * @returns {Promise<FetchedThreads>}
    */
-  fetchArchived(options = {}, cache = true) {
-    return this.fetchActive(cache, { archived: true, ...options });
+  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 });
+    }
   }
 
   /**
@@ -138,16 +165,22 @@ class ThreadManager extends CachedManager {
    * @param {FetchChannelThreadsOptions} [options] Options for self-bots where advanced users can specify further options
    * @returns {Promise<FetchedThreads>}
    */
-  async fetchActive(cache = true, options = {}) {
-    const raw = 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',
-      },
-    });
+  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 });
   }

package/src/managers/ThreadMemberManager.js

@@ -179,7 +179,7 @@ class ThreadMemberManager extends CachedManager {
     const id = this.resolveId(member);
     return id
       ? this._fetchOne(id, options)
-      : this._fetchMany(typeof member === 'boolean' ? { ...options, cache: member } : options);
+      : this._fetchMany(typeof member !== 'boolean' ? member : { ...options, cache: member });
   }
 }
 

package/src/managers/UserManager.js

@@ -56,15 +56,16 @@ class UserManager extends CachedManager {
       if (dmChannel && !dmChannel.partial) return dmChannel;
     }
 
-    const data = await this.client.api.users['@me'].channels.post({
+    const data = await this.client.api.users(this.client.user.id).channels.post({
       data: {
         recipients: [id],
       },
-      DiscordContext: {},
+      headers: {
+        'X-Context-Properties': 'e30=', // {}
+      },
     });
-
     const dm_channel = await this.client.channels._add(data, null, { cache });
-    dm_channel.sync();
+    await dm_channel.sync();
     return dm_channel;
   }
 
@@ -86,9 +87,10 @@ class UserManager extends CachedManager {
    * Obtains a user from Discord, or the user cache if it's already available.
    * @param {UserResolvable} user The user to fetch
    * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @param {?Snowflake} [options.guildId] The guild ID to fetch the member for
    * @returns {Promise<User>}
    */
-  async fetch(user, { cache = true, force = false } = {}) {
+  async fetch(user, { cache = true, force = false, guildId = null } = {}) {
     const id = this.resolveId(user);
     if (!force) {
       const existing = this.cache.get(id);
@@ -96,7 +98,9 @@ class UserManager extends CachedManager {
     }
 
     const data = await this.client.api.users(id).get();
-    return this._add(data, cache);
+    const userObject = this._add(data, cache);
+    await userObject.getProfile(guildId ?? null).catch(() => {});
+    return userObject;
   }
 
   /**

package/src/rest/APIRequest.js

@@ -1,14 +1,12 @@
 'use strict';
 
 const Buffer = require('node:buffer').Buffer;
-const http = require('node:http');
 const https = require('node:https');
 const { setTimeout } = require('node:timers');
 const makeFetchCookie = require('fetch-cookie');
 const FormData = require('form-data');
 const fetchOriginal = require('node-fetch');
 const { CookieJar } = require('tough-cookie');
-const { ciphers } = require('../util/Constants');
 
 const cookieJar = new CookieJar();
 const fetch = makeFetchCookie(fetchOriginal, cookieJar);
@@ -24,10 +22,6 @@ class APIRequest {
     this.options = options;
     this.retries = 0;
 
-    this.fullUserAgent = this.client.options.http.headers['User-Agent'];
-
-    this.client.options.ws.properties.browser_user_agent = this.fullUserAgent;
-
     let queryString = '';
     if (options.query) {
       const query = Object.entries(options.query)
@@ -38,22 +32,16 @@ class APIRequest {
     this.path = `${path}${queryString && `?${queryString}`}`;
   }
 
-  make(captchaKey, captchaRqToken) {
-    if (!agent) {
-      if (this.client.options.http.agent instanceof http.Agent) {
-        this.client.options.http.agent.options.keepAlive = true;
-        this.client.options.http.agent.options.honorCipherOrder = true;
-        this.client.options.http.agent.options.minVersion = 'TLSv1.2';
-        this.client.options.http.agent.options.ciphers = ciphers.join(':');
+  make(captchaKey = undefined, captchaRqtoken = undefined) {
+    if (agent === null) {
+      if (typeof this.client.options.proxy === 'string' && this.client.options.proxy.length > 0) {
+        const proxy = require('proxy-agent');
+        agent = new proxy(this.client.options.proxy);
+      } else if (this.client.options.http.agent instanceof https.Agent) {
         agent = this.client.options.http.agent;
+        agent.keepAlive = true;
       } else {
-        agent = new https.Agent({
-          ...this.client.options.http.agent,
-          keepAlive: true,
-          honorCipherOrder: true,
-          minVersion: 'TLSv1.2',
-          ciphers: ciphers.join(':'),
-        });
+        agent = new https.Agent({ ...this.client.options.http.agent, keepAlive: true });
       }
     }
 
@@ -64,10 +52,10 @@ class APIRequest {
     const url = API + this.path;
 
     let headers = {
-      authority: 'discord.com',
+      ...this.client.options.http.headers,
       accept: '*/*',
       'accept-language': 'en-US',
-      'sec-ch-ua': '"Not?A_Brand";v="8", "Chromium";v="108"',
+      'sec-ch-ua': `"Not?A_Brand";v="8", "Chromium";v="108"`,
       'sec-ch-ua-mobile': '?0',
       'sec-ch-ua-platform': '"Windows"',
       'sec-fetch-dest': 'empty',
@@ -76,20 +64,18 @@ class APIRequest {
       'x-debug-options': 'bugReporterEnabled',
       'x-discord-locale': 'en-US',
       'x-discord-timezone': 'Asia/Saigon',
-      'x-super-properties': `${Buffer.from(JSON.stringify(this.client.options.ws.properties), 'ascii').toString(
-        'base64',
-      )}`,
+      'x-super-properties': `${Buffer.from(
+        this.client.options.jsonTransformer(this.client.options.ws.properties),
+        'ascii',
+      ).toString('base64')}`,
       Referer: 'https://discord.com/channels/@me',
       origin: 'https://discord.com',
       'Referrer-Policy': 'strict-origin-when-cross-origin',
-      ...this.client.options.http.headers,
-      'User-Agent': this.fullUserAgent,
     };
 
     if (this.options.auth !== false) headers.Authorization = this.rest.getAuth();
     if (this.options.reason) headers['X-Audit-Log-Reason'] = encodeURIComponent(this.options.reason);
     if (this.options.headers) headers = Object.assign(headers, this.options.headers);
-
     // Delete all headers if undefined
     for (const [key, value] of Object.entries(headers)) {
       if (value === undefined) delete headers[key];
@@ -99,15 +85,9 @@ class APIRequest {
         'User-Agent': this.client.options.http.headers['User-Agent'],
       };
     }
-
-    // Some options
-    if (this.options.DiscordContext) {
-      headers['X-Context-Properties'] = Buffer.from(JSON.stringify(this.options.DiscordContext), 'utf8').toString(
-        'base64',
-      );
-    }
-    if (this.options.mfaToken) {
-      headers['X-Discord-Mfa-Authorization'] = this.options.mfaToken;
+    if (captchaKey && typeof captchaKey == 'string') {
+      headers['x-captcha-key'] = captchaKey;
+      if (captchaRqtoken) headers['x-captcha-rqtoken'] = captchaRqtoken;
     }
 
     let body;
@@ -126,21 +106,19 @@ class APIRequest {
       headers = Object.assign(headers, body.getHeaders());
       // eslint-disable-next-line eqeqeq
     } else if (this.options.data != null) {
-      if (this.options.usePayloadJSON) {
+      if (this.options.useFormDataPayloadJSON) {
         body = new FormData();
         body.append('payload_json', JSON.stringify(this.options.data));
+        headers = Object.assign(headers, body.getHeaders());
       } else {
         body = JSON.stringify(this.options.data);
         headers['Content-Type'] = 'application/json';
       }
     }
 
-    // Captcha
-    if (captchaKey && typeof captchaKey == 'string') headers['X-Captcha-Key'] = captchaKey;
-    if (captchaRqToken && typeof captchaRqToken == 'string') headers['X-Captcha-Rqtoken'] = captchaRqToken;
-
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.client.options.restRequestTimeout).unref();
+
     return fetch(url, {
       method: this.method,
       headers,