discord.js-seflbot-v13 1.1.0

package/src/managers/UserManager.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const { Error } = require('../errors');
+const { GuildMember } = require('../structures/GuildMember');
+const { Message } = require('../structures/Message');
+const ThreadMember = require('../structures/ThreadMember');
+const User = require('../structures/User');
+
+/**
+ * Manages API methods for users and stores their cache.
+ * @extends {CachedManager}
+ */
+class UserManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, User, iterable);
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, User>}
+   * @name UserManager#cache
+   */
+
+  /**
+   * Data that resolves to give a User object. This can be:
+   * * A User object
+   * * A Snowflake
+   * * A Message object (resolves to the message author)
+   * * A GuildMember object
+   * * A ThreadMember object
+   * @typedef {User|Snowflake|Message|GuildMember|ThreadMember} UserResolvable
+   */
+
+  /**
+   * The DM between the client's user and a user
+   * @param {Snowflake} userId The user id
+   * @returns {?DMChannel}
+   * @private
+   */
+  dmChannel(userId) {
+    return this.client.channels.cache.find(c => c.type === 'DM' && c.recipient.id === userId) ?? null;
+  }
+
+  /**
+   * Creates a {@link DMChannel} between the client and a user.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<DMChannel>}
+   */
+  async createDM(user, { cache = true, force = false } = {}) {
+    const id = this.resolveId(user);
+
+    if (!force) {
+      const dmChannel = this.dmChannel(id);
+      if (dmChannel && !dmChannel.partial) return dmChannel;
+    }
+
+    const data = await this.client.api.users(this.client.user.id).channels.post({
+      data: {
+        recipients: [id],
+      },
+      headers: {
+        'X-Context-Properties': 'e30=', // {}
+      },
+    });
+    const dm_channel = await this.client.channels._add(data, null, { cache });
+    await dm_channel.sync();
+    return dm_channel;
+  }
+
+  /**
+   * Deletes a {@link DMChannel} (if one exists) between the client and a user. Resolves with the channel if successful.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {Promise<DMChannel>}
+   */
+  async deleteDM(user) {
+    const id = this.resolveId(user);
+    const dmChannel = this.dmChannel(id);
+    if (!dmChannel) throw new Error('USER_NO_DM_CHANNEL');
+    await this.client.api.channels(dmChannel.id).delete();
+    this.client.channels._remove(dmChannel.id);
+    return dmChannel;
+  }
+
+  /**
+   * 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, guildId = null } = {}) {
+    const id = this.resolveId(user);
+    if (!force) {
+      const existing = this.cache.get(id);
+      if (existing && !existing.partial) return existing;
+    }
+
+    const data = await this.client.api.users(id).get();
+    const userObject = this._add(data, cache);
+    await userObject.getProfile(guildId ?? null).catch(() => {});
+    return userObject;
+  }
+
+  /**
+   * Fetches a user's flags.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<UserFlags>}
+   */
+  async fetchFlags(user, options) {
+    return (await this.fetch(user, options)).flags;
+  }
+
+  /**
+   * Sends a message to a user.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @param {string|MessagePayload|MessageOptions} options The options to provide
+   * @returns {Promise<Message>}
+   */
+  async send(user, options) {
+    return (await this.createDM(user)).send(options);
+  }
+
+  /**
+   * Resolves a {@link UserResolvable} to a {@link User} object.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {?User}
+   */
+  resolve(user) {
+    if (user instanceof GuildMember || user instanceof ThreadMember) return user.user;
+    if (user instanceof Message) return user.author;
+    return super.resolve(user);
+  }
+
+  /**
+   * Resolves a {@link UserResolvable} to a {@link User} id.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {?Snowflake}
+   */
+  resolveId(user) {
+    if (user instanceof ThreadMember) return user.id;
+    if (user instanceof GuildMember) return user.user.id;
+    if (user instanceof Message) return user.author.id;
+    return super.resolveId(user);
+  }
+}
+
+module.exports = UserManager;

package/src/managers/VoiceStateManager.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const VoiceState = require('../structures/VoiceState');
+
+/**
+ * Manages API methods for VoiceStates and stores their cache.
+ * @extends {CachedManager}
+ */
+class VoiceStateManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, VoiceState, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, VoiceState>}
+   * @name VoiceStateManager#cache
+   */
+
+  _add(data, cache = true) {
+    const existing = this.cache.get(data.user_id);
+    if (existing) return existing._patch(data);
+
+    const entry = new this.holds(this.guild, data);
+    if (cache) this.cache.set(data.user_id, entry);
+    return entry;
+  }
+}
+
+module.exports = VoiceStateManager;

