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

package/src/structures/Channel.js

@@ -0,0 +1,271 @@
+'use strict';
+
+const process = require('node:process');
+const Base = require('./Base');
+let CategoryChannel;
+let DMChannel;
+let NewsChannel;
+let StageChannel;
+let StoreChannel;
+let TextChannel;
+let ThreadChannel;
+let VoiceChannel;
+let DirectoryChannel;
+let ForumChannel;
+const ChannelFlags = require('../util/ChannelFlags');
+const { ChannelTypes, ThreadChannelTypes, VoiceBasedChannelTypes } = require('../util/Constants');
+const SnowflakeUtil = require('../util/SnowflakeUtil');
+
+/**
+ * @type {WeakSet<Channel>}
+ * @private
+ * @internal
+ */
+const deletedChannels = new WeakSet();
+let deprecationEmittedForDeleted = false;
+
+/**
+ * Represents any channel on Discord.
+ * @extends {Base}
+ * @abstract
+ */
+class Channel extends Base {
+  constructor(client, data, immediatePatch = true) {
+    super(client);
+
+    const type = ChannelTypes[data?.type];
+    /**
+     * The type of the channel
+     * @type {ChannelType}
+     */
+    this.type = type ?? 'UNKNOWN';
+
+    if (data && immediatePatch) this._patch(data);
+  }
+
+  _patch(data) {
+    /**
+     * The channel's id
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+
+    if ('flags' in data) {
+      /**
+       * The flags that are applied to the channel.
+       * <info>This is only `null` in a {@link PartialGroupDMChannel}. In all other cases, it is not `null`.</info>
+       * @type {?Readonly<ChannelFlags>}
+       */
+      this.flags = new ChannelFlags(data.flags).freeze();
+    } else {
+      this.flags ??= new ChannelFlags().freeze();
+    }
+  }
+
+  /**
+   * The timestamp the channel was created at
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return SnowflakeUtil.timestampFrom(this.id);
+  }
+
+  /**
+   * The time the channel was created at
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * Whether or not the structure has been deleted
+   * @type {boolean}
+   * @deprecated This will be removed in the next major version, see https://github.com/discordjs/discord.js/issues/7091
+   */
+  get deleted() {
+    if (!deprecationEmittedForDeleted) {
+      deprecationEmittedForDeleted = true;
+      process.emitWarning(
+        'Channel#deleted is deprecated, see https://github.com/discordjs/discord.js/issues/7091.',
+        'DeprecationWarning',
+      );
+    }
+
+    return deletedChannels.has(this);
+  }
+
+  set deleted(value) {
+    if (!deprecationEmittedForDeleted) {
+      deprecationEmittedForDeleted = true;
+      process.emitWarning(
+        'Channel#deleted is deprecated, see https://github.com/discordjs/discord.js/issues/7091.',
+        'DeprecationWarning',
+      );
+    }
+
+    if (value) deletedChannels.add(this);
+    else deletedChannels.delete(this);
+  }
+
+  /**
+   * Whether this Channel is a partial
+   * <info>This is always false outside of DM channels.</info>
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return false;
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the channel's mention instead of the Channel object.
+   * @returns {string}
+   * @example
+   * // Logs: Hello from <#123456789012345678>!
+   * console.log(`Hello from ${channel}!`);
+   */
+  toString() {
+    return `<#${this.id}>`;
+  }
+
+  /**
+   * Deletes this channel.
+   * @returns {Promise<Channel>}
+   * @example
+   * // Delete the channel
+   * channel.delete()
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async delete() {
+    await this.client.api.channels(this.id).delete();
+    return this;
+  }
+
+  /**
+   * Fetches this channel.
+   * @param {boolean} [force=true] Whether to skip the cache check and request the API
+   * @returns {Promise<Channel>}
+   */
+  fetch(force = true) {
+    return this.client.channels.fetch(this.id, { force });
+  }
+
+  /**
+   * Indicates whether this channel is {@link TextBasedChannels text-based}.
+   * @returns {boolean}
+   */
+  isText() {
+    return 'messages' in this;
+  }
+
+  /**
+   * Indicates whether this channel is {@link BaseGuildVoiceChannel voice-based}.
+   * @returns {boolean}
+   */
+  isVoice() {
+    return VoiceBasedChannelTypes.includes(this.type);
+  }
+
+  /**
+   * Indicates whether this channel is a {@link ThreadChannel}.
+   * @returns {boolean}
+   */
+  isThread() {
+    return ThreadChannelTypes.includes(this.type);
+  }
+
+  /**
+   * Indicates whether this channel is a {@link DirectoryChannel}
+   * @returns {boolean}
+   */
+  isDirectory() {
+    return this.type === 'GUILD_DIRECTORY';
+  }
+
+  static create(client, data, guild, { allowUnknownGuild } = {}) {
+    CategoryChannel ??= require('./CategoryChannel');
+    DMChannel ??= require('./DMChannel');
+    NewsChannel ??= require('./NewsChannel');
+    StageChannel ??= require('./StageChannel');
+    StoreChannel ??= require('./StoreChannel');
+    TextChannel ??= require('./TextChannel');
+    ThreadChannel ??= require('./ThreadChannel');
+    VoiceChannel ??= require('./VoiceChannel');
+    DirectoryChannel ??= require('./DirectoryChannel');
+    ForumChannel ??= require('./ForumChannel');
+
+    let channel;
+    if (!data.guild_id && !guild) {
+      if ((data.recipients && data.type !== ChannelTypes.GROUP_DM) || data.type === ChannelTypes.DM) {
+        channel = new DMChannel(client, data);
+      } else if (data.type === ChannelTypes.GROUP_DM) {
+        const PartialGroupDMChannel = require('./PartialGroupDMChannel');
+        channel = new PartialGroupDMChannel(client, data);
+      }
+    } else {
+      guild ??= client.guilds.cache.get(data.guild_id);
+
+      if (guild || allowUnknownGuild) {
+        switch (data.type) {
+          case ChannelTypes.GUILD_TEXT: {
+            channel = new TextChannel(guild, data, client);
+            break;
+          }
+          case ChannelTypes.GUILD_VOICE: {
+            channel = new VoiceChannel(guild, data, client);
+            break;
+          }
+          case ChannelTypes.GUILD_CATEGORY: {
+            channel = new CategoryChannel(guild, data, client);
+            break;
+          }
+          case ChannelTypes.GUILD_NEWS: {
+            channel = new NewsChannel(guild, data, client);
+            break;
+          }
+          case ChannelTypes.GUILD_STORE: {
+            channel = new StoreChannel(guild, data, client);
+            break;
+          }
+          case ChannelTypes.GUILD_STAGE_VOICE: {
+            channel = new StageChannel(guild, data, client);
+            break;
+          }
+          case ChannelTypes.GUILD_NEWS_THREAD:
+          case ChannelTypes.GUILD_PUBLIC_THREAD:
+          case ChannelTypes.GUILD_PRIVATE_THREAD: {
+            channel = new ThreadChannel(guild, data, client);
+            if (!allowUnknownGuild) channel.parent?.threads.cache.set(channel.id, channel);
+            break;
+          }
+
+          case ChannelTypes.GUILD_DIRECTORY:
+            channel = new DirectoryChannel(client, data);
+            break;
+
+          case ChannelTypes.GUILD_FORUM:
+            channel = new ForumChannel(guild, data, client);
+            break;
+        }
+        if (channel && !allowUnknownGuild) guild.channels?.cache.set(channel.id, channel);
+      }
+    }
+    return channel;
+  }
+
+  toJSON(...props) {
+    return super.toJSON({ createdTimestamp: true }, ...props);
+  }
+}
+
+exports.Channel = Channel;
+exports.deletedChannels = deletedChannels;
+
+/**
+ * @external APIChannel
+ * @see {@link https://discord.com/developers/docs/resources/channel#channel-object}
+ */