package/src/rest/APIRequest.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const Buffer = require('node:buffer').Buffer;
+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 cookieJar = new CookieJar();
+const fetch = makeFetchCookie(fetchOriginal, cookieJar);
+
+let agent = null;
+
+class APIRequest {
+  constructor(rest, method, path, options) {
+    this.rest = rest;
+    this.client = rest.client;
+    this.method = method;
+    this.route = options.route;
+    this.options = options;
+    this.retries = 0;
+
+    let queryString = '';
+    if (options.query) {
+      const query = Object.entries(options.query)
+        .filter(([, value]) => value !== null && typeof value !== 'undefined')
+        .flatMap(([key, value]) => (Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]));
+      queryString = new URLSearchParams(query).toString();
+    }
+    this.path = `${path}${queryString && `?${queryString}`}`;
+  }
+
+  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.ProxyAgent(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 });
+      }
+    }
+
+    const API =
+      this.options.versioned === false
+        ? this.client.options.http.api
+        : `${this.client.options.http.api}/v${this.client.options.http.version}`;
+    const url = API + this.path;
+
+    let headers = {
+      ...this.client.options.http.headers,
+      authority: 'discord.com',
+      accept: '*/*',
+      'accept-language': 'en-US',
+      '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',
+      'sec-fetch-mode': 'cors',
+      'sec-fetch-site': 'same-origin',
+      'x-debug-options': 'bugReporterEnabled',
+      'x-discord-locale': 'en-US',
+      'x-discord-timezone': 'Asia/Saigon',
+      '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',
+    };
+
+    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];
+    }
+    if (this.options.webhook === true) {
+      headers = {
+        'User-Agent': this.client.options.http.headers['User-Agent'],
+      };
+    }
+    if (captchaKey && typeof captchaKey == 'string') {
+      headers['x-captcha-key'] = captchaKey;
+      if (captchaRqtoken) headers['x-captcha-rqtoken'] = captchaRqtoken;
+    }
+
+    let body;
+    if (this.options.files?.length) {
+      body = new FormData();
+      for (const [index, file] of this.options.files.entries()) {
+        if (file?.file) body.append(file.key ?? `files[${index}]`, file.file, file.name);
+      }
+      if (typeof this.options.data !== 'undefined') {
+        if (this.options.dontUsePayloadJSON) {
+          for (const [key, value] of Object.entries(this.options.data)) body.append(key, value);
+        } else {
+          body.append('payload_json', JSON.stringify(this.options.data));
+        }
+      }
+      headers = Object.assign(headers, body.getHeaders());
+      // eslint-disable-next-line eqeqeq
+    } else if (this.options.data != null) {
+      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';
+      }
+    }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.client.options.restRequestTimeout).unref();
+
+    return fetch(url, {
+      method: this.method,
+      headers,
+      agent,
+      body,
+      signal: controller.signal,
+    }).finally(() => clearTimeout(timeout));
+  }
+}
+
+module.exports = APIRequest;

package/src/rest/APIRouter.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const noop = () => {}; // eslint-disable-line no-empty-function
+const methods = ['get', 'post', 'delete', 'patch', 'put'];
+const reflectors = [
+  'toString',
+  'valueOf',
+  'inspect',
+  'constructor',
+  Symbol.toPrimitive,
+  Symbol.for('nodejs.util.inspect.custom'),
+];
+
+function buildRoute(manager) {
+  const route = [''];
+  const handler = {
+    get(target, name) {
+      if (reflectors.includes(name)) return () => route.join('/');
+      if (methods.includes(name)) {
+        const routeBucket = [];
+        for (let i = 0; i < route.length; i++) {
+          // Reactions routes and sub-routes all share the same bucket
+          if (route[i - 1] === 'reactions') break;
+          // Literal ids should only be taken account if they are the Major id (the Channel/Guild id)
+          if (/\d{16,19}/g.test(route[i]) && !/channels|guilds/.test(route[i - 1])) routeBucket.push(':id');
+          // All other parts of the route should be considered as part of the bucket identifier
+          else routeBucket.push(route[i]);
+        }
+        return options =>
+          manager.request(
+            name,
+            route.join('/'),
+            Object.assign(
+              {
+                versioned: manager.versioned,
+                route: routeBucket.join('/'),
+              },
+              options,
+            ),
+          );
+      }
+      route.push(name);
+      return new Proxy(noop, handler);
+    },
+    apply(target, _, args) {
+      route.push(...args.filter(x => x != null)); // eslint-disable-line eqeqeq
+      return new Proxy(noop, handler);
+    },
+  };
+  return new Proxy(noop, handler);
+}
+
+module.exports = buildRoute;

package/src/rest/CaptchaSolver.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const proxyParser = proxy => {
+  const protocolSplit = proxy.split('://');
+  const protocol = protocolSplit.length === 1 ? null : protocolSplit[0];
+  const rest = protocolSplit.length === 1 ? protocolSplit[0] : protocolSplit[1];
+  const authSplit = rest.split('@');
+  if (authSplit.length === 1) {
+    const host = authSplit[0].split(':')[0];
+    const port = Number(authSplit[0].split(':')[1]);
+    const proxyConfig = {
+      host,
+      port,
+    };
+    if (protocol != null) {
+      proxyConfig.protocol = protocol;
+    }
+    return proxyConfig;
+  }
+  const host = authSplit[1].split(':')[0];
+  const port = Number(authSplit[1].split(':')[1]);
+  const [username, password] = authSplit[0].split(':');
+  const proxyConfig = {
+    host,
+    port,
+    auth: {
+      username,
+      password,
+    },
+  };
+  if (protocol != null) {
+    proxyConfig.protocol = protocol;
+  }
+  return proxyConfig;
+};
+
+module.exports = class CaptchaSolver {
+  constructor(service, key, defaultCaptchaSolver, proxyString = '') {
+    this.service = 'custom';
+    this.solver = undefined;
+    this.defaultCaptchaSolver = defaultCaptchaSolver;
+    this.key = null;
+    this.proxy = proxyString.length ? proxyParser(proxyString) : null;
+    this._setup(service, key);
+  }
+  _missingModule(name) {
+    return new Error(`${name} module not found, please install it with \`npm i ${name}\``);
+  }
+  _setup(service, key) {
+    switch (service) {
+      case '2captcha': {
+        if (!key || typeof key !== 'string') throw new Error('2captcha key is not provided');
+        try {
+          const lib = require('2captcha');
+          this.service = '2captcha';
+          this.key = key;
+          this.solver = new lib.Solver(key);
+          this.solve = (data, userAgent) =>
+            new Promise((resolve, reject) => {
+              const siteKey = data.captcha_sitekey;
+              let postD = {
+                invisible: 1,
+                userAgent,
+              };
+              if (this.proxy !== null) {
+                postD = {
+                  ...postD,
+                  proxytype: this.proxy.protocol?.toUpperCase(),
+                  proxy: `${'auth' in this.proxy ? `${this.proxy.auth.username}:${this.proxy.auth.password}@` : ''}${
+                    this.proxy.host
+                  }:${this.proxy.port}`,
+                };
+              }
+              if (data.captcha_rqdata) {
+                postD = {
+                  ...postD,
+                  data: data.captcha_rqdata,
+                };
+              }
+              this.solver
+                .hcaptcha(siteKey, 'discord.com', postD)
+                .then(res => {
+                  if (typeof res.data == 'string') {
+                    resolve(res.data);
+                  } else {
+                    reject(new Error('Unknown Response'));
+                  }
+                })
+                .catch(reject);
+            });
+          break;
+        } catch (e) {
+          throw this._missingModule('2captcha');
+        }
+      }
+      case 'capmonster': {
+        if (!key || typeof key !== 'string') throw new Error('Capmonster key is not provided');
+        try {
+          const { HCaptchaTask } = require('node-capmonster');
+          this.service = 'capmonster';
+          this.key = key;
+          const client = new HCaptchaTask(this.key);
+          this.solve = (captchaData, userAgent) =>
+            new Promise((resolve, reject) => {
+              if (userAgent) client.setUserAgent(userAgent);
+              if (this.proxy !== null) {
+                client.setGlobalProxy(
+                  this.proxy.protocol,
+                  this.proxy.host,
+                  this.proxy.port,
+                  'auth' in this.proxy ? this.proxy.auth.username : undefined,
+                  'auth' in this.proxy ? this.proxy.auth.password : undefined,
+                );
+              }
+              client
+                .createWithTask(
+                  client.task({
+                    websiteURL: 'https://discord.com/channels/@me',
+                    websiteKey: captchaData.captcha_sitekey,
+                    isInvisible: !!captchaData.captcha_rqdata,
+                    data: captchaData.captcha_rqdata,
+                  }),
+                )
+                .then(id => client.joinTaskResult(id))
+                .then(result => resolve(result.gRecaptchaResponse))
+                .catch(reject);
+            });
+        } catch (e) {
+          throw this._missingModule('node-capmonster');
+        }
+        break;
+      }
+      default: {
+        this.solve = this.defaultCaptchaSolver;
+      }
+    }
+  }
+  solve() {}
+};