package/src/structures/ClientApplication.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { ApplicationRoleConnectionMetadata } = require('./ApplicationRoleConnectionMetadata');
+const Team = require('./Team');
+const Application = require('./interfaces/Application');
+const ApplicationCommandManager = require('../managers/ApplicationCommandManager');
+const ApplicationFlags = require('../util/ApplicationFlags');
+const { ApplicationRoleConnectionMetadataTypes } = require('../util/Constants');
+const Permissions = require('../util/Permissions');
+
+/**
+ * @typedef {Object} ClientApplicationInstallParams
+ * @property {InviteScope[]} scopes The scopes to add the application to the server with
+ * @property {Readonly<Permissions>} permissions The permissions this bot will request upon joining
+ */
+
+/**
+ * Represents a Client OAuth2 Application.
+ * @extends {Application}
+ */
+class ClientApplication extends Application {
+  constructor(client, data, user) {
+    super(client, data);
+
+    /**
+     * The application command manager for this application
+     * @type {ApplicationCommandManager}
+     */
+    this.commands = new ApplicationCommandManager(this.client, undefined, user);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    /**
+     * The tags this application has (max of 5)
+     * @type {string[]}
+     */
+    this.tags = data.tags ?? [];
+
+    if ('install_params' in data) {
+      /**
+       * Settings for this application's default in-app authorization
+       * @type {?ClientApplicationInstallParams}
+       */
+      this.installParams = {
+        scopes: data.install_params.scopes,
+        permissions: new Permissions(data.install_params.permissions).freeze(),
+      };
+    } else {
+      this.installParams ??= null;
+    }
+
+    if ('custom_install_url' in data) {
+      /**
+       * This application's custom installation URL
+       * @type {?string}
+       */
+      this.customInstallURL = data.custom_install_url;
+    } else {
+      this.customInstallURL = null;
+    }
+
+    if ('flags' in data) {
+      /**
+       * The flags this application has
+       * @type {ApplicationFlags}
+       */
+      this.flags = new ApplicationFlags(data.flags).freeze();
+    }
+
+    if ('cover_image' in data) {
+      /**
+       * The hash of the application's cover image
+       * @type {?string}
+       */
+      this.cover = data.cover_image;
+    } else {
+      this.cover ??= null;
+    }
+
+    if ('rpc_origins' in data) {
+      /**
+       * The application's RPC origins, if enabled
+       * @type {string[]}
+       */
+      this.rpcOrigins = data.rpc_origins;
+    } else {
+      this.rpcOrigins ??= [];
+    }
+
+    if ('bot_require_code_grant' in data) {
+      /**
+       * If this application's bot requires a code grant when using the OAuth2 flow
+       * @type {?boolean}
+       */
+      this.botRequireCodeGrant = data.bot_require_code_grant;
+    } else {
+      this.botRequireCodeGrant ??= null;
+    }
+
+    if ('bot_public' in data) {
+      /**
+       * If this application's bot is public
+       * @type {?boolean}
+       */
+      this.botPublic = data.bot_public;
+    } else {
+      this.botPublic ??= null;
+    }
+
+    if ('popular_application_command_ids' in data) {
+      /**
+       * List of popular command
+       * @type {?Collection<Snowflake, ApplicationCommand>}
+       */
+      this.popularCommands = new Collection();
+      data.popular_application_command_ids.forEach(id => {
+        this.popularCommands.set(id, this.commands?.cache?.get(id));
+      });
+    }
+
+    /**
+     * The owner of this OAuth application
+     * @type {?(User|Team)}
+     */
+    this.owner = data.team
+      ? new Team(this.client, data.team)
+      : data.owner
+      ? this.client.users._add(data.owner)
+      : this.owner ?? null;
+  }
+
+  /**
+   * Whether this application is partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return !this.name;
+  }
+
+  /**
+   * Obtains this application from Discord.
+   * @returns {Promise<ClientApplication>}
+   */
+  async fetch() {
+    const app = await this.client.api.oauth2.authorize.get({
+      query: {
+        client_id: this.id,
+        scope: 'bot applications.commands',
+      },
+    });
+    const user = this.client.users._add(app.bot);
+    user._partial = false;
+    this._patch(app.application);
+    return this;
+  }
+
+  /**
+   * Gets this application's role connection metadata records
+   * @returns {Promise<ApplicationRoleConnectionMetadata[]>}
+   */
+  async fetchRoleConnectionMetadataRecords() {
+    const metadata = await this.client.api.applications(this.id)('role-connections').metadata.get();
+    return metadata.map(data => new ApplicationRoleConnectionMetadata(data));
+  }
+
+  /**
+   * Data for creating or editing an application role connection metadata.
+   * @typedef {Object} ApplicationRoleConnectionMetadataEditOptions
+   * @property {string} name The name of the metadata field
+   * @property {?Object<Locale, string>} [nameLocalizations] The name localizations for the metadata field
+   * @property {string} description The description of the metadata field
+   * @property {?Object<Locale, string>} [descriptionLocalizations] The description localizations for the metadata field
+   * @property {string} key The dictionary key of the metadata field
+   * @property {ApplicationRoleConnectionMetadataType} type The type of the metadata field
+   */
+
+  /**
+   * Updates this application's role connection metadata records
+   * @param {ApplicationRoleConnectionMetadataEditOptions[]} records The new role connection metadata records
+   * @returns {Promise<ApplicationRoleConnectionMetadata[]>}
+   */
+  async editRoleConnectionMetadataRecords(records) {
+    const newRecords = await this.client.api
+      .applications(this.client.user.id)('role-connections')
+      .metadata.put({
+        data: records.map(record => ({
+          type: typeof record.type === 'string' ? ApplicationRoleConnectionMetadataTypes[record.type] : record.type,
+          key: record.key,
+          name: record.name,
+          name_localizations: record.nameLocalizations,
+          description: record.description,
+          description_localizations: record.descriptionLocalizations,
+        })),
+      });
+
+    return newRecords.map(data => new ApplicationRoleConnectionMetadata(data));
+  }
+}
+
+module.exports = ClientApplication;

package/src/structures/ClientPresence.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { Presence } = require('./Presence');
+const { TypeError } = require('../errors');
+const { Opcodes, ActivityTypes } = require('../util/Constants');
+
+/**
+ * Represents the client's presence.
+ * @extends {Presence}
+ */
+class ClientPresence extends Presence {
+  constructor(client, data = {}) {
+    super(client, Object.assign(data, { status: data.status ?? 'online', user: { id: null } }));
+  }
+
+  /**
+   * Sets the client's presence
+   * @param {PresenceData} presence The data to set the presence to
+   * @returns {ClientPresence}
+   */
+  set(presence) {
+    const packet = this._parse(presence);
+    // Parse with custom class
+    this._patch(packet, true);
+    if (typeof presence.shardId === 'undefined') {
+      this.client.ws.broadcast({ op: Opcodes.STATUS_UPDATE, d: packet });
+    } else if (Array.isArray(presence.shardId)) {
+      for (const shardId of presence.shardId) {
+        this.client.ws.shards.get(shardId).send({ op: Opcodes.STATUS_UPDATE, d: packet });
+      }
+    } else {
+      this.client.ws.shards.get(presence.shardId).send({ op: Opcodes.STATUS_UPDATE, d: packet });
+    }
+    // Parse with default class
+    // this._patch(packet, false);
+    return this;
+  }
+
+  /**
+   * Parses presence data into a packet ready to be sent to Discord
+   * @param {PresenceData} presence The data to parse
+   * @returns {APIPresence}
+   * @private
+   */
+  _parse({ status, since, afk, activities }) {
+    const data = {
+      activities: [],
+      afk: typeof afk === 'boolean' ? afk : false,
+      since: 0,
+      status: status ?? this.status,
+    };
+    if (activities?.length) {
+      for (const [i, activity] of activities.entries()) {
+        if (![ActivityTypes.CUSTOM, 'CUSTOM'].includes(activity.type) && typeof activity.name !== 'string') {
+          throw new TypeError('INVALID_TYPE', `activities[${i}].name`, 'string');
+        }
+        activity.type ??= 0;
+        data.activities.push(
+          Object.assign(activity, {
+            type: typeof activity.type === 'number' ? activity.type : ActivityTypes[activity.type],
+          }),
+        );
+      }
+    } else if (!activities && (status || afk || since) && this.activities.length) {
+      data.activities.push(
+        ...this.activities.map(a =>
+          Object.assign(a, {
+            type: typeof a.type === 'number' ? a.type : ActivityTypes[a.type],
+          }),
+        ),
+      );
+    }
+
+    return data;
+  }
+}
+
+module.exports = ClientPresence;
+
+/* eslint-disable max-len */
+/**
+ * @external APIPresence
+ * @see {@link https://discord.com/developers/docs/rich-presence/how-to#updating-presence-update-presence-payload-fields}
+ */