package/src/rest/DiscordAPIError.js

@@ -0,0 +1,103 @@
+'use strict';
+
+/**
+ * Represents an error from the Discord API.
+ * @extends Error
+ */
+class DiscordAPIError extends Error {
+  constructor(error, status, request) {
+    super();
+    const flattened = this.constructor.flattenErrors(error.errors ?? error).join('\n');
+    this.name = 'DiscordAPIError';
+    this.message = error.message && flattened ? `${error.message}\n${flattened}` : error.message ?? flattened;
+
+    /**
+     * The HTTP method used for the request
+     * @type {string}
+     */
+    this.method = request.method;
+
+    /**
+     * The path of the request relative to the HTTP endpoint
+     * @type {string}
+     */
+    this.path = request.path;
+
+    /**
+     * HTTP error code returned by Discord
+     * @type {number | string}
+     */
+    this.code = error.code;
+
+    /**
+     * The HTTP status code
+     * @type {number}
+     */
+    this.httpStatus = status;
+
+    /**
+     * @typedef {Object} Captcha
+     * @property {Array<string>} captcha_key ['message']
+     * @property {string} captcha_sitekey Captcha sitekey (hcaptcha)
+     * @property {string} captcha_service hcaptcha
+     * @property {string} [captcha_rqdata]
+     * @property {string} [captcha_rqtoken]
+     */
+
+    /**
+     * Captcha response data if the request requires a captcha
+     * @type {Captcha | null}
+     */
+    this.captcha = error?.captcha_service ? error : null;
+
+    /**
+     * The data associated with the request that caused this error
+     * @type {HTTPErrorData}
+     */
+    this.requestData = {
+      json: request.options.data,
+      files: request.options.files ?? [],
+    };
+
+    /**
+     * The number of times this request has been retried
+     * @type {number}
+     */
+    this.retries = request.retries;
+  }
+
+  /**
+   * Flattens an errors object returned from the API into an array.
+   * @param {APIError} obj Discord errors object
+   * @param {string} [key] Used internally to determine key names of nested fields
+   * @returns {string[]}
+   * @private
+   */
+  static flattenErrors(obj, key = '') {
+    let messages = [];
+
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === 'message') continue;
+      const newKey = key ? (isNaN(k) ? `${key}.${k}` : `${key}[${k}]`) : k;
+
+      if (v._errors) {
+        messages.push(`${newKey}: ${v._errors.map(e => e.message).join(' ')}`);
+      } else if (v.code ?? v.message) {
+        messages.push(`${v.code ? `${v.code}: ` : ''}${v.message}`.trim());
+      } else if (typeof v === 'string') {
+        messages.push(v);
+      } else {
+        messages = messages.concat(this.flattenErrors(v, newKey));
+      }
+    }
+
+    return messages;
+  }
+}
+
+module.exports = DiscordAPIError;
+
+/**
+ * @external APIError
+ * @see {@link https://discord.com/developers/docs/reference#error-messages}
+ */

package/src/rest/HTTPError.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * Represents an HTTP error from a request.
+ * @extends Error
+ */
+class HTTPError extends Error {
+  constructor(message, name, code, request) {
+    super(message);
+
+    /**
+     * The name of the error
+     * @type {string}
+     */
+    this.name = name;
+
+    /**
+     * HTTP error code returned from the request
+     * @type {number}
+     */
+    this.code = code ?? 500;
+
+    /**
+     * The HTTP method used for the request
+     * @type {string}
+     */
+    this.method = request.method;
+
+    /**
+     * The path of the request relative to the HTTP endpoint
+     * @type {string}
+     */
+    this.path = request.path;
+
+    /**
+     * The HTTP data that was sent to Discord
+     * @typedef {Object} HTTPErrorData
+     * @property {*} json The JSON data that was sent
+     * @property {HTTPAttachmentData[]} files The files that were sent with this request, if any
+     */
+
+    /**
+     * The attachment data that is sent to Discord
+     * @typedef {Object} HTTPAttachmentData
+     * @property {string|Buffer|Stream} attachment The source of this attachment data
+     * @property {string} name The file name
+     * @property {Buffer|Stream} file The file buffer
+     */
+
+    /**
+     * The data associated with the request that caused this error
+     * @type {HTTPErrorData}
+     */
+    this.requestData = {
+      json: request.options.data,
+      files: request.options.files ?? [],
+      headers: request.options.headers,
+    };
+  }
+}
+
+module.exports = HTTPError